vne-language 0.1.0 → 0.2.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "vne-language",
   "displayName": "vne-language",
   "description": "Syntax highlighting for .vne scenario files",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "main": "./src/extension.js",
   "scripts": {
     "package:vsix": "vsce package",

package/src/collect-command-tokens.js

@@ -5,13 +5,194 @@
     root.VneCommandTokens = factory();
   }
 })(typeof globalThis !== "undefined" ? globalThis : this, function () {
-  const TOKEN_TYPES = ["keyword", "function"];
+  const TOKEN_TYPES = ["keyword", "function", "number"];
 
   const escapeRegExp = (value) => String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
   const actionLiterals = (entry) =>
     Object.values((entry && entry.actions) || {}).filter((value) => typeof value === "string" && value.length > 0);
 
+  const enumLiterals = (arg) => {
+    if (!arg || arg.kind !== "enum" || !arg.values || typeof arg.values !== "object") return [];
+
+    return Object.values(arg.values).filter((value) => typeof value === "string" && value.length > 0);
+  };
+
+  const collectEnumLiteralsFromEntry = (entry) => {
+    const literals = new Set();
+
+    for (const arg of entry.args || []) {
+      for (const value of enumLiterals(arg)) literals.add(value);
+    }
+
+    for (const specs of Object.values(entry.argsByAction || {})) {
+      for (const arg of specs || []) {
+        for (const value of enumLiterals(arg)) literals.add(value);
+      }
+    }
+
+    for (const value of actionLiterals(entry)) literals.add(value);
+
+    return [...literals].sort((a, b) => b.length - a.length);
+  };
+
+  const isDelimitedToken = (token) => {
+    if (!token || !token.text) return false;
+    const open = token.text[0];
+    return open === "{" || open === '"' || open === "'";
+  };
+
+  const matchesArg = (spec, token) => {
+    if (!spec || !token) return false;
+
+    if (spec.kind === "id") {
+      if (spec.delimited) return isDelimitedToken(token);
+      return true;
+    }
+
+    if (spec.kind === "number") return /^-?\d+(?:\.\d+)?$/.test(token.text);
+
+    if (spec.kind === "enum") return enumLiterals(spec).includes(token.text);
+
+    return false;
+  };
+
+  /**
+   * Read `{…}`, `"…"`, or `'…'` as a single token (continues after the closer).
+   * @returns {{ text: string, start: number, end: number } | null}
+   */
+  const readDelimitedToken = (line, from, end = line.length) => {
+    const open = line[from];
+    if (from >= end) return null;
+
+    if (open === "{") {
+      let depth = 1;
+      let index = from + 1;
+
+      while (index < end && depth > 0) {
+        const ch = line[index];
+        if (ch === "{") depth += 1;
+        else if (ch === "}") depth -= 1;
+        index += 1;
+      }
+
+      return { text: line.slice(from, index), start: from, end: index };
+    }
+
+    if (open === '"' || open === "'") {
+      let index = from + 1;
+
+      while (index < end) {
+        const ch = line[index];
+        if (ch === "\\") {
+          index += 2;
+          continue;
+        }
+        if (ch === open) {
+          index += 1;
+          break;
+        }
+        index += 1;
+      }
+
+      return { text: line.slice(from, index), start: from, end: index };
+    }
+
+    return null;
+  };
+
+  /**
+   * Read next positional token (stops before `|` or `key:`; `{…}` / quotes are one token).
+   * @param {string[]} [extraLiterals] longest-first operator/enum literals (e.g. `===`, `++`)
+   * @param {number} [end]
+   * @returns {{ text: string, start: number, end: number } | null}
+   */
+  const nextPositionalToken = (line, from, extraLiterals = [], end = line.length) => {
+    let index = from;
+
+    while (index < end && /\s/.test(line[index])) index += 1;
+
+    if (index >= end) return null;
+
+    const ch = line[index];
+    if (ch === "|") return null;
+
+    if (ch === "{" || ch === '"' || ch === "'") {
+      return readDelimitedToken(line, index, end);
+    }
+
+    if (/^[a-zA-Z0-9_-]+:/.test(line.slice(index))) return null;
+
+    const rest = line.slice(index, end);
+
+    for (const literal of extraLiterals) {
+      if (rest.startsWith(literal)) {
+        const after = rest.slice(literal.length);
+        // Prefer operator match when next char is boundary (space/end/brace) or literal is word-like id
+        if (after === "" || /^\s/.test(after) || /^[{|"']/.test(after) || /^[a-zA-Z0-9_-]+:/.test(after)) {
+          return { text: literal, start: index, end: index + literal.length };
+        }
+      }
+    }
+
+    const numberMatch = /^-?\d+(?:\.\d+)?/.exec(rest);
+    if (numberMatch) {
+      return { text: numberMatch[0], start: index, end: index + numberMatch[0].length };
+    }
+
+    const idMatch = /^[a-zA-Z0-9_/-]+/.exec(rest);
+    if (!idMatch) return null;
+
+    return { text: idMatch[0], start: index, end: index + idMatch[0].length };
+  };
+
+  const collectPositionalTokens = (line, from, end = line.length, extraLiterals = []) => {
+    const tokens = [];
+    let cursor = from;
+
+    while (cursor < end) {
+      const token = nextPositionalToken(line, cursor, extraLiterals, end);
+      if (!token || token.start >= end) break;
+      tokens.push(token);
+      cursor = token.end;
+    }
+
+    return tokens;
+  };
+
+  const pushArgRanges = (ranges, lineIndex, tokens, specs) => {
+    const argSpecs = Array.isArray(specs) ? specs : [];
+    let tokenIndex = 0;
+
+    for (const spec of argSpecs) {
+      if (!spec) continue;
+
+      if (tokenIndex >= tokens.length) {
+        if (spec.optional) continue;
+        break;
+      }
+
+      const token = tokens[tokenIndex];
+
+      if (matchesArg(spec, token)) {
+        if (spec.kind === "id") {
+          ranges.push({ line: lineIndex, start: token.start, length: token.text.length, type: "function" });
+        } else if (spec.kind === "number") {
+          ranges.push({ line: lineIndex, start: token.start, length: token.text.length, type: "number" });
+        } else if (spec.kind === "enum") {
+          ranges.push({ line: lineIndex, start: token.start, length: token.text.length, type: "keyword" });
+        }
+
+        tokenIndex += 1;
+        continue;
+      }
+
+      if (spec.optional) continue;
+
+      break;
+    }
+  };
+
   /**
    * Collect semantic token ranges for document text.
    * @returns {{ line: number, start: number, length: number, type: string }[]}
@@ -32,38 +213,42 @@
       const lead = line.slice(trimmedStart);
       if (lead.startsWith("//") || lead.startsWith("#")) continue;
 
-      const execMatch = /^(\s*)([%$])\s+([a-zA-Z0-9_.-]+)(?:\s+([a-zA-Z0-9_-]+))?/.exec(line);
+      const pipeIndex = line.indexOf("|");
+      const execEnd = pipeIndex === -1 ? line.length : pipeIndex;
+      const execMatch = /^(\s*)([%$])\s+([a-zA-Z0-9_.-]+)/.exec(line.slice(0, execEnd));
 
       if (execMatch) {
         const prefix = execMatch[2];
         const commandName = execMatch[3];
-        const action = execMatch[4];
         const dict = prefix === "$" ? modules : blocks;
         const entry = dict[commandName];
-        const actions = actionLiterals(entry);
 
-        if (entry && action && actions.includes(action)) {
-          const nameOffset = line.indexOf(commandName, execMatch[1].length);
-          const actionOffset = line.indexOf(action, nameOffset + commandName.length);
+        if (entry) {
+          const commandStart = line.indexOf(commandName, trimmedStart);
+          const extraLiterals = collectEnumLiteralsFromEntry(entry);
+          const tokens = collectPositionalTokens(line, commandStart + commandName.length, execEnd, extraLiterals);
+          const actions = actionLiterals(entry);
+          const first = tokens[0];
+          const hasAction = Boolean(first && actions.includes(first.text));
 
-          if (actionOffset !== -1) {
-            ranges.push({ line: lineIndex, start: actionOffset, length: action.length, type: "keyword" });
-          }
-
-          if (actionOffset !== -1) {
-            const afterAction = line.slice(actionOffset + action.length);
-            const idMatch = /^\s+([a-zA-Z0-9_/-]+)/.exec(afterAction);
+          if (hasAction) {
+            ranges.push({
+              line: lineIndex,
+              start: first.start,
+              length: first.text.length,
+              type: "keyword",
+            });
 
-            if (idMatch) {
-              const idOffset = actionOffset + action.length + afterAction.indexOf(idMatch[1]);
-              ranges.push({ line: lineIndex, start: idOffset, length: idMatch[1].length, type: "function" });
-            }
+            const specs =
+              (entry.argsByAction && entry.argsByAction[first.text]) ||
+              (actions.length ? [{ kind: "id" }] : []);
+            pushArgRanges(ranges, lineIndex, tokens.slice(1), specs);
+          } else if (Array.isArray(entry.args) && entry.args.length) {
+            pushArgRanges(ranges, lineIndex, tokens, entry.args);
           }
         }
       }
 
-      const pipeIndex = line.indexOf("|");
-
       if (pipeIndex !== -1 && lineKeywords.length) {
         const rest = line.slice(pipeIndex + 1);
 
@@ -113,7 +298,12 @@
     TOKEN_TYPES,
     actionLiterals,
     collectCommandTokenRanges,
+    collectPositionalTokens,
     encodeSemanticTokenData,
+    enumLiterals,
     escapeRegExp,
+    isDelimitedToken,
+    nextPositionalToken,
+    readDelimitedToken,
   };
 });

package/src/load-commands.js

@@ -42,10 +42,20 @@ const findContractPackageDirs = (gameRoot) => {
 
 const importModule = async (filePath) => import(pathToFileURL(filePath).href);
 
+/**
+ * @param {unknown} keywords
+ * @returns {string[]}
+ */
+const collectLineKeywords = (keywords) => {
+  if (!keywords || typeof keywords !== "object") return [];
+
+  return Object.values(keywords).filter((value) => typeof value === "string" && value.length > 0);
+};
+
 /**
  * Load and merge SCENARIO_COMMANDS from contracts in node_modules of the game package.
  *
- * Imports only `dist/commands.js` when present (not the full package entry), so we do not
+ * Imports only `dist/commands.js` / `dist/const.js` when present (not the full package entry), so we do not
  * pull every contract's side-effect graph into the editor/extension host.
  *
  * @param {string} gameRoot
@@ -56,34 +66,31 @@ const loadCommandsFromNodeModules = async (gameRoot) => {
 
   const packageDirs = findContractPackageDirs(gameRoot);
   const manifests = [];
-  let lineKeywords = [];
+  const lineKeywords = [];
 
-  for (const [shortName, packageDir] of packageDirs) {
+  for (const [, packageDir] of packageDirs) {
     const commandsPath = path.join(packageDir, "dist", "commands.js");
+    const constPath = path.join(packageDir, "dist", "const.js");
 
-    if (!fs.existsSync(commandsPath)) continue;
+    if (fs.existsSync(commandsPath)) {
+      try {
+        const mod = await importModule(commandsPath);
 
-    try {
-      const mod = await importModule(commandsPath);
-
-      if (mod.SCENARIO_COMMANDS) manifests.push(mod.SCENARIO_COMMANDS);
-
-      if (shortName === "contracts.core.scenario") {
-        const constPath = path.join(packageDir, "dist", "const.js");
+        if (mod.SCENARIO_COMMANDS) manifests.push(mod.SCENARIO_COMMANDS);
+      } catch {
+        // Skip unreadable / incompatible packages.
+      }
+    }
 
-        if (fs.existsSync(constPath)) {
-          const consts = await importModule(constPath);
-          const keywords = consts.LINE_KEYWORDS || consts.CONSTANTS?.LINE_KEYWORDS;
+    if (fs.existsSync(constPath)) {
+      try {
+        const consts = await importModule(constPath);
+        const keywords = consts.LINE_KEYWORDS || consts.CONSTANTS?.LINE_KEYWORDS;
 
-          if (keywords && typeof keywords === "object") {
-            lineKeywords = Object.values(keywords).filter(
-              (value) => typeof value === "string" && value.length > 0,
-            );
-          }
-        }
+        lineKeywords.push(...collectLineKeywords(keywords));
+      } catch {
+        // Skip unreadable / incompatible packages.
       }
-    } catch {
-      // Skip unreadable / incompatible packages.
     }
   }
 
@@ -92,7 +99,7 @@ const loadCommandsFromNodeModules = async (gameRoot) => {
   return {
     modules: merged.modules,
     blocks: merged.blocks,
-    lineKeywords,
+    lineKeywords: [...new Set(lineKeywords)],
   };
 };
 

package/src/smoke-check.js

@@ -22,6 +22,11 @@ const main = async () => {
 
   assert(commands.modules.stack, "expected stack module from contracts");
   assert(commands.modules.scenario, "expected scenario module from contracts");
+  assert(commands.modules.save, "expected save module from contracts");
+  assert(commands.modules["bl.bg"], "expected bl.bg module from layer contracts");
+  assert(commands.modules["audio.music"], "expected audio.music module from contracts");
+  assert(commands.blocks.qte, "expected qte block from contracts");
+  assert(commands.blocks.choose, "expected choose block from contracts");
   assert(
     Object.values(commands.modules.stack.actions || {}).includes("jump"),
     "expected stack jump action",
@@ -30,10 +35,51 @@ const main = async () => {
     Object.values(commands.modules.scenario.actions || {}).includes("goto"),
     "expected scenario goto action",
   );
+  assert(
+    Object.values(commands.modules.save.actions || {}).includes("key"),
+    "expected save key action",
+  );
+  assert(
+    Object.values(commands.modules["bl.bg"].actions || {}).includes("show"),
+    "expected bl.bg show action",
+  );
+  assert(
+    Object.values(commands.modules["audio.music"].actions || {}).includes("play"),
+    "expected audio.music play action",
+  );
+  assert(commands.modules["text.meet"], "expected text.meet module from contracts");
+  assert(commands.modules["ul.sprite"], "expected ul.sprite module from layer contracts");
+  assert(
+    Array.isArray(commands.modules["text.meet"].args) && commands.modules["text.meet"].args[0]?.kind === "id",
+    "expected text.meet args id slot",
+  );
+  assert(
+    Array.isArray(commands.modules["ul.sprite"].argsByAction?.show) &&
+      commands.modules["ul.sprite"].argsByAction.show.some((arg) => arg.kind === "enum"),
+    "expected ul.sprite show position enum slot",
+  );
   assert(commands.lineKeywords.includes("async"), "expected LINE_KEYWORDS from scenario contract");
+  assert(commands.lineKeywords.includes("extend"), "expected LINE_KEYWORDS from text contract");
+  assert(commands.lineKeywords.includes("global"), "expected LINE_KEYWORDS from vars contract");
+  assert(commands.lineKeywords.includes("dangerous"), "expected LINE_KEYWORDS from layer animation contract");
+  assert(commands.lineKeywords.includes("qte-fallback"), "expected LINE_KEYWORDS from qte contract");
 
   const ranges = collectCommandTokenRanges(
-    ['  $ stack jump testsCanvas', '  "hi" | async global', '  $ scenario goto loop'].join("\n"),
+    [
+      "  $ stack jump testsCanvas",
+      '  "hi" | async global',
+      "  $ scenario goto loop",
+      "  $ save key autosave",
+      "  $ bl.bg show forest",
+      "  $ audio.music play theme",
+      "  $ text.meet alice",
+      "  $ ul.sprite show co center",
+      "  $ flag quest unset",
+      "  $ counter gold += 2",
+      "  $ bl.bg show {castle/surgery_room} opacity 500 | async",
+      "  $ ul.sprite show co left {co/default} opacity 500",
+      "  $ ul.sprite hide co opacity 300",
+    ].join("\n"),
     commands,
   );
 
@@ -53,6 +99,78 @@ const main = async () => {
     ranges.some((range) => range.type === "keyword" && range.line === 2),
     "expected keyword token on scenario goto",
   );
+  assert(
+    ranges.some((range) => range.type === "keyword" && range.line === 3),
+    "expected keyword token on save key",
+  );
+  assert(
+    ranges.some((range) => range.type === "keyword" && range.line === 4),
+    "expected keyword token on bl.bg show",
+  );
+  assert(
+    ranges.some((range) => range.type === "keyword" && range.line === 5),
+    "expected keyword token on audio.music play",
+  );
+  assert(
+    ranges.some((range) => range.type === "function" && range.line === 6),
+    "expected function token for text.meet speaker",
+  );
+  assert(
+    ranges.some((range) => range.type === "keyword" && range.line === 7 && range.length === "show".length),
+    "expected keyword token on ul.sprite show",
+  );
+  assert(
+    ranges.some((range) => range.type === "function" && range.line === 7),
+    "expected function token for sprite name",
+  );
+  assert(
+    ranges.some((range) => range.type === "keyword" && range.line === 7 && range.length === "center".length),
+    "expected keyword token for sprite position",
+  );
+  assert(
+    ranges.some((range) => range.type === "function" && range.line === 8),
+    "expected function token for flag name",
+  );
+  assert(
+    ranges.some((range) => range.type === "keyword" && range.line === 8 && range.length === "unset".length),
+    "expected keyword token for flag unset",
+  );
+  assert(
+    ranges.some((range) => range.type === "function" && range.line === 9),
+    "expected function token for counter name",
+  );
+  assert(
+    ranges.some((range) => range.type === "keyword" && range.line === 9 && range.length === "+=".length),
+    "expected keyword token for counter +=",
+  );
+  assert(
+    ranges.some((range) => range.type === "function" && range.line === 10 && range.length === "{castle/surgery_room}".length),
+    "expected function token for braced bg media ref",
+  );
+  assert(
+    ranges.some((range) => range.type === "keyword" && range.line === 10 && range.length === "opacity".length),
+    "expected keyword token for bg opacity transition",
+  );
+  assert(
+    ranges.some((range) => range.type === "number" && range.line === 10 && range.length === "500".length),
+    "expected number token for bg duration",
+  );
+  assert(
+    ranges.some((range) => range.type === "function" && range.line === 11 && range.length === "{co/default}".length),
+    "expected function token for braced sprite variation",
+  );
+  assert(
+    ranges.some((range) => range.type === "keyword" && range.line === 11 && range.length === "opacity".length),
+    "expected keyword token for sprite show opacity",
+  );
+  assert(
+    ranges.some((range) => range.type === "keyword" && range.line === 12 && range.length === "opacity".length),
+    "expected keyword token for sprite hide opacity",
+  );
+  assert(
+    ranges.some((range) => range.type === "number" && range.line === 12 && range.length === "300".length),
+    "expected number token for sprite hide duration",
+  );
 
   console.log("ok", {
     gameRoot,

package/syntaxes/base.json

@@ -61,157 +61,9 @@
       "name": "variable.other",
       "match": "(?<=\\s)[a-zA-Z0-9_-]+:(?=\\s|$)"
     },
-    {
-      "name": "variable.other",
-      "match": "(?<=\\b(counter|flag)\\s+)[a-zA-Z0-9_-]+"
-    },
     {
       "name": "keyword.other",
       "match": "(?<=^\\s*)[a-zA-Z0-9_-]+(?=\\s+\")"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.sprite\\s)(show|hide|change|move)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.bg\\s)(show|hide|change)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.video\\s)(show|hide|change)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.text\\s)(show|hide|change|move)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.filter\\s)(set|unset)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.clip\\s)(set|unset)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.mask\\s)(set|unset|change)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.scale\\s)(set|unset)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.animation\\s)(set|unset)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\baudio\\.(music|sound|ambient|voice)\\s)(play|stop|pause|resume|volume)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bvideo\\s)play\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\binterface\\s)(show|hide|view)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bsave\\s)key\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bflag\\s+[a-zA-Z0-9_-]+\\s)(set|unset)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\btime\\s+)(add|set)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bdate\\s+)(add|set)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\btext\\.wall\\s+)(clear|start|end)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\btext\\.meet\\s+)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bcomment\\s+)hide\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bachievement\\s+)unlock\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bwallet\\s+[a-zA-Z0-9_-]+\\s)(add|set|reset)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bcredits\\s+)(show|hide)\\b"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\bachievement\\s+unlock\\s+)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\bwallet\\s+)[a-zA-Z0-9_-]+(?=\\s+(add|set|reset))"
-    },
-    {
-      "name": "entity.name.type",
-      "match": "(?<=\\binterface\\s+view\\s+)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.bg\\sshow\\s\\{[^}]*\\}\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.bg\\shide\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.sprite\\sshow\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.sprite\\s(hide|change|move)\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.video\\s(show|change)\\s)[a-zA-Z0-9_{}/-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.text\\s(show|hide|change|move)\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.filter\\sset\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.clip\\sset\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.mask\\sset\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.animation\\sset\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "keyword.other",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.sprite\\s(show|hide|change|move)\\s[a-zA-Z0-9_-]+\\s)[a-zA-Z0-9_-]+"
     }
   ],
   "repository": {},

package/syntaxes/vne.json

@@ -61,161 +61,9 @@
       "name": "variable.other",
       "match": "(?<=\\s)[a-zA-Z0-9_-]+:(?=\\s|$)"
     },
-    {
-      "name": "variable.other",
-      "match": "(?<=\\b(counter|flag)\\s+)[a-zA-Z0-9_-]+"
-    },
     {
       "name": "keyword.other",
       "match": "(?<=^\\s*)[a-zA-Z0-9_-]+(?=\\s+\")"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.sprite\\s)(show|hide|change|move)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.bg\\s)(show|hide|change)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.video\\s)(show|hide|change)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.text\\s)(show|hide|change|move)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.filter\\s)(set|unset)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.clip\\s)(set|unset)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.mask\\s)(set|unset|change)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.scale\\s)(set|unset)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.animation\\s)(set|unset)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\baudio\\.(music|sound|ambient|voice)\\s)(play|stop|pause|resume|volume)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bvideo\\s)play\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\binterface\\s)(show|hide|view)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bsave\\s)key\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bflag\\s+[a-zA-Z0-9_-]+\\s)(set|unset)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\btime\\s+)(add|set)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bdate\\s+)(add|set)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\btext\\.wall\\s+)(clear|start|end)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\btext\\.meet\\s+)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bcomment\\s+)hide\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bachievement\\s+)unlock\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bwallet\\s+[a-zA-Z0-9_-]+\\s)(add|set|reset)\\b"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\bcredits\\s+)(show|hide)\\b"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\bachievement\\s+unlock\\s+)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\bwallet\\s+)[a-zA-Z0-9_-]+(?=\\s+(add|set|reset))"
-    },
-    {
-      "name": "entity.name.type",
-      "match": "(?<=\\binterface\\s+view\\s+)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.bg\\sshow\\s\\{[^}]*\\}\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.bg\\shide\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.sprite\\sshow\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.sprite\\s(hide|change|move)\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.video\\s(show|change)\\s)[a-zA-Z0-9_{}/-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.text\\s(show|hide|change|move)\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.filter\\sset\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.clip\\sset\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.mask\\sset\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "entity.name.function",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.animation\\sset\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "keyword.other",
-      "match": "(?<=\\b(bl|ml|fl|ul)\\.sprite\\s(show|hide|change|move)\\s[a-zA-Z0-9_-]+\\s)[a-zA-Z0-9_-]+"
-    },
-    {
-      "name": "keyword.control",
-      "match": "(?<=\\s\\|\\s.*)(global|skip-if-possible|async|extend|autonext|dangerous)(?=\\s|$)"
     }
   ],
   "repository": {},