@flanksource/clicky-ui 0.3.34 → 0.3.35

package/dist/expressions/lang/hover.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hover.js","sources":["../../../src/expressions/lang/hover.ts"],"sourcesContent":["import type { GomplateSpec, Monaco, SpecFunction, SpecMacro } from \"./types\";\n\n/**\n * Indexes are built per registration, not once per module.\n *\n * A host's catalogue arrives from its `/api/spec` after the editor has already\n * mounted, so anything computed at module scope is frozen before the host can\n * speak. `setSpec` re-registers with a fresh index instead.\n */\nexport function registerCelHover(monaco: Monaco, languageId: string, spec: GomplateSpec) {\n  return monaco.languages.registerHoverProvider(languageId, celHoverProvider(spec));\n}\n\nexport function registerGoTemplateHover(monaco: Monaco, languageId: string, spec: GomplateSpec) {\n  return monaco.languages.registerHoverProvider(languageId, goTemplateHoverProvider(spec));\n}\n\n/**\n * The providers the register functions install, exposed so a test can drive\n * them over a real model rather than through Monaco's registry, which offers no\n * way to enumerate what is registered.\n */\nexport function celHoverProvider(spec: GomplateSpec) {\n  const functions = new Map<string, SpecFunction>(spec.cel.functions.map((f) => [f.name, f]));\n  const macrosByName = new Map<string, SpecMacro[]>();\n  for (const macro of spec.cel.macros) {\n    macrosByName.set(macro.name, [...(macrosByName.get(macro.name) ?? []), macro]);\n  }\n\n  return {\n    provideHover(model: Model, position: Position) {\n      const word = dottedWordAt(model, position);\n      if (!word) return null;\n\n      const fn = functions.get(word.text) ?? functions.get(word.leaf);\n      if (fn) return { range: word.range, contents: [{ value: functionDocumentation(fn) }] };\n\n      const macros = macrosByName.get(word.leaf);\n      if (macros) {\n        return {\n          range: word.range,\n          contents: macros.map((macro) => ({ value: macroDocumentation(macro) })),\n        };\n      }\n      return null;\n    },\n  };\n}\n\nexport function goTemplateHoverProvider(spec: GomplateSpec) {\n  const functions = new Map<string, SpecFunction>(\n    spec.gotemplate.functions.map((f) => [f.name, f]),\n  );\n\n  return {\n    provideHover(model: Model, position: Position) {\n      const word = dottedWordAt(model, position);\n      const fn = word && functions.get(word.text);\n      if (!fn || !word) return null;\n      return { range: word.range, contents: [{ value: functionDocumentation(fn) }] };\n    },\n  };\n}\n\n/** Renders a function as markdown: signature, overloads, docs, examples. */\nexport function functionDocumentation(fn: SpecFunction): string {\n  const lines: string[] = [];\n  lines.push(\"```\", fn.signature ? `${fn.name}${fn.signature}` : fn.name, \"```\");\n\n  if (fn.memberOnly) {\n    lines.push(\"\", \"_Callable only in member position: `value.\" + leafOf(fn.name) + \"(...)`._\");\n  }\n  if (fn.doc) lines.push(\"\", fn.doc);\n\n  if (fn.overloads?.length) {\n    lines.push(\"\", \"**Overloads**\", \"\");\n    for (const overload of fn.overloads) {\n      const receiver = overload.member && overload.args.length > 0 ? `${overload.args[0]}.` : \"\";\n      const args = overload.member ? overload.args.slice(1) : overload.args;\n      lines.push(`- \\`${receiver}${leafOf(fn.name)}(${args.join(\", \")}) -> ${overload.result}\\``);\n    }\n  }\n  if (fn.examples?.length) {\n    lines.push(\"\", \"**Examples**\", \"\", \"```cel\", ...fn.examples, \"```\");\n  }\n  return lines.join(\"\\n\");\n}\n\n/** Renders a macro as markdown. */\nexport function macroDocumentation(macro: SpecMacro): string {\n  const shape = macro.receiverStyle ? `value.${macro.name}(...)` : `${macro.name}(...)`;\n  const arity = macro.argCount === 0 ? \"variadic\" : `${macro.argCount} arguments`;\n  const lines = [\"```\", shape, \"```\", \"\", `_Macro, ${arity}. Expanded at parse time._`];\n  if (macro.doc) lines.push(\"\", macro.doc);\n  if (macro.examples?.length) lines.push(\"\", \"```cel\", ...macro.examples, \"```\");\n  return lines.join(\"\\n\");\n}\n\nfunction leafOf(name: string) {\n  const dot = name.lastIndexOf(\".\");\n  return dot < 0 ? name : name.slice(dot + 1);\n}\n\ninterface Model {\n  getLineContent(line: number): string;\n}\n\ninterface Position {\n  lineNumber: number;\n  column: number;\n}\n\n/**\n * Monaco's own word lookup stops at a dot, so `k8s.isHealthy` would be read as\n * `isHealthy`. The dotted name is what the spec is keyed by, so widen it here.\n */\nfunction dottedWordAt(model: Model, position: Position) {\n  const line = model.getLineContent(position.lineNumber);\n  const isWord = (c: string) => /[A-Za-z0-9_.]/.test(c);\n\n  let start = position.column - 1;\n  while (start > 0 && isWord(line[start - 1]!)) start--;\n  let end = position.column - 1;\n  while (end < line.length && isWord(line[end]!)) end++;\n  if (start === end) return null;\n\n  const text = line.slice(start, end).replace(/^\\.+|\\.+$/g, \"\");\n  if (!text) return null;\n\n  return {\n    text,\n    leaf: leafOf(text),\n    range: {\n      startLineNumber: position.lineNumber,\n      endLineNumber: position.lineNumber,\n      startColumn: start + 1,\n      endColumn: end + 1,\n    },\n  };\n}\n"],"names":[],"mappings":"AASO,SAAS,iBAAiB,QAAgB,YAAoB,MAAoB;AACvF,SAAO,OAAO,UAAU,sBAAsB,YAAY,iBAAiB,IAAI,CAAC;AAClF;AAEO,SAAS,wBAAwB,QAAgB,YAAoB,MAAoB;AAC9F,SAAO,OAAO,UAAU,sBAAsB,YAAY,wBAAwB,IAAI,CAAC;AACzF;AAOO,SAAS,iBAAiB,MAAoB;AACnD,QAAM,YAAY,IAAI,IAA0B,KAAK,IAAI,UAAU,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AAC1F,QAAM,mCAAmB,IAAA;AACzB,aAAW,SAAS,KAAK,IAAI,QAAQ;AACnC,iBAAa,IAAI,MAAM,MAAM,CAAC,GAAI,aAAa,IAAI,MAAM,IAAI,KAAK,CAAA,GAAK,KAAK,CAAC;AAAA,EAC/E;AAEA,SAAO;AAAA,IACL,aAAa,OAAc,UAAoB;AAC7C,YAAM,OAAO,aAAa,OAAO,QAAQ;AACzC,UAAI,CAAC,KAAM,QAAO;AAElB,YAAM,KAAK,UAAU,IAAI,KAAK,IAAI,KAAK,UAAU,IAAI,KAAK,IAAI;AAC9D,UAAI,GAAI,QAAO,EAAE,OAAO,KAAK,OAAO,UAAU,CAAC,EAAE,OAAO,sBAAsB,EAAE,EAAA,CAAG,EAAA;AAEnF,YAAM,SAAS,aAAa,IAAI,KAAK,IAAI;AACzC,UAAI,QAAQ;AACV,eAAO;AAAA,UACL,OAAO,KAAK;AAAA,UACZ,UAAU,OAAO,IAAI,CAAC,WAAW,EAAE,OAAO,mBAAmB,KAAK,IAAI;AAAA,QAAA;AAAA,MAE1E;AACA,aAAO;AAAA,IACT;AAAA,EAAA;AAEJ;AAEO,SAAS,wBAAwB,MAAoB;AAC1D,QAAM,YAAY,IAAI;AAAA,IACpB,KAAK,WAAW,UAAU,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;AAAA,EAAA;AAGlD,SAAO;AAAA,IACL,aAAa,OAAc,UAAoB;AAC7C,YAAM,OAAO,aAAa,OAAO,QAAQ;AACzC,YAAM,KAAK,QAAQ,UAAU,IAAI,KAAK,IAAI;AAC1C,UAAI,CAAC,MAAM,CAAC,KAAM,QAAO;AACzB,aAAO,EAAE,OAAO,KAAK,OAAO,UAAU,CAAC,EAAE,OAAO,sBAAsB,EAAE,EAAA,CAAG,EAAA;AAAA,IAC7E;AAAA,EAAA;AAEJ;AAGO,SAAS,sBAAsB,IAA0B;AAxDzD;AAyDL,QAAM,QAAkB,CAAA;AACxB,QAAM,KAAK,OAAO,GAAG,YAAY,GAAG,GAAG,IAAI,GAAG,GAAG,SAAS,KAAK,GAAG,MAAM,KAAK;AAE7E,MAAI,GAAG,YAAY;AACjB,UAAM,KAAK,IAAI,+CAA+C,OAAO,GAAG,IAAI,IAAI,UAAU;AAAA,EAC5F;AACA,MAAI,GAAG,IAAK,OAAM,KAAK,IAAI,GAAG,GAAG;AAEjC,OAAI,QAAG,cAAH,mBAAc,QAAQ;AACxB,UAAM,KAAK,IAAI,iBAAiB,EAAE;AAClC,eAAW,YAAY,GAAG,WAAW;AACnC,YAAM,WAAW,SAAS,UAAU,SAAS,KAAK,SAAS,IAAI,GAAG,SAAS,KAAK,CAAC,CAAC,MAAM;AACxF,YAAM,OAAO,SAAS,SAAS,SAAS,KAAK,MAAM,CAAC,IAAI,SAAS;AACjE,YAAM,KAAK,OAAO,QAAQ,GAAG,OAAO,GAAG,IAAI,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC,QAAQ,SAAS,MAAM,IAAI;AAAA,IAC5F;AAAA,EACF;AACA,OAAI,QAAG,aAAH,mBAAa,QAAQ;AACvB,UAAM,KAAK,IAAI,gBAAgB,IAAI,UAAU,GAAG,GAAG,UAAU,KAAK;AAAA,EACpE;AACA,SAAO,MAAM,KAAK,IAAI;AACxB;AAGO,SAAS,mBAAmB,OAA0B;AAhFtD;AAiFL,QAAM,QAAQ,MAAM,gBAAgB,SAAS,MAAM,IAAI,UAAU,GAAG,MAAM,IAAI;AAC9E,QAAM,QAAQ,MAAM,aAAa,IAAI,aAAa,GAAG,MAAM,QAAQ;AACnE,QAAM,QAAQ,CAAC,OAAO,OAAO,OAAO,IAAI,WAAW,KAAK,4BAA4B;AACpF,MAAI,MAAM,IAAK,OAAM,KAAK,IAAI,MAAM,GAAG;AACvC,OAAI,WAAM,aAAN,mBAAgB,OAAQ,OAAM,KAAK,IAAI,UAAU,GAAG,MAAM,UAAU,KAAK;AAC7E,SAAO,MAAM,KAAK,IAAI;AACxB;AAEA,SAAS,OAAO,MAAc;AAC5B,QAAM,MAAM,KAAK,YAAY,GAAG;AAChC,SAAO,MAAM,IAAI,OAAO,KAAK,MAAM,MAAM,CAAC;AAC5C;AAeA,SAAS,aAAa,OAAc,UAAoB;AACtD,QAAM,OAAO,MAAM,eAAe,SAAS,UAAU;AACrD,QAAM,SAAS,CAAC,MAAc,gBAAgB,KAAK,CAAC;AAEpD,MAAI,QAAQ,SAAS,SAAS;AAC9B,SAAO,QAAQ,KAAK,OAAO,KAAK,QAAQ,CAAC,CAAE,EAAG;AAC9C,MAAI,MAAM,SAAS,SAAS;AAC5B,SAAO,MAAM,KAAK,UAAU,OAAO,KAAK,GAAG,CAAE,EAAG;AAChD,MAAI,UAAU,IAAK,QAAO;AAE1B,QAAM,OAAO,KAAK,MAAM,OAAO,GAAG,EAAE,QAAQ,cAAc,EAAE;AAC5D,MAAI,CAAC,KAAM,QAAO;AAElB,SAAO;AAAA,IACL;AAAA,IACA,MAAM,OAAO,IAAI;AAAA,IACjB,OAAO;AAAA,MACL,iBAAiB,SAAS;AAAA,MAC1B,eAAe,SAAS;AAAA,MACxB,aAAa,QAAQ;AAAA,MACrB,WAAW,MAAM;AAAA,IAAA;AAAA,EACnB;AAEJ;"}

