@arcgis/coding-components 4.28.0-beta.2 → 4.28.0-beta.21

package/dist/esm/arcade-mode-b98b226c.js

@@ -0,0 +1,594 @@
+import { n as main, e as editor, M as MarkerSeverity, R as Range, l as languages, E as Emitter } from './arcade-defaults-a266962b.js';
+import './index-d4ec142a.js';
+
+var ge=(e=>(e.False="false",e.Null="null",e.True="true",e))(ge||{}),xe=(e=>(e.Break="break",e.Continue="continue",e.Else="else",e.For="for",e.From="from",e.Function="function",e.If="if",e.Import="import",e.Export="export",e.In="in",e.Return="return",e.Var="var",e.While="while",e))(xe||{}),c=(e=>(e.AssignmentExpression="AssignmentExpression",e.ArrayExpression="ArrayExpression",e.BlockComment="BlockComment",e.BlockStatement="BlockStatement",e.BinaryExpression="BinaryExpression",e.BreakStatement="BreakStatement",e.CallExpression="CallExpression",e.ContinueStatement="ContinueStatement",e.EmptyStatement="EmptyStatement",e.ExpressionStatement="ExpressionStatement",e.ExportNamedDeclaration="ExportNamedDeclaration",e.ExportSpecifier="ExportSpecifier",e.ForStatement="ForStatement",e.ForInStatement="ForInStatement",e.FunctionDeclaration="FunctionDeclaration",e.Identifier="Identifier",e.IfStatement="IfStatement",e.ImportDeclaration="ImportDeclaration",e.ImportDefaultSpecifier="ImportDefaultSpecifier",e.LineComment="LineComment",e.Literal="Literal",e.LogicalExpression="LogicalExpression",e.MemberExpression="MemberExpression",e.ObjectExpression="ObjectExpression",e.Program="Program",e.Property="Property",e.ReturnStatement="ReturnStatement",e.TemplateElement="TemplateElement",e.TemplateLiteral="TemplateLiteral",e.UnaryExpression="UnaryExpression",e.UpdateExpression="UpdateExpression",e.VariableDeclaration="VariableDeclaration",e.VariableDeclarator="VariableDeclarator",e.WhileStatement="WhileStatement",e))(c||{}),De=["++","--"],We=["-","+","!","~"],qe=["=","/=","*=","%=","+=","-="],He=["||","&&"],bt=["|","&",">>","<<",">>>","^","==","!=","<","<=",">",">=","+","-","*","/","%"],It=(e=>(e[e.Unknown=0]="Unknown",e[e.BooleanLiteral=1]="BooleanLiteral",e[e.EOF=2]="EOF",e[e.Identifier=3]="Identifier",e[e.Keyword=4]="Keyword",e[e.NullLiteral=5]="NullLiteral",e[e.NumericLiteral=6]="NumericLiteral",e[e.Punctuator=7]="Punctuator",e[e.StringLiteral=8]="StringLiteral",e[e.Template=10]="Template",e))(It||{}),kt=(e=>(e.InvalidModuleUri="InvalidModuleUri",e.ForInOfLoopInitializer="ForInOfLoopInitializer",e.IdentiferExpected="IdentiferExpected",e.InvalidEscapedReservedWord="InvalidEscapedReservedWord",e.InvalidExpression="InvalidExpression",e.InvalidFunctionIdentifier="InvalidFunctionIdentifier",e.InvalidHexEscapeSequence="InvalidHexEscapeSequence",e.InvalidLeftHandSideInAssignment="InvalidLeftHandSideInAssignment",e.InvalidLeftHandSideInForIn="InvalidLeftHandSideInForIn",e.InvalidTemplateHead="InvalidTemplateHead",e.InvalidVariableAssignment="InvalidVariableAssignment",e.KeyMustBeString="KeyMustBeString",e.NoFunctionInsideBlock="NoFunctionInsideBlock",e.NoFunctionInsideFunction="NoFunctionInsideFunction",e.ModuleExportRootOnly="ModuleExportRootOnly",e.ModuleImportRootOnly="ModuleImportRootOnly",e.PunctuatorExpected="PunctuatorExpected",e.TemplateOctalLiteral="TemplateOctalLiteral",e.UnexpectedBoolean="UnexpectedBoolean",e.UnexpectedEndOfScript="UnexpectedEndOfScript",e.UnexpectedIdentifier="UnexpectedIdentifier",e.UnexpectedKeyword="UnexpectedKeyword",e.UnexpectedNull="UnexpectedNull",e.UnexpectedNumber="UnexpectedNumber",e.UnexpectedPunctuator="UnexpectedPunctuator",e.UnexpectedString="UnexpectedString",e.UnexpectedTemplate="UnexpectedTemplate",e.UnexpectedToken="UnexpectedToken",e))(kt||{});var v=[[],[],[]];De.forEach(e=>v[e.length-1].push(e));We.forEach(e=>v[e.length-1].push(e));He.forEach(e=>v[e.length-1].push(e));qe.forEach(e=>v[e.length-1].push(e));bt.forEach(e=>v[e.length-1].push(e));var rt=(D=>(D.AlreadyDefined="AlreadyDefined",D.ApiConflict="ApiConflict",D.AssignedNeverUsed="AssignedNeverUsed",D.DefinedNeverAssigned="DefinedNeverAssigned",D.DefinedNeverUsed="DefinedNeverUsed",D.EmptyBlockStatement="EmptyBlockStatement",D.ExecutionError="ExecutionError",D.InvalidApiFunctionUsage="InvalidApiFunctionUsage",D.InvalidConstantIdentifier="InvalidConstantIdentifier",D.InvalidPropertyIdentifier="InvalidPropertyIdentifier",D.NoArgumentExpected="NoArgumentExpected",D.NotADictionary="NotADictionary",D.NotDefined="NotDefined",D.NotEnoughArguments="NotEnoughArguments",D.ProfileVariablesAreImmutable="ProfileVariablesAreImmutable",D.ProfileVariablesConflict="ProfileVariablesConflict",D.ReservedKeyword="ReservedKeyword",D.TooManyArguments="TooManyArguments",D.UnexpectedEmptyFunction="UnexpectedEmptyFunction",D.UnexpectedPropertyIdentifier="UnexpectedPropertyIdentifier",D.UnknownPropertyIdentifier="UnknownPropertyIdentifier",D))(rt||{});var st=Object.values(xe),at=Object.values(ge);at.map(e=>({label:e,kind:main.CompletionItemKind.Constant}));st.map(e=>({label:e,kind:main.CompletionItemKind.Keyword}));
+
+const operators = [
+  "<=",
+  ">=",
+  "==",
+  "!=",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "++",
+  "--",
+  "<<",
+  ">>",
+  ">>>",
+  "&",
+  "|",
+  "^",
+  "!",
+  "~",
+  "&&",
+  "||",
+  "=",
+  "+=",
+  "-=",
+  "*=",
+  "**=",
+  "/=",
+  "%="
+];
+const arcadeLanguageConfiguration = {
+  // the default separators except `@$`
+  wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+  comments: {
+    lineComment: "//",
+    blockComment: ["/*", "*/"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"', notIn: ["string"] },
+    { open: "'", close: "'", notIn: ["string", "comment"] },
+    { open: "`", close: "`", notIn: ["string", "comment"] }
+  ],
+  autoCloseBefore: ";:.,=}])` \n\t",
+  folding: {
+    markers: {
+      start: new RegExp("^\\s*//\\s*#?region\\b"),
+      end: new RegExp("^\\s*//\\s*#?endregion\\b")
+    }
+  },
+  indentationRules: {
+    // ^(.*\*/)?\s*\}.*$
+    decreaseIndentPattern: /^((?!.*?\/\*).*\*\/)?\s*[\}\]\)].*$/,
+    // ^.*\{[^}"']*$
+    increaseIndentPattern: /^((?!\/\/).)*(\{[^}"'`]*|\([^)"'`]*|\[[^\]"'`]*)$/
+  }
+};
+const arcadeMonarchLanguage = {
+  // Set defaultToken to invalid to see what you do not tokenize yet
+  defaultToken: "invalid",
+  tokenPostfix: ".arc",
+  // Arcade is case insensitive
+  ignoreCase: true,
+  // builtinFunctions: Array.from(arcadeService.FunctionNames),
+  // Arcade keywords. 'from' is a special case as we want to treat it as a keyword in
+  // import statement but as an identifer in var statement.
+  keywords: st.filter((k) => k !== "from"),
+  operators,
+  constants: ["true", "false", "null"],
+  // we include these common regular expressions
+  symbols: /[=><!~?:&|+\-*\/\^%]+/,
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  digits: /\d+(_+\d+)*/,
+  octaldigits: /[0-7]+(_+[0-7]+)*/,
+  binarydigits: /[0-1]+(_+[0-1]+)*/,
+  hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+  regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+  regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [[/[{}]/, "delimiter.bracket"], { include: "common" }],
+    common: [
+      // import statement. import followed by a white space
+      [/import(?=\s)/, { token: "keyword", next: "@import" }],
+      // identifiers and keywords
+      [
+        /[a-z_$][\w$]*/,
+        {
+          cases: {
+            "@constants": "constant",
+            "@keywords": "keyword",
+            "@default": "identifier"
+          }
+        }
+      ],
+      // whitespace
+      { include: "@whitespace" },
+      // regular expression: ensure it is terminated before beginning (otherwise it is an opeator)
+      [
+        /\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|\/|,|\)|\]|\}|$))/,
+        { token: "regexp", bracket: "@open", next: "@regexp" }
+      ],
+      // delimiters and operators
+      [/[()\[\]]/, "@brackets"],
+      [/[<>](?!@symbols)/, "@brackets"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "delimiter",
+            "@default": ""
+          }
+        }
+      ],
+      // numbers
+      [/(@digits)[eE]([\-+]?(@digits))?/, "number"],
+      [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, "number"],
+      [/0[xX](@hexdigits)/, "number"],
+      [/0[oO]?(@octaldigits)/, "number"],
+      [/0[bB](@binarydigits)/, "number"],
+      [/(@digits)/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      [/'([^'\\]|\\.)*$/, "string.invalid"],
+      [/"/, "string", "@string_double"],
+      [/'/, "string", "@string_single"],
+      [/`/, "string", "@string_backtick"]
+    ],
+    import: [
+      // import keyword
+      [/import(?=\s)/, { token: "keyword" }],
+      // whitespace
+      { include: "@whitespace" },
+      // identifier
+      [/[a-z_$][\w$]*/, "identifier"],
+      // whitespace
+      { include: "@whitespace" },
+      // from keyword
+      [/from/, { token: "keyword", next: "@popall" }]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/\/\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ],
+    comment: [
+      [/[^\/*]+/, "comment"],
+      [/\*\//, "comment", "@pop"],
+      [/[\/*]/, "comment"]
+    ],
+    // We match regular expression quite precisely
+    regexp: [
+      [/(\{)(\d+(?:,\d*)?)(\})/, ["regexp.escape.control", "regexp.escape.control", "regexp.escape.control"]],
+      [
+        /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,
+        ["regexp.escape.control", { token: "regexp.escape.control", next: "@regexrange" }]
+      ],
+      [/(\()(\?:|\?=|\?!)/, ["regexp.escape.control", "regexp.escape.control"]],
+      [/[()]/, "regexp.escape.control"],
+      [/@regexpctl/, "regexp.escape.control"],
+      [/[^\\\/]/, "regexp"],
+      [/@regexpesc/, "regexp.escape"],
+      [/\\\./, "regexp.invalid"],
+      [/(\/)([gimsuy]*)/, [{ token: "regexp", bracket: "@close", next: "@pop" }, "keyword.other"]]
+    ],
+    regexrange: [
+      [/-/, "regexp.escape.control"],
+      [/\^/, "regexp.invalid"],
+      [/@regexpesc/, "regexp.escape"],
+      [/[^\]]/, "regexp"],
+      [/\]/, { token: "regexp.escape.control", next: "@pop", bracket: "@close" }]
+    ],
+    string_double: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, "string", "@pop"]
+    ],
+    string_single: [
+      [/[^\\']+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/'/, "string", "@pop"]
+    ],
+    string_backtick: [
+      [/\$\{/, { token: "delimiter.bracket", next: "@bracketCounting" }],
+      [/[^\\`$]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/`/, "string", "@pop"]
+    ],
+    bracketCounting: [
+      [/\{/, "delimiter.bracket", "@bracketCounting"],
+      [/\}/, "delimiter.bracket", "@pop"],
+      { include: "common" }
+    ]
+  }
+};
+
+//#region Diagnostic
+class DiagnosticsAdapter {
+  constructor(_languageId, _worker, { defaults, diagnosticsService }) {
+    this._languageId = _languageId;
+    this._worker = _worker;
+    this._disposables = [];
+    this._listener = Object.create(null);
+    this._diagnosticsService = diagnosticsService;
+    this._defaults = defaults;
+    const onModelAdd = (model) => {
+      const languageId = model.getLanguageId();
+      if (languageId !== this._languageId) {
+        return;
+      }
+      let handle;
+      this._listener[model.uri.toString()] = model.onDidChangeContent(() => {
+        window.clearTimeout(handle);
+        handle = window.setTimeout(() => this._doValidate(model, languageId), 500);
+      });
+      this._doValidate(model, languageId);
+    };
+    const onModelRemoved = (model) => {
+      const uriStr = model.uri.toString();
+      editor.setModelMarkers(model, this._languageId, []);
+      const listener = this._listener[uriStr];
+      if (listener) {
+        listener.dispose();
+        delete this._listener[uriStr];
+      }
+    };
+    this._disposables.push(editor.onDidCreateModel(onModelAdd));
+    this._disposables.push(editor.onWillDisposeModel((model) => {
+      onModelRemoved(model);
+    }));
+    this._disposables.push(editor.onDidChangeModelLanguage((event) => {
+      onModelRemoved(event.model);
+      onModelAdd(event.model);
+    }));
+    this._disposables.push(defaults.onDidChange(() => {
+      editor.getModels().forEach((model) => {
+        if (model.getLanguageId() === this._languageId) {
+          onModelRemoved(model);
+          onModelAdd(model);
+        }
+      });
+    }));
+    this._disposables.push(defaults.onModelContextDidChange((key) => {
+      editor.getModels().forEach((model) => {
+        if (model.getLanguageId() === this._languageId && model.uri.toString() === key) {
+          this._doValidate(model, this._languageId);
+        }
+      });
+    }));
+    this._disposables.push({
+      dispose: () => {
+        for (const key in this._listener) {
+          this._listener[key].dispose();
+        }
+      }
+    });
+    editor.getModels().forEach(onModelAdd);
+  }
+  dispose() {
+    this._disposables.forEach((d) => d && d.dispose());
+    this._disposables = [];
+  }
+  async _doValidate(model, languageId) {
+    if (!model.isAttachedToEditor()) {
+      return;
+    }
+    try {
+      const workerProxy = await this._worker(model.uri);
+      const context = this._defaults.getApiContextForModel(model.uri);
+      const diagnostics = await workerProxy.doValidation(model.uri.toString(), context);
+      const markers = diagnostics.map((d) => toMarker(model.uri, d));
+      this._diagnosticsService.fireDiagnosticsChange(model.uri, diagnostics);
+      editor.setModelMarkers(model, languageId, markers);
+    }
+    catch (err) {
+      console.error(err);
+    }
+  }
+}
+function toSeverity(languageServiceSeverity) {
+  switch (languageServiceSeverity) {
+    case main.DiagnosticSeverity.Error:
+      return MarkerSeverity.Error;
+    case main.DiagnosticSeverity.Warning:
+      return MarkerSeverity.Warning;
+    case main.DiagnosticSeverity.Information:
+      return MarkerSeverity.Info;
+    case main.DiagnosticSeverity.Hint:
+      return MarkerSeverity.Hint;
+    default:
+      return MarkerSeverity.Info;
+  }
+}
+function toMarker(_resource, diag) {
+  // Diagnostics positions are zero-based, MarkerData are 1-based
+  return {
+    severity: toSeverity(diag.severity),
+    startLineNumber: diag.range.start.line + 1,
+    startColumn: diag.range.start.character + 1,
+    endLineNumber: diag.range.end.line + 1,
+    endColumn: diag.range.end.character + 1,
+    message: diag.message
+  };
+}
+//#endregion
+//#region Completion
+function fromPosition(position) {
+  // Language service is zero based
+  return { character: position.column - 1, line: position.lineNumber - 1 };
+}
+function toRange(range) {
+  return new Range(range.start.line + 1, range.start.character + 1, range.end.line + 1, range.end.character + 1);
+}
+function toTextEdit(textEdit) {
+  return {
+    range: toRange(textEdit.range),
+    text: textEdit.newText
+  };
+}
+function isInsertReplaceEdit(edit) {
+  return (typeof edit.insert !== "undefined" && typeof edit.replace !== "undefined");
+}
+function toCompletionItemKind(kind) {
+  const mItemKind = languages.CompletionItemKind;
+  switch (kind) {
+    case main.CompletionItemKind.Text:
+      return mItemKind.Text;
+    case main.CompletionItemKind.Method:
+      return mItemKind.Method;
+    case main.CompletionItemKind.Function:
+      return mItemKind.Function;
+    case main.CompletionItemKind.Constructor:
+      return mItemKind.Constructor;
+    case main.CompletionItemKind.Field:
+      return mItemKind.Field;
+    case main.CompletionItemKind.Variable:
+      return mItemKind.Variable;
+    case main.CompletionItemKind.Class:
+      return mItemKind.Class;
+    case main.CompletionItemKind.Interface:
+      return mItemKind.Interface;
+    case main.CompletionItemKind.Module:
+      return mItemKind.Module;
+    case main.CompletionItemKind.Property:
+      return mItemKind.Property;
+    case main.CompletionItemKind.Unit:
+      return mItemKind.Unit;
+    case main.CompletionItemKind.Value:
+      return mItemKind.Value;
+    case main.CompletionItemKind.Enum:
+      return mItemKind.Enum;
+    case main.CompletionItemKind.Keyword:
+      return mItemKind.Keyword;
+    case main.CompletionItemKind.Snippet:
+      return mItemKind.Snippet;
+    case main.CompletionItemKind.Color:
+      return mItemKind.Color;
+    case main.CompletionItemKind.File:
+      return mItemKind.File;
+    case main.CompletionItemKind.Reference:
+      return mItemKind.Reference;
+    case main.CompletionItemKind.Folder:
+      return mItemKind.Folder;
+    case main.CompletionItemKind.EnumMember:
+      return mItemKind.EnumMember;
+    case main.CompletionItemKind.Constant:
+      return mItemKind.Constant;
+    case main.CompletionItemKind.Struct:
+      return mItemKind.Struct;
+    case main.CompletionItemKind.Event:
+      return mItemKind.Event;
+    case main.CompletionItemKind.Operator:
+      return mItemKind.Operator;
+    case main.CompletionItemKind.TypeParameter:
+      return mItemKind.TypeParameter;
+  }
+  return mItemKind.Property;
+}
+class CompletionProvider {
+  constructor(_worker, _defaults) {
+    this._worker = _worker;
+    this._defaults = _defaults;
+    this.triggerCharacters = [".", "("];
+  }
+  async provideCompletionItems(model, position
+  // _context: languages.CompletionContext,
+  // _token: CancellationToken,
+  ) {
+    const worker = await this._worker(model.uri);
+    const context = this._defaults.getApiContextForModel(model.uri);
+    const completionList = await worker.doComplete(model.uri.toString(), fromPosition(position), context);
+    if (!completionList) {
+      return;
+    }
+    const wordInfo = model.getWordUntilPosition(position);
+    const wordRange = new Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
+    const items = completionList.items.map((entry) => {
+      const item = {
+        label: entry.label,
+        insertText: entry.insertText || entry.label,
+        sortText: entry.sortText,
+        filterText: entry.filterText,
+        detail: entry.detail,
+        range: wordRange,
+        kind: toCompletionItemKind(entry.kind)
+      };
+      if (entry.textEdit) {
+        if (isInsertReplaceEdit(entry.textEdit)) {
+          item.range = {
+            insert: toRange(entry.textEdit.insert),
+            replace: toRange(entry.textEdit.replace)
+          };
+        }
+        else {
+          item.range = toRange(entry.textEdit.range);
+        }
+        item.insertText = entry.textEdit.newText;
+      }
+      if (entry.additionalTextEdits) {
+        item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit);
+      }
+      if (entry.insertTextFormat === main.InsertTextFormat.Snippet) {
+        item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet;
+      }
+      if (entry.documentation) {
+        if (typeof entry.documentation === "string") {
+          item.documentation = entry.documentation;
+        }
+        else {
+          item.documentation = {
+            supportThemeIcons: false,
+            value: entry.documentation.value,
+            supportHtml: true
+          };
+        }
+      }
+      return item;
+    });
+    return {
+      incomplete: completionList.isIncomplete,
+      suggestions: items
+    };
+  }
+}
+//#endregion
+//#region Formatter
+class FormattingProvider {
+  constructor(_worker, _defaults) {
+    this._worker = _worker;
+    this._defaults = _defaults;
+  }
+  async provideDocumentFormattingEdits(model
+  // _options: languages.FormattingOptions,
+  // _token: CancellationToken,
+  ) {
+    const worker = await this._worker(model.uri);
+    const context = this._defaults.getApiContextForModel(model.uri.toString());
+    const edits = await worker.doFormat(model.uri.toString(), context);
+    if (!edits) {
+      return [];
+    }
+    return edits.map((e) => ({ range: toRange(e.range), text: e.newText }));
+  }
+}
+//#endregion
+
+/**
+ * Manager to create our arcade worker and client proxy
+ */
+class WorkerManager {
+  constructor(_defaults) {
+    this._defaults = _defaults;
+    this._worker = null;
+    this._client = null;
+    // Observes the arcade defaults. If modified then stop the worker.
+    this._configChangeListener = this._defaults.onDidChange(() => this.stopWorker());
+  }
+  dispose() {
+    this._configChangeListener.dispose();
+    this.stopWorker();
+  }
+  stopWorker() {
+    if (this._worker) {
+      this._worker.dispose();
+      this._worker = null;
+    }
+    this._client = null;
+  }
+  _getClientProxy() {
+    // We used createWebWorker to create or run the web worker if it isn’t already created.
+    // Otherwise, we get and return the proxy client.
+    if (!this._client) {
+      const { languageId, languageOptions } = this._defaults;
+      this._worker = editor.createWebWorker({
+        moduleId: "ArcadeWorker",
+        label: languageId,
+        createData: {
+          languageId,
+          languageOptions
+        }
+      });
+      this._client = this._worker.getProxy();
+    }
+    return this._client;
+  }
+  async getLanguageServiceWorker(...resources) {
+    const _client = await this._getClientProxy();
+    await this._worker?.withSyncedResources(resources);
+    return _client;
+  }
+}
+
+let arcadeWorker;
+/**
+ * Returns the arcade worker for the model uris.
+ * @param uris The model uris for which to get the worker.
+ * @returns The arcade worker.
+ */
+async function getArcadeWorker(...uris) {
+  return new Promise((resolve, reject) => {
+    if (!arcadeWorker) {
+      return reject("TypeScript not registered!");
+    }
+    resolve(arcadeWorker(...uris));
+  });
+}
+/**
+ * The Arcade Language Diagnostic Service.
+ * Consumers can listen to the diagnostics change event to get notified when the diagnostics change.
+ */
+class ArcadeDiagnosticService {
+  constructor() {
+    this._onDiagnosticsChange = new Emitter();
+  }
+  /**
+   * An event to signal changes to the diagnostics.
+   * The event value is the uri string and the diagnostics.
+   */
+  get onDiagnosticsChange() {
+    return this._onDiagnosticsChange.event;
+  }
+  /**
+   * Fires the diagnostics change event.
+   * @param uri The uri of the model for which the diagnostics changed.
+   * @param diagnostics The diagnostics for the model.
+   */
+  fireDiagnosticsChange(uri, diagnostics) {
+    this._onDiagnosticsChange.fire({ uri, diagnostics });
+  }
+}
+const arcadeDiagnosticService = new ArcadeDiagnosticService();
+/**
+ * Get the Arcade Diagnostic Service.
+ * @returns The Arcade Language Diagnostic Service.
+ */
+function getArcadeDiagnosticService() {
+  return arcadeDiagnosticService;
+}
+function setupMode(arcadeDefaults) {
+  const client = new WorkerManager(arcadeDefaults);
+  const workerAccessor = (...uris) => client.getLanguageServiceWorker(...uris);
+  arcadeWorker = workerAccessor;
+  // Use the arcade Monarch Json to define the highlighting
+  languages.setMonarchTokensProvider(arcadeDefaults.languageId, arcadeMonarchLanguage);
+  languages.setLanguageConfiguration(arcadeDefaults.languageId, arcadeLanguageConfiguration);
+  // Creates and registers a Completion Adapter
+  languages.registerCompletionItemProvider(arcadeDefaults.languageId, new CompletionProvider(workerAccessor, arcadeDefaults));
+  // Creates and registers a Formatter
+  languages.registerDocumentFormattingEditProvider(arcadeDefaults.languageId, new FormattingProvider(workerAccessor, arcadeDefaults));
+  // Creates a Diagnostic Adapter
+  new DiagnosticsAdapter(arcadeDefaults.languageId, workerAccessor, {
+    defaults: arcadeDefaults,
+    diagnosticsService: arcadeDiagnosticService
+  });
+}
+
+export { getArcadeDiagnosticService, getArcadeWorker, setupMode };