@player-tools/json-language-service 0.2.2--canary.20.454

package/dist/index.cjs.js

@@ -0,0 +1,2519 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsoncParser = require('jsonc-parser');
+var tapableTs = require('tapable-ts');
+var vscodeLanguageserverTypes = require('vscode-languageserver-types');
+var vscodeLanguageserverTextdocument = require('vscode-languageserver-textdocument');
+var detectIndent = require('detect-indent');
+var timm = require('timm');
+var xlrSdk = require('@player-tools/xlr-sdk');
+var xlrUtils = require('@player-tools/xlr-utils');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var detectIndent__default = /*#__PURE__*/_interopDefaultLegacy(detectIndent);
+
+function isPropertyNode(node) {
+  return (node == null ? void 0 : node.type) === "property";
+}
+function isObjectNode(node) {
+  return (node == null ? void 0 : node.type) === "object";
+}
+function isKeyNode(node) {
+  return isPropertyNode(node == null ? void 0 : node.parent) && (node == null ? void 0 : node.parent.keyNode) === node;
+}
+function isValueNode(node) {
+  return isPropertyNode(node == null ? void 0 : node.parent) && (node == null ? void 0 : node.parent.valueNode) === node;
+}
+function isViewNode(node) {
+  return (node == null ? void 0 : node.type) === "view";
+}
+function isStateNode(node) {
+  return (node == null ? void 0 : node.type) === "state";
+}
+function isFlowNode(node) {
+  return (node == null ? void 0 : node.type) === "flow";
+}
+function isNavigationNode(node) {
+  return (node == null ? void 0 : node.type) === "navigation";
+}
+function getValForKey(node, key) {
+  var _a;
+  const prop = node.properties.find((k) => k.keyNode.value === key);
+  return (_a = prop == null ? void 0 : prop.valueNode) == null ? void 0 : _a.jsonNode.value;
+}
+function getPropForValNode(node) {
+  if (isValueNode(node) && isPropertyNode(node == null ? void 0 : node.parent)) {
+    return node == null ? void 0 : 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;
+}
+
+class ASTNodeImpl {
+  constructor(jsonNode, parent) {
+    this.jsonNode = jsonNode;
+    this.parent = parent;
+  }
+}
+class StringASTNodeImpl extends ASTNodeImpl {
+  constructor(jsonNode, parent) {
+    super(jsonNode, parent);
+    this.type = "string";
+    this.value = jsonNode.value;
+  }
+}
+class NumberASTNodeImpl extends ASTNodeImpl {
+  constructor(jsonNode, parent) {
+    super(jsonNode, parent);
+    this.type = "number";
+    this.value = jsonNode.value;
+  }
+}
+class BooleanASTNodeImpl extends ASTNodeImpl {
+  constructor(jsonNode, parent) {
+    super(jsonNode, parent);
+    this.type = "boolean";
+    this.value = jsonNode.value;
+  }
+}
+class NullASTNodeImpl extends ASTNodeImpl {
+  constructor() {
+    super(...arguments);
+    this.type = "null";
+    this.value = null;
+  }
+}
+class PropertyASTNodeImpl extends ASTNodeImpl {
+  constructor(jsonNode, parent, keyNode) {
+    super(jsonNode, parent);
+    this.type = "property";
+    this.keyNode = keyNode;
+  }
+  get children() {
+    return this.valueNode ? [this.keyNode, this.valueNode] : [this.keyNode];
+  }
+}
+class ViewASTNodeImpl extends ASTNodeImpl {
+  constructor() {
+    super(...arguments);
+    this.type = "view";
+    this.properties = [];
+    this.id = void 0;
+    this.viewType = void 0;
+  }
+  get children() {
+    return this.properties;
+  }
+}
+class ContentASTNodeImpl extends ASTNodeImpl {
+  constructor() {
+    super(...arguments);
+    this.type = "content";
+    this.properties = [];
+    this.views = void 0;
+    this.navigation = void 0;
+  }
+  get children() {
+    return this.properties;
+  }
+}
+class NavigationASTNodeImpl extends ASTNodeImpl {
+  constructor() {
+    super(...arguments);
+    this.type = "navigation";
+    this.properties = [];
+    this.begin = void 0;
+    this.flows = [];
+  }
+  get children() {
+    return this.properties;
+  }
+}
+class FlowASTNodeImpl extends ASTNodeImpl {
+  constructor() {
+    super(...arguments);
+    this.type = "flow";
+    this.properties = [];
+    this.start = void 0;
+    this.states = [];
+  }
+  get children() {
+    return this.properties;
+  }
+}
+class FlowStateASTNodeImpl extends ASTNodeImpl {
+  constructor() {
+    super(...arguments);
+    this.type = "state";
+    this.properties = [];
+    this.stateType = void 0;
+  }
+  get children() {
+    return this.properties;
+  }
+}
+class AssetASTNodeImpl extends ASTNodeImpl {
+  constructor() {
+    super(...arguments);
+    this.type = "asset";
+    this.properties = [];
+    this.id = void 0;
+    this.assetType = void 0;
+  }
+  get children() {
+    return this.properties;
+  }
+}
+class ArrayASTNodeImpl extends ASTNodeImpl {
+  constructor() {
+    super(...arguments);
+    this.type = "array";
+    this.items = [];
+  }
+  get children() {
+    return this.items;
+  }
+}
+class ObjectASTNodeImpl extends ASTNodeImpl {
+  constructor() {
+    super(...arguments);
+    this.type = "object";
+    this.properties = [];
+  }
+  get children() {
+    return this.properties;
+  }
+}
+
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function prettyPrintParseErrorCode(code) {
+  switch (code) {
+    case 6:
+      return `Expected comma`;
+    case 5:
+      return `Expected colon`;
+    case 3:
+      return `Expected property name`;
+    case 4:
+      return `Expected value`;
+    case 7:
+      return `Expected }`;
+    case 9:
+      return `Expected end of file`;
+    case 8:
+      return `Expected ]`;
+    case 12:
+      return `Expected "`;
+    default:
+      return jsoncParser.printParseErrorCode(code);
+  }
+}
+function convertErrorsToDiags(document, errors) {
+  return errors.map((parseError) => {
+    return vscodeLanguageserverTypes.Diagnostic.create(vscodeLanguageserverTypes.Range.create(document.positionAt(parseError.offset), document.positionAt(parseError.offset + parseError.length)), prettyPrintParseErrorCode(parseError.error), vscodeLanguageserverTypes.DiagnosticSeverity.Error);
+  });
+}
+
+function isStringProperty(node) {
+  var _a;
+  return ((_a = node.valueNode) == null ? void 0 : _a.type) === "string";
+}
+class PlayerContent {
+  constructor(root, errors, jsonToNodeMap) {
+    this.root = root;
+    this.jsonNodeToNode = jsonToNodeMap;
+    this.syntaxErrors = errors;
+  }
+  getNodeFromOffset(offset) {
+    const jsonNode = jsoncParser.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);
+    }
+  }
+}
+exports.ObjType = void 0;
+(function(ObjType2) {
+  ObjType2[ObjType2["FLOW"] = 0] = "FLOW";
+  ObjType2[ObjType2["ASSET"] = 1] = "ASSET";
+  ObjType2[ObjType2["ASSET_WRAPPER"] = 2] = "ASSET_WRAPPER";
+  ObjType2[ObjType2["UNKNOWN"] = 3] = "UNKNOWN";
+})(exports.ObjType || (exports.ObjType = {}));
+function identify(node) {
+  var _a;
+  if (node === void 0 || node.type !== "object") {
+    return 3;
+  }
+  const knownProps = (_a = node.children) == null ? void 0 : _a.reduce((props, childNode) => {
+    if (childNode.type === "property" && childNode.children) {
+      const [key] = childNode.children;
+      props.add(key.value);
+    }
+    return props;
+  }, new Set());
+  if (knownProps == null ? void 0 : knownProps.has("type")) {
+    return 1;
+  }
+  return 0;
+}
+function parse(document) {
+  const errors = [];
+  const jsonToNode = new Map();
+  const root = jsoncParser.parseTree(document.getText(), errors, {
+    disallowComments: true
+  });
+  const diags = convertErrorsToDiags(document, errors);
+  function parseAsset(node, parent) {
+    var _a;
+    const assetNode = new AssetASTNodeImpl(node, parent);
+    (_a = node.children) == null ? void 0 : _a.forEach((prop) => {
+      var _a2;
+      if (prop.type === "property" && ((_a2 = prop.children) == null ? void 0 : _a2.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) {
+    var _a, _b;
+    switch (node == null ? void 0 : 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);
+        (_a = node.children) == null ? void 0 : _a.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);
+        (_b = node.children) == null ? void 0 : _b.forEach((prop) => {
+          var _a2;
+          if (prop.type === "property" && ((_a2 = prop.children) == null ? void 0 : _a2.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;
+      }
+    }
+  }
+  function parseView(node, parent) {
+    var _a;
+    const viewNode = new ViewASTNodeImpl(node, parent);
+    (_a = node.children) == null ? void 0 : _a.forEach((prop) => {
+      var _a2, _b, _c;
+      if (prop.type === "property" && ((_b = (_a2 = prop.children) == null ? void 0 : _a2.length) != null ? _b : 0) > 0) {
+        const [key, val] = (_c = prop.children) != null ? _c : [];
+        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) {
+    var _a;
+    const state = new FlowStateASTNodeImpl(node, parent);
+    jsonToNode.set(node, state);
+    if (node.type === "object") {
+      (_a = node.children) == null ? void 0 : _a.forEach((prop) => {
+        var _a2;
+        if (prop.type === "property" && ((_a2 = prop.children) == null ? void 0 : _a2.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 == null ? void 0 : 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) {
+    var _a;
+    const flow = new FlowASTNodeImpl(node, parent);
+    jsonToNode.set(node, flow);
+    if (node.type === "object") {
+      (_a = node.children) == null ? void 0 : _a.forEach((prop) => {
+        var _a2;
+        if (prop.type === "property" && ((_a2 = prop.children) == null ? void 0 : _a2.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 == null ? void 0 : val.type) === "string") {
+            property.valueNode = parseUnknownNode(val, property);
+            flow.start = property;
+          } else if ((val == null ? void 0 : 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) {
+    var _a;
+    const navNode = new NavigationASTNodeImpl(node, parent);
+    jsonToNode.set(node, navNode);
+    if (node.type === "object") {
+      (_a = node.children) == null ? void 0 : _a.forEach((prop) => {
+        var _a2;
+        if (prop.type === "property" && ((_a2 = prop.children) == null ? void 0 : _a2.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 == null ? void 0 : val.type) === "string") {
+            property.valueNode = parseUnknownNode(val, property);
+            navNode.begin = property;
+          } else if ((val == null ? void 0 : 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) {
+    var _a;
+    const contentNode = new ContentASTNodeImpl(node, void 0);
+    if (node.type === "object") {
+      (_a = node.children) == null ? void 0 : _a.forEach((childProp) => {
+        var _a2, _b;
+        if (childProp.type === "property" && ((_a2 = childProp.children) == null ? void 0 : _a2.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 == null ? void 0 : val.type) === "array") {
+            const views = new ArrayASTNodeImpl(val, property);
+            (_b = val.children) == null ? void 0 : _b.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:
+      rootASTNode = parseAsset(root);
+      break;
+    case 0:
+      rootASTNode = parseContent(root);
+      break;
+  }
+  return new PlayerContent(rootASTNode, diags, jsonToNode);
+}
+
+function replaceString(node, newText) {
+  return {
+    type: "replace",
+    node,
+    value: newText
+  };
+}
+function toRange(document, node) {
+  return vscodeLanguageserverTypes.Range.create(document.positionAt(node.jsonNode.offset), document.positionAt(node.jsonNode.offset + node.jsonNode.length));
+}
+function toTextEdit(document, edit) {
+  switch (edit.type) {
+    case "replace":
+      return vscodeLanguageserverTypes.TextEdit.replace(toRange(document, edit.node), edit.value);
+    default:
+      throw new Error("Dont know how to convert this to a TextEdit");
+  }
+}
+
+var __async$9 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function walk(node, visitor) {
+  return __async$9(this, null, function* () {
+    const queue = [node];
+    let stop = false;
+    while (queue.length > 0 && !stop) {
+      const nodeToVisit = queue.shift();
+      if (nodeToVisit == null ? void 0 : nodeToVisit.children) {
+        queue.push(...nodeToVisit.children);
+      }
+      stop = nodeToVisit ? yield visitor(nodeToVisit) : true;
+    }
+  });
+}
+function getNodeValue(node) {
+  return jsoncParser.getNodeValue(node.jsonNode);
+}
+
+const 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 vscodeLanguageserverTextdocument.TextDocument.create("foo", "json", 1, str);
+}
+function isKnownRootType(document) {
+  const { type } = document.root;
+  return type === "view" || type === "asset" || type === "content";
+}
+function isValueCompletion(node) {
+  var _a;
+  return ((_a = node.parent) == null ? void 0 : _a.type) === "property" && node.parent.valueNode === node;
+}
+function isPropertyCompletion(node) {
+  var _a;
+  return ((_a = node.parent) == null ? void 0 : _a.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 = vscodeLanguageserverTypes.Range.create(document.positionAt(node.jsonNode.offset), document.positionAt(node.jsonNode.offset + node.jsonNode.length));
+  return vscodeLanguageserverTypes.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__default["default"](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;
+  }
+  return flowXLR;
+}
+
+var __async$8 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const isInView = (node) => {
+  if (node.type === "view") {
+    return true;
+  }
+  if (!node.parent) {
+    return false;
+  }
+  return isInView(node.parent);
+};
+const checkTypesForAssetWrapper = (nodes) => {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.type === "ref" && node.ref.includes("AssetWrapper"))
+      return true;
+    if (node.type === "or")
+      return checkTypesForAssetWrapper(node.or);
+    if (node.type === "and")
+      return checkTypesForAssetWrapper(node.and);
+  }
+  return false;
+};
+const checkSwitchCase = (node) => {
+  return node.value === "staticSwitch" || node.value === "dynamicSwitch";
+};
+class AssetWrapperArrayPlugin {
+  constructor() {
+    this.name = "asset-wrapper-to-array";
+  }
+  apply(service) {
+    service.hooks.validate.tap(this.name, (documentInfo, validationContext) => __async$8(this, null, function* () {
+      validationContext.useASTVisitor({
+        ArrayNode: (arrayNode) => __async$8(this, null, function* () {
+          if (!isInView(arrayNode)) {
+            return;
+          }
+          const xlrInfo = service.XLRService.getTypeInfoAtPosition(arrayNode);
+          if (!xlrInfo)
+            return;
+          const isAssetWrapper = checkTypesForAssetWrapper(xlrInfo.nodes);
+          const parentNode = arrayNode.parent;
+          if ((parentNode == null ? void 0 : 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: vscodeLanguageserverTypes.DiagnosticSeverity.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)
+                  }
+                };
+              }
+            });
+          }
+        })
+      });
+    }));
+  }
+}
+
+var __async$7 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function getBindingInfo(ctx) {
+  var _a, _b, _c;
+  const info = {
+    bindingToSchemaType: new Map(),
+    typeToNode: new Map()
+  };
+  if (ctx.PlayerContent.root.type !== "content") {
+    return info;
+  }
+  const schemaRoot = (_a = ctx.PlayerContent.root.properties) == null ? void 0 : _a.find((child) => child.keyNode.value === "schema");
+  if (!schemaRoot || ((_b = schemaRoot.valueNode) == null ? void 0 : _b.type) !== "object") {
+    return info;
+  }
+  const schemaTypeQueue = [
+    {
+      currentPath: "",
+      typeToVisit: "ROOT",
+      visited: 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 || ((_c = typeNode.valueNode) == null ? void 0 : _c.type) !== "object") {
+      continue;
+    }
+    info.typeToNode.set(typeToVisit, { type: typeToVisit, typeNode });
+    typeNode.valueNode.properties.forEach((prop) => {
+      var _a2, _b2;
+      const nextPath = [currentPath, prop.keyNode.value].join(currentPath === "" ? "" : ".");
+      info.bindingToSchemaType.set(nextPath, {
+        binding: nextPath,
+        typeName: typeToVisit,
+        key: prop.keyNode.value
+      });
+      if (((_a2 = prop.valueNode) == null ? void 0 : _a2.type) === "object") {
+        const nestedTypeName = prop.valueNode.properties.find((c) => c.keyNode.value === "type");
+        if (nestedTypeName && ((_b2 = nestedTypeName.valueNode) == null ? void 0 : _b2.type) === "string") {
+          schemaTypeQueue.push({
+            currentPath: nextPath,
+            typeToVisit: nestedTypeName.valueNode.value,
+            visited
+          });
+        }
+      }
+    });
+  }
+  return info;
+}
+const 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) {
+  var _a, _b, _c;
+  if (ctx.node.type !== "string" || ((_a = ctx.node.parent) == null ? void 0 : _a.type) !== "property") {
+    return false;
+  }
+  if (checkTypesForBinding((_c = (_b = ctx.XLR) == null ? void 0 : _b.nodes) != null ? _c : [])) {
+    return true;
+  }
+  return false;
+}
+function getLocationForBindingTypeDefinition(ctx, schemaInfo) {
+  var _a;
+  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 || ((_a = nodeLocation.typeNode.valueNode) == null ? void 0 : _a.type) !== "object") {
+    return;
+  }
+  const prop = getProperty(nodeLocation.typeNode.valueNode, info.key);
+  if (!prop) {
+    return;
+  }
+  return getLSLocationOfNode(ctx.document, prop);
+}
+function getLocationForSchemaType(ctx, schemaInfo) {
+  var _a, _b, _c;
+  if (isValueCompletion(ctx.node)) {
+    if (((_a = ctx.node.parent) == null ? void 0 : _a.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 = (_b = getContentNode(ctx.node)) == null ? void 0 : _b.properties.find((p) => p.keyNode.value === "schema");
+      if (((_c = schemaPropNode == null ? void 0 : schemaPropNode.valueNode) == null ? void 0 : _c.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);
+    }
+  }
+}
+class SchemaInfoPlugin {
+  constructor() {
+    this.name = "view-node";
+  }
+  apply(service) {
+    let schemaInfo;
+    service.hooks.onDocumentUpdate.tap(this.name, (ctx) => {
+      schemaInfo = getBindingInfo(ctx);
+    });
+    service.hooks.complete.tap(this.name, (ctx, completionCtx) => __async$7(this, null, function* () {
+      var _a;
+      if (!isBindingPropertyAssignment(ctx)) {
+        return;
+      }
+      const existingBindingValue = ctx.node.value;
+      const bindings = Array.from((_a = schemaInfo == null ? void 0 : schemaInfo.bindingToSchemaType.keys()) != null ? _a : []).filter((k) => k.startsWith(existingBindingValue));
+      bindings.forEach((b) => {
+        completionCtx.addCompletionItem({
+          kind: vscodeLanguageserverTypes.CompletionItemKind.Value,
+          label: b.substring(existingBindingValue.length)
+        });
+      });
+    }));
+    service.hooks.definition.tap(this.name, (ctx) => {
+      if (!schemaInfo) {
+        return;
+      }
+      return getLocationForSchemaType(ctx, schemaInfo) || getLocationForBindingTypeDefinition(ctx, schemaInfo);
+    });
+  }
+}
+
+var __async$6 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const 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;
+};
+function createValidationVisitor$3(ctx, sdk) {
+  const nodesWithErrors = new Set();
+  return {
+    AssetNode: (assetNode) => {
+      var _a, _b, _c, _d;
+      let expectedType = (_b = (_a = assetNode.assetType) == null ? void 0 : _a.valueNode) == null ? void 0 : _b.value;
+      if (!sdk.hasType(expectedType)) {
+        ctx.addViolation({
+          node: assetNode,
+          message: `Warning - Asset Type ${(_d = (_c = assetNode.assetType) == null ? void 0 : _c.valueNode) == null ? void 0 : _d.value} was not loaded into Validator definitions`,
+          severity: vscodeLanguageserverTypes.DiagnosticSeverity.Warning
+        });
+        expectedType = "Asset";
+      }
+      const validationIssues = sdk.validateByName(expectedType, assetNode.jsonNode);
+      validationIssues.forEach((issue) => {
+        if (!nodesWithErrors.has(issue.node) || issue.type === "missing") {
+          nodesWithErrors.add(issue.node);
+          ctx.addViolation({
+            node: findErrorNode(assetNode, issue.node),
+            message: `Asset Validation Error - ${issue.type}: ${issue.message}`,
+            severity: vscodeLanguageserverTypes.DiagnosticSeverity.Error
+          });
+        }
+      });
+    },
+    ViewNode: (viewNode) => {
+      var _a, _b, _c, _d;
+      let expectedType = (_b = (_a = viewNode.viewType) == null ? void 0 : _a.valueNode) == null ? void 0 : _b.value;
+      if (!sdk.hasType(expectedType)) {
+        ctx.addViolation({
+          node: viewNode,
+          message: `Warning - View Type ${(_d = (_c = viewNode.viewType) == null ? void 0 : _c.valueNode) == null ? void 0 : _d.value} was not loaded into Validator definitions`,
+          severity: vscodeLanguageserverTypes.DiagnosticSeverity.Warning
+        });
+        expectedType = "View";
+      }
+      const validationIssues = sdk.validateByName(expectedType, viewNode.jsonNode);
+      validationIssues.forEach((issue) => {
+        if (!nodesWithErrors.has(issue.node) || issue.type === "missing") {
+          nodesWithErrors.add(issue.node);
+          ctx.addViolation({
+            node: findErrorNode(viewNode, issue.node),
+            message: `View Validation Error - ${issue.type}: ${issue.message}`,
+            severity: vscodeLanguageserverTypes.DiagnosticSeverity.Error
+          });
+        }
+      });
+    },
+    ContentNode: (contentNode) => {
+      var _a;
+      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" && ((_a = flowType.properties.views) == null ? void 0 : _a.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: vscodeLanguageserverTypes.DiagnosticSeverity.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: vscodeLanguageserverTypes.DiagnosticSeverity.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: vscodeLanguageserverTypes.DiagnosticSeverity.Error
+          });
+        }
+      });
+    },
+    FlowStateNode: (flowStateNode) => {
+      var _a, _b;
+      const flowxlr = mapFlowStateToType((_b = (_a = flowStateNode.stateType) == null ? void 0 : _a.valueNode) == null ? void 0 : _b.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: vscodeLanguageserverTypes.DiagnosticSeverity.Error
+            });
+          }
+        });
+      } else {
+        ctx.addViolation({
+          node: flowStateNode,
+          message: "Unknown Flow Type, valid options are: VIEW, END, ACTION, EXTERNAL, FLOW",
+          severity: vscodeLanguageserverTypes.DiagnosticSeverity.Error
+        });
+      }
+    }
+  };
+}
+function getObjectCompletions(authoredNode, potentialTypes) {
+  const completions = [];
+  const presentKeys = 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) => {
+        var _a;
+        if (!presentKeys.has(prop)) {
+          completions.push({
+            label: prop,
+            documentation: (_a = node.properties[prop].node.description) != null ? _a : node.properties[prop].node.title,
+            kind: vscodeLanguageserverTypes.CompletionItemKind.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) => {
+    var _a;
+    if (nodeType.type === "object") {
+      const propertyNode = (_a = nodeType.properties[propertyName]) == null ? void 0 : _a.node;
+      if (propertyNode && propertyNode.type === "string" && propertyNode.const) {
+        completions.push({
+          label: propertyNode.const,
+          kind: vscodeLanguageserverTypes.CompletionItemKind.Value
+        });
+      }
+    }
+  });
+  return completions;
+}
+function complete(ctx) {
+  var _a, _b, _c;
+  if ((_a = ctx.XLR) == null ? void 0 : _a.nearestObjects) {
+    if (ctx.node.type === "string" && ((_c = (_b = ctx.node) == null ? void 0 : _b.parent) == null ? void 0 : _c.type) === "property") {
+      return getPropertyCompletions(ctx.node.parent.keyNode.value, ctx.XLR.nearestObjects);
+    }
+    return getObjectCompletions(ctx.node, ctx.XLR.nearestObjects);
+  }
+  return [];
+}
+function hover(ctx) {
+  var _a;
+  if (ctx.XLR && ctx.node.type === "string") {
+    const docStrings = [];
+    const prop = ctx.node.value;
+    ctx.XLR.nearestObjects.forEach((typeNode) => {
+      var _a2, _b, _c, _d, _e, _f;
+      const docString = (_f = (_e = (_b = (_a2 = typeNode.properties[prop]) == null ? void 0 : _a2.node) == null ? void 0 : _b.description) != null ? _e : (_d = (_c = typeNode.properties[prop]) == null ? void 0 : _c.node) == null ? void 0 : _d.title) != null ? _f : void 0;
+      if (docString) {
+        docStrings.push(docString);
+      }
+    });
+    if (docStrings.length > 1) {
+      return {
+        contents: {
+          kind: vscodeLanguageserverTypes.MarkupKind.PlainText,
+          value: "Docs unavailable - More than one type could exist at this location"
+        }
+      };
+    }
+    return {
+      contents: {
+        kind: vscodeLanguageserverTypes.MarkupKind.PlainText,
+        value: (_a = docStrings[0]) != null ? _a : "Error getting docs"
+      }
+    };
+  }
+}
+class XLRPlugin {
+  constructor() {
+    this.name = "xlr-plugin";
+  }
+  apply(service) {
+    service.hooks.validate.tap(this.name, (ctx, validation) => __async$6(this, null, function* () {
+      validation.useASTVisitor(createValidationVisitor$3(validation, service.XLRService.XLRSDK));
+    }));
+    service.hooks.complete.tap(this.name, (ctx, completion) => __async$6(this, null, function* () {
+      complete(ctx).map((i) => completion.addCompletionItem(i));
+    }));
+    service.hooks.hover.tap(this.name, (ctx) => {
+      return hover(ctx);
+    });
+  }
+}
+
+var __async$5 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const generateID = (node) => {
+  var _a, _b, _c;
+  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" && ((_b = (_a = node.assetType) == null ? void 0 : _a.valueNode) == null ? void 0 : _b.value)) {
+    current = (_c = node.assetType.valueNode) == null ? void 0 : _c.value;
+  }
+  return [prefix, current].filter(Boolean).join("-");
+};
+const createViolation = (node) => {
+  var _a, _b, _c;
+  const valueNode = (_a = node.id) == null ? void 0 : _a.valueNode;
+  if (!valueNode) {
+    return;
+  }
+  return {
+    node: valueNode,
+    severity: vscodeLanguageserverTypes.DiagnosticSeverity.Error,
+    message: `The id '${(_c = (_b = node.id) == null ? void 0 : _b.valueNode) == null ? void 0 : _c.value}' is already in use in this view.`,
+    fix: () => {
+      return {
+        name: "Generate new ID",
+        edit: replaceString(valueNode, `"${generateID(node)}"`)
+      };
+    }
+  };
+};
+const createValidationVisitor$2 = (ctx) => {
+  const viewInfo = new Map();
+  return {
+    AssetNode: (assetNode) => {
+      var _a, _b;
+      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 || !((_a = assetID.valueNode) == null ? void 0 : _a.value)) {
+        return;
+      }
+      const id = (_b = assetID.valueNode) == null ? void 0 : _b.value;
+      if (!viewInfo.has(view)) {
+        viewInfo.set(view, new Map());
+      }
+      const assetIDMap = viewInfo.get(view);
+      const idInfo = assetIDMap == null ? void 0 : assetIDMap.get(id);
+      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 == null ? void 0 : assetIDMap.set(id, { original: assetNode, handled: false });
+      }
+    }
+  };
+};
+class DuplicateIDPlugin {
+  constructor() {
+    this.name = "duplicate-id";
+  }
+  apply(service) {
+    service.hooks.validate.tap(this.name, (ctx, validation) => __async$5(this, null, function* () {
+      validation.useASTVisitor(createValidationVisitor$2(validation));
+    }));
+  }
+}
+
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async$4 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function createRuleVisitor$1(context) {
+  const checkForLegacyAction = (node) => {
+    if (node.type === "asset") {
+      return;
+    }
+    if (node.type === "object" && !node.properties.some((p) => p.keyNode.value === "asset" || p.keyNode.value === "dynamicSwitch" || p.keyNode.value === "staticSwitch")) {
+      context.addViolation({
+        message: "Migrate to an action-asset",
+        node,
+        severity: vscodeLanguageserverTypes.DiagnosticSeverity.Warning,
+        fix: () => {
+          const newActionAsset = {
+            asset: __spreadValues$3({
+              type: "action"
+            }, getNodeValue(node))
+          };
+          return {
+            name: "Convert to Asset",
+            edit: {
+              type: "replace",
+              node,
+              value: JSON.stringify(newActionAsset, null, 2)
+            }
+          };
+        }
+      });
+    }
+  };
+  return {
+    ViewNode: (viewNode) => {
+      var _a;
+      const actionsProp = viewNode.properties.find((p) => p.keyNode.value === "actions");
+      if (!actionsProp || ((_a = actionsProp.valueNode) == null ? void 0 : _a.type) !== "array") {
+        return;
+      }
+      actionsProp.valueNode.children.forEach((action) => {
+        checkForLegacyAction(action);
+      });
+    }
+  };
+}
+class LegacyActionPlugin {
+  constructor() {
+    this.name = "legacy-action";
+  }
+  apply(service) {
+    service.hooks.validate.tap(this.name, (ctx, validationContext) => __async$4(this, null, function* () {
+      validationContext.useASTVisitor(createRuleVisitor$1(validationContext));
+    }));
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+var __async$3 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function createRuleVisitor(context, docInfo) {
+  const checkForLegacyTemplate = (node) => {
+    var _a;
+    const templateDataProp = node.properties.find((p) => p.keyNode.value === "templateData");
+    const templateValueProp = node.properties.find((p) => p.keyNode.value === "template");
+    const templateOutputProp = node.properties.find((p) => p.keyNode.value === "templateOutput");
+    if (!templateDataProp && !templateOutputProp && (!templateValueProp || ((_a = templateValueProp.valueNode) == null ? void 0 : _a.type) === "array")) {
+      return;
+    }
+    const templateViolation = {
+      severity: vscodeLanguageserverTypes.DiagnosticSeverity.Error,
+      message: `Migrate to the template[] syntax.`,
+      fix: () => {
+        var _a2, _b, _c, _d, _e, _f, _g, _h;
+        const path = [
+          "template",
+          ((_a2 = templateValueProp == null ? void 0 : templateValueProp.valueNode) == null ? void 0 : _a2.type) === "array" ? templateValueProp.valueNode.children.length : 0
+        ];
+        const newTemplateObj = {
+          value: ((_b = templateValueProp == null ? void 0 : templateValueProp.valueNode) == null ? void 0 : _b.type) !== "array" && (templateValueProp == null ? void 0 : templateValueProp.valueNode) ? getNodeValue(templateValueProp == null ? void 0 : templateValueProp.valueNode) : {},
+          output: (_d = (_c = templateOutputProp == null ? void 0 : templateOutputProp.valueNode) == null ? void 0 : _c.jsonNode.value) != null ? _d : "",
+          data: (_f = (_e = templateDataProp == null ? void 0 : templateDataProp.valueNode) == null ? void 0 : _e.jsonNode.value) != null ? _f : ""
+        };
+        const oldValue = getNodeValue(node);
+        let newValue = timm.omit(oldValue, "templateData");
+        newValue = timm.omit(newValue, "templateOutput");
+        if (((_g = templateValueProp == null ? void 0 : templateValueProp.valueNode) == null ? void 0 : _g.type) !== "array") {
+          newValue = timm.omit(newValue, "template");
+        }
+        newValue = timm.set(newValue, "template", timm.addLast((_h = newValue.template) != null ? _h : [], newTemplateObj));
+        return {
+          edit: {
+            type: "replace",
+            path,
+            node,
+            value: formatLikeNode(docInfo.document, node, newValue)
+          },
+          name: "Convert to template[]"
+        };
+      }
+    };
+    if (templateDataProp) {
+      context.addViolation(__spreadProps$2(__spreadValues$2({}, templateViolation), {
+        node: templateDataProp
+      }));
+    }
+    if (templateOutputProp) {
+      context.addViolation(__spreadProps$2(__spreadValues$2({}, templateViolation), {
+        node: templateOutputProp
+      }));
+    }
+  };
+  return {
+    ViewNode: checkForLegacyTemplate,
+    AssetNode: checkForLegacyTemplate,
+    ObjectNode: checkForLegacyTemplate
+  };
+}
+class LegacyTemplatePlugin {
+  constructor() {
+    this.name = "legacy-template";
+  }
+  apply(service) {
+    service.hooks.validate.tap(this.name, (ctx, validationContext) => __async$3(this, null, function* () {
+      validationContext.useASTVisitor(createRuleVisitor(validationContext, ctx));
+    }));
+  }
+}
+
+const getObjectTarget = (node) => {
+  if (isObjectNode(node)) {
+    return node;
+  }
+  if (isKeyNode(node) && isPropertyNode(node.parent) && isObjectNode(node.parent.valueNode)) {
+    return node.parent.valueNode;
+  }
+};
+class MissingAssetWrapperPlugin {
+  constructor() {
+    this.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) => {
+        var _a;
+        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: (_a = d.severity) != null ? _a : vscodeLanguageserverTypes.DiagnosticSeverity.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;
+    });
+  }
+}
+
+var __async$2 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const createValidationVisitor$1 = (ctx) => {
+  const validTransitions = new Map();
+  return {
+    FlowNode: (flowNode) => {
+      var _a;
+      const flowNodeId = (_a = flowNode.parent) == null ? void 0 : _a.keyNode.value;
+      flowNode.states.forEach((p) => {
+        var _a2;
+        if (!validTransitions.has(flowNodeId)) {
+          validTransitions.set(flowNodeId, new Set());
+        }
+        (_a2 = validTransitions.get(flowNodeId)) == null ? void 0 : _a2.add(p.keyNode.value);
+      });
+    },
+    FlowStateNode: (flowState) => {
+      var _a, _b, _c;
+      const transitions = flowState.properties.find((p) => p.keyNode.value === "transitions");
+      let flowNode = flowState.parent;
+      while (flowNode && !isFlowNode(flowNode)) {
+        flowNode = flowNode == null ? void 0 : flowNode.parent;
+      }
+      const flowNodeId = (_a = flowNode == null ? void 0 : flowNode.parent) == null ? void 0 : _a.keyNode.value;
+      (_c = (_b = transitions == null ? void 0 : transitions.valueNode) == null ? void 0 : _b.children) == null ? void 0 : _c.forEach((transitionObjects) => {
+        var _a2, _b2;
+        if (transitionObjects.type === "property" && ((_a2 = transitionObjects.valueNode) == null ? void 0 : _a2.type) === "string") {
+          if (!((_b2 = validTransitions.get(flowNodeId)) == null ? void 0 : _b2.has(transitionObjects.valueNode.value))) {
+            ctx.addViolation({
+              node: transitionObjects.valueNode,
+              severity: vscodeLanguageserverTypes.DiagnosticSeverity.Error,
+              message: `Node '${transitionObjects.valueNode.value}' not found`
+            });
+          }
+        }
+      });
+    }
+  };
+};
+const isTransitionValue = (node) => {
+  var _a;
+  return node.type === "string" && isPropertyNode(node.parent) && ((_a = node.parent.parent) == null ? void 0 : _a.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);
+};
+const getFlowNode = (node) => {
+  if (isFlowNode(node)) {
+    return node;
+  }
+  if (node.parent) {
+    return getFlowNode(node.parent);
+  }
+};
+class NavStatePlugin {
+  constructor() {
+    this.name = "nav-state";
+  }
+  apply(service) {
+    service.hooks.validate.tap(this.name, (ctx, validation) => __async$2(this, null, function* () {
+      validation.useASTVisitor(createValidationVisitor$1(validation));
+    }));
+    service.hooks.complete.tap(this.name, (ctx, completionCtx) => __async$2(this, null, function* () {
+      if (!isValueCompletion(ctx.node)) {
+        return;
+      }
+      if (isTransitionValue(ctx.node)) {
+        const flowNode = getFlowNode(ctx.node);
+        flowNode == null ? void 0 : flowNode.states.forEach((p) => {
+          completionCtx.addCompletionItem({
+            kind: vscodeLanguageserverTypes.CompletionItemKind.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 == null ? void 0 : flowNode.states.find((n) => n.keyNode.value === value);
+        if (flowProp) {
+          return getLSLocationOfNode(ctx.document, flowProp.keyNode);
+        }
+      }
+    });
+  }
+}
+
+var __async$1 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const createValidationVisitor = (ctx, viewInfo) => {
+  return {
+    FlowStateNode: (flowState) => {
+      var _a, _b, _c;
+      if (((_b = (_a = flowState.stateType) == null ? void 0 : _a.valueNode) == null ? void 0 : _b.value) === "VIEW") {
+        const refNode = getProperty(flowState, "ref");
+        if (!refNode || ((_c = refNode.valueNode) == null ? void 0 : _c.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: vscodeLanguageserverTypes.DiagnosticSeverity.Error
+        });
+      }
+    },
+    ViewNode: (viewNode) => {
+      var _a, _b;
+      if (viewNode.id && ((_a = viewNode.id.valueNode) == null ? void 0 : _a.value) !== void 0) {
+        if (!viewInfo.nodes.get((_b = viewNode.id.valueNode) == null ? void 0 : _b.value)) {
+          ctx.addViolation({
+            node: viewNode.id.valueNode,
+            message: `View is not reachable`,
+            severity: vscodeLanguageserverTypes.DiagnosticSeverity.Warning
+          });
+        }
+      }
+    }
+  };
+};
+const getViewInfo = (ctx) => {
+  var _a, _b, _c, _d;
+  const views = new Map();
+  const nodes = new Map();
+  const { root } = ctx.PlayerContent;
+  if (root.type === "content") {
+    (_b = (_a = root.views) == null ? void 0 : _a.valueNode) == null ? void 0 : _b.children.forEach((c) => {
+      var _a2;
+      if (isViewNode(c) && ((_a2 = c.id) == null ? void 0 : _a2.valueNode)) {
+        views.set(c.id.valueNode.value, {
+          id: c.id.valueNode.value,
+          idProp: c.id
+        });
+      }
+    });
+    (_d = (_c = root.navigation) == null ? void 0 : _c.valueNode) == null ? void 0 : _d.flows.forEach((flow) => {
+      var _a2, _b2;
+      (_b2 = (_a2 = flow.valueNode) == null ? void 0 : _a2.states) == null ? void 0 : _b2.forEach((state) => {
+        var _a3, _b3, _c2, _d2;
+        if (((_c2 = (_b3 = (_a3 = state.valueNode) == null ? void 0 : _a3.stateType) == null ? void 0 : _b3.valueNode) == null ? void 0 : _c2.value) === "VIEW") {
+          const ref = state.valueNode.properties.find((p) => p.keyNode.value === "ref");
+          if (((_d2 = ref == null ? void 0 : ref.valueNode) == null ? void 0 : _d2.type) === "string") {
+            const refVal = ref.valueNode.value;
+            nodes.set(refVal, {
+              id: refVal,
+              refProp: ref
+            });
+          }
+        }
+      });
+    });
+  }
+  return {
+    views,
+    nodes
+  };
+};
+class ViewNodePlugin {
+  constructor() {
+    this.name = "view-node";
+  }
+  apply(service) {
+    let viewInfo;
+    service.hooks.validate.tap(this.name, (ctx, validation) => __async$1(this, null, function* () {
+      if (!viewInfo) {
+        return;
+      }
+      validation.useASTVisitor(createValidationVisitor(validation, viewInfo));
+    }));
+    service.hooks.onDocumentUpdate.tap(this.name, (ctx) => {
+      viewInfo = getViewInfo(ctx);
+    });
+    service.hooks.complete.tap(this.name, (ctx, completionCtx) => __async$1(this, null, function* () {
+      var _a, _b;
+      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((_a = viewInfo == null ? void 0 : viewInfo.views.keys()) != null ? _a : []).forEach((vID) => {
+          completionCtx.addCompletionItem({
+            kind: vscodeLanguageserverTypes.CompletionItemKind.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((_b = viewInfo == null ? void 0 : viewInfo.nodes.keys()) != null ? _b : []).forEach((vID) => {
+          completionCtx.addCompletionItem({
+            kind: vscodeLanguageserverTypes.CompletionItemKind.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 == null ? void 0 : 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 == null ? void 0 : viewInfo.views.get(value);
+          if (viewNode) {
+            return getLSLocationOfNode(ctx.document, viewNode.idProp);
+          }
+        }
+      }
+    });
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+const applyCommonProps = (inputNode, capability) => {
+  const outputNode = __spreadValues$1({}, inputNode);
+  if (capability === "Assets") {
+    if (outputNode.type === "object") {
+      if (!outputNode.properties.applicability) {
+        outputNode.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 (outputNode.type === "object" && !outputNode.properties._comment) {
+    outputNode.properties._comment = {
+      required: false,
+      node: {
+        description: "Adds a comment for the given node",
+        type: "string"
+      }
+    };
+  } else if (outputNode.type === "and") {
+    outputNode.and.map((n) => applyCommonProps(n, capability));
+  } else if (outputNode.type === "or") {
+    outputNode.or.map((n) => applyCommonProps(n, capability));
+  }
+  return outputNode;
+};
+const applyAssetWrapperOrSwitch = (node, capability) => {
+  return xlrSdk.simpleTransformGenerator("ref", "Assets", (xlrNode) => {
+    if (xlrNode.ref.includes("AssetWrapper")) {
+      return __spreadProps$1(__spreadValues$1({}, xlrNode), {
+        ref: xlrNode.ref.replace("AssetWrapper", "AssetWrapperOrSwitch")
+      });
+    }
+    return xlrNode;
+  })(node, capability);
+};
+const applyValueRefs = (node, capability) => {
+  return xlrSdk.simpleTransformGenerator("object", "Assets", (inputNode) => {
+    const xlrNode = __spreadValues$1({}, inputNode);
+    for (const key in xlrNode.properties) {
+      if (key === "id" || key === "type") {
+        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 (xlrUtils.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);
+};
+const applyTemplateProperty = (node, capability) => {
+  const templateTypes = [];
+  return xlrSdk.simpleTransformGenerator("object", "Assets", (inputNode) => {
+    const xlrNode = __spreadValues$1({}, 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}">`
+        });
+      }
+    }
+    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);
+};
+
+const PLUGINS = [
+  new DuplicateIDPlugin(),
+  new ViewNodePlugin(),
+  new SchemaInfoPlugin(),
+  new LegacyTemplatePlugin(),
+  new LegacyActionPlugin(),
+  new AssetWrapperArrayPlugin(),
+  new NavStatePlugin(),
+  new MissingAssetWrapperPlugin(),
+  new XLRPlugin()
+];
+const DEFAULT_FILTERS = {
+  typeFilter: "Transformed"
+};
+const TRANSFORM_FUNCTIONS = [
+  applyAssetWrapperOrSwitch,
+  applyValueRefs,
+  applyCommonProps,
+  applyTemplateProperty
+];
+
+class PlayerXLRRegistry extends xlrSdk.BasicXLRRegistry {
+  constructor() {
+    super();
+    this.registrationMap = 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) {
+    var _a, _b, _c, _d, _e, _f;
+    let registeredName = type.name;
+    if ((capability === "Assets" || capability === "Views") && type.type === "object" && ((_c = (_b = (_a = type.extends) == null ? void 0 : _a.genericArguments) == null ? void 0 : _b[0]) == null ? void 0 : _c.type) === "string" && ((_f = (_e = (_d = type.extends) == null ? void 0 : _d.genericArguments) == null ? void 0 : _e[0]) == null ? void 0 : _f.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 == null ? void 0 : metaData.plugin) === (firstElement == null ? void 0 : firstElement.plugin) && (metaData == null ? void 0 : metaData.capability) === (firstElement == null ? void 0 : 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);
+  }
+}
+
+class XLRService {
+  constructor() {
+    this.baseTypes = [
+      "asset",
+      "view",
+      "flow",
+      "content",
+      "navigation",
+      "state"
+    ];
+    this.XLRSDK = new xlrSdk.XLRSDK(new PlayerXLRRegistry());
+  }
+  walker(n, path) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    if (this.baseTypes.indexOf(n.type) > -1) {
+      if (n.type === "asset") {
+        const name = this.XLRSDK.hasType((_c = (_b = (_a = n.assetType) == null ? void 0 : _a.valueNode) == null ? void 0 : _b.value) != null ? _c : "") ? (_e = (_d = n.assetType) == null ? void 0 : _d.valueNode) == null ? void 0 : _e.value : "Asset";
+        return {
+          name,
+          path
+        };
+      }
+      if (n.type === "view") {
+        const name = this.XLRSDK.hasType((_h = (_g = (_f = n.viewType) == null ? void 0 : _f.valueNode) == null ? void 0 : _g.value) != null ? _h : "") ? (_j = (_i = n.viewType) == null ? void 0 : _i.valueNode) == null ? void 0 : _j.value : "View";
+        return { name, path };
+      }
+      if (n.type === "state") {
+        if ((_l = (_k = n.stateType) == null ? void 0 : _k.valueNode) == null ? void 0 : _l.value) {
+          const flowStateType = mapFlowStateToType((_n = (_m = n.stateType) == null ? void 0 : _m.valueNode) == null ? void 0 : _n.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) {
+    var _a;
+    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 == null ? void 0 : nodePointer.properties[pathSegment.keyNode.value]) {
+            newNode = (_a = nodePointer == null ? void 0 : nodePointer.properties[pathSegment.keyNode.value]) == null ? void 0 : _a.node;
+          } else if (nodePointer == null ? void 0 : nodePointer.additionalProperties) {
+            const adNode = nodePointer == null ? void 0 : 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
+    };
+  }
+}
+
+const LOG_TYPES = ["debug", "info", "warn", "error"];
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+class PlayerLanguageService {
+  constructor(config) {
+    this.parseCache = new Map();
+    this.fixableViolationsForDocument = new Map();
+    this.hooks = {
+      onDocumentUpdate: new tapableTs.SyncHook(),
+      validate: new tapableTs.AsyncParallelHook(),
+      onValidateEnd: new tapableTs.SyncWaterfallHook(),
+      complete: new tapableTs.AsyncParallelHook(),
+      hover: new tapableTs.SyncBailHook(),
+      definition: new tapableTs.SyncBailHook()
+    };
+    var _a;
+    this.XLRService = new XLRService();
+    PLUGINS.forEach((p) => p.apply(this));
+    (_a = config == null ? void 0 : config.plugins) == null ? void 0 : _a.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;
+  }
+  updateSource(document) {
+    return __async(this, null, function* () {
+      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 = __spreadValues({}, documentContext);
+      this.hooks.onDocumentUpdate.call(ctx);
+      return ctx;
+    });
+  }
+  getJSONPositionInfo(ctx, position) {
+    return __async(this, null, function* () {
+      const { document, PlayerContent } = ctx;
+      const node = PlayerContent.getNodeFromOffset(document.offsetAt(position));
+      return {
+        node
+      };
+    });
+  }
+  updateSourceWithPosition(document, position) {
+    return __async(this, null, function* () {
+      const ctx = yield this.updateSource(document);
+      const { node } = yield this.getJSONPositionInfo(ctx, position);
+      const XLRInfo = this.XLRService.getTypeInfoAtPosition(node);
+      if (!node || !XLRInfo) {
+        return void 0;
+      }
+      return __spreadProps(__spreadValues({}, ctx), {
+        node,
+        position,
+        XLR: XLRInfo
+      });
+    });
+  }
+  onClose(document) {
+    this.fixableViolationsForDocument.delete(document.uri);
+    this.parseCache.delete(document.uri);
+  }
+  formatTextDocument(document, options, range) {
+    return __async(this, null, function* () {
+      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 jsoncParser.format(document.getText(), formatRange, formattingOptions).map((edit) => {
+        return vscodeLanguageserverTypes.TextEdit.replace(vscodeLanguageserverTypes.Range.create(document.positionAt(edit.offset), document.positionAt(edit.offset + edit.length)), edit.content);
+      });
+    });
+  }
+  validateTextDocument(document) {
+    return __async(this, null, function* () {
+      const ctx = yield 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, new Map());
+        }
+        const fixableDiags = this.fixableViolationsForDocument.get(document.uri);
+        fixableDiags == null ? void 0 : 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);
+          }
+        };
+        yield this.hooks.validate.call(ctx, validationContext);
+        yield walk(ctx.PlayerContent.root, (node) => __async(this, null, function* () {
+          const visitorProp = typeToVisitorMap[node.type];
+          astVisitors.forEach((visitor) => __async(this, null, function* () {
+            var _a, _b;
+            try {
+              yield (_a = visitor[visitorProp]) == null ? void 0 : _a.call(visitor, node);
+            } catch (e) {
+              (_b = ctx.log) == null ? void 0 : _b.error(`Error running rules for ${visitorProp}: ${e.message}, Stack ${e.stack}`);
+            }
+          }));
+          return false;
+        }));
+      }
+      return this.hooks.onValidateEnd.call(diagnostics, {
+        documentContext: ctx,
+        addFixableViolation
+      });
+    });
+  }
+  getCompletionsAtPosition(document, position) {
+    return __async(this, null, function* () {
+      const ctxWithPos = yield this.updateSourceWithPosition(document, position);
+      if (!ctxWithPos) {
+        return vscodeLanguageserverTypes.CompletionList.create();
+      }
+      const completionItems = [];
+      const completionContext = {
+        addCompletionItem: (i) => {
+          completionItems.push(i);
+        }
+      };
+      yield this.hooks.complete.call(ctxWithPos, completionContext);
+      return vscodeLanguageserverTypes.CompletionList.create(completionItems);
+    });
+  }
+  resolveCompletionItem(completionItem) {
+    return __async(this, null, function* () {
+      return completionItem;
+    });
+  }
+  getHoverInfoAtPosition(document, position) {
+    return __async(this, null, function* () {
+      const context = yield this.updateSourceWithPosition(document, position);
+      if (!context) {
+        return void 0;
+      }
+      return this.hooks.hover.call(context);
+    });
+  }
+  getCodeActionsInRange(document, context) {
+    return __async(this, null, function* () {
+      const diagsForDocument = this.fixableViolationsForDocument.get(document.uri);
+      if (!diagsForDocument || diagsForDocument.size === 0 || context.diagnostics.length === 0) {
+        return [];
+      }
+      const actions = [];
+      diagsForDocument.forEach((violation, diagnostic) => {
+        var _a;
+        const matching = context.diagnostics.find((diag) => containsRange(diagnostic.range, diag.range));
+        const fixedAction = (_a = violation.fix) == null ? void 0 : _a.call(violation);
+        if (!matching || !fixedAction) {
+          return;
+        }
+        actions.push({
+          title: fixedAction.name,
+          kind: vscodeLanguageserverTypes.CodeActionKind.QuickFix,
+          edit: {
+            changes: {
+              [document.uri]: [toTextEdit(document, fixedAction.edit)]
+            }
+          }
+        });
+      });
+      return actions;
+    });
+  }
+  getDefinitionAtPosition(document, position) {
+    return __async(this, null, function* () {
+      const context = yield this.updateSourceWithPosition(document, position);
+      if (!context) {
+        return void 0;
+      }
+      return this.hooks.definition.call(context);
+    });
+  }
+  setAssetTypes(typeFiles) {
+    return __async(this, null, function* () {
+      typeFiles.forEach((file) => {
+        if (file.includes("types")) {
+          this.XLRService.XLRSDK.loadDefinitionsFromDisk(file, {});
+        } else {
+          this.XLRService.XLRSDK.loadDefinitionsFromDisk(file, DEFAULT_FILTERS, TRANSFORM_FUNCTIONS);
+        }
+      });
+    });
+  }
+}
+
+exports.ASTNodeImpl = ASTNodeImpl;
+exports.ArrayASTNodeImpl = ArrayASTNodeImpl;
+exports.AssetASTNodeImpl = AssetASTNodeImpl;
+exports.BooleanASTNodeImpl = BooleanASTNodeImpl;
+exports.ContentASTNodeImpl = ContentASTNodeImpl;
+exports.DEFAULT_FILTERS = DEFAULT_FILTERS;
+exports.FlowASTNodeImpl = FlowASTNodeImpl;
+exports.FlowStateASTNodeImpl = FlowStateASTNodeImpl;
+exports.LOG_TYPES = LOG_TYPES;
+exports.NavigationASTNodeImpl = NavigationASTNodeImpl;
+exports.NullASTNodeImpl = NullASTNodeImpl;
+exports.NumberASTNodeImpl = NumberASTNodeImpl;
+exports.ObjectASTNodeImpl = ObjectASTNodeImpl;
+exports.PLUGINS = PLUGINS;
+exports.PlayerContent = PlayerContent;
+exports.PlayerLanguageService = PlayerLanguageService;
+exports.PlayerXLRRegistry = PlayerXLRRegistry;
+exports.PropertyASTNodeImpl = PropertyASTNodeImpl;
+exports.StringASTNodeImpl = StringASTNodeImpl;
+exports.TRANSFORM_FUNCTIONS = TRANSFORM_FUNCTIONS;
+exports.ViewASTNodeImpl = ViewASTNodeImpl;
+exports.XLRService = XLRService;
+exports.applyAssetWrapperOrSwitch = applyAssetWrapperOrSwitch;
+exports.applyCommonProps = applyCommonProps;
+exports.applyTemplateProperty = applyTemplateProperty;
+exports.applyValueRefs = applyValueRefs;
+exports.containsRange = containsRange;
+exports.formatLikeNode = formatLikeNode;
+exports.getContentNode = getContentNode;
+exports.getLSLocationOfNode = getLSLocationOfNode;
+exports.getNodeValue = getNodeValue;
+exports.getPropForValNode = getPropForValNode;
+exports.getProperty = getProperty;
+exports.getValForKey = getValForKey;
+exports.getViewNode = getViewNode;
+exports.isFlowNode = isFlowNode;
+exports.isKeyNode = isKeyNode;
+exports.isKnownRootType = isKnownRootType;
+exports.isNavigationNode = isNavigationNode;
+exports.isObjectNode = isObjectNode;
+exports.isPropertyCompletion = isPropertyCompletion;
+exports.isPropertyNode = isPropertyNode;
+exports.isStateNode = isStateNode;
+exports.isValueCompletion = isValueCompletion;
+exports.isValueNode = isValueNode;
+exports.isViewNode = isViewNode;
+exports.mapFlowStateToType = mapFlowStateToType;
+exports.parse = parse;
+exports.replaceString = replaceString;
+exports.toRange = toRange;
+exports.toTextDocument = toTextDocument;
+exports.toTextEdit = toTextEdit;
+exports.typeToVisitorMap = typeToVisitorMap;
+exports.walk = walk;
+//# sourceMappingURL=index.cjs.js.map