package/dist/expressions/lang/index.cjs

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("./generated/index.cjs");
+const completion = require("./completion.cjs");
+const hover = require("./hover.cjs");
+const environment = require("./environment.cjs");
+const attributes = require("./attributes.cjs");
+const merge = require("./merge.cjs");
+const theme = require("./theme.cjs");
+function registerGomplateLanguages(monaco, options = {}) {
+  const { languages = index.LANGUAGE_IDS, completions = true, hovers = true, themes = true } = options;
+  if (themes) theme.defineThemes(monaco);
+  const known = new Set(monaco.languages.getLanguages().map((l) => l.id));
+  const selected = [];
+  for (const id of languages) {
+    const definition = index.definitions[id];
+    if (!definition) {
+      throw new Error(
+        `unknown gomplate language "${id}"; expected one of ${index.LANGUAGE_IDS.join(", ")}`
+      );
+    }
+    selected.push(id);
+    if (known.has(id)) continue;
+    monaco.languages.register({ id });
+    monaco.languages.setLanguageConfiguration(id, definition.configuration);
+  }
+  const applySpec = (merged) => {
+    for (const id of selected) {
+      const definition = index.definitions[id];
+      const attributes$1 = attributes.attributesFor(id, merged);
+      monaco.languages.setMonarchTokensProvider(
+        id,
+        attributes$1 ? { ...definition.monarch, ...attributes$1 } : definition.monarch
+      );
+      const flavour = environment.pathFlavour(id);
+      const installed = [];
+      if (completions) {
+        installed.push(
+          completion.registerCompletion(monaco, id, { spec: merged, environment: options.environment })
+        );
+      }
+      if (hovers && flavour === "cel") installed.push(hover.registerCelHover(monaco, id, merged));
+      if (hovers && flavour === "gotemplate") {
+        installed.push(hover.registerGoTemplateHover(monaco, id, merged));
+      }
+      replaceProviders(monaco, id, installed);
+    }
+  };
+  applySpec(merge.mergeSpec(index.spec, options.spec));
+  return {
+    setSpec(next) {
+      applySpec(merge.mergeSpec(index.spec, next));
+    },
+    dispose() {
+      for (const id of selected) replaceProviders(monaco, id, []);
+    }
+  };
+}
+const providersByLanguage = /* @__PURE__ */ new WeakMap();
+function replaceProviders(monaco, id, installed) {
+  let byLanguage = providersByLanguage.get(monaco);
+  if (!byLanguage) {
+    byLanguage = /* @__PURE__ */ new Map();
+    providersByLanguage.set(monaco, byLanguage);
+  }
+  for (const disposable of byLanguage.get(id) ?? []) disposable.dispose();
+  if (installed.length === 0) byLanguage.delete(id);
+  else byLanguage.set(id, installed);
+}
+exports.LANGUAGE_IDS = index.LANGUAGE_IDS;
+exports.definitions = index.definitions;
+exports.spec = index.spec;
+exports.childEntries = environment.childEntries;
+exports.isIdentifier = environment.isIdentifier;
+exports.kindOf = environment.kindOf;
+exports.pathExpression = environment.pathExpression;
+exports.pathFlavour = environment.pathFlavour;
+exports.resolvePath = environment.resolvePath;
+exports.summarize = environment.summarize;
+exports.attributesFor = attributes.attributesFor;
+exports.celAttributes = attributes.celAttributes;
+exports.goTemplateAttributes = attributes.goTemplateAttributes;
+exports.mergeSpec = merge.mergeSpec;
+exports.GOMPLATE_DARK_THEME = theme.GOMPLATE_DARK_THEME;
+exports.GOMPLATE_LIGHT_THEME = theme.GOMPLATE_LIGHT_THEME;
+exports.registerGomplateLanguages = registerGomplateLanguages;
+//# sourceMappingURL=index.cjs.map

