@aroman22/codegraph-vba-darwin-arm64 1.5.2 → 1.6.1

package/lib/dist/extraction/vba/sql-wrapper.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanSqlInLine = scanSqlInLine;
+exports.trackSqlVariableAssignment = trackSqlVariableAssignment;
+/**
+ * SQL-in-strings sweep (REQ-CODE-8). Scans SQL wrapper calls
+ * (`DoCmd.RunSQL "…"`, `*db.OpenRecordset "…"`, `getdb().Execute "…"`) and
+ * variable-form executions, tracks `sql = sql & "…"` accumulation, and emits
+ * `references` edges (via `ctx.emitReference`) to the table names found in the
+ * FROM/JOIN/INTO/UPDATE clauses.
+ */
+const vba_preprocess_1 = require("../vba-preprocess");
+const text_utils_1 = require("./text-utils");
+/** SQL wrapper helpers — order matters because `db.Execute` is a suffix of others. */
+const SQL_WRAPPERS = [
+    { name: 'DoCmd.RunSQL', re: /\bDoCmd\.RunSQL\s+"((?:[^"]|"")*)"/g },
+    { name: '*db.OpenRecordset', re: /\b(?:\p{L}[\p{L}\p{N}_]*)?db\b(?:\(\))?\.OpenRecordset\s+"((?:[^"]|"")*)"/giu },
+    { name: '*db.Execute', re: /\b(?:\p{L}[\p{L}\p{N}_]*)?db\b(?:\(\))?\.Execute\s+"((?:[^"]|"")*)"/giu },
+    // Fix 4 (Issue #4): inline-literal forms `getdb().Execute "..."` and
+    // `getdb().OpenRecordset "..."` — the variable form is covered by
+    // SQL_VAR_EXEC_RE but the direct-literal form was missing.
+    { name: 'getdb().Execute', re: /\bgetdb\(\)\.Execute\s+"((?:[^"]|"")*)"/g },
+    { name: 'getdb().OpenRecordset', re: /\bgetdb\(\)\.OpenRecordset\s+"((?:[^"]|"")*)"/g },
+];
+/** SQL assigned to a local variable, e.g. `m_SQL = "SELECT ..." & ...`. */
+const SQL_VAR_ASSIGN_RE = /^\s*(\p{L}[\p{L}\p{N}_]*)\s*=\s*(.*)$/iu;
+/** SQL wrapper called with a variable, e.g. `getdb().Execute m_SQL`. */
+const SQL_VAR_EXEC_RE = /\b(?:\p{L}[\p{L}\p{N}_]*)?db\b(?:\(\))?\.(?:OpenRecordset|Execute)\s*\(?\s*(\p{L}[\p{L}\p{N}_]*)\s*\)?/giu;
+/**
+ * Issue #42: `DoCmd.RunSQL <identifier>` (variable form) — the dominant
+ * Access idiom for executing a dynamically-built SQL string. Today only
+ * the literal form `DoCmd.RunSQL "DELETE FROM X"` is tracked via the
+ * `SQL_WRAPPERS` regex; the variable form silently dropped table impact for
+ * every procedure that builds SQL in a string and runs it through
+ * `DoCmd.RunSQL`.
+ *
+ * This regex is the DoCmd.RunSQL analogue of `SQL_VAR_EXEC_RE` above and
+ * is iterated by `scanSqlInLine`. When a match is found, the captured
+ * identifier is resolved against `sqlVariables` (populated by
+ * `trackSqlVariableAssignment` with `&`-accumulate semantics — Issue #13)
+ * and the resulting SQL string drives `emitSqlTableReferences`.
+ *
+ * The optional `(?:\(\))?` + `\s*\(?` shape lets the regex match both
+ * the parenthesised form `DoCmd.RunSQL(strSQL)` and the no-paren form
+ * `DoCmd.RunSQL strSQL` that the existing SQL_WRAPPERS literal regex
+ * does not cover. The captured identifier is the only thing we need —
+ * we DO NOT try to parse what the variable points at; that's the
+ * existing `sqlVariables` map's job.
+ */
+const SQL_VAR_DOCMD_RUNSQL_RE = /\bDoCmd\.RunSQL\s*\(?\s*(\p{L}[\p{L}\p{N}_]*)\s*\)?/giu;
+/**
+ * SQL table-name regex scoped to the clauses that introduce a table
+ * reference: `FROM <t>`, `JOIN <t>`, `INTO <t>`, `UPDATE <t>`. Adding
+ * `JOIN` lets the scanner pick up tables from joined fragments that
+ * arrive via `&`-concatenated wrapper literals (e.g.
+ * `db.Execute "FROM A" & " JOIN B"`); without it the second literal's
+ * table was silently dropped even though the wrapper regex now matches
+ * the chain.
+ *
+ * The captured table name is an optional bracketed/unbracketed schema
+ * prefix followed by a `.`, then a bracketed-or-bare identifier — so
+ * `FROM dbo.tblCustomers` and `FROM [My Schema].[My Table]` come
+ * through as one composite reference. Without the prefix the regex
+ * still matches a single identifier byte-identical to the old shape.
+ * Brackets in the captured composite are stripped by
+ * `emitSqlTableReferences` (`replace(/[\[\]]/g, '')`), so the public
+ * node name is the unwrapped form `dbo.tblCustomers` /
+ * `My Schema.My Table` — matching how plain `[Order Details]` is also
+ * unwrapped to `Order Details`. The identifier class
+ * `\[[^\]]+\]|\p{L}[\p{L}\p{N}_]*` (same as the saved-queries
+ * `TABLE_RE` in `sql-query-extractor.ts`) ensures bracketed names
+ * with spaces — `[Order Details]`, `[My Schema]`, `[My Table]` —
+ * are captured whole.
+ */
+const SQL_TABLE_RE = /\b(?:FROM|JOIN|INTO|UPDATE)\s+((?:(?:\[[^\]]+\]|\p{L}[\p{L}\p{N}_]*)\.)?(?:\[[^\]]+\]|\p{L}[\p{L}\p{N}_]*))/giu;
+/**
+ * Regex matching the chained `& "..."` literals that may follow a
+ * wrapper's first literal on the same physical line. Captures the
+ * literal CONTENT (group 1); the surrounding `&` and quotes are
+ * structural, not data. VBA allows whitespace around `&` and around
+ * the inner quotes — handled with `\s*`. The `((?:[^"]|"")*)` body
+ * mirrors the wrapper regex so a `""` inside a chained literal still
+ * decodes to a single `"`.
+ *
+ * Cross-physical-line concat via `_` continuation is OUT OF SCOPE for
+ * v1 (deferred; see commit message).
+ */
+const SQL_WRAPPER_CHAIN_RE = /&\s*"((?:[^"]|"")*)"/g;
+/**
+ * Given the text that follows a SQL wrapper's first literal on the same
+ * physical line, return the contents of every `& "..."` chained literal
+ * in source order. Operates per-physical-line only — VBA `_` line
+ * continuation across physical lines is handled separately by
+ * `collectStringLiteralText` for the variable-assignment path.
+ */
+function collectSqlWrapperChain(rest) {
+    const out = [];
+    const re = new RegExp(SQL_WRAPPER_CHAIN_RE.source, SQL_WRAPPER_CHAIN_RE.flags);
+    let m;
+    while ((m = re.exec(rest)) !== null) {
+        out.push(m[1] ?? '');
+    }
+    return out;
+}
+function scanSqlInLine(ctx, line, lineNum, dedupe, sqlVariables) {
+    for (const { re } of SQL_WRAPPERS) {
+        // Each wrapper regex is stateful (has /g); reset before use.
+        const localRe = new RegExp(re.source, re.flags);
+        let m;
+        while ((m = localRe.exec(line)) !== null) {
+            const firstLiteral = m[1] ?? '';
+            // After the wrapper regex consumes up to and including the closing
+            // `"` of the first literal, walk the rest of the line for any
+            // `& "..."` chains and concatenate every literal's content. Joining
+            // with a space (mirrors `collectStringLiteralText`) keeps adjacent
+            // `FROM tblA` & `FROM tblB` separated so `SQL_TABLE_RE` finds both.
+            const rest = line.slice(m.index + m[0].length);
+            const chain = collectSqlWrapperChain(rest);
+            const joined = [firstLiteral, ...chain].join(' ');
+            emitSqlTableReferences(ctx, joined, lineNum, dedupe);
+        }
+    }
+    const localRe = new RegExp(SQL_VAR_EXEC_RE.source, SQL_VAR_EXEC_RE.flags);
+    let vm;
+    while ((vm = localRe.exec(line)) !== null) {
+        const varName = (vm[1] ?? '').toLowerCase();
+        const sqlString = sqlVariables.get(varName);
+        if (!sqlString)
+            continue;
+        emitSqlTableReferences(ctx, sqlString, lineNum, dedupe);
+    }
+    // Issue #42: `DoCmd.RunSQL <identifier>` (variable form). Mirrors the
+    // SQL_VAR_EXEC_RE path above but for the Access-style `DoCmd.RunSQL`
+    // idiom — the dominant pattern in real-world VBA modules. Resolve the
+    // captured identifier against `sqlVariables` (populated by
+    // `trackSqlVariableAssignment` with `&`-accumulate semantics, Issue
+    // #13) and feed the resolved SQL string into `emitSqlTableReferences`.
+    // Unresolved identifiers (no row in the map) are silently skipped —
+    // same graceful-no-op contract as SQL_VAR_EXEC_RE.
+    const docmdLocalRe = new RegExp(SQL_VAR_DOCMD_RUNSQL_RE.source, SQL_VAR_DOCMD_RUNSQL_RE.flags);
+    let dm;
+    while ((dm = docmdLocalRe.exec(line)) !== null) {
+        const varName = (dm[1] ?? '').toLowerCase();
+        const sqlString = sqlVariables.get(varName);
+        if (!sqlString)
+            continue;
+        emitSqlTableReferences(ctx, sqlString, lineNum, dedupe);
+    }
+}
+/**
+ * #13 fix: `sql = sql & "..."` (self-referential concatenation) must
+ * ACCUMULATE the new fragment onto whatever was already tracked for
+ * `varName`, not overwrite it. Overwriting silently dropped earlier
+ * fragments' tables — typically the initial `FROM <table>` in
+ * `sql = "SELECT * FROM tblA"` followed by `sql = sql & " WHERE x=1"`.
+ *
+ * Detection: the RHS (`m[2]`, trimmed) starts with `<varName> &`,
+ * case-insensitively — matching VBA's case-insensitive identifiers (`Sql`
+ * and `sql` are the same variable). A genuine fresh assignment (RHS does
+ * NOT start with the self-reference) still RESETS tracking — that
+ * behavior is unchanged.
+ */
+function trackSqlVariableAssignment(lines, lineIndex, sqlVariables) {
+    const line = lines[lineIndex] ?? '';
+    const m = SQL_VAR_ASSIGN_RE.exec(line);
+    if (!m)
+        return;
+    const rawVarName = m[1] ?? '';
+    const varName = rawVarName.toLowerCase();
+    const rhs = (m[2] ?? '').trim();
+    const newFragment = collectStringLiteralText(lines, lineIndex);
+    if (!newFragment)
+        return;
+    const selfRefRe = new RegExp(`^${(0, text_utils_1.escapeRegExpLiteral)(rawVarName)}\\s*&`, 'i');
+    const existing = sqlVariables.get(varName);
+    if (existing !== undefined && selfRefRe.test(rhs)) {
+        sqlVariables.set(varName, `${existing} ${newFragment}`);
+    }
+    else {
+        sqlVariables.set(varName, newFragment);
+    }
+}
+function collectStringLiteralText(lines, startIndex) {
+    const fragments = [];
+    for (let i = startIndex; i < lines.length; i++) {
+        const line = lines[i] ?? '';
+        for (const lit of (0, vba_preprocess_1.extractStringLiterals)(line)) {
+            fragments.push(lit.text);
+        }
+        if (!line.trimEnd().endsWith('&'))
+            break;
+    }
+    return fragments.join(' ');
+}
+function emitSqlTableReferences(ctx, sqlString, lineNum, dedupe) {
+    // Scan the SQL string for FROM/INTO/UPDATE <table>.
+    // Preserve the source regex's `/u` flag (Unicode property classes)
+    // — hardcoding `'gi'` here would silently break non-ASCII identifiers.
+    const tableRe = new RegExp(SQL_TABLE_RE.source, SQL_TABLE_RE.flags);
+    let tm;
+    while ((tm = tableRe.exec(sqlString)) !== null) {
+        const table = (tm[1] ?? '').replace(/[\[\]]/g, '');
+        if (!table)
+            continue;
+        const key = `${lineNum}:${table}`;
+        if (dedupe.has(key))
+            continue;
+        dedupe.add(key);
+        ctx.emitReference(table, lineNum, 0, 'vba-sql-table');
+    }
+}
+//# sourceMappingURL=sql-wrapper.js.map

