@malloydata/malloy 0.0.1

package/dist/lang/parse-tree-walkers/document-highlight-walker.js

@@ -0,0 +1,375 @@
+"use strict";
+/*
+ * Copyright 2021 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortHighlights = exports.walkForDocumentHighlights = exports.passForHighlights = exports.HighlightType = void 0;
+const ParseTreeWalker_1 = require("antlr4ts/tree/ParseTreeWalker");
+const MalloyParser_1 = require("../lib/Malloy/MalloyParser");
+// TODO maybe this could be an enum like Definition__Field, etc.
+exports.HighlightType = {
+    Identifier: "identifier",
+    Type: "type",
+    Literal: {
+        Date: "literal.date",
+        Number: "literal.number",
+        String: "literal.string",
+        RegularExpression: "literal.regular_expression",
+        Boolean: "literal.boolean",
+        Null: "literal.null",
+    },
+    Call: {
+        Aggregate: "call.aggregate",
+        TimeFrame: "call.time_frame",
+        Cast: "call.cast",
+        Table: "call.table",
+        From: "call.from",
+        Function: "call.function",
+        FromSQL: "call.from_sql",
+    },
+    // TODO many of these should probably be categorized further
+    Keyword: {
+        AggregateModifier: {
+            Distinct: "keyword.aggregate_modifier.distinct",
+        },
+        CastModifier: {
+            As: "keyword.cast_modifier.as",
+        },
+        Is: "keyword.is",
+        On: "keyword.on",
+        Desc: "keyword.desc",
+        Asc: "keyword.asc",
+        Pick: "keyword.pick",
+        When: "keyword.when",
+        Else: "keyword.else",
+        With: "keyword.with",
+        // TODO or is this a meta type?
+        JSON: "keyword.json",
+        // TODO or is this a meta type?
+        Turtle: "keyword.turtle",
+        Import: "keyword.import",
+    },
+    Operator: {
+        Comparison: "operator.comparison",
+        Boolean: "operator.boolean",
+        Date: "operator.date",
+    },
+    Comment: {
+        Line: "comment.line",
+        Block: "comment.block",
+    },
+    Property: {
+        Accept: "property.accept",
+        Aggregate: "property.aggregate",
+        Dimension: "property.dimension",
+        Except: "property.except",
+        Source: "property.source",
+        GroupBy: "property.group_by",
+        Having: "property.having",
+        Index: "property.index",
+        JoinOne: "keyword.join_one",
+        JoinMany: "keyword.join_many",
+        JoinCross: "keyword.join_cross",
+        Limit: "property.limit",
+        Measure: "property.measure",
+        Nest: "property.nest",
+        OrderBy: "property.order_by",
+        PrimaryKey: "property.primary_key",
+        Project: "property.project",
+        Query: "property.query",
+        Rename: "property.rename",
+        Top: "property.top",
+        Where: "property.where",
+        SQL: "property.sql",
+    },
+};
+function passForHighlights(tokens) {
+    const highlights = [];
+    const register = (token, type, removeColon = false) => {
+        var _a;
+        const offset = token.startIndex - token.charPositionInLine;
+        const tokenLines = ((_a = token.text) === null || _a === void 0 ? void 0 : _a.split("\n")) || [];
+        const numberOfLines = tokenLines.length;
+        const lengthOfAllButLastLine = tokenLines
+            .slice(0, -1)
+            .reduce((a, l) => a + l.length, 0);
+        const colonAdjustment = removeColon ? 1 : 0;
+        highlights.push({
+            type,
+            range: {
+                start: { line: token.line - 1, character: token.startIndex - offset },
+                end: {
+                    line: token.line - 1 + numberOfLines - 1,
+                    character: token.stopIndex +
+                        2 -
+                        (numberOfLines > 1 ? token.startIndex : offset) -
+                        lengthOfAllButLastLine -
+                        numberOfLines -
+                        colonAdjustment,
+                },
+            },
+        });
+    };
+    for (let i = 0; i < tokens.size; i++) {
+        const token = tokens.get(i);
+        switch (token.type) {
+            case MalloyParser_1.MalloyParser.ACCEPT:
+                register(token, exports.HighlightType.Property.Accept, true);
+                break;
+            case MalloyParser_1.MalloyParser.AGGREGATE:
+                register(token, exports.HighlightType.Property.Aggregate, true);
+                break;
+            case MalloyParser_1.MalloyParser.DIMENSION:
+                register(token, exports.HighlightType.Property.Dimension, true);
+                break;
+            case MalloyParser_1.MalloyParser.EXCEPT:
+                register(token, exports.HighlightType.Property.Except, true);
+                break;
+            case MalloyParser_1.MalloyParser.GROUP_BY:
+                register(token, exports.HighlightType.Property.GroupBy, true);
+                break;
+            case MalloyParser_1.MalloyParser.HAVING:
+                register(token, exports.HighlightType.Property.Having, true);
+                break;
+            case MalloyParser_1.MalloyParser.INDEX:
+                register(token, exports.HighlightType.Property.Index, true);
+                break;
+            case MalloyParser_1.MalloyParser.JOIN_CROSS:
+                register(token, exports.HighlightType.Property.JoinOne, true);
+                break;
+            case MalloyParser_1.MalloyParser.JOIN_ONE:
+                register(token, exports.HighlightType.Property.JoinMany, true);
+                break;
+            case MalloyParser_1.MalloyParser.JOIN_MANY:
+                register(token, exports.HighlightType.Property.JoinCross, true);
+                break;
+            case MalloyParser_1.MalloyParser.LIMIT:
+                register(token, exports.HighlightType.Property.Limit, true);
+                break;
+            case MalloyParser_1.MalloyParser.MEASURE:
+                register(token, exports.HighlightType.Property.Measure, true);
+                break;
+            case MalloyParser_1.MalloyParser.NEST:
+                register(token, exports.HighlightType.Property.Nest, true);
+                break;
+            case MalloyParser_1.MalloyParser.ORDER_BY:
+                register(token, exports.HighlightType.Property.OrderBy, true);
+                break;
+            case MalloyParser_1.MalloyParser.PRIMARY_KEY:
+                register(token, exports.HighlightType.Property.PrimaryKey, true);
+                break;
+            case MalloyParser_1.MalloyParser.PROJECT:
+                register(token, exports.HighlightType.Property.Project, true);
+                break;
+            case MalloyParser_1.MalloyParser.QUERY:
+                register(token, exports.HighlightType.Property.Query, true);
+                break;
+            case MalloyParser_1.MalloyParser.RENAME:
+                register(token, exports.HighlightType.Property.Rename, true);
+                break;
+            case MalloyParser_1.MalloyParser.SOURCE:
+                register(token, exports.HighlightType.Property.Source, true);
+                break;
+            case MalloyParser_1.MalloyParser.TOP:
+                register(token, exports.HighlightType.Property.Top, true);
+                break;
+            case MalloyParser_1.MalloyParser.WHERE:
+                register(token, exports.HighlightType.Property.Where, true);
+                break;
+            case MalloyParser_1.MalloyParser.SQL:
+                register(token, exports.HighlightType.Property.SQL, true);
+                break;
+            case MalloyParser_1.MalloyParser.TABLE:
+                register(token, exports.HighlightType.Call.Table);
+                break;
+            case MalloyParser_1.MalloyParser.FROM:
+                register(token, exports.HighlightType.Call.From);
+                break;
+            case MalloyParser_1.MalloyParser.FROM_SQL:
+                register(token, exports.HighlightType.Call.FromSQL);
+                break;
+            case MalloyParser_1.MalloyParser.STRING_LITERAL:
+            case MalloyParser_1.MalloyParser.JSON_STRING:
+                register(token, exports.HighlightType.Literal.String);
+                break;
+            case MalloyParser_1.MalloyParser.NUMERIC_LITERAL:
+            case MalloyParser_1.MalloyParser.INTEGER_LITERAL:
+                register(token, exports.HighlightType.Literal.Number);
+                break;
+            case MalloyParser_1.MalloyParser.HACKY_REGEX:
+                register(token, exports.HighlightType.Literal.RegularExpression);
+                break;
+            case MalloyParser_1.MalloyParser.IS:
+                register(token, exports.HighlightType.Keyword.Is);
+                break;
+            case MalloyParser_1.MalloyParser.DISTINCT:
+                register(token, exports.HighlightType.Keyword.AggregateModifier.Distinct);
+                break;
+            case MalloyParser_1.MalloyParser.ON:
+                register(token, exports.HighlightType.Keyword.On);
+                break;
+            case MalloyParser_1.MalloyParser.DESC:
+                register(token, exports.HighlightType.Keyword.Desc);
+                break;
+            case MalloyParser_1.MalloyParser.ASC:
+                register(token, exports.HighlightType.Keyword.Asc);
+                break;
+            case MalloyParser_1.MalloyParser.CAST:
+                register(token, exports.HighlightType.Call.Cast);
+                break;
+            case MalloyParser_1.MalloyParser.AS:
+                register(token, exports.HighlightType.Keyword.CastModifier.As);
+                break;
+            case MalloyParser_1.MalloyParser.PICK:
+                register(token, exports.HighlightType.Keyword.Pick);
+                break;
+            case MalloyParser_1.MalloyParser.WHEN:
+                register(token, exports.HighlightType.Keyword.When);
+                break;
+            case MalloyParser_1.MalloyParser.WITH:
+                register(token, exports.HighlightType.Keyword.With);
+                break;
+            case MalloyParser_1.MalloyParser.ELSE:
+                register(token, exports.HighlightType.Keyword.Else);
+                break;
+            case MalloyParser_1.MalloyParser.JSON:
+                register(token, exports.HighlightType.Keyword.JSON);
+                break;
+            case MalloyParser_1.MalloyParser.TURTLE:
+                register(token, exports.HighlightType.Keyword.Turtle);
+                break;
+            case MalloyParser_1.MalloyParser.TRUE:
+            case MalloyParser_1.MalloyParser.FALSE:
+                register(token, exports.HighlightType.Literal.Boolean);
+                break;
+            case MalloyParser_1.MalloyParser.NOW:
+            case MalloyParser_1.MalloyParser.LITERAL_TIMESTAMP:
+            case MalloyParser_1.MalloyParser.LITERAL_QUARTER:
+            case MalloyParser_1.MalloyParser.LITERAL_MONTH:
+            case MalloyParser_1.MalloyParser.LITERAL_DAY:
+            case MalloyParser_1.MalloyParser.LITERAL_WEEK:
+            case MalloyParser_1.MalloyParser.LITERAL_YEAR:
+                register(token, exports.HighlightType.Literal.Date);
+                break;
+            case MalloyParser_1.MalloyParser.NULL:
+                register(token, exports.HighlightType.Literal.Null);
+                break;
+            case MalloyParser_1.MalloyParser.AND:
+            case MalloyParser_1.MalloyParser.OR:
+            case MalloyParser_1.MalloyParser.NOT:
+                register(token, exports.HighlightType.Operator.Boolean);
+                break;
+            case MalloyParser_1.MalloyParser.FOR:
+                register(token, exports.HighlightType.Operator.Date);
+                break;
+            case MalloyParser_1.MalloyParser.COMMENT_TO_EOL:
+                register(token, exports.HighlightType.Comment.Line);
+                break;
+            case MalloyParser_1.MalloyParser.BLOCK_COMMENT:
+                register(token, exports.HighlightType.Comment.Block);
+                break;
+            case MalloyParser_1.MalloyParser.SUM:
+            case MalloyParser_1.MalloyParser.COUNT:
+            case MalloyParser_1.MalloyParser.AVG:
+            case MalloyParser_1.MalloyParser.MIN:
+            case MalloyParser_1.MalloyParser.MAX:
+                register(token, exports.HighlightType.Call.Aggregate);
+                break;
+            case MalloyParser_1.MalloyParser.IDENTIFIER:
+            case MalloyParser_1.MalloyParser.OBJECT_NAME_LITERAL:
+                register(token, exports.HighlightType.Identifier);
+                break;
+            case MalloyParser_1.MalloyParser.STRING:
+            case MalloyParser_1.MalloyParser.NUMBER:
+            case MalloyParser_1.MalloyParser.BOOLEAN:
+            case MalloyParser_1.MalloyParser.DATE:
+            case MalloyParser_1.MalloyParser.TIMESTAMP:
+                register(token, exports.HighlightType.Type);
+                break;
+            case MalloyParser_1.MalloyParser.SECOND:
+            case MalloyParser_1.MalloyParser.MINUTE:
+            case MalloyParser_1.MalloyParser.HOUR:
+            case MalloyParser_1.MalloyParser.DAY:
+            case MalloyParser_1.MalloyParser.WEEK:
+            case MalloyParser_1.MalloyParser.MONTH:
+            case MalloyParser_1.MalloyParser.QUARTER:
+            case MalloyParser_1.MalloyParser.YEAR:
+                register(token, exports.HighlightType.Call.TimeFrame);
+                break;
+            case MalloyParser_1.MalloyParser.IMPORT:
+                register(token, exports.HighlightType.Keyword.Import);
+                break;
+            // TODO durations? How should we highlight `3 days` or
+            //      `(1 + 2) days` or `n days`?
+        }
+    }
+    return highlights;
+}
+exports.passForHighlights = passForHighlights;
+class DocumentHighlightWalker {
+    constructor(tokens, highlights) {
+        this.tokens = tokens;
+        this.highlights = highlights;
+    }
+    rangeOf(pcx) {
+        const stopToken = pcx.stop || pcx.start;
+        return {
+            start: {
+                line: pcx.start.line - 1,
+                character: pcx.start.charPositionInLine,
+            },
+            end: {
+                line: stopToken.line - 1,
+                character: stopToken.stopIndex -
+                    (stopToken.startIndex - stopToken.charPositionInLine) +
+                    1,
+            },
+        };
+    }
+    enterExprFunc(pcx) {
+        const id = pcx.id() || pcx.timeframe();
+        if (id) {
+            this.highlights.push({
+                range: this.rangeOf(id),
+                type: exports.HighlightType.Call.Function,
+            });
+        }
+    }
+}
+function walkForDocumentHighlights(tokens, parseTree) {
+    const finder = new DocumentHighlightWalker(tokens, []);
+    const listener = finder;
+    ParseTreeWalker_1.ParseTreeWalker.DEFAULT.walk(listener, parseTree);
+    return finder.highlights;
+}
+exports.walkForDocumentHighlights = walkForDocumentHighlights;
+function sortHighlights(highlights) {
+    return highlights.sort((a, b) => {
+        if (a.range.start.line < b.range.start.line) {
+            return -1;
+        }
+        else if (a.range.start.line > b.range.start.line) {
+            return 1;
+        }
+        else if (a.range.start.character < b.range.start.character) {
+            return -1;
+        }
+        else if (a.range.start.character > b.range.start.character) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    });
+}
+exports.sortHighlights = sortHighlights;
+//# sourceMappingURL=document-highlight-walker.js.map

package/dist/lang/parse-tree-walkers/document-symbol-walker.d.ts

@@ -0,0 +1,11 @@
+import { CommonTokenStream } from "antlr4ts";
+import { ParseTree } from "antlr4ts/tree";
+import { DocumentRange } from "../../model/malloy_types";
+import { MalloyTranslation } from "../parse-malloy";
+export interface DocumentSymbol {
+    range: DocumentRange;
+    type: string;
+    name: string;
+    children: DocumentSymbol[];
+}
+export declare function walkForDocumentSymbols(forParse: MalloyTranslation, tokens: CommonTokenStream, parseTree: ParseTree): DocumentSymbol[];

package/dist/lang/parse-tree-walkers/document-symbol-walker.js

@@ -0,0 +1,172 @@
+"use strict";
+/*
+ * Copyright 2021 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkForDocumentSymbols = void 0;
+const ParseTreeWalker_1 = require("antlr4ts/tree/ParseTreeWalker");
+class DocumentSymbolWalker {
+    constructor(translator, tokens, scopes, symbols) {
+        this.translator = translator;
+        this.tokens = tokens;
+        this.scopes = scopes;
+        this.symbols = symbols;
+    }
+    popScope() {
+        return this.scopes.pop();
+    }
+    peekScope() {
+        return this.scopes[this.scopes.length - 1];
+    }
+    enterTopLevelQueryDef(pcx) {
+        this.symbols.push({
+            range: this.translator.rangeFromContext(pcx),
+            name: pcx.queryName().text,
+            type: "query",
+            children: [],
+        });
+    }
+    enterTopLevelAnonQueryDef(pcx) {
+        this.symbols.push({
+            range: this.translator.rangeFromContext(pcx),
+            name: "unnamed_query",
+            type: "unnamed_query",
+            children: [],
+        });
+    }
+    enterExploreDefinition(pcx) {
+        this.scopes.push({
+            range: this.translator.rangeFromContext(pcx),
+            name: pcx.exploreNameDef().id().text,
+            type: "explore",
+            children: [],
+        });
+    }
+    exitExploreDefinition(_pcx) {
+        const scope = this.popScope();
+        if (scope) {
+            this.symbols.push(scope);
+        }
+    }
+    enterExploreQueryDef(pcx) {
+        const symbol = {
+            range: this.translator.rangeFromContext(pcx),
+            name: pcx.exploreQueryNameDef().id().text,
+            type: "query",
+            children: [],
+        };
+        const parent = this.peekScope();
+        if (parent) {
+            parent.children.push(symbol);
+        }
+        this.scopes.push(symbol);
+    }
+    exitExploreQueryDef(_pcx) {
+        this.popScope();
+    }
+    handleNestEntry(pcx) {
+        const symbol = {
+            range: this.translator.rangeFromContext(pcx),
+            name: pcx.queryName().id().text,
+            type: "query",
+            children: [],
+        };
+        const parent = this.peekScope();
+        if (parent) {
+            parent.children.push(symbol);
+        }
+        return symbol;
+    }
+    enterNestExisting(pcx) {
+        this.handleNestEntry(pcx);
+    }
+    enterNestDef(pcx) {
+        const symbol = this.handleNestEntry(pcx);
+        this.scopes.push(symbol);
+    }
+    exitNestDef(_pcx) {
+        this.popScope();
+    }
+    enterFieldDef(pcx) {
+        const symbol = {
+            range: this.translator.rangeFromContext(pcx),
+            name: pcx.fieldNameDef().id().text,
+            type: "field",
+            children: [],
+        };
+        const parent = this.peekScope();
+        if (parent) {
+            parent.children.push(symbol);
+        }
+    }
+    enterQueryFieldRef(pcx) {
+        const symbol = {
+            range: this.translator.rangeFromContext(pcx),
+            name: pcx.fieldPath().text,
+            type: "field",
+            children: [],
+        };
+        const parent = this.peekScope();
+        if (parent) {
+            parent.children.push(symbol);
+        }
+    }
+    enterExploreRenameDef(pcx) {
+        const symbol = {
+            range: this.translator.rangeFromContext(pcx),
+            name: pcx.fieldName()[0].text,
+            type: "field",
+            children: [],
+        };
+        const parent = this.peekScope();
+        if (parent) {
+            parent.children.push(symbol);
+        }
+    }
+    enterJoinWith(pcx) {
+        this.handleJoinDef(pcx);
+    }
+    enterJoinOn(pcx) {
+        this.handleJoinDef(pcx);
+    }
+    handleJoinDef(pcx) {
+        const symbol = {
+            range: this.translator.rangeFromContext(pcx),
+            name: pcx.joinNameDef().id().text,
+            type: "join",
+            children: [],
+        };
+        const parent = this.peekScope();
+        if (parent) {
+            parent.children.push(symbol);
+        }
+    }
+    enterSqlStatementDef(pcx) {
+        var _a;
+        const name = (_a = pcx.sqlCommandNameDef()) === null || _a === void 0 ? void 0 : _a.id().text;
+        const symbol = {
+            range: this.translator.rangeFromContext(pcx),
+            name: name || "unnamed_sql",
+            type: name === undefined ? "unnamed_sql" : "sql",
+            children: [],
+        };
+        this.symbols.push(symbol);
+    }
+}
+function walkForDocumentSymbols(forParse, tokens, parseTree) {
+    const finder = new DocumentSymbolWalker(forParse, tokens, [], []);
+    const listener = finder;
+    ParseTreeWalker_1.ParseTreeWalker.DEFAULT.walk(listener, parseTree);
+    return finder.symbols;
+}
+exports.walkForDocumentSymbols = walkForDocumentSymbols;
+//# sourceMappingURL=document-symbol-walker.js.map

package/dist/lang/parse-tree-walkers/explore-query-walker.d.ts

@@ -0,0 +1,34 @@
+import { CommonTokenStream } from "antlr4ts";
+import { ParseTree } from "antlr4ts/tree";
+import { MalloyListener } from "../lib/Malloy/MalloyListener";
+declare type SimpleRange = [number | undefined, number | undefined];
+export interface FilterRef {
+    text: string;
+    range: SimpleRange;
+}
+export interface FilterList {
+    range: SimpleRange;
+}
+export interface ExploreRef {
+    text: string;
+    range: SimpleRange;
+}
+export interface ExploreClauseRef {
+    exploreRef: ExploreRef;
+    filterRefs: FilterRef[];
+    filterLists: FilterList[];
+    range: SimpleRange;
+}
+export declare class ExploreQueryWalker implements MalloyListener {
+    tokens: CommonTokenStream;
+    exploreClauseRefs: ExploreClauseRef[];
+    currentExploreClauseRef: ExploreClauseRef | undefined;
+    constructor(tokens: CommonTokenStream);
+    exploreQueryAtOffset(offset: number): ExploreClauseRef | undefined;
+    filterAtOffset(offset: number): FilterRef | undefined;
+    hasFilterListAtOffset(offset: number): boolean;
+    inDocument: boolean;
+    enterMalloyDocument(): void;
+}
+export declare function exploreQueryWalkerBuilder(tokens: CommonTokenStream, parseTree: ParseTree): ExploreQueryWalker;
+export {};

package/dist/lang/parse-tree-walkers/explore-query-walker.js

@@ -0,0 +1,64 @@
+"use strict";
+/*
+ * Copyright 2021 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreQueryWalkerBuilder = exports.ExploreQueryWalker = void 0;
+const ParseTreeWalker_1 = require("antlr4ts/tree/ParseTreeWalker");
+class ExploreQueryWalker {
+    constructor(tokens) {
+        // just to make this compile, no need for this
+        this.inDocument = false;
+        this.exploreClauseRefs = [];
+        this.tokens = tokens;
+    }
+    exploreQueryAtOffset(offset) {
+        return this.exploreClauseRefs.find((ex) => {
+            if (ex.range[0] === undefined || ex.range[1] === undefined)
+                return false;
+            return ex.range[0] <= offset && ex.range[1] >= offset;
+        });
+    }
+    filterAtOffset(offset) {
+        const exploreRef = this.exploreQueryAtOffset(offset);
+        if (!exploreRef)
+            return;
+        return exploreRef.filterRefs.find((filterRef) => {
+            if (filterRef.range[0] === undefined || filterRef.range[1] === undefined)
+                return false;
+            return filterRef.range[0] <= offset && filterRef.range[1] >= offset;
+        });
+    }
+    hasFilterListAtOffset(offset) {
+        const exploreRef = this.exploreQueryAtOffset(offset);
+        if (!exploreRef)
+            return false;
+        return !!exploreRef.filterLists.find((filterList) => {
+            if (filterList.range[0] === undefined ||
+                filterList.range[1] === undefined)
+                return false;
+            return filterList.range[0] <= offset && filterList.range[1] >= offset;
+        });
+    }
+    enterMalloyDocument() {
+        this.inDocument = true;
+    }
+}
+exports.ExploreQueryWalker = ExploreQueryWalker;
+function exploreQueryWalkerBuilder(tokens, parseTree) {
+    const finder = new ExploreQueryWalker(tokens);
+    const listener = finder;
+    ParseTreeWalker_1.ParseTreeWalker.DEFAULT.walk(listener, parseTree);
+    return finder;
+}
+exports.exploreQueryWalkerBuilder = exploreQueryWalkerBuilder;
+//# sourceMappingURL=explore-query-walker.js.map

package/dist/lang/parse-tree-walkers/find-external-references.d.ts

@@ -0,0 +1,11 @@
+import { CommonTokenStream } from "antlr4ts";
+import type { ParseTree } from "antlr4ts/tree";
+import { DocumentRange } from "../../model/malloy_types";
+import { MalloyTranslation } from "../parse-malloy";
+declare type References = Record<string, DocumentRange>;
+interface FinderFound {
+    tables?: References;
+    urls?: References;
+}
+export declare function findReferences(trans: MalloyTranslation, tokens: CommonTokenStream, parseTree: ParseTree): FinderFound | null;
+export {};