package/dist/expressions/lang/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../../src/expressions/lang/index.ts"],"sourcesContent":["import { LANGUAGE_IDS, definitions, spec } from \"./generated\";\nimport type { LanguageId } from \"./generated\";\nimport { registerCompletion } from \"./completion\";\nimport type { EnvironmentSource } from \"./completion\";\nimport { registerCelHover, registerGoTemplateHover } from \"./hover\";\nimport { pathFlavour } from \"./environment\";\nimport { attributesFor } from \"./attributes\";\nimport { mergeSpec } from \"./merge\";\nimport { defineThemes } from \"./theme\";\nimport type { GomplateSpec, LanguageDefinition, Monaco } from \"./types\";\n\nexport { spec, LANGUAGE_IDS, definitions };\nexport type { LanguageId };\nexport * from \"./types\";\nexport { GOMPLATE_DARK_THEME, GOMPLATE_LIGHT_THEME } from \"./theme\";\nexport {\n  childEntries,\n  isIdentifier,\n  kindOf,\n  pathExpression,\n  pathFlavour,\n  resolvePath,\n  summarize,\n} from \"./environment\";\nexport type { EnvironmentEntry, PathSegment, ValueKind } from \"./environment\";\nexport { environmentPrefixAt } from \"./prefix\";\nexport type { EnvironmentPrefix } from \"./prefix\";\nexport type { EnvironmentSource } from \"./completion\";\nexport { mergeSpec } from \"./merge\";\nexport { attributesFor, celAttributes, goTemplateAttributes } from \"./attributes\";\nexport type { Attributes } from \"./attributes\";\n\nexport interface RegisterOptions {\n  /** Which languages to register. Defaults to all of them. */\n  languages?: readonly LanguageId[];\n  /** Register completion providers. Defaults to true. */\n  completions?: boolean;\n  /** Register hover providers. Defaults to true. */\n  hovers?: boolean;\n  /** Define the gomplate colour themes. Defaults to true. */\n  themes?: boolean;\n  /**\n   * The document expressions are evaluated against, so completion can offer the\n   * key paths it actually contains.\n   *\n   * A getter rather than a value: registration happens once, before the first\n   * editor mounts, while the document keeps being edited afterwards. It is\n   * called on every completion request.\n   */\n  environment?: EnvironmentSource;\n  /**\n   * A host's own catalogue, merged over gomplate's.\n   *\n   * Usually left unset here and supplied later through `setSpec`, because it\n   * arrives from the host's `GET /api/spec` after the editor has mounted.\n   */\n  spec?: GomplateSpec;\n}\n\n/** What `registerGomplateLanguages` hands back. */\nexport interface RegisteredLanguages {\n  /**\n   * Replaces the catalogue and re-applies it.\n   *\n   * Registration has to happen in `beforeMount`, before the first model exists,\n   * while a host's spec arrives over the network afterwards — so gating\n   * registration on the fetch would stall the editor. Register with the baked\n   * catalogue instead and call this when the response lands: the tokenizers are\n   * re-applied with the merged word lists, and completion and hover are\n   * re-registered against the merged functions.\n   */\n  setSpec(spec: GomplateSpec | undefined): void;\n  dispose(): void;\n}\n\n/**\n * Registers gomplate's languages with a Monaco instance.\n *\n * Safe to call more than once: a language already registered is left alone, so\n * a component tree with several editors does not need to coordinate. The\n * returned handle removes only the providers this call added.\n */\nexport function registerGomplateLanguages(\n  monaco: Monaco,\n  options: RegisterOptions = {},\n): RegisteredLanguages {\n  const { languages = LANGUAGE_IDS, completions = true, hovers = true, themes = true } = options;\n\n  if (themes) defineThemes(monaco);\n\n  const known = new Set(monaco.languages.getLanguages().map((l) => l.id));\n  const selected: LanguageId[] = [];\n\n  for (const id of languages) {\n    const definition: LanguageDefinition | undefined = definitions[id];\n    if (!definition) {\n      throw new Error(\n        `unknown gomplate language \"${id}\"; expected one of ${LANGUAGE_IDS.join(\", \")}`,\n      );\n    }\n    selected.push(id);\n\n    // Only the registration itself is once-only. The tokenizer and the\n    // providers are re-applied below for every selected language, whether or\n    // not this call is the one that introduced it -- otherwise a second editor\n    // would get a handle whose setSpec silently does nothing.\n    if (known.has(id)) continue;\n    monaco.languages.register({ id });\n    monaco.languages.setLanguageConfiguration(id, definition.configuration);\n  }\n\n  const applySpec = (merged: GomplateSpec) => {\n    for (const id of selected) {\n      const definition = definitions[id]!;\n      const attributes = attributesFor(id, merged);\n      // Spread over the generated definition rather than replacing it: the\n      // tokenizer rules and the grammar-derived lists (CEL's `operators`) are\n      // not the spec's to change.\n      monaco.languages.setMonarchTokensProvider(\n        id,\n        attributes ? { ...definition.monarch, ...attributes } : definition.monarch,\n      );\n\n      const flavour = pathFlavour(id);\n      const installed: { dispose(): void }[] = [];\n      if (completions) {\n        installed.push(\n          registerCompletion(monaco, id, { spec: merged, environment: options.environment }),\n        );\n      }\n      if (hovers && flavour === \"cel\") installed.push(registerCelHover(monaco, id, merged));\n      if (hovers && flavour === \"gotemplate\") {\n        installed.push(registerGoTemplateHover(monaco, id, merged));\n      }\n      replaceProviders(monaco, id, installed);\n    }\n  };\n\n  applySpec(mergeSpec(spec, options.spec));\n\n  return {\n    setSpec(next) {\n      applySpec(mergeSpec(spec, next));\n    },\n    dispose() {\n      for (const id of selected) replaceProviders(monaco, id, []);\n    },\n  };\n}\n\n/**\n * One set of completion and hover providers per language, per Monaco.\n *\n * Monaco stacks providers rather than replacing them, so registering twice for\n * a language shows every suggestion twice. Tracking them here means the latest\n * registration wins instead, and a component tree with several editors does not\n * have to coordinate.\n */\nconst providersByLanguage = new WeakMap<Monaco, Map<string, { dispose(): void }[]>>();\n\nfunction replaceProviders(monaco: Monaco, id: string, installed: { dispose(): void }[]) {\n  let byLanguage = providersByLanguage.get(monaco);\n  if (!byLanguage) {\n    byLanguage = new Map();\n    providersByLanguage.set(monaco, byLanguage);\n  }\n  for (const disposable of byLanguage.get(id) ?? []) disposable.dispose();\n  if (installed.length === 0) byLanguage.delete(id);\n  else byLanguage.set(id, installed);\n}\n"],"names":["LANGUAGE_IDS","definitions","attributes","attributesFor","pathFlavour","registerCompletion","registerCelHover","registerGoTemplateHover","mergeSpec","spec"],"mappings":";;;;;;;;;AAkFO,SAAS,0BACd,QACA,UAA2B,IACN;AACrB,QAAM,EAAE,YAAYA,MAAAA,cAAc,cAAc,MAAM,SAAS,MAAM,SAAS,KAAA,IAAS;AAEvF,MAAI,2BAAqB,MAAM;AAE/B,QAAM,QAAQ,IAAI,IAAI,OAAO,UAAU,eAAe,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;AACtE,QAAM,WAAyB,CAAA;AAE/B,aAAW,MAAM,WAAW;AAC1B,UAAM,aAA6CC,MAAAA,YAAY,EAAE;AACjE,QAAI,CAAC,YAAY;AACf,YAAM,IAAI;AAAA,QACR,8BAA8B,EAAE,sBAAsBD,MAAAA,aAAa,KAAK,IAAI,CAAC;AAAA,MAAA;AAAA,IAEjF;AACA,aAAS,KAAK,EAAE;AAMhB,QAAI,MAAM,IAAI,EAAE,EAAG;AACnB,WAAO,UAAU,SAAS,EAAE,GAAA,CAAI;AAChC,WAAO,UAAU,yBAAyB,IAAI,WAAW,aAAa;AAAA,EACxE;AAEA,QAAM,YAAY,CAAC,WAAyB;AAC1C,eAAW,MAAM,UAAU;AACzB,YAAM,aAAaC,MAAAA,YAAY,EAAE;AACjC,YAAMC,eAAaC,WAAAA,cAAc,IAAI,MAAM;AAI3C,aAAO,UAAU;AAAA,QACf;AAAA,QACAD,eAAa,EAAE,GAAG,WAAW,SAAS,GAAGA,aAAA,IAAe,WAAW;AAAA,MAAA;AAGrE,YAAM,UAAUE,YAAAA,YAAY,EAAE;AAC9B,YAAM,YAAmC,CAAA;AACzC,UAAI,aAAa;AACf,kBAAU;AAAA,UACRC,8BAAmB,QAAQ,IAAI,EAAE,MAAM,QAAQ,aAAa,QAAQ,YAAA,CAAa;AAAA,QAAA;AAAA,MAErF;AACA,UAAI,UAAU,YAAY,MAAO,WAAU,KAAKC,MAAAA,iBAAiB,QAAQ,IAAI,MAAM,CAAC;AACpF,UAAI,UAAU,YAAY,cAAc;AACtC,kBAAU,KAAKC,MAAAA,wBAAwB,QAAQ,IAAI,MAAM,CAAC;AAAA,MAC5D;AACA,uBAAiB,QAAQ,IAAI,SAAS;AAAA,IACxC;AAAA,EACF;AAEA,YAAUC,MAAAA,UAAUC,MAAAA,MAAM,QAAQ,IAAI,CAAC;AAEvC,SAAO;AAAA,IACL,QAAQ,MAAM;AACZ,gBAAUD,MAAAA,UAAUC,YAAM,IAAI,CAAC;AAAA,IACjC;AAAA,IACA,UAAU;AACR,iBAAW,MAAM,SAAU,kBAAiB,QAAQ,IAAI,EAAE;AAAA,IAC5D;AAAA,EAAA;AAEJ;AAUA,MAAM,0CAA0B,QAAA;AAEhC,SAAS,iBAAiB,QAAgB,IAAY,WAAkC;AACtF,MAAI,aAAa,oBAAoB,IAAI,MAAM;AAC/C,MAAI,CAAC,YAAY;AACf,qCAAiB,IAAA;AACjB,wBAAoB,IAAI,QAAQ,UAAU;AAAA,EAC5C;AACA,aAAW,cAAc,WAAW,IAAI,EAAE,KAAK,CAAA,cAAe,QAAA;AAC9D,MAAI,UAAU,WAAW,EAAG,YAAW,OAAO,EAAE;AAAA,MAC3C,YAAW,IAAI,IAAI,SAAS;AACnC;;;;;;;;;;;;;;;;;;"}

package/dist/expressions/lang/index.d.ts

