EXAMPLE 04 • closures-hidden.ts

Closures & Hidden Compiler Frames

Unpack tuple-compressed closure state (_c[0..3]) across nested scopes while hiding internal compiler trampolines (isHidden: true).

Nested Scope Chain (Module -> Closure Function -> Inner Function -> Block)Hidden Stack Frame Ranges (isStackFrame: true, isHidden: true)Tuple-Packed Closure Capture Bindings (_c[0] -> endpointName, _c[3] -> usedTokens)Synthesized Boolean Guard Bindings (rem >= 0 -> allowed)

OPEN CHROME DEVTOOLS (F12) FIRST, THEN TRIGGER:

Ready. Click "Run & Pause in Debugger" with DevTools open.

How This Example Works

Compilers frequently transform closures by packing captured outer variables (endpointName, maxBurst, windowSeconds, usedTokens) into a flat heap array _c = ["/api/v2/inference", 50, 60, 12], and wrap calls in internal runtime trampolines like __withCompilerTrampoline(cb).

This example demonstrates two key features of the Scopes proposal:
1) Marking __withCompilerTrampoline's range with isHidden: true (and retaining the definition scope pointer on wrappers that contain authored code) so Chrome DevTools automatically strips internal compiler frames from the Call Stack.
2) Reconstructing the outer createEndpointHandler closure scope from _c[0..3] alongside the inner handleRequest function scope and if (allowed) block scope.

What to Try & Verify in DevTools

Verify Hidden Trampoline Frames Are Omitted from Call Stack Call Stack

Try:Click "Run & Pause in Debugger" to pause inside handleRequest in closures-hidden.ts and inspect the Call Stack pane.

Clean Call Stack: handleRequest appears called directly by executeRateLimitCheck (line 45).
Hidden Runtime Wrappers: Both __withCompilerTrampoline and its anonymous callback (isHidden: true) are automatically omitted from the stack trace.

Inspect the Multi-Level Scope Chain (Block -> Local -> Closure -> Module) Scope View

Try:While paused at debugger; on line 19 of closures-hidden.ts, expand each section in the Scope sidebar.

Block Scope (if (allowed)): Shows burstUtilization: 40.
Local Scope (handleRequest): Shows clientIp: "192.0.2.44", requestWeight: 8, remainingTokens: 30, and synthesized allowed: true.
Closure Scope (createEndpointHandler): Unpacks tuple _c[0..3] into endpointName: "/api/v2/inference", maxBurst: 50, windowSeconds: 60, and usedTokens: 20. executeRateLimitCheck's variables (limiter, handler) must not show up: it is not a lexical parent of handleRequest.
Module Scope: Shows DEFAULT_REGION: "us-central1" (and RateLimiter as <unavailable>).

Autocomplete Across Block, Function, Closure & Module Scopes Autocomplete

Try:Open the Console (Esc) while paused and type prefixes from different scope levels: burst, rem, endp, usedT, and DEFAULT_.

Full Lexical Chain Aggregation: Autocomplete merges variables from the Block, Function, outer Closure, and Module scopes.

Break Conditionally on Tuple-Packed Closure State Conditional Breakpoints

Try:Right-click line 20 (return { region: DEFAULT_REGION, ... }), add a conditional breakpoint burstUtilization >= 40 && usedTokens === 20, resume (F8), and re-run.

Cross-Scope Condition Rewriting: DevTools rewrites burstUtilization to util and usedTokens to _c[3], pausing cleanly at the return statement.

Evaluate Expressions Mixing All 4 Scope Levels Debug Evaluate

Try:Run the expressions below in the Console while paused at debugger;.

Multi-Scope Substitution: A single expression can seamlessly combine DEFAULT_REGION (Module), endpointName / usedTokens / maxBurst (Closure), remainingTokens / allowed (Function), and burstUtilization (Block).

Other things to try

Step Out (Shift+F11) of handleRequest: you should never land in __withCompilerTrampoline.
Add Watch expressions using closure variables (usedTokens, maxBurst), then select another frame.
Hover DEFAULT_REGION, endpointName and usedTokens in the editor with different frames selected.

Not sure if it's a DevTools bug? Tab 4. Decoded Scopes shows what the source map actually encodes.

Try in the Console While Paused

While paused, select a frame and evaluate these in the Console (Esc opens the drawer) using the authored names:

