@lenne.tech/cli 1.48.0 → 1.49.0

package/build/lib/spinner-lifetime.js

@@ -0,0 +1,245 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSpinnerLeaks = findSpinnerLeaks;
+/**
+ * Finds progress spinners that can be left running.
+ *
+ * gluegun's `spin(text)` is `require('ora')(text).start()`. ora 4.0.2 with the
+ * default `discardStdin: true` does three things on start that only a stop undoes:
+ * it puts the terminal into raw mode (remembering the value it found), it calls
+ * `stdin.resume()` and adds a `data` listener, and it starts a `setInterval` for
+ * the animation.
+ *
+ * A spinner that is never stopped therefore does not merely look untidy — the
+ * interval and the resumed stdin keep the Node event loop alive, so the process
+ * never exits, and the terminal stays in raw mode. That combination is how
+ * `lt fullstack init` could reach the end of its work and simply not return, with
+ * a spinner still turning. `failRun` deliberately sets `process.exitCode` instead
+ * of calling `process.exit()` (so a failure message is never truncated), which
+ * means "the event loop drains" is a precondition the CLI relies on.
+ *
+ * ## What "stopped" means here
+ *
+ * This is a dominance approximation, not a full control-flow analysis, and it is
+ * deliberately conservative in the direction that avoids false alarms — a guard
+ * that flags correct code gets switched off. A statement list definitely stops a
+ * spinner when it contains a direct stop call, or an `if` whose BOTH branches
+ * stop, or a `try` whose body and `catch` both stop (or whose `finally` stops).
+ * Anything else does not count.
+ *
+ * Two questions are asked per spinner:
+ *
+ * 1. Can the end of its enclosing block be reached without a stop? That is the
+ *    silent case — the command falls off the end, exit code 0, spinner running.
+ * 2. Is there a `return` after it that no stop dominates? That is the early-exit
+ *    case — an error path that prints and leaves.
+ *
+ * Returns inside a nested function are ignored: they leave the callback, not the
+ * command.
+ */
+const ts = __importStar(require("typescript"));
+/** Methods that stop an ora spinner. `stopAndPersist` is what `succeed`/`fail`/… call. */
+const STOP_METHODS = new Set(['fail', 'info', 'stop', 'stopAndPersist', 'succeed', 'warn']);
+/**
+ * Every spinner in `source` that can outlive the code path that started it.
+ *
+ * @param source The file's text.
+ * @param fileName Only used to pick the parser dialect.
+ */
+function findSpinnerLeaks(source, fileName = 'file.ts') {
+    const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true);
+    const leaks = [];
+    const lineOf = (node) => sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+    for (const declaration of spinnerDeclarations(sourceFile)) {
+        const name = declaration.name.getText(sourceFile);
+        const block = enclosingBlock(declaration);
+        if (!block) {
+            continue;
+        }
+        const returns = returnsAfter(block, declaration);
+        // `return spinner;` hands ownership to the caller, which is then responsible
+        // for stopping it — a factory like `logger.ts#spin` is not a leak. One such
+        // return exempts the whole declaration, because the spinner's lifetime is no
+        // longer decided in this function.
+        if (returns.some((statement) => handsOverOwnership(statement, name))) {
+            continue;
+        }
+        const after = statementsAfter(block, declaration);
+        if (!after.some((statement) => definitelyStops(statement, name, sourceFile))) {
+            leaks.push({
+                line: lineOf(declaration),
+                reason: after.length === 0 ? 'never-stopped' : 'falls-through',
+                spinner: name,
+            });
+        }
+        for (const returnStatement of returns) {
+            if (!dominatedByStop(returnStatement, block, declaration, name, sourceFile)) {
+                leaks.push({ line: lineOf(returnStatement), reason: 'return-without-stop', spinner: name });
+            }
+        }
+    }
+    return leaks.sort((a, b) => a.line - b.line);
+}
+/**
+ * True when executing `statement` always stops `name`.
+ *
+ * Only the shapes the CLI actually uses are recognised. Everything unrecognised
+ * answers false, so an unusual construct produces a finding to look at rather
+ * than a silent pass.
+ */
+function definitelyStops(statement, name, sourceFile) {
+    if (ts.isExpressionStatement(statement)) {
+        return isStopCall(statement.expression, name, sourceFile);
+    }
+    if (ts.isBlock(statement)) {
+        return statement.statements.some((child) => definitelyStops(child, name, sourceFile));
+    }
+    if (ts.isIfStatement(statement)) {
+        // Only an if/else that stops on BOTH sides stops unconditionally.
+        return (!!statement.elseStatement &&
+            definitelyStops(statement.thenStatement, name, sourceFile) &&
+            definitelyStops(statement.elseStatement, name, sourceFile));
+    }
+    if (ts.isTryStatement(statement)) {
+        if (statement.finallyBlock && definitelyStops(statement.finallyBlock, name, sourceFile)) {
+            return true;
+        }
+        return (definitelyStops(statement.tryBlock, name, sourceFile) &&
+            !!statement.catchClause &&
+            definitelyStops(statement.catchClause.block, name, sourceFile));
+    }
+    return false;
+}
+/**
+ * True when some stop of `name` is guaranteed to run before `returnStatement`.
+ *
+ * Walks out from the return towards `block`, and at each level checks the
+ * statements that precede the one we came from — a stop in any of them dominates.
+ */
+function dominatedByStop(returnStatement, block, declaration, name, sourceFile) {
+    let child = returnStatement;
+    let parent = returnStatement.parent;
+    while (parent) {
+        if (ts.isBlock(parent) || ts.isSourceFile(parent)) {
+            for (const statement of parent.statements) {
+                if (statement === child || statement.getStart(sourceFile) >= child.getStart(sourceFile)) {
+                    break;
+                }
+                if (statement.getStart(sourceFile) > declaration.getStart(sourceFile) &&
+                    definitelyStops(statement, name, sourceFile)) {
+                    return true;
+                }
+            }
+        }
+        if (parent === block) {
+            return false;
+        }
+        child = parent;
+        parent = parent.parent;
+    }
+    return false;
+}
+/** The nearest enclosing block of a declaration — the scope its spinner must not outlive. */
+function enclosingBlock(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isBlock(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+/** True for `return spinner;` — the caller becomes responsible for stopping it. */
+function handsOverOwnership(statement, name) {
+    return !!statement.expression && ts.isIdentifier(statement.expression) && statement.expression.text === name;
+}
+/** True for `x.succeed(…)` / `x.fail(…)` / … on the spinner called `name`. */
+function isStopCall(expression, name, sourceFile) {
+    if (!ts.isCallExpression(expression) || !ts.isPropertyAccessExpression(expression.expression)) {
+        return false;
+    }
+    const access = expression.expression;
+    return access.expression.getText(sourceFile) === name && STOP_METHODS.has(access.name.text);
+}
+/** Every `return` after `declaration` inside `block`, skipping nested functions. */
+function returnsAfter(block, declaration) {
+    const found = [];
+    const start = declaration.getStart();
+    const visit = (node) => {
+        if (ts.isFunctionLike(node)) {
+            return; // A return there leaves the callback, not the command.
+        }
+        if (ts.isReturnStatement(node) && node.getStart() > start) {
+            found.push(node);
+        }
+        ts.forEachChild(node, visit);
+    };
+    for (const statement of block.statements) {
+        if (statement.getStart() > start) {
+            visit(statement);
+        }
+    }
+    return found;
+}
+/** `const x = spin(…)` declarations, including `toolbox.print.spin(…)`. */
+function spinnerDeclarations(sourceFile) {
+    const found = [];
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.initializer &&
+            ts.isCallExpression(node.initializer)) {
+            const callee = node.initializer.expression;
+            const name = ts.isPropertyAccessExpression(callee)
+                ? callee.name.text
+                : ts.isIdentifier(callee)
+                    ? callee.text
+                    : '';
+            if (name === 'spin') {
+                found.push(node);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return found;
+}
+/** The statements of `block` that follow `declaration`. */
+function statementsAfter(block, declaration) {
+    const start = declaration.getStart();
+    return block.statements.filter((statement) => statement.getStart() > start);
+}

package/build/templates/check/check.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// @lt-check-wrapper 3.13.0
+// @lt-check-wrapper 3.13.1
 /**
  * Quiet, report-driven wrapper around the project `check` pipeline.
  *
@@ -33,7 +33,7 @@
  * scripts/check-wrapper-version.test.mjs fails when it drifts from
  * package.json. In a generated project it keeps the release it came from.
  */
-import { execSync, spawn } from 'node:child_process';
+import { execFileSync, execSync, spawn } from 'node:child_process';
 import { readFileSync, realpathSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -84,6 +84,12 @@ function fmtDuration(ms) {
 // binds only to the first simple command, so a step written with `;` or a
 // leading `cd` would be reported as pinned and run unpinned. Both carry the
 // same value, so they cannot disagree.
+//
+// On Windows only the second level exists: cmd.exe has no `VAR=value cmd`
+// syntax and would run the assignment as a command, so `pinCheckBuildDir`
+// writes no prefix there and `stepEnv` carries the pin alone. That is why
+// `stepEnv` keys on the command rather than on the presence of a prefix —
+// scripts/check-windows.test.mjs holds the two together.
 const CHECK_BUILD_DIR = '.nuxt-check';
 
 // Deliberately narrow: a blanket prefix would override the dirs the package.json
@@ -123,8 +129,15 @@ export const PM_INVOCATION = new RegExp(`${PM_INSTALL.source}|${PM_AUDIT.source}
  * existing-pin test is NOT anchored to the start of the string, because the
  * shape the nuxt starter actually ships is `cross-env NUXT_BUILD_DIR=… pnpm …`,
  * which a `^` anchor does not see.
+ *
+ * On Windows there is no prefix at all: `VAR=value cmd` is POSIX shell syntax,
+ * and cmd.exe reads the assignment as the command name ('NUXT_BUILD_DIR' is not
+ * recognized as an internal or external command). `stepEnv` below hands the
+ * same value to the child as a real environment variable, which is what every
+ * step relies on there.
  */
-export function pinCheckBuildDir(cmd) {
+export function pinCheckBuildDir(cmd, platform = process.platform) {
+  if (platform === 'win32') return cmd;
   if (!PM_INVOCATION.test(cmd) || /(^|\s)NUXT_BUILD_DIR=/.test(cmd)) return cmd;
   return `NUXT_BUILD_DIR=${CHECK_BUILD_DIR} ${cmd}`;
 }
@@ -132,13 +145,22 @@ export function pinCheckBuildDir(cmd) {
 /**
  * The environment a step needs beyond the inherited one.
  *
- * Mirrors the textual pin so a shell construct the prefix cannot reach (a `;`
- * separator, a leading `cd`) still gets the isolated build dir. Only for
- * commands the pin applies to — a step that pins itself keeps its own value,
- * because the prefix check already declined to touch it.
+ * Keyed on the COMMAND, not on the textual pin. Two reasons, and the second is
+ * why reading the text was not enough:
+ *
+ *  - a shell construct the prefix cannot reach (a `;` separator, a leading
+ *    `cd`) would be reported as pinned and run unpinned;
+ *  - on Windows `pinCheckBuildDir` writes no prefix, so a predicate that looks
+ *    for one would find nothing and hand the step NO build dir — the pin would
+ *    silently disappear on exactly the platform that cannot use the prefix.
+ *
+ * A step that pins itself keeps its own value: the textual prefix wins over the
+ * inherited environment, and `cross-env` sets the variable itself.
  */
-function stepEnv(step) {
-  return /(^|\s)NUXT_BUILD_DIR=/.test(step.cmd) ? { NUXT_BUILD_DIR: CHECK_BUILD_DIR } : null;
+export function stepEnv(step) {
+  return PM_INVOCATION.test(step.cmd) || /(^|\s)NUXT_BUILD_DIR=/.test(step.cmd)
+    ? { NUXT_BUILD_DIR: CHECK_BUILD_DIR }
+    : null;
 }
 
 // ── step classification ────────────────────────────────────────────────────
@@ -407,11 +429,39 @@ const IDLE_TIMEOUT_MS = (() => {
 // ── command runner ─────────────────────────────────────────────────────────
 const RUNNING = new Set();
 
+/**
+ * How to kill a process tree on this platform.
+ *
+ * Windows has neither `pgrep` nor signals: `process.kill(pid, 'SIGTERM')` there ends the one
+ * process and orphans its children, and `taskkill /T` alone was measured to leave the tree
+ * running ("Die Beendigung dieses Prozesses muss erzwungen werden") with the port still held.
+ * `/F` is what actually frees it, so the whole tree is force-killed in one call.
+ *
+ * The consequence is worth stating, because it is a behaviour difference and not an
+ * implementation detail: on Windows there is no graceful stage. The SIGTERM call already
+ * terminates, so a child's graceful-shutdown hook does not run — a server gets no chance to
+ * close connections or flush. The SIGKILL escalation five seconds later then finds nothing.
+ *
+ * Split out as a pure function so both branches can be tested from either platform.
+ */
+export function killTreePlan(pid, signal, platform = process.platform) {
+  return platform === 'win32' ? { args: ['/PID', String(pid), '/T', '/F'], command: 'taskkill' } : { signal };
+}
+
 // Best-effort kill of a child's whole process tree (sh → pnpm → vitest →
 // fork workers). Killing only the direct child orphans the tree — exactly the
 // zombie workers a deadlock leaves behind. Children are collected via pgrep
 // and killed leaves-first.
 function killTree(child, signal = 'SIGTERM') {
+  const plan = killTreePlan(child.pid, signal);
+  if (plan.command) {
+    try {
+      execFileSync(plan.command, plan.args, { stdio: 'ignore' });
+    } catch {
+      /* already gone, or taskkill refused — nothing further to try */
+    }
+    return;
+  }
   const pids = [];
   const collect = (pid) => {
     pids.push(pid);

package/build/templates/check/lt-monorepo-pin.json

@@ -1,13 +1,13 @@
 {
-  "commit": "61f8c9f9b3292cca71d9bfdfbf18e11d47a9a4a8",
+  "commit": "fcf7c83cffa37b09db88481833e7ccc0dd2fbe0f",
   "files": {
     "build-test-gate.mjs": "865bf1b9dd28151f53b9f2dfe4c3c46d29b9303fb1c2f497ce0e3136bcd37d71",
-    "check.mjs": "783dce99aad1d2faf3d880184e43422c6b8433afcfa50c1f652b2d8ef6b2a1db",
+    "check.mjs": "fed669a625b56d907ab2e3693c2e5797a877c460588bd79f89249d88c568c178",
     "lib/ansi.mjs": "f997ee6e9bf1c7ee54ab612d4040fcc778064ec160eae19bf5c3960a75a6e2ff",
     "lib/audit-report.mjs": "503825c3342dec1ee5d8d70e5af21b73e798faee320426b2492190cde0801df2",
     "lib/workspace-packages.mjs": "ccdd133622a88186c924bc8271d35cf1f8357dc26d4a607998ca5e91fce5bf88"
   },
-  "ref": "v3.13.0",
+  "ref": "v3.13.1",
   "repository": "lenneTech/lt-monorepo",
-  "version": "3.13.0"
+  "version": "3.13.1"
 }

package/docs/commands.md

@@ -663,29 +663,33 @@ Run `--explain` to see three commonly recommended keys the profile deliberately
 
 ### `lt dev test`
 
-One-shot E2E wrapper: ensure `up`, wait for the App URL, run `pnpm run test:e2e` with the `.lt-dev/.env` bridge loaded. Optional teardown after.
+One-shot E2E wrapper: brings up an isolated test stack next to the `lt dev up` session (own URLs `<slug>-test.localhost` / `api.<slug>-test.localhost`, own ports, own Caddy block, own database `<…>-test`), runs `test:e2e` against it, and tears the stack down afterwards. The dev session is never touched.
 
 **Usage:**
 ```bash
-lt dev test                      # App E2E (projects/app)
-lt dev test --api                # API E2E (projects/api) — no Caddy required
-lt dev test --teardown           # plus `lt dev down` after
+lt dev test                      # App E2E against the isolated stack, auto teardown
+lt dev test --keep               # leave the test stack up afterwards
+lt dev test down                 # tear a leftover test stack down
+lt dev test --api                # API E2E (projects/api) — no stack, no Caddy
 lt dev test --debug              # PWDEBUG=1 + HEADED=1
+lt dev test --shard [N|auto]     # split across N isolated stacks (bare --shard = 2)
 lt dev test -- --ui spec.ts      # everything after `--` is forwarded to playwright
 ```
 
 **Alias:** `lt d t`
 
-**Behaviour:**
-1. Pre-flight: Caddy installed + daemon running (App mode only).
-2. If no `lt dev up` session is alive: invokes `lt dev up` first.
-3. Waits up to 30 s for the App URL to respond.
-4. Reads `<root>/.lt-dev/.env` and merges into the spawn env (existing process.env wins for keys it defines).
-5. Spawns `pnpm run test:e2e [forwarded args]` in `projects/api` (with `--api`) or `projects/app` (default).
-6. With `--teardown`, runs `lt dev down` after.
+**Behaviour (App mode):**
+1. Pre-flight: Caddy installed + daemon running, and `playwright.config.ts` env-aware (otherwise abort; `--force` overrides).
+2. Builds the API and applies pending migrations to the test DB (`migrate:up`, with the API's own env, so it hits the same DB). A failed migration aborts the run; a project without a `migrate:up` script starts unmigrated. Then starts the compiled API. Without a build output it falls back to the project's `start` script, which migrates by itself.
+3. Builds the App (`nuxt build`) and serves the Nitro output.
+4. Waits for both to answer and aborts if either never does, so the suite never runs against a dead stack.
+5. Runs `test:e2e [forwarded args]` in the App with the `.lt-dev/.env.test` bridge loaded.
+6. Tears the stack down (processes, Caddy block, env bridge, session file) unless `--keep` is set.
+
+The test DB outlives the run: the CLI never drops it. That is why step 2 migrates it: without the migration the DB drifts behind every environment that does migrate. A project whose Playwright global-setup resets the DB gets it passed as `MONGO_URI`.
 
 **When to use this vs. `pnpm run test:e2e` directly:**
-- Use **`lt dev test`** for TDD loops, ad-hoc reproduction, or when you want a single-command "ensure-up + run + teardown" flow.
+- Use **`lt dev test`** for TDD loops, ad-hoc reproduction, or when you want a single-command "isolated stack + run + teardown" flow.
 - Use **direct `pnpm run test:e2e`** (or VS Code Playwright Extension, IDE test runners) for everyday work — the auto-injected `playwright.config.ts` bridge loads the `.lt-dev/.env` automatically, so the env is correct without the wrapper.
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/cli",
-  "version": "1.48.0",
+  "version": "1.49.0",
   "description": "lenne.Tech CLI: lt",
   "keywords": [
     "lenne.Tech",

package/build/lib/strip-comments.js

@@ -1,78 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stripComments = stripComments;
-const ts = __importStar(require("typescript"));
-/**
- * Removes comments from TypeScript/JavaScript source, preserving everything else verbatim.
- *
- * Exists because detectors that search source for import specifiers must not read comments as
- * code. A keyword-anchored regex is not sufficient on its own: a docblock that DOCUMENTS an import
- * rewrite legitimately quotes the exact syntax the detector looks for. nest-server-starter's
- * `tests/unit/bootstrap-diagnostics.spec.ts` contains
- *
- *   * CLI's vendor conversion rewrites `from '@lenne.tech/nest-server'` to a relative `./core` path
- *
- * which matched `/(?:from|import|…)\s*['"]@lenne\.tech\/nest-server['"]/` and made
- * `lt fullstack init --framework-mode vendor` warn about imports that file does not have.
- *
- * Uses the TypeScript scanner rather than a regex, so string literals, template literals and
- * regex literals containing `//` or `/*` are handled correctly by construction — a hand-rolled
- * stripper trips over `'https://…'` and over `/* ` inside a string.
- *
- * Comment characters are replaced with spaces instead of being deleted, so byte offsets and line
- * numbers of the surrounding code stay unchanged — a caller can still report a meaningful
- * position from a match.
- *
- * @param source - TypeScript or JavaScript source text
- * @returns The source with every comment blanked out
- *
- * @example
- * stripComments("// from 'pkg'\nimport x from 'pkg';")
- * // => "             \nimport x from 'pkg';"
- */
-function stripComments(source) {
-    const scanner = ts.createScanner(ts.ScriptTarget.Latest, /* skipTrivia */ false, ts.LanguageVariant.Standard, source);
-    let result = '';
-    let token = scanner.scan();
-    while (token !== ts.SyntaxKind.EndOfFileToken) {
-        const text = scanner.getTokenText();
-        const isComment = token === ts.SyntaxKind.SingleLineCommentTrivia || token === ts.SyntaxKind.MultiLineCommentTrivia;
-        // Keep newlines so line numbers survive; blank everything else in the comment.
-        result += isComment ? text.replace(/[^\n]/g, ' ') : text;
-        token = scanner.scan();
-    }
-    return result;
-}