@@ -0,0 +1,65 @@
+import { LANGUAGE_IDS, definitions, spec, LanguageId } from './generated';
+import { EnvironmentSource } from './completion';
+import { GomplateSpec, Monaco } from './types';
+export { spec, LANGUAGE_IDS, definitions };
+export type { LanguageId };
+export * from './types';
+export { GOMPLATE_DARK_THEME, GOMPLATE_LIGHT_THEME } from './theme';
+export { childEntries, isIdentifier, kindOf, pathExpression, pathFlavour, resolvePath, summarize, } from './environment';
+export type { EnvironmentEntry, PathSegment, ValueKind } from './environment';
+export { environmentPrefixAt } from './prefix';
+export type { EnvironmentPrefix } from './prefix';
+export type { EnvironmentSource } from './completion';
+export { mergeSpec } from './merge';
+export { attributesFor, celAttributes, goTemplateAttributes } from './attributes';
+export type { Attributes } from './attributes';
+export interface RegisterOptions {
+    /** Which languages to register. Defaults to all of them. */
+    languages?: readonly LanguageId[];
+    /** Register completion providers. Defaults to true. */
+    completions?: boolean;
+    /** Register hover providers. Defaults to true. */
+    hovers?: boolean;
+    /** Define the gomplate colour themes. Defaults to true. */
+    themes?: boolean;
+    /**
+     * The document expressions are evaluated against, so completion can offer the
+     * key paths it actually contains.
+     *
+     * A getter rather than a value: registration happens once, before the first
+     * editor mounts, while the document keeps being edited afterwards. It is
+     * called on every completion request.
+     */
+    environment?: EnvironmentSource;
+    /**
+     * A host's own catalogue, merged over gomplate's.
+     *
+     * Usually left unset here and supplied later through `setSpec`, because it
+     * arrives from the host's `GET /api/spec` after the editor has mounted.
+     */
+    spec?: GomplateSpec;
+}
+/** What `registerGomplateLanguages` hands back. */
+export interface RegisteredLanguages {
+    /**
+     * Replaces the catalogue and re-applies it.
+     *
+     * Registration has to happen in `beforeMount`, before the first model exists,
+     * while a host's spec arrives over the network afterwards — so gating
+     * registration on the fetch would stall the editor. Register with the baked
+     * catalogue instead and call this when the response lands: the tokenizers are
+     * re-applied with the merged word lists, and completion and hover are
+     * re-registered against the merged functions.
+     */
+    setSpec(spec: GomplateSpec | undefined): void;
+    dispose(): void;
+}
+/**
+ * Registers gomplate's languages with a Monaco instance.
+ *
+ * Safe to call more than once: a language already registered is left alone, so
+ * a component tree with several editors does not need to coordinate. The
+ * returned handle removes only the providers this call added.
+ */
+export declare function registerGomplateLanguages(monaco: Monaco, options?: RegisterOptions): RegisteredLanguages;
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/lang/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/expressions/lang/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAMtD,OAAO,KAAK,EAAE,YAAY,EAAsB,MAAM,EAAE,MAAM,SAAS,CAAC;AAExE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,WAAW,EAAE,CAAC;AAC3C,YAAY,EAAE,UAAU,EAAE,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,MAAM,EACN,cAAc,EACd,WAAW,EACX,WAAW,EACX,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAC/C,YAAY,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAClF,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,WAAW,eAAe;IAC9B,4DAA4D;IAC5D,SAAS,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAClC,uDAAuD;IACvD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,kDAAkD;IAClD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC;;;;;OAKG;IACH,IAAI,CAAC,EAAE,YAAY,CAAC;CACrB;AAED,mDAAmD;AACnD,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;OASG;IACH,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI,CAAC;IAC9C,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,eAAoB,GAC5B,mBAAmB,CA+DrB"}

package/dist/expressions/lang/index.js

@@ -0,0 +1,90 @@
+import { LANGUAGE_IDS, definitions, spec } from "./generated/index.js";
+import { registerCompletion } from "./completion.js";
+import { registerCelHover, registerGoTemplateHover } from "./hover.js";
+import { pathFlavour } from "./environment.js";
+import { childEntries, isIdentifier, kindOf, pathExpression, resolvePath, summarize } from "./environment.js";
+import { attributesFor } from "./attributes.js";
+import { celAttributes, goTemplateAttributes } from "./attributes.js";
+import { mergeSpec } from "./merge.js";
+import { defineThemes } from "./theme.js";
+import { GOMPLATE_DARK_THEME, GOMPLATE_LIGHT_THEME } from "./theme.js";
+function registerGomplateLanguages(monaco, options = {}) {
+  const { languages = LANGUAGE_IDS, completions = true, hovers = true, themes = true } = options;
+  if (themes) defineThemes(monaco);
+  const known = new Set(monaco.languages.getLanguages().map((l) => l.id));
+  const selected = [];
+  for (const id of languages) {
+    const definition = definitions[id];
+    if (!definition) {
+      throw new Error(
+        `unknown gomplate language "${id}"; expected one of ${LANGUAGE_IDS.join(", ")}`
+      );
+    }
+    selected.push(id);
+    if (known.has(id)) continue;
+    monaco.languages.register({ id });
+    monaco.languages.setLanguageConfiguration(id, definition.configuration);
+  }
+  const applySpec = (merged) => {
+    for (const id of selected) {
+      const definition = definitions[id];
+      const attributes = attributesFor(id, merged);
+      monaco.languages.setMonarchTokensProvider(
+        id,
+        attributes ? { ...definition.monarch, ...attributes } : definition.monarch
+      );
+      const flavour = pathFlavour(id);
+      const installed = [];
+      if (completions) {
+        installed.push(
+          registerCompletion(monaco, id, { spec: merged, environment: options.environment })
+        );
+      }
+      if (hovers && flavour === "cel") installed.push(registerCelHover(monaco, id, merged));
+      if (hovers && flavour === "gotemplate") {
+        installed.push(registerGoTemplateHover(monaco, id, merged));
+      }
+      replaceProviders(monaco, id, installed);
+    }
+  };
+  applySpec(mergeSpec(spec, options.spec));
+  return {
+    setSpec(next) {
+      applySpec(mergeSpec(spec, next));
+    },
+    dispose() {
+      for (const id of selected) replaceProviders(monaco, id, []);
+    }
+  };
+}
+const providersByLanguage = /* @__PURE__ */ new WeakMap();
+function replaceProviders(monaco, id, installed) {
+  let byLanguage = providersByLanguage.get(monaco);
+  if (!byLanguage) {
+    byLanguage = /* @__PURE__ */ new Map();
+    providersByLanguage.set(monaco, byLanguage);
+  }
+  for (const disposable of byLanguage.get(id) ?? []) disposable.dispose();
+  if (installed.length === 0) byLanguage.delete(id);
+  else byLanguage.set(id, installed);
+}
+export {
+  GOMPLATE_DARK_THEME,
+  GOMPLATE_LIGHT_THEME,
+  LANGUAGE_IDS,
+  attributesFor,
+  celAttributes,
+  childEntries,
+  definitions,
+  goTemplateAttributes,
+  isIdentifier,
+  kindOf,
+  mergeSpec,
+  pathExpression,
+  pathFlavour,
+  registerGomplateLanguages,
+  resolvePath,
+  spec,
+  summarize
+};
+//# sourceMappingURL=index.js.map

