@documentdb-js/shell-runtime 0.8.0

package/dist/DocumentDBShellRuntime.d.ts

@@ -0,0 +1,144 @@
+import { type MongoClient } from 'mongodb';
+import { type ShellEvalOptions, type ShellEvaluationResult, type ShellRuntimeCallbacks, type ShellRuntimeOptions } from './types';
+/**
+ * Shell runtime abstraction for DocumentDB.
+ *
+ * Wraps the @mongosh evaluation pipeline behind a clean API that both the
+ * query playground (scratchpad) and future interactive shell (Step 9) consume.
+ *
+ * The runtime:
+ * - Intercepts known commands (help) before they reach @mongosh
+ * - Creates a fresh @mongosh evaluation context per `evaluate()` call
+ * - Transforms raw @mongosh ShellResult into a protocol-agnostic result type
+ * - Delegates to `DocumentDBServiceProvider` for database operations
+ *
+ * The caller owns the `MongoClient` lifecycle — the runtime only uses it.
+ *
+ * @example
+ * ```typescript
+ * const runtime = new DocumentDBShellRuntime(mongoClient, {
+ *     onConsoleOutput: (output) => console.log(output),
+ *     onLog: (level, msg) => logger[level](msg),
+ * });
+ *
+ * const result = await runtime.evaluate('db.users.find({})', 'myDatabase');
+ * console.log(result.type, result.printable);
+ *
+ * runtime.dispose();
+ * ```
+ */
+export declare class DocumentDBShellRuntime {
+    private readonly _mongoClient;
+    private readonly _callbacks;
+    private readonly _options;
+    private readonly _commandInterceptor;
+    private readonly _resultTransformer;
+    private _disposed;
+    private _persistent;
+    constructor(mongoClient: MongoClient, callbacks?: ShellRuntimeCallbacks, options?: ShellRuntimeOptions);
+    /**
+     * Evaluate shell code against the specified database.
+     *
+     * Creates a fresh @mongosh context per call — no variable leakage between
+     * evaluations. The target database is pre-selected via `use()` before
+     * executing user code.
+     *
+     * @param code - JavaScript/shell code string to evaluate
+     * @param databaseName - Target database name for execution
+     * @param evalOptions - Per-eval overrides (e.g. displayBatchSize from user settings)
+     * @returns Evaluation result with type, printable value, and timing
+     * @throws Error if the runtime has been disposed
+     * @throws Error if @mongosh evaluation fails (syntax error, runtime error, etc.)
+     */
+    evaluate(code: string, databaseName: string, evalOptions?: ShellEvalOptions): Promise<ShellEvaluationResult>;
+    /**
+     * Fresh-context evaluation (playground mode).
+     * Creates a new @mongosh context per call — no variable leakage between evaluations.
+     */
+    private evaluateFresh;
+    /**
+     * Persistent-context evaluation (interactive shell mode).
+     * Reuses the same @mongosh context across calls — variables, cursor state,
+     * and the `db` reference persist between evaluations.
+     */
+    private evaluatePersistent;
+    /**
+     * Dispose the runtime. After disposal, `evaluate()` calls will throw.
+     * Does NOT close the MongoClient — the caller owns its lifecycle.
+     */
+    dispose(): void;
+    /**
+     * Apply the display batch size to the instance state.
+     * Uses @mongosh's displayBatchSizeFromDBQuery property which takes
+     * precedence over config.get('displayBatchSize') in cursor iteration.
+     */
+    private applyBatchSize;
+    /**
+     * Register the console output listener on the @mongosh instance state.
+     * Routes `print()`, `printjson()`, and `console.log()` output to the
+     * caller-provided callback.
+     */
+    private registerConsoleOutputListener;
+    private log;
+}
+/**
+ * Rewrites bare `use <name>` / `show <name>` direct shell commands into
+ * function-call form (`use("<name>");` / `show("<name>");`).
+ *
+ * ## Why this is needed
+ *
+ * Direct shell commands like `use mydb` are detected by the evaluation
+ * pipeline as special tokens. When they appear as the first line of a
+ * multi-line code block, the pipeline processes only the direct command
+ * and silently discards all subsequent statements. Converting them to
+ * function-call form bypasses that short-circuit so the entire block is
+ * evaluated normally.
+ *
+ * ## How it works
+ *
+ * A single linear scan of the input tracks whether each character sits in
+ * plain code, a `//` line comment, a `/* ... *\/` block comment, a `'...'`
+ * or `"..."` string literal, a `` `...` `` template literal (including
+ * `${...}` expression nesting), or a `/.../` regex literal. Only line
+ * starts that fall in the plain-code state are considered candidates for
+ * rewriting. The per-line regex extracts the argument once the context
+ * check has passed.
+ *
+ * This avoids the collateral rewrites a naive regex would produce in:
+ *
+ * - single- and double-quoted string literals
+ * - template literals (`` `use mydb` `` as string content)
+ * - line and block comments
+ * - regular-expression literals (`/use mydb/`)
+ *
+ * ### Scope note — why a scanner, not a parser
+ *
+ * This is a lexical scanner, not a syntactic parser. It recognizes the
+ * literal forms listed above, which covers every collateral-rewrite
+ * failure mode reported so far. It intentionally does **not** understand
+ * JavaScript statement structure, so a handful of exotic cases are not
+ * distinguished:
+ *
+ * - `use` / `show` as a declared identifier rather than a statement
+ *   starter (e.g. `const use = mydb; use` — runtime-invalid anyway).
+ * - `use mydb` nested inside a block such as `if (x) { use mydb }`
+ *   (the bare form was never valid inside a block either; rewriting it
+ *   to `use("mydb");` is still a legal expression statement).
+ * - Contextual keywords used where a regex is legal but the scanner
+ *   guessed division, or vice-versa.
+ *
+ * Getting 100% of these right would require a real JS parser (e.g.
+ * `acorn` / `acorn-loose`) or the TypeScript compiler. We deliberately
+ * avoid adding that dependency: `@documentdb-js/shell-runtime`
+ * is intended to also ship as a lightweight standalone runtime for CLI
+ * tooling, and pulling in a full JS parser would dominate its footprint
+ * for an edge case that is not observed in real user input.
+ *
+ * ## ASI safety
+ *
+ * The emitted replacement always ends with `;` so a following line that
+ * begins with `[`, `(`, `+`, `-`, or `/` starts a fresh statement instead
+ * of binding to the call expression.
+ */
+export declare function normalizeDirectCommands(code: string): string;
+//# sourceMappingURL=DocumentDBShellRuntime.d.ts.map

