pdl-editor 0.30.0

package/dist/index.mjs

@@ -0,0 +1,832 @@
+// src/index.tsx
+import React from "react";
+import * as monaco from "monaco-editor/esm/vs/editor/editor.api";
+import "monaco-editor/min/vs/editor/editor.main.css";
+import "monaco-editor/esm/vs/editor/contrib/hover/browser/hoverContribution";
+import EditorWorker from "monaco-editor/esm/vs/editor/editor.worker?worker";
+import { wireTmGrammars } from "monaco-editor-textmate";
+import { Registry } from "monaco-textmate";
+import { loadWASM as loadOnigasm } from "onigasm";
+import onigasmWasmUrl from "onigasm/lib/onigasm.wasm?url";
+
+// assets/language-configuration.json
+var language_configuration_default = {
+  comments: {
+    lineComment: "//",
+    blockComment: [
+      "/*",
+      "*/"
+    ]
+  },
+  brackets: [
+    [
+      "(",
+      ")"
+    ]
+  ],
+  autoClosingPairs: [
+    {
+      open: '"',
+      close: '"'
+    },
+    {
+      open: "`",
+      close: "`"
+    },
+    {
+      open: "(",
+      close: ")"
+    }
+  ],
+  surroundingPairs: [
+    {
+      open: '"',
+      close: '"'
+    },
+    {
+      open: "`",
+      close: "`"
+    },
+    {
+      open: "(",
+      close: ")"
+    }
+  ],
+  wordPattern: "(-?\\d*\\.\\d\\w*)|([^`~!@#$%^&*()+={}\\[\\]\\\\|;:'\",.<>/?\\s]+)",
+  indentationRules: {
+    increaseIndentPattern: "^\\s*let\\s+[A-Za-z_][A-Za-z0-9_]*\\s*=\\s*$",
+    decreaseIndentPattern: "^\\s*$"
+  }
+};
+
+// assets/pdl.tmLanguage.json
+var pdl_tmLanguage_default = {
+  $schema: "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  name: "PDL",
+  scopeName: "source.pdl",
+  patterns: [
+    {
+      include: "#comments"
+    },
+    {
+      include: "#strings"
+    },
+    {
+      include: "#backtickColumns"
+    },
+    {
+      include: "#numbers"
+    },
+    {
+      include: "#contextReferences"
+    },
+    {
+      include: "#operators"
+    },
+    {
+      include: "#declarations"
+    },
+    {
+      include: "#keywords"
+    },
+    {
+      include: "#functions"
+    }
+  ],
+  repository: {
+    comments: {
+      patterns: [
+        {
+          name: "comment.line.double-slash.pdl",
+          match: "//.*$"
+        },
+        {
+          name: "comment.block.pdl",
+          begin: "/\\*",
+          end: "\\*/"
+        }
+      ]
+    },
+    strings: {
+      patterns: [
+        {
+          name: "string.quoted.double.pdl",
+          begin: '"',
+          end: '"',
+          patterns: [
+            {
+              name: "constant.character.escape.pdl",
+              match: '\\\\(?:["\\\\nrt]|u\\{[0-9A-Fa-f]+\\})'
+            }
+          ]
+        }
+      ]
+    },
+    backtickColumns: {
+      patterns: [
+        {
+          name: "variable.other.column.pdl",
+          begin: "`",
+          end: "`",
+          patterns: [
+            {
+              name: "constant.character.escape.pdl",
+              match: "\\\\(?:[`\\\\])"
+            }
+          ]
+        }
+      ]
+    },
+    numbers: {
+      patterns: [
+        {
+          name: "constant.numeric.pdl",
+          match: "\\b[0-9]+(?:\\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\\b"
+        }
+      ]
+    },
+    operators: {
+      patterns: [
+        {
+          name: "keyword.operator.pdl",
+          match: "\\|"
+        },
+        {
+          name: "keyword.operator.comparison.pdl",
+          match: "==|!=|<=|>=|<|>"
+        },
+        {
+          name: "keyword.operator.arithmetic.pdl",
+          match: "[+\\-*/%]"
+        },
+        {
+          name: "keyword.operator.context.pdl",
+          match: "[$@]"
+        }
+      ]
+    },
+    contextReferences: {
+      patterns: [
+        {
+          name: "variable.parameter.context.pdl",
+          match: "[$@][A-Za-z_][A-Za-z0-9_]*\\b"
+        }
+      ]
+    },
+    declarations: {
+      patterns: [
+        {
+          name: "meta.context.declaration.pdl",
+          match: "\\b(param|state)\\s+([A-Za-z_][A-Za-z0-9_]*)\\b",
+          captures: {
+            "1": {
+              name: "keyword.declaration.pdl"
+            },
+            "2": {
+              name: "variable.parameter.declaration.pdl"
+            }
+          }
+        },
+        {
+          name: "meta.binding.declaration.pdl",
+          match: "\\b(let)\\s+([A-Za-z_][A-Za-z0-9_]*)\\b",
+          captures: {
+            "1": {
+              name: "keyword.declaration.pdl"
+            },
+            "2": {
+              name: "variable.other.declaration.pdl"
+            }
+          }
+        },
+        {
+          name: "meta.output.declaration.pdl",
+          match: "\\b(output)\\s+([A-Za-z_][A-Za-z0-9_]*)\\b",
+          captures: {
+            "1": {
+              name: "keyword.declaration.pdl"
+            },
+            "2": {
+              name: "entity.name.function.output.pdl"
+            }
+          }
+        },
+        {
+          name: "variable.parameter.pdl",
+          match: "\\b[A-Za-z_][A-Za-z0-9_]*\\b(?=\\s*=(?!=))"
+        }
+      ]
+    },
+    keywords: {
+      patterns: [
+        {
+          name: "keyword.control.pdl",
+          match: "\\b(?:let|output|param|state|load|filter|select|drop|rename|mutate|group_by|agg|sort|limit|join|union|distinct|pivot_longer|complete|save|on|kind|by_name|names_to|values_to|fill|format|over|partition_by|order_by|rows|between|unbounded_preceding|current_row|unbounded_following|preceding|following|stdin|stdout|and|or|not|asc|desc|inner|left|right|full|semi|anti|nulls_first|nulls_last)\\b"
+        },
+        {
+          name: "constant.language.pdl",
+          match: "\\b(?:true|false|null)\\b"
+        }
+      ]
+    },
+    functions: {
+      patterns: [
+        {
+          name: "support.function.window.pdl",
+          match: "\\b(?:count|count_distinct|sum|mean|min|max)\\b(?=\\s*\\([^)]*\\)\\s*over\\b)"
+        },
+        {
+          name: "support.function.aggregate.pdl",
+          match: "\\b(?:count|count_distinct|sum|mean|min|max)\\b(?=\\s*\\()"
+        },
+        {
+          name: "support.function.scalar.pdl",
+          match: "\\b(?:is_null|not_null|coalesce|concat|lower|upper|trim|to_number|abs|round|if_else|col)\\b(?=\\s*\\()"
+        },
+        {
+          name: "support.function.window.pdl",
+          match: "\\b(?:row_number|rank|dense_rank|percent_rank|cume_dist|lag|lead|first_value|last_value)\\b(?=\\s*\\()"
+        }
+      ]
+    }
+  }
+};
+
+// src/index.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var PDL_LANGUAGE_ID = "pdl";
+var PDL_SCOPE_NAME = "source.pdl";
+var PDL_THEME_NAME = "pdl-playground";
+var PDL_MARKER_OWNER = "pdl-wasm";
+var PDL_DEFAULT_MODEL_URI = "inmemory://pdl/main.pdl";
+var SEMANTIC_TOKEN_TYPES = [
+  "keyword",
+  "function",
+  "variable",
+  "string",
+  "number",
+  "operator",
+  "pdlBindingDeclaration",
+  "pdlBindingReference",
+  "pdlColumnDefinition",
+  "pdlColumnReference",
+  "pdlContextDeclaration",
+  "pdlContextReference"
+];
+var setupPromise = null;
+var onigasmPromise = null;
+var providerDisposable = null;
+var editorContexts = /* @__PURE__ */ new Map();
+function PdlEditor({
+  value,
+  files,
+  diagnostics,
+  runtime,
+  onChange,
+  modelUri,
+  languageId = PDL_LANGUAGE_ID,
+  themeName = PDL_THEME_NAME,
+  theme,
+  className = "pdl-editor-shell",
+  editorClassName = "pdl-editor",
+  options,
+  setupOptions
+}) {
+  const hostRef = React.useRef(null);
+  const editorRef = React.useRef(null);
+  const modelRef = React.useRef(null);
+  const onChangeRef = React.useRef(onChange);
+  const diagnosticsRef = React.useRef(diagnostics);
+  const filesRef = React.useRef(files);
+  const runtimeRef = React.useRef(runtime);
+  const [setupError, setSetupError] = React.useState(null);
+  const resolvedModelUri = React.useMemo(() => monaco.Uri.parse(modelUri ?? PDL_DEFAULT_MODEL_URI), [modelUri]);
+  React.useEffect(() => {
+    onChangeRef.current = onChange;
+  }, [onChange]);
+  React.useEffect(() => {
+    filesRef.current = files;
+  }, [files]);
+  React.useEffect(() => {
+    runtimeRef.current = runtime;
+  }, [runtime]);
+  React.useEffect(() => {
+    diagnosticsRef.current = diagnostics;
+    const model = modelRef.current;
+    if (model) {
+      setPdlMarkers(model, diagnostics);
+    }
+  }, [diagnostics]);
+  React.useEffect(() => {
+    const model = modelRef.current;
+    if (model && model.getValue() !== value) {
+      const selection = editorRef.current?.getSelection() ?? null;
+      model.setValue(value);
+      if (selection) {
+        editorRef.current?.setSelection(selection);
+      }
+      setPdlMarkers(model, diagnosticsRef.current);
+    }
+  }, [value]);
+  React.useEffect(() => {
+    let cancelled = false;
+    let editor2 = null;
+    let model = null;
+    let contentDisposable = null;
+    let contextKey = null;
+    setupPdlMonaco({ ...setupOptions, languageId, themeName, theme }).then(() => {
+      if (cancelled || !hostRef.current) {
+        return;
+      }
+      ensurePdlProviders(languageId);
+      model = monaco.editor.createModel(value, languageId, resolvedModelUri);
+      contextKey = model.uri.toString();
+      editorContexts.set(contextKey, {
+        runtime: () => runtimeRef.current,
+        files: () => filesRef.current
+      });
+      editor2 = monaco.editor.create(hostRef.current, {
+        model,
+        theme: themeName,
+        automaticLayout: true,
+        bracketPairColorization: { enabled: true },
+        cursorBlinking: "smooth",
+        fixedOverflowWidgets: true,
+        fontFamily: '"SFMono-Regular", Consolas, "Liberation Mono", Menlo, monospace',
+        fontSize: 13,
+        lineHeight: 20,
+        minimap: { enabled: false },
+        overviewRulerBorder: false,
+        padding: { top: 12, bottom: 12 },
+        renderLineHighlight: "line",
+        scrollBeyondLastLine: false,
+        smoothScrolling: true,
+        tabSize: 2,
+        wordWrap: "off",
+        ...options
+      });
+      modelRef.current = model;
+      editorRef.current = editor2;
+      setPdlMarkers(model, diagnosticsRef.current);
+      contentDisposable = model.onDidChangeContent(() => {
+        onChangeRef.current(model?.getValue() ?? "");
+      });
+    }).catch((err) => {
+      if (!cancelled) {
+        setSetupError(err instanceof Error ? err.message : String(err));
+      }
+    });
+    return () => {
+      cancelled = true;
+      contentDisposable?.dispose();
+      if (contextKey) {
+        editorContexts.delete(contextKey);
+      }
+      if (model) {
+        monaco.editor.setModelMarkers(model, PDL_MARKER_OWNER, []);
+      }
+      editor2?.dispose();
+      model?.dispose();
+      if (editorRef.current === editor2) {
+        editorRef.current = null;
+      }
+      if (modelRef.current === model) {
+        modelRef.current = null;
+      }
+    };
+  }, [languageId, options, resolvedModelUri, setupOptions, theme, themeName]);
+  return /* @__PURE__ */ jsxs("div", { className, children: [
+    /* @__PURE__ */ jsx("div", { "aria-label": "PDL source", className: editorClassName, ref: hostRef }),
+    setupError ? /* @__PURE__ */ jsxs("div", { className: "editor-error", children: [
+      "Editor failed to load: ",
+      setupError
+    ] }) : null
+  ] });
+}
+function setupPdlMonaco(options = {}) {
+  setupPromise ?? (setupPromise = setupPdlMonacoOnce(options).catch((error) => {
+    setupPromise = null;
+    throw error;
+  }));
+  return setupPromise;
+}
+function registerPdlLanguage(options = {}) {
+  const languageId = options.languageId ?? PDL_LANGUAGE_ID;
+  if (monaco.languages.getLanguages().some((language) => language.id === languageId)) {
+    return;
+  }
+  monaco.languages.register({
+    id: languageId,
+    aliases: options.aliases ?? ["PDL", "pdl"],
+    extensions: options.extensions ?? [".pdl"]
+  });
+  monaco.languages.setLanguageConfiguration(
+    languageId,
+    options.languageConfiguration ?? language_configuration_default
+  );
+}
+function definePdlTheme(themeName = PDL_THEME_NAME, theme = defaultPdlTheme()) {
+  monaco.editor.defineTheme(themeName, theme);
+}
+function defaultPdlTheme() {
+  return {
+    base: "vs",
+    inherit: true,
+    rules: [
+      { token: "comment", foreground: "6b7280", fontStyle: "italic" },
+      { token: "string", foreground: "7a4a10" },
+      { token: "number", foreground: "b42318" },
+      { token: "keyword", foreground: "166f5c", fontStyle: "bold" },
+      { token: "function", foreground: "0f5f8f", fontStyle: "bold" },
+      { token: "property", foreground: "0e7490" },
+      { token: "variable", foreground: "355f8c" },
+      { token: "pdlBindingDeclaration", foreground: "7c3aed", fontStyle: "bold" },
+      { token: "pdlBindingReference", foreground: "6d28d9" },
+      { token: "pdlColumnDefinition", foreground: "475569" },
+      { token: "pdlColumnReference", foreground: "0e7490" },
+      { token: "pdlContextDeclaration", foreground: "9a5512", fontStyle: "bold" },
+      { token: "pdlContextReference", foreground: "9a5512" },
+      { token: "operator", foreground: "4f5b63" },
+      { token: "constant.character.escape", foreground: "9f5b00", fontStyle: "bold" },
+      { token: "constant.numeric", foreground: "b42318" },
+      { token: "constant.language", foreground: "6f42c1" },
+      { token: "invalid.illegal", foreground: "b42318", fontStyle: "underline" },
+      { token: "keyword.control", foreground: "166f5c", fontStyle: "bold" },
+      { token: "keyword.declaration", foreground: "166f5c", fontStyle: "bold" },
+      { token: "keyword.operator.frame", foreground: "7a3f98", fontStyle: "bold" },
+      { token: "keyword.operator", foreground: "4f5b63" },
+      { token: "support.function", foreground: "0f5f8f", fontStyle: "bold" },
+      { token: "support.function.aggregate", foreground: "0f5f8f", fontStyle: "bold" },
+      { token: "support.function.aggregate.pdl", foreground: "0f5f8f", fontStyle: "bold" },
+      { token: "support.function.scalar", foreground: "0f5f8f", fontStyle: "bold" },
+      { token: "support.function.scalar.pdl", foreground: "0f5f8f", fontStyle: "bold" },
+      { token: "support.function.window", foreground: "0f5f8f", fontStyle: "bold" },
+      { token: "support.function.window.pdl", foreground: "0f5f8f", fontStyle: "bold" },
+      { token: "entity.name.function.geometry", foreground: "0f5f8f", fontStyle: "bold" },
+      { token: "entity.name.function.stat", foreground: "7a3f98", fontStyle: "bold" },
+      { token: "entity.name.function.source", foreground: "3c6b22", fontStyle: "bold" },
+      { token: "entity.name.function.literal", foreground: "6f42c1" },
+      { token: "entity.name.function", foreground: "315f7d" },
+      { token: "entity.name.namespace", foreground: "7c3aed", fontStyle: "bold" },
+      { token: "support.type.namespace", foreground: "2563eb", fontStyle: "bold" },
+      { token: "variable.parameter.property.unknown", foreground: "a33d2d" },
+      { token: "variable.parameter.property", foreground: "9a5512" },
+      { token: "variable.other.declaration", foreground: "7c3aed", fontStyle: "bold" },
+      { token: "variable.other.binding", foreground: "2563eb", fontStyle: "bold" },
+      { token: "variable.other.quoted", foreground: "385f70" },
+      { token: "variable.parameter", foreground: "475569" },
+      { token: "variable.other.member", foreground: "475569" },
+      { token: "variable.other.readwrite", foreground: "475569" },
+      { token: "variable.other.column.definition", foreground: "475569" },
+      { token: "variable.other.column", foreground: "0e7490" },
+      { token: "punctuation", foreground: "68757d" }
+    ],
+    colors: {
+      "editor.background": "#ffffff",
+      "editor.foreground": "#171f24",
+      "editor.lineHighlightBackground": "#f4f7f6",
+      "editorLineNumber.foreground": "#9aa6ac",
+      "editorLineNumber.activeForeground": "#21695d",
+      "editorCursor.foreground": "#1f6f62",
+      "editor.selectionBackground": "#cfe8df",
+      "editor.inactiveSelectionBackground": "#e8f2ee",
+      "editorIndentGuide.background1": "#edf1f3",
+      "editorIndentGuide.activeBackground1": "#c9d8d3"
+    }
+  };
+}
+function registerPdlEditorProviders(options) {
+  const languageId = options.languageId ?? PDL_LANGUAGE_ID;
+  const programPathForRequest = options.programPathForModel ?? programPathForModel;
+  const disposables = [
+    monaco.languages.registerHoverProvider(languageId, {
+      provideHover(model, position) {
+        const hover = requestFeature(model, options, programPathForRequest, {
+          kind: "hover",
+          position: toTextPosition(position)
+        });
+        if (!hover) {
+          return null;
+        }
+        return {
+          contents: [{ value: hover.markdown, isTrusted: false, supportHtml: false }],
+          range: fromTextRange(hover.range)
+        };
+      }
+    }),
+    monaco.languages.registerCompletionItemProvider(languageId, {
+      triggerCharacters: ["|", '"', " ", "$", "@"],
+      provideCompletionItems(model, position) {
+        const completions = requestFeature(model, options, programPathForRequest, {
+          kind: "completion",
+          position: toTextPosition(position)
+        });
+        return {
+          suggestions: (completions ?? []).map((item) => completionItem(item, position))
+        };
+      }
+    }),
+    monaco.languages.registerDocumentFormattingEditProvider(languageId, {
+      provideDocumentFormattingEdits(model) {
+        const edit = requestFeature(model, options, programPathForRequest, {
+          kind: "formatting"
+        });
+        return edit ? [textEdit(edit)] : [];
+      }
+    }),
+    monaco.languages.registerDocumentSemanticTokensProvider(languageId, {
+      getLegend() {
+        return {
+          tokenTypes: SEMANTIC_TOKEN_TYPES,
+          tokenModifiers: []
+        };
+      },
+      provideDocumentSemanticTokens(model) {
+        const tokens = requestFeature(model, options, programPathForRequest, {
+          kind: "semanticTokens"
+        });
+        return {
+          data: new Uint32Array(encodeSemanticTokens(tokens ?? [])),
+          resultId: void 0
+        };
+      },
+      releaseDocumentSemanticTokens() {
+        return void 0;
+      }
+    }),
+    monaco.languages.registerDefinitionProvider(languageId, {
+      provideDefinition(model, position) {
+        const location = requestFeature(model, options, programPathForRequest, {
+          kind: "definition",
+          position: toTextPosition(position)
+        });
+        return location ? [{ uri: model.uri, range: fromTextRange(location.range) }] : [];
+      }
+    }),
+    monaco.languages.registerReferenceProvider(languageId, {
+      provideReferences(model, position) {
+        const locations = requestFeature(model, options, programPathForRequest, {
+          kind: "references",
+          position: toTextPosition(position)
+        });
+        return (locations ?? []).map((location) => ({
+          uri: model.uri,
+          range: fromTextRange(location.range)
+        }));
+      }
+    }),
+    monaco.languages.registerRenameProvider(languageId, {
+      provideRenameEdits(model, position, newName) {
+        const edits = requestFeature(model, options, programPathForRequest, {
+          kind: "rename",
+          position: toTextPosition(position),
+          newName
+        });
+        return {
+          edits: (edits ?? []).map((edit) => ({
+            resource: model.uri,
+            textEdit: textEdit(edit),
+            versionId: void 0
+          }))
+        };
+      }
+    }),
+    monaco.languages.registerDocumentSymbolProvider(languageId, {
+      provideDocumentSymbols(model) {
+        const symbols = requestFeature(model, options, programPathForRequest, {
+          kind: "documentSymbols"
+        });
+        return (symbols ?? []).map(documentSymbol);
+      }
+    })
+  ];
+  return {
+    dispose() {
+      for (const disposable of disposables) {
+        disposable.dispose();
+      }
+    }
+  };
+}
+function programPathForModel(model) {
+  const path = model.uri.path.replace(/^\/+/, "");
+  return path ? `memory/${path}` : "memory/main.pdl";
+}
+function setPdlMarkers(model, diagnostics) {
+  monaco.editor.setModelMarkers(
+    model,
+    PDL_MARKER_OWNER,
+    diagnostics.map((diagnostic) => diagnosticToPdlMarker(diagnostic))
+  );
+}
+function diagnosticToPdlMarker(diagnostic) {
+  const start = fromTextPosition(diagnostic.range.start);
+  const end = fromTextPosition(diagnostic.range.end);
+  return {
+    code: diagnostic.code,
+    severity: severityToMarkerSeverity(diagnostic.severity),
+    source: "PDL",
+    message: diagnostic.message,
+    startLineNumber: start.lineNumber,
+    startColumn: start.column,
+    endLineNumber: end.lineNumber,
+    endColumn: end.column === start.column && end.lineNumber === start.lineNumber ? end.column + 1 : end.column
+  };
+}
+function ensurePdlProviders(languageId) {
+  providerDisposable ?? (providerDisposable = registerPdlEditorProviders({
+    languageId,
+    getRuntime: (model) => editorContexts.get(model.uri.toString())?.runtime() ?? null,
+    getFiles: (model) => editorContexts.get(model.uri.toString())?.files() ?? {}
+  }));
+}
+async function setupPdlMonacoOnce(options) {
+  if (options.configureWorker !== false) {
+    configureMonacoWorker();
+  }
+  registerPdlLanguage(options);
+  definePdlTheme(options.themeName ?? PDL_THEME_NAME, options.theme ?? defaultPdlTheme());
+  await loadOnigasmOnce(options.onigasmWasmUrl ?? onigasmWasmUrl);
+  const registry = new Registry({
+    getGrammarDefinition: async () => ({
+      format: "json",
+      content: options.grammar ?? pdl_tmLanguage_default
+    })
+  });
+  await wireTmGrammars(
+    monaco,
+    registry,
+    /* @__PURE__ */ new Map([[options.languageId ?? PDL_LANGUAGE_ID, options.scopeName ?? PDL_SCOPE_NAME]])
+  );
+}
+function configureMonacoWorker() {
+  const target = globalThis;
+  target.MonacoEnvironment ?? (target.MonacoEnvironment = {
+    getWorker: () => new EditorWorker()
+  });
+}
+function loadOnigasmOnce(url) {
+  onigasmPromise ?? (onigasmPromise = loadOnigasm(url).catch((error) => {
+    onigasmPromise = null;
+    throw error;
+  }));
+  return onigasmPromise;
+}
+function requestFeature(model, options, resolveProgramPath, request) {
+  const runtime = options.getRuntime(model);
+  if (!runtime) {
+    return null;
+  }
+  const response = runtime.editorService(model.getValue(), options.getFiles(model), request, resolveProgramPath(model));
+  if (response.error) {
+    console.warn(`PDL editor service failed: ${response.error}`);
+    return null;
+  }
+  return response.result;
+}
+function toTextPosition(position) {
+  return {
+    line: Math.max(0, position.lineNumber - 1),
+    character: Math.max(0, position.column - 1)
+  };
+}
+function fromTextPosition(position) {
+  return {
+    lineNumber: position.line + 1,
+    column: position.character + 1
+  };
+}
+function fromTextRange(range) {
+  const start = fromTextPosition(range.start);
+  const end = fromTextPosition(range.end);
+  return new monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column);
+}
+function completionItem(item, position) {
+  return {
+    label: item.label,
+    kind: completionKind(item.kind),
+    detail: item.detail,
+    insertText: item.insert_text,
+    range: new monaco.Range(position.lineNumber, position.column, position.lineNumber, position.column)
+  };
+}
+function completionKind(kind) {
+  switch (kind) {
+    case "Binding":
+    case "Context":
+      return monaco.languages.CompletionItemKind.Variable;
+    case "Column":
+      return monaco.languages.CompletionItemKind.Field;
+    case "Format":
+      return monaco.languages.CompletionItemKind.EnumMember;
+    case "Function":
+      return monaco.languages.CompletionItemKind.Function;
+    case "Keyword":
+    case "Stage":
+      return monaco.languages.CompletionItemKind.Keyword;
+  }
+}
+function textEdit(edit) {
+  return {
+    range: fromTextRange(edit.range),
+    text: edit.new_text
+  };
+}
+function encodeSemanticTokens(tokens) {
+  let previousLine = 0;
+  let previousStart = 0;
+  const data = [];
+  for (const token of tokens) {
+    if (token.range.start.line !== token.range.end.line) {
+      continue;
+    }
+    const deltaLine = token.range.start.line - previousLine;
+    const deltaStart = deltaLine === 0 ? token.range.start.character - previousStart : token.range.start.character;
+    const length = token.range.end.character - token.range.start.character;
+    if (length <= 0) {
+      continue;
+    }
+    data.push(deltaLine, deltaStart, length, semanticTokenIndex(token.token_type), 0);
+    previousLine = token.range.start.line;
+    previousStart = token.range.start.character;
+  }
+  return data;
+}
+function semanticTokenIndex(kind) {
+  switch (kind) {
+    case "Keyword":
+      return 0;
+    case "Function":
+      return 1;
+    case "Variable":
+      return 2;
+    case "String":
+      return 3;
+    case "Number":
+      return 4;
+    case "Operator":
+      return 5;
+    case "BindingDeclaration":
+      return 6;
+    case "BindingReference":
+      return 7;
+    case "ColumnDefinition":
+      return 8;
+    case "ColumnReference":
+      return 9;
+    case "ContextDeclaration":
+      return 10;
+    case "ContextReference":
+      return 11;
+  }
+}
+function documentSymbol(symbol) {
+  return {
+    name: symbol.name,
+    detail: symbol.detail,
+    kind: symbolKind(symbol.kind),
+    range: fromTextRange(symbol.range),
+    selectionRange: fromTextRange(symbol.selection_range),
+    tags: [],
+    children: symbol.children.map(documentSymbol)
+  };
+}
+function symbolKind(kind) {
+  switch (kind) {
+    case "Binding":
+    case "Context":
+      return monaco.languages.SymbolKind.Variable;
+    case "Function":
+      return monaco.languages.SymbolKind.Function;
+    case "Stage":
+      return monaco.languages.SymbolKind.Method;
+  }
+}
+function severityToMarkerSeverity(severity) {
+  switch (severity) {
+    case "error":
+      return monaco.MarkerSeverity.Error;
+    case "warning":
+      return monaco.MarkerSeverity.Warning;
+    case "info":
+      return monaco.MarkerSeverity.Info;
+    case "hint":
+      return monaco.MarkerSeverity.Hint;
+  }
+}
+export {
+  PDL_DEFAULT_MODEL_URI,
+  PDL_LANGUAGE_ID,
+  PDL_MARKER_OWNER,
+  PDL_SCOPE_NAME,
+  PDL_THEME_NAME,
+  PdlEditor,
+  defaultPdlTheme,
+  definePdlTheme,
+  diagnosticToPdlMarker,
+  programPathForModel,
+  registerPdlEditorProviders,
+  registerPdlLanguage,
+  setPdlMarkers,
+  setupPdlMonaco
+};