package/dist/expressions/lang/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/expressions/lang/index.ts"],"sourcesContent":["import { LANGUAGE_IDS, definitions, spec } from \"./generated\";\nimport type { LanguageId } from \"./generated\";\nimport { registerCompletion } from \"./completion\";\nimport type { EnvironmentSource } from \"./completion\";\nimport { registerCelHover, registerGoTemplateHover } from \"./hover\";\nimport { pathFlavour } from \"./environment\";\nimport { attributesFor } from \"./attributes\";\nimport { mergeSpec } from \"./merge\";\nimport { defineThemes } from \"./theme\";\nimport type { GomplateSpec, LanguageDefinition, Monaco } from \"./types\";\n\nexport { spec, LANGUAGE_IDS, definitions };\nexport type { LanguageId };\nexport * from \"./types\";\nexport { GOMPLATE_DARK_THEME, GOMPLATE_LIGHT_THEME } from \"./theme\";\nexport {\n  childEntries,\n  isIdentifier,\n  kindOf,\n  pathExpression,\n  pathFlavour,\n  resolvePath,\n  summarize,\n} from \"./environment\";\nexport type { EnvironmentEntry, PathSegment, ValueKind } from \"./environment\";\nexport { environmentPrefixAt } from \"./prefix\";\nexport type { EnvironmentPrefix } from \"./prefix\";\nexport type { EnvironmentSource } from \"./completion\";\nexport { mergeSpec } from \"./merge\";\nexport { attributesFor, celAttributes, goTemplateAttributes } from \"./attributes\";\nexport type { Attributes } from \"./attributes\";\n\nexport interface RegisterOptions {\n  /** Which languages to register. Defaults to all of them. */\n  languages?: readonly LanguageId[];\n  /** Register completion providers. Defaults to true. */\n  completions?: boolean;\n  /** Register hover providers. Defaults to true. */\n  hovers?: boolean;\n  /** Define the gomplate colour themes. Defaults to true. */\n  themes?: boolean;\n  /**\n   * The document expressions are evaluated against, so completion can offer the\n   * key paths it actually contains.\n   *\n   * A getter rather than a value: registration happens once, before the first\n   * editor mounts, while the document keeps being edited afterwards. It is\n   * called on every completion request.\n   */\n  environment?: EnvironmentSource;\n  /**\n   * A host's own catalogue, merged over gomplate's.\n   *\n   * Usually left unset here and supplied later through `setSpec`, because it\n   * arrives from the host's `GET /api/spec` after the editor has mounted.\n   */\n  spec?: GomplateSpec;\n}\n\n/** What `registerGomplateLanguages` hands back. */\nexport interface RegisteredLanguages {\n  /**\n   * Replaces the catalogue and re-applies it.\n   *\n   * Registration has to happen in `beforeMount`, before the first model exists,\n   * while a host's spec arrives over the network afterwards — so gating\n   * registration on the fetch would stall the editor. Register with the baked\n   * catalogue instead and call this when the response lands: the tokenizers are\n   * re-applied with the merged word lists, and completion and hover are\n   * re-registered against the merged functions.\n   */\n  setSpec(spec: GomplateSpec | undefined): void;\n  dispose(): void;\n}\n\n/**\n * Registers gomplate's languages with a Monaco instance.\n *\n * Safe to call more than once: a language already registered is left alone, so\n * a component tree with several editors does not need to coordinate. The\n * returned handle removes only the providers this call added.\n */\nexport function registerGomplateLanguages(\n  monaco: Monaco,\n  options: RegisterOptions = {},\n): RegisteredLanguages {\n  const { languages = LANGUAGE_IDS, completions = true, hovers = true, themes = true } = options;\n\n  if (themes) defineThemes(monaco);\n\n  const known = new Set(monaco.languages.getLanguages().map((l) => l.id));\n  const selected: LanguageId[] = [];\n\n  for (const id of languages) {\n    const definition: LanguageDefinition | undefined = definitions[id];\n    if (!definition) {\n      throw new Error(\n        `unknown gomplate language \"${id}\"; expected one of ${LANGUAGE_IDS.join(\", \")}`,\n      );\n    }\n    selected.push(id);\n\n    // Only the registration itself is once-only. The tokenizer and the\n    // providers are re-applied below for every selected language, whether or\n    // not this call is the one that introduced it -- otherwise a second editor\n    // would get a handle whose setSpec silently does nothing.\n    if (known.has(id)) continue;\n    monaco.languages.register({ id });\n    monaco.languages.setLanguageConfiguration(id, definition.configuration);\n  }\n\n  const applySpec = (merged: GomplateSpec) => {\n    for (const id of selected) {\n      const definition = definitions[id]!;\n      const attributes = attributesFor(id, merged);\n      // Spread over the generated definition rather than replacing it: the\n      // tokenizer rules and the grammar-derived lists (CEL's `operators`) are\n      // not the spec's to change.\n      monaco.languages.setMonarchTokensProvider(\n        id,\n        attributes ? { ...definition.monarch, ...attributes } : definition.monarch,\n      );\n\n      const flavour = pathFlavour(id);\n      const installed: { dispose(): void }[] = [];\n      if (completions) {\n        installed.push(\n          registerCompletion(monaco, id, { spec: merged, environment: options.environment }),\n        );\n      }\n      if (hovers && flavour === \"cel\") installed.push(registerCelHover(monaco, id, merged));\n      if (hovers && flavour === \"gotemplate\") {\n        installed.push(registerGoTemplateHover(monaco, id, merged));\n      }\n      replaceProviders(monaco, id, installed);\n    }\n  };\n\n  applySpec(mergeSpec(spec, options.spec));\n\n  return {\n    setSpec(next) {\n      applySpec(mergeSpec(spec, next));\n    },\n    dispose() {\n      for (const id of selected) replaceProviders(monaco, id, []);\n    },\n  };\n}\n\n/**\n * One set of completion and hover providers per language, per Monaco.\n *\n * Monaco stacks providers rather than replacing them, so registering twice for\n * a language shows every suggestion twice. Tracking them here means the latest\n * registration wins instead, and a component tree with several editors does not\n * have to coordinate.\n */\nconst providersByLanguage = new WeakMap<Monaco, Map<string, { dispose(): void }[]>>();\n\nfunction replaceProviders(monaco: Monaco, id: string, installed: { dispose(): void }[]) {\n  let byLanguage = providersByLanguage.get(monaco);\n  if (!byLanguage) {\n    byLanguage = new Map();\n    providersByLanguage.set(monaco, byLanguage);\n  }\n  for (const disposable of byLanguage.get(id) ?? []) disposable.dispose();\n  if (installed.length === 0) byLanguage.delete(id);\n  else byLanguage.set(id, installed);\n}\n"],"names":[],"mappings":";;;;;;;;;;AAkFO,SAAS,0BACd,QACA,UAA2B,IACN;AACrB,QAAM,EAAE,YAAY,cAAc,cAAc,MAAM,SAAS,MAAM,SAAS,KAAA,IAAS;AAEvF,MAAI,qBAAqB,MAAM;AAE/B,QAAM,QAAQ,IAAI,IAAI,OAAO,UAAU,eAAe,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;AACtE,QAAM,WAAyB,CAAA;AAE/B,aAAW,MAAM,WAAW;AAC1B,UAAM,aAA6C,YAAY,EAAE;AACjE,QAAI,CAAC,YAAY;AACf,YAAM,IAAI;AAAA,QACR,8BAA8B,EAAE,sBAAsB,aAAa,KAAK,IAAI,CAAC;AAAA,MAAA;AAAA,IAEjF;AACA,aAAS,KAAK,EAAE;AAMhB,QAAI,MAAM,IAAI,EAAE,EAAG;AACnB,WAAO,UAAU,SAAS,EAAE,GAAA,CAAI;AAChC,WAAO,UAAU,yBAAyB,IAAI,WAAW,aAAa;AAAA,EACxE;AAEA,QAAM,YAAY,CAAC,WAAyB;AAC1C,eAAW,MAAM,UAAU;AACzB,YAAM,aAAa,YAAY,EAAE;AACjC,YAAM,aAAa,cAAc,IAAI,MAAM;AAI3C,aAAO,UAAU;AAAA,QACf;AAAA,QACA,aAAa,EAAE,GAAG,WAAW,SAAS,GAAG,WAAA,IAAe,WAAW;AAAA,MAAA;AAGrE,YAAM,UAAU,YAAY,EAAE;AAC9B,YAAM,YAAmC,CAAA;AACzC,UAAI,aAAa;AACf,kBAAU;AAAA,UACR,mBAAmB,QAAQ,IAAI,EAAE,MAAM,QAAQ,aAAa,QAAQ,YAAA,CAAa;AAAA,QAAA;AAAA,MAErF;AACA,UAAI,UAAU,YAAY,MAAO,WAAU,KAAK,iBAAiB,QAAQ,IAAI,MAAM,CAAC;AACpF,UAAI,UAAU,YAAY,cAAc;AACtC,kBAAU,KAAK,wBAAwB,QAAQ,IAAI,MAAM,CAAC;AAAA,MAC5D;AACA,uBAAiB,QAAQ,IAAI,SAAS;AAAA,IACxC;AAAA,EACF;AAEA,YAAU,UAAU,MAAM,QAAQ,IAAI,CAAC;AAEvC,SAAO;AAAA,IACL,QAAQ,MAAM;AACZ,gBAAU,UAAU,MAAM,IAAI,CAAC;AAAA,IACjC;AAAA,IACA,UAAU;AACR,iBAAW,MAAM,SAAU,kBAAiB,QAAQ,IAAI,EAAE;AAAA,IAC5D;AAAA,EAAA;AAEJ;AAUA,MAAM,0CAA0B,QAAA;AAEhC,SAAS,iBAAiB,QAAgB,IAAY,WAAkC;AACtF,MAAI,aAAa,oBAAoB,IAAI,MAAM;AAC/C,MAAI,CAAC,YAAY;AACf,qCAAiB,IAAA;AACjB,wBAAoB,IAAI,QAAQ,UAAU;AAAA,EAC5C;AACA,aAAW,cAAc,WAAW,IAAI,EAAE,KAAK,CAAA,cAAe,QAAA;AAC9D,MAAI,UAAU,WAAW,EAAG,YAAW,OAAO,EAAE;AAAA,MAC3C,YAAW,IAAI,IAAI,SAAS;AACnC;"}

package/dist/expressions/lang/merge.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function mergeSpec(base, incoming) {
+  if (!incoming) return base;
+  return {
+    cel: mergeCel(base.cel, incoming.cel),
+    gotemplate: mergeGoTemplate(base.gotemplate, incoming.gotemplate)
+  };
+}
+function mergeCel(base, incoming) {
+  return {
+    namespaces: union(base.namespaces, incoming.namespaces),
+    keywords: union(base.keywords, incoming.keywords),
+    types: union(base.types, incoming.types),
+    variables: union(base.variables ?? [], incoming.variables ?? []),
+    // Keyed by arity as well as name: `map` is registered twice, at 2 and 3
+    // arguments, and folding those together would drop an overload the hover
+    // list already renders separately.
+    macros: keyed(
+      base.macros,
+      incoming.macros,
+      (macro) => `${macro.name}/${macro.argCount}/${macro.receiverStyle}`
+    ),
+    functions: byName(base.functions, incoming.functions)
+  };
+}
+function mergeGoTemplate(base, incoming) {
+  return {
+    namespaces: union(base.namespaces, incoming.namespaces),
+    keywords: union(base.keywords, incoming.keywords),
+    builtins: union(base.builtins, incoming.builtins),
+    // Delimiters are a property of the binary's parser, not a list to merge:
+    // a host that has changed them means it, and half of a pair would be worse
+    // than either.
+    delimiters: incoming.delimiters ?? base.delimiters,
+    functions: byName(base.functions, incoming.functions)
+  };
+}
+function union(base, incoming) {
+  return [.../* @__PURE__ */ new Set([...base, ...incoming])].sort();
+}
+function byName(base, incoming) {
+  return keyed(base, incoming, (item) => item.name);
+}
+function keyed(base, incoming, key) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const item of base) merged.set(key(item), item);
+  for (const item of incoming) merged.set(key(item), item);
+  return [...merged.values()].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+}
+exports.mergeSpec = mergeSpec;
+//# sourceMappingURL=merge.cjs.map