package/dist/DocumentDBShellRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocumentDBShellRuntime.d.ts","sourceRoot":"","sources":["../src/DocumentDBShellRuntime.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAM3C,OAAO,EACH,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EAC3B,MAAM,SAAS,CAAC;AAgBjB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,sBAAsB;IAC/B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAC3C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAwB;IACnD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsB;IAC/C,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IACzD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoB;IACvD,OAAO,CAAC,SAAS,CAAS;IAG1B,OAAO,CAAC,WAAW,CAOH;gBAEJ,WAAW,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE,qBAAqB,EAAE,OAAO,CAAC,EAAE,mBAAmB;IAStG;;;;;;;;;;;;;OAaG;IACG,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAgClH;;;OAGG;YACW,aAAa;IAoD3B;;;;OAIG;YACW,kBAAkB;IAiEhC;;;OAGG;IACH,OAAO,IAAI,IAAI;IAKf;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAMtB;;;;OAIG;IACH,OAAO,CAAC,6BAA6B;IAyBrC,OAAO,CAAC,GAAG;CAGd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA6C5D"}

package/dist/DocumentDBShellRuntime.js

@@ -0,0 +1,521 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentDBShellRuntime = void 0;
+exports.normalizeDirectCommands = normalizeDirectCommands;
+const shell_api_1 = require("@mongosh/shell-api");
+const shell_evaluator_1 = require("@mongosh/shell-evaluator");
+const vm_1 = __importDefault(require("vm"));
+const CommandInterceptor_1 = require("./CommandInterceptor");
+const DocumentDBServiceProvider_1 = require("./DocumentDBServiceProvider");
+const HelpProvider_1 = require("./HelpProvider");
+const ResultTransformer_1 = require("./ResultTransformer");
+/**
+ * Matches `<cmd> <arg>` on a single line. Used to extract the argument text
+ * after the scanner has already confirmed that `<cmd>` starts a real top-level
+ * `use`/`show` statement (not inside a string, comment, or regex literal).
+ */
+const DIRECT_COMMAND_LINE_RE = /^(\s*)(use|show)\s+([^(\s][^;]*?)\s*;?\s*$/;
+const DEFAULT_OPTIONS = {
+    productName: 'DocumentDB for VS Code',
+    productDocsLink: 'https://github.com/microsoft/vscode-documentdb',
+    displayBatchSize: 50,
+    persistent: false,
+};
+/**
+ * Shell runtime abstraction for DocumentDB.
+ *
+ * Wraps the @mongosh evaluation pipeline behind a clean API that both the
+ * query playground (scratchpad) and future interactive shell (Step 9) consume.
+ *
+ * The runtime:
+ * - Intercepts known commands (help) before they reach @mongosh
+ * - Creates a fresh @mongosh evaluation context per `evaluate()` call
+ * - Transforms raw @mongosh ShellResult into a protocol-agnostic result type
+ * - Delegates to `DocumentDBServiceProvider` for database operations
+ *
+ * The caller owns the `MongoClient` lifecycle — the runtime only uses it.
+ *
+ * @example
+ * ```typescript
+ * const runtime = new DocumentDBShellRuntime(mongoClient, {
+ *     onConsoleOutput: (output) => console.log(output),
+ *     onLog: (level, msg) => logger[level](msg),
+ * });
+ *
+ * const result = await runtime.evaluate('db.users.find({})', 'myDatabase');
+ * console.log(result.type, result.printable);
+ *
+ * runtime.dispose();
+ * ```
+ */
+class DocumentDBShellRuntime {
+    _mongoClient;
+    _callbacks;
+    _options;
+    _commandInterceptor;
+    _resultTransformer;
+    _disposed = false;
+    // Persistent mode state — reused across evaluate() calls when options.persistent is true
+    _persistent;
+    constructor(mongoClient, callbacks, options) {
+        this._mongoClient = mongoClient;
+        this._callbacks = callbacks ?? {};
+        this._options = { ...DEFAULT_OPTIONS, ...options };
+        const helpSurface = this._options.persistent ? 'shell' : 'playground';
+        this._commandInterceptor = new CommandInterceptor_1.CommandInterceptor(new HelpProvider_1.HelpProvider(helpSurface));
+        this._resultTransformer = new ResultTransformer_1.ResultTransformer();
+    }
+    /**
+     * Evaluate shell code against the specified database.
+     *
+     * Creates a fresh @mongosh context per call — no variable leakage between
+     * evaluations. The target database is pre-selected via `use()` before
+     * executing user code.
+     *
+     * @param code - JavaScript/shell code string to evaluate
+     * @param databaseName - Target database name for execution
+     * @param evalOptions - Per-eval overrides (e.g. displayBatchSize from user settings)
+     * @returns Evaluation result with type, printable value, and timing
+     * @throws Error if the runtime has been disposed
+     * @throws Error if @mongosh evaluation fails (syntax error, runtime error, etc.)
+     */
+    async evaluate(code, databaseName, evalOptions) {
+        if (this._disposed) {
+            throw new Error('Shell runtime has been disposed');
+        }
+        // Check for intercepted commands (help, etc.)
+        const intercepted = this._commandInterceptor.tryIntercept(code);
+        if (intercepted) {
+            return intercepted;
+        }
+        // Normalize bare direct commands (`use dbName`, `show dbs`) into function-call
+        // form (`use("dbName")`, `show("dbs")`) so they go through the async rewriter
+        // instead of short-circuiting. Without this, a bare `use` as the first token
+        // of a multi-line block consumes the entire input and silently drops subsequent
+        // statements.
+        code = normalizeDirectCommands(code);
+        this.log('trace', `Evaluating code (${code.split('\n').length} lines, ${code.length} chars, db: ${databaseName})`);
+        const startTime = Date.now();
+        if (this._options.persistent) {
+            return this.evaluatePersistent(code, databaseName, evalOptions, startTime);
+        }
+        else {
+            return this.evaluateFresh(code, databaseName, evalOptions, startTime);
+        }
+    }
+    /**
+     * Fresh-context evaluation (playground mode).
+     * Creates a new @mongosh context per call — no variable leakage between evaluations.
+     */
+    async evaluateFresh(code, databaseName, evalOptions, startTime) {
+        // Create fresh shell context per execution
+        const { serviceProvider, bus } = DocumentDBServiceProvider_1.DocumentDBServiceProvider.createForDocumentDB(this._mongoClient, this._options.productName, this._options.productDocsLink);
+        const instanceState = new shell_api_1.ShellInstanceState(serviceProvider, bus);
+        try {
+            const evaluator = new shell_evaluator_1.ShellEvaluator(instanceState);
+            this.applyBatchSize(instanceState, evalOptions);
+            this.registerConsoleOutputListener(instanceState);
+            // Set up eval context with shell globals (db, ObjectId, ISODate, etc.)
+            const context = {};
+            instanceState.setCtx(context);
+            // Custom eval function using vm.runInContext for sandboxed execution
+            // eslint-disable-next-line @typescript-eslint/require-await
+            const customEvalFn = async (evalCode, ctx) => {
+                const vmContext = vm_1.default.isContext(ctx) ? ctx : vm_1.default.createContext(ctx);
+                return vm_1.default.runInContext(evalCode, vmContext);
+            };
+            // Pre-select the target database (fresh context each time)
+            await evaluator.customEval(customEvalFn, `use(${JSON.stringify(databaseName)})`, context, 'playground');
+            // Evaluate user code
+            const result = await evaluator.customEval(customEvalFn, code, context, 'playground');
+            const durationMs = Date.now() - startTime;
+            this.log('trace', `Evaluation complete (${durationMs}ms)`);
+            return this._resultTransformer.transform(result, durationMs);
+        }
+        finally {
+            await instanceState.close();
+        }
+    }
+    /**
+     * Persistent-context evaluation (interactive shell mode).
+     * Reuses the same @mongosh context across calls — variables, cursor state,
+     * and the `db` reference persist between evaluations.
+     */
+    async evaluatePersistent(code, databaseName, evalOptions, startTime) {
+        // Initialize persistent state on first call
+        if (!this._persistent) {
+            const { serviceProvider, bus } = DocumentDBServiceProvider_1.DocumentDBServiceProvider.createForDocumentDB(this._mongoClient, this._options.productName, this._options.productDocsLink);
+            const instanceState = new shell_api_1.ShellInstanceState(serviceProvider, bus);
+            const evaluator = new shell_evaluator_1.ShellEvaluator(instanceState);
+            const context = {};
+            instanceState.setCtx(context);
+            const vmContext = vm_1.default.createContext(context);
+            this.registerConsoleOutputListener(instanceState);
+            // Pre-select the initial database
+            await evaluator.customEval(
+            // eslint-disable-next-line @typescript-eslint/require-await
+            async (evalCode, _ctx) => {
+                return vm_1.default.runInContext(evalCode, vmContext);
+            }, `use(${JSON.stringify(databaseName)})`, context, 'shell');
+            this._persistent = { instanceState, evaluator, context, vmContext };
+        }
+        const { instanceState, evaluator, context, vmContext } = this._persistent;
+        // Apply batch size per-eval (may change between evaluations via settings)
+        this.applyBatchSize(instanceState, evalOptions);
+        // Evaluate user code using the persistent context
+        const result = await evaluator.customEval(
+        // eslint-disable-next-line @typescript-eslint/require-await
+        async (evalCode, _ctx) => {
+            return vm_1.default.runInContext(evalCode, vmContext);
+        }, code, context, 'shell');
+        const durationMs = Date.now() - startTime;
+        this.log('trace', `Evaluation complete (${durationMs}ms)`);
+        return this._resultTransformer.transform(result, durationMs);
+    }
+    /**
+     * Dispose the runtime. After disposal, `evaluate()` calls will throw.
+     * Does NOT close the MongoClient — the caller owns its lifecycle.
+     */
+    dispose() {
+        this._disposed = true;
+        this._persistent = undefined;
+    }
+    /**
+     * Apply the display batch size to the instance state.
+     * Uses @mongosh's displayBatchSizeFromDBQuery property which takes
+     * precedence over config.get('displayBatchSize') in cursor iteration.
+     */
+    applyBatchSize(instanceState, evalOptions) {
+        const batchSize = evalOptions?.displayBatchSize ?? this._options.displayBatchSize ?? DEFAULT_OPTIONS.displayBatchSize;
+        instanceState.displayBatchSizeFromDBQuery = batchSize;
+    }
+    /**
+     * Register the console output listener on the @mongosh instance state.
+     * Routes `print()`, `printjson()`, and `console.log()` output to the
+     * caller-provided callback.
+     */
+    registerConsoleOutputListener(instanceState) {
+        const onConsoleOutput = this._callbacks.onConsoleOutput;
+        if (!onConsoleOutput) {
+            return;
+        }
+        instanceState.setEvaluationListener({
+            onPrint(values, _type) {
+                const output = values
+                    .map((v) => {
+                    if (typeof v.printable === 'string') {
+                        return v.printable;
+                    }
+                    try {
+                        return JSON.stringify(v.printable, null, 2);
+                    }
+                    catch {
+                        return String(v.printable);
+                    }
+                })
+                    .join(' ');
+                onConsoleOutput(output + '\n');
+            },
+        });
+    }
+    log(level, message) {
+        this._callbacks.onLog?.(level, message);
+    }
+}
+exports.DocumentDBShellRuntime = DocumentDBShellRuntime;
+/**
+ * Rewrites bare `use <name>` / `show <name>` direct shell commands into
+ * function-call form (`use("<name>");` / `show("<name>");`).
+ *
+ * ## Why this is needed
+ *
+ * Direct shell commands like `use mydb` are detected by the evaluation
+ * pipeline as special tokens. When they appear as the first line of a
+ * multi-line code block, the pipeline processes only the direct command
+ * and silently discards all subsequent statements. Converting them to
+ * function-call form bypasses that short-circuit so the entire block is
+ * evaluated normally.
+ *
+ * ## How it works
+ *
+ * A single linear scan of the input tracks whether each character sits in
+ * plain code, a `//` line comment, a `/* ... *\/` block comment, a `'...'`
+ * or `"..."` string literal, a `` `...` `` template literal (including
+ * `${...}` expression nesting), or a `/.../` regex literal. Only line
+ * starts that fall in the plain-code state are considered candidates for
+ * rewriting. The per-line regex extracts the argument once the context
+ * check has passed.
+ *
+ * This avoids the collateral rewrites a naive regex would produce in:
+ *
+ * - single- and double-quoted string literals
+ * - template literals (`` `use mydb` `` as string content)
+ * - line and block comments
+ * - regular-expression literals (`/use mydb/`)
+ *
+ * ### Scope note — why a scanner, not a parser
+ *
+ * This is a lexical scanner, not a syntactic parser. It recognizes the
+ * literal forms listed above, which covers every collateral-rewrite
+ * failure mode reported so far. It intentionally does **not** understand
+ * JavaScript statement structure, so a handful of exotic cases are not
+ * distinguished:
+ *
+ * - `use` / `show` as a declared identifier rather than a statement
+ *   starter (e.g. `const use = mydb; use` — runtime-invalid anyway).
+ * - `use mydb` nested inside a block such as `if (x) { use mydb }`
+ *   (the bare form was never valid inside a block either; rewriting it
+ *   to `use("mydb");` is still a legal expression statement).
+ * - Contextual keywords used where a regex is legal but the scanner
+ *   guessed division, or vice-versa.
+ *
+ * Getting 100% of these right would require a real JS parser (e.g.
+ * `acorn` / `acorn-loose`) or the TypeScript compiler. We deliberately
+ * avoid adding that dependency: `@documentdb-js/shell-runtime`
+ * is intended to also ship as a lightweight standalone runtime for CLI
+ * tooling, and pulling in a full JS parser would dominate its footprint
+ * for an edge case that is not observed in real user input.
+ *
+ * ## ASI safety
+ *
+ * The emitted replacement always ends with `;` so a following line that
+ * begins with `[`, `(`, `+`, `-`, or `/` starts a fresh statement instead
+ * of binding to the call expression.
+ */
+function normalizeDirectCommands(code) {
+    if (!code.includes('\n')) {
+        return code;
+    }
+    // Cheap early exit: if neither token appears anywhere, skip scanning.
+    if (!/\b(use|show)\b/.test(code)) {
+        return code;
+    }
+    const candidateLineStarts = findCodeLineStarts(code);
+    if (candidateLineStarts.length === 0) {
+        return code;
+    }
+    const edits = [];
+    for (const lineStart of candidateLineStarts) {
+        const nextNewline = code.indexOf('\n', lineStart);
+        const lineEnd = nextNewline === -1 ? code.length : nextNewline;
+        const line = code.slice(lineStart, lineEnd);
+        const match = DIRECT_COMMAND_LINE_RE.exec(line);
+        if (!match)
+            continue;
+        const [, indent, cmd, arg] = match;
+        edits.push({
+            lineStart,
+            lineEnd,
+            replacement: `${indent}${cmd}(${JSON.stringify(arg)});`,
+        });
+    }
+    if (edits.length === 0) {
+        return code;
+    }
+    // Apply right-to-left so earlier offsets stay valid.
+    edits.sort((a, b) => b.lineStart - a.lineStart);
+    let result = code;
+    for (const edit of edits) {
+        result = result.slice(0, edit.lineStart) + edit.replacement + result.slice(edit.lineEnd);
+    }
+    return result;
+}
+/**
+ * Scan `code` once and return the offsets of every line start that falls in
+ * plain-code state (i.e., outside any string, template, comment, or regex
+ * literal). The returned offsets are candidates for direct-command rewriting.
+ *
+ * The scanner covers exactly what we need to avoid false rewrites:
+ *
+ * - `//` line comments and `/* *\/` block comments
+ * - single- and double-quoted strings with `\` escapes
+ * - template literals, including nested `${ ... }` expressions (which are
+ *   themselves code and can contain further strings/templates)
+ * - regex literals, disambiguated from division by tracking whether a `/`
+ *   can begin an expression at its position
+ *
+ * It is **lexical** only; it does not build an AST or understand statement
+ * structure. A full parser (e.g. `acorn` / `acorn-loose`) would be needed
+ * for 100% syntactic accuracy — see the note on `normalizeDirectCommands`
+ * for why that trade-off is intentional here.
+ */
+function findCodeLineStarts(code) {
+    const starts = [];
+    // `${...}` nesting inside template literals: each element counts the
+    // currently-open `{` inside that expression so we know when to pop back
+    // into template-literal state.
+    const templateStack = [];
+    let inLineComment = false;
+    let inBlockComment = false;
+    let stringQuote = null;
+    let inTemplate = false;
+    let inRegex = false;
+    let regexCharClass = false;
+    // Whether a `/` at the current cursor may start a regex literal.
+    let canRegex = true;
+    // True only at the FIRST offset of a line (offset 0, or the position
+    // right after a newline). Cleared as soon as we consume that offset,
+    // so we never record the same line twice.
+    let atLineStart = true;
+    const len = code.length;
+    for (let i = 0; i < len; i++) {
+        const ch = code[i];
+        const next = i + 1 < len ? code[i + 1] : '';
+        // Record plain-code line starts (at most once per line).
+        if (atLineStart &&
+            !inLineComment &&
+            !inBlockComment &&
+            stringQuote === null &&
+            !inTemplate &&
+            !inRegex &&
+            templateStack.length === 0) {
+            starts.push(i);
+        }
+        atLineStart = false;
+        if (inLineComment) {
+            if (ch === '\n') {
+                inLineComment = false;
+                atLineStart = true;
+                canRegex = true;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (ch === '*' && next === '/') {
+                inBlockComment = false;
+                i++;
+                canRegex = true;
+            }
+            else if (ch === '\n') {
+                atLineStart = true;
+            }
+            continue;
+        }
+        if (stringQuote !== null) {
+            if (ch === '\\' && next !== '') {
+                i++;
+                continue;
+            }
+            if (ch === stringQuote) {
+                stringQuote = null;
+                canRegex = false;
+            }
+            else if (ch === '\n') {
+                // Unterminated string at newline: recover by exiting string
+                // state so we don't swallow the rest of the input.
+                stringQuote = null;
+                atLineStart = true;
+                canRegex = true;
+            }
+            continue;
+        }
+        if (inTemplate) {
+            if (ch === '\\' && next !== '') {
+                i++;
+                continue;
+            }
+            if (ch === '`') {
+                inTemplate = false;
+                canRegex = false;
+            }
+            else if (ch === '$' && next === '{') {
+                templateStack.push(1);
+                inTemplate = false;
+                i++;
+                canRegex = true;
+            }
+            else if (ch === '\n') {
+                atLineStart = true;
+            }
+            continue;
+        }
+        if (inRegex) {
+            if (ch === '\\' && next !== '') {
+                i++;
+                continue;
+            }
+            if (ch === '[') {
+                regexCharClass = true;
+            }
+            else if (ch === ']') {
+                regexCharClass = false;
+            }
+            else if (ch === '/' && !regexCharClass) {
+                inRegex = false;
+                // Consume optional flags.
+                while (i + 1 < len && /[a-z]/i.test(code[i + 1]))
+                    i++;
+                canRegex = false;
+            }
+            else if (ch === '\n') {
+                // Unterminated regex: recover.
+                inRegex = false;
+                regexCharClass = false;
+                atLineStart = true;
+                canRegex = true;
+            }
+            continue;
+        }
+        // Plain-code state (outer) or template-expression state (inner).
+        if (ch === '/' && next === '/') {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            stringQuote = ch;
+            canRegex = false;
+            continue;
+        }
+        if (ch === '`') {
+            inTemplate = true;
+            canRegex = false;
+            continue;
+        }
+        if (ch === '/' && canRegex) {
+            inRegex = true;
+            regexCharClass = false;
+            continue;
+        }
+        if (ch === '{' && templateStack.length > 0) {
+            templateStack[templateStack.length - 1]++;
+        }
+        if (ch === '}' && templateStack.length > 0) {
+            templateStack[templateStack.length - 1]--;
+            if (templateStack[templateStack.length - 1] === 0) {
+                templateStack.pop();
+                inTemplate = true;
+                canRegex = false;
+                continue;
+            }
+        }
+        if (ch === '\n') {
+            atLineStart = true;
+            canRegex = true;
+            continue;
+        }
+        // Heuristic for the regex/division ambiguity: letters/digits/closers
+        // disallow a regex at the next `/`; other punctuation allows one.
+        // Adequate for line-start candidates, which is all we care about.
+        if (/[A-Za-z0-9_$)\]]/.test(ch)) {
+            canRegex = false;
+        }
+        else if (!/\s/.test(ch)) {
+            canRegex = true;
+        }
+    }
+    return starts;
+}
+//# sourceMappingURL=DocumentDBShellRuntime.js.map