`${DEFAULT_REGION}:${endpointName} -> ${usedTokens}/${maxBurst} tokens (${burstUtilization}%)`

Expected Result: "us-central1:/api/v2/inference -> 20/50 tokens (40%)"

Combines variables from 4 different scope levels (Module, Closure, and Block) into a single template string.

usedTokens + remainingTokens === maxBurst

Expected Result: true

Substitutes _c[3] + rem === _c[1] (20 + 30 === 50).

allowed && windowSeconds === 60

Expected Result: true

Substitutes synthesized boolean rem >= 0 for allowed and tuple slot _c[2] for windowSeconds.

        
        // Authored TypeScript: closures-hidden.ts
      
        const DEFAULT_REGION = "us-central1";
      
        export class RateLimiter {
      
          createEndpointHandler(
      
            endpointName: string,
      
            maxBurst: number,
      
            windowSeconds: number,
      
          ) {
      
            let usedTokens = 12;
      
            return function handleRequest(clientIp: string, requestWeight: number) {
      
              usedTokens += requestWeight;
      
              const remainingTokens = maxBurst - usedTokens;
      
              const allowed = remainingTokens >= 0;
      
              if (allowed) {
      
                const burstUtilization = Number(((usedTokens / maxBurst) * 100).toFixed(1));
      
                debugger; // Pause: Inspect Block, Local & Closure scopes and the hidden trampoline frames!
      
                return {
      
                  region: DEFAULT_REGION,
      
                  endpoint: endpointName,
      
                  clientIp,
      
                  allowed,
      
                  remainingTokens,
      
                  burstUtilization,
      
                };
      
              }
      
              return {
      
                region: DEFAULT_REGION,
      
                endpoint: endpointName,
      
                clientIp,
      
                allowed: false,
      
                remainingTokens: 0,
      
                burstUtilization: 100,
      
              };
      
            };
      
          }
      
        }
      
        export function executeRateLimitCheck() {
      
          const limiter = new RateLimiter();
      
          const handler = limiter.createEndpointHandler("/api/v2/inference", 50, 60);
      
          return handler("192.0.2.44", 8);
      
        }

        
        function __withCompilerTrampoline(cb) {
      
          return cb();
      
        }
      
        function executeRateLimitCheck() {
      
          const _c = ["/api/v2/inference", 50, 60, 12];
      
          function handleRequest(ip, w) {
      
            _c[3] += w;
      
            const rem = _c[1] - _c[3];
      
            if (rem >= 0) {
      
              const util = Number(((_c[3] / _c[1]) * 100).toFixed(1));
      
              debugger;
      
              return { region: "us-central1", endpoint: _c[0], clientIp: ip, allowed: true, remainingTokens: rem, burstUtilization: util };
      
            }
      
            return { region: "us-central1", endpoint: _c[0], clientIp: ip, allowed: false, remainingTokens: 0, burstUtilization: 100 };
      
          }
      
          return __withCompilerTrampoline(function() {
      
            return handleRequest("192.0.2.44", 8);
      
          });
      
        }
      
        window.runExample04 = function() {
      
          return executeRateLimitCheck();
      
        };
      
        //# sourceMappingURL=bundle.js.map

        
        const builder = new SafeScopeInfoBuilder();
      
        // 1. Original Scopes: Module -> Function (createEndpointHandler)
      
        //    -> Function (handleRequest) -> Block (if allowed)
      
        builder
      
          .startSource()
      
          .startScope(0, 0, {
      
            kind: "Module",
      
            key: "module",
      
            variables: ["DEFAULT_REGION", "RateLimiter", "executeRateLimitCheck"],
      
          })
      
          .startScope(factoryStart.line, factoryStart.column, {
      
            name: "createEndpointHandler",
      
            kind: "Function",
      
            isStackFrame: true,
      
            key: "createEndpointHandler",
      
            variables: ["endpointName", "maxBurst", "windowSeconds", "usedTokens"],
      
          })
      
          .startScope(handlerStart.line, handlerStart.column, {
      
            name: "handleRequest",
      
            kind: "Function",
      
            isStackFrame: true,
      
            key: "handleRequest",
      
            variables: ["clientIp", "requestWeight", "remainingTokens", "allowed"],
      
          })
      
          .startScope(ifBlockStart.line, ifBlockStart.column, {
      
            kind: "Block",
      
            key: "ifBlock",
      
            variables: ["burstUtilization"],
      
          })
      
          .endScope(ifBlockEnd.line, ifBlockEnd.column)
      
          .endScope(handlerEnd.line, handlerEnd.column)
      
          .endScope(factoryEnd.line, factoryEnd.column)
      
          .startScope(execStart.line, execStart.column, {
      
            name: "executeRateLimitCheck",
      
            kind: "Function",
      
            isStackFrame: true,
      
            key: "executeRateLimitCheck",
      
            variables: ["limiter", "handler"],
      
          })
      
          .endScope(execEnd.line, execEnd.column)
      
          .endScope(moduleEnd.line, moduleEnd.column)
      
          .endSource();
      
        // 2. Generated Ranges:
      
        //    - __withCompilerTrampoline is marked with isStackFrame: true, isHidden: true
      
        //      so DevTools omits it from the Call Stack!
      
        //    - Captured closure variables are unpacked from tuple _c[0..3].
      
        //    - availableFrom(start, from, end, value) = unavailable in [start, from), bound to value in [from, end).
      
        //      Used for generated const (_c, rem, util) that are still in their TDZ before their declaration ran.
      
        builder
      
          .startRange(0, 0, {
      
            scopeKey: "module",
      
            values: ['"us-central1"', null, "executeRateLimitCheck"],
      
          })
      
          .startRange(trampolineStart.line, trampolineStart.column, {
      
            isStackFrame: true,
      
            isHidden: true, // <--- Hides internal compiler wrapper from Call Stack!
      
          })
      
          .endRange(trampolineEnd.line, trampolineEnd.column)
      
          .startRange(genExecStart.line, genExecStart.column, {
      
            scopeKey: "executeRateLimitCheck",
      
            isStackFrame: true,
      
            values: [null, "handleRequest"],
      
          })
      
          .startRange(genClosureStart.line, genClosureStart.column, {
      
            scopeKey: "createEndpointHandler",
      
            isStackFrame: false,
      
            values: [0, 1, 2, 3].map((i) =>
      
              availableFrom(genClosureStart, afterC, genClosureEnd, `_c[${i}]`)
      
            ),
      
          })
      
          .startRange(genHandlerStart.line, genHandlerStart.column, {
      
            scopeKey: "handleRequest",
      
            isStackFrame: true,
      
            values: [
      
              "ip",
      
              "w",
      
              availableFrom(genHandlerStart, afterRem, genHandlerEnd, "rem"),
      
              availableFrom(genHandlerStart, afterRem, genHandlerEnd, "rem >= 0"),
      
            ],
      
          })
      
          .startRange(genIfStart.line, genIfStart.column, {
      
            scopeKey: "ifBlock",
      
            values: [availableFrom(genIfStart, afterUtil, genIfEnd, "util")],
      
          })
      
          .endRange(genIfEnd.line, genIfEnd.column)
      
          .endRange(genHandlerEnd.line, genHandlerEnd.column)
      
          .endRange(genClosureEnd.line, genClosureEnd.column)
      
          // Generated wrapper function that contains authored code from executeRateLimitCheck:
      
          // keep definition scope pointer ('executeRateLimitCheck') and mark isHidden: true.
      
          .startRange(genAnonTrampolineStart.line, genAnonTrampolineStart.column, {
      
            scopeKey: "executeRateLimitCheck",
      
            isStackFrame: true,
      
            isHidden: true,
      
            values: [null, "handleRequest"],
      
          })
      
          .endRange(genAnonTrampolineEnd.line, genAnonTrampolineEnd.column)
      
          .endRange(genExecEnd.line, genExecEnd.column)
      
          // Generated-only entry helper without corresponding authored code:
      
          .startRange(genRunStart.line, genRunStart.column, {
      
            isStackFrame: true,
      
          })
      
          .endRange(genRunEnd.line, genRunEnd.column)
      
          .endRange(genModuleEnd.line, genModuleEnd.column);