package/dist/expressions/lang/merge.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.cjs","sources":["../../../src/expressions/lang/merge.ts"],"sourcesContent":["import type { CelSpec, GoTemplateSpec, GomplateSpec, SpecFunction, SpecMacro } from \"./types\";\n\n/**\n * Folds a host's catalogue into the one this package ships.\n *\n * A host binary registers functions on top of gomplate's — mission-control's\n * `catalog.query`, `gitops.source` — and serves the result from `/api/spec`.\n * That response already *contains* gomplate's own functions, so merging is\n * mostly a union; the interesting case is a host that overrides a name, where\n * the host wins because its binary is what will actually evaluate.\n */\nexport function mergeSpec(base: GomplateSpec, incoming: GomplateSpec | undefined): GomplateSpec {\n  if (!incoming) return base;\n  return {\n    cel: mergeCel(base.cel, incoming.cel),\n    gotemplate: mergeGoTemplate(base.gotemplate, incoming.gotemplate),\n  };\n}\n\nfunction mergeCel(base: CelSpec, incoming: CelSpec): CelSpec {\n  return {\n    namespaces: union(base.namespaces, incoming.namespaces),\n    keywords: union(base.keywords, incoming.keywords),\n    types: union(base.types, incoming.types),\n    variables: union(base.variables ?? [], incoming.variables ?? []),\n    // Keyed by arity as well as name: `map` is registered twice, at 2 and 3\n    // arguments, and folding those together would drop an overload the hover\n    // list already renders separately.\n    macros: keyed<SpecMacro>(\n      base.macros,\n      incoming.macros,\n      (macro) => `${macro.name}/${macro.argCount}/${macro.receiverStyle}`,\n    ),\n    functions: byName<SpecFunction>(base.functions, incoming.functions),\n  };\n}\n\nfunction mergeGoTemplate(base: GoTemplateSpec, incoming: GoTemplateSpec): GoTemplateSpec {\n  return {\n    namespaces: union(base.namespaces, incoming.namespaces),\n    keywords: union(base.keywords, incoming.keywords),\n    builtins: union(base.builtins, incoming.builtins),\n    // Delimiters are a property of the binary's parser, not a list to merge:\n    // a host that has changed them means it, and half of a pair would be worse\n    // than either.\n    delimiters: incoming.delimiters ?? base.delimiters,\n    functions: byName<SpecFunction>(base.functions, incoming.functions),\n  };\n}\n\nfunction union(base: readonly string[], incoming: readonly string[]): string[] {\n  return [...new Set([...base, ...incoming])].sort();\n}\n\n/** Keyed by name, incoming wins, order stable and alphabetical. */\nfunction byName<T extends { name: string }>(base: readonly T[], incoming: readonly T[]): T[] {\n  return keyed(base, incoming, (item) => item.name);\n}\n\nfunction keyed<T extends { name: string }>(\n  base: readonly T[],\n  incoming: readonly T[],\n  key: (item: T) => string,\n): T[] {\n  const merged = new Map<string, T>();\n  for (const item of base) merged.set(key(item), item);\n  for (const item of incoming) merged.set(key(item), item);\n  return [...merged.values()].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));\n}\n"],"names":[],"mappings":";;AAWO,SAAS,UAAU,MAAoB,UAAkD;AAC9F,MAAI,CAAC,SAAU,QAAO;AACtB,SAAO;AAAA,IACL,KAAK,SAAS,KAAK,KAAK,SAAS,GAAG;AAAA,IACpC,YAAY,gBAAgB,KAAK,YAAY,SAAS,UAAU;AAAA,EAAA;AAEpE;AAEA,SAAS,SAAS,MAAe,UAA4B;AAC3D,SAAO;AAAA,IACL,YAAY,MAAM,KAAK,YAAY,SAAS,UAAU;AAAA,IACtD,UAAU,MAAM,KAAK,UAAU,SAAS,QAAQ;AAAA,IAChD,OAAO,MAAM,KAAK,OAAO,SAAS,KAAK;AAAA,IACvC,WAAW,MAAM,KAAK,aAAa,CAAA,GAAI,SAAS,aAAa,EAAE;AAAA;AAAA;AAAA;AAAA,IAI/D,QAAQ;AAAA,MACN,KAAK;AAAA,MACL,SAAS;AAAA,MACT,CAAC,UAAU,GAAG,MAAM,IAAI,IAAI,MAAM,QAAQ,IAAI,MAAM,aAAa;AAAA,IAAA;AAAA,IAEnE,WAAW,OAAqB,KAAK,WAAW,SAAS,SAAS;AAAA,EAAA;AAEtE;AAEA,SAAS,gBAAgB,MAAsB,UAA0C;AACvF,SAAO;AAAA,IACL,YAAY,MAAM,KAAK,YAAY,SAAS,UAAU;AAAA,IACtD,UAAU,MAAM,KAAK,UAAU,SAAS,QAAQ;AAAA,IAChD,UAAU,MAAM,KAAK,UAAU,SAAS,QAAQ;AAAA;AAAA;AAAA;AAAA,IAIhD,YAAY,SAAS,cAAc,KAAK;AAAA,IACxC,WAAW,OAAqB,KAAK,WAAW,SAAS,SAAS;AAAA,EAAA;AAEtE;AAEA,SAAS,MAAM,MAAyB,UAAuC;AAC7E,SAAO,CAAC,GAAG,oBAAI,IAAI,CAAC,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC,EAAE,KAAA;AAC9C;AAGA,SAAS,OAAmC,MAAoB,UAA6B;AAC3F,SAAO,MAAM,MAAM,UAAU,CAAC,SAAS,KAAK,IAAI;AAClD;AAEA,SAAS,MACP,MACA,UACA,KACK;AACL,QAAM,6BAAa,IAAA;AACnB,aAAW,QAAQ,KAAM,QAAO,IAAI,IAAI,IAAI,GAAG,IAAI;AACnD,aAAW,QAAQ,SAAU,QAAO,IAAI,IAAI,IAAI,GAAG,IAAI;AACvD,SAAO,CAAC,GAAG,OAAO,OAAA,CAAQ,EAAE,KAAK,CAAC,GAAG,MAAO,EAAE,OAAO,EAAE,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,IAAI,CAAE;AAC7F;;"}

package/dist/expressions/lang/merge.d.ts

@@ -0,0 +1,12 @@
+import { GomplateSpec } from './types';
+/**
+ * Folds a host's catalogue into the one this package ships.
+ *
+ * A host binary registers functions on top of gomplate's — mission-control's
+ * `catalog.query`, `gitops.source` — and serves the result from `/api/spec`.
+ * That response already *contains* gomplate's own functions, so merging is
+ * mostly a union; the interesting case is a host that overrides a name, where
+ * the host wins because its binary is what will actually evaluate.
+ */
+export declare function mergeSpec(base: GomplateSpec, incoming: GomplateSpec | undefined): GomplateSpec;
+//# sourceMappingURL=merge.d.ts.map

package/dist/expressions/lang/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../src/expressions/lang/merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA2B,YAAY,EAA2B,MAAM,SAAS,CAAC;AAE9F;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,GAAG,SAAS,GAAG,YAAY,CAM9F"}

package/dist/expressions/lang/merge.js

@@ -0,0 +1,52 @@
+function mergeSpec(base, incoming) {
+  if (!incoming) return base;
+  return {
+    cel: mergeCel(base.cel, incoming.cel),
+    gotemplate: mergeGoTemplate(base.gotemplate, incoming.gotemplate)
+  };
+}
+function mergeCel(base, incoming) {
+  return {
+    namespaces: union(base.namespaces, incoming.namespaces),
+    keywords: union(base.keywords, incoming.keywords),
+    types: union(base.types, incoming.types),
+    variables: union(base.variables ?? [], incoming.variables ?? []),
+    // Keyed by arity as well as name: `map` is registered twice, at 2 and 3
+    // arguments, and folding those together would drop an overload the hover
+    // list already renders separately.
+    macros: keyed(
+      base.macros,
+      incoming.macros,
+      (macro) => `${macro.name}/${macro.argCount}/${macro.receiverStyle}`
+    ),
+    functions: byName(base.functions, incoming.functions)
+  };
+}
+function mergeGoTemplate(base, incoming) {
+  return {
+    namespaces: union(base.namespaces, incoming.namespaces),
+    keywords: union(base.keywords, incoming.keywords),
+    builtins: union(base.builtins, incoming.builtins),
+    // Delimiters are a property of the binary's parser, not a list to merge:
+    // a host that has changed them means it, and half of a pair would be worse
+    // than either.
+    delimiters: incoming.delimiters ?? base.delimiters,
+    functions: byName(base.functions, incoming.functions)
+  };
+}
+function union(base, incoming) {
+  return [.../* @__PURE__ */ new Set([...base, ...incoming])].sort();
+}
+function byName(base, incoming) {
+  return keyed(base, incoming, (item) => item.name);
+}
+function keyed(base, incoming, key) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const item of base) merged.set(key(item), item);
+  for (const item of incoming) merged.set(key(item), item);
+  return [...merged.values()].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+}
+export {
+  mergeSpec
+};
+//# sourceMappingURL=merge.js.map

