@malloydata/malloy 0.0.240-dev250311202829 → 0.0.240-dev250311214430

package/dist/lang/parse-malloy.js

@@ -46,10 +46,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MalloyTranslator = exports.MalloyChildTranslator = exports.MalloyTranslation = void 0;
-const antlr4ts_1 = require("antlr4ts");
 const malloy_types_1 = require("../model/malloy_types");
-const MalloyLexer_1 = require("./lib/Malloy/MalloyLexer");
-const MalloyParser_1 = require("./lib/Malloy/MalloyParser");
 const ast = __importStar(require("./ast"));
 const malloy_to_ast_1 = require("./malloy-to-ast");
 const parse_log_1 = require("./parse-log");
@@ -65,20 +62,7 @@ const malloy_tag_1 = require("@malloydata/malloy-tag");
 const model_annotation_walker_1 = require("./parse-tree-walkers/model-annotation-walker");
 const find_table_path_walker_1 = require("./parse-tree-walkers/find-table-path-walker");
 const annotation_1 = require("../annotation");
-const malloy_error_strategy_1 = require("./syntax-errors/malloy-error-strategy");
-const malloy_parser_error_listener_1 = require("./syntax-errors/malloy-parser-error-listener");
-/**
- * This ignores a -> popMode when the mode stack is empty, which is a hack,
- * but it let's us parse }%
- */
-class HandlesOverpoppingLexer extends MalloyLexer_1.MalloyLexer {
-    popMode() {
-        if (this._modeStack.isEmpty) {
-            return this._mode;
-        }
-        return super.popMode();
-    }
-}
+const run_malloy_parser_1 = require("./run-malloy-parser");
 class ParseStep {
     step(that) {
         if (this.response) {
@@ -101,10 +85,10 @@ class ParseStep {
             return { urls: [that.sourceURL] };
         }
         const source = srcEnt.value === '' ? '\n' : srcEnt.value;
-        this.sourceInfo = this.getSourceInfo(source);
+        this.sourceInfo = (0, utils_1.getSourceInfo)(source);
         let parse;
         try {
-            parse = this.runParser(source, that);
+            parse = this.runParser(source, this.sourceInfo, that);
         }
         catch (parseException) {
             that.root.logError('parse-exception', { message: parseException.message });
@@ -121,65 +105,11 @@ class ParseStep {
         }
         return this.response;
     }
-    /**
-     * Split the source up into lines so we can correctly compute offset
-     * to the line/char positions favored by LSP and VSCode.
-     */
-    getSourceInfo(code) {
-        const eolRegex = /\r?\n/;
-        const info = {
-            at: [],
-            lines: [],
-            length: code.length,
-        };
-        let src = code;
-        let lineStart = 0;
-        while (src !== '') {
-            const eol = src.match(eolRegex);
-            if (eol && eol.index !== undefined) {
-                // line text DOES NOT include the EOL
-                info.lines.push(src.slice(0, eol.index));
-                const lineLength = eol.index + eol[0].length;
-                info.at.push({
-                    begin: lineStart,
-                    end: lineStart + lineLength,
-                });
-                lineStart += lineLength;
-                src = src.slice(lineLength);
-            }
-            else {
-                // last line, does not have a line end
-                info.lines.push(src);
-                info.at.push({ begin: lineStart, end: lineStart + src.length });
-                break;
-            }
-        }
-        return info;
-    }
-    runParser(source, that) {
-        const inputStream = antlr4ts_1.CharStreams.fromString(source);
-        const lexer = new HandlesOverpoppingLexer(inputStream);
-        const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
-        const malloyParser = new MalloyParser_1.MalloyParser(tokenStream);
-        malloyParser.removeErrorListeners();
-        malloyParser.addErrorListener(new malloy_parser_error_listener_1.MalloyParserErrorListener(that, that.root.logger));
-        malloyParser.errorHandler = new malloy_error_strategy_1.MalloyErrorStrategy();
-        // Admitted code smell here, testing likes to parse from an arbitrary
-        // node and this is the simplest way to allow that.
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const parseFunc = malloyParser[that.grammarRule];
-        if (!parseFunc) {
-            throw new Error(`No such parse rule as ${that.grammarRule}`);
-        }
+    runParser(source, sourceInfo, that) {
+        const parse = (0, run_malloy_parser_1.runMalloyParser)(source, that.sourceURL, sourceInfo, that.root.logger, that.grammarRule);
         return {
-            root: parseFunc.call(malloyParser),
-            tokenStream: tokenStream,
-            sourceStream: inputStream,
-            sourceURL: that.sourceURL,
+            ...parse,
             importBaseURL: that.importBaseURL || that.sourceURL,
-            rangeFromContext: cx => that.rangeFromContext(cx),
-            // TODO some way to not forget to update this
-            malloyVersion: '4.0.0',
         };
     }
 }
@@ -786,42 +716,7 @@ class MalloyTranslation {
         };
     }
     rangeFromContext(pcx) {
-        return this.rangeFromTokens(pcx.start, pcx.stop || pcx.start);
-    }
-    rangeFromTokens(startToken, stopToken) {
-        const start = {
-            line: startToken.line - 1,
-            character: startToken.charPositionInLine,
-        };
-        if (this.parseStep.sourceInfo && stopToken.stopIndex !== -1) {
-            // Find the line which contains the stopIndex
-            const lastLine = this.parseStep.sourceInfo.lines.length - 1;
-            for (let lineNo = startToken.line - 1; lineNo <= lastLine; lineNo++) {
-                const at = this.parseStep.sourceInfo.at[lineNo];
-                if (stopToken.stopIndex >= at.begin && stopToken.stopIndex < at.end) {
-                    return {
-                        start,
-                        end: {
-                            line: lineNo,
-                            character: stopToken.stopIndex - at.begin + 1,
-                        },
-                    };
-                }
-            }
-            // Should be impossible to get here, but if we do ... return the last
-            // character of the last line of the file
-            return {
-                start,
-                end: {
-                    line: lastLine,
-                    character: this.parseStep.sourceInfo.lines[lastLine].length,
-                },
-            };
-        }
-        return { start, end: start };
-    }
-    rangeFromToken(token) {
-        return this.rangeFromTokens(token, token);
+        return (0, utils_1.rangeFromContext)(this.parseStep.sourceInfo, pcx);
     }
     firstReferenceToDialect(dialect) {
         if (this.dialectAlreadyChecked[dialect]) {

package/dist/lang/parse-tree-walkers/model-annotation-walker.js

@@ -34,7 +34,7 @@ class ModelAnnotationWalker {
     getLocation(cx) {
         return {
             url: this.parseInfo.sourceURL,
-            range: this.parseInfo.rangeFromContext(cx),
+            range: this.translator.rangeFromContext(cx),
         };
     }
     enterDocAnnotations(pcx) {

package/dist/lang/run-malloy-parser.d.ts

@@ -0,0 +1,3 @@
+import { MessageLogger } from './parse-log';
+import { ParseInfo, SourceInfo } from './utils';
+export declare function runMalloyParser(code: string, sourceURL: string, sourceInfo: SourceInfo, logger: MessageLogger, grammarRule?: string): ParseInfo;

package/dist/lang/run-malloy-parser.js

@@ -0,0 +1,53 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMalloyParser = void 0;
+const antlr4ts_1 = require("antlr4ts");
+const MalloyLexer_1 = require("./lib/Malloy/MalloyLexer");
+const MalloyParser_1 = require("./lib/Malloy/MalloyParser");
+const malloy_error_strategy_1 = require("./syntax-errors/malloy-error-strategy");
+const malloy_parser_error_listener_1 = require("./syntax-errors/malloy-parser-error-listener");
+/**
+ * This ignores a -> popMode when the mode stack is empty, which is a hack,
+ * but it let's us parse }%
+ */
+class HandlesOverpoppingLexer extends MalloyLexer_1.MalloyLexer {
+    popMode() {
+        if (this._modeStack.isEmpty) {
+            return this._mode;
+        }
+        return super.popMode();
+    }
+}
+function runMalloyParser(code, sourceURL, sourceInfo, logger, grammarRule = 'malloyDocument') {
+    const inputStream = antlr4ts_1.CharStreams.fromString(code);
+    const lexer = new HandlesOverpoppingLexer(inputStream);
+    const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
+    const malloyParser = new MalloyParser_1.MalloyParser(tokenStream);
+    malloyParser.removeErrorListeners();
+    malloyParser.addErrorListener(new malloy_parser_error_listener_1.MalloyParserErrorListener(logger, sourceURL, sourceInfo));
+    malloyParser.errorHandler = new malloy_error_strategy_1.MalloyErrorStrategy();
+    // Admitted code smell here, testing likes to parse from an arbitrary
+    // node and this is the simplest way to allow that.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const parseFunc = malloyParser[grammarRule];
+    if (!parseFunc) {
+        throw new Error(`No such parse rule as ${grammarRule}`);
+    }
+    return {
+        root: parseFunc.call(malloyParser),
+        tokenStream: tokenStream,
+        sourceStream: inputStream,
+        sourceInfo,
+        sourceURL,
+        // TODO some way to not forget to update this
+        malloyVersion: '4.0.0',
+    };
+}
+exports.runMalloyParser = runMalloyParser;
+//# sourceMappingURL=run-malloy-parser.js.map

package/dist/lang/syntax-errors/malloy-parser-error-listener.d.ts

@@ -1,12 +1,13 @@
 import { ANTLRErrorListener, Token } from 'antlr4ts';
 import { ErrorCase } from './custom-error-messages';
 import { MessageLogger, MessageCode, MessageParameterType, LogMessageOptions } from '../parse-log';
-import { MalloyTranslation } from '../parse-malloy';
+import { SourceInfo } from '../utils';
 export declare const malloyCustomErrorCases: ErrorCase[];
 export declare class MalloyParserErrorListener implements ANTLRErrorListener<Token> {
-    readonly translator: MalloyTranslation;
     readonly messages: MessageLogger;
-    constructor(translator: MalloyTranslation, messages: MessageLogger);
+    readonly sourceURL: string;
+    readonly sourceInfo: SourceInfo;
+    constructor(messages: MessageLogger, sourceURL: string, sourceInfo: SourceInfo);
     logError<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: Omit<LogMessageOptions, 'severity'>): T;
     syntaxError(recognizer: unknown, offendingSymbol: Token | undefined, line: number, charPositionInLine: number, message: string, _e: unknown): void;
 }

package/dist/lang/syntax-errors/malloy-parser-error-listener.js

@@ -10,6 +10,7 @@ exports.MalloyParserErrorListener = exports.malloyCustomErrorCases = void 0;
 const MalloyParser_1 = require("../lib/Malloy/MalloyParser");
 const custom_error_messages_1 = require("./custom-error-messages");
 const parse_log_1 = require("../parse-log");
+const utils_1 = require("../utils");
 // A set of custom error messages and their triggering cases,
 // used for syntax error message re-writing when ANTLR would
 // otherwise print a standard (and not very useful) error message.
@@ -141,9 +142,12 @@ exports.malloyCustomErrorCases = [
     },
 ];
 class MalloyParserErrorListener {
-    constructor(translator, messages) {
-        this.translator = translator;
+    constructor(
+    // readonly translator: MalloyTranslation,
+    messages, sourceURL, sourceInfo) {
         this.messages = messages;
+        this.sourceURL = sourceURL;
+        this.sourceInfo = sourceInfo;
     }
     logError(code, parameters, options) {
         this.messages.log((0, parse_log_1.makeLogMessage)(code, parameters, { severity: 'error', ...options }));
@@ -152,14 +156,14 @@ class MalloyParserErrorListener {
     syntaxError(recognizer, offendingSymbol, line, charPositionInLine, message, _e) {
         const errAt = { line: line - 1, character: charPositionInLine };
         const range = offendingSymbol
-            ? this.translator.rangeFromToken(offendingSymbol)
+            ? (0, utils_1.rangeFromToken)(this.sourceInfo, offendingSymbol)
             : { start: errAt, end: errAt };
         const overrideMessage = (0, custom_error_messages_1.checkCustomErrorMessage)(recognizer, offendingSymbol, exports.malloyCustomErrorCases);
         if (overrideMessage) {
             message = overrideMessage;
         }
         this.logError('syntax-error', { message }, {
-            at: { url: this.translator.sourceURL, range },
+            at: { url: this.sourceURL, range },
         });
     }
 }

package/dist/lang/utils.d.ts

@@ -1,3 +1,29 @@
-import { DocumentLocation, DocumentPosition } from '../model/malloy_types';
+import { CodePointCharStream, CommonTokenStream, ParserRuleContext, Token } from 'antlr4ts';
+import { DocumentLocation, DocumentPosition, DocumentRange } from '../model/malloy_types';
+import { ParseTree } from 'antlr4ts/tree';
 export declare function locationContainsPosition(location: DocumentLocation, position: DocumentPosition): boolean;
 export declare function isNotUndefined<T>(value: T | undefined): value is T;
+export interface SourceInfo {
+    lines: string[];
+    at: {
+        begin: number;
+        end: number;
+    }[];
+    length: number;
+}
+export declare function rangeFromTokens(sourceInfo: SourceInfo | undefined, startToken: Token, stopToken: Token): DocumentRange;
+export declare function rangeFromToken(sourceInfo: SourceInfo | undefined, token: Token): DocumentRange;
+export declare function rangeFromContext(sourceInfo: SourceInfo | undefined, pcx: ParserRuleContext): DocumentRange;
+/**
+ * Split the source up into lines so we can correctly compute offset
+ * to the line/char positions favored by LSP and VSCode.
+ */
+export declare function getSourceInfo(code: string): SourceInfo;
+export interface ParseInfo {
+    root: ParseTree;
+    tokenStream: CommonTokenStream;
+    sourceStream: CodePointCharStream;
+    sourceURL: string;
+    malloyVersion: string;
+    sourceInfo: SourceInfo;
+}

package/dist/lang/utils.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNotUndefined = exports.locationContainsPosition = void 0;
+exports.getSourceInfo = exports.rangeFromContext = exports.rangeFromToken = exports.rangeFromTokens = exports.isNotUndefined = exports.locationContainsPosition = void 0;
 function locationContainsPosition(location, position) {
     return (location.range.start.line <= position.line &&
         location.range.end.line >= position.line &&
@@ -36,4 +36,81 @@ function isNotUndefined(value) {
     return value !== undefined;
 }
 exports.isNotUndefined = isNotUndefined;
+function rangeFromTokens(sourceInfo, startToken, stopToken) {
+    const start = {
+        line: startToken.line - 1,
+        character: startToken.charPositionInLine,
+    };
+    if (sourceInfo && stopToken.stopIndex !== -1) {
+        // Find the line which contains the stopIndex
+        const lastLine = sourceInfo.lines.length - 1;
+        for (let lineNo = startToken.line - 1; lineNo <= lastLine; lineNo++) {
+            const at = sourceInfo.at[lineNo];
+            if (stopToken.stopIndex >= at.begin && stopToken.stopIndex < at.end) {
+                return {
+                    start,
+                    end: {
+                        line: lineNo,
+                        character: stopToken.stopIndex - at.begin + 1,
+                    },
+                };
+            }
+        }
+        // Should be impossible to get here, but if we do ... return the last
+        // character of the last line of the file
+        return {
+            start,
+            end: {
+                line: lastLine,
+                character: sourceInfo.lines[lastLine].length,
+            },
+        };
+    }
+    return { start, end: start };
+}
+exports.rangeFromTokens = rangeFromTokens;
+function rangeFromToken(sourceInfo, token) {
+    return rangeFromTokens(sourceInfo, token, token);
+}
+exports.rangeFromToken = rangeFromToken;
+function rangeFromContext(sourceInfo, pcx) {
+    return rangeFromTokens(sourceInfo, pcx.start, pcx.stop || pcx.start);
+}
+exports.rangeFromContext = rangeFromContext;
+/**
+ * Split the source up into lines so we can correctly compute offset
+ * to the line/char positions favored by LSP and VSCode.
+ */
+function getSourceInfo(code) {
+    const eolRegex = /\r?\n/;
+    const info = {
+        at: [],
+        lines: [],
+        length: code.length,
+    };
+    let src = code;
+    let lineStart = 0;
+    while (src !== '') {
+        const eol = src.match(eolRegex);
+        if (eol && eol.index !== undefined) {
+            // line text DOES NOT include the EOL
+            info.lines.push(src.slice(0, eol.index));
+            const lineLength = eol.index + eol[0].length;
+            info.at.push({
+                begin: lineStart,
+                end: lineStart + lineLength,
+            });
+            lineStart += lineLength;
+            src = src.slice(lineLength);
+        }
+        else {
+            // last line, does not have a line end
+            info.lines.push(src);
+            info.at.push({ begin: lineStart, end: lineStart + src.length });
+            break;
+        }
+    }
+    return info;
+}
+exports.getSourceInfo = getSourceInfo;
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.240-dev250311202829",
+  "version": "0.0.240-dev250311214430",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -41,8 +41,8 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-interfaces": "^0.0.240-dev250311202829",
-    "@malloydata/malloy-tag": "^0.0.240-dev250311202829",
+    "@malloydata/malloy-interfaces": "^0.0.240-dev250311214430",
+    "@malloydata/malloy-tag": "^0.0.240-dev250311214430",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jest-diff": "^29.6.2",

package/dist/api/asynchronous.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/api/asynchronous.spec.js

@@ -1,240 +0,0 @@
-"use strict";
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const asynchronous_1 = require("./asynchronous");
-describe('api', () => {
-    describe('compile model', () => {
-        test('compile model with table dependency', async () => {
-            const connection = {
-                dialectName: 'duckdb',
-                fetchSchemaForTable: async (_name) => {
-                    return {
-                        fields: [
-                            {
-                                kind: 'dimension',
-                                name: 'carrier',
-                                type: { kind: 'string_type' },
-                            },
-                        ],
-                    };
-                },
-                fetchSchemaForSQLQuery: async (_sql) => {
-                    throw new Error('not implemented');
-                },
-            };
-            const urls = {
-                readURL: async (_url) => {
-                    return "source: flights is connection.table('flights')";
-                },
-            };
-            const connections = {
-                lookupConnection: async (_name) => {
-                    return connection;
-                },
-            };
-            const fetchers = {
-                urls,
-                connections,
-            };
-            const result = await (0, asynchronous_1.compileModel)({
-                model_url: 'file://test.malloy',
-            }, fetchers);
-            const expected = {
-                model: {
-                    entries: [
-                        {
-                            kind: 'source',
-                            name: 'flights',
-                            schema: {
-                                fields: [
-                                    {
-                                        kind: 'dimension',
-                                        name: 'carrier',
-                                        type: { kind: 'string_type' },
-                                    },
-                                ],
-                            },
-                        },
-                    ],
-                    anonymous_queries: [],
-                },
-            };
-            expect(result).toMatchObject(expected);
-        });
-    });
-    describe('compile query', () => {
-        test('compile query with table dependency', async () => {
-            const connection = {
-                dialectName: 'duckdb',
-                fetchSchemaForTable: async (_name) => {
-                    return {
-                        fields: [
-                            {
-                                kind: 'dimension',
-                                name: 'carrier',
-                                type: { kind: 'string_type' },
-                            },
-                        ],
-                    };
-                },
-                fetchSchemaForSQLQuery: async (_sql) => {
-                    throw new Error('not implemented');
-                },
-            };
-            const urls = {
-                readURL: async (_url) => {
-                    return "source: flights is connection.table('flights')";
-                },
-            };
-            const connections = {
-                lookupConnection: async (_name) => {
-                    return connection;
-                },
-            };
-            const fetchers = {
-                urls,
-                connections,
-            };
-            const result = await (0, asynchronous_1.compileQuery)({
-                model_url: 'file://test.malloy',
-                query: {
-                    definition: {
-                        kind: 'arrow',
-                        source_reference: { name: 'flights' },
-                        view: {
-                            kind: 'segment',
-                            operations: [
-                                {
-                                    kind: 'group_by',
-                                    field: {
-                                        expression: { kind: 'field_reference', name: 'carrier' },
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-            }, fetchers);
-            const expected = {
-                result: {
-                    connection_name: 'connection',
-                    sql: `SELECT \n\
-   base."carrier" as "carrier"
-FROM flights as base
-GROUP BY 1
-ORDER BY 1 asc NULLS LAST
-`,
-                    schema: {
-                        fields: [
-                            {
-                                kind: 'dimension',
-                                name: 'carrier',
-                                type: { kind: 'string_type' },
-                            },
-                        ],
-                    },
-                },
-            };
-            expect(result).toMatchObject(expected);
-        });
-    });
-    describe('run query', () => {
-        test('run query with table dependency', async () => {
-            const data = {
-                kind: 'array_cell',
-                array_value: [
-                    {
-                        kind: 'record_cell',
-                        record_value: [{ kind: 'string_cell', string_value: 'WN' }],
-                    },
-                    {
-                        kind: 'record_cell',
-                        record_value: [{ kind: 'string_cell', string_value: 'AA' }],
-                    },
-                ],
-            };
-            const connection = {
-                dialectName: 'duckdb',
-                fetchSchemaForTable: async (_name) => {
-                    return {
-                        fields: [
-                            {
-                                kind: 'dimension',
-                                name: 'carrier',
-                                type: { kind: 'string_type' },
-                            },
-                        ],
-                    };
-                },
-                fetchSchemaForSQLQuery: async (_sql) => {
-                    throw new Error('not implemented');
-                },
-                runSQL: async (_sql) => {
-                    return data;
-                },
-            };
-            const urls = {
-                readURL: async (_url) => {
-                    return "source: flights is connection.table('flights')";
-                },
-            };
-            const connections = {
-                lookupConnection: async (_name) => {
-                    return connection;
-                },
-            };
-            const fetchers = {
-                urls,
-                connections,
-            };
-            const result = await (0, asynchronous_1.runQuery)({
-                model_url: 'file://test.malloy',
-                query: {
-                    definition: {
-                        kind: 'arrow',
-                        source_reference: { name: 'flights' },
-                        view: {
-                            kind: 'segment',
-                            operations: [
-                                {
-                                    kind: 'group_by',
-                                    field: {
-                                        expression: { kind: 'field_reference', name: 'carrier' },
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-            }, fetchers);
-            const expected = {
-                result: {
-                    connection_name: 'connection',
-                    sql: `SELECT \n\
-   base."carrier" as "carrier"
-FROM flights as base
-GROUP BY 1
-ORDER BY 1 asc NULLS LAST
-`,
-                    schema: {
-                        fields: [
-                            {
-                                kind: 'dimension',
-                                name: 'carrier',
-                                type: { kind: 'string_type' },
-                            },
-                        ],
-                    },
-                    data,
-                },
-            };
-            expect(result).toMatchObject(expected);
-        });
-    });
-});
-//# sourceMappingURL=asynchronous.spec.js.map

package/dist/api/sessioned.spec.d.ts

@@ -1 +0,0 @@
-export {};