Decoded OriginalScope Tree (closures-hidden.ts)
      Module
      (anonymous)
      [0:0 → 46:0)
      
    
variables: [DEFAULT_REGION, RateLimiter, executeRateLimitCheck]

      Function
      createEndpointHandler
      [4:23 → 38:3)
      isStackFrame
    
variables: [endpointName, maxBurst, windowSeconds, usedTokens]

      Function
      handleRequest
      [11:33 → 37:5)
      isStackFrame
    
variables: [clientIp, requestWeight, remainingTokens, allowed]

      Block
      (anonymous)
      [16:6 → 27:7)
      
    
variables: [burstUtilization]

      Function
      executeRateLimitCheck
      [41:37 → 45:1)
      isStackFrame
    
variables: [limiter, handler]
Decoded GeneratedRange & Binding Tree (bundle.js)
      Range [0:0 → 23:0)
      → Module
      isStackFrame: false
      
      
    

          bindings: DEFAULT_REGION → "us-central1", RateLimiter → <unavailable>, executeRateLimitCheck → executeRateLimitCheck
        

      Range [0:33 → 2:1)
      → unmapped range
      isStackFrame
      isHidden: true
      
    

      Range [3:30 → 18:1)
      → Function(executeRateLimitCheck)
      isStackFrame
      
      
    

          bindings: limiter → <unavailable>, handler → handleRequest
        

      Range [4:2 → 14:3)
      → Function(createEndpointHandler)
      isStackFrame: false
      
      
    

          bindings: endpointName → SubRanges([4:2-4:47]: unavailable | [4:47-14:3]: _c[0]), maxBurst → SubRanges([4:2-4:47]: unavailable | [4:47-14:3]: _c[1]), windowSeconds → SubRanges([4:2-4:47]: unavailable | [4:47-14:3]: _c[2]), usedTokens → SubRanges([4:2-4:47]: unavailable | [4:47-14:3]: _c[3])
        

      Range [5:24 → 14:3)
      → Function(handleRequest)
      isStackFrame
      
      
    

          bindings: clientIp → ip, requestWeight → w, remainingTokens → SubRanges([5:24-7:30]: unavailable | [7:30-14:3]: rem), allowed → SubRanges([5:24-7:30]: unavailable | [7:30-14:3]: rem >= 0)
        

      Range [8:4 → 12:5)
      → Block
      isStackFrame: false
      
      
    

          bindings: burstUtilization → SubRanges([8:4-9:62]: unavailable | [9:62-12:5]: util)
        

      Range [15:42 → 17:3)
      → Function(executeRateLimitCheck)
      isStackFrame
      isHidden: true
      
    

          bindings: limiter → <unavailable>, handler → handleRequest
        

      Range [19:30 → 21:1)
      → unmapped range
      isStackFrame
      
      
    

              Raw Source Map JSON (bundle.js.map)
              {
  "version": 3,
  "file": "bundle.js",
  "sources": [
    "closures-hidden.ts"
  ],
  "sourcesContent": [
    "// Authored TypeScript: closures-hidden.ts\nconst DEFAULT_REGION = \"us-central1\";\n\nexport class RateLimiter {\n  createEndpointHandler(\n    endpointName: string,\n    maxBurst: number,\n    windowSeconds: number,\n  ) {\n    let usedTokens = 12;\n\n    return function handleRequest(clientIp: string, requestWeight: number) {\n      usedTokens += requestWeight;\n      const remainingTokens = maxBurst - usedTokens;\n      const allowed = remainingTokens >= 0;\n\n      if (allowed) {\n        const burstUtilization = Number(((usedTokens / maxBurst) * 100).toFixed(1));\n        debugger; // Pause: Inspect Block, Local & Closure scopes and the hidden trampoline frames!\n        return {\n          region: DEFAULT_REGION,\n          endpoint: endpointName,\n          clientIp,\n          allowed,\n          remainingTokens,\n          burstUtilization,\n        };\n      }\n\n      return {\n        region: DEFAULT_REGION,\n        endpoint: endpointName,\n        clientIp,\n        allowed: false,\n        remainingTokens: 0,\n        burstUtilization: 100,\n      };\n    };\n  }\n}\n\nexport function executeRateLimitCheck() {\n  const limiter = new RateLimiter();\n  const handler = limiter.createEndpointHandler(\"/api/v2/inference\", 50, 60);\n  return handler(\"192.0.2.44\", 8);\n}\n"
  ],
  "names": [
    "executeRateLimitCheck",
    "usedTokens",
    "handleRequest",
    "remainingTokens",
    "burstUtilization",
    "Module",
    "DEFAULT_REGION",
    "RateLimiter",
    "createEndpointHandler",
    "Function",
    "endpointName",
    "maxBurst",
    "windowSeconds",
    "clientIp",
    "requestWeight",
    "allowed",
    "Block",
    "limiter",
    "handler",
    "\"us-central1\"",
    "_c[0]",
    "_c[1]",
    "_c[2]",
    "_c[3]",
    "ip",
    "w",
    "rem",
    "rem >= 0",
    "util"
  ],
  "mappings": ";;;AAyCAA;EAhCIC;EAEAC;IACE;IACAC;IAGA;MACEC;MACA;MACA;;;;EAyBN;IAAA;;;;;;;",
  "scopes": [
    "BCAAK,DMCP,BHEXQI,DUCCX,BHHhBNA,DYCXY,BCFGO,DX,CLH,CKF,CBD,BHDlBFP,DaC,CEB,CBA"
  ],
  "ranges": [
    "ECAAA,GUAB,EMhB,FCB,EHBeAI,GAD,EDBCAH,GAAAA,HAAtBV,HBAtBW,HCAtBX,HDAtBY,EHBYAC,GZaAA,HCCeb,HDCec,EDDEAC,GA,HAB+Bd,FEF,FCD,FA,EPBqBAC,GAD,FCD,FBB,EFBe,FCB,FCA"
  ]
}
            