package/dist/expressions/lang/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.js","sources":["../../../src/expressions/lang/merge.ts"],"sourcesContent":["import type { CelSpec, GoTemplateSpec, GomplateSpec, SpecFunction, SpecMacro } from \"./types\";\n\n/**\n * Folds a host's catalogue into the one this package ships.\n *\n * A host binary registers functions on top of gomplate's — mission-control's\n * `catalog.query`, `gitops.source` — and serves the result from `/api/spec`.\n * That response already *contains* gomplate's own functions, so merging is\n * mostly a union; the interesting case is a host that overrides a name, where\n * the host wins because its binary is what will actually evaluate.\n */\nexport function mergeSpec(base: GomplateSpec, incoming: GomplateSpec | undefined): GomplateSpec {\n  if (!incoming) return base;\n  return {\n    cel: mergeCel(base.cel, incoming.cel),\n    gotemplate: mergeGoTemplate(base.gotemplate, incoming.gotemplate),\n  };\n}\n\nfunction mergeCel(base: CelSpec, incoming: CelSpec): CelSpec {\n  return {\n    namespaces: union(base.namespaces, incoming.namespaces),\n    keywords: union(base.keywords, incoming.keywords),\n    types: union(base.types, incoming.types),\n    variables: union(base.variables ?? [], incoming.variables ?? []),\n    // Keyed by arity as well as name: `map` is registered twice, at 2 and 3\n    // arguments, and folding those together would drop an overload the hover\n    // list already renders separately.\n    macros: keyed<SpecMacro>(\n      base.macros,\n      incoming.macros,\n      (macro) => `${macro.name}/${macro.argCount}/${macro.receiverStyle}`,\n    ),\n    functions: byName<SpecFunction>(base.functions, incoming.functions),\n  };\n}\n\nfunction mergeGoTemplate(base: GoTemplateSpec, incoming: GoTemplateSpec): GoTemplateSpec {\n  return {\n    namespaces: union(base.namespaces, incoming.namespaces),\n    keywords: union(base.keywords, incoming.keywords),\n    builtins: union(base.builtins, incoming.builtins),\n    // Delimiters are a property of the binary's parser, not a list to merge:\n    // a host that has changed them means it, and half of a pair would be worse\n    // than either.\n    delimiters: incoming.delimiters ?? base.delimiters,\n    functions: byName<SpecFunction>(base.functions, incoming.functions),\n  };\n}\n\nfunction union(base: readonly string[], incoming: readonly string[]): string[] {\n  return [...new Set([...base, ...incoming])].sort();\n}\n\n/** Keyed by name, incoming wins, order stable and alphabetical. */\nfunction byName<T extends { name: string }>(base: readonly T[], incoming: readonly T[]): T[] {\n  return keyed(base, incoming, (item) => item.name);\n}\n\nfunction keyed<T extends { name: string }>(\n  base: readonly T[],\n  incoming: readonly T[],\n  key: (item: T) => string,\n): T[] {\n  const merged = new Map<string, T>();\n  for (const item of base) merged.set(key(item), item);\n  for (const item of incoming) merged.set(key(item), item);\n  return [...merged.values()].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));\n}\n"],"names":[],"mappings":"AAWO,SAAS,UAAU,MAAoB,UAAkD;AAC9F,MAAI,CAAC,SAAU,QAAO;AACtB,SAAO;AAAA,IACL,KAAK,SAAS,KAAK,KAAK,SAAS,GAAG;AAAA,IACpC,YAAY,gBAAgB,KAAK,YAAY,SAAS,UAAU;AAAA,EAAA;AAEpE;AAEA,SAAS,SAAS,MAAe,UAA4B;AAC3D,SAAO;AAAA,IACL,YAAY,MAAM,KAAK,YAAY,SAAS,UAAU;AAAA,IACtD,UAAU,MAAM,KAAK,UAAU,SAAS,QAAQ;AAAA,IAChD,OAAO,MAAM,KAAK,OAAO,SAAS,KAAK;AAAA,IACvC,WAAW,MAAM,KAAK,aAAa,CAAA,GAAI,SAAS,aAAa,EAAE;AAAA;AAAA;AAAA;AAAA,IAI/D,QAAQ;AAAA,MACN,KAAK;AAAA,MACL,SAAS;AAAA,MACT,CAAC,UAAU,GAAG,MAAM,IAAI,IAAI,MAAM,QAAQ,IAAI,MAAM,aAAa;AAAA,IAAA;AAAA,IAEnE,WAAW,OAAqB,KAAK,WAAW,SAAS,SAAS;AAAA,EAAA;AAEtE;AAEA,SAAS,gBAAgB,MAAsB,UAA0C;AACvF,SAAO;AAAA,IACL,YAAY,MAAM,KAAK,YAAY,SAAS,UAAU;AAAA,IACtD,UAAU,MAAM,KAAK,UAAU,SAAS,QAAQ;AAAA,IAChD,UAAU,MAAM,KAAK,UAAU,SAAS,QAAQ;AAAA;AAAA;AAAA;AAAA,IAIhD,YAAY,SAAS,cAAc,KAAK;AAAA,IACxC,WAAW,OAAqB,KAAK,WAAW,SAAS,SAAS;AAAA,EAAA;AAEtE;AAEA,SAAS,MAAM,MAAyB,UAAuC;AAC7E,SAAO,CAAC,GAAG,oBAAI,IAAI,CAAC,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC,EAAE,KAAA;AAC9C;AAGA,SAAS,OAAmC,MAAoB,UAA6B;AAC3F,SAAO,MAAM,MAAM,UAAU,CAAC,SAAS,KAAK,IAAI;AAClD;AAEA,SAAS,MACP,MACA,UACA,KACK;AACL,QAAM,6BAAa,IAAA;AACnB,aAAW,QAAQ,KAAM,QAAO,IAAI,IAAI,IAAI,GAAG,IAAI;AACnD,aAAW,QAAQ,SAAU,QAAO,IAAI,IAAI,IAAI,GAAG,IAAI;AACvD,SAAO,CAAC,GAAG,OAAO,OAAA,CAAQ,EAAE,KAAK,CAAC,GAAG,MAAO,EAAE,OAAO,EAAE,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,IAAI,CAAE;AAC7F;"}