package/lib/dist/extraction/vba/sql-wrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-wrapper.js","sourceRoot":"","sources":["../../../src/extraction/vba/sql-wrapper.ts"],"names":[],"mappings":"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"}

package/lib/dist/extraction/vba/tempvars.d.ts

@@ -0,0 +1,10 @@
+import { VbaExtractorContext, ProcInfo } from './context';
+/**
+ * Issue #50: scan one line of VBA source for TempVars access sites and
+ * emit one `references` edge per site. Bang form scans the MASKED line,
+ * paren + Add forms scan the ORIGINAL line. Access is classified by the
+ * line suffix after the match: a bare `=` next non-whitespace char is a
+ * write (VBA has no `==`).
+ */
+export declare function sweepTempVars(ctx: VbaExtractorContext, maskedLine: string, originalLine: string, lineNum: number, caller: ProcInfo | undefined): void;
+//# sourceMappingURL=tempvars.d.ts.map

package/lib/dist/extraction/vba/tempvars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tempvars.d.ts","sourceRoot":"","sources":["../../../src/extraction/vba/tempvars.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAmG1D;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,mBAAmB,EACxB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,QAAQ,GAAG,SAAS,GAC3B,IAAI,CAiCN"}

package/lib/dist/extraction/vba/tempvars.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sweepTempVars = sweepTempVars;
+/**
+ * TempVars sweep (issue #50). Models each STATIC-LITERAL Access TempVars key
+ * as a synthetic `class` placeholder node (cross-file id-stable) and emits one
+ * `references` edge per reading/writing procedure with
+ * `metadata.synthesizedBy: 'vba-tempvar'` and `metadata.access` ∈ {read, write}.
+ */
+const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
+const text_utils_1 = require("./text-utils");
+/**
+ * Issue #50: TempVars — Access's global key-value store for cross-form
+ * state. Three scanner surfaces cover the four real idioms:
+ *   - `TEMP_VAR_BANG_RE`  — `TempVars!clave`         (no parens; write or read)
+ *   - `TEMP_VAR_PAREN_RE` — `TempVars("clave")`      (parens; write or read)
+ *   - `TEMP_VAR_ADD_RE`   — `TempVars.Add "clave", v` (always a write)
+ *
+ * Bang vs paren split by line-source: the bang form has no string literals
+ * in scope, so we scan the MASKED line (`maskStringContent` replaces
+ * `"…"` content with spaces). The paren and Add forms have their key INSIDE
+ * a `"…"` literal that gets blanked by the masker, so those regexes scan
+ * the ORIGINAL (unmasked) line.
+ *
+ * Dynamic-key forms — `TempVars(strNombre)`, `TempVars("clave" & suffix)` —
+ * are silently unmatched by all three regexes (none tolerate a function-call
+ * or `&` arg). REQ-CODE-4 "unresolvable is silent" applies.
+ */
+const TEMP_VAR_BANG_RE = /\bTempVars!\s*(\p{L}[\p{L}\p{N}_]*)/gu;
+/**
+ * Issue #50 (cont.):
+ * `TempVars("clave")` / `TempVars(  "clave"  )` capture. Scanned
+ * over the original (unmasked) line — the literal lives INSIDE a
+ * string and would be stripped by `maskStringContent`.
+ */
+const TEMP_VAR_PAREN_RE = /\bTempVars\s*\(\s*"([^"]+)"\s*\)/gu;
+/**
+ * Issue #50 (cont.):
+ * `TempVars.Add "clave", value` capture. Always a write (the
+ * `.Add` method inserts/updates the entry). Scanned over the
+ * original (unmasked) line for the same string-literal reason as
+ * `TEMP_VAR_PAREN_RE`.
+ */
+const TEMP_VAR_ADD_RE = /\bTempVars\.Add\s+"([^"]+)"\s*,/gi;
+/**
+ * Issue #50: emit one TempVar reading/writing site. Per call:
+ *   - placeholder `class` node keyed on the synthetic
+ *     `synthetic:tempvar/<key>` file path so cross-file extraction
+ *     calls collapse to one node per key,
+ *   - `references` edge from the calling `function` node
+ *     (via `findOrCreateFunctionNodeId`) carrying
+ *     `metadata.synthesizedBy: 'vba-tempvar'` AND
+ *     `metadata.access: 'read' | 'write'`.
+ *
+ * Skips when there is no caller (module-level code) — REQ-CODE-4
+ * "unresolvable/runtime reference is silent".
+ */
+function emitTempVarReference(ctx, caller, key, lineNum, column, access) {
+    if (!caller)
+        return;
+    if (!key)
+        return;
+    const syntheticFilePath = `synthetic:tempvar/${key}`;
+    const targetId = (0, tree_sitter_helpers_1.generateNodeId)(syntheticFilePath, 'class', // placeholder kind — see SQL_TABLE_RE emitReference for precedent
+    key, 0);
+    if (!ctx.synthTempVarNodeIds.has(targetId)) {
+        ctx.synthTempVarNodeIds.add(targetId);
+        ctx.nodes.push({
+            id: targetId,
+            kind: 'class',
+            name: key,
+            qualifiedName: key,
+            filePath: syntheticFilePath,
+            language: 'vba',
+            startLine: lineNum,
+            endLine: lineNum,
+            startColumn: column,
+            endColumn: column + key.length,
+            updatedAt: Date.now(),
+        });
+    }
+    ctx.edges.push({
+        source: ctx.findOrCreateFunctionNodeId(caller),
+        target: targetId,
+        kind: 'references',
+        provenance: 'heuristic',
+        metadata: {
+            synthesizedBy: 'vba-tempvar',
+            // User-facing enum: lowercase single-token string values.
+            access,
+        },
+        line: lineNum,
+        column,
+    });
+}
+/**
+ * Issue #50: scan one line of VBA source for TempVars access sites and
+ * emit one `references` edge per site. Bang form scans the MASKED line,
+ * paren + Add forms scan the ORIGINAL line. Access is classified by the
+ * line suffix after the match: a bare `=` next non-whitespace char is a
+ * write (VBA has no `==`).
+ */
+function sweepTempVars(ctx, maskedLine, originalLine, lineNum, caller) {
+    // 1) Bang form — masked line. No string-literal interaction.
+    const bangRe = new RegExp(TEMP_VAR_BANG_RE.source, TEMP_VAR_BANG_RE.flags);
+    let bm;
+    while ((bm = bangRe.exec(maskedLine)) !== null) {
+        const key = bm[1] ?? '';
+        if (!key)
+            continue;
+        const access = (0, text_utils_1.detectAssignmentSuffix)(maskedLine, bm.index + bm[0].length)
+            ? 'write'
+            : 'read';
+        emitTempVarReference(ctx, caller, key, lineNum, bm.index, access);
+    }
+    // 2) Paren form — original line. The literal survives only here.
+    const parenRe = new RegExp(TEMP_VAR_PAREN_RE.source, TEMP_VAR_PAREN_RE.flags);
+    let pm;
+    while ((pm = parenRe.exec(originalLine)) !== null) {
+        const key = pm[1] ?? '';
+        if (!key)
+            continue;
+        const access = (0, text_utils_1.detectAssignmentSuffix)(originalLine, pm.index + pm[0].length)
+            ? 'write'
+            : 'read';
+        emitTempVarReference(ctx, caller, key, lineNum, pm.index, access);
+    }
+    // 3) Add form — original line. Always a write.
+    const addRe = new RegExp(TEMP_VAR_ADD_RE.source, TEMP_VAR_ADD_RE.flags);
+    let am;
+    while ((am = addRe.exec(originalLine)) !== null) {
+        const key = am[1] ?? '';
+        if (!key)
+            continue;
+        emitTempVarReference(ctx, caller, key, lineNum, am.index, 'write');
+    }
+}
+//# sourceMappingURL=tempvars.js.map