1	// Authored TypeScript: closures-hidden.ts
2	const DEFAULT_REGION = "us-central1";
3
4	export class RateLimiter {
5	createEndpointHandler(
6	endpointName: string,
7	maxBurst: number,
8	windowSeconds: number,
9	) {
10	let usedTokens = 12;
11
12	return function handleRequest(clientIp: string, requestWeight: number) {
13	usedTokens += requestWeight;
14	const remainingTokens = maxBurst - usedTokens;
15	const allowed = remainingTokens >= 0;
16
17	if (allowed) {
18	const burstUtilization = Number(((usedTokens / maxBurst) * 100).toFixed(1));
19	debugger; // Pause: Inspect Block, Local & Closure scopes and the hidden trampoline frames!
20	return {
21	region: DEFAULT_REGION,
22	endpoint: endpointName,
23	clientIp,
24	allowed,
25	remainingTokens,
26	burstUtilization,
27	};
28	}
29
30	return {
31	region: DEFAULT_REGION,
32	endpoint: endpointName,
33	clientIp,
34	allowed: false,
35	remainingTokens: 0,
36	burstUtilization: 100,
37	};
38	};
39	}
40	}
41
42	export function executeRateLimitCheck() {
43	const limiter = new RateLimiter();
44	const handler = limiter.createEndpointHandler("/api/v2/inference", 50, 60);
45	return handler("192.0.2.44", 8);
46	}

