@arcgis/coding-components 4.31.0-next.21 → 4.31.0-next.23

package/dist/esm/sql-expr-mode-0f087c3e.js

@@ -0,0 +1,1821 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
+ * v4.31.0-next.23
+ */
+import { g as editor, T as importCoreSql, V as newLayersSupportFieldsIndex, z as languages, m as main, Q as debounce, O as Emitter } from './language-defaults-base-5cb37b1e.js';
+import { b as getFieldsFromLayerVariable, s as sqlExprDefaults } from './sql-expr-defaults-f1fd7291.js';
+import { t as toCompletionItemKind } from './arcade-language-features-749f495a.js';
+import './index-51f840b4.js';
+
+/**
+ * Manager to create our sql-expression worker and client proxy
+ */
+class SqlExprWorkerManager {
+    constructor(_defaults) {
+        this._defaults = _defaults;
+        this._worker = null;
+        this._client = null;
+        // Observes the sql-expression 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;
+    }
+    async _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: "SqlExprWorker",
+                label: languageId,
+                createData: {
+                    languageId,
+                    languageOptions,
+                },
+            });
+            this._client = this._worker.getProxy();
+        }
+        return await this._client;
+    }
+    async getLanguageServiceWorker(...resources) {
+        const _client = await this._getClientProxy();
+        await this._worker?.withSyncedResources(resources);
+        return _client;
+    }
+}
+
+const sqlExprLanguageConfig = {
+    comments: {
+        lineComment: "--",
+        blockComment: ["/*", "*/"],
+    },
+    brackets: [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"],
+    ],
+    autoClosingPairs: [
+        { open: "{", close: "}" },
+        { open: "[", close: "]" },
+        { open: "(", close: ")" },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+    ],
+    surroundingPairs: [
+        { open: "{", close: "}" },
+        { open: "[", close: "]" },
+        { open: "(", close: ")" },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+    ],
+};
+// TODO: trim down
+const sqlExprLanguageSyntax = {
+    defaultToken: "",
+    tokenPostfix: ".sql",
+    ignoreCase: true,
+    brackets: [
+        { open: "[", close: "]", token: "delimiter.square" },
+        { open: "(", close: ")", token: "delimiter.parenthesis" },
+    ],
+    keywords: [
+        // This list is generated using `keywords.js`
+        "ABORT",
+        "ABSOLUTE",
+        "ACTION",
+        "ADA",
+        "ADD",
+        "AFTER",
+        "ALL",
+        "ALLOCATE",
+        "ALTER",
+        "ALWAYS",
+        "ANALYZE",
+        "AND",
+        "ANY",
+        "ARE",
+        "AS",
+        "ASC",
+        "ASSERTION",
+        "AT",
+        "ATTACH",
+        "AUTHORIZATION",
+        "AUTOINCREMENT",
+        "AVG",
+        "BACKUP",
+        "BEFORE",
+        "BEGIN",
+        "BETWEEN",
+        "BIT",
+        "BIT_LENGTH",
+        "BOTH",
+        "BREAK",
+        "BROWSE",
+        "BULK",
+        "BY",
+        "CASCADE",
+        "CASCADED",
+        "CASE",
+        "CAST",
+        "CATALOG",
+        "CHAR",
+        "CHARACTER",
+        "CHARACTER_LENGTH",
+        "CHAR_LENGTH",
+        "CHECK",
+        "CHECKPOINT",
+        "CLOSE",
+        "CLUSTERED",
+        "COALESCE",
+        "COLLATE",
+        "COLLATION",
+        "COLUMN",
+        "COMMIT",
+        "COMPUTE",
+        "CONFLICT",
+        "CONNECT",
+        "CONNECTION",
+        "CONSTRAINT",
+        "CONSTRAINTS",
+        "CONTAINS",
+        "CONTAINSTABLE",
+        "CONTINUE",
+        "CONVERT",
+        "CORRESPONDING",
+        "COUNT",
+        "CREATE",
+        "CROSS",
+        "CURRENT",
+        "CURRENT_DATE",
+        "CURRENT_TIME",
+        "CURRENT_TIMESTAMP",
+        "CURRENT_USER",
+        "CURSOR",
+        "DATABASE",
+        "DATE",
+        "DAY",
+        "DBCC",
+        "DEALLOCATE",
+        "DEC",
+        "DECIMAL",
+        "DECLARE",
+        "DEFAULT",
+        "DEFERRABLE",
+        "DEFERRED",
+        "DELETE",
+        "DENY",
+        "DESC",
+        "DESCRIBE",
+        "DESCRIPTOR",
+        "DETACH",
+        "DIAGNOSTICS",
+        "DISCONNECT",
+        "DISK",
+        "DISTINCT",
+        "DISTRIBUTED",
+        "DO",
+        "DOMAIN",
+        "DOUBLE",
+        "DROP",
+        "DUMP",
+        "EACH",
+        "ELSE",
+        "END",
+        "END-EXEC",
+        "ERRLVL",
+        "ESCAPE",
+        "EXCEPT",
+        "EXCEPTION",
+        "EXCLUDE",
+        "EXCLUSIVE",
+        "EXEC",
+        "EXECUTE",
+        "EXISTS",
+        "EXIT",
+        "EXPLAIN",
+        "EXTERNAL",
+        "EXTRACT",
+        "FAIL",
+        "FALSE",
+        "FETCH",
+        "FILE",
+        "FILLFACTOR",
+        "FILTER",
+        "FIRST",
+        "FLOAT",
+        "FOLLOWING",
+        "FOR",
+        "FOREIGN",
+        "FORTRAN",
+        "FOUND",
+        "FREETEXT",
+        "FREETEXTTABLE",
+        "FROM",
+        "FULL",
+        "FUNCTION",
+        "GENERATED",
+        "GET",
+        "GLOB",
+        "GLOBAL",
+        "GO",
+        "GOTO",
+        "GRANT",
+        "GROUP",
+        "GROUPS",
+        "HAVING",
+        "HOLDLOCK",
+        "HOUR",
+        "IDENTITY",
+        "IDENTITYCOL",
+        "IDENTITY_INSERT",
+        "IF",
+        "IGNORE",
+        "IMMEDIATE",
+        "IN",
+        "INCLUDE",
+        "INDEX",
+        "INDEXED",
+        "INDICATOR",
+        "INITIALLY",
+        "INNER",
+        "INPUT",
+        "INSENSITIVE",
+        "INSERT",
+        "INSTEAD",
+        "INT",
+        "INTEGER",
+        "INTERSECT",
+        "INTERVAL",
+        "INTO",
+        "IS",
+        "ISNULL",
+        "ISOLATION",
+        "JOIN",
+        "KEY",
+        "KILL",
+        "LANGUAGE",
+        "LAST",
+        "LEADING",
+        "LEFT",
+        "LEVEL",
+        "LIKE",
+        "LIMIT",
+        "LINENO",
+        "LOAD",
+        "LOCAL",
+        "LOWER",
+        "MATCH",
+        "MATERIALIZED",
+        "MAX",
+        "MERGE",
+        "MIN",
+        "MINUTE",
+        "MODULE",
+        "MONTH",
+        "NAMES",
+        "NATIONAL",
+        "NATURAL",
+        "NCHAR",
+        "NEXT",
+        "NO",
+        "NOCHECK",
+        "NONCLUSTERED",
+        "NONE",
+        "NOT",
+        "NOTHING",
+        "NOTNULL",
+        "NULL",
+        "NULLIF",
+        "NULLS",
+        "NUMERIC",
+        "OCTET_LENGTH",
+        "OF",
+        "OFF",
+        "OFFSET",
+        "OFFSETS",
+        "ON",
+        "ONLY",
+        "OPEN",
+        "OPENDATASOURCE",
+        "OPENQUERY",
+        "OPENROWSET",
+        "OPENXML",
+        "OPTION",
+        "OR",
+        "ORDER",
+        "OTHERS",
+        "OUTER",
+        "OUTPUT",
+        "OVER",
+        "OVERLAPS",
+        "PAD",
+        "PARTIAL",
+        "PARTITION",
+        "PASCAL",
+        "PERCENT",
+        "PIVOT",
+        "PLAN",
+        "POSITION",
+        "PRAGMA",
+        "PRECEDING",
+        "PRECISION",
+        "PREPARE",
+        "PRESERVE",
+        "PRIMARY",
+        "PRINT",
+        "PRIOR",
+        "PRIVILEGES",
+        "PROC",
+        "PROCEDURE",
+        "PUBLIC",
+        "QUERY",
+        "RAISE",
+        "RAISERROR",
+        "RANGE",
+        "READ",
+        "READTEXT",
+        "REAL",
+        "RECONFIGURE",
+        "RECURSIVE",
+        "REFERENCES",
+        "REGEXP",
+        "REINDEX",
+        "RELATIVE",
+        "RELEASE",
+        "RENAME",
+        "REPLACE",
+        "REPLICATION",
+        "RESTORE",
+        "RESTRICT",
+        "RETURN",
+        "RETURNING",
+        "REVERT",
+        "REVOKE",
+        "RIGHT",
+        "ROLLBACK",
+        "ROW",
+        "ROWCOUNT",
+        "ROWGUIDCOL",
+        "ROWS",
+        "RULE",
+        "SAVE",
+        "SAVEPOINT",
+        "SCHEMA",
+        "SCROLL",
+        "SECOND",
+        "SECTION",
+        "SECURITYAUDIT",
+        "SELECT",
+        "SEMANTICKEYPHRASETABLE",
+        "SEMANTICSIMILARITYDETAILSTABLE",
+        "SEMANTICSIMILARITYTABLE",
+        "SESSION",
+        "SESSION_USER",
+        "SET",
+        "SETUSER",
+        "SHUTDOWN",
+        "SIZE",
+        "SMALLINT",
+        "SOME",
+        "SPACE",
+        "SQL",
+        "SQLCA",
+        "SQLCODE",
+        "SQLERROR",
+        "SQLSTATE",
+        "SQLWARNING",
+        "STATISTICS",
+        "SUBSTRING",
+        "SUM",
+        "SYSTEM_USER",
+        "TABLE",
+        "TABLESAMPLE",
+        "TEMP",
+        "TEMPORARY",
+        "TEXTSIZE",
+        "THEN",
+        "TIES",
+        "TIME",
+        "TIMESTAMP",
+        "TIMEZONE_HOUR",
+        "TIMEZONE_MINUTE",
+        "TO",
+        "TOP",
+        "TRAILING",
+        "TRAN",
+        "TRANSACTION",
+        "TRANSLATE",
+        "TRANSLATION",
+        "TRIGGER",
+        "TRIM",
+        "TRUE",
+        "TRUNCATE",
+        "TRY_CONVERT",
+        "TSEQUAL",
+        "UNBOUNDED",
+        "UNION",
+        "UNIQUE",
+        "UNKNOWN",
+        "UNPIVOT",
+        "UPDATE",
+        "UPDATETEXT",
+        "UPPER",
+        "USAGE",
+        "USE",
+        "USER",
+        "USING",
+        "VACUUM",
+        "VALUE",
+        "VALUES",
+        "VARCHAR",
+        "VARYING",
+        "VIEW",
+        "VIRTUAL",
+        "WAITFOR",
+        "WHEN",
+        "WHENEVER",
+        "WHERE",
+        "WHILE",
+        "WINDOW",
+        "WITH",
+        "WITHIN GROUP",
+        "WITHOUT",
+        "WORK",
+        "WRITE",
+        "WRITETEXT",
+        "YEAR",
+        "ZONE",
+    ],
+    operators: [
+        // Logical
+        "ALL",
+        "AND",
+        "ANY",
+        "BETWEEN",
+        "EXISTS",
+        "IN",
+        "LIKE",
+        "NOT",
+        "OR",
+        "SOME",
+        // Set
+        "EXCEPT",
+        "INTERSECT",
+        "UNION",
+        // Join
+        "APPLY",
+        "CROSS",
+        "FULL",
+        "INNER",
+        "JOIN",
+        "LEFT",
+        "OUTER",
+        "RIGHT",
+        // Predicates
+        "CONTAINS",
+        "FREETEXT",
+        "IS",
+        "NULL",
+        // Pivoting
+        "PIVOT",
+        "UNPIVOT",
+        // Merging
+        "MATCHED",
+    ],
+    builtinFunctions: [
+        // Aggregate
+        "AVG",
+        "CHECKSUM_AGG",
+        "COUNT",
+        "COUNT_BIG",
+        "GROUPING",
+        "GROUPING_ID",
+        "MAX",
+        "MIN",
+        "SUM",
+        "STDEV",
+        "STDEVP",
+        "VAR",
+        "VARP",
+        // Analytic
+        "CUME_DIST",
+        "FIRST_VALUE",
+        "LAG",
+        "LAST_VALUE",
+        "LEAD",
+        "PERCENTILE_CONT",
+        "PERCENTILE_DISC",
+        "PERCENT_RANK",
+        // Collation
+        "COLLATE",
+        "COLLATIONPROPERTY",
+        "TERTIARY_WEIGHTS",
+        // Azure
+        "FEDERATION_FILTERING_VALUE",
+        // Conversion
+        "CAST",
+        "CONVERT",
+        "PARSE",
+        "TRY_CAST",
+        "TRY_CONVERT",
+        "TRY_PARSE",
+        // Cryptographic
+        "ASYMKEY_ID",
+        "ASYMKEYPROPERTY",
+        "CERTPROPERTY",
+        "CERT_ID",
+        "CRYPT_GEN_RANDOM",
+        "DECRYPTBYASYMKEY",
+        "DECRYPTBYCERT",
+        "DECRYPTBYKEY",
+        "DECRYPTBYKEYAUTOASYMKEY",
+        "DECRYPTBYKEYAUTOCERT",
+        "DECRYPTBYPASSPHRASE",
+        "ENCRYPTBYASYMKEY",
+        "ENCRYPTBYCERT",
+        "ENCRYPTBYKEY",
+        "ENCRYPTBYPASSPHRASE",
+        "HASHBYTES",
+        "IS_OBJECTSIGNED",
+        "KEY_GUID",
+        "KEY_ID",
+        "KEY_NAME",
+        "SIGNBYASYMKEY",
+        "SIGNBYCERT",
+        "SYMKEYPROPERTY",
+        "VERIFYSIGNEDBYCERT",
+        "VERIFYSIGNEDBYASYMKEY",
+        // Cursor
+        "CURSOR_STATUS",
+        // Datatype
+        "DATALENGTH",
+        "IDENT_CURRENT",
+        "IDENT_INCR",
+        "IDENT_SEED",
+        "IDENTITY",
+        "SQL_VARIANT_PROPERTY",
+        // Datetime
+        "CURRENT_TIMESTAMP",
+        "DATEADD",
+        "DATEDIFF",
+        "DATEFROMPARTS",
+        "DATENAME",
+        "DATEPART",
+        "DATETIME2FROMPARTS",
+        "DATETIMEFROMPARTS",
+        "DATETIMEOFFSETFROMPARTS",
+        "DAY",
+        "EOMONTH",
+        "GETDATE",
+        "GETUTCDATE",
+        "ISDATE",
+        "MONTH",
+        "SMALLDATETIMEFROMPARTS",
+        "SWITCHOFFSET",
+        "SYSDATETIME",
+        "SYSDATETIMEOFFSET",
+        "SYSUTCDATETIME",
+        "TIMEFROMPARTS",
+        "TODATETIMEOFFSET",
+        "YEAR",
+        // Logical
+        "CHOOSE",
+        "COALESCE",
+        "IIF",
+        "NULLIF",
+        // Mathematical
+        "ABS",
+        "ACOS",
+        "ASIN",
+        "ATAN",
+        "ATN2",
+        "CEILING",
+        "COS",
+        "COT",
+        "DEGREES",
+        "EXP",
+        "FLOOR",
+        "LOG",
+        "LOG10",
+        "PI",
+        "POWER",
+        "RADIANS",
+        "RAND",
+        "ROUND",
+        "SIGN",
+        "SIN",
+        "SQRT",
+        "SQUARE",
+        "TAN",
+        // Metadata
+        "APP_NAME",
+        "APPLOCK_MODE",
+        "APPLOCK_TEST",
+        "ASSEMBLYPROPERTY",
+        "COL_LENGTH",
+        "COL_NAME",
+        "COLUMNPROPERTY",
+        "DATABASE_PRINCIPAL_ID",
+        "DATABASEPROPERTYEX",
+        "DB_ID",
+        "DB_NAME",
+        "FILE_ID",
+        "FILE_IDEX",
+        "FILE_NAME",
+        "FILEGROUP_ID",
+        "FILEGROUP_NAME",
+        "FILEGROUPPROPERTY",
+        "FILEPROPERTY",
+        "FULLTEXTCATALOGPROPERTY",
+        "FULLTEXTSERVICEPROPERTY",
+        "INDEX_COL",
+        "INDEXKEY_PROPERTY",
+        "INDEXPROPERTY",
+        "OBJECT_DEFINITION",
+        "OBJECT_ID",
+        "OBJECT_NAME",
+        "OBJECT_SCHEMA_NAME",
+        "OBJECTPROPERTY",
+        "OBJECTPROPERTYEX",
+        "ORIGINAL_DB_NAME",
+        "PARSENAME",
+        "SCHEMA_ID",
+        "SCHEMA_NAME",
+        "SCOPE_IDENTITY",
+        "SERVERPROPERTY",
+        "STATS_DATE",
+        "TYPE_ID",
+        "TYPE_NAME",
+        "TYPEPROPERTY",
+        // Ranking
+        "DENSE_RANK",
+        "NTILE",
+        "RANK",
+        "ROW_NUMBER",
+        // Replication
+        "PUBLISHINGSERVERNAME",
+        // Rowset
+        "OPENDATASOURCE",
+        "OPENQUERY",
+        "OPENROWSET",
+        "OPENXML",
+        // Security
+        "CERTENCODED",
+        "CERTPRIVATEKEY",
+        "CURRENT_USER",
+        "HAS_DBACCESS",
+        "HAS_PERMS_BY_NAME",
+        "IS_MEMBER",
+        "IS_ROLEMEMBER",
+        "IS_SRVROLEMEMBER",
+        "LOGINPROPERTY",
+        "ORIGINAL_LOGIN",
+        "PERMISSIONS",
+        "PWDENCRYPT",
+        "PWDCOMPARE",
+        "SESSION_USER",
+        "SESSIONPROPERTY",
+        "SUSER_ID",
+        "SUSER_NAME",
+        "SUSER_SID",
+        "SUSER_SNAME",
+        "SYSTEM_USER",
+        "USER",
+        "USER_ID",
+        "USER_NAME",
+        // String
+        "ASCII",
+        "CHAR",
+        "CHARINDEX",
+        "CONCAT",
+        "DIFFERENCE",
+        "FORMAT",
+        "LEFT",
+        "LEN",
+        "LOWER",
+        "LTRIM",
+        "NCHAR",
+        "PATINDEX",
+        "QUOTENAME",
+        "REPLACE",
+        "REPLICATE",
+        "REVERSE",
+        "RIGHT",
+        "RTRIM",
+        "SOUNDEX",
+        "SPACE",
+        "STR",
+        "STUFF",
+        "SUBSTRING",
+        "UNICODE",
+        "UPPER",
+        // System
+        "BINARY_CHECKSUM",
+        "CHECKSUM",
+        "CONNECTIONPROPERTY",
+        "CONTEXT_INFO",
+        "CURRENT_REQUEST_ID",
+        "ERROR_LINE",
+        "ERROR_NUMBER",
+        "ERROR_MESSAGE",
+        "ERROR_PROCEDURE",
+        "ERROR_SEVERITY",
+        "ERROR_STATE",
+        "FORMATMESSAGE",
+        "GETANSINULL",
+        "GET_FILESTREAM_TRANSACTION_CONTEXT",
+        "HOST_ID",
+        "HOST_NAME",
+        "ISNULL",
+        "ISNUMERIC",
+        "MIN_ACTIVE_ROWVERSION",
+        "NEWID",
+        "NEWSEQUENTIALID",
+        "ROWCOUNT_BIG",
+        "XACT_STATE",
+        // TextImage
+        "TEXTPTR",
+        "TEXTVALID",
+        // Trigger
+        "COLUMNS_UPDATED",
+        "EVENTDATA",
+        "TRIGGER_NESTLEVEL",
+        "UPDATE",
+        // ChangeTracking
+        "CHANGETABLE",
+        "CHANGE_TRACKING_CONTEXT",
+        "CHANGE_TRACKING_CURRENT_VERSION",
+        "CHANGE_TRACKING_IS_COLUMN_IN_MASK",
+        "CHANGE_TRACKING_MIN_VALID_VERSION",
+        // FullTextSearch
+        "CONTAINSTABLE",
+        "FREETEXTTABLE",
+        // SemanticTextSearch
+        "SEMANTICKEYPHRASETABLE",
+        "SEMANTICSIMILARITYDETAILSTABLE",
+        "SEMANTICSIMILARITYTABLE",
+        // FileStream
+        "FILETABLEROOTPATH",
+        "GETFILENAMESPACEPATH",
+        "GETPATHLOCATOR",
+        "PATHNAME",
+        // ServiceBroker
+        "GET_TRANSMISSION_STATUS",
+    ],
+    builtinVariables: [
+        // Configuration
+        "@@DATEFIRST",
+        "@@DBTS",
+        "@@LANGID",
+        "@@LANGUAGE",
+        "@@LOCK_TIMEOUT",
+        "@@MAX_CONNECTIONS",
+        "@@MAX_PRECISION",
+        "@@NESTLEVEL",
+        "@@OPTIONS",
+        "@@REMSERVER",
+        "@@SERVERNAME",
+        "@@SERVICENAME",
+        "@@SPID",
+        "@@TEXTSIZE",
+        "@@VERSION",
+        // Cursor
+        "@@CURSOR_ROWS",
+        "@@FETCH_STATUS",
+        // Datetime
+        "@@DATEFIRST",
+        // Metadata
+        "@@PROCID",
+        // System
+        "@@ERROR",
+        "@@IDENTITY",
+        "@@ROWCOUNT",
+        "@@TRANCOUNT",
+        // Stats
+        "@@CONNECTIONS",
+        "@@CPU_BUSY",
+        "@@IDLE",
+        "@@IO_BUSY",
+        "@@PACKET_ERRORS",
+        "@@PACK_RECEIVED",
+        "@@PACK_SENT",
+        "@@TIMETICKS",
+        "@@TOTAL_ERRORS",
+        "@@TOTAL_READ",
+        "@@TOTAL_WRITE",
+    ],
+    pseudoColumns: ["$ACTION", "$IDENTITY", "$ROWGUID", "$PARTITION"],
+    tokenizer: {
+        root: [
+            { include: "@comments" },
+            { include: "@whitespace" },
+            { include: "@pseudoColumns" },
+            { include: "@numbers" },
+            { include: "@strings" },
+            { include: "@complexIdentifiers" },
+            { include: "@scopes" },
+            [/[;,.]/, "delimiter"],
+            [/[()]/, "@brackets"],
+            [
+                /[\w@#$]+/,
+                {
+                    cases: {
+                        "@operators": "operator",
+                        "@builtinVariables": "predefined",
+                        "@builtinFunctions": "predefined",
+                        "@keywords": "keyword",
+                        "@default": "identifier",
+                    },
+                },
+            ],
+            [/[<>=!%&+\-*/|~^]/, "operator"],
+        ],
+        whitespace: [[/\s+/, "white"]],
+        comments: [
+            [/--+.*/, "comment"],
+            [/\/\*/, { token: "comment.quote", next: "@comment" }],
+        ],
+        comment: [
+            [/[^*/]+/, "comment"],
+            // Not supporting nested comments, as nested comments seem to not be standard?
+            // i.e. http://stackoverflow.com/questions/728172/are-there-multiline-comment-delimiters-in-sql-that-are-vendor-agnostic
+            // [/\/\*/, { token: 'comment.quote', next: '@push' }],    // nested comment not allowed :-(
+            [/\*\//, { token: "comment.quote", next: "@pop" }],
+            [/./, "comment"],
+        ],
+        // TODO: discuss
+        pseudoColumns: [
+            [
+                /[$][A-Za-z_][\w@#$]*/,
+                {
+                    cases: {
+                        "@pseudoColumns": "predefined",
+                        "@default": "identifier",
+                    },
+                },
+            ],
+        ],
+        numbers: [
+            [/0[xX][0-9a-fA-F]*/, "number"],
+            [/[$][+-]*\d*(\.\d*)?/, "number"],
+            [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, "number"],
+        ],
+        strings: [
+            [/N'/, { token: "string", next: "@string" }],
+            [/'/, { token: "string", next: "@string" }],
+        ],
+        string: [
+            [/[^']+/, "string"],
+            [/''/, "string"],
+            [/'/, { token: "string", next: "@pop" }],
+        ],
+        complexIdentifiers: [
+            [/\[/, { token: "identifier.quote", next: "@bracketedIdentifier" }],
+            [/"/, { token: "identifier.quote", next: "@quotedIdentifier" }],
+        ],
+        bracketedIdentifier: [
+            [/[^\]]+/, "identifier"],
+            [/]]/, "identifier"],
+            [/]/, { token: "identifier.quote", next: "@pop" }],
+        ],
+        quotedIdentifier: [
+            [/[^"]+/, "identifier"],
+            [/""/, "identifier"],
+            [/"/, { token: "identifier.quote", next: "@pop" }],
+        ],
+        scopes: [
+            [/BEGIN\s+(DISTRIBUTED\s+)?TRAN(SACTION)?\b/i, "keyword"],
+            [/BEGIN\s+TRY\b/i, { token: "keyword.try" }],
+            [/END\s+TRY\b/i, { token: "keyword.try" }],
+            [/BEGIN\s+CATCH\b/i, { token: "keyword.catch" }],
+            [/END\s+CATCH\b/i, { token: "keyword.catch" }],
+            [/(BEGIN|CASE)\b/i, { token: "keyword.block" }],
+            [/END\b/i, { token: "keyword.block" }],
+            [/WHEN\b/i, { token: "keyword.choice" }],
+            [/THEN\b/i, { token: "keyword.choice" }],
+        ],
+    },
+};
+
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+async function sqlExpressionCompletion(range, model, position, sdkFunctions) {
+    try {
+        /*
+          Handles the case where we have a valid SQL expression in the editor and is
+          able to generate an AST from it and traverse it to provide completion items.
+        */
+        const editorValue = model.getValue();
+        const sql = await importCoreSql();
+        const fieldIndex = await newLayersSupportFieldsIndex([]);
+        const { parseTree } = await sql.parseWhereClause(editorValue, fieldIndex);
+        const completionItems = getCompletionItems(model, parseTree, range, position, sdkFunctions);
+        return completionItems;
+    }
+    catch {
+        /*
+          Handles the case where we have an incomplete SQL expression (i.e. if users are
+          still typing or has erroneous syntax). We fall back to a more lexical approach
+          in this way to "fail gracefully" in order to still provide completion items.
+        */
+        const errorRange = {
+            startColumn: 1,
+            endColumn: position.column,
+            startLineNumber: 1,
+            endLineNumber: position.lineNumber,
+        };
+        /* Matching a '(', ')', ' ', or ',' */
+        const delimiter = /(?:\(|\)|\s|,)/u;
+        /*
+          Filter callback function to filter out all non-function words, non-sql keywords, empty
+          strings and single quotes ('). Preserve all '(', ')', ',' and 'END' tokens
+          within our array.
+         */
+        const filterToken = (token) => {
+            const tokenIsAFunction = sdkFunctions[token] !== undefined;
+            const isParenLessFunction = isSqlParenLessFunction(token);
+            const excludedTokens = token !== "" && token !== "'";
+            const includedTokens = ["(", ")", ",", "END"].includes(token);
+            /*
+              Returns the tokens if they are either a standardized function, parenthesis-less function
+              or is one of the tokens that we specified to keep. Filters all empty string and
+              single quotations.
+            */
+            return excludedTokens && (tokenIsAFunction || isParenLessFunction || includedTokens);
+        };
+        const textValueUpToCursor = model.getValueInRange(errorRange).toUpperCase();
+        // TODO: test this...
+        const tokens = textValueUpToCursor
+            .split(delimiter)
+            .map((token) => token.trim())
+            .filter((token) => filterToken(token));
+        /* Keeps track of our current context item */
+        const contextStack = [];
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            const nonEmptyContextStack = contextStack.length > 0;
+            /*
+              As long as we have not hit the last token in our list yet, we can do a
+              lookahead and see if the next token makes a valid sub-expression.
+            */
+            if (i < tokens.length - 1) {
+                const nextToken = tokens[i + 1];
+                const invalidFunctionCall = sdkFunctions[token] && nextToken !== "(";
+                if (invalidFunctionCall) {
+                    continue;
+                }
+            }
+            if (token === "(" || token === ",") {
+                if (nonEmptyContextStack) {
+                    const currentContext = contextStack[contextStack.length - 1];
+                    /*
+                      This marks the end of our parenthesis-less function's scope, hence
+                      we cleanse the context and let the next token update the context.
+                    */
+                    if (isSqlParenLessFunction(currentContext)) {
+                        contextStack.pop();
+                    }
+                }
+                continue;
+            }
+            else if (token === ")" || token === "END") {
+                /*
+                  If we have a non empty context stack, that means we are within another
+                  function's scope right now (another context). We will return to the outer
+                  scope to provide us the necessary completion items.
+                */
+                if (nonEmptyContextStack) {
+                    contextStack.pop();
+                }
+                continue;
+            }
+            /*
+              If we end off with a standardized function without a '(', we should not
+              update the context. We should only trigger completion if they have a '('
+              to indicate that it's a function call.
+            */
+            if (i === tokens.length - 1 && sdkFunctions[token]) {
+                continue;
+            }
+            /*
+              Very specific case where we have something like
+      
+              | TRIM(INTERVAL INTERVAL, ... |
+      
+              and we do not want the completion items for "INTERVAL" to persist even after
+              the context ends.
+      
+              In essence, we only update the context once.
+            */
+            if (i > 0) {
+                const prevTokenIsParenLess = isSqlParenLessFunction(tokens[i - 1]);
+                const curTokenIsParenLess = isSqlParenLessFunction(token);
+                if (!(curTokenIsParenLess && prevTokenIsParenLess)) {
+                    contextStack.push(token);
+                }
+            }
+            else if (i === 0) {
+                contextStack.push(token);
+            }
+        }
+        let completionItems = [];
+        [...new Set(contextStack)].forEach((context, index) => {
+            const autoCompletionItem = generateCompletionList(context, range, index);
+            completionItems = [...completionItems, ...autoCompletionItem];
+        });
+        return completionItems;
+    }
+}
+/*
+  Helper function that takes in our model/position information and traverse the
+  completed AST to generate an array of Monaco's completion items.
+
+  This function is invoked only if we have a valid SQL expression that can be parsed to
+  generate an AST. In other words, this is only invoked for our "success" case.
+*/
+const getCompletionItems = (model, node, range, position, sdkFunctions) => {
+    /*
+      Using an object here so that we can pass by reference to the function to
+      handle updating the state instead of pass by value if we use a primitive
+      type like string. This also allows us to extend the context and add more
+      data and attributes if we need to in the future.
+    */
+    const context = { contextString: "NONE", additionalContext: "NONE" };
+    traverseAST({ model, node, position, context, sdkFunctions });
+    const { contextString, additionalContext } = context;
+    const completionItems = generateCompletionList(contextString, range, 0);
+    const additionalItems = generateCompletionList(additionalContext, range, 1);
+    return [...completionItems, ...additionalItems];
+};
+/*
+  This function traverses the AST and finds which node and context we are currently
+  in to help provide the necessary completion items. This follows from having a complete
+  and valid SQL expression. The main purpose of this function is to provide the correct
+  completion items when users trigger IntelliSense via CTRL + Space.
+
+  This is a recursive function.
+*/
+// eslint-disable-next-line complexity
+const traverseAST = (
+/*
+  Keeping the node type as generic 'any' here as __esri.SQLNode does not have updated types
+  with the addition of the range property. Documentation is outdated and may or may not
+  contain mismatching property names (ListNode uses "expr" as property for all expressions
+  but representation is via "value") and some missing cases (e.g. case "parameter" is not
+  identified).
+*/
+{ model, node, position, context, sdkFunctions, delimiterPos, }) => {
+    /* Our current cursor position within the editor */
+    // const cursorRow: number = position.lineNumber;
+    // const cursorColumn: number = position.column;
+    switch (node.type) {
+        case "interval": {
+            /*
+              Here, we are using an interval node as a standalone and not within any
+              function call or expression list.
+            */
+            if (!delimiterPos) {
+                updateContext(context, "INTERVAL", false);
+                return;
+            }
+            /*
+              We can ensure that the match is never null since a fully generated AST
+              follows from a syntactically correct SQL expression.
+            */
+            const nextDelimPos = model.findNextMatch(
+            // @ts-ignore
+            /\)|,/u, {
+                lineNumber: node.location.end.line,
+                column: node.location.end.column,
+            }, true, true, null, true).range;
+            const [inlineFunc, funcWrapped] = getCursorWithinRange(position, delimiterPos, nextDelimPos);
+            if (inlineFunc ?? funcWrapped) {
+                updateContext(context, "INTERVAL", false);
+            }
+            return;
+        }
+        case "case-expression": {
+            /* Only update context if we are within the range */
+            // Representing the range for the "CASE" keyword for starting the case expression
+            const startPos = {
+                startColumn: node.location.start.column,
+                endColumn: node.location.start.column + 4,
+                startLineNumber: node.location.start.line,
+                endLineNumber: node.location.start.line,
+            };
+            // Representing the range for the "END" keyword for ending the case expression
+            const endPos = {
+                startColumn: node.location.end.column - 3,
+                endColumn: node.location.end.column,
+                startLineNumber: node.location.end.line,
+                endLineNumber: node.location.end.line,
+            };
+            const [inline, wrapped] = getCursorWithinRange(position, startPos, endPos);
+            if (inline ?? wrapped) {
+                updateContext(context, "CASE", false);
+            }
+            return;
+        }
+        case "expression-list": {
+            const exprList = node.value;
+            let delimiter;
+            exprList.forEach((expr, index) => {
+                /* The position of our opening delimiter '(' */
+                if (index === 0) {
+                    const match = model.findMatches("(", {
+                        startLineNumber: 1,
+                        endLineNumber: node.location.start.line,
+                        startColumn: 1,
+                        endColumn: node.location.start.column,
+                    }, false, true, null, true);
+                    delimiter = match[match.length - 1].range;
+                }
+                traverseAST({ model, node: expr, position, context, sdkFunctions, delimiterPos: delimiter });
+                /*
+                  Finds and updates our next delimiter position (i.e. the delimiter that immediately
+                  follows this current node)
+                */
+                delimiter = getDelimiterPosition(index + 1, expr, model, exprList.length);
+            });
+            return;
+        }
+        case "unary-expression":
+            traverseAST({ model, node: node.expr, position, context, sdkFunctions });
+            return;
+        case "binary-expression":
+            traverseAST({ model, node: node.left, position, context, sdkFunctions });
+            traverseAST({ model, node: node.right, position, context, sdkFunctions });
+            return;
+        case "null":
+        case "boolean":
+        case "string":
+        case "timestamp":
+        case "date":
+        case "time":
+        case "number":
+        case "current-time":
+            return;
+        case "column-reference": {
+            const columnName = node.column;
+            const isParenLessFunction = isSqlParenLessFunction(columnName);
+            /*
+              In this case, we are using a standalone column reference, not a part of any
+              expression list or function param. Update the context accordingly if it is
+              any of the parenthesis-less functions.
+            */
+            if (!delimiterPos) {
+                if (isParenLessFunction) {
+                    updateContext(context, columnName, false);
+                }
+                return;
+            }
+            /*
+              The delimiter right before we start our expression. This delimiter is useful for us
+              as it gives positional information for when the expression starts if it's used as a
+              parameter in a function.
+      
+              For example, if we have something like Function(a, b), then the range of b would have
+              a start column value of 13 (offset of 12) whereas "," would be 11 (offset of 10).
+      
+              This will be useful in the case where we want to provide completion items before our
+              keyword appears (if any).
+            */
+            const delimiterCharacter = model.getValueInRange(delimiterPos);
+            const nextDelimiterPos = model.findNextMatch(
+            /*
+              Function call only accepts string even though docs noted that RegExp is allowed.
+              "@param searchString — The string used to search. If it is a regular expression,
+              set isRegex to true"
+            */
+            // @ts-ignore
+            /\)|,/u, {
+                column: node.location.start.column,
+                lineNumber: node.location.start.line,
+            }, true, true, null, true).range;
+            const [inlineWithFunction, wrappedWithinFunction] = getCursorWithinRange(position, delimiterPos, nextDelimiterPos);
+            if (inlineWithFunction ?? wrappedWithinFunction) {
+                /*
+                  We updated our additional context here if this is our first argument within a function call.
+                  This is so we don't override the previous context with our current context, which may
+                  strip away certain completion items. For example, if we have the SQL expression
+                  CAST(INTERVAL), we still want the completion items for CAST as well as INTERVAL.
+                */
+                if (isParenLessFunction) {
+                    updateContext(context, columnName, delimiterCharacter === "(");
+                }
+            }
+            return;
+        }
+        case "data-type":
+            return;
+        case "function": {
+            const functionName = node.name;
+            const argsList = node.args.value;
+            const startRange = {
+                startLineNumber: node.location.start.line,
+                endLineNumber: node.location.start.line,
+                startColumn: node.location.start.column,
+                endColumn: node.location.start.column + functionName.length,
+            };
+            const endRange = {
+                startLineNumber: node.location.end.line,
+                endLineNumber: node.location.end.line,
+                startColumn: node.location.end.column,
+                endColumn: node.location.end.column,
+            };
+            const [inlineWithFunc, wrappedWithinFunc] = getCursorWithinRange(position, startRange, endRange);
+            if (inlineWithFunc ?? wrappedWithinFunc) {
+                updateContext(context, functionName, false);
+            }
+            let delimiterPosition;
+            argsList.forEach((arg, index) => {
+                const nodeType = arg.type;
+                let completionNodeType = false;
+                switch (nodeType) {
+                    case "function":
+                    case "column-reference":
+                    case "interval":
+                    case "case-expression":
+                        completionNodeType = true;
+                        break;
+                }
+                /*
+                  We can ensure that the match is never undefined since a fully generated AST
+                  follows from a syntactically correct SQL expression.
+                */
+                if (index === 0) {
+                    delimiterPosition = model.findNextMatch("(", {
+                        column: node.location.start.column,
+                        lineNumber: node.location.start.line,
+                    }, false, true, null, true).range;
+                }
+                /* TRIM(abc) === TRIM(BOTH ' ' FROM abc). In this case, our next delimiter is the end */
+                const trimFuncDefault = arg.type === "string" && arg.value === "BOTH";
+                /*
+                  If the current node is not a completion node type, and is the default trim function,
+                  then we will just use the current node as a reference to get the next delimiter position.
+                */
+                if (!completionNodeType && trimFuncDefault) {
+                    return;
+                }
+                traverseAST({ model, node: arg, position, context, sdkFunctions, delimiterPos: delimiterPosition });
+                delimiterPosition = getDelimiterPosition(index + 1, arg, model, argsList.length);
+            });
+            return;
+        }
+        /* Currently no support for parameter type (@) */
+        case "parameter":
+        case "when-clause":
+        case "interval-period":
+        case "interval-qualifier":
+            return;
+        default:
+            throw new Error("Invalid syntax.");
+    }
+};
+/*
+  Helper function that generates our list of completion items after traversing
+  our AST and updating the context.
+  
+  The sorting number is used as a way of grouping and organizing our completion lists.
+
+  - All default completion items have a sort value of 'z' (ASCII 122) + their corresponding
+    grouping value (e.g. 'za', 'zb', etc...)
+  - All completion items found by cursor matching have a value between 'a' - 'y' (ASCII 97-121)
+  - The higher the sorting number, the higher it will appear on our completion list
+*/
+const generateCompletionList = (functionName, range, sortingNumber) => {
+    const identifiers = getKeywords(functionName);
+    const completionItems = identifiers?.map((identifier) => {
+        const dataKind = dataTypes.includes(identifier.toUpperCase())
+            ? languages.CompletionItemKind.TypeParameter
+            : languages.CompletionItemKind.Keyword;
+        return {
+            label: identifier,
+            kind: dataKind,
+            insertText: identifier,
+            range,
+            sortText: String.fromCharCode(121 - sortingNumber),
+        };
+    });
+    return completionItems ?? [];
+};
+/*
+  Function to help us update our current context depending on where our cursor
+  is within the editor. This will allow us to gather the relevant completion items
+  depending on the value of the context (i.e. the function that our cursor is within).
+
+  This is invoked only during our traversal of the AST (i.e. "success" case).
+*/
+const updateContext = (oldContext, newContext, updateAdditionalContext) => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    updateAdditionalContext ? (oldContext.additionalContext = newContext) : (oldContext.contextString = newContext);
+};
+/** source  */
+const sqlBinOps = [
+    "AND",
+    "OR",
+    "IS",
+    "ISNOT",
+    "IN",
+    "NOT IN",
+    "BETWEEN",
+    "NOTBETWEEN",
+    "LIKE",
+    "NOT LIKE",
+];
+/*
+  The current state of sorting completion items.
+
+  All fields that are provided by default (keywords, standardized functions, constants, etc.)
+  all have a sort value of "z". As we parse our SQL Expression and traverse an AST (if we can),
+  we will have new completion items depending on our cursor context. These completion items
+  should appear first at the top of our list, with the most recent context having the highest
+  appearance on our list. In this manner, we add new completion items with a smaller
+  lexicographic value than the previous to promote the correct ordering. (I.e. add in new completion
+  items with a sort value of "y" next, then "x", then "w", all the way until "a". It is unlikely
+  that we will need more than 26 difference context but if we do require more, we can make use of
+  double-lettered sort values).
+*/
+const sortTextValues = {
+    identifiers: "a",
+    fields: "aa",
+    constants: "ab",
+    literals: "ab",
+    functions: "ac",
+    snippets: "b",
+    keywords: "c",
+    dataType: "d",
+};
+function generateCompletionItems(fields, range, sdkFunctions) {
+    const fieldsCompletion = fields.map((field) => ({
+        label: field.completion?.label ?? field.name,
+        insertText: field.completion?.insertText ?? field.name,
+        sortText: `z${sortTextValues.fields}`,
+        detail: field.completion?.detail,
+        range,
+        kind: languages.CompletionItemKind.Variable,
+        documentation: field.completion?.documentation,
+    }));
+    //   {
+    //   const funcName = func.toLowerCase();
+    //   const apiContext = apiFunctions[funcName as keyof typeof apiFunctions] as ApiContextType;
+    //   const { name, snippet, parameters, returnValue, description, examples } = apiContext;
+    //   const completionItemData = {
+    //     kind: monaco.languages.CompletionItemKind.Function,
+    //     range,
+    //     sortText: `z${sortTextValues.functions}`,
+    //     detail: generateTypeDescription(name, parameters, returnValue),
+    //     documentation: generateCompletionDocumentation(description, examples),
+    //   };
+    //   /*
+    //     We take 2 different forms of the same function over our REST API.
+    //     e.g. CURRENT_TIME and CURRENT_TIME() are both accepted.
+    //   */
+    //   if (Array.isArray(snippet) && snippet.length) {
+    //     return [
+    //       { ...completionItemData, label: name, insertText: snippet[0]! },
+    //       snippet[1] && { ...completionItemData, label: name.slice(0, -2), insertText: snippet[1] },
+    //     ];
+    //   }
+    //   return [{ ...completionItemData, label: name, insertText: snippet }];
+    // }
+    // );
+    const sqlBinOpsCompletion = sqlBinOps.map((binOp) => {
+        const formatOperator = (binOp) => {
+            if (binOp === "ISNOT") {
+                return "IS NOT";
+            }
+            if (binOp === "NOTBETWEEN") {
+                return "NOT BETWEEN";
+            }
+            return binOp;
+        };
+        return {
+            label: formatOperator(binOp),
+            kind: languages.CompletionItemKind.Keyword,
+            insertText: formatOperator(binOp),
+            range,
+            sortText: `z${sortTextValues.keywords}`,
+        };
+    });
+    const sqlKeywordsCompletion = sqlParenLessFunctions.map((keyword) => {
+        if (keyword === "CASE") {
+            return {
+                label: keyword,
+                kind: languages.CompletionItemKind.Snippet,
+                insertText: `CASE
+	WHEN condition1 THEN result1 
+	ELSE result
+END`,
+                range,
+                sortText: `z${sortTextValues.snippets}`,
+            };
+        }
+        return {
+            label: keyword,
+            kind: languages.CompletionItemKind.Keyword,
+            insertText: keyword,
+            range,
+            sortText: `z${sortTextValues.keywords}`,
+        };
+    });
+    const sqlDataTypeCompletion = dataTypes.map((dataType) => ({
+        label: dataType,
+        kind: languages.CompletionItemKind.TypeParameter,
+        insertText: dataType,
+        range,
+        sortText: `z${sortTextValues.dataType}`,
+    }));
+    const sqlFunctionCompletion = Object.values(sdkFunctions).map((apiItem) => {
+        const entry = apiItem.completion;
+        const item = {
+            label: entry.label,
+            insertText: entry.insertText || entry.label,
+            sortText: `z${sortTextValues.functions}`,
+            filterText: entry.filterText,
+            detail: entry.detail,
+            range,
+            kind: toCompletionItemKind(entry.kind),
+        };
+        if (entry.insertTextFormat === main.exports.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 {
+        fieldsCompletion,
+        sqlFunctionCompletion,
+        sqlBinOpsCompletion,
+        sqlKeywordsCompletion,
+        sqlDataTypeCompletion,
+    };
+}
+
+// list of properties that sit on a SQLNode and can have children
+var ChildBearingProperties;
+(function (ChildBearingProperties) {
+    ChildBearingProperties["ARGS"] = "args";
+    ChildBearingProperties["CLAUSES"] = "clauses";
+    ChildBearingProperties["ELSE"] = "else";
+    ChildBearingProperties["END"] = "end";
+    ChildBearingProperties["EXPR"] = "expr";
+    ChildBearingProperties["LEFT"] = "left";
+    ChildBearingProperties["OPERAND"] = "operand";
+    ChildBearingProperties["QUALIFIER"] = "qualifier";
+    ChildBearingProperties["RIGHT"] = "right";
+    ChildBearingProperties["START"] = "start";
+    ChildBearingProperties["VALUE"] = "value";
+})(ChildBearingProperties || (ChildBearingProperties = {}));
+// list of node types that can have children
+var ChildBearingNodeTypes;
+(function (ChildBearingNodeTypes) {
+    ChildBearingNodeTypes["CASE_EXPRESSION"] = "case-expression";
+    ChildBearingNodeTypes["EXPRESSION_LIST"] = "expression-list";
+    ChildBearingNodeTypes["FUNCTION"] = "function";
+    ChildBearingNodeTypes["INTERVAL"] = "interval";
+    ChildBearingNodeTypes["INTERVAL_QUALIFIER"] = "interval-qualifier";
+    ChildBearingNodeTypes["WHEN_CLAUSE"] = "when-clause";
+    ChildBearingNodeTypes["UNARY_EXPRESSION"] = "unary-expression";
+    ChildBearingNodeTypes["BINARY_EXPRESSION"] = "binary-expression";
+})(ChildBearingNodeTypes || (ChildBearingNodeTypes = {}));
+const sqlFunctionParamKeywords = {
+    CAST: ["DATE", "FLOAT", "INTEGER", "REAL", "SMALLINT", "TIME", "TIMESTAMP", "VARCHAR"],
+    EXTRACT: ["YEAR", "MONTH", "DAY", "HOUR", "MINUTE", "SECOND"],
+    TRIM: ["LEADING", "TRAILING", "BOTH"],
+};
+
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+function transposeSdkFunctions(sdkLibrary) {
+    return sdkLibrary.flatMap((category) => category.items).reduce((acc, item) => ({ ...acc, [item.name]: item }), {});
+}
+class SqlExprCompletionProvider {
+    constructor(
+    // private _worker: ISqlExprWorkerAccessor,
+    _defaults) {
+        this._defaults = _defaults;
+        this._sdkFunctions = transposeSdkFunctions([]);
+    }
+    async provideCompletionItems(model, position) {
+        const word = model.getWordUntilPosition(position);
+        const range = {
+            startLineNumber: position.lineNumber,
+            endLineNumber: position.lineNumber,
+            startColumn: word.startColumn,
+            endColumn: word.endColumn,
+        };
+        const apiContext = this._defaults.getApiContextForModel(model.uri);
+        // get the fields from the api context
+        const fields = apiContext.profile ? getFieldsFromLayerVariable(apiContext.profile) : [];
+        const sdkLibrary = await this._defaults.getApiLibrary(model.uri.toString());
+        this._sdkFunctions = transposeSdkFunctions(sdkLibrary);
+        const sqlContextCompletion = await sqlExpressionCompletion(range, model, position, this._sdkFunctions);
+        const { sqlKeywordsCompletion, sqlBinOpsCompletion, sqlFunctionCompletion, fieldsCompletion, sqlDataTypeCompletion, } = generateCompletionItems(fields, range, this._sdkFunctions);
+        /*
+              Filters our completion items list so that if we happen to have the same label but
+              different sortText order, we keep the sortText with the lowest ASCII value (i.e.
+              the smallest character in terms of lexicographic ordering).
+            */
+        const filteredItems = new Map();
+        [
+            ...sqlKeywordsCompletion,
+            ...sqlBinOpsCompletion,
+            ...sqlDataTypeCompletion,
+            ...sqlFunctionCompletion,
+            ...fieldsCompletion,
+            ...sqlContextCompletion,
+        ].forEach((item) => {
+            const { sortText } = item;
+            const label = item.label;
+            const itemExists = filteredItems.get(label);
+            if (!itemExists) {
+                filteredItems.set(label, item);
+            }
+            const currentOrder = sortText.charCodeAt(0);
+            const currentLowestOrder = filteredItems.get(label).sortText.charCodeAt(0);
+            if (currentOrder < currentLowestOrder) {
+                filteredItems.set(label, item);
+            }
+        });
+        const completionItems = Array.from(filteredItems.entries()).map(([, value]) => value);
+        return {
+            suggestions: completionItems,
+        };
+    }
+}
+// TODO: create DiagnosticsAdapter common class
+class SqlExprDiagnosticsAdapter {
+    constructor(_languageId, _worker, { defaults, diagnosticService, }) {
+        this._languageId = _languageId;
+        this._worker = _worker;
+        this._disposables = [];
+        this._listener = new Map();
+        this._diagnosticsService = diagnosticService;
+        this._defaults = defaults;
+        const onModelAdd = (model) => {
+            const languageId = model.getLanguageId();
+            if (languageId !== this._languageId) {
+                return;
+            }
+            const debouncedValidate = debounce(() => {
+                this._doValidate(model, languageId).catch((err) => {
+                    throw err;
+                });
+            });
+            this._listener.set(model.uri.toString(), model.onDidChangeContent(debouncedValidate));
+            this._doValidate(model, languageId).catch(console.error);
+        };
+        const onModelRemoved = (model) => {
+            const uri = model.uri.toString();
+            editor.setModelMarkers(model, this._languageId, []);
+            const listener = this._listener.get(uri);
+            if (listener) {
+                listener.dispose();
+                this._listener.delete(uri);
+            }
+        };
+        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).catch(console.error);
+                }
+            });
+        }));
+        this._disposables.push({
+            dispose: () => {
+                this._listener.forEach((value) => value.dispose());
+                this._listener.clear();
+            },
+        });
+        editor.getModels().forEach(onModelAdd);
+    }
+    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);
+            this._diagnosticsService.fireDiagnosticsChange(model.uri, diagnostics);
+            editor.setModelMarkers(model, languageId, diagnostics);
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
+}
+const sqlParenLessFunctions = ["INTERVAL", "CASE"];
+const dataTypes = sqlFunctionParamKeywords.CAST;
+/*
+  Helper function that takes in a context string and returns a string list of
+  all the keywords that are used by that identifier. This is used to generate
+  our completion items list for specific contexts.
+*/
+const getKeywords = (identifier) => {
+    switch (identifier.toLowerCase()) {
+        case "extract":
+            /* Need to revisit TIMEZONE_HOUR and TIMEZONE_MINUTE with the team */
+            return sqlFunctionParamKeywords.EXTRACT;
+        case "position":
+            return ["IN"];
+        case "trim":
+            return sqlFunctionParamKeywords.TRIM;
+        case "cast":
+            return ["AS", ...sqlFunctionParamKeywords.CAST];
+        case "interval":
+            return [...sqlFunctionParamKeywords.EXTRACT];
+        case "case":
+            return ["WHEN", "THEN", "ELSE", "END"];
+        default:
+            return [];
+    }
+};
+/*
+  Helper function that takes in an index and node and determines the next
+  delimiter position after the current index argument. This function is invoked
+  only when we have a list of arguments via a function call or expression list.
+*/
+const getDelimiterPosition = (index, node, model, lastIndex) => {
+    let delimiterPosition;
+    const start = node.range.start;
+    const end = node.range.end;
+    /*
+        We can ensure that the match is never null since a fully generated AST
+        follows from a syntactically correct SQL expression.
+      */
+    if (index === 0) {
+        delimiterPosition = model.findNextMatch("(", {
+            lineNumber: start.line,
+            column: start.column,
+        }, false, true, null, true).range;
+    }
+    else if (index === lastIndex) {
+        delimiterPosition = {
+            startLineNumber: end.line,
+            endLineNumber: end.line,
+            startColumn: end.column,
+            endColumn: end.column,
+        };
+    }
+    else {
+        delimiterPosition = model.findNextMatch(",", {
+            lineNumber: start.line,
+            column: start.column,
+        }, false, true, null, true).range;
+    }
+    return delimiterPosition;
+};
+/* Helper function to determine if our word is a SQL parenthesis-less function. */
+const isSqlParenLessFunction = (word) => {
+    const keyword = word.toUpperCase();
+    return sqlParenLessFunctions.includes(keyword);
+};
+/*
+  Helper function to determine if our cursor is within the range of a function.
+  This can be any of the patterns:
+  - function(<here>)
+  - function(<here>
+    <here>
+  <here>)
+*/
+const getCursorWithinRange = (position, startPos, endPos) => {
+    let inlineWithFunction = false;
+    let wrappedWithinFunction = false;
+    const cursorColumn = position.column;
+    const cursorRow = position.lineNumber;
+    /*
+      Handles the case if our function is inline. An expression following the pattern
+      
+      FUNCTION(arg) where our cursor position is in between the '(' and ')' of FUNCTION.
+      i.e. FUNCTION( | arg | ) where '|' represents the possible cursor position.
+    */
+    if (startPos.startLineNumber === endPos.startLineNumber &&
+        startPos.startLineNumber === cursorRow &&
+        cursorColumn > startPos.startColumn &&
+        cursorColumn < endPos.endColumn) {
+        inlineWithFunction = true;
+    }
+    /*
+      Handles the case where our function signature is multiline. That is, if we are
+      anywhere between the '(' and the ')' of some expression that follows the pattern:
+      
+      FUNCTION( |
+        | args |
+      | )
+      
+      where '|' represents the possible cursor position.
+    */
+    const functionWrap = (cursorRow === startPos.startLineNumber && cursorColumn > startPos.startColumn) ||
+        (cursorRow === endPos.startLineNumber && cursorColumn < endPos.endColumn) ||
+        (cursorRow > startPos.startLineNumber && cursorRow < endPos.endLineNumber);
+    if (startPos.startLineNumber !== endPos.startLineNumber) {
+        if (functionWrap) {
+            wrappedWithinFunction = true;
+        }
+    }
+    return [inlineWithFunction, wrappedWithinFunction];
+};
+
+let sqlExprWorker;
+/**
+ * Returns the sql-expression worker for the model uris.
+ * @param uris The model uris for which to get the worker.
+ * @returns The sql-expression worker.
+ */
+async function getSqlExprWorker(...uris) {
+    return await new Promise((resolve, reject) => {
+        if (!sqlExprWorker) {
+            reject(new Error("sql expression worker not registered!"));
+            return;
+        }
+        resolve(sqlExprWorker(...uris));
+    });
+}
+class SqlExprDiagnosticService {
+    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 sqlExprDiagnosticService = new SqlExprDiagnosticService();
+/**
+ *
+ * @returns The Sql Expression Diagnostic Service.
+ */
+function getSqlExprDiagnosticService() {
+    return sqlExprDiagnosticService;
+}
+function setupMode(defaults) {
+    const client = new SqlExprWorkerManager(defaults);
+    const workerAccessor = async (...uris) => await client.getLanguageServiceWorker(...uris);
+    sqlExprWorker = workerAccessor;
+    // Use the sql-expression Monarch Json to define the highlighting
+    languages.setMonarchTokensProvider(sqlExprDefaults.languageId, sqlExprLanguageSyntax);
+    languages.setLanguageConfiguration(sqlExprDefaults.languageId, sqlExprLanguageConfig);
+    const completionProvider = new SqlExprCompletionProvider(sqlExprDefaults);
+    // Creates and registers a Completion Adapter
+    // Registers a completion item provider for our custom language
+    languages.registerCompletionItemProvider(sqlExprDefaults.languageId, completionProvider);
+    // TODO: Creates and registers a Formatter
+    // languages.registerDocumentFormattingEditProvider(
+    //   SqlExprDefaults.languageId,
+    //   new FormattingProvider(workerAccessor, SqlExprDefaults),
+    // );
+    // eslint-disable-next-line no-new
+    new SqlExprDiagnosticsAdapter(defaults.languageId, workerAccessor, {
+        defaults,
+        diagnosticService: sqlExprDiagnosticService,
+    });
+}
+
+export { getSqlExprDiagnosticService, getSqlExprWorker, setupMode };