@vaultgradient/pipequery-lang 1.2.2

package/dist/highlighting/index.cjs

@@ -0,0 +1,562 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/highlighting/shared.ts
+var OPERATION_NAMES = [
+  "where",
+  "select",
+  "sort",
+  "groupBy",
+  "join",
+  "first",
+  "last",
+  "distinct",
+  "map",
+  "reduce",
+  "rollup",
+  "pivot",
+  "flatten",
+  "transpose"
+];
+var KEYWORDS = [
+  "as",
+  "asc",
+  "desc",
+  "true",
+  "false",
+  "null"
+];
+var AGGREGATE_FUNCTIONS = [
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "count",
+  "median",
+  "stddev",
+  "var",
+  "percentile",
+  "skew",
+  "kurt",
+  "vwap",
+  "wavg",
+  "drawdown",
+  "pct",
+  "sharpe",
+  "calmar",
+  "sortino",
+  "info_ratio",
+  "distinct_count",
+  "sum_abs",
+  "abs_sum",
+  "first_value",
+  "last_value"
+];
+var BUILTIN_FUNCTIONS = [
+  "if",
+  "coalesce",
+  "lower",
+  "upper",
+  "len",
+  "abs",
+  "round",
+  "concat",
+  "contains",
+  "startsWith",
+  "endsWith",
+  "trim",
+  "substring",
+  "replace"
+];
+var WINDOW_FUNCTIONS = [
+  "running_sum",
+  "running_avg",
+  "running_count",
+  "running_min",
+  "running_max",
+  "row_number",
+  "lag",
+  "lead"
+];
+var ALL_FUNCTIONS = [
+  ...AGGREGATE_FUNCTIONS,
+  ...BUILTIN_FUNCTIONS,
+  ...WINDOW_FUNCTIONS
+];
+var ALL_KEYWORDS = [
+  ...OPERATION_NAMES,
+  ...KEYWORDS
+];
+var COLORS = {
+  keyword: "#c792ea",
+  string: "#c3e88d",
+  number: "#f78c6c",
+  operator: "#89ddff",
+  field: "#82aaff",
+  function: "#ffcb6b",
+  comment: "#546e7a"
+};
+
+// src/highlighting/codemirror/index.ts
+var _language = require('@codemirror/language');
+
+// src/highlighting/codemirror/language.ts
+var keywordSet = new Set(ALL_KEYWORDS);
+var functionSet = new Set(ALL_FUNCTIONS);
+var pipeQueryStreamParser = {
+  name: "pipequery",
+  startState() {
+    return { inString: "", afterPipe: false };
+  },
+  token(stream, state) {
+    if (state.inString) {
+      const quote = state.inString;
+      while (!stream.eol()) {
+        const ch2 = stream.next();
+        if (ch2 === "\\" && !stream.eol()) {
+          stream.next();
+        } else if (ch2 === quote) {
+          state.inString = "";
+          return "string";
+        }
+      }
+      return "string";
+    }
+    if (stream.eatSpace()) return null;
+    if (stream.match("//")) {
+      stream.skipToEnd();
+      return "comment";
+    }
+    if (stream.match(">=") || stream.match("<=") || stream.match("==") || stream.match("!=") || stream.match("&&") || stream.match("||")) {
+      state.afterPipe = false;
+      return "operator";
+    }
+    const ch = stream.peek();
+    if (ch === "|") {
+      stream.next();
+      state.afterPipe = true;
+      return "operator";
+    }
+    if (ch === ">" || ch === "<" || ch === "!" || ch === "+" || ch === "-" || ch === "*" || ch === "/" || ch === "%") {
+      stream.next();
+      state.afterPipe = false;
+      return "operator";
+    }
+    if (ch === "(" || ch === ")" || ch === "," || ch === ".") {
+      stream.next();
+      if (ch !== "(") state.afterPipe = false;
+      return "punctuation";
+    }
+    if (ch && ch >= "0" && ch <= "9") {
+      stream.match(/^\d+(\.\d+)?/);
+      state.afterPipe = false;
+      return "number";
+    }
+    if (ch === '"' || ch === "'") {
+      state.inString = ch;
+      stream.next();
+      return "string";
+    }
+    if (stream.match(/^[a-zA-Z_]\w*/)) {
+      const word = stream.current();
+      if (keywordSet.has(word)) {
+        state.afterPipe = false;
+        return "keyword";
+      }
+      if (functionSet.has(word)) {
+        state.afterPipe = false;
+        return "function";
+      }
+      state.afterPipe = false;
+      return "variableName";
+    }
+    stream.next();
+    state.afterPipe = false;
+    return null;
+  }
+};
+
+// src/highlighting/codemirror/highlight.ts
+
+var _highlight = require('@lezer/highlight');
+var pipeQueryHighlightStyle = _language.HighlightStyle.define([
+  { tag: _highlight.tags.keyword, color: COLORS.keyword, fontWeight: "600" },
+  { tag: _highlight.tags.function(_highlight.tags.variableName), color: COLORS.function },
+  { tag: _highlight.tags.variableName, color: COLORS.field },
+  { tag: _highlight.tags.string, color: COLORS.string },
+  { tag: _highlight.tags.number, color: COLORS.number },
+  { tag: _highlight.tags.operator, color: COLORS.operator },
+  { tag: _highlight.tags.punctuation, color: COLORS.operator },
+  { tag: _highlight.tags.lineComment, color: COLORS.comment, fontStyle: "italic" }
+]);
+var pipeQueryHighlightExtension = _language.syntaxHighlighting.call(void 0, pipeQueryHighlightStyle);
+
+// src/highlighting/codemirror/completion.ts
+var _autocomplete = require('@codemirror/autocomplete');
+var OP_HINTS = {
+  where: "Filter rows matching a condition",
+  select: "Pick or compute columns",
+  sort: "Order rows by fields",
+  groupBy: "Group rows by key fields",
+  join: "Join with another data source",
+  first: "Take first N rows",
+  last: "Take last N rows",
+  distinct: "Remove duplicate rows",
+  map: "Add computed columns",
+  reduce: "Fold rows into a single value",
+  rollup: "Group + aggregate in one step",
+  pivot: "Pivot rows into columns",
+  flatten: "Expand nested arrays",
+  transpose: "Swap rows and columns"
+};
+var FN_HINTS = {
+  // Aggregate
+  sum: "Total of values",
+  avg: "Arithmetic mean",
+  min: "Minimum value",
+  max: "Maximum value",
+  count: "Row count",
+  median: "50th percentile",
+  stddev: "Standard deviation",
+  var: "Variance",
+  percentile: "p-th percentile",
+  skew: "Skewness",
+  kurt: "Excess kurtosis",
+  vwap: "Volume-weighted avg price",
+  wavg: "Weighted average",
+  drawdown: "Max peak-to-trough decline",
+  pct: "Percentage of total",
+  sharpe: "Sharpe ratio",
+  calmar: "Calmar ratio",
+  sortino: "Sortino ratio",
+  info_ratio: "Information ratio",
+  distinct_count: "Count of unique values",
+  sum_abs: "Sum of absolute values",
+  abs_sum: "Abs of sum",
+  first_value: "First value in group",
+  last_value: "Last value in group",
+  // Built-in
+  if: "Conditional expression",
+  coalesce: "First non-null value",
+  lower: "Lowercase string",
+  upper: "Uppercase string",
+  len: "String length",
+  abs: "Absolute value",
+  round: "Round to N decimals",
+  concat: "Concatenate strings",
+  contains: "Check if string contains substring",
+  startsWith: "Check if string starts with prefix",
+  endsWith: "Check if string ends with suffix",
+  trim: "Remove leading/trailing whitespace",
+  substring: "Extract part of a string",
+  replace: "Replace all occurrences in string",
+  // Window
+  running_sum: "Cumulative sum",
+  running_avg: "Cumulative average",
+  running_count: "Cumulative count",
+  running_min: "Running minimum",
+  running_max: "Running maximum",
+  row_number: "Row number (1-based)",
+  lag: "Previous row value",
+  lead: "Next row value"
+};
+var KW_HINTS = {
+  as: "Alias a column",
+  asc: "Ascending order",
+  desc: "Descending order",
+  true: "Boolean true",
+  false: "Boolean false",
+  null: "Null value"
+};
+var OP_COMPLETIONS = OPERATION_NAMES.map((name) => ({
+  label: name,
+  type: "keyword",
+  detail: "operation",
+  info: OP_HINTS[name],
+  boost: 2
+}));
+var FN_COMPLETIONS = ALL_FUNCTIONS.map((name) => ({
+  label: name,
+  type: "function",
+  detail: AGGREGATE_FUNCTIONS.includes(name) ? "aggregate" : WINDOW_FUNCTIONS.includes(name) ? "window" : "built-in",
+  info: FN_HINTS[name],
+  apply: `${name}(`
+}));
+var AGG_COMPLETIONS = FN_COMPLETIONS.filter(
+  (c) => AGGREGATE_FUNCTIONS.includes(c.label)
+);
+var KW_COMPLETIONS = KEYWORDS.map((name) => ({
+  label: name,
+  type: "keyword",
+  detail: "keyword",
+  info: KW_HINTS[name]
+}));
+var SORT_KW = [
+  { label: "asc", type: "keyword", detail: "ascending order" },
+  { label: "desc", type: "keyword", detail: "descending order" }
+];
+function detectContext(text) {
+  let depth = 0;
+  let i = text.length - 1;
+  while (i >= 0 && /[\w.]/.test(text[i])) i--;
+  while (i >= 0 && /\s/.test(text[i])) i--;
+  if (i < 0) return { kind: "startOfQuery" };
+  const ch = text[i];
+  if (ch === "|") return { kind: "afterPipe" };
+  for (let j = text.length - 1; j >= 0; j--) {
+    const c = text[j];
+    if (c === ")") depth++;
+    else if (c === "(") {
+      depth--;
+      if (depth < 0) {
+        let k = j - 1;
+        while (k >= 0 && /\s/.test(text[k])) k--;
+        let end = k + 1;
+        while (k >= 0 && /\w/.test(text[k])) k--;
+        const op = text.slice(k + 1, end);
+        if (op && OPERATION_NAMES.includes(op)) {
+          return { kind: "insideOp", op };
+        }
+        if (op && ALL_FUNCTIONS.includes(op)) {
+          return { kind: "general" };
+        }
+        return { kind: "general" };
+      }
+    }
+    if (c === '"' || c === "'") {
+      const q = c;
+      j--;
+      while (j >= 0 && text[j] !== q) j--;
+    }
+  }
+  const trimmed = text.trimStart();
+  if (!trimmed.includes("|")) return { kind: "startOfQuery" };
+  return { kind: "general" };
+}
+function resolve(v) {
+  return typeof v === "function" ? v() : v;
+}
+function buildFieldCompletions(fields) {
+  return fields.map((f) => ({
+    label: f,
+    type: "variable",
+    detail: "field",
+    boost: 1
+  }));
+}
+function buildSourceCompletions(sources) {
+  return sources.map((s) => ({
+    label: s,
+    type: "variable",
+    detail: "source",
+    boost: 3
+  }));
+}
+function createCompletionSource(config) {
+  return function completionSource(cx) {
+    const word = cx.matchBefore(/[\w.]*/);
+    if (!word) return null;
+    if (word.from === word.to && !cx.explicit) return null;
+    const fields = resolve(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _ => _.fields]), () => ( [])));
+    const sources = resolve(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _2 => _2.sources]), () => ( [])));
+    const textBefore = cx.state.doc.sliceString(0, word.from);
+    const ctx = detectContext(textBefore);
+    let completions;
+    switch (ctx.kind) {
+      case "afterPipe":
+        completions = OP_COMPLETIONS;
+        break;
+      case "startOfQuery":
+        completions = [
+          ...buildSourceCompletions(sources),
+          ...OP_COMPLETIONS
+        ];
+        break;
+      case "insideOp":
+        switch (ctx.op) {
+          case "sort":
+            completions = [...buildFieldCompletions(fields), ...SORT_KW];
+            break;
+          case "select":
+          case "groupBy":
+          case "distinct":
+            completions = [...buildFieldCompletions(fields), ...FN_COMPLETIONS];
+            break;
+          case "rollup":
+          case "pivot":
+            completions = [...buildFieldCompletions(fields), ...AGG_COMPLETIONS];
+            break;
+          case "where":
+          case "map":
+            completions = [
+              ...buildFieldCompletions(fields),
+              ...FN_COMPLETIONS,
+              ...KW_COMPLETIONS
+            ];
+            break;
+          case "join":
+            completions = [
+              ...buildSourceCompletions(sources),
+              ...buildFieldCompletions(fields),
+              ...KW_COMPLETIONS
+            ];
+            break;
+          default:
+            completions = [
+              ...buildFieldCompletions(fields),
+              ...FN_COMPLETIONS,
+              ...KW_COMPLETIONS
+            ];
+        }
+        break;
+      case "general":
+      default:
+        completions = [
+          ...buildFieldCompletions(fields),
+          ...FN_COMPLETIONS,
+          ...KW_COMPLETIONS,
+          ...OP_COMPLETIONS
+        ];
+    }
+    return {
+      from: word.from,
+      options: completions,
+      validFor: /^\w*$/
+    };
+  };
+}
+function pipeQueryCompletion(config) {
+  return _autocomplete.autocompletion.call(void 0, {
+    override: [createCompletionSource(config)],
+    activateOnTyping: true,
+    icons: true
+  });
+}
+
+// src/highlighting/codemirror/index.ts
+function pipeQuery(config) {
+  const lang = _language.StreamLanguage.define(pipeQueryStreamParser);
+  const extensions = [pipeQueryHighlightExtension];
+  if (_optionalChain([config, 'optionalAccess', _3 => _3.completion]) !== false) {
+    extensions.push(
+      pipeQueryCompletion(
+        typeof _optionalChain([config, 'optionalAccess', _4 => _4.completion]) === "object" ? config.completion : void 0
+      )
+    );
+  }
+  return new (0, _language.LanguageSupport)(lang, extensions);
+}
+
+// src/highlighting/monaco/language.ts
+var monarchLanguage = {
+  defaultToken: "variable",
+  keywords: [...ALL_KEYWORDS],
+  functions: [...ALL_FUNCTIONS],
+  operators: [
+    ">=",
+    "<=",
+    "==",
+    "!=",
+    "&&",
+    "||",
+    ">",
+    "<",
+    "!",
+    "+",
+    "-",
+    "*",
+    "/",
+    "%"
+  ],
+  tokenizer: {
+    root: [
+      // Line comments (forward-compat)
+      [/\/\/.*$/, "comment"],
+      // Strings
+      [/"/, "string", "@string_double"],
+      [/'/, "string", "@string_single"],
+      // Numbers
+      [/\d+(\.\d+)?/, "number"],
+      // Pipe operator (bold styling via separate token)
+      [/\|/, "operator.pipe"],
+      // Multi-char operators first, then single-char
+      [/>=|<=|==|!=|&&|\|\|/, "operator"],
+      [/[><!+\-*/%]/, "operator"],
+      // Parentheses, comma, dot
+      [/[().,]/, "delimiter"],
+      // Identifiers, keywords, functions
+      [/[a-zA-Z_]\w*/, {
+        cases: {
+          "@keywords": "keyword",
+          "@functions": "type.function",
+          "@default": "variable"
+        }
+      }]
+    ],
+    string_double: [
+      [/[^\\"]+/, "string"],
+      [/\\./, "string.escape"],
+      [/"/, "string", "@pop"]
+    ],
+    string_single: [
+      [/[^\\']+/, "string"],
+      [/\\./, "string.escape"],
+      [/'/, "string", "@pop"]
+    ]
+  }
+};
+var languageConfiguration = {
+  brackets: [["(", ")"]],
+  autoClosingPairs: [
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ],
+  surroundingPairs: [
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ]
+};
+
+// src/highlighting/monaco/theme.ts
+var tokenThemeRules = [
+  { token: "keyword", foreground: "c792ea", fontStyle: "bold" },
+  { token: "type.function", foreground: "ffcb6b" },
+  { token: "variable", foreground: "82aaff" },
+  { token: "string", foreground: "c3e88d" },
+  { token: "string.escape", foreground: "c3e88d", fontStyle: "bold" },
+  { token: "number", foreground: "f78c6c" },
+  { token: "operator", foreground: "89ddff" },
+  { token: "operator.pipe", foreground: "89ddff", fontStyle: "bold" },
+  { token: "delimiter", foreground: "89ddff" },
+  { token: "comment", foreground: "546e7a", fontStyle: "italic" }
+];
+
+// src/highlighting/monaco/index.ts
+function registerPipeQuery(monaco) {
+  monaco.languages.register({ id: "pipequery" });
+  monaco.languages.setMonarchTokensProvider("pipequery", monarchLanguage);
+  monaco.languages.setLanguageConfiguration("pipequery", languageConfiguration);
+  monaco.editor.defineTheme("pipequery-dark", {
+    base: "vs-dark",
+    inherit: true,
+    rules: tokenThemeRules,
+    colors: {}
+  });
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AGGREGATE_FUNCTIONS = AGGREGATE_FUNCTIONS; exports.ALL_FUNCTIONS = ALL_FUNCTIONS; exports.ALL_KEYWORDS = ALL_KEYWORDS; exports.BUILTIN_FUNCTIONS = BUILTIN_FUNCTIONS; exports.COLORS = COLORS; exports.KEYWORDS = KEYWORDS; exports.OPERATION_NAMES = OPERATION_NAMES; exports.WINDOW_FUNCTIONS = WINDOW_FUNCTIONS; exports.languageConfiguration = languageConfiguration; exports.monarchLanguage = monarchLanguage; exports.pipeQuery = pipeQuery; exports.pipeQueryCompletion = pipeQueryCompletion; exports.pipeQueryHighlightExtension = pipeQueryHighlightExtension; exports.pipeQueryHighlightStyle = pipeQueryHighlightStyle; exports.registerPipeQuery = registerPipeQuery; exports.tokenThemeRules = tokenThemeRules;

package/dist/highlighting/index.d.cts

@@ -0,0 +1,136 @@
+import { HighlightStyle, LanguageSupport } from '@codemirror/language';
+import { Extension } from '@codemirror/state';
+
+declare const OPERATION_NAMES: readonly ["where", "select", "sort", "groupBy", "join", "first", "last", "distinct", "map", "reduce", "rollup", "pivot", "flatten", "transpose"];
+declare const KEYWORDS: readonly ["as", "asc", "desc", "true", "false", "null"];
+declare const AGGREGATE_FUNCTIONS: readonly ["sum", "avg", "min", "max", "count", "median", "stddev", "var", "percentile", "skew", "kurt", "vwap", "wavg", "drawdown", "pct", "sharpe", "calmar", "sortino", "info_ratio", "distinct_count", "sum_abs", "abs_sum", "first_value", "last_value"];
+declare const BUILTIN_FUNCTIONS: readonly ["if", "coalesce", "lower", "upper", "len", "abs", "round", "concat", "contains", "startsWith", "endsWith", "trim", "substring", "replace"];
+declare const WINDOW_FUNCTIONS: readonly ["running_sum", "running_avg", "running_count", "running_min", "running_max", "row_number", "lag", "lead"];
+declare const ALL_FUNCTIONS: readonly ["sum", "avg", "min", "max", "count", "median", "stddev", "var", "percentile", "skew", "kurt", "vwap", "wavg", "drawdown", "pct", "sharpe", "calmar", "sortino", "info_ratio", "distinct_count", "sum_abs", "abs_sum", "first_value", "last_value", "if", "coalesce", "lower", "upper", "len", "abs", "round", "concat", "contains", "startsWith", "endsWith", "trim", "substring", "replace", "running_sum", "running_avg", "running_count", "running_min", "running_max", "row_number", "lag", "lead"];
+declare const ALL_KEYWORDS: readonly ["where", "select", "sort", "groupBy", "join", "first", "last", "distinct", "map", "reduce", "rollup", "pivot", "flatten", "transpose", "as", "asc", "desc", "true", "false", "null"];
+declare const COLORS: {
+    readonly keyword: "#c792ea";
+    readonly string: "#c3e88d";
+    readonly number: "#f78c6c";
+    readonly operator: "#89ddff";
+    readonly field: "#82aaff";
+    readonly function: "#ffcb6b";
+    readonly comment: "#546e7a";
+};
+
+/**
+ * Highlight style for PipeQuery matching the project's dark theme palette.
+ */
+declare const pipeQueryHighlightStyle: HighlightStyle;
+/**
+ * CodeMirror extension that applies the PipeQuery highlight style.
+ */
+declare const pipeQueryHighlightExtension: Extension;
+
+interface PipeQueryCompletionConfig {
+    /** Dynamic field names from the current data context. */
+    fields?: string[] | (() => string[]);
+    /** Available data source names (e.g. "crypto", "orders"). */
+    sources?: string[] | (() => string[]);
+}
+declare function pipeQueryCompletion(config?: PipeQueryCompletionConfig): Extension;
+
+interface PipeQueryConfig {
+    /**
+     * Autocomplete configuration. Pass `false` to disable.
+     * Defaults to enabled with no field/source suggestions.
+     */
+    completion?: PipeQueryCompletionConfig | false;
+}
+/**
+ * CodeMirror 6 language support for PipeQuery.
+ *
+ * Usage:
+ * ```ts
+ * import { pipeQuery } from './highlighting/codemirror';
+ *
+ * // Basic (keywords + functions autocomplete)
+ * const editor = new EditorView({ extensions: [pipeQuery()] });
+ *
+ * // With field & source suggestions
+ * const editor = new EditorView({
+ *   extensions: [pipeQuery({ completion: { fields: ['id', 'name'], sources: ['orders'] } })],
+ * });
+ *
+ * // Disable autocomplete
+ * const editor = new EditorView({ extensions: [pipeQuery({ completion: false })] });
+ * ```
+ */
+declare function pipeQuery(config?: PipeQueryConfig): LanguageSupport;
+
+/**
+ * Monaco Monarch tokenizer definition for PipeQuery.
+ *
+ * See: https://microsoft.github.io/monaco-editor/monarch.html
+ */
+declare const monarchLanguage: {
+    defaultToken: string;
+    keywords: ("where" | "select" | "sort" | "groupBy" | "join" | "first" | "last" | "distinct" | "map" | "reduce" | "rollup" | "pivot" | "flatten" | "transpose" | "as" | "asc" | "desc" | "true" | "false" | "null")[];
+    functions: ("sum" | "avg" | "min" | "max" | "count" | "median" | "stddev" | "var" | "percentile" | "skew" | "kurt" | "vwap" | "wavg" | "drawdown" | "pct" | "sharpe" | "calmar" | "sortino" | "info_ratio" | "distinct_count" | "sum_abs" | "abs_sum" | "first_value" | "last_value" | "if" | "coalesce" | "lower" | "upper" | "len" | "abs" | "round" | "concat" | "contains" | "startsWith" | "endsWith" | "trim" | "substring" | "replace" | "running_sum" | "running_avg" | "running_count" | "running_min" | "running_max" | "row_number" | "lag" | "lead")[];
+    operators: string[];
+    tokenizer: {
+        root: ((string | RegExp)[] | (RegExp | {
+            cases: {
+                '@keywords': string;
+                '@functions': string;
+                '@default': string;
+            };
+        })[])[];
+        string_double: (string | RegExp)[][];
+        string_single: (string | RegExp)[][];
+    };
+};
+/**
+ * Language configuration for PipeQuery (brackets, auto-closing, etc.).
+ */
+declare const languageConfiguration: {
+    brackets: [string, string][];
+    autoClosingPairs: {
+        open: string;
+        close: string;
+    }[];
+    surroundingPairs: {
+        open: string;
+        close: string;
+    }[];
+};
+
+/**
+ * Monaco token theme rules for PipeQuery.
+ * Use with `monaco.editor.defineTheme()`.
+ *
+ * Colors match the project's dark theme palette from Docs.tsx.
+ */
+declare const tokenThemeRules: ({
+    token: string;
+    foreground: string;
+    fontStyle: string;
+} | {
+    token: string;
+    foreground: string;
+    fontStyle?: undefined;
+})[];
+
+/**
+ * Register the PipeQuery language with a Monaco Editor instance.
+ *
+ * Usage:
+ * ```ts
+ * import * as monaco from 'monaco-editor';
+ * import { registerPipeQuery } from './highlighting/monaco';
+ *
+ * registerPipeQuery(monaco);
+ * const editor = monaco.editor.create(container, {
+ *   language: 'pipequery',
+ *   theme: 'pipequery-dark',
+ * });
+ * ```
+ */
+declare function registerPipeQuery(monaco: any): void;
+
+export { AGGREGATE_FUNCTIONS, ALL_FUNCTIONS, ALL_KEYWORDS, BUILTIN_FUNCTIONS, COLORS, KEYWORDS, OPERATION_NAMES, type PipeQueryCompletionConfig, type PipeQueryConfig, WINDOW_FUNCTIONS, languageConfiguration, monarchLanguage, pipeQuery, pipeQueryCompletion, pipeQueryHighlightExtension, pipeQueryHighlightStyle, registerPipeQuery, tokenThemeRules };