1	function __withCompilerTrampoline(cb) {
2	return cb();
3	}
4	function executeRateLimitCheck() {
5	const _c = ["/api/v2/inference", 50, 60, 12];
6	function handleRequest(ip, w) {
7	_c[3] += w;
8	const rem = _c[1] - _c[3];
9	if (rem >= 0) {
10	const util = Number(((_c[3] / _c[1]) * 100).toFixed(1));
11	debugger;
12	return { region: "us-central1", endpoint: _c[0], clientIp: ip, allowed: true, remainingTokens: rem, burstUtilization: util };
13	}
14	return { region: "us-central1", endpoint: _c[0], clientIp: ip, allowed: false, remainingTokens: 0, burstUtilization: 100 };
15	}
16	return __withCompilerTrampoline(function() {
17	return handleRequest("192.0.2.44", 8);
18	});
19	}
20	window.runExample04 = function() {
21	return executeRateLimitCheck();
22	};
23	//# sourceMappingURL=bundle.js.map

1	const builder = new SafeScopeInfoBuilder();
2
3	// 1. Original Scopes: Module -> Function (createEndpointHandler)
4	// -> Function (handleRequest) -> Block (if allowed)
5	builder
6	.startSource()
7	.startScope(0, 0, {
8	kind: "Module",
9	key: "module",
10	variables: ["DEFAULT_REGION", "RateLimiter", "executeRateLimitCheck"],
11	})
12	.startScope(factoryStart.line, factoryStart.column, {
13	name: "createEndpointHandler",
14	kind: "Function",
15	isStackFrame: true,
16	key: "createEndpointHandler",
17	variables: ["endpointName", "maxBurst", "windowSeconds", "usedTokens"],
18	})
19	.startScope(handlerStart.line, handlerStart.column, {
20	name: "handleRequest",
21	kind: "Function",
22	isStackFrame: true,
23	key: "handleRequest",
24	variables: ["clientIp", "requestWeight", "remainingTokens", "allowed"],
25	})
26	.startScope(ifBlockStart.line, ifBlockStart.column, {
27	kind: "Block",
28	key: "ifBlock",
29	variables: ["burstUtilization"],
30	})
31	.endScope(ifBlockEnd.line, ifBlockEnd.column)
32	.endScope(handlerEnd.line, handlerEnd.column)
33	.endScope(factoryEnd.line, factoryEnd.column)
34	.startScope(execStart.line, execStart.column, {
35	name: "executeRateLimitCheck",
36	kind: "Function",
37	isStackFrame: true,
38	key: "executeRateLimitCheck",
39	variables: ["limiter", "handler"],
40	})
41	.endScope(execEnd.line, execEnd.column)
42	.endScope(moduleEnd.line, moduleEnd.column)
43	.endSource();
44
45	// 2. Generated Ranges:
46	// - __withCompilerTrampoline is marked with isStackFrame: true, isHidden: true
47	// so DevTools omits it from the Call Stack!
48	// - Captured closure variables are unpacked from tuple _c[0..3].
49	// - availableFrom(start, from, end, value) = unavailable in [start, from), bound to value in [from, end).
50	// Used for generated const (_c, rem, util) that are still in their TDZ before their declaration ran.
51	builder
52	.startRange(0, 0, {
53	scopeKey: "module",
54	values: ['"us-central1"', null, "executeRateLimitCheck"],
55	})
56	.startRange(trampolineStart.line, trampolineStart.column, {
57	isStackFrame: true,
58	isHidden: true, // <--- Hides internal compiler wrapper from Call Stack!
59	})
60	.endRange(trampolineEnd.line, trampolineEnd.column)
61	.startRange(genExecStart.line, genExecStart.column, {
62	scopeKey: "executeRateLimitCheck",
63	isStackFrame: true,
64	values: [null, "handleRequest"],
65	})
66	.startRange(genClosureStart.line, genClosureStart.column, {
67	scopeKey: "createEndpointHandler",
68	isStackFrame: false,
69	values: [0, 1, 2, 3].map((i) =>
70	availableFrom(genClosureStart, afterC, genClosureEnd, `_c[${i}]`)
71	),
72	})
73	.startRange(genHandlerStart.line, genHandlerStart.column, {
74	scopeKey: "handleRequest",
75	isStackFrame: true,
76	values: [
77	"ip",
78	"w",
79	availableFrom(genHandlerStart, afterRem, genHandlerEnd, "rem"),
80	availableFrom(genHandlerStart, afterRem, genHandlerEnd, "rem >= 0"),
81	],
82	})
83	.startRange(genIfStart.line, genIfStart.column, {
84	scopeKey: "ifBlock",
85	values: [availableFrom(genIfStart, afterUtil, genIfEnd, "util")],
86	})
87	.endRange(genIfEnd.line, genIfEnd.column)
88	.endRange(genHandlerEnd.line, genHandlerEnd.column)
89	.endRange(genClosureEnd.line, genClosureEnd.column)
90	// Generated wrapper function that contains authored code from executeRateLimitCheck:
91	// keep definition scope pointer ('executeRateLimitCheck') and mark isHidden: true.
92	.startRange(genAnonTrampolineStart.line, genAnonTrampolineStart.column, {
93	scopeKey: "executeRateLimitCheck",
94	isStackFrame: true,
95	isHidden: true,
96	values: [null, "handleRequest"],
97	})
98	.endRange(genAnonTrampolineEnd.line, genAnonTrampolineEnd.column)
99	.endRange(genExecEnd.line, genExecEnd.column)
100	// Generated-only entry helper without corresponding authored code:
101	.startRange(genRunStart.line, genRunStart.column, {
102	isStackFrame: true,
103	})
104	.endRange(genRunEnd.line, genRunEnd.column)
105	.endRange(genModuleEnd.line, genModuleEnd.column);