package/dist/expressions/lang/prefix.cjs

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("./generated/index.cjs");
+const environment = require("./environment.cjs");
+const IDENT = /[A-Za-z0-9_]/;
+const SUBSCRIPT = /^(?:(\d+)|"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)')$/;
+function environmentPrefixAt(model, position, languageId) {
+  const flavour = environment.pathFlavour(languageId);
+  if (!flavour) return null;
+  const line = model.getLineContent(position.lineNumber);
+  const before = line.slice(0, position.column - 1);
+  if (flavour === "gotemplate" && !insideAction(before)) return null;
+  let leafStart = before.length;
+  while (leafStart > 0 && IDENT.test(before[leafStart - 1])) leafStart--;
+  const leaf = before.slice(leafStart);
+  const head = before.slice(0, leafStart);
+  const chain = parseChain(head);
+  if (!chain) return null;
+  if (leaf !== "" && !chain.dotted && chain.segments.length > 0) return null;
+  let start = chain.start;
+  if (flavour === "gotemplate" && !chain.rooted) return null;
+  if (flavour === "jsonpath") {
+    const marker = head[chain.start - 1];
+    if (marker !== "$" && marker !== "@") return null;
+    start -= 1;
+  }
+  if (flavour === "cel" && chain.rooted) return null;
+  return {
+    segments: chain.segments,
+    leaf,
+    startColumn: start + 1,
+    endColumn: position.column,
+    typed: before.slice(start)
+  };
+}
+function parseChain(head) {
+  let pos = head.length;
+  const dotted = pos > 0 && head[pos - 1] === ".";
+  if (dotted) pos--;
+  const reversed = [];
+  let rooted = false;
+  for (; ; ) {
+    if (pos > 0 && head[pos - 1] === "]") {
+      const open = head.lastIndexOf("[", pos - 2);
+      if (open < 0) return null;
+      const segment = parseSubscript(head.slice(open + 1, pos - 1));
+      if (segment === null) return null;
+      reversed.push(segment);
+      pos = open;
+      rooted = false;
+      continue;
+    }
+    if (pos > 0 && IDENT.test(head[pos - 1])) {
+      let start = pos;
+      while (start > 0 && IDENT.test(head[start - 1])) start--;
+      reversed.push(head.slice(start, pos));
+      pos = start;
+      rooted = pos > 0 && head[pos - 1] === ".";
+      if (rooted) {
+        pos--;
+        continue;
+      }
+      break;
+    }
+    break;
+  }
+  if (reversed.length === 0 && dotted) rooted = true;
+  return { segments: reversed.reverse(), start: pos, dotted, rooted };
+}
+function parseSubscript(inner) {
+  const match = SUBSCRIPT.exec(inner.trim());
+  if (!match) return null;
+  if (match[1] !== void 0) return Number(match[1]);
+  const quoted = match[2] ?? match[3];
+  try {
+    return JSON.parse(`"${quoted.replace(/\\'/g, "'")}"`);
+  } catch {
+    return null;
+  }
+}
+function insideAction(before) {
+  const { left, right, leftComment, rightComment } = index.spec.gotemplate.delimiters;
+  const open = before.lastIndexOf(left);
+  if (open < 0) return false;
+  if (before.lastIndexOf(right) > open) return false;
+  const comment = before.lastIndexOf(leftComment);
+  if (comment >= open && before.lastIndexOf(rightComment) < comment) return false;
+  return true;
+}
+exports.environmentPrefixAt = environmentPrefixAt;
+//# sourceMappingURL=prefix.cjs.map

package/dist/expressions/lang/prefix.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefix.cjs","sources":["../../../src/expressions/lang/prefix.ts"],"sourcesContent":["import { spec } from \"./generated\";\nimport { pathFlavour } from \"./environment\";\nimport type { PathSegment } from \"./environment\";\n\n/** The subset of a Monaco model this module reads. */\nexport interface PrefixModel {\n  getLineContent(line: number): string;\n}\n\nexport interface PrefixPosition {\n  lineNumber: number;\n  column: number;\n}\n\n/** A path expression under construction at the cursor. */\nexport interface EnvironmentPrefix {\n  /** The segments already committed, left of the trailing dot. */\n  segments: PathSegment[];\n  /** The partially typed leaf, empty right after a dot. */\n  leaf: string;\n  /**\n   * 1-based columns spanning the whole expression typed so far, root marker\n   * included. A completion replaces this range with a freshly rendered path, so\n   * the inserted text is always well formed rather than glued onto what is\n   * already there.\n   */\n  startColumn: number;\n  endColumn: number;\n  /** The text in that range, which Monaco filters candidates against. */\n  typed: string;\n}\n\nconst IDENT = /[A-Za-z0-9_]/;\nconst SUBSCRIPT = /^(?:(\\d+)|\"((?:[^\"\\\\]|\\\\.)*)\"|'((?:[^'\\\\]|\\\\.)*)')$/;\n\n/**\n * Reads the path expression the cursor sits in, or null when it sits somewhere\n * the document's keys have no meaning.\n *\n * `dottedWordAt` in `hover.ts` cannot serve here: it scans past the cursor and\n * strips the trailing dot, and the trailing dot is precisely the signal that a\n * child is being completed.\n */\nexport function environmentPrefixAt(\n  model: PrefixModel,\n  position: PrefixPosition,\n  languageId: string,\n): EnvironmentPrefix | null {\n  const flavour = pathFlavour(languageId);\n  if (!flavour) return null;\n\n  const line = model.getLineContent(position.lineNumber);\n  const before = line.slice(0, position.column - 1);\n\n  if (flavour === \"gotemplate\" && !insideAction(before)) return null;\n\n  let leafStart = before.length;\n  while (leafStart > 0 && IDENT.test(before[leafStart - 1]!)) leafStart--;\n  const leaf = before.slice(leafStart);\n  const head = before.slice(0, leafStart);\n\n  const chain = parseChain(head);\n  if (!chain) return null;\n  // Without a dot the leaf can only be a root name, so anything that looks like\n  // the tail of a path before it (`items[0]name`) is malformed, not a prefix.\n  if (leaf !== \"\" && !chain.dotted && chain.segments.length > 0) return null;\n\n  // `chain.start` already sits on the leading `.` when there is one, so a go\n  // template needs no adjustment; JSONPath's `$` sits one place further left.\n  let start = chain.start;\n  if (flavour === \"gotemplate\" && !chain.rooted) return null;\n  if (flavour === \"jsonpath\") {\n    const marker = head[chain.start - 1];\n    if (marker !== \"$\" && marker !== \"@\") return null;\n    start -= 1;\n  }\n  if (flavour === \"cel\" && chain.rooted) return null; // a leading `.` is not CEL\n\n  return {\n    segments: chain.segments,\n    leaf,\n    startColumn: start + 1,\n    endColumn: position.column,\n    typed: before.slice(start),\n  };\n}\n\ninterface Chain {\n  segments: PathSegment[];\n  /** Index in `head` where the segment list starts, root marker excluded. */\n  start: number;\n  /** Whether `head` ends with the dot that opens a new segment. */\n  dotted: boolean;\n  /** Whether the outermost segment is preceded by a `.`, as go templates need. */\n  rooted: boolean;\n}\n\n/**\n * Parses the trailing path of `head` backwards.\n *\n * Backwards because a path has no left boundary of its own: it ends where the\n * expression around it begins, and that is only knowable by walking off it.\n */\nfunction parseChain(head: string): Chain | null {\n  let pos = head.length;\n  const dotted = pos > 0 && head[pos - 1] === \".\";\n  if (dotted) pos--;\n\n  const reversed: PathSegment[] = [];\n  let rooted = false;\n\n  for (;;) {\n    if (pos > 0 && head[pos - 1] === \"]\") {\n      const open = head.lastIndexOf(\"[\", pos - 2);\n      if (open < 0) return null;\n      const segment = parseSubscript(head.slice(open + 1, pos - 1));\n      if (segment === null) return null;\n      reversed.push(segment);\n      pos = open;\n      rooted = false;\n      continue;\n    }\n    if (pos > 0 && IDENT.test(head[pos - 1]!)) {\n      let start = pos;\n      while (start > 0 && IDENT.test(head[start - 1]!)) start--;\n      reversed.push(head.slice(start, pos));\n      pos = start;\n      rooted = pos > 0 && head[pos - 1] === \".\";\n      if (rooted) {\n        pos--;\n        continue;\n      }\n      break;\n    }\n    break;\n  }\n\n  // Only the trailing dot was consumed, so that dot is itself the root marker.\n  if (reversed.length === 0 && dotted) rooted = true;\n\n  return { segments: reversed.reverse(), start: pos, dotted, rooted };\n}\n\nfunction parseSubscript(inner: string): PathSegment | null {\n  const match = SUBSCRIPT.exec(inner.trim());\n  if (!match) return null;\n  if (match[1] !== undefined) return Number(match[1]);\n  const quoted = match[2] ?? match[3]!;\n  try {\n    return JSON.parse(`\"${quoted.replace(/\\\\'/g, \"'\")}\"`) as string;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Whether the cursor sits between template delimiters. Outside them the text is\n * literal output, where a key path means nothing.\n */\nfunction insideAction(before: string): boolean {\n  const { left, right, leftComment, rightComment } = spec.gotemplate.delimiters;\n\n  const open = before.lastIndexOf(left);\n  if (open < 0) return false;\n  if (before.lastIndexOf(right) > open) return false;\n\n  // `{{/*` opens with the ordinary left delimiter, so an unterminated comment\n  // reads as an open action unless it is checked for separately.\n  const comment = before.lastIndexOf(leftComment);\n  if (comment >= open && before.lastIndexOf(rightComment) < comment) return false;\n\n  return true;\n}\n"],"names":["pathFlavour","spec"],"mappings":"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"}

package/dist/expressions/lang/prefix.d.ts

@@ -0,0 +1,36 @@
+import { PathSegment } from './environment';
+/** The subset of a Monaco model this module reads. */
+export interface PrefixModel {
+    getLineContent(line: number): string;
+}
+export interface PrefixPosition {
+    lineNumber: number;
+    column: number;
+}
+/** A path expression under construction at the cursor. */
+export interface EnvironmentPrefix {
+    /** The segments already committed, left of the trailing dot. */
+    segments: PathSegment[];
+    /** The partially typed leaf, empty right after a dot. */
+    leaf: string;
+    /**
+     * 1-based columns spanning the whole expression typed so far, root marker
+     * included. A completion replaces this range with a freshly rendered path, so
+     * the inserted text is always well formed rather than glued onto what is
+     * already there.
+     */
+    startColumn: number;
+    endColumn: number;
+    /** The text in that range, which Monaco filters candidates against. */
+    typed: string;
+}
+/**
+ * Reads the path expression the cursor sits in, or null when it sits somewhere
+ * the document's keys have no meaning.
+ *
+ * `dottedWordAt` in `hover.ts` cannot serve here: it scans past the cursor and
+ * strips the trailing dot, and the trailing dot is precisely the signal that a
+ * child is being completed.
+ */
+export declare function environmentPrefixAt(model: PrefixModel, position: PrefixPosition, languageId: string): EnvironmentPrefix | null;
+//# sourceMappingURL=prefix.d.ts.map

package/dist/expressions/lang/prefix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefix.d.ts","sourceRoot":"","sources":["../../../src/expressions/lang/prefix.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,sDAAsD;AACtD,MAAM,WAAW,WAAW;IAC1B,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;CACtC;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,0DAA0D;AAC1D,MAAM,WAAW,iBAAiB;IAChC,gEAAgE;IAChE,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;CACf;AAKD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,cAAc,EACxB,UAAU,EAAE,MAAM,GACjB,iBAAiB,GAAG,IAAI,CAsC1B"}