package/lib/dist/extraction/vba/tempvars.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tempvars.js","sourceRoot":"","sources":["../../../src/extraction/vba/tempvars.ts"],"names":[],"mappings":"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"}

package/lib/dist/extraction/vba/text-utils.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Pure text helpers shared across the VBA extraction passes. None of these
+ * touch extractor state — they are deterministic string transforms lifted
+ * out of `VbaExtractor` verbatim so each pass module can import what it needs
+ * without pulling in the orchestrator.
+ */
+/**
+ * Fold a VBA visibility keyword to the canonical lowercase enum, matching
+ * the procedure convention: `Private` → 'private'; `Public`, `Global`,
+ * `Friend`, or none → 'public' (VBA's default module-level `Const`/`Enum`
+ * is Private, but we follow the same broader-than-private fold the proc
+ * sweep uses so visibility is consistent across symbol kinds).
+ */
+export declare function foldVisibility(raw: string): 'public' | 'private';
+/**
+ * Fix 2 (Issue #2): replace string-literal content with spaces so that
+ * call-site patterns inside `"..."` spans are invisible to CALL_RE and
+ * the statement-form detectors.  Column positions are preserved (each
+ * character is replaced 1-for-1) so any col-based metadata stays correct.
+ */
+export declare function maskStringContent(line: string): string;
+/**
+ * #13 helper: escape a variable name for safe interpolation into the
+ * self-reference RegExp built by `trackSqlVariableAssignment`. VBA
+ * identifiers are alphanumeric+underscore only, so in practice nothing here
+ * ever needs escaping — this guards against regex metacharacters anyway
+ * rather than assume the input is always well-formed.
+ */
+export declare function escapeRegExpLiteral(value: string): string;
+export declare function parseConstDeclarations(body: string): Array<{
+    name: string;
+    value: string | null;
+}>;
+export declare function splitOutsideVbaStrings(value: string, separator: string): string[];
+/**
+ * Issue #50 helper: return true iff `line.charAt(fromIndex..)` (after the
+ * matched TempVars site, including any trailing whitespace) holds an `=`
+ * (write-assignment) and not a `==` (VBA has no `==` operator, so a bare
+ * check for `=` is safe). Used by `sweepTempVars` to classify a `TempVars`
+ * access as read vs write from the local line context.
+ *
+ * We skip over trailing whitespace only — `.`, `(`, `<`, `>`, `*`, `+`
+ * etc. all mean "this isn't an assignment target", and bare `=`
+ * is the only access-suffix shape VBA syntax allows here. A line like
+ * `TempVars!x = 1` (write) or `Debug.Print TempVars!x` (read) land in
+ * the right bucket without further analysis.
+ *
+ * Strings should already be masked out of `line` (`maskStringContent`)
+ * when this is called for the bang form (no string in scope anyway);
+ * the paren form passes the ORIGINAL line — but for THAT form the
+ * captured match ends at the closing `"` of the literal, so any `=`
+ * that follows is unambiguously outside the string.
+ */
+export declare function detectAssignmentSuffix(line: string, fromIndex: number): boolean;
+export declare function unwrapVbaStringLiteral(raw: string): string;
+/**
+ * Hueco 3 helper: parse an Access event-handler Sub name into its
+ * `<ControlName>_<EventName>` components. Returns null when the name does
+ * not match the convention, when the split yields an empty segment, or
+ * when the control name is `Form` (form-level events are NOT control
+ * handlers — `Form_Load` is the form's own lifecycle event, not a
+ * command-button click).
+ *
+ * Splitting on the LAST underscore (rather than the first) lets
+ * multi-word event names parse correctly: `ComandoAltaPM_BeforeDelConfirm`
+ * yields control=`ComandoAltaPM`, event=`BeforeDelConfirm`, not
+ * control=`ComandoAlta`, event=`PM_BeforeDelConfirm`.
+ */
+export declare function parseEventHandlerName(name: string): {
+    controlName: string;
+    eventName: string;
+} | null;
+//# sourceMappingURL=text-utils.d.ts.map

