algraf-editor 0.67.0

package/dist/index.cjs

@@ -0,0 +1,1161 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.tsx
+var index_exports = {};
+__export(index_exports, {
+  ALGRAF_DEFAULT_MODEL_URI: () => ALGRAF_DEFAULT_MODEL_URI,
+  ALGRAF_LANGUAGE_ID: () => ALGRAF_LANGUAGE_ID,
+  ALGRAF_MARKER_OWNER: () => ALGRAF_MARKER_OWNER,
+  ALGRAF_SCOPE_NAME: () => ALGRAF_SCOPE_NAME,
+  ALGRAF_THEME_NAME: () => ALGRAF_THEME_NAME,
+  AlgrafEditor: () => AlgrafEditor,
+  defaultAlgrafTheme: () => defaultAlgrafTheme,
+  defineAlgrafTheme: () => defineAlgrafTheme,
+  diagnosticToAlgrafMarker: () => diagnosticToAlgrafMarker,
+  registerAlgrafEditorProviders: () => registerAlgrafEditorProviders,
+  registerAlgrafLanguage: () => registerAlgrafLanguage,
+  setAlgrafMarkers: () => setAlgrafMarkers,
+  setupAlgrafMonaco: () => setupAlgrafMonaco
+});
+module.exports = __toCommonJS(index_exports);
+var import_react = __toESM(require("react"), 1);
+var monaco2 = __toESM(require("monaco-editor/esm/vs/editor/editor.api"), 1);
+var import_editor_main = require("monaco-editor/min/vs/editor/editor.main.css");
+var import_hoverContribution = require("monaco-editor/esm/vs/editor/contrib/hover/browser/hoverContribution");
+var import_editor = __toESM(require("monaco-editor/esm/vs/editor/editor.worker?worker"), 1);
+var import_monaco_editor_textmate = require("monaco-editor-textmate");
+var import_monaco_textmate = require("monaco-textmate");
+var import_onigasm = require("onigasm");
+var import_onigasm2 = __toESM(require("onigasm/lib/onigasm.wasm?url"), 1);
+
+// assets/algraf.tmLanguage.json
+var algraf_tmLanguage_default = {
+  $schema: "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  name: "Algraf",
+  scopeName: "source.algraf",
+  patterns: [
+    {
+      include: "#comments"
+    },
+    {
+      include: "#strings"
+    },
+    {
+      include: "#quoted-identifiers"
+    },
+    {
+      include: "#numbers"
+    },
+    {
+      include: "#let-bindings"
+    },
+    {
+      include: "#declarations"
+    },
+    {
+      include: "#interactions"
+    },
+    {
+      include: "#geometries"
+    },
+    {
+      include: "#stats"
+    },
+    {
+      include: "#sources"
+    },
+    {
+      include: "#constants"
+    },
+    {
+      include: "#properties"
+    },
+    {
+      include: "#columns"
+    },
+    {
+      include: "#operators"
+    },
+    {
+      include: "#functions"
+    }
+  ],
+  repository: {
+    comments: {
+      patterns: [
+        {
+          name: "comment.line.double-slash.algraf",
+          match: "//.*$"
+        }
+      ]
+    },
+    strings: {
+      patterns: [
+        {
+          name: "string.quoted.double.algraf",
+          begin: '"',
+          end: '"',
+          patterns: [
+            {
+              name: "constant.character.escape.algraf",
+              match: '\\\\[nrt"\\\\]'
+            },
+            {
+              name: "invalid.illegal.escape.algraf",
+              match: "\\\\."
+            }
+          ]
+        }
+      ]
+    },
+    "quoted-identifiers": {
+      patterns: [
+        {
+          name: "variable.other.quoted.algraf",
+          begin: "`",
+          end: "`",
+          patterns: [
+            {
+              name: "constant.character.escape.algraf",
+              match: "\\\\[`\\\\]"
+            }
+          ]
+        }
+      ]
+    },
+    numbers: {
+      patterns: [
+        {
+          name: "constant.numeric.algraf",
+          match: "\\b-?[0-9]+(?:\\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\\b"
+        }
+      ]
+    },
+    "let-bindings": {
+      patterns: [
+        {
+          match: "\\b(let)\\s+([A-Za-z_][A-Za-z0-9_]*)",
+          captures: {
+            "1": {
+              name: "keyword.declaration.let.algraf"
+            },
+            "2": {
+              name: "variable.other.declaration.algraf"
+            }
+          }
+        }
+      ]
+    },
+    declarations: {
+      patterns: [
+        {
+          name: "keyword.declaration.algraf",
+          match: "\\b(?:Algraf|Chart|Space|Inset|Derive|from|Table|Parse|Scale|Guide|Theme|Layout)\\b"
+        },
+        {
+          name: "keyword.declaration.let.algraf",
+          match: "\\blet\\b"
+        }
+      ]
+    },
+    geometries: {
+      patterns: [
+        {
+          name: "entity.name.function.geometry.algraf",
+          match: "\\b(?:Point|Line|Path|Bar|Rect|Histogram|FreqPoly|Bin2D|HexBin|Smooth|Boxplot|Violin|Density|ErrorBar|LineRange|PointRange|CrossBar|Ribbon|Tile|HLine|VLine|Rug|Area|Text|Label|Image|Segment|Geo|Graticule)\\b(?=\\s*\\()"
+        }
+      ]
+    },
+    interactions: {
+      patterns: [
+        {
+          name: "entity.name.function.interaction.algraf",
+          match: "\\bOn\\b(?=\\s*\\()"
+        }
+      ]
+    },
+    stats: {
+      patterns: [
+        {
+          name: "entity.name.function.stat.algraf",
+          match: "\\b(?:Bin|Bin2D|HexBin|Summary2D|SummaryHex|ContourLines|ContourBands|Density2D|Density2DContours|Density2DBands|Distinct|Ecdf|Qq|Summary|SummaryBin|Cut|Count|Smooth|StepVertices|JitterPoints|VectorEndpoints|CurveSample|IntervalSegments|IntervalRects|IntervalMiddles|Boxplot|Density|Centroid|Simplify|SpatialJoin)\\b(?=\\s*\\()"
+        }
+      ]
+    },
+    sources: {
+      patterns: [
+        {
+          name: "entity.name.function.source.algraf",
+          match: "\\b(?:GeoJson|Shapefile|Sqlite|TopoJson|Style|Stop)\\b(?=\\s*\\()"
+        },
+        {
+          name: "entity.name.function.literal.algraf",
+          match: "\\b(?:datetime|date)\\b(?=\\s*\\()"
+        }
+      ]
+    },
+    constants: {
+      patterns: [
+        {
+          name: "constant.language.algraf",
+          match: "\\b(?:true|false|null|stdin)\\b"
+        }
+      ]
+    },
+    properties: {
+      patterns: [
+        {
+          name: "variable.parameter.property.algraf",
+          match: "\\b(?:version|features|data|match|width|height|minSize|maxSize|padding|placement|clip|title|subtitle|caption|alt|description|marginTop|marginRight|marginBottom|marginLeft|facetColumns|facetRows|facetCols|facetScales|facetLabel|facetLabels|panelSpacing|axis|legend|grid|timeFormat|tickLabelAngle|tickLabelRows|table|column|format|formats|unit|timezone|onError|coords|zoomX|zoomY|aspect|theta|innerRadius|startAngle|direction|radius|fill|stroke|strokeWidth|dash|alpha|size|shape|src|group|sort|layout|baseline|stat|xmin|xmax|ymin|ymax|bins|binWidth|boundary|closed|interval|bandwidth|n|quantiles|outliers|span|se|taper|curvature|points|lengthScale|type|mode|domain|breaks|expand|expansion|range|reverse|integer|palette|gradient|labels|reducer|by|distribution|reference|output|method|label|at|anchor|dx|dy|nudge|nudgeData|jitter|x|y|xend|yend|sides|tooltip|highlight|projection|name|plotTitle|plotSubtitle|plotCaption|axisTitle|axisText|stripText|legendTitle|legendText|panelBackground|gridMajor|gridMinor|legendPosition|legendSpacing|fontFamily|fontSize|titleSize|pointSize|lineWidth|background|plotBackground|axisColor|gridColor|textColor|axes|style|color|value)\\b(?=\\s*:)"
+        },
+        {
+          name: "variable.parameter.property.unknown.algraf",
+          match: "\\b[A-Za-z_][A-Za-z0-9_]*\\b(?=\\s*:)"
+        }
+      ]
+    },
+    columns: {
+      patterns: [
+        {
+          name: "variable.other.column.algraf",
+          match: "\\b[A-Za-z_][A-Za-z0-9_]*\\b(?!\\s*[:(])"
+        }
+      ]
+    },
+    operators: {
+      patterns: [
+        {
+          name: "keyword.operator.algebra.algraf",
+          match: "[*/+]"
+        },
+        {
+          name: "keyword.operator.map.algraf",
+          match: "=>"
+        },
+        {
+          name: "keyword.operator.assignment.algraf",
+          match: "="
+        },
+        {
+          name: "punctuation.separator.comma.algraf",
+          match: ","
+        },
+        {
+          name: "punctuation.separator.key-value.algraf",
+          match: ":"
+        },
+        {
+          name: "punctuation.section.braces.algraf",
+          match: "[{}]"
+        },
+        {
+          name: "punctuation.section.parens.algraf",
+          match: "[()]"
+        },
+        {
+          name: "punctuation.section.brackets.algraf",
+          match: "[\\[\\]]"
+        }
+      ]
+    },
+    functions: {
+      patterns: [
+        {
+          name: "entity.name.function.algraf",
+          match: "\\b[A-Za-z_][A-Za-z0-9_]*\\b(?=\\s*\\()"
+        }
+      ]
+    }
+  }
+};
+
+// assets/language-configuration.json
+var language_configuration_default = {
+  comments: {
+    lineComment: "//"
+  },
+  brackets: [
+    [
+      "{",
+      "}"
+    ],
+    [
+      "(",
+      ")"
+    ],
+    [
+      "[",
+      "]"
+    ]
+  ],
+  autoClosingPairs: [
+    {
+      open: "{",
+      close: "}"
+    },
+    {
+      open: "(",
+      close: ")"
+    },
+    {
+      open: "[",
+      close: "]"
+    },
+    {
+      open: '"',
+      close: '"',
+      notIn: [
+        "string",
+        "comment"
+      ]
+    },
+    {
+      open: "`",
+      close: "`",
+      notIn: [
+        "string",
+        "comment"
+      ]
+    }
+  ],
+  surroundingPairs: [
+    {
+      open: "{",
+      close: "}"
+    },
+    {
+      open: "(",
+      close: ")"
+    },
+    {
+      open: "[",
+      close: "]"
+    },
+    {
+      open: '"',
+      close: '"'
+    },
+    {
+      open: "`",
+      close: "`"
+    }
+  ],
+  folding: {
+    markers: {
+      start: "^\\s*//\\s*#region\\b",
+      end: "^\\s*//\\s*#endregion\\b"
+    }
+  },
+  wordPattern: "`[^`]*(?:\\\\.[^`]*)*`|[A-Za-z_][A-Za-z0-9_]*"
+};
+
+// src/providers.ts
+var monaco = __toESM(require("monaco-editor/esm/vs/editor/editor.api"), 1);
+var SEMANTIC_TOKEN_TYPES = [
+  "keyword",
+  "function",
+  "property",
+  "variable",
+  "operator",
+  "string",
+  "number",
+  "comment"
+];
+function registerAlgrafEditorProviders(languageId, getRuntime, getFiles) {
+  const disposables = [
+    monaco.languages.registerHoverProvider(languageId, {
+      provideHover(model, position) {
+        const hover = requestFeature(model, getRuntime, getFiles, {
+          kind: "hover",
+          position: toLspPosition(position)
+        });
+        if (!hover) {
+          return null;
+        }
+        return {
+          contents: hoverContents(hover.contents),
+          range: hover.range ? fromLspRange(hover.range) : void 0
+        };
+      }
+    }),
+    monaco.languages.registerCompletionItemProvider(languageId, {
+      triggerCharacters: [":", "*", "/", "+", "("],
+      provideCompletionItems(model, position) {
+        const response = requestFeature(
+          model,
+          getRuntime,
+          getFiles,
+          {
+            kind: "completion",
+            position: toLspPosition(position)
+          }
+        );
+        const items = Array.isArray(response) ? response : response?.items ?? [];
+        return {
+          suggestions: items.map((item) => completionItem(item, position))
+        };
+      }
+    }),
+    monaco.languages.registerSignatureHelpProvider(languageId, {
+      signatureHelpTriggerCharacters: ["(", ","],
+      signatureHelpRetriggerCharacters: [","],
+      provideSignatureHelp(model, position) {
+        const help = requestFeature(model, getRuntime, getFiles, {
+          kind: "signatureHelp",
+          position: toLspPosition(position)
+        });
+        if (!help) {
+          return null;
+        }
+        return {
+          value: {
+            activeSignature: help.activeSignature ?? 0,
+            activeParameter: help.activeParameter ?? 0,
+            signatures: help.signatures.map((signature) => ({
+              label: signature.label,
+              documentation: markdownString(signature.documentation),
+              parameters: (signature.parameters ?? []).map((parameter) => ({
+                label: parameter.label,
+                documentation: markdownString(parameter.documentation)
+              }))
+            }))
+          },
+          dispose: () => void 0
+        };
+      }
+    }),
+    monaco.languages.registerDocumentFormattingEditProvider(languageId, {
+      provideDocumentFormattingEdits(model) {
+        const edits = requestFeature(model, getRuntime, getFiles, {
+          kind: "formatting"
+        });
+        return (edits ?? []).map(textEdit);
+      }
+    }),
+    monaco.languages.registerDocumentRangeFormattingEditProvider(languageId, {
+      provideDocumentRangeFormattingEdits(model, range) {
+        const edits = requestFeature(model, getRuntime, getFiles, {
+          kind: "rangeFormatting",
+          range: toLspRange(range)
+        });
+        return (edits ?? []).map(textEdit);
+      }
+    }),
+    monaco.languages.registerDocumentSemanticTokensProvider(languageId, {
+      getLegend() {
+        return {
+          tokenTypes: SEMANTIC_TOKEN_TYPES,
+          tokenModifiers: []
+        };
+      },
+      provideDocumentSemanticTokens(model) {
+        const result = requestFeature(
+          model,
+          getRuntime,
+          getFiles,
+          {
+            kind: "semanticTokens"
+          }
+        );
+        return {
+          data: new Uint32Array(flattenSemanticTokens(result?.data ?? [])),
+          resultId: void 0
+        };
+      },
+      releaseDocumentSemanticTokens() {
+        return void 0;
+      }
+    }),
+    monaco.languages.registerCodeActionProvider(languageId, {
+      provideCodeActions(model, range, context) {
+        const actions = requestFeature(model, getRuntime, getFiles, {
+          kind: "codeActions",
+          range: toLspRange(range),
+          diagnostics: context.markers.map(markerToDiagnostic)
+        });
+        return {
+          actions: (actions ?? []).map((action) => codeAction(action, model.uri)),
+          dispose: () => void 0
+        };
+      }
+    }),
+    monaco.languages.registerDefinitionProvider(languageId, {
+      provideDefinition(model, position) {
+        const result = requestFeature(
+          model,
+          getRuntime,
+          getFiles,
+          {
+            kind: "definition",
+            position: toLspPosition(position)
+          }
+        );
+        return locations(result);
+      }
+    }),
+    monaco.languages.registerReferenceProvider(languageId, {
+      provideReferences(model, position, context) {
+        const result = requestFeature(model, getRuntime, getFiles, {
+          kind: "references",
+          position: toLspPosition(position),
+          includeDeclaration: context.includeDeclaration
+        });
+        return locations(result);
+      }
+    }),
+    monaco.languages.registerDocumentHighlightProvider(languageId, {
+      provideDocumentHighlights(model, position) {
+        const result = requestFeature(model, getRuntime, getFiles, {
+          kind: "documentHighlights",
+          position: toLspPosition(position)
+        });
+        return (result ?? []).map((highlight) => ({
+          range: fromLspRange(highlight.range),
+          kind: documentHighlightKind(highlight.kind)
+        }));
+      }
+    }),
+    monaco.languages.registerRenameProvider(languageId, {
+      resolveRenameLocation(model, position) {
+        const response = requestFeature(model, getRuntime, getFiles, {
+          kind: "prepareRename",
+          position: toLspPosition(position)
+        });
+        const range = "range" in (response ?? {}) ? response.range : response;
+        if (!range) {
+          return {
+            range: new monaco.Range(position.lineNumber, position.column, position.lineNumber, position.column),
+            text: "",
+            rejectReason: "This symbol cannot be renamed."
+          };
+        }
+        return {
+          range: fromLspRange(range),
+          text: model.getValueInRange(fromLspRange(range))
+        };
+      },
+      provideRenameEdits(model, position, newName) {
+        const edit = requestFeature(model, getRuntime, getFiles, {
+          kind: "rename",
+          position: toLspPosition(position),
+          newName
+        });
+        if (!edit) {
+          return { edits: [] };
+        }
+        return workspaceEdit(edit);
+      }
+    }),
+    monaco.languages.registerDocumentSymbolProvider(languageId, {
+      provideDocumentSymbols(model) {
+        const result = requestFeature(model, getRuntime, getFiles, {
+          kind: "documentSymbols"
+        });
+        return (result ?? []).map(documentSymbol);
+      }
+    })
+  ];
+  return {
+    dispose() {
+      for (const disposable of disposables) {
+        disposable.dispose();
+      }
+    }
+  };
+}
+function requestFeature(model, getRuntime, getFiles, request) {
+  const runtime = getRuntime(model);
+  if (!runtime) {
+    return null;
+  }
+  const response = runtime.editorService(model.getValue(), getFiles(model), request, model.uri.toString());
+  if (response.error) {
+    console.warn(`Algraf editor service failed: ${response.error}`);
+    return null;
+  }
+  return response.result;
+}
+function toLspPosition(position) {
+  return {
+    line: Math.max(0, position.lineNumber - 1),
+    character: Math.max(0, position.column - 1)
+  };
+}
+function fromLspPosition(position) {
+  return {
+    lineNumber: position.line + 1,
+    column: position.character + 1
+  };
+}
+function toLspRange(range) {
+  return {
+    start: toLspPosition({ lineNumber: range.startLineNumber, column: range.startColumn }),
+    end: toLspPosition({ lineNumber: range.endLineNumber, column: range.endColumn })
+  };
+}
+function fromLspRange(range) {
+  const start = fromLspPosition(range.start);
+  const end = fromLspPosition(range.end);
+  return new monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column);
+}
+function hoverContents(contents) {
+  const values = Array.isArray(contents) ? contents : [contents];
+  return values.map((value) => ({
+    value: typeof value === "string" ? value : value.value,
+    isTrusted: false,
+    supportThemeIcons: false,
+    supportHtml: false
+  }));
+}
+function markdownString(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return {
+    value: value.value,
+    isTrusted: false,
+    supportHtml: false
+  };
+}
+function completionItem(item, position) {
+  return {
+    label: item.label,
+    kind: completionKind(item.kind),
+    detail: item.detail,
+    documentation: markdownString(item.documentation),
+    insertText: item.insertText ?? item.label,
+    insertTextRules: item.insertTextFormat === 2 ? monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet : void 0,
+    range: new monaco.Range(position.lineNumber, position.column, position.lineNumber, position.column)
+  };
+}
+function completionKind(kind) {
+  switch (kind) {
+    case 3:
+      return monaco.languages.CompletionItemKind.Function;
+    case 5:
+      return monaco.languages.CompletionItemKind.Field;
+    case 10:
+      return monaco.languages.CompletionItemKind.Property;
+    case 12:
+      return monaco.languages.CompletionItemKind.Value;
+    case 14:
+      return monaco.languages.CompletionItemKind.Keyword;
+    case 15:
+      return monaco.languages.CompletionItemKind.Snippet;
+    case 16:
+      return monaco.languages.CompletionItemKind.Color;
+    case 24:
+      return monaco.languages.CompletionItemKind.Operator;
+    default:
+      return monaco.languages.CompletionItemKind.Text;
+  }
+}
+function textEdit(edit) {
+  return {
+    range: fromLspRange(edit.range),
+    text: edit.newText
+  };
+}
+function flattenSemanticTokens(data) {
+  if (data.length === 0 || typeof data[0] === "number") {
+    return data;
+  }
+  return data.flatMap((token) => [
+    token.deltaLine,
+    token.deltaStart,
+    token.length,
+    token.tokenType,
+    token.tokenModifiersBitset
+  ]);
+}
+function markerToDiagnostic(marker) {
+  return {
+    range: toLspRange(marker),
+    severity: markerSeverity(marker.severity),
+    code: markerCode(marker.code),
+    source: marker.source,
+    message: marker.message
+  };
+}
+function markerSeverity(severity) {
+  switch (severity) {
+    case monaco.MarkerSeverity.Error:
+      return 1;
+    case monaco.MarkerSeverity.Warning:
+      return 2;
+    case monaco.MarkerSeverity.Info:
+      return 3;
+    case monaco.MarkerSeverity.Hint:
+      return 4;
+  }
+}
+function markerCode(code) {
+  if (typeof code === "string" || typeof code === "number") {
+    return code;
+  }
+  return code?.value;
+}
+function codeAction(action, currentUri) {
+  return {
+    title: action.title,
+    kind: action.kind,
+    diagnostics: action.diagnostics?.map((diagnostic) => ({
+      severity: diagnosticSeverity(diagnostic.severity),
+      message: diagnostic.message,
+      startLineNumber: diagnostic.range.start.line + 1,
+      startColumn: diagnostic.range.start.character + 1,
+      endLineNumber: diagnostic.range.end.line + 1,
+      endColumn: diagnostic.range.end.character + 1
+    })),
+    edit: action.edit ? workspaceEdit(action.edit, currentUri) : void 0
+  };
+}
+function diagnosticSeverity(severity) {
+  switch (severity) {
+    case 1:
+      return monaco.MarkerSeverity.Error;
+    case 2:
+      return monaco.MarkerSeverity.Warning;
+    case 3:
+      return monaco.MarkerSeverity.Info;
+    case 4:
+      return monaco.MarkerSeverity.Hint;
+    default:
+      return monaco.MarkerSeverity.Info;
+  }
+}
+function workspaceEdit(edit, fallbackUri) {
+  const edits = [];
+  for (const [uri, textEdits] of Object.entries(edit.changes ?? {})) {
+    const resource = uri ? monaco.Uri.parse(uri) : fallbackUri;
+    if (!resource) {
+      continue;
+    }
+    for (const text of textEdits) {
+      edits.push({
+        resource,
+        textEdit: {
+          range: fromLspRange(text.range),
+          text: text.newText
+        },
+        versionId: void 0
+      });
+    }
+  }
+  return { edits };
+}
+function locations(result) {
+  const values = Array.isArray(result) ? result : result ? [result] : [];
+  return values.map((location) => ({
+    uri: monaco.Uri.parse(location.uri),
+    range: fromLspRange(location.range)
+  }));
+}
+function documentHighlightKind(kind) {
+  switch (kind) {
+    case 3:
+      return monaco.languages.DocumentHighlightKind.Write;
+    case 2:
+      return monaco.languages.DocumentHighlightKind.Read;
+    default:
+      return monaco.languages.DocumentHighlightKind.Text;
+  }
+}
+function documentSymbol(symbol) {
+  return {
+    name: symbol.name,
+    detail: symbol.detail ?? "",
+    kind: symbolKind(symbol.kind),
+    range: fromLspRange(symbol.range),
+    selectionRange: fromLspRange(symbol.selectionRange),
+    tags: [],
+    children: symbol.children?.map(documentSymbol)
+  };
+}
+function symbolKind(kind) {
+  switch (kind) {
+    case 7:
+      return monaco.languages.SymbolKind.Property;
+    case 12:
+      return monaco.languages.SymbolKind.Function;
+    case 13:
+      return monaco.languages.SymbolKind.Variable;
+    case 19:
+      return monaco.languages.SymbolKind.Object;
+    default:
+      return monaco.languages.SymbolKind.Object;
+  }
+}
+
+// src/index.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var ALGRAF_LANGUAGE_ID = "algraf";
+var ALGRAF_SCOPE_NAME = "source.algraf";
+var ALGRAF_THEME_NAME = "algraf-playground";
+var ALGRAF_MARKER_OWNER = "algraf-wasm";
+var ALGRAF_DEFAULT_MODEL_URI = "inmemory://algraf/demo.ag";
+var encoder = new TextEncoder();
+var setupPromise = null;
+var onigasmPromise = null;
+var providerDisposable = null;
+var editorContexts = /* @__PURE__ */ new Map();
+function AlgrafEditor({
+  value,
+  files,
+  diagnostics,
+  runtime,
+  onChange,
+  modelUri,
+  languageId = ALGRAF_LANGUAGE_ID,
+  themeName = ALGRAF_THEME_NAME,
+  theme,
+  className = "algraf-editor-shell",
+  editorClassName = "algraf-editor",
+  options,
+  setupOptions
+}) {
+  const hostRef = import_react.default.useRef(null);
+  const editorRef = import_react.default.useRef(null);
+  const modelRef = import_react.default.useRef(null);
+  const onChangeRef = import_react.default.useRef(onChange);
+  const diagnosticsRef = import_react.default.useRef(diagnostics);
+  const filesRef = import_react.default.useRef(files);
+  const runtimeRef = import_react.default.useRef(runtime);
+  const [setupError, setSetupError] = import_react.default.useState(null);
+  const resolvedModelUri = import_react.default.useMemo(() => monaco2.Uri.parse(modelUri ?? ALGRAF_DEFAULT_MODEL_URI), [modelUri]);
+  import_react.default.useEffect(() => {
+    onChangeRef.current = onChange;
+  }, [onChange]);
+  import_react.default.useEffect(() => {
+    filesRef.current = files;
+  }, [files]);
+  import_react.default.useEffect(() => {
+    runtimeRef.current = runtime;
+  }, [runtime]);
+  import_react.default.useEffect(() => {
+    diagnosticsRef.current = diagnostics;
+    const model = modelRef.current;
+    if (model) {
+      setAlgrafMarkers(model, diagnostics);
+    }
+  }, [diagnostics]);
+  import_react.default.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);
+      }
+      setAlgrafMarkers(model, diagnosticsRef.current);
+    }
+  }, [value]);
+  import_react.default.useEffect(() => {
+    let cancelled = false;
+    let editor2 = null;
+    let model = null;
+    let contentDisposable = null;
+    let contextKey = null;
+    setupAlgrafMonaco({ ...setupOptions, languageId, themeName, theme }).then(() => {
+      if (cancelled || !hostRef.current) {
+        return;
+      }
+      ensureAlgrafProviders(languageId);
+      model = monaco2.editor.createModel(value, languageId, resolvedModelUri);
+      contextKey = model.uri.toString();
+      editorContexts.set(contextKey, {
+        runtime: () => runtimeRef.current,
+        files: () => filesRef.current
+      });
+      editor2 = monaco2.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: 4,
+        wordWrap: "off",
+        ...options
+      });
+      modelRef.current = model;
+      editorRef.current = editor2;
+      setAlgrafMarkers(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) {
+        monaco2.editor.setModelMarkers(model, ALGRAF_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__ */ (0, import_jsx_runtime.jsxs)("div", { className, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { "aria-label": "Algraf source", className: editorClassName, ref: hostRef }),
+    setupError ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "algraf-editor-error", children: [
+      "Editor failed to load: ",
+      setupError
+    ] }) : null
+  ] });
+}
+function ensureAlgrafProviders(languageId) {
+  providerDisposable ?? (providerDisposable = registerAlgrafEditorProviders(
+    languageId,
+    (model) => editorContexts.get(model.uri.toString())?.runtime() ?? null,
+    (model) => editorContexts.get(model.uri.toString())?.files() ?? {}
+  ));
+}
+function setupAlgrafMonaco(options = {}) {
+  setupPromise ?? (setupPromise = setupAlgrafMonacoOnce(options).catch((error) => {
+    setupPromise = null;
+    throw error;
+  }));
+  return setupPromise;
+}
+function registerAlgrafLanguage(options = {}) {
+  const languageId = options.languageId ?? ALGRAF_LANGUAGE_ID;
+  if (monaco2.languages.getLanguages().some((language) => language.id === languageId)) {
+    return;
+  }
+  monaco2.languages.register({
+    id: languageId,
+    aliases: options.aliases ?? ["Algraf", "algraf"],
+    extensions: options.extensions ?? [".ag"]
+  });
+  monaco2.languages.setLanguageConfiguration(
+    languageId,
+    options.languageConfiguration ?? language_configuration_default
+  );
+}
+async function setupAlgrafMonacoOnce(options) {
+  if (options.configureWorker !== false) {
+    configureMonacoWorker();
+  }
+  registerAlgrafLanguage(options);
+  defineAlgrafTheme(options.themeName ?? ALGRAF_THEME_NAME, options.theme ?? defaultAlgrafTheme());
+  await loadOnigasmOnce(options.onigasmWasmUrl ?? import_onigasm2.default);
+  const registry = new import_monaco_textmate.Registry({
+    getGrammarDefinition: async () => ({
+      format: "json",
+      content: options.grammar ?? algraf_tmLanguage_default
+    })
+  });
+  await (0, import_monaco_editor_textmate.wireTmGrammars)(
+    monaco2,
+    registry,
+    /* @__PURE__ */ new Map([[options.languageId ?? ALGRAF_LANGUAGE_ID, options.scopeName ?? ALGRAF_SCOPE_NAME]])
+  );
+}
+function configureMonacoWorker() {
+  const target = globalThis;
+  target.MonacoEnvironment ?? (target.MonacoEnvironment = {
+    getWorker: () => new import_editor.default()
+  });
+}
+function loadOnigasmOnce(url) {
+  onigasmPromise ?? (onigasmPromise = (0, import_onigasm.loadWASM)(url).catch((error) => {
+    onigasmPromise = null;
+    throw error;
+  }));
+  return onigasmPromise;
+}
+function defineAlgrafTheme(themeName = ALGRAF_THEME_NAME, theme = defaultAlgrafTheme()) {
+  monaco2.editor.defineTheme(themeName, theme);
+}
+function defaultAlgrafTheme() {
+  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: "9a5512" },
+      { token: "variable", foreground: "355f8c" },
+      { 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: "variable.parameter.property.unknown", foreground: "a33d2d" },
+      { token: "variable.parameter.property", foreground: "9a5512" },
+      { token: "variable.other.declaration", foreground: "145f52", fontStyle: "bold" },
+      { token: "variable.other.quoted", foreground: "385f70" },
+      { token: "variable.other.column", foreground: "355f8c" },
+      { 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 setAlgrafMarkers(model, diagnostics) {
+  monaco2.editor.setModelMarkers(
+    model,
+    ALGRAF_MARKER_OWNER,
+    diagnostics.map((diagnostic) => diagnosticToAlgrafMarker(model, diagnostic))
+  );
+}
+function diagnosticToAlgrafMarker(model, diagnostic) {
+  const start = byteOffsetToPosition(model.getValue(), diagnostic.span.start);
+  const end = normalizeEndPosition(model, start, byteOffsetToPosition(model.getValue(), diagnostic.span.end));
+  return {
+    code: diagnostic.code,
+    severity: severityToMarkerSeverity(diagnostic.severity),
+    source: "Algraf",
+    message: diagnostic.help ? `${diagnostic.message}
+
+${diagnostic.help}` : diagnostic.message,
+    startLineNumber: start.lineNumber,
+    startColumn: start.column,
+    endLineNumber: end.lineNumber,
+    endColumn: end.column,
+    relatedInformation: diagnostic.related?.map((related) => {
+      const relatedStart = byteOffsetToPosition(model.getValue(), related.span.start);
+      const relatedEnd = normalizeEndPosition(model, relatedStart, byteOffsetToPosition(model.getValue(), related.span.end));
+      return {
+        resource: model.uri,
+        message: related.message,
+        startLineNumber: relatedStart.lineNumber,
+        startColumn: relatedStart.column,
+        endLineNumber: relatedEnd.lineNumber,
+        endColumn: relatedEnd.column
+      };
+    })
+  };
+}
+function severityToMarkerSeverity(severity) {
+  switch (severity) {
+    case "error":
+      return monaco2.MarkerSeverity.Error;
+    case "warning":
+      return monaco2.MarkerSeverity.Warning;
+    case "information":
+      return monaco2.MarkerSeverity.Info;
+    case "hint":
+      return monaco2.MarkerSeverity.Hint;
+  }
+}
+function byteOffsetToPosition(source, targetByteOffset) {
+  const byteOffset = Math.max(0, targetByteOffset);
+  let bytesSeen = 0;
+  let lineNumber = 1;
+  let column = 1;
+  for (let index = 0; index < source.length && bytesSeen < byteOffset; ) {
+    const codePoint = source.codePointAt(index);
+    if (codePoint === void 0) {
+      break;
+    }
+    const char = String.fromCodePoint(codePoint);
+    const charBytes = encoder.encode(char).length;
+    if (bytesSeen + charBytes > byteOffset) {
+      break;
+    }
+    bytesSeen += charBytes;
+    index += char.length;
+    if (char === "\n") {
+      lineNumber += 1;
+      column = 1;
+    } else {
+      column += char.length;
+    }
+  }
+  return { lineNumber, column };
+}
+function normalizeEndPosition(model, start, end) {
+  if (end.lineNumber !== start.lineNumber || end.column !== start.column) {
+    return end;
+  }
+  const maxColumn = model.getLineMaxColumn(start.lineNumber);
+  if (start.column < maxColumn) {
+    return {
+      lineNumber: start.lineNumber,
+      column: start.column + 1
+    };
+  }
+  return end;
+}