package/lib/dist/extraction/vba/text-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-utils.d.ts","sourceRoot":"","sources":["../../../src/extraction/vba/text-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA4BtD;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,GACX,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAc/C;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CA0BjF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAW/E;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAgB1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,GACX;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAUnD"}

package/lib/dist/extraction/vba/text-utils.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * Pure text helpers shared across the VBA extraction passes. None of these
+ * touch extractor state — they are deterministic string transforms lifted
+ * out of `VbaExtractor` verbatim so each pass module can import what it needs
+ * without pulling in the orchestrator.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.foldVisibility = foldVisibility;
+exports.maskStringContent = maskStringContent;
+exports.escapeRegExpLiteral = escapeRegExpLiteral;
+exports.parseConstDeclarations = parseConstDeclarations;
+exports.splitOutsideVbaStrings = splitOutsideVbaStrings;
+exports.detectAssignmentSuffix = detectAssignmentSuffix;
+exports.unwrapVbaStringLiteral = unwrapVbaStringLiteral;
+exports.parseEventHandlerName = parseEventHandlerName;
+/**
+ * Fold a VBA visibility keyword to the canonical lowercase enum, matching
+ * the procedure convention: `Private` → 'private'; `Public`, `Global`,
+ * `Friend`, or none → 'public' (VBA's default module-level `Const`/`Enum`
+ * is Private, but we follow the same broader-than-private fold the proc
+ * sweep uses so visibility is consistent across symbol kinds).
+ */
+function foldVisibility(raw) {
+    return raw.trim().toLowerCase() === 'private' ? 'private' : 'public';
+}
+/**
+ * Fix 2 (Issue #2): replace string-literal content with spaces so that
+ * call-site patterns inside `"..."` spans are invisible to CALL_RE and
+ * the statement-form detectors.  Column positions are preserved (each
+ * character is replaced 1-for-1) so any col-based metadata stays correct.
+ */
+function maskStringContent(line) {
+    let result = '';
+    let i = 0;
+    while (i < line.length) {
+        const ch = line[i];
+        if (ch === '"') {
+            result += ' '; // opening quote masked
+            i++;
+            while (i < line.length) {
+                const c = line[i];
+                if (c === '"' && line[i + 1] === '"') {
+                    result += '  '; // doubled-quote escape masked (2 chars)
+                    i += 2;
+                }
+                else if (c === '"') {
+                    result += ' '; // closing quote masked
+                    i++;
+                    break;
+                }
+                else {
+                    result += ' '; // string content → space
+                    i++;
+                }
+            }
+        }
+        else {
+            result += ch;
+            i++;
+        }
+    }
+    return result;
+}
+/**
+ * #13 helper: escape a variable name for safe interpolation into the
+ * self-reference RegExp built by `trackSqlVariableAssignment`. VBA
+ * identifiers are alphanumeric+underscore only, so in practice nothing here
+ * ever needs escaping — this guards against regex metacharacters anyway
+ * rather than assume the input is always well-formed.
+ */
+function escapeRegExpLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function parseConstDeclarations(body) {
+    const declarations = [];
+    for (const part of splitOutsideVbaStrings(body, ',')) {
+        const m = /^\s*(\p{L}[\p{L}\p{N}_]*)\s*(?:As\s+[^=]+?)?\s*=\s*(.+?)\s*$/iu.exec(part);
+        if (!m)
+            continue;
+        const name = m[1] ?? '';
+        const rawValue = (m[2] ?? '').trim();
+        declarations.push({
+            name,
+            value: rawValue.startsWith('"') ? unwrapVbaStringLiteral(rawValue) : rawValue || null,
+        });
+    }
+    return declarations;
+}
+function splitOutsideVbaStrings(value, separator) {
+    const parts = [];
+    let current = '';
+    let inString = false;
+    for (let i = 0; i < value.length; i++) {
+        const ch = value[i];
+        const next = value[i + 1];
+        if (ch === '"') {
+            current += ch;
+            if (inString && next === '"') {
+                current += next;
+                i++;
+                continue;
+            }
+            inString = !inString;
+            continue;
+        }
+        if (!inString && ch === separator) {
+            parts.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    parts.push(current);
+    return parts;
+}
+/**
+ * Issue #50 helper: return true iff `line.charAt(fromIndex..)` (after the
+ * matched TempVars site, including any trailing whitespace) holds an `=`
+ * (write-assignment) and not a `==` (VBA has no `==` operator, so a bare
+ * check for `=` is safe). Used by `sweepTempVars` to classify a `TempVars`
+ * access as read vs write from the local line context.
+ *
+ * We skip over trailing whitespace only — `.`, `(`, `<`, `>`, `*`, `+`
+ * etc. all mean "this isn't an assignment target", and bare `=`
+ * is the only access-suffix shape VBA syntax allows here. A line like
+ * `TempVars!x = 1` (write) or `Debug.Print TempVars!x` (read) land in
+ * the right bucket without further analysis.
+ *
+ * Strings should already be masked out of `line` (`maskStringContent`)
+ * when this is called for the bang form (no string in scope anyway);
+ * the paren form passes the ORIGINAL line — but for THAT form the
+ * captured match ends at the closing `"` of the literal, so any `=`
+ * that follows is unambiguously outside the string.
+ */
+function detectAssignmentSuffix(line, fromIndex) {
+    let i = fromIndex;
+    while (i < line.length) {
+        const ch = line[i];
+        if (ch === ' ' || ch === '\t') {
+            i++;
+            continue;
+        }
+        return ch === '=';
+    }
+    return false;
+}
+function unwrapVbaStringLiteral(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith('"'))
+        return trimmed;
+    let text = '';
+    for (let i = 1; i < trimmed.length; i++) {
+        const ch = trimmed[i];
+        const next = trimmed[i + 1];
+        if (ch === '"' && next === '"') {
+            text += '"';
+            i++;
+            continue;
+        }
+        if (ch === '"')
+            break;
+        text += ch;
+    }
+    return text;
+}
+/**
+ * Hueco 3 helper: parse an Access event-handler Sub name into its
+ * `<ControlName>_<EventName>` components. Returns null when the name does
+ * not match the convention, when the split yields an empty segment, or
+ * when the control name is `Form` (form-level events are NOT control
+ * handlers — `Form_Load` is the form's own lifecycle event, not a
+ * command-button click).
+ *
+ * Splitting on the LAST underscore (rather than the first) lets
+ * multi-word event names parse correctly: `ComandoAltaPM_BeforeDelConfirm`
+ * yields control=`ComandoAltaPM`, event=`BeforeDelConfirm`, not
+ * control=`ComandoAlta`, event=`PM_BeforeDelConfirm`.
+ */
+function parseEventHandlerName(name) {
+    if (!name)
+        return null;
+    const lastUnderscore = name.lastIndexOf('_');
+    if (lastUnderscore <= 0)
+        return null; // no underscore OR starts with underscore
+    const controlName = name.slice(0, lastUnderscore);
+    const eventName = name.slice(lastUnderscore + 1);
+    if (!controlName || !eventName)
+        return null;
+    // Form-level events live on the form, not on a control.
+    if (controlName.toLowerCase() === 'form')
+        return null;
+    return { controlName, eventName };
+}
+//# sourceMappingURL=text-utils.js.map