This is page 5 of 10. Use http://codebase.md/hangwin/mcp-chrome?lines=true&page={x} to view the full context.
# Directory Structure
```
├── .gitattributes
├── .github
│ └── workflows
│ └── build-release.yml
├── .gitignore
├── .husky
│ ├── commit-msg
│ └── pre-commit
├── .prettierignore
├── .prettierrc.json
├── .vscode
│ └── extensions.json
├── app
│ ├── chrome-extension
│ │ ├── _locales
│ │ │ ├── de
│ │ │ │ └── messages.json
│ │ │ ├── en
│ │ │ │ └── messages.json
│ │ │ ├── ja
│ │ │ │ └── messages.json
│ │ │ ├── ko
│ │ │ │ └── messages.json
│ │ │ ├── zh_CN
│ │ │ │ └── messages.json
│ │ │ └── zh_TW
│ │ │ └── messages.json
│ │ ├── .env.example
│ │ ├── assets
│ │ │ └── vue.svg
│ │ ├── common
│ │ │ ├── constants.ts
│ │ │ ├── message-types.ts
│ │ │ └── tool-handler.ts
│ │ ├── entrypoints
│ │ │ ├── background
│ │ │ │ ├── index.ts
│ │ │ │ ├── native-host.ts
│ │ │ │ ├── semantic-similarity.ts
│ │ │ │ ├── storage-manager.ts
│ │ │ │ └── tools
│ │ │ │ ├── base-browser.ts
│ │ │ │ ├── browser
│ │ │ │ │ ├── bookmark.ts
│ │ │ │ │ ├── common.ts
│ │ │ │ │ ├── console.ts
│ │ │ │ │ ├── file-upload.ts
│ │ │ │ │ ├── history.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── inject-script.ts
│ │ │ │ │ ├── interaction.ts
│ │ │ │ │ ├── keyboard.ts
│ │ │ │ │ ├── network-capture-debugger.ts
│ │ │ │ │ ├── network-capture-web-request.ts
│ │ │ │ │ ├── network-request.ts
│ │ │ │ │ ├── screenshot.ts
│ │ │ │ │ ├── vector-search.ts
│ │ │ │ │ ├── web-fetcher.ts
│ │ │ │ │ └── window.ts
│ │ │ │ └── index.ts
│ │ │ ├── content.ts
│ │ │ ├── offscreen
│ │ │ │ ├── index.html
│ │ │ │ └── main.ts
│ │ │ └── popup
│ │ │ ├── App.vue
│ │ │ ├── components
│ │ │ │ ├── ConfirmDialog.vue
│ │ │ │ ├── icons
│ │ │ │ │ ├── BoltIcon.vue
│ │ │ │ │ ├── CheckIcon.vue
│ │ │ │ │ ├── DatabaseIcon.vue
│ │ │ │ │ ├── DocumentIcon.vue
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── TabIcon.vue
│ │ │ │ │ ├── TrashIcon.vue
│ │ │ │ │ └── VectorIcon.vue
│ │ │ │ ├── ModelCacheManagement.vue
│ │ │ │ └── ProgressIndicator.vue
│ │ │ ├── index.html
│ │ │ ├── main.ts
│ │ │ └── style.css
│ │ ├── eslint.config.js
│ │ ├── inject-scripts
│ │ │ ├── click-helper.js
│ │ │ ├── fill-helper.js
│ │ │ ├── inject-bridge.js
│ │ │ ├── interactive-elements-helper.js
│ │ │ ├── keyboard-helper.js
│ │ │ ├── network-helper.js
│ │ │ ├── screenshot-helper.js
│ │ │ └── web-fetcher-helper.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── public
│ │ │ ├── icon
│ │ │ │ ├── 128.png
│ │ │ │ ├── 16.png
│ │ │ │ ├── 32.png
│ │ │ │ ├── 48.png
│ │ │ │ └── 96.png
│ │ │ ├── libs
│ │ │ │ └── ort.min.js
│ │ │ └── wxt.svg
│ │ ├── README.md
│ │ ├── tsconfig.json
│ │ ├── utils
│ │ │ ├── content-indexer.ts
│ │ │ ├── i18n.ts
│ │ │ ├── image-utils.ts
│ │ │ ├── lru-cache.ts
│ │ │ ├── model-cache-manager.ts
│ │ │ ├── offscreen-manager.ts
│ │ │ ├── semantic-similarity-engine.ts
│ │ │ ├── simd-math-engine.ts
│ │ │ ├── text-chunker.ts
│ │ │ └── vector-database.ts
│ │ ├── workers
│ │ │ ├── ort-wasm-simd-threaded.jsep.mjs
│ │ │ ├── ort-wasm-simd-threaded.jsep.wasm
│ │ │ ├── ort-wasm-simd-threaded.mjs
│ │ │ ├── ort-wasm-simd-threaded.wasm
│ │ │ ├── simd_math_bg.wasm
│ │ │ ├── simd_math.js
│ │ │ └── similarity.worker.js
│ │ └── wxt.config.ts
│ └── native-server
│ ├── debug.sh
│ ├── install.md
│ ├── jest.config.js
│ ├── package.json
│ ├── README.md
│ ├── src
│ │ ├── cli.ts
│ │ ├── constant
│ │ │ └── index.ts
│ │ ├── file-handler.ts
│ │ ├── index.ts
│ │ ├── mcp
│ │ │ ├── mcp-server-stdio.ts
│ │ │ ├── mcp-server.ts
│ │ │ ├── register-tools.ts
│ │ │ └── stdio-config.json
│ │ ├── native-messaging-host.ts
│ │ ├── scripts
│ │ │ ├── browser-config.ts
│ │ │ ├── build.ts
│ │ │ ├── constant.ts
│ │ │ ├── postinstall.ts
│ │ │ ├── register-dev.ts
│ │ │ ├── register.ts
│ │ │ ├── run_host.bat
│ │ │ ├── run_host.sh
│ │ │ └── utils.ts
│ │ ├── server
│ │ │ ├── index.ts
│ │ │ └── server.test.ts
│ │ └── util
│ │ └── logger.ts
│ └── tsconfig.json
├── commitlint.config.cjs
├── docs
│ ├── ARCHITECTURE_zh.md
│ ├── ARCHITECTURE.md
│ ├── CHANGELOG.md
│ ├── CONTRIBUTING_zh.md
│ ├── CONTRIBUTING.md
│ ├── TOOLS_zh.md
│ ├── TOOLS.md
│ ├── TROUBLESHOOTING_zh.md
│ ├── TROUBLESHOOTING.md
│ └── WINDOWS_INSTALL_zh.md
├── eslint.config.js
├── LICENSE
├── package.json
├── packages
│ ├── shared
│ │ ├── package.json
│ │ ├── src
│ │ │ ├── constants.ts
│ │ │ ├── index.ts
│ │ │ ├── tools.ts
│ │ │ └── types.ts
│ │ └── tsconfig.json
│ └── wasm-simd
│ ├── .gitignore
│ ├── BUILD.md
│ ├── Cargo.toml
│ ├── package.json
│ ├── README.md
│ └── src
│ └── lib.rs
├── pnpm-lock.yaml
├── pnpm-workspace.yaml
├── prompt
│ ├── content-analize.md
│ ├── excalidraw-prompt.md
│ └── modify-web.md
├── README_zh.md
├── README.md
├── releases
│ ├── chrome-extension
│ │ └── latest
│ │ └── chrome-mcp-server-lastest.zip
│ └── README.md
└── test-inject-script.js
```
# Files
--------------------------------------------------------------------------------
/app/chrome-extension/entrypoints/background/tools/browser/network-capture-web-request.ts:
--------------------------------------------------------------------------------
```typescript
1 | import { createErrorResponse, ToolResult } from '@/common/tool-handler';
2 | import { BaseBrowserToolExecutor } from '../base-browser';
3 | import { TOOL_NAMES } from 'chrome-mcp-shared';
4 | import { LIMITS, NETWORK_FILTERS } from '@/common/constants';
5 |
6 | // Static resource file extensions
7 | const STATIC_RESOURCE_EXTENSIONS = [
8 | '.jpg',
9 | '.jpeg',
10 | '.png',
11 | '.gif',
12 | '.svg',
13 | '.webp',
14 | '.ico',
15 | '.bmp', // Images
16 | '.css',
17 | '.scss',
18 | '.less', // Styles
19 | '.js',
20 | '.jsx',
21 | '.ts',
22 | '.tsx', // Scripts
23 | '.woff',
24 | '.woff2',
25 | '.ttf',
26 | '.eot',
27 | '.otf', // Fonts
28 | '.mp3',
29 | '.mp4',
30 | '.avi',
31 | '.mov',
32 | '.wmv',
33 | '.flv',
34 | '.ogg',
35 | '.wav', // Media
36 | '.pdf',
37 | '.doc',
38 | '.docx',
39 | '.xls',
40 | '.xlsx',
41 | '.ppt',
42 | '.pptx', // Documents
43 | ];
44 |
45 | // Ad and analytics domain list
46 | const AD_ANALYTICS_DOMAINS = NETWORK_FILTERS.EXCLUDED_DOMAINS;
47 |
48 | interface NetworkCaptureStartToolParams {
49 | url?: string; // URL to navigate to or focus. If not provided, uses active tab.
50 | maxCaptureTime?: number; // Maximum capture time (milliseconds)
51 | inactivityTimeout?: number; // Inactivity timeout (milliseconds)
52 | includeStatic?: boolean; // Whether to include static resources
53 | }
54 |
55 | interface NetworkRequestInfo {
56 | requestId: string;
57 | url: string;
58 | method: string;
59 | type: string;
60 | requestTime: number;
61 | requestHeaders?: Record<string, string>;
62 | requestBody?: string;
63 | responseHeaders?: Record<string, string>;
64 | responseTime?: number;
65 | status?: number;
66 | statusText?: string;
67 | responseSize?: number;
68 | responseType?: string;
69 | responseBody?: string;
70 | errorText?: string;
71 | specificRequestHeaders?: Record<string, string>;
72 | specificResponseHeaders?: Record<string, string>;
73 | mimeType?: string; // Response MIME type
74 | }
75 |
76 | interface CaptureInfo {
77 | tabId: number;
78 | tabUrl: string;
79 | tabTitle: string;
80 | startTime: number;
81 | endTime?: number;
82 | requests: Record<string, NetworkRequestInfo>;
83 | maxCaptureTime: number;
84 | inactivityTimeout: number;
85 | includeStatic: boolean;
86 | limitReached?: boolean; // Whether request count limit is reached
87 | }
88 |
89 | /**
90 | * Network Capture Start Tool V2 - Uses Chrome webRequest API to start capturing network requests
91 | */
92 | class NetworkCaptureStartTool extends BaseBrowserToolExecutor {
93 | name = TOOL_NAMES.BROWSER.NETWORK_CAPTURE_START;
94 | public static instance: NetworkCaptureStartTool | null = null;
95 | public captureData: Map<number, CaptureInfo> = new Map(); // tabId -> capture data
96 | private captureTimers: Map<number, NodeJS.Timeout> = new Map(); // tabId -> max capture timer
97 | private inactivityTimers: Map<number, NodeJS.Timeout> = new Map(); // tabId -> inactivity timer
98 | private lastActivityTime: Map<number, number> = new Map(); // tabId -> timestamp of last activity
99 | private requestCounters: Map<number, number> = new Map(); // tabId -> count of captured requests
100 | public static MAX_REQUESTS_PER_CAPTURE = LIMITS.MAX_NETWORK_REQUESTS; // Maximum capture request count
101 | private listeners: { [key: string]: (details: any) => void } = {};
102 |
103 | // Static resource MIME types list (for filtering)
104 | private static STATIC_MIME_TYPES_TO_FILTER = [
105 | 'image/', // All image types
106 | 'font/', // All font types
107 | 'audio/', // All audio types
108 | 'video/', // All video types
109 | 'text/css',
110 | 'text/javascript',
111 | 'application/javascript',
112 | 'application/x-javascript',
113 | 'application/pdf',
114 | 'application/zip',
115 | 'application/octet-stream', // Usually for downloads or generic binary data
116 | ];
117 |
118 | // API response MIME types list (these types are usually not filtered)
119 | private static API_MIME_TYPES = [
120 | 'application/json',
121 | 'application/xml',
122 | 'text/xml',
123 | 'application/x-www-form-urlencoded',
124 | 'application/graphql',
125 | 'application/grpc',
126 | 'application/protobuf',
127 | 'application/x-protobuf',
128 | 'application/x-json',
129 | 'application/ld+json',
130 | 'application/problem+json',
131 | 'application/problem+xml',
132 | 'application/soap+xml',
133 | 'application/vnd.api+json',
134 | ];
135 |
136 | constructor() {
137 | super();
138 | if (NetworkCaptureStartTool.instance) {
139 | return NetworkCaptureStartTool.instance;
140 | }
141 | NetworkCaptureStartTool.instance = this;
142 |
143 | // Listen for tab close events
144 | chrome.tabs.onRemoved.addListener(this.handleTabRemoved.bind(this));
145 | // Listen for tab creation events
146 | chrome.tabs.onCreated.addListener(this.handleTabCreated.bind(this));
147 | }
148 |
149 | /**
150 | * Handle tab close events
151 | */
152 | private handleTabRemoved(tabId: number) {
153 | if (this.captureData.has(tabId)) {
154 | console.log(`NetworkCaptureV2: Tab ${tabId} was closed, cleaning up resources.`);
155 | this.cleanupCapture(tabId);
156 | }
157 | }
158 |
159 | /**
160 | * Handle tab creation events
161 | * If a new tab is opened from a tab being captured, automatically start capturing the new tab's requests
162 | */
163 | private async handleTabCreated(tab: chrome.tabs.Tab) {
164 | try {
165 | // Check if there are any tabs currently capturing
166 | if (this.captureData.size === 0) return;
167 |
168 | // Get the openerTabId of the new tab (ID of the tab that opened this tab)
169 | const openerTabId = tab.openerTabId;
170 | if (!openerTabId) return;
171 |
172 | // Check if the opener tab is currently capturing
173 | if (!this.captureData.has(openerTabId)) return;
174 |
175 | // Get the new tab's ID
176 | const newTabId = tab.id;
177 | if (!newTabId) return;
178 |
179 | console.log(
180 | `NetworkCaptureV2: New tab ${newTabId} created from capturing tab ${openerTabId}, will extend capture to it.`,
181 | );
182 |
183 | // Get the opener tab's capture settings
184 | const openerCaptureInfo = this.captureData.get(openerTabId);
185 | if (!openerCaptureInfo) return;
186 |
187 | // Wait a short time to ensure the tab is ready
188 | await new Promise((resolve) => setTimeout(resolve, 500));
189 |
190 | // Start capturing requests for the new tab
191 | await this.startCaptureForTab(newTabId, {
192 | maxCaptureTime: openerCaptureInfo.maxCaptureTime,
193 | inactivityTimeout: openerCaptureInfo.inactivityTimeout,
194 | includeStatic: openerCaptureInfo.includeStatic,
195 | });
196 |
197 | console.log(`NetworkCaptureV2: Successfully extended capture to new tab ${newTabId}`);
198 | } catch (error) {
199 | console.error(`NetworkCaptureV2: Error extending capture to new tab:`, error);
200 | }
201 | }
202 |
203 | /**
204 | * Determine whether a request should be filtered (based on URL)
205 | */
206 | private shouldFilterRequest(url: string, includeStatic: boolean): boolean {
207 | try {
208 | const urlObj = new URL(url);
209 |
210 | // Check if it's an ad or analytics domain
211 | if (AD_ANALYTICS_DOMAINS.some((domain) => urlObj.hostname.includes(domain))) {
212 | console.log(`NetworkCaptureV2: Filtering ad/analytics domain: ${urlObj.hostname}`);
213 | return true;
214 | }
215 |
216 | // If not including static resources, check extensions
217 | if (!includeStatic) {
218 | const path = urlObj.pathname.toLowerCase();
219 | if (STATIC_RESOURCE_EXTENSIONS.some((ext) => path.endsWith(ext))) {
220 | console.log(`NetworkCaptureV2: Filtering static resource by extension: ${path}`);
221 | return true;
222 | }
223 | }
224 |
225 | return false;
226 | } catch (e) {
227 | console.error('NetworkCaptureV2: Error filtering URL:', e);
228 | return false;
229 | }
230 | }
231 |
232 | /**
233 | * Filter based on MIME type
234 | */
235 | private shouldFilterByMimeType(mimeType: string, includeStatic: boolean): boolean {
236 | if (!mimeType) return false;
237 |
238 | // Always keep API response types
239 | if (NetworkCaptureStartTool.API_MIME_TYPES.some((type) => mimeType.startsWith(type))) {
240 | return false;
241 | }
242 |
243 | // If not including static resources, filter out static resource MIME types
244 | if (!includeStatic) {
245 | // Filter static resource MIME types
246 | if (
247 | NetworkCaptureStartTool.STATIC_MIME_TYPES_TO_FILTER.some((type) =>
248 | mimeType.startsWith(type),
249 | )
250 | ) {
251 | console.log(`NetworkCaptureV2: Filtering static resource by MIME type: ${mimeType}`);
252 | return true;
253 | }
254 |
255 | // Filter all MIME types starting with text/ (except those already in API_MIME_TYPES)
256 | if (mimeType.startsWith('text/')) {
257 | console.log(`NetworkCaptureV2: Filtering text response: ${mimeType}`);
258 | return true;
259 | }
260 | }
261 |
262 | return false;
263 | }
264 |
265 | /**
266 | * Update last activity time and reset inactivity timer
267 | */
268 | private updateLastActivityTime(tabId: number): void {
269 | const captureInfo = this.captureData.get(tabId);
270 | if (!captureInfo) return;
271 |
272 | this.lastActivityTime.set(tabId, Date.now());
273 |
274 | // Reset inactivity timer
275 | if (this.inactivityTimers.has(tabId)) {
276 | clearTimeout(this.inactivityTimers.get(tabId)!);
277 | }
278 |
279 | if (captureInfo.inactivityTimeout > 0) {
280 | this.inactivityTimers.set(
281 | tabId,
282 | setTimeout(() => this.checkInactivity(tabId), captureInfo.inactivityTimeout),
283 | );
284 | }
285 | }
286 |
287 | /**
288 | * Check for inactivity
289 | */
290 | private checkInactivity(tabId: number): void {
291 | const captureInfo = this.captureData.get(tabId);
292 | if (!captureInfo) return;
293 |
294 | const lastActivity = this.lastActivityTime.get(tabId) || captureInfo.startTime;
295 | const now = Date.now();
296 | const inactiveTime = now - lastActivity;
297 |
298 | if (inactiveTime >= captureInfo.inactivityTimeout) {
299 | console.log(
300 | `NetworkCaptureV2: No activity for ${inactiveTime}ms, stopping capture for tab ${tabId}`,
301 | );
302 | this.stopCaptureByInactivity(tabId);
303 | } else {
304 | // If inactivity time hasn't been reached yet, continue checking
305 | const remainingTime = captureInfo.inactivityTimeout - inactiveTime;
306 | this.inactivityTimers.set(
307 | tabId,
308 | setTimeout(() => this.checkInactivity(tabId), remainingTime),
309 | );
310 | }
311 | }
312 |
313 | /**
314 | * Stop capture due to inactivity
315 | */
316 | private async stopCaptureByInactivity(tabId: number): Promise<void> {
317 | const captureInfo = this.captureData.get(tabId);
318 | if (!captureInfo) return;
319 |
320 | console.log(`NetworkCaptureV2: Stopping capture due to inactivity for tab ${tabId}`);
321 | await this.stopCapture(tabId);
322 | }
323 |
324 | /**
325 | * Clean up capture resources
326 | */
327 | private cleanupCapture(tabId: number): void {
328 | // Clear timers
329 | if (this.captureTimers.has(tabId)) {
330 | clearTimeout(this.captureTimers.get(tabId)!);
331 | this.captureTimers.delete(tabId);
332 | }
333 |
334 | if (this.inactivityTimers.has(tabId)) {
335 | clearTimeout(this.inactivityTimers.get(tabId)!);
336 | this.inactivityTimers.delete(tabId);
337 | }
338 |
339 | // Remove data
340 | this.lastActivityTime.delete(tabId);
341 | this.captureData.delete(tabId);
342 | this.requestCounters.delete(tabId);
343 |
344 | console.log(`NetworkCaptureV2: Cleaned up all resources for tab ${tabId}`);
345 | }
346 |
347 | /**
348 | * Set up request listeners
349 | */
350 | private setupListeners(): void {
351 | // Before request is sent
352 | this.listeners.onBeforeRequest = (details: chrome.webRequest.WebRequestBodyDetails) => {
353 | const captureInfo = this.captureData.get(details.tabId);
354 | if (!captureInfo) return;
355 |
356 | if (this.shouldFilterRequest(details.url, captureInfo.includeStatic)) {
357 | return;
358 | }
359 |
360 | const currentCount = this.requestCounters.get(details.tabId) || 0;
361 | if (currentCount >= NetworkCaptureStartTool.MAX_REQUESTS_PER_CAPTURE) {
362 | console.log(
363 | `NetworkCaptureV2: Request limit (${NetworkCaptureStartTool.MAX_REQUESTS_PER_CAPTURE}) reached for tab ${details.tabId}, ignoring new request: ${details.url}`,
364 | );
365 | captureInfo.limitReached = true;
366 | return;
367 | }
368 |
369 | this.requestCounters.set(details.tabId, currentCount + 1);
370 | this.updateLastActivityTime(details.tabId);
371 |
372 | if (!captureInfo.requests[details.requestId]) {
373 | captureInfo.requests[details.requestId] = {
374 | requestId: details.requestId,
375 | url: details.url,
376 | method: details.method,
377 | type: details.type,
378 | requestTime: details.timeStamp,
379 | };
380 |
381 | if (details.requestBody) {
382 | const requestBody = this.processRequestBody(details.requestBody);
383 | if (requestBody) {
384 | captureInfo.requests[details.requestId].requestBody = requestBody;
385 | }
386 | }
387 |
388 | console.log(
389 | `NetworkCaptureV2: Captured request ${currentCount + 1}/${NetworkCaptureStartTool.MAX_REQUESTS_PER_CAPTURE} for tab ${details.tabId}: ${details.method} ${details.url}`,
390 | );
391 | }
392 | };
393 |
394 | // Send request headers
395 | this.listeners.onSendHeaders = (details: chrome.webRequest.WebRequestHeadersDetails) => {
396 | const captureInfo = this.captureData.get(details.tabId);
397 | if (!captureInfo || !captureInfo.requests[details.requestId]) return;
398 |
399 | if (details.requestHeaders) {
400 | const headers: Record<string, string> = {};
401 | details.requestHeaders.forEach((header) => {
402 | headers[header.name] = header.value || '';
403 | });
404 | captureInfo.requests[details.requestId].requestHeaders = headers;
405 | }
406 | };
407 |
408 | // Receive response headers
409 | this.listeners.onHeadersReceived = (details: chrome.webRequest.WebResponseHeadersDetails) => {
410 | const captureInfo = this.captureData.get(details.tabId);
411 | if (!captureInfo || !captureInfo.requests[details.requestId]) return;
412 |
413 | const requestInfo = captureInfo.requests[details.requestId];
414 |
415 | requestInfo.status = details.statusCode;
416 | requestInfo.statusText = details.statusLine;
417 | requestInfo.responseTime = details.timeStamp;
418 | requestInfo.mimeType = details.responseHeaders?.find(
419 | (h) => h.name.toLowerCase() === 'content-type',
420 | )?.value;
421 |
422 | // Secondary filtering based on MIME type
423 | if (
424 | requestInfo.mimeType &&
425 | this.shouldFilterByMimeType(requestInfo.mimeType, captureInfo.includeStatic)
426 | ) {
427 | delete captureInfo.requests[details.requestId];
428 |
429 | const currentCount = this.requestCounters.get(details.tabId) || 0;
430 | if (currentCount > 0) {
431 | this.requestCounters.set(details.tabId, currentCount - 1);
432 | }
433 |
434 | console.log(
435 | `NetworkCaptureV2: Filtered request by MIME type (${requestInfo.mimeType}): ${requestInfo.url}`,
436 | );
437 | return;
438 | }
439 |
440 | if (details.responseHeaders) {
441 | const headers: Record<string, string> = {};
442 | details.responseHeaders.forEach((header) => {
443 | headers[header.name] = header.value || '';
444 | });
445 | requestInfo.responseHeaders = headers;
446 | }
447 |
448 | this.updateLastActivityTime(details.tabId);
449 | };
450 |
451 | // Request completed
452 | this.listeners.onCompleted = (details: chrome.webRequest.WebResponseCacheDetails) => {
453 | const captureInfo = this.captureData.get(details.tabId);
454 | if (!captureInfo || !captureInfo.requests[details.requestId]) return;
455 |
456 | const requestInfo = captureInfo.requests[details.requestId];
457 | if ('responseSize' in details) {
458 | requestInfo.responseSize = details.fromCache ? 0 : (details as any).responseSize;
459 | }
460 |
461 | this.updateLastActivityTime(details.tabId);
462 | };
463 |
464 | // Request failed
465 | this.listeners.onErrorOccurred = (details: chrome.webRequest.WebResponseErrorDetails) => {
466 | const captureInfo = this.captureData.get(details.tabId);
467 | if (!captureInfo || !captureInfo.requests[details.requestId]) return;
468 |
469 | const requestInfo = captureInfo.requests[details.requestId];
470 | requestInfo.errorText = details.error;
471 |
472 | this.updateLastActivityTime(details.tabId);
473 | };
474 |
475 | // Register all listeners
476 | chrome.webRequest.onBeforeRequest.addListener(
477 | this.listeners.onBeforeRequest,
478 | { urls: ['<all_urls>'] },
479 | ['requestBody'],
480 | );
481 |
482 | chrome.webRequest.onSendHeaders.addListener(
483 | this.listeners.onSendHeaders,
484 | { urls: ['<all_urls>'] },
485 | ['requestHeaders'],
486 | );
487 |
488 | chrome.webRequest.onHeadersReceived.addListener(
489 | this.listeners.onHeadersReceived,
490 | { urls: ['<all_urls>'] },
491 | ['responseHeaders'],
492 | );
493 |
494 | chrome.webRequest.onCompleted.addListener(this.listeners.onCompleted, { urls: ['<all_urls>'] });
495 |
496 | chrome.webRequest.onErrorOccurred.addListener(this.listeners.onErrorOccurred, {
497 | urls: ['<all_urls>'],
498 | });
499 | }
500 |
501 | /**
502 | * Remove all request listeners
503 | * Only remove listeners when all tab captures have stopped
504 | */
505 | private removeListeners(): void {
506 | // Don't remove listeners if there are still tabs being captured
507 | if (this.captureData.size > 0) {
508 | console.log(
509 | `NetworkCaptureV2: Still capturing on ${this.captureData.size} tabs, not removing listeners.`,
510 | );
511 | return;
512 | }
513 |
514 | console.log(`NetworkCaptureV2: No more active captures, removing all listeners.`);
515 |
516 | if (this.listeners.onBeforeRequest) {
517 | chrome.webRequest.onBeforeRequest.removeListener(this.listeners.onBeforeRequest);
518 | }
519 |
520 | if (this.listeners.onSendHeaders) {
521 | chrome.webRequest.onSendHeaders.removeListener(this.listeners.onSendHeaders);
522 | }
523 |
524 | if (this.listeners.onHeadersReceived) {
525 | chrome.webRequest.onHeadersReceived.removeListener(this.listeners.onHeadersReceived);
526 | }
527 |
528 | if (this.listeners.onCompleted) {
529 | chrome.webRequest.onCompleted.removeListener(this.listeners.onCompleted);
530 | }
531 |
532 | if (this.listeners.onErrorOccurred) {
533 | chrome.webRequest.onErrorOccurred.removeListener(this.listeners.onErrorOccurred);
534 | }
535 |
536 | // Clear listener object
537 | this.listeners = {};
538 | }
539 |
540 | /**
541 | * Process request body data
542 | */
543 | private processRequestBody(requestBody: chrome.webRequest.WebRequestBody): string | undefined {
544 | if (requestBody.raw && requestBody.raw.length > 0) {
545 | return '[Binary data]';
546 | } else if (requestBody.formData) {
547 | return JSON.stringify(requestBody.formData);
548 | }
549 | return undefined;
550 | }
551 |
552 | /**
553 | * Start network request capture for specified tab
554 | * @param tabId Tab ID
555 | * @param options Capture options
556 | */
557 | private async startCaptureForTab(
558 | tabId: number,
559 | options: {
560 | maxCaptureTime: number;
561 | inactivityTimeout: number;
562 | includeStatic: boolean;
563 | },
564 | ): Promise<void> {
565 | const { maxCaptureTime, inactivityTimeout, includeStatic } = options;
566 |
567 | // If already capturing, stop first
568 | if (this.captureData.has(tabId)) {
569 | console.log(
570 | `NetworkCaptureV2: Already capturing on tab ${tabId}. Stopping previous session.`,
571 | );
572 | await this.stopCapture(tabId);
573 | }
574 |
575 | try {
576 | // Get tab information
577 | const tab = await chrome.tabs.get(tabId);
578 |
579 | // Initialize capture data
580 | this.captureData.set(tabId, {
581 | tabId: tabId,
582 | tabUrl: tab.url || '',
583 | tabTitle: tab.title || '',
584 | startTime: Date.now(),
585 | requests: {},
586 | maxCaptureTime,
587 | inactivityTimeout,
588 | includeStatic,
589 | limitReached: false,
590 | });
591 |
592 | // Initialize request counter
593 | this.requestCounters.set(tabId, 0);
594 |
595 | // Set up listeners
596 | this.setupListeners();
597 |
598 | // Update last activity time
599 | this.updateLastActivityTime(tabId);
600 |
601 | console.log(
602 | `NetworkCaptureV2: Started capture for tab ${tabId} (${tab.url}). Max requests: ${NetworkCaptureStartTool.MAX_REQUESTS_PER_CAPTURE}, Max time: ${maxCaptureTime}ms, Inactivity: ${inactivityTimeout}ms.`,
603 | );
604 |
605 | // Set maximum capture time
606 | if (maxCaptureTime > 0) {
607 | this.captureTimers.set(
608 | tabId,
609 | setTimeout(async () => {
610 | console.log(
611 | `NetworkCaptureV2: Max capture time (${maxCaptureTime}ms) reached for tab ${tabId}.`,
612 | );
613 | await this.stopCapture(tabId);
614 | }, maxCaptureTime),
615 | );
616 | }
617 | } catch (error: any) {
618 | console.error(`NetworkCaptureV2: Error starting capture for tab ${tabId}:`, error);
619 |
620 | // Clean up resources
621 | if (this.captureData.has(tabId)) {
622 | this.cleanupCapture(tabId);
623 | }
624 |
625 | throw error;
626 | }
627 | }
628 |
629 | /**
630 | * Stop capture
631 | * @param tabId Tab ID
632 | */
633 | public async stopCapture(
634 | tabId: number,
635 | ): Promise<{ success: boolean; message?: string; data?: any }> {
636 | const captureInfo = this.captureData.get(tabId);
637 | if (!captureInfo) {
638 | console.log(`NetworkCaptureV2: No capture in progress for tab ${tabId}`);
639 | return { success: false, message: `No capture in progress for tab ${tabId}` };
640 | }
641 |
642 | try {
643 | // Record end time
644 | captureInfo.endTime = Date.now();
645 |
646 | // Extract common request and response headers
647 | const requestsArray = Object.values(captureInfo.requests);
648 | const commonRequestHeaders = this.analyzeCommonHeaders(requestsArray, 'requestHeaders');
649 | const commonResponseHeaders = this.analyzeCommonHeaders(requestsArray, 'responseHeaders');
650 |
651 | // Process request data, remove common headers
652 | const processedRequests = requestsArray.map((req) => {
653 | const finalReq: NetworkRequestInfo = { ...req };
654 |
655 | if (finalReq.requestHeaders) {
656 | finalReq.specificRequestHeaders = this.filterOutCommonHeaders(
657 | finalReq.requestHeaders,
658 | commonRequestHeaders,
659 | );
660 | delete finalReq.requestHeaders;
661 | } else {
662 | finalReq.specificRequestHeaders = {};
663 | }
664 |
665 | if (finalReq.responseHeaders) {
666 | finalReq.specificResponseHeaders = this.filterOutCommonHeaders(
667 | finalReq.responseHeaders,
668 | commonResponseHeaders,
669 | );
670 | delete finalReq.responseHeaders;
671 | } else {
672 | finalReq.specificResponseHeaders = {};
673 | }
674 |
675 | return finalReq;
676 | });
677 |
678 | // Sort by time
679 | processedRequests.sort((a, b) => (a.requestTime || 0) - (b.requestTime || 0));
680 |
681 | // Remove listeners
682 | this.removeListeners();
683 |
684 | // Prepare result data
685 | const resultData = {
686 | captureStartTime: captureInfo.startTime,
687 | captureEndTime: captureInfo.endTime,
688 | totalDurationMs: captureInfo.endTime - captureInfo.startTime,
689 | settingsUsed: {
690 | maxCaptureTime: captureInfo.maxCaptureTime,
691 | inactivityTimeout: captureInfo.inactivityTimeout,
692 | includeStatic: captureInfo.includeStatic,
693 | maxRequests: NetworkCaptureStartTool.MAX_REQUESTS_PER_CAPTURE,
694 | },
695 | commonRequestHeaders,
696 | commonResponseHeaders,
697 | requests: processedRequests,
698 | requestCount: processedRequests.length,
699 | totalRequestsReceived: this.requestCounters.get(tabId) || 0,
700 | requestLimitReached: captureInfo.limitReached || false,
701 | tabUrl: captureInfo.tabUrl,
702 | tabTitle: captureInfo.tabTitle,
703 | };
704 |
705 | // Clean up resources
706 | this.cleanupCapture(tabId);
707 |
708 | return {
709 | success: true,
710 | data: resultData,
711 | };
712 | } catch (error: any) {
713 | console.error(`NetworkCaptureV2: Error stopping capture for tab ${tabId}:`, error);
714 |
715 | // Ensure resources are cleaned up
716 | this.cleanupCapture(tabId);
717 |
718 | return {
719 | success: false,
720 | message: `Error stopping capture: ${error.message || String(error)}`,
721 | };
722 | }
723 | }
724 |
725 | /**
726 | * Analyze common request or response headers
727 | */
728 | private analyzeCommonHeaders(
729 | requests: NetworkRequestInfo[],
730 | headerType: 'requestHeaders' | 'responseHeaders',
731 | ): Record<string, string> {
732 | if (!requests || requests.length === 0) return {};
733 |
734 | // Find headers that are included in all requests
735 | const commonHeaders: Record<string, string> = {};
736 | const firstRequestWithHeaders = requests.find(
737 | (req) => req[headerType] && Object.keys(req[headerType] || {}).length > 0,
738 | );
739 |
740 | if (!firstRequestWithHeaders || !firstRequestWithHeaders[headerType]) {
741 | return {};
742 | }
743 |
744 | // Get all headers from the first request
745 | const headers = firstRequestWithHeaders[headerType] as Record<string, string>;
746 | const headerNames = Object.keys(headers);
747 |
748 | // Check if each header exists in all requests with the same value
749 | for (const name of headerNames) {
750 | const value = headers[name];
751 | const isCommon = requests.every((req) => {
752 | const reqHeaders = req[headerType] as Record<string, string>;
753 | return reqHeaders && reqHeaders[name] === value;
754 | });
755 |
756 | if (isCommon) {
757 | commonHeaders[name] = value;
758 | }
759 | }
760 |
761 | return commonHeaders;
762 | }
763 |
764 | /**
765 | * Filter out common headers
766 | */
767 | private filterOutCommonHeaders(
768 | headers: Record<string, string>,
769 | commonHeaders: Record<string, string>,
770 | ): Record<string, string> {
771 | if (!headers || typeof headers !== 'object') return {};
772 |
773 | const specificHeaders: Record<string, string> = {};
774 | // Use Object.keys to avoid ESLint no-prototype-builtins warning
775 | Object.keys(headers).forEach((name) => {
776 | if (!(name in commonHeaders) || headers[name] !== commonHeaders[name]) {
777 | specificHeaders[name] = headers[name];
778 | }
779 | });
780 |
781 | return specificHeaders;
782 | }
783 |
784 | async execute(args: NetworkCaptureStartToolParams): Promise<ToolResult> {
785 | const {
786 | url: targetUrl,
787 | maxCaptureTime = 3 * 60 * 1000, // Default 3 minutes
788 | inactivityTimeout = 60 * 1000, // Default 1 minute of inactivity before auto-stop
789 | includeStatic = false, // Default: don't include static resources
790 | } = args;
791 |
792 | console.log(`NetworkCaptureStartTool: Executing with args:`, args);
793 |
794 | try {
795 | // Get current tab or create new tab
796 | let tabToOperateOn: chrome.tabs.Tab;
797 |
798 | if (targetUrl) {
799 | // Find tabs matching the URL
800 | const matchingTabs = await chrome.tabs.query({ url: targetUrl });
801 |
802 | if (matchingTabs.length > 0) {
803 | // Use existing tab
804 | tabToOperateOn = matchingTabs[0];
805 | console.log(`NetworkCaptureV2: Found existing tab with URL: ${targetUrl}`);
806 | } else {
807 | // Create new tab
808 | console.log(`NetworkCaptureV2: Creating new tab with URL: ${targetUrl}`);
809 | tabToOperateOn = await chrome.tabs.create({ url: targetUrl, active: true });
810 |
811 | // Wait for page to load
812 | await new Promise((resolve) => setTimeout(resolve, 1000));
813 | }
814 | } else {
815 | // Use current active tab
816 | const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
817 | if (!tabs[0]) {
818 | return createErrorResponse('No active tab found');
819 | }
820 | tabToOperateOn = tabs[0];
821 | }
822 |
823 | if (!tabToOperateOn?.id) {
824 | return createErrorResponse('Failed to identify or create a tab');
825 | }
826 |
827 | // Use startCaptureForTab method to start capture
828 | try {
829 | await this.startCaptureForTab(tabToOperateOn.id, {
830 | maxCaptureTime,
831 | inactivityTimeout,
832 | includeStatic,
833 | });
834 | } catch (error: any) {
835 | return createErrorResponse(
836 | `Failed to start capture for tab ${tabToOperateOn.id}: ${error.message || String(error)}`,
837 | );
838 | }
839 |
840 | return {
841 | content: [
842 | {
843 | type: 'text',
844 | text: JSON.stringify({
845 | success: true,
846 | message: 'Network capture V2 started successfully, waiting for stop command.',
847 | tabId: tabToOperateOn.id,
848 | url: tabToOperateOn.url,
849 | maxCaptureTime,
850 | inactivityTimeout,
851 | includeStatic,
852 | maxRequests: NetworkCaptureStartTool.MAX_REQUESTS_PER_CAPTURE,
853 | }),
854 | },
855 | ],
856 | isError: false,
857 | };
858 | } catch (error: any) {
859 | console.error('NetworkCaptureStartTool: Critical error:', error);
860 | return createErrorResponse(
861 | `Error in NetworkCaptureStartTool: ${error.message || String(error)}`,
862 | );
863 | }
864 | }
865 | }
866 |
867 | /**
868 | * Network capture stop tool V2 - Stop webRequest API capture and return results
869 | */
870 | class NetworkCaptureStopTool extends BaseBrowserToolExecutor {
871 | name = TOOL_NAMES.BROWSER.NETWORK_CAPTURE_STOP;
872 | public static instance: NetworkCaptureStopTool | null = null;
873 |
874 | constructor() {
875 | super();
876 | if (NetworkCaptureStopTool.instance) {
877 | return NetworkCaptureStopTool.instance;
878 | }
879 | NetworkCaptureStopTool.instance = this;
880 | }
881 |
882 | async execute(): Promise<ToolResult> {
883 | console.log(`NetworkCaptureStopTool: Executing`);
884 |
885 | try {
886 | const startTool = NetworkCaptureStartTool.instance;
887 |
888 | if (!startTool) {
889 | return createErrorResponse('Network capture V2 start tool instance not found');
890 | }
891 |
892 | // Get all tabs currently capturing
893 | const ongoingCaptures = Array.from(startTool.captureData.keys());
894 | console.log(
895 | `NetworkCaptureStopTool: Found ${ongoingCaptures.length} ongoing captures: ${ongoingCaptures.join(', ')}`,
896 | );
897 |
898 | if (ongoingCaptures.length === 0) {
899 | return createErrorResponse('No active network captures found in any tab.');
900 | }
901 |
902 | // Get current active tab
903 | const activeTabs = await chrome.tabs.query({ active: true, currentWindow: true });
904 | const activeTabId = activeTabs[0]?.id;
905 |
906 | // Determine the primary tab to stop
907 | let primaryTabId: number;
908 |
909 | if (activeTabId && startTool.captureData.has(activeTabId)) {
910 | // If current active tab is capturing, prioritize stopping it
911 | primaryTabId = activeTabId;
912 | console.log(
913 | `NetworkCaptureStopTool: Active tab ${activeTabId} is capturing, will stop it first.`,
914 | );
915 | } else if (ongoingCaptures.length === 1) {
916 | // If only one tab is capturing, stop it
917 | primaryTabId = ongoingCaptures[0];
918 | console.log(
919 | `NetworkCaptureStopTool: Only one tab ${primaryTabId} is capturing, stopping it.`,
920 | );
921 | } else {
922 | // If multiple tabs are capturing but current active tab is not among them, stop the first one
923 | primaryTabId = ongoingCaptures[0];
924 | console.log(
925 | `NetworkCaptureStopTool: Multiple tabs capturing, active tab not among them. Stopping tab ${primaryTabId} first.`,
926 | );
927 | }
928 |
929 | const stopResult = await startTool.stopCapture(primaryTabId);
930 |
931 | if (!stopResult.success) {
932 | return createErrorResponse(
933 | stopResult.message || `Failed to stop network capture for tab ${primaryTabId}`,
934 | );
935 | }
936 |
937 | // If multiple tabs are capturing, stop other tabs
938 | if (ongoingCaptures.length > 1) {
939 | const otherTabIds = ongoingCaptures.filter((id) => id !== primaryTabId);
940 | console.log(
941 | `NetworkCaptureStopTool: Stopping ${otherTabIds.length} additional captures: ${otherTabIds.join(', ')}`,
942 | );
943 |
944 | for (const tabId of otherTabIds) {
945 | try {
946 | await startTool.stopCapture(tabId);
947 | } catch (error) {
948 | console.error(`NetworkCaptureStopTool: Error stopping capture on tab ${tabId}:`, error);
949 | }
950 | }
951 | }
952 | return {
953 | content: [
954 | {
955 | type: 'text',
956 | text: JSON.stringify({
957 | success: true,
958 | message: `Capture complete. ${stopResult.data?.requestCount || 0} requests captured.`,
959 | tabId: primaryTabId,
960 | tabUrl: stopResult.data?.tabUrl || 'N/A',
961 | tabTitle: stopResult.data?.tabTitle || 'Unknown Tab',
962 | requestCount: stopResult.data?.requestCount || 0,
963 | commonRequestHeaders: stopResult.data?.commonRequestHeaders || {},
964 | commonResponseHeaders: stopResult.data?.commonResponseHeaders || {},
965 | requests: stopResult.data?.requests || [],
966 | captureStartTime: stopResult.data?.captureStartTime,
967 | captureEndTime: stopResult.data?.captureEndTime,
968 | totalDurationMs: stopResult.data?.totalDurationMs,
969 | settingsUsed: stopResult.data?.settingsUsed || {},
970 | totalRequestsReceived: stopResult.data?.totalRequestsReceived || 0,
971 | requestLimitReached: stopResult.data?.requestLimitReached || false,
972 | remainingCaptures: Array.from(startTool.captureData.keys()),
973 | }),
974 | },
975 | ],
976 | isError: false,
977 | };
978 | } catch (error: any) {
979 | console.error('NetworkCaptureStopTool: Critical error:', error);
980 | return createErrorResponse(
981 | `Error in NetworkCaptureStopTool: ${error.message || String(error)}`,
982 | );
983 | }
984 | }
985 | }
986 |
987 | export const networkCaptureStartTool = new NetworkCaptureStartTool();
988 | export const networkCaptureStopTool = new NetworkCaptureStopTool();
989 |
```
--------------------------------------------------------------------------------
/app/chrome-extension/entrypoints/background/tools/browser/network-capture-debugger.ts:
--------------------------------------------------------------------------------
```typescript
1 | import { createErrorResponse, ToolResult } from '@/common/tool-handler';
2 | import { BaseBrowserToolExecutor } from '../base-browser';
3 | import { TOOL_NAMES } from 'chrome-mcp-shared';
4 |
5 | interface NetworkDebuggerStartToolParams {
6 | url?: string; // URL to navigate to or focus. If not provided, uses active tab.
7 | maxCaptureTime?: number;
8 | inactivityTimeout?: number; // Inactivity timeout (milliseconds)
9 | includeStatic?: boolean; // if include static resources
10 | }
11 |
12 | // Network request object interface
13 | interface NetworkRequestInfo {
14 | requestId: string;
15 | url: string;
16 | method: string;
17 | requestHeaders?: Record<string, string>; // Will be removed after common headers extraction
18 | responseHeaders?: Record<string, string>; // Will be removed after common headers extraction
19 | requestTime?: number; // Timestamp of the request
20 | responseTime?: number; // Timestamp of the response
21 | type: string; // Resource type (e.g., Document, XHR, Fetch, Script, Stylesheet)
22 | status: string; // 'pending', 'complete', 'error'
23 | statusCode?: number;
24 | statusText?: string;
25 | requestBody?: string;
26 | responseBody?: string;
27 | base64Encoded?: boolean; // For responseBody
28 | encodedDataLength?: number; // Actual bytes received
29 | errorText?: string; // If loading failed
30 | canceled?: boolean; // If loading was canceled
31 | mimeType?: string;
32 | specificRequestHeaders?: Record<string, string>; // Headers unique to this request
33 | specificResponseHeaders?: Record<string, string>; // Headers unique to this response
34 | [key: string]: any; // Allow other properties from debugger events
35 | }
36 |
37 | // Static resource file extensions list
38 | const STATIC_RESOURCE_EXTENSIONS = [
39 | '.png',
40 | '.jpg',
41 | '.jpeg',
42 | '.gif',
43 | '.bmp',
44 | '.webp',
45 | '.svg',
46 | '.ico',
47 | '.cur',
48 | '.css',
49 | '.woff',
50 | '.woff2',
51 | '.ttf',
52 | '.eot',
53 | '.otf',
54 | '.mp3',
55 | '.mp4',
56 | '.avi',
57 | '.mov',
58 | '.webm',
59 | '.ogg',
60 | '.wav',
61 | '.pdf',
62 | '.zip',
63 | '.rar',
64 | '.7z',
65 | '.iso',
66 | '.dmg',
67 | '.js',
68 | '.jsx',
69 | '.ts',
70 | '.tsx',
71 | '.map', // Source maps
72 | ];
73 |
74 | // Ad and analytics domains list
75 | const AD_ANALYTICS_DOMAINS = [
76 | 'google-analytics.com',
77 | 'googletagmanager.com',
78 | 'analytics.google.com',
79 | 'doubleclick.net',
80 | 'googlesyndication.com',
81 | 'googleads.g.doubleclick.net',
82 | 'facebook.com/tr',
83 | 'connect.facebook.net',
84 | 'bat.bing.com',
85 | 'linkedin.com', // Often for tracking pixels/insights
86 | 'analytics.twitter.com',
87 | 'static.hotjar.com',
88 | 'script.hotjar.com',
89 | 'stats.g.doubleclick.net',
90 | 'amazon-adsystem.com',
91 | 'adservice.google.com',
92 | 'pagead2.googlesyndication.com',
93 | 'ads-twitter.com',
94 | 'ads.yahoo.com',
95 | 'adroll.com',
96 | 'adnxs.com',
97 | 'criteo.com',
98 | 'quantserve.com',
99 | 'scorecardresearch.com',
100 | 'segment.io',
101 | 'amplitude.com',
102 | 'mixpanel.com',
103 | 'optimizely.com',
104 | 'crazyegg.com',
105 | 'clicktale.net',
106 | 'mouseflow.com',
107 | 'fullstory.com',
108 | 'clarity.ms',
109 | ];
110 |
111 | const DEBUGGER_PROTOCOL_VERSION = '1.3';
112 | const MAX_RESPONSE_BODY_SIZE_BYTES = 1 * 1024 * 1024; // 1MB
113 | const DEFAULT_MAX_CAPTURE_TIME_MS = 3 * 60 * 1000; // 3 minutes
114 | const DEFAULT_INACTIVITY_TIMEOUT_MS = 60 * 1000; // 1 minute
115 |
116 | /**
117 | * Network capture start tool - uses Chrome Debugger API to start capturing network requests
118 | */
119 | class NetworkDebuggerStartTool extends BaseBrowserToolExecutor {
120 | name = TOOL_NAMES.BROWSER.NETWORK_DEBUGGER_START;
121 | private captureData: Map<number, any> = new Map(); // tabId -> capture data
122 | private captureTimers: Map<number, NodeJS.Timeout> = new Map(); // tabId -> max capture timer
123 | private inactivityTimers: Map<number, NodeJS.Timeout> = new Map(); // tabId -> inactivity timer
124 | private lastActivityTime: Map<number, number> = new Map(); // tabId -> timestamp of last network activity
125 | private pendingResponseBodies: Map<string, Promise<any>> = new Map(); // requestId -> promise for getResponseBody
126 | private requestCounters: Map<number, number> = new Map(); // tabId -> count of captured requests (after filtering)
127 | private static MAX_REQUESTS_PER_CAPTURE = 100; // Max requests to store to prevent memory issues
128 | public static instance: NetworkDebuggerStartTool | null = null;
129 |
130 | constructor() {
131 | super();
132 | if (NetworkDebuggerStartTool.instance) {
133 | return NetworkDebuggerStartTool.instance;
134 | }
135 | NetworkDebuggerStartTool.instance = this;
136 |
137 | chrome.debugger.onEvent.addListener(this.handleDebuggerEvent.bind(this));
138 | chrome.debugger.onDetach.addListener(this.handleDebuggerDetach.bind(this));
139 | chrome.tabs.onRemoved.addListener(this.handleTabRemoved.bind(this));
140 | chrome.tabs.onCreated.addListener(this.handleTabCreated.bind(this));
141 | }
142 |
143 | private handleTabRemoved(tabId: number) {
144 | if (this.captureData.has(tabId)) {
145 | console.log(`NetworkDebuggerStartTool: Tab ${tabId} was closed, cleaning up resources.`);
146 | this.cleanupCapture(tabId);
147 | }
148 | }
149 |
150 | /**
151 | * Handle tab creation events
152 | * If a new tab is opened from a tab that is currently capturing, automatically start capturing the new tab's requests
153 | */
154 | private async handleTabCreated(tab: chrome.tabs.Tab) {
155 | try {
156 | // Check if there are any tabs currently capturing
157 | if (this.captureData.size === 0) return;
158 |
159 | // Get the openerTabId of the new tab (ID of the tab that opened this tab)
160 | const openerTabId = tab.openerTabId;
161 | if (!openerTabId) return;
162 |
163 | // Check if the opener tab is currently capturing
164 | if (!this.captureData.has(openerTabId)) return;
165 |
166 | // Get the new tab's ID
167 | const newTabId = tab.id;
168 | if (!newTabId) return;
169 |
170 | console.log(
171 | `NetworkDebuggerStartTool: New tab ${newTabId} created from capturing tab ${openerTabId}, will extend capture to it.`,
172 | );
173 |
174 | // Get the opener tab's capture settings
175 | const openerCaptureInfo = this.captureData.get(openerTabId);
176 | if (!openerCaptureInfo) return;
177 |
178 | // Wait a short time to ensure the tab is ready
179 | await new Promise((resolve) => setTimeout(resolve, 500));
180 |
181 | // Start capturing requests for the new tab
182 | await this.startCaptureForTab(newTabId, {
183 | maxCaptureTime: openerCaptureInfo.maxCaptureTime,
184 | inactivityTimeout: openerCaptureInfo.inactivityTimeout,
185 | includeStatic: openerCaptureInfo.includeStatic,
186 | });
187 |
188 | console.log(`NetworkDebuggerStartTool: Successfully extended capture to new tab ${newTabId}`);
189 | } catch (error) {
190 | console.error(`NetworkDebuggerStartTool: Error extending capture to new tab:`, error);
191 | }
192 | }
193 |
194 | /**
195 | * Start network request capture for specified tab
196 | * @param tabId Tab ID
197 | * @param options Capture options
198 | */
199 | private async startCaptureForTab(
200 | tabId: number,
201 | options: {
202 | maxCaptureTime: number;
203 | inactivityTimeout: number;
204 | includeStatic: boolean;
205 | },
206 | ): Promise<void> {
207 | const { maxCaptureTime, inactivityTimeout, includeStatic } = options;
208 |
209 | // If already capturing, stop first
210 | if (this.captureData.has(tabId)) {
211 | console.log(
212 | `NetworkDebuggerStartTool: Already capturing on tab ${tabId}. Stopping previous session.`,
213 | );
214 | await this.stopCapture(tabId);
215 | }
216 |
217 | try {
218 | // Get tab information
219 | const tab = await chrome.tabs.get(tabId);
220 |
221 | // Check if debugger is already attached
222 | const targets = await chrome.debugger.getTargets();
223 | const existingTarget = targets.find(
224 | (t) => t.tabId === tabId && t.attached && t.type === 'page',
225 | );
226 | if (existingTarget && !existingTarget.extensionId) {
227 | throw new Error(
228 | `Debugger is already attached to tab ${tabId} by another tool (e.g., DevTools).`,
229 | );
230 | }
231 |
232 | // Attach debugger
233 | try {
234 | await chrome.debugger.attach({ tabId }, DEBUGGER_PROTOCOL_VERSION);
235 | } catch (error: any) {
236 | if (error.message?.includes('Cannot attach to the target with an attached client')) {
237 | throw new Error(
238 | `Debugger is already attached to tab ${tabId}. This might be DevTools or another extension.`,
239 | );
240 | }
241 | throw error;
242 | }
243 |
244 | // Enable network tracking
245 | try {
246 | await chrome.debugger.sendCommand({ tabId }, 'Network.enable');
247 | } catch (error: any) {
248 | await chrome.debugger
249 | .detach({ tabId })
250 | .catch((e) => console.warn('Error detaching after failed enable:', e));
251 | throw error;
252 | }
253 |
254 | // Initialize capture data
255 | this.captureData.set(tabId, {
256 | startTime: Date.now(),
257 | tabUrl: tab.url,
258 | tabTitle: tab.title,
259 | maxCaptureTime,
260 | inactivityTimeout,
261 | includeStatic,
262 | requests: {},
263 | limitReached: false,
264 | });
265 |
266 | // Initialize request counter
267 | this.requestCounters.set(tabId, 0);
268 |
269 | // Update last activity time
270 | this.updateLastActivityTime(tabId);
271 |
272 | console.log(
273 | `NetworkDebuggerStartTool: Started capture for tab ${tabId} (${tab.url}). Max requests: ${NetworkDebuggerStartTool.MAX_REQUESTS_PER_CAPTURE}, Max time: ${maxCaptureTime}ms, Inactivity: ${inactivityTimeout}ms.`,
274 | );
275 |
276 | // Set maximum capture time
277 | if (maxCaptureTime > 0) {
278 | this.captureTimers.set(
279 | tabId,
280 | setTimeout(async () => {
281 | console.log(
282 | `NetworkDebuggerStartTool: Max capture time (${maxCaptureTime}ms) reached for tab ${tabId}.`,
283 | );
284 | await this.stopCapture(tabId, true); // Auto-stop due to max time
285 | }, maxCaptureTime),
286 | );
287 | }
288 | } catch (error: any) {
289 | console.error(`NetworkDebuggerStartTool: Error starting capture for tab ${tabId}:`, error);
290 |
291 | // Clean up resources
292 | if (this.captureData.has(tabId)) {
293 | await chrome.debugger
294 | .detach({ tabId })
295 | .catch((e) => console.warn('Cleanup detach error:', e));
296 | this.cleanupCapture(tabId);
297 | }
298 |
299 | throw error;
300 | }
301 | }
302 |
303 | private handleDebuggerEvent(source: chrome.debugger.Debuggee, method: string, params?: any) {
304 | if (!source.tabId) return;
305 |
306 | const tabId = source.tabId;
307 | const captureInfo = this.captureData.get(tabId);
308 |
309 | if (!captureInfo) return; // Not capturing for this tab
310 |
311 | // Update last activity time for any relevant network event
312 | this.updateLastActivityTime(tabId);
313 |
314 | switch (method) {
315 | case 'Network.requestWillBeSent':
316 | this.handleRequestWillBeSent(tabId, params);
317 | break;
318 | case 'Network.responseReceived':
319 | this.handleResponseReceived(tabId, params);
320 | break;
321 | case 'Network.loadingFinished':
322 | this.handleLoadingFinished(tabId, params);
323 | break;
324 | case 'Network.loadingFailed':
325 | this.handleLoadingFailed(tabId, params);
326 | break;
327 | }
328 | }
329 |
330 | private handleDebuggerDetach(source: chrome.debugger.Debuggee, reason: string) {
331 | if (source.tabId && this.captureData.has(source.tabId)) {
332 | console.log(
333 | `NetworkDebuggerStartTool: Debugger detached from tab ${source.tabId}, reason: ${reason}. Cleaning up.`,
334 | );
335 | // Potentially inform the user or log the result if the detachment was unexpected
336 | this.cleanupCapture(source.tabId); // Ensure cleanup happens
337 | }
338 | }
339 |
340 | private updateLastActivityTime(tabId: number) {
341 | this.lastActivityTime.set(tabId, Date.now());
342 | const captureInfo = this.captureData.get(tabId);
343 |
344 | if (captureInfo && captureInfo.inactivityTimeout > 0) {
345 | if (this.inactivityTimers.has(tabId)) {
346 | clearTimeout(this.inactivityTimers.get(tabId)!);
347 | }
348 | this.inactivityTimers.set(
349 | tabId,
350 | setTimeout(() => this.checkInactivity(tabId), captureInfo.inactivityTimeout),
351 | );
352 | }
353 | }
354 |
355 | private checkInactivity(tabId: number) {
356 | const captureInfo = this.captureData.get(tabId);
357 | if (!captureInfo) return;
358 |
359 | const lastActivity = this.lastActivityTime.get(tabId) || captureInfo.startTime; // Use startTime if no activity yet
360 | const now = Date.now();
361 | const inactiveTime = now - lastActivity;
362 |
363 | if (inactiveTime >= captureInfo.inactivityTimeout) {
364 | console.log(
365 | `NetworkDebuggerStartTool: No activity for ${inactiveTime}ms (threshold: ${captureInfo.inactivityTimeout}ms), stopping capture for tab ${tabId}`,
366 | );
367 | this.stopCaptureByInactivity(tabId);
368 | } else {
369 | // Reschedule check for the remaining time, this handles system sleep or other interruptions
370 | const remainingTime = Math.max(0, captureInfo.inactivityTimeout - inactiveTime);
371 | this.inactivityTimers.set(
372 | tabId,
373 | setTimeout(() => this.checkInactivity(tabId), remainingTime),
374 | );
375 | }
376 | }
377 |
378 | private async stopCaptureByInactivity(tabId: number) {
379 | const captureInfo = this.captureData.get(tabId);
380 | if (!captureInfo) return;
381 |
382 | console.log(`NetworkDebuggerStartTool: Stopping capture due to inactivity for tab ${tabId}.`);
383 | // Potentially, we might want to notify the client/user that this happened.
384 | // For now, just stop and make the results available if StopTool is called.
385 | await this.stopCapture(tabId, true); // Pass a flag indicating it's an auto-stop
386 | }
387 |
388 | // Static resource MIME types list (used when includeStatic is false)
389 | private static STATIC_MIME_TYPES_TO_FILTER = [
390 | 'image/', // all image types (image/png, image/jpeg, etc.)
391 | 'font/', // all font types (font/woff, font/ttf, etc.)
392 | 'audio/', // all audio types
393 | 'video/', // all video types
394 | 'text/css',
395 | // Note: text/javascript, application/javascript etc. are often filtered by extension.
396 | // If script files need to be filtered by MIME type as well, add them here.
397 | // 'application/javascript',
398 | // 'application/x-javascript',
399 | 'application/pdf',
400 | 'application/zip',
401 | 'application/octet-stream', // Often used for downloads or generic binary data
402 | ];
403 |
404 | // API-like response MIME types (these are generally NOT filtered, and we might want their bodies)
405 | private static API_MIME_TYPES = [
406 | 'application/json',
407 | 'application/xml',
408 | 'text/xml',
409 | // 'text/json' is not standard, but sometimes seen. 'application/json' is preferred.
410 | 'text/plain', // Can be API response, handle with care. Often captured.
411 | 'application/x-www-form-urlencoded', // Form submissions, can be API calls
412 | 'application/graphql',
413 | // Add other common API types if needed
414 | ];
415 |
416 | private shouldFilterRequestByUrl(url: string): boolean {
417 | try {
418 | const urlObj = new URL(url);
419 | // Filter ad/analytics domains
420 | if (AD_ANALYTICS_DOMAINS.some((domain) => urlObj.hostname.includes(domain))) {
421 | // console.log(`NetworkDebuggerStartTool: Filtering ad/analytics domain: ${urlObj.hostname}`);
422 | return true;
423 | }
424 | return false;
425 | } catch (e) {
426 | // Invalid URL? Log and don't filter.
427 | console.error(`NetworkDebuggerStartTool: Error parsing URL for filtering: ${url}`, e);
428 | return false;
429 | }
430 | }
431 |
432 | private shouldFilterRequestByExtension(url: string, includeStatic: boolean): boolean {
433 | if (includeStatic) return false; // If including static, don't filter by extension
434 |
435 | try {
436 | const urlObj = new URL(url);
437 | const path = urlObj.pathname.toLowerCase();
438 | if (STATIC_RESOURCE_EXTENSIONS.some((ext) => path.endsWith(ext))) {
439 | // console.log(`NetworkDebuggerStartTool: Filtering static resource by extension: ${path}`);
440 | return true;
441 | }
442 | return false;
443 | } catch (e) {
444 | console.error(
445 | `NetworkDebuggerStartTool: Error parsing URL for extension filtering: ${url}`,
446 | e,
447 | );
448 | return false;
449 | }
450 | }
451 |
452 | // MIME type-based filtering, called after response is received
453 | private shouldFilterByMimeType(mimeType: string, includeStatic: boolean): boolean {
454 | if (!mimeType) return false; // No MIME type, don't make a decision based on it here
455 |
456 | // If API_MIME_TYPES contains this mimeType, we explicitly DON'T want to filter it by MIME.
457 | if (NetworkDebuggerStartTool.API_MIME_TYPES.some((apiMime) => mimeType.startsWith(apiMime))) {
458 | return false;
459 | }
460 |
461 | // If we are NOT including static files, then check against the list of static MIME types.
462 | if (!includeStatic) {
463 | if (
464 | NetworkDebuggerStartTool.STATIC_MIME_TYPES_TO_FILTER.some((staticMime) =>
465 | mimeType.startsWith(staticMime),
466 | )
467 | ) {
468 | // console.log(`NetworkDebuggerStartTool: Filtering static resource by MIME type: ${mimeType}`);
469 | return true;
470 | }
471 | }
472 |
473 | // Default: don't filter by MIME type if no other rule matched
474 | return false;
475 | }
476 |
477 | private handleRequestWillBeSent(tabId: number, params: any) {
478 | const captureInfo = this.captureData.get(tabId);
479 | if (!captureInfo) return;
480 |
481 | const { requestId, request, timestamp, type, loaderId, frameId } = params;
482 |
483 | // Initial filtering by URL (ads, analytics) and extension (if !includeStatic)
484 | if (
485 | this.shouldFilterRequestByUrl(request.url) ||
486 | this.shouldFilterRequestByExtension(request.url, captureInfo.includeStatic)
487 | ) {
488 | return;
489 | }
490 |
491 | const currentCount = this.requestCounters.get(tabId) || 0;
492 | if (currentCount >= NetworkDebuggerStartTool.MAX_REQUESTS_PER_CAPTURE) {
493 | // console.log(`NetworkDebuggerStartTool: Request limit (${NetworkDebuggerStartTool.MAX_REQUESTS_PER_CAPTURE}) reached for tab ${tabId}. Ignoring: ${request.url}`);
494 | captureInfo.limitReached = true; // Mark that limit was hit
495 | return;
496 | }
497 |
498 | // Store initial request info
499 | // Ensure we don't overwrite if a redirect (same requestId) occurred, though usually loaderId changes
500 | if (!captureInfo.requests[requestId]) {
501 | // Or check based on loaderId as well if needed
502 | captureInfo.requests[requestId] = {
503 | requestId,
504 | url: request.url,
505 | method: request.method,
506 | requestHeaders: request.headers, // Temporary, will be processed
507 | requestTime: timestamp * 1000, // Convert seconds to milliseconds
508 | type: type || 'Other',
509 | status: 'pending', // Initial status
510 | loaderId, // Useful for tracking redirects
511 | frameId, // Useful for context
512 | };
513 |
514 | if (request.postData) {
515 | captureInfo.requests[requestId].requestBody = request.postData;
516 | }
517 | // console.log(`NetworkDebuggerStartTool: Captured request for tab ${tabId}: ${request.method} ${request.url}`);
518 | } else {
519 | // This could be a redirect. Update URL and other relevant fields.
520 | // Chrome often issues a new `requestWillBeSent` for redirects with the same `requestId` but a new `loaderId`.
521 | // console.log(`NetworkDebuggerStartTool: Request ${requestId} updated (likely redirect) for tab ${tabId} to URL: ${request.url}`);
522 | const existingRequest = captureInfo.requests[requestId];
523 | existingRequest.url = request.url; // Update URL due to redirect
524 | existingRequest.requestTime = timestamp * 1000; // Update time for the redirected request
525 | if (request.headers) existingRequest.requestHeaders = request.headers;
526 | if (request.postData) existingRequest.requestBody = request.postData;
527 | else delete existingRequest.requestBody;
528 | }
529 | }
530 |
531 | private handleResponseReceived(tabId: number, params: any) {
532 | const captureInfo = this.captureData.get(tabId);
533 | if (!captureInfo) return;
534 |
535 | const { requestId, response, timestamp, type } = params; // type here is resource type
536 | const requestInfo: NetworkRequestInfo = captureInfo.requests[requestId];
537 |
538 | if (!requestInfo) {
539 | // console.warn(`NetworkDebuggerStartTool: Received response for unknown requestId ${requestId} on tab ${tabId}`);
540 | return;
541 | }
542 |
543 | // Secondary filtering based on MIME type, now that we have it
544 | if (this.shouldFilterByMimeType(response.mimeType, captureInfo.includeStatic)) {
545 | // console.log(`NetworkDebuggerStartTool: Filtering request by MIME type (${response.mimeType}): ${requestInfo.url}`);
546 | delete captureInfo.requests[requestId]; // Remove from captured data
547 | // Note: We don't decrement requestCounter here as it's meant to track how many *potential* requests were processed up to MAX_REQUESTS.
548 | // Or, if MAX_REQUESTS is strictly for *stored* requests, then decrement. For now, let's assume it's for stored.
549 | // const currentCount = this.requestCounters.get(tabId) || 0;
550 | // if (currentCount > 0) this.requestCounters.set(tabId, currentCount -1);
551 | return;
552 | }
553 |
554 | // If not filtered by MIME, then increment actual stored request counter
555 | const currentStoredCount = Object.keys(captureInfo.requests).length; // A bit inefficient but accurate
556 | this.requestCounters.set(tabId, currentStoredCount);
557 |
558 | requestInfo.status = response.status === 0 ? 'pending' : 'complete'; // status 0 can mean pending or blocked
559 | requestInfo.statusCode = response.status;
560 | requestInfo.statusText = response.statusText;
561 | requestInfo.responseHeaders = response.headers; // Temporary
562 | requestInfo.mimeType = response.mimeType;
563 | requestInfo.responseTime = timestamp * 1000; // Convert seconds to milliseconds
564 | if (type) requestInfo.type = type; // Update resource type if provided by this event
565 |
566 | // console.log(`NetworkDebuggerStartTool: Received response for ${requestId} on tab ${tabId}: ${response.status}`);
567 | }
568 |
569 | private async handleLoadingFinished(tabId: number, params: any) {
570 | const captureInfo = this.captureData.get(tabId);
571 | if (!captureInfo) return;
572 |
573 | const { requestId, encodedDataLength } = params;
574 | const requestInfo: NetworkRequestInfo = captureInfo.requests[requestId];
575 |
576 | if (!requestInfo) {
577 | // console.warn(`NetworkDebuggerStartTool: LoadingFinished for unknown requestId ${requestId} on tab ${tabId}`);
578 | return;
579 | }
580 |
581 | requestInfo.encodedDataLength = encodedDataLength;
582 | if (requestInfo.status === 'pending') requestInfo.status = 'complete'; // Mark as complete if not already
583 | // requestInfo.responseTime is usually set by responseReceived, but this timestamp is later.
584 | // timestamp here is when the resource finished loading. Could be useful for duration calculation.
585 |
586 | if (this.shouldCaptureResponseBody(requestInfo)) {
587 | try {
588 | // console.log(`NetworkDebuggerStartTool: Attempting to get response body for ${requestId} (${requestInfo.url})`);
589 | const responseBodyData = await this.getResponseBody(tabId, requestId);
590 | if (responseBodyData) {
591 | if (
592 | responseBodyData.body &&
593 | responseBodyData.body.length > MAX_RESPONSE_BODY_SIZE_BYTES
594 | ) {
595 | requestInfo.responseBody =
596 | responseBodyData.body.substring(0, MAX_RESPONSE_BODY_SIZE_BYTES) +
597 | `\n\n... [Response truncated, total size: ${responseBodyData.body.length} bytes] ...`;
598 | } else {
599 | requestInfo.responseBody = responseBodyData.body;
600 | }
601 | requestInfo.base64Encoded = responseBodyData.base64Encoded;
602 | // console.log(`NetworkDebuggerStartTool: Successfully got response body for ${requestId}, size: ${requestInfo.responseBody?.length || 0} bytes`);
603 | }
604 | } catch (error) {
605 | // console.warn(`NetworkDebuggerStartTool: Failed to get response body for ${requestId}:`, error);
606 | requestInfo.errorText =
607 | (requestInfo.errorText || '') +
608 | ` Failed to get body: ${error instanceof Error ? error.message : String(error)}`;
609 | }
610 | }
611 | }
612 |
613 | private shouldCaptureResponseBody(requestInfo: NetworkRequestInfo): boolean {
614 | const mimeType = requestInfo.mimeType || '';
615 |
616 | // Prioritize API MIME types for body capture
617 | if (NetworkDebuggerStartTool.API_MIME_TYPES.some((type) => mimeType.startsWith(type))) {
618 | return true;
619 | }
620 |
621 | // Heuristics for other potential API calls not perfectly matching MIME types
622 | const url = requestInfo.url.toLowerCase();
623 | if (
624 | /\/(api|service|rest|graphql|query|data|rpc|v[0-9]+)\//i.test(url) ||
625 | url.includes('.json') ||
626 | url.includes('json=') ||
627 | url.includes('format=json')
628 | ) {
629 | // If it looks like an API call by URL structure, try to get body,
630 | // unless it's a known non-API MIME type that slipped through (e.g. a script from a /api/ path)
631 | if (
632 | mimeType &&
633 | NetworkDebuggerStartTool.STATIC_MIME_TYPES_TO_FILTER.some((staticMime) =>
634 | mimeType.startsWith(staticMime),
635 | )
636 | ) {
637 | return false; // e.g. a CSS file served from an /api/ path
638 | }
639 | return true;
640 | }
641 |
642 | return false;
643 | }
644 |
645 | private handleLoadingFailed(tabId: number, params: any) {
646 | const captureInfo = this.captureData.get(tabId);
647 | if (!captureInfo) return;
648 |
649 | const { requestId, errorText, canceled, type } = params;
650 | const requestInfo: NetworkRequestInfo = captureInfo.requests[requestId];
651 |
652 | if (!requestInfo) {
653 | // console.warn(`NetworkDebuggerStartTool: LoadingFailed for unknown requestId ${requestId} on tab ${tabId}`);
654 | return;
655 | }
656 |
657 | requestInfo.status = 'error';
658 | requestInfo.errorText = errorText;
659 | requestInfo.canceled = canceled;
660 | if (type) requestInfo.type = type;
661 | // timestamp here is when loading failed.
662 | // console.log(`NetworkDebuggerStartTool: Loading failed for ${requestId} on tab ${tabId}: ${errorText}`);
663 | }
664 |
665 | private async getResponseBody(
666 | tabId: number,
667 | requestId: string,
668 | ): Promise<{ body: string; base64Encoded: boolean } | null> {
669 | const pendingKey = `${tabId}_${requestId}`;
670 | if (this.pendingResponseBodies.has(pendingKey)) {
671 | return this.pendingResponseBodies.get(pendingKey)!; // Return existing promise
672 | }
673 |
674 | const responseBodyPromise = (async () => {
675 | try {
676 | // Check if debugger is still attached to this tabId
677 | const attachedTabs = await chrome.debugger.getTargets();
678 | if (!attachedTabs.some((target) => target.tabId === tabId && target.attached)) {
679 | // console.warn(`NetworkDebuggerStartTool: Debugger not attached to tab ${tabId} when trying to get response body for ${requestId}.`);
680 | throw new Error(`Debugger not attached to tab ${tabId}`);
681 | }
682 |
683 | const result = (await chrome.debugger.sendCommand({ tabId }, 'Network.getResponseBody', {
684 | requestId,
685 | })) as { body: string; base64Encoded: boolean };
686 | return result;
687 | } finally {
688 | this.pendingResponseBodies.delete(pendingKey); // Clean up after promise resolves or rejects
689 | }
690 | })();
691 |
692 | this.pendingResponseBodies.set(pendingKey, responseBodyPromise);
693 | return responseBodyPromise;
694 | }
695 |
696 | private cleanupCapture(tabId: number) {
697 | if (this.captureTimers.has(tabId)) {
698 | clearTimeout(this.captureTimers.get(tabId)!);
699 | this.captureTimers.delete(tabId);
700 | }
701 | if (this.inactivityTimers.has(tabId)) {
702 | clearTimeout(this.inactivityTimers.get(tabId)!);
703 | this.inactivityTimers.delete(tabId);
704 | }
705 |
706 | this.lastActivityTime.delete(tabId);
707 | this.captureData.delete(tabId);
708 | this.requestCounters.delete(tabId);
709 |
710 | // Abort pending getResponseBody calls for this tab
711 | // Note: Promises themselves cannot be "aborted" externally in a standard way once created.
712 | // We can delete them from the map, so new calls won't use them,
713 | // and the original promise will eventually resolve or reject.
714 | const keysToDelete: string[] = [];
715 | this.pendingResponseBodies.forEach((_, key) => {
716 | if (key.startsWith(`${tabId}_`)) {
717 | keysToDelete.push(key);
718 | }
719 | });
720 | keysToDelete.forEach((key) => this.pendingResponseBodies.delete(key));
721 |
722 | console.log(`NetworkDebuggerStartTool: Cleaned up resources for tab ${tabId}.`);
723 | }
724 |
725 | // isAutoStop is true if stop was triggered by timeout, false if by user/explicit call
726 | async stopCapture(tabId: number, isAutoStop: boolean = false): Promise<any> {
727 | const captureInfo = this.captureData.get(tabId);
728 | if (!captureInfo) {
729 | return { success: false, message: 'No capture in progress for this tab.' };
730 | }
731 |
732 | console.log(
733 | `NetworkDebuggerStartTool: Stopping capture for tab ${tabId}. Auto-stop: ${isAutoStop}`,
734 | );
735 |
736 | try {
737 | // Detach debugger first to prevent further events.
738 | // Check if debugger is attached before trying to send commands or detach
739 | const attachedTargets = await chrome.debugger.getTargets();
740 | const isAttached = attachedTargets.some(
741 | (target) => target.tabId === tabId && target.attached,
742 | );
743 |
744 | if (isAttached) {
745 | try {
746 | await chrome.debugger.sendCommand({ tabId }, 'Network.disable');
747 | } catch (e) {
748 | console.warn(
749 | `NetworkDebuggerStartTool: Error disabling network for tab ${tabId} (possibly already detached):`,
750 | e,
751 | );
752 | }
753 | try {
754 | await chrome.debugger.detach({ tabId });
755 | } catch (e) {
756 | console.warn(
757 | `NetworkDebuggerStartTool: Error detaching debugger for tab ${tabId} (possibly already detached):`,
758 | e,
759 | );
760 | }
761 | } else {
762 | console.log(
763 | `NetworkDebuggerStartTool: Debugger was not attached to tab ${tabId} at stopCapture.`,
764 | );
765 | }
766 | } catch (error: any) {
767 | // Catch errors from getTargets or general logic
768 | console.error(
769 | 'NetworkDebuggerStartTool: Error during debugger interaction in stopCapture:',
770 | error,
771 | );
772 | // Proceed to cleanup and data formatting
773 | }
774 |
775 | // Process data even if detach/disable failed, as some data might have been captured.
776 | const allRequests = Object.values(captureInfo.requests) as NetworkRequestInfo[];
777 | const commonRequestHeaders = this.analyzeCommonHeaders(allRequests, 'requestHeaders');
778 | const commonResponseHeaders = this.analyzeCommonHeaders(allRequests, 'responseHeaders');
779 |
780 | const processedRequests = allRequests.map((req) => {
781 | const finalReq: Partial<NetworkRequestInfo> &
782 | Pick<NetworkRequestInfo, 'requestId' | 'url' | 'method' | 'type' | 'status'> = { ...req };
783 |
784 | if (finalReq.requestHeaders) {
785 | finalReq.specificRequestHeaders = this.filterOutCommonHeaders(
786 | finalReq.requestHeaders,
787 | commonRequestHeaders,
788 | );
789 | delete finalReq.requestHeaders; // Remove original full headers
790 | } else {
791 | finalReq.specificRequestHeaders = {};
792 | }
793 |
794 | if (finalReq.responseHeaders) {
795 | finalReq.specificResponseHeaders = this.filterOutCommonHeaders(
796 | finalReq.responseHeaders,
797 | commonResponseHeaders,
798 | );
799 | delete finalReq.responseHeaders; // Remove original full headers
800 | } else {
801 | finalReq.specificResponseHeaders = {};
802 | }
803 | return finalReq as NetworkRequestInfo; // Cast back to full type
804 | });
805 |
806 | // Sort requests by requestTime
807 | processedRequests.sort((a, b) => (a.requestTime || 0) - (b.requestTime || 0));
808 |
809 | const resultData = {
810 | captureStartTime: captureInfo.startTime,
811 | captureEndTime: Date.now(),
812 | totalDurationMs: Date.now() - captureInfo.startTime,
813 | commonRequestHeaders,
814 | commonResponseHeaders,
815 | requests: processedRequests,
816 | requestCount: processedRequests.length, // Actual stored requests
817 | totalRequestsReceivedBeforeLimit: captureInfo.limitReached
818 | ? NetworkDebuggerStartTool.MAX_REQUESTS_PER_CAPTURE
819 | : processedRequests.length,
820 | requestLimitReached: !!captureInfo.limitReached,
821 | stoppedBy: isAutoStop
822 | ? this.lastActivityTime.get(tabId)
823 | ? 'inactivity_timeout'
824 | : 'max_capture_time'
825 | : 'user_request',
826 | tabUrl: captureInfo.tabUrl,
827 | tabTitle: captureInfo.tabTitle,
828 | };
829 |
830 | console.log(
831 | `NetworkDebuggerStartTool: Capture stopped for tab ${tabId}. ${resultData.requestCount} requests processed. Limit reached: ${resultData.requestLimitReached}. Stopped by: ${resultData.stoppedBy}`,
832 | );
833 |
834 | this.cleanupCapture(tabId); // Final cleanup of all internal states for this tab
835 |
836 | return {
837 | success: true,
838 | message: `Capture stopped. ${resultData.requestCount} requests.`,
839 | data: resultData,
840 | };
841 | }
842 |
843 | private analyzeCommonHeaders(
844 | requests: NetworkRequestInfo[],
845 | headerTypeKey: 'requestHeaders' | 'responseHeaders',
846 | ): Record<string, string> {
847 | if (!requests || requests.length === 0) return {};
848 |
849 | const headerValueCounts = new Map<string, Map<string, number>>(); // headerName -> (headerValue -> count)
850 | let requestsWithHeadersCount = 0;
851 |
852 | for (const req of requests) {
853 | const headers = req[headerTypeKey] as Record<string, string> | undefined;
854 | if (headers && Object.keys(headers).length > 0) {
855 | requestsWithHeadersCount++;
856 | for (const name in headers) {
857 | // Normalize header name to lowercase for consistent counting
858 | const lowerName = name.toLowerCase();
859 | const value = headers[name];
860 | if (!headerValueCounts.has(lowerName)) {
861 | headerValueCounts.set(lowerName, new Map());
862 | }
863 | const values = headerValueCounts.get(lowerName)!;
864 | values.set(value, (values.get(value) || 0) + 1);
865 | }
866 | }
867 | }
868 |
869 | if (requestsWithHeadersCount === 0) return {};
870 |
871 | const commonHeaders: Record<string, string> = {};
872 | headerValueCounts.forEach((values, name) => {
873 | values.forEach((count, value) => {
874 | if (count === requestsWithHeadersCount) {
875 | // This (name, value) pair is present in all requests that have this type of headers.
876 | // We need to find the original casing for the header name.
877 | // This is tricky as HTTP headers are case-insensitive. Let's pick the first encountered one.
878 | // A more robust way would be to store original names, but lowercase comparison is standard.
879 | // For simplicity, we'll use the lowercase name for commonHeaders keys.
880 | // Or, find one original casing:
881 | let originalName = name;
882 | for (const req of requests) {
883 | const hdrs = req[headerTypeKey] as Record<string, string> | undefined;
884 | if (hdrs) {
885 | const foundName = Object.keys(hdrs).find((k) => k.toLowerCase() === name);
886 | if (foundName) {
887 | originalName = foundName;
888 | break;
889 | }
890 | }
891 | }
892 | commonHeaders[originalName] = value;
893 | }
894 | });
895 | });
896 | return commonHeaders;
897 | }
898 |
899 | private filterOutCommonHeaders(
900 | headers: Record<string, string>,
901 | commonHeaders: Record<string, string>,
902 | ): Record<string, string> {
903 | if (!headers || typeof headers !== 'object') return {};
904 |
905 | const specificHeaders: Record<string, string> = {};
906 | const commonHeadersLower: Record<string, string> = {};
907 |
908 | // Use Object.keys to avoid ESLint no-prototype-builtins warning
909 | Object.keys(commonHeaders).forEach((commonName) => {
910 | commonHeadersLower[commonName.toLowerCase()] = commonHeaders[commonName];
911 | });
912 |
913 | // Use Object.keys to avoid ESLint no-prototype-builtins warning
914 | Object.keys(headers).forEach((name) => {
915 | const lowerName = name.toLowerCase();
916 | // If the header (by name, case-insensitively) is not in commonHeaders OR
917 | // if its value is different from the common one, then it's specific.
918 | if (!(lowerName in commonHeadersLower) || headers[name] !== commonHeadersLower[lowerName]) {
919 | specificHeaders[name] = headers[name];
920 | }
921 | });
922 |
923 | return specificHeaders;
924 | }
925 |
926 | async execute(args: NetworkDebuggerStartToolParams): Promise<ToolResult> {
927 | const {
928 | url: targetUrl,
929 | maxCaptureTime = DEFAULT_MAX_CAPTURE_TIME_MS,
930 | inactivityTimeout = DEFAULT_INACTIVITY_TIMEOUT_MS,
931 | includeStatic = false,
932 | } = args;
933 |
934 | console.log(
935 | `NetworkDebuggerStartTool: Executing with args: url=${targetUrl}, maxTime=${maxCaptureTime}, inactivityTime=${inactivityTimeout}, includeStatic=${includeStatic}`,
936 | );
937 |
938 | let tabToOperateOn: chrome.tabs.Tab | undefined;
939 |
940 | try {
941 | if (targetUrl) {
942 | const existingTabs = await chrome.tabs.query({
943 | url: targetUrl.startsWith('http') ? targetUrl : `*://*/*${targetUrl}*`,
944 | }); // More specific query
945 | if (existingTabs.length > 0 && existingTabs[0]?.id) {
946 | tabToOperateOn = existingTabs[0];
947 | // Ensure window gets focus and tab is truly activated
948 | await chrome.windows.update(tabToOperateOn.windowId, { focused: true });
949 | await chrome.tabs.update(tabToOperateOn.id!, { active: true });
950 | } else {
951 | tabToOperateOn = await chrome.tabs.create({ url: targetUrl, active: true });
952 | // Wait for tab to be somewhat ready. A better way is to listen to tabs.onUpdated status='complete'
953 | // but for debugger attachment, it just needs the tabId.
954 | await new Promise((resolve) => setTimeout(resolve, 500)); // Short delay
955 | }
956 | } else {
957 | const activeTabs = await chrome.tabs.query({ active: true, currentWindow: true });
958 | if (activeTabs.length > 0 && activeTabs[0]?.id) {
959 | tabToOperateOn = activeTabs[0];
960 | } else {
961 | return createErrorResponse('No active tab found and no URL provided.');
962 | }
963 | }
964 |
965 | if (!tabToOperateOn?.id) {
966 | return createErrorResponse('Failed to identify or create a target tab.');
967 | }
968 | const tabId = tabToOperateOn.id;
969 |
970 | // Use startCaptureForTab method to start capture
971 | try {
972 | await this.startCaptureForTab(tabId, {
973 | maxCaptureTime,
974 | inactivityTimeout,
975 | includeStatic,
976 | });
977 | } catch (error: any) {
978 | return createErrorResponse(
979 | `Failed to start capture for tab ${tabId}: ${error.message || String(error)}`,
980 | );
981 | }
982 |
983 | return {
984 | content: [
985 | {
986 | type: 'text',
987 | text: JSON.stringify({
988 | success: true,
989 | message: `Network capture started on tab ${tabId}. Waiting for stop command or timeout.`,
990 | tabId,
991 | url: tabToOperateOn.url,
992 | maxCaptureTime,
993 | inactivityTimeout,
994 | includeStatic,
995 | maxRequests: NetworkDebuggerStartTool.MAX_REQUESTS_PER_CAPTURE,
996 | }),
997 | },
998 | ],
999 | isError: false,
1000 | };
1001 | } catch (error: any) {
1002 | console.error('NetworkDebuggerStartTool: Critical error during execute:', error);
1003 | // If a tabId was involved and debugger might be attached, try to clean up.
1004 | const tabIdToClean = tabToOperateOn?.id;
1005 | if (tabIdToClean && this.captureData.has(tabIdToClean)) {
1006 | await chrome.debugger
1007 | .detach({ tabId: tabIdToClean })
1008 | .catch((e) => console.warn('Cleanup detach error:', e));
1009 | this.cleanupCapture(tabIdToClean);
1010 | }
1011 | return createErrorResponse(
1012 | `Error in NetworkDebuggerStartTool: ${error.message || String(error)}`,
1013 | );
1014 | }
1015 | }
1016 | }
1017 |
1018 | /**
1019 | * Network capture stop tool - stops capture and returns results for the active tab
1020 | */
1021 | class NetworkDebuggerStopTool extends BaseBrowserToolExecutor {
1022 | name = TOOL_NAMES.BROWSER.NETWORK_DEBUGGER_STOP;
1023 | public static instance: NetworkDebuggerStopTool | null = null;
1024 |
1025 | constructor() {
1026 | super();
1027 | if (NetworkDebuggerStopTool.instance) {
1028 | return NetworkDebuggerStopTool.instance;
1029 | }
1030 | NetworkDebuggerStopTool.instance = this;
1031 | }
1032 |
1033 | async execute(): Promise<ToolResult> {
1034 | console.log(`NetworkDebuggerStopTool: Executing command.`);
1035 |
1036 | const startTool = NetworkDebuggerStartTool.instance;
1037 | if (!startTool) {
1038 | return createErrorResponse(
1039 | 'NetworkDebuggerStartTool instance not available. Cannot stop capture.',
1040 | );
1041 | }
1042 |
1043 | // Get all tabs currently capturing
1044 | const ongoingCaptures = Array.from(startTool['captureData'].keys());
1045 | console.log(
1046 | `NetworkDebuggerStopTool: Found ${ongoingCaptures.length} ongoing captures: ${ongoingCaptures.join(', ')}`,
1047 | );
1048 |
1049 | if (ongoingCaptures.length === 0) {
1050 | return createErrorResponse('No active network captures found in any tab.');
1051 | }
1052 |
1053 | // Get current active tab
1054 | const activeTabs = await chrome.tabs.query({ active: true, currentWindow: true });
1055 | const activeTabId = activeTabs[0]?.id;
1056 |
1057 | // Determine the primary tab to stop
1058 | let primaryTabId: number;
1059 |
1060 | if (activeTabId && startTool['captureData'].has(activeTabId)) {
1061 | // If current active tab is capturing, prioritize stopping it
1062 | primaryTabId = activeTabId;
1063 | console.log(
1064 | `NetworkDebuggerStopTool: Active tab ${activeTabId} is capturing, will stop it first.`,
1065 | );
1066 | } else if (ongoingCaptures.length === 1) {
1067 | // If only one tab is capturing, stop it
1068 | primaryTabId = ongoingCaptures[0];
1069 | console.log(
1070 | `NetworkDebuggerStopTool: Only one tab ${primaryTabId} is capturing, stopping it.`,
1071 | );
1072 | } else {
1073 | // If multiple tabs are capturing but current active tab is not among them, stop the first one
1074 | primaryTabId = ongoingCaptures[0];
1075 | console.log(
1076 | `NetworkDebuggerStopTool: Multiple tabs capturing, active tab not among them. Stopping tab ${primaryTabId} first.`,
1077 | );
1078 | }
1079 |
1080 | // Stop capture for the primary tab
1081 | const result = await this.performStop(startTool, primaryTabId);
1082 |
1083 | // If multiple tabs are capturing, stop other tabs
1084 | if (ongoingCaptures.length > 1) {
1085 | const otherTabIds = ongoingCaptures.filter((id) => id !== primaryTabId);
1086 | console.log(
1087 | `NetworkDebuggerStopTool: Stopping ${otherTabIds.length} additional captures: ${otherTabIds.join(', ')}`,
1088 | );
1089 |
1090 | for (const tabId of otherTabIds) {
1091 | try {
1092 | await startTool.stopCapture(tabId);
1093 | } catch (error) {
1094 | console.error(`NetworkDebuggerStopTool: Error stopping capture on tab ${tabId}:`, error);
1095 | }
1096 | }
1097 | }
1098 |
1099 | return result;
1100 | }
1101 |
1102 | private async performStop(
1103 | startTool: NetworkDebuggerStartTool,
1104 | tabId: number,
1105 | ): Promise<ToolResult> {
1106 | console.log(`NetworkDebuggerStopTool: Attempting to stop capture for tab ${tabId}.`);
1107 | const stopResult = await startTool.stopCapture(tabId);
1108 |
1109 | if (!stopResult?.success) {
1110 | return createErrorResponse(
1111 | stopResult?.message ||
1112 | `Failed to stop network capture for tab ${tabId}. It might not have been capturing.`,
1113 | );
1114 | }
1115 |
1116 | const resultData = stopResult.data || {};
1117 |
1118 | // Get all tabs still capturing (there might be other tabs still capturing after stopping)
1119 | const remainingCaptures = Array.from(startTool['captureData'].keys());
1120 |
1121 | // Sort requests by time
1122 | if (resultData.requests && Array.isArray(resultData.requests)) {
1123 | resultData.requests.sort(
1124 | (a: NetworkRequestInfo, b: NetworkRequestInfo) =>
1125 | (a.requestTime || 0) - (b.requestTime || 0),
1126 | );
1127 | }
1128 |
1129 | return {
1130 | content: [
1131 | {
1132 | type: 'text',
1133 | text: JSON.stringify({
1134 | success: true,
1135 | message: `Capture for tab ${tabId} (${resultData.tabUrl || 'N/A'}) stopped. ${resultData.requestCount || 0} requests captured.`,
1136 | tabId: tabId,
1137 | tabUrl: resultData.tabUrl || 'N/A',
1138 | tabTitle: resultData.tabTitle || 'Unknown Tab',
1139 | requestCount: resultData.requestCount || 0,
1140 | commonRequestHeaders: resultData.commonRequestHeaders || {},
1141 | commonResponseHeaders: resultData.commonResponseHeaders || {},
1142 | requests: resultData.requests || [],
1143 | captureStartTime: resultData.captureStartTime,
1144 | captureEndTime: resultData.captureEndTime,
1145 | totalDurationMs: resultData.totalDurationMs,
1146 | settingsUsed: resultData.settingsUsed || {},
1147 | remainingCaptures: remainingCaptures,
1148 | totalRequestsReceived: resultData.totalRequestsReceived || resultData.requestCount || 0,
1149 | requestLimitReached: resultData.requestLimitReached || false,
1150 | }),
1151 | },
1152 | ],
1153 | isError: false,
1154 | };
1155 | }
1156 | }
1157 |
1158 | export const networkDebuggerStartTool = new NetworkDebuggerStartTool();
1159 | export const networkDebuggerStopTool = new NetworkDebuggerStopTool();
1160 |
```
--------------------------------------------------------------------------------
/app/chrome-extension/workers/ort-wasm-simd-threaded.jsep.mjs:
--------------------------------------------------------------------------------
```
1 | var ortWasmThreaded = (() => {
2 | var _scriptName = import.meta.url;
3 |
4 | return (
5 | async function(moduleArg = {}) {
6 | var moduleRtn;
7 |
8 | var e=moduleArg,aa,ca,da=new Promise((a,b)=>{aa=a;ca=b}),ea="object"==typeof window,k="undefined"!=typeof WorkerGlobalScope,n="object"==typeof process&&"object"==typeof process.versions&&"string"==typeof process.versions.node&&"renderer"!=process.type,q=k&&self.name?.startsWith("em-pthread");if(n){const {createRequire:a}=await import("module");var require=a(import.meta.url),fa=require("worker_threads");global.Worker=fa.Worker;q=(k=!fa.pc)&&"em-pthread"==fa.workerData}
9 | e.mountExternalData=(a,b)=>{a.startsWith("./")&&(a=a.substring(2));(e.Fb||(e.Fb=new Map)).set(a,b)};e.unmountExternalData=()=>{delete e.Fb};var SharedArrayBuffer=globalThis.SharedArrayBuffer??(new WebAssembly.Memory({initial:0,maximum:0,qc:!0})).buffer.constructor;
10 | const ha=a=>async(...b)=>{try{if(e.Gb)throw Error("Session already started");const c=e.Gb={ec:b[0],errors:[]},d=await a(...b);if(e.Gb!==c)throw Error("Session mismatch");e.Kb?.flush();const f=c.errors;if(0<f.length){let g=await Promise.all(f);g=g.filter(h=>h);if(0<g.length)throw Error(g.join("\n"));}return d}finally{e.Gb=null}};
11 | e.jsepInit=(a,b)=>{if("webgpu"===a){[e.Kb,e.Vb,e.Zb,e.Lb,e.Yb,e.kb,e.$b,e.bc,e.Wb,e.Xb,e.ac]=b;const c=e.Kb;e.jsepRegisterBuffer=(d,f,g,h)=>c.registerBuffer(d,f,g,h);e.jsepGetBuffer=d=>c.getBuffer(d);e.jsepCreateDownloader=(d,f,g)=>c.createDownloader(d,f,g);e.jsepOnCreateSession=d=>{c.onCreateSession(d)};e.jsepOnReleaseSession=d=>{c.onReleaseSession(d)};e.jsepOnRunStart=d=>c.onRunStart(d);e.cc=(d,f)=>{c.upload(d,f)}}else if("webnn"===a){const c=b[0];[e.oc,e.Ob,e.webnnEnsureTensor,e.Pb,e.webnnDownloadTensor]=
12 | b.slice(1);e.webnnReleaseTensorId=e.Ob;e.webnnUploadTensor=e.Pb;e.webnnOnRunStart=d=>c.onRunStart(d);e.webnnOnRunEnd=c.onRunEnd.bind(c);e.webnnRegisterMLContext=(d,f)=>{c.registerMLContext(d,f)};e.webnnOnReleaseSession=d=>{c.onReleaseSession(d)};e.webnnCreateMLTensorDownloader=(d,f)=>c.createMLTensorDownloader(d,f);e.webnnRegisterMLTensor=(d,f,g,h)=>c.registerMLTensor(d,f,g,h);e.webnnCreateMLContext=d=>c.createMLContext(d);e.webnnRegisterMLConstant=(d,f,g,h,l,m)=>c.registerMLConstant(d,f,g,h,l,e.Fb,
13 | m);e.webnnRegisterGraphInput=c.registerGraphInput.bind(c);e.webnnIsGraphInput=c.isGraphInput.bind(c);e.webnnRegisterGraphOutput=c.registerGraphOutput.bind(c);e.webnnIsGraphOutput=c.isGraphOutput.bind(c);e.webnnCreateTemporaryTensor=c.createTemporaryTensor.bind(c);e.webnnIsGraphInputOutputTypeSupported=c.isGraphInputOutputTypeSupported.bind(c)}};
14 | let ja=()=>{const a=(b,c,d)=>(...f)=>{const g=t,h=c?.();f=b(...f);const l=c?.();h!==l&&(b=l,d(h),c=d=null);return t!=g?ia():f};(b=>{for(const c of b)e[c]=a(e[c],()=>e[c],d=>e[c]=d)})(["_OrtAppendExecutionProvider","_OrtCreateSession","_OrtRun","_OrtRunWithBinding","_OrtBindInput"]);"undefined"!==typeof ha&&(e._OrtRun=ha(e._OrtRun),e._OrtRunWithBinding=ha(e._OrtRunWithBinding));ja=void 0};e.asyncInit=()=>{ja?.()};var ka=Object.assign({},e),la="./this.program",ma=(a,b)=>{throw b;},v="",na,oa;
15 | if(n){var fs=require("fs"),pa=require("path");import.meta.url.startsWith("data:")||(v=pa.dirname(require("url").fileURLToPath(import.meta.url))+"/");oa=a=>{a=qa(a)?new URL(a):a;return fs.readFileSync(a)};na=async a=>{a=qa(a)?new URL(a):a;return fs.readFileSync(a,void 0)};!e.thisProgram&&1<process.argv.length&&(la=process.argv[1].replace(/\\/g,"/"));process.argv.slice(2);ma=(a,b)=>{process.exitCode=a;throw b;}}else if(ea||k)k?v=self.location.href:"undefined"!=typeof document&&
16 | document.currentScript&&(v=document.currentScript.src),_scriptName&&(v=_scriptName),v.startsWith("blob:")?v="":v=v.slice(0,v.replace(/[?#].*/,"").lastIndexOf("/")+1),n||(k&&(oa=a=>{var b=new XMLHttpRequest;b.open("GET",a,!1);b.responseType="arraybuffer";b.send(null);return new Uint8Array(b.response)}),na=async a=>{if(qa(a))return new Promise((c,d)=>{var f=new XMLHttpRequest;f.open("GET",a,!0);f.responseType="arraybuffer";f.onload=()=>{200==f.status||0==f.status&&f.response?c(f.response):d(f.status)};
17 | f.onerror=d;f.send(null)});var b=await fetch(a,{credentials:"same-origin"});if(b.ok)return b.arrayBuffer();throw Error(b.status+" : "+b.url);});var ra=console.log.bind(console),sa=console.error.bind(console);n&&(ra=(...a)=>fs.writeSync(1,a.join(" ")+"\n"),sa=(...a)=>fs.writeSync(2,a.join(" ")+"\n"));var ta=ra,x=sa;Object.assign(e,ka);ka=null;var ua=e.wasmBinary,z,va,A=!1,wa,B,xa,ya,za,Aa,Ba,Ca,C,Da,Ea,qa=a=>a.startsWith("file://");function D(){z.buffer!=B.buffer&&E();return B}
18 | function F(){z.buffer!=B.buffer&&E();return xa}function G(){z.buffer!=B.buffer&&E();return ya}function Fa(){z.buffer!=B.buffer&&E();return za}function H(){z.buffer!=B.buffer&&E();return Aa}function I(){z.buffer!=B.buffer&&E();return Ba}function Ga(){z.buffer!=B.buffer&&E();return Ca}function J(){z.buffer!=B.buffer&&E();return Ea}
19 | if(q){var Ha;if(n){var Ia=fa.parentPort;Ia.on("message",b=>onmessage({data:b}));Object.assign(globalThis,{self:global,postMessage:b=>Ia.postMessage(b)})}var Ja=!1;x=function(...b){b=b.join(" ");n?fs.writeSync(2,b+"\n"):console.error(b)};self.alert=function(...b){postMessage({Cb:"alert",text:b.join(" "),jc:Ka()})};self.onunhandledrejection=b=>{throw b.reason||b;};function a(b){try{var c=b.data,d=c.Cb;if("load"===d){let f=[];self.onmessage=g=>f.push(g);self.startWorker=()=>{postMessage({Cb:"loaded"});
20 | for(let g of f)a(g);self.onmessage=a};for(const g of c.Sb)if(!e[g]||e[g].proxy)e[g]=(...h)=>{postMessage({Cb:"callHandler",Rb:g,args:h})},"print"==g&&(ta=e[g]),"printErr"==g&&(x=e[g]);z=c.lc;E();Ha(c.mc)}else if("run"===d){La(c.Bb);Ma(c.Bb,0,0,1,0,0);Na();Oa(c.Bb);Ja||(Pa(),Ja=!0);try{Qa(c.hc,c.Ib)}catch(f){if("unwind"!=f)throw f;}}else"setimmediate"!==c.target&&("checkMailbox"===d?Ja&&Ra():d&&(x(`worker: received unknown command ${d}`),x(c)))}catch(f){throw Sa(),f;}}self.onmessage=a}
21 | function E(){var a=z.buffer;e.HEAP8=B=new Int8Array(a);e.HEAP16=ya=new Int16Array(a);e.HEAPU8=xa=new Uint8Array(a);e.HEAPU16=za=new Uint16Array(a);e.HEAP32=Aa=new Int32Array(a);e.HEAPU32=Ba=new Uint32Array(a);e.HEAPF32=Ca=new Float32Array(a);e.HEAPF64=Ea=new Float64Array(a);e.HEAP64=C=new BigInt64Array(a);e.HEAPU64=Da=new BigUint64Array(a)}q||(z=new WebAssembly.Memory({initial:256,maximum:65536,shared:!0}),E());function Ta(){q?startWorker(e):K.Da()}var Ua=0,Va=null;
22 | function Wa(){Ua--;if(0==Ua&&Va){var a=Va;Va=null;a()}}function L(a){a="Aborted("+a+")";x(a);A=!0;a=new WebAssembly.RuntimeError(a+". Build with -sASSERTIONS for more info.");ca(a);throw a;}var Xa;async function Ya(a){if(!ua)try{var b=await na(a);return new Uint8Array(b)}catch{}if(a==Xa&&ua)a=new Uint8Array(ua);else if(oa)a=oa(a);else throw"both async and sync fetching of the wasm failed";return a}
23 | async function Za(a,b){try{var c=await Ya(a);return await WebAssembly.instantiate(c,b)}catch(d){x(`failed to asynchronously prepare wasm: ${d}`),L(d)}}async function $a(a){var b=Xa;if(!ua&&"function"==typeof WebAssembly.instantiateStreaming&&!qa(b)&&!n)try{var c=fetch(b,{credentials:"same-origin"});return await WebAssembly.instantiateStreaming(c,a)}catch(d){x(`wasm streaming compile failed: ${d}`),x("falling back to ArrayBuffer instantiation")}return Za(b,a)}
24 | function ab(){bb={L:cb,Aa:db,b:eb,$:fb,A:gb,pa:hb,X:ib,Z:jb,qa:kb,na:lb,ga:mb,ma:nb,J:ob,Y:pb,V:qb,oa:rb,W:sb,va:tb,E:ub,Q:vb,O:wb,D:xb,v:yb,r:zb,P:Ab,z:Bb,R:Cb,ja:Db,T:Eb,aa:Fb,M:Gb,F:Hb,ia:Oa,sa:Ib,t:Jb,Ca:Kb,w:Lb,o:Mb,m:Nb,c:Ob,Ba:Pb,n:Qb,j:Rb,u:Sb,p:Tb,f:Ub,s:Vb,l:Wb,e:Xb,k:Yb,h:Zb,g:$b,d:ac,da:bc,ea:cc,fa:dc,ba:ec,ca:fc,N:gc,xa:hc,ua:ic,i:jc,C:kc,G:lc,ta:mc,x:nc,ra:oc,U:pc,q:qc,y:rc,K:sc,S:tc,za:uc,ya:vc,ka:wc,la:xc,_:yc,B:zc,I:Ac,ha:Bc,H:Cc,a:z,wa:Dc};return{a:bb}}
25 | var Ec={840156:(a,b,c,d,f)=>{if("undefined"==typeof e||!e.Fb)return 1;a=M(Number(a>>>0));a.startsWith("./")&&(a=a.substring(2));a=e.Fb.get(a);if(!a)return 2;b=Number(b>>>0);c=Number(c>>>0);d=Number(d>>>0);if(b+c>a.byteLength)return 3;try{const g=a.subarray(b,b+c);switch(f){case 0:F().set(g,d>>>0);break;case 1:e.nc?e.nc(d,g):e.cc(d,g);break;default:return 4}return 0}catch{return 4}},840980:(a,b,c)=>{e.Pb(a,F().subarray(b>>>0,b+c>>>0))},841044:()=>e.oc(),841086:a=>{e.Ob(a)},841123:()=>{e.Wb()},841154:()=>
26 | {e.Xb()},841183:()=>{e.ac()},841208:a=>e.Vb(a),841241:a=>e.Zb(a),841273:(a,b,c)=>{e.Lb(Number(a),Number(b),Number(c),!0)},841336:(a,b,c)=>{e.Lb(Number(a),Number(b),Number(c))},841393:()=>"undefined"!==typeof wasmOffsetConverter,841450:a=>{e.kb("Abs",a,void 0)},841501:a=>{e.kb("Neg",a,void 0)},841552:a=>{e.kb("Floor",a,void 0)},841605:a=>{e.kb("Ceil",a,void 0)},841657:a=>{e.kb("Reciprocal",a,void 0)},841715:a=>{e.kb("Sqrt",a,void 0)},841767:a=>{e.kb("Exp",a,void 0)},841818:a=>{e.kb("Erf",a,void 0)},
27 | 841869:a=>{e.kb("Sigmoid",a,void 0)},841924:(a,b,c)=>{e.kb("HardSigmoid",a,{alpha:b,beta:c})},842003:a=>{e.kb("Log",a,void 0)},842054:a=>{e.kb("Sin",a,void 0)},842105:a=>{e.kb("Cos",a,void 0)},842156:a=>{e.kb("Tan",a,void 0)},842207:a=>{e.kb("Asin",a,void 0)},842259:a=>{e.kb("Acos",a,void 0)},842311:a=>{e.kb("Atan",a,void 0)},842363:a=>{e.kb("Sinh",a,void 0)},842415:a=>{e.kb("Cosh",a,void 0)},842467:a=>{e.kb("Asinh",a,void 0)},842520:a=>{e.kb("Acosh",a,void 0)},842573:a=>{e.kb("Atanh",a,void 0)},
28 | 842626:a=>{e.kb("Tanh",a,void 0)},842678:a=>{e.kb("Not",a,void 0)},842729:(a,b,c)=>{e.kb("Clip",a,{min:b,max:c})},842798:a=>{e.kb("Clip",a,void 0)},842850:(a,b)=>{e.kb("Elu",a,{alpha:b})},842908:a=>{e.kb("Gelu",a,void 0)},842960:a=>{e.kb("Relu",a,void 0)},843012:(a,b)=>{e.kb("LeakyRelu",a,{alpha:b})},843076:(a,b)=>{e.kb("ThresholdedRelu",a,{alpha:b})},843146:(a,b)=>{e.kb("Cast",a,{to:b})},843204:a=>{e.kb("Add",a,void 0)},843255:a=>{e.kb("Sub",a,void 0)},843306:a=>{e.kb("Mul",a,void 0)},843357:a=>
29 | {e.kb("Div",a,void 0)},843408:a=>{e.kb("Pow",a,void 0)},843459:a=>{e.kb("Equal",a,void 0)},843512:a=>{e.kb("Greater",a,void 0)},843567:a=>{e.kb("GreaterOrEqual",a,void 0)},843629:a=>{e.kb("Less",a,void 0)},843681:a=>{e.kb("LessOrEqual",a,void 0)},843740:(a,b,c,d,f)=>{e.kb("ReduceMean",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},843915:(a,b,c,d,f)=>{e.kb("ReduceMax",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>
30 | 0,Number(f)>>>0)):[]})},844089:(a,b,c,d,f)=>{e.kb("ReduceMin",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844263:(a,b,c,d,f)=>{e.kb("ReduceProd",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844438:(a,b,c,d,f)=>{e.kb("ReduceSum",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844612:(a,b,c,d,f)=>{e.kb("ReduceL1",a,{keepDims:!!b,
31 | noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844785:(a,b,c,d,f)=>{e.kb("ReduceL2",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},844958:(a,b,c,d,f)=>{e.kb("ReduceLogSum",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},845135:(a,b,c,d,f)=>{e.kb("ReduceSumSquare",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>
32 | 0,Number(f)>>>0)):[]})},845315:(a,b,c,d,f)=>{e.kb("ReduceLogSumExp",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},845495:a=>{e.kb("Where",a,void 0)},845548:(a,b,c)=>{e.kb("Transpose",a,{perm:b?Array.from(H().subarray(Number(b)>>>0,Number(c)>>>0)):[]})},845672:(a,b,c,d)=>{e.kb("DepthToSpace",a,{blocksize:b,mode:M(c),format:d?"NHWC":"NCHW"})},845805:(a,b,c,d)=>{e.kb("DepthToSpace",a,{blocksize:b,mode:M(c),format:d?"NHWC":"NCHW"})},845938:(a,
33 | b,c,d,f,g,h,l,m,p,r,u,w,y,ba)=>{e.kb("ConvTranspose",a,{format:m?"NHWC":"NCHW",autoPad:b,dilations:[c],group:d,kernelShape:[f],pads:[g,h],strides:[l],wIsConst:()=>!!D()[p>>>0],outputPadding:r?Array.from(H().subarray(Number(r)>>>0,Number(u)>>>0)):[],outputShape:w?Array.from(H().subarray(Number(w)>>>0,Number(y)>>>0)):[],activation:M(ba)})},846371:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("ConvTranspose",a,{format:l?"NHWC":"NCHW",autoPad:b,dilations:Array.from(H().subarray(Number(c)>>>0,(Number(c)>>>0)+2>>>
34 | 0)),group:d,kernelShape:Array.from(H().subarray(Number(f)>>>0,(Number(f)>>>0)+2>>>0)),pads:Array.from(H().subarray(Number(g)>>>0,(Number(g)>>>0)+4>>>0)),strides:Array.from(H().subarray(Number(h)>>>0,(Number(h)>>>0)+2>>>0)),wIsConst:()=>!!D()[m>>>0],outputPadding:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],outputShape:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[],activation:M(y)})},847032:(a,b,c,d,f,g,h,l,m,p,r,u,w,y,ba)=>{e.kb("ConvTranspose",a,{format:m?"NHWC":"NCHW",
35 | autoPad:b,dilations:[c],group:d,kernelShape:[f],pads:[g,h],strides:[l],wIsConst:()=>!!D()[p>>>0],outputPadding:r?Array.from(H().subarray(Number(r)>>>0,Number(u)>>>0)):[],outputShape:w?Array.from(H().subarray(Number(w)>>>0,Number(y)>>>0)):[],activation:M(ba)})},847465:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("ConvTranspose",a,{format:l?"NHWC":"NCHW",autoPad:b,dilations:Array.from(H().subarray(Number(c)>>>0,(Number(c)>>>0)+2>>>0)),group:d,kernelShape:Array.from(H().subarray(Number(f)>>>0,(Number(f)>>>0)+
36 | 2>>>0)),pads:Array.from(H().subarray(Number(g)>>>0,(Number(g)>>>0)+4>>>0)),strides:Array.from(H().subarray(Number(h)>>>0,(Number(h)>>>0)+2>>>0)),wIsConst:()=>!!D()[m>>>0],outputPadding:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],outputShape:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[],activation:M(y)})},848126:(a,b)=>{e.kb("GlobalAveragePool",a,{format:b?"NHWC":"NCHW"})},848217:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("AveragePool",a,{format:y?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,
37 | count_include_pad:d,storage_order:f,dilations:g?Array.from(H().subarray(Number(g)>>>0,Number(h)>>>0)):[],kernel_shape:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],pads:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],strides:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[]})},848696:(a,b)=>{e.kb("GlobalAveragePool",a,{format:b?"NHWC":"NCHW"})},848787:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("AveragePool",a,{format:y?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,count_include_pad:d,
38 | storage_order:f,dilations:g?Array.from(H().subarray(Number(g)>>>0,Number(h)>>>0)):[],kernel_shape:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],pads:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],strides:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[]})},849266:(a,b)=>{e.kb("GlobalMaxPool",a,{format:b?"NHWC":"NCHW"})},849353:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("MaxPool",a,{format:y?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:f,dilations:g?
39 | Array.from(H().subarray(Number(g)>>>0,Number(h)>>>0)):[],kernel_shape:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],pads:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],strides:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[]})},849828:(a,b)=>{e.kb("GlobalMaxPool",a,{format:b?"NHWC":"NCHW"})},849915:(a,b,c,d,f,g,h,l,m,p,r,u,w,y)=>{e.kb("MaxPool",a,{format:y?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:f,dilations:g?Array.from(H().subarray(Number(g)>>>
40 | 0,Number(h)>>>0)):[],kernel_shape:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],pads:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],strides:u?Array.from(H().subarray(Number(u)>>>0,Number(w)>>>0)):[]})},850390:(a,b,c,d,f)=>{e.kb("Gemm",a,{alpha:b,beta:c,transA:d,transB:f})},850494:a=>{e.kb("MatMul",a,void 0)},850548:(a,b,c,d)=>{e.kb("ArgMax",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},850656:(a,b,c,d)=>{e.kb("ArgMin",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},850764:(a,
41 | b)=>{e.kb("Softmax",a,{axis:b})},850827:(a,b)=>{e.kb("Concat",a,{axis:b})},850887:(a,b,c,d,f)=>{e.kb("Split",a,{axis:b,numOutputs:c,splitSizes:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},851043:a=>{e.kb("Expand",a,void 0)},851097:(a,b)=>{e.kb("Gather",a,{axis:Number(b)})},851168:(a,b)=>{e.kb("GatherElements",a,{axis:Number(b)})},851247:(a,b)=>{e.kb("GatherND",a,{batch_dims:Number(b)})},851326:(a,b,c,d,f,g,h,l,m,p,r)=>{e.kb("Resize",a,{antialias:b,axes:c?Array.from(H().subarray(Number(c)>>>
42 | 0,Number(d)>>>0)):[],coordinateTransformMode:M(f),cubicCoeffA:g,excludeOutside:h,extrapolationValue:l,keepAspectRatioPolicy:M(m),mode:M(p),nearestMode:M(r)})},851688:(a,b,c,d,f,g,h)=>{e.kb("Slice",a,{starts:b?Array.from(H().subarray(Number(b)>>>0,Number(c)>>>0)):[],ends:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[],axes:g?Array.from(H().subarray(Number(g)>>>0,Number(h)>>>0)):[]})},851952:a=>{e.kb("Tile",a,void 0)},852004:(a,b,c)=>{e.kb("InstanceNormalization",a,{epsilon:b,format:c?"NHWC":
43 | "NCHW"})},852118:(a,b,c)=>{e.kb("InstanceNormalization",a,{epsilon:b,format:c?"NHWC":"NCHW"})},852232:a=>{e.kb("Range",a,void 0)},852285:(a,b)=>{e.kb("Einsum",a,{equation:M(b)})},852366:(a,b,c,d,f)=>{e.kb("Pad",a,{mode:b,value:c,pads:d?Array.from(H().subarray(Number(d)>>>0,Number(f)>>>0)):[]})},852509:(a,b,c,d,f,g)=>{e.kb("BatchNormalization",a,{epsilon:b,momentum:c,spatial:!!f,trainingMode:!!d,format:g?"NHWC":"NCHW"})},852678:(a,b,c,d,f,g)=>{e.kb("BatchNormalization",a,{epsilon:b,momentum:c,spatial:!!f,
44 | trainingMode:!!d,format:g?"NHWC":"NCHW"})},852847:(a,b,c)=>{e.kb("CumSum",a,{exclusive:Number(b),reverse:Number(c)})},852944:(a,b,c)=>{e.kb("DequantizeLinear",a,{axis:b,blockSize:c})},853034:(a,b,c,d,f)=>{e.kb("GridSample",a,{align_corners:b,mode:M(c),padding_mode:M(d),format:f?"NHWC":"NCHW"})},853204:(a,b,c,d,f)=>{e.kb("GridSample",a,{align_corners:b,mode:M(c),padding_mode:M(d),format:f?"NHWC":"NCHW"})},853374:(a,b)=>{e.kb("ScatterND",a,{reduction:M(b)})},853459:(a,b,c,d,f,g,h,l,m)=>{e.kb("Attention",
45 | a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:f,doRotary:g,qkvHiddenSizes:h?Array.from(H().subarray(Number(l)>>>0,Number(l)+h>>>0)):[],pastPresentShareBuffer:!!m})},853731:a=>{e.kb("BiasAdd",a,void 0)},853786:a=>{e.kb("BiasSplitGelu",a,void 0)},853847:a=>{e.kb("FastGelu",a,void 0)},853903:(a,b,c,d,f,g,h,l,m,p,r,u,w,y,ba,Wd)=>{e.kb("Conv",a,{format:u?"NHWC":"NCHW",auto_pad:b,dilations:c?Array.from(H().subarray(Number(c)>>>0,Number(d)>>>0)):[],group:f,kernel_shape:g?Array.from(H().subarray(Number(g)>>>
46 | 0,Number(h)>>>0)):[],pads:l?Array.from(H().subarray(Number(l)>>>0,Number(m)>>>0)):[],strides:p?Array.from(H().subarray(Number(p)>>>0,Number(r)>>>0)):[],w_is_const:()=>!!D()[Number(w)>>>0],activation:M(y),activation_params:ba?Array.from(Ga().subarray(Number(ba)>>>0,Number(Wd)>>>0)):[]})},854487:a=>{e.kb("Gelu",a,void 0)},854539:(a,b,c,d,f,g,h,l,m)=>{e.kb("GroupQueryAttention",a,{numHeads:b,kvNumHeads:c,scale:d,softcap:f,doRotary:g,rotaryInterleaved:h,smoothSoftmax:l,localWindowSize:m})},854756:(a,
47 | b,c,d)=>{e.kb("LayerNormalization",a,{axis:b,epsilon:c,simplified:!!d})},854867:(a,b,c,d)=>{e.kb("LayerNormalization",a,{axis:b,epsilon:c,simplified:!!d})},854978:(a,b,c,d,f,g)=>{e.kb("MatMulNBits",a,{k:b,n:c,accuracyLevel:d,bits:f,blockSize:g})},855105:(a,b,c,d,f,g)=>{e.kb("MultiHeadAttention",a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:f,doRotary:g})},855264:(a,b)=>{e.kb("QuickGelu",a,{alpha:b})},855328:(a,b,c,d,f)=>{e.kb("RotaryEmbedding",a,{interleaved:!!b,numHeads:c,rotaryEmbeddingDim:d,
48 | scale:f})},855467:(a,b,c)=>{e.kb("SkipLayerNormalization",a,{epsilon:b,simplified:!!c})},855569:(a,b,c)=>{e.kb("SkipLayerNormalization",a,{epsilon:b,simplified:!!c})},855671:(a,b,c,d)=>{e.kb("GatherBlockQuantized",a,{gatherAxis:b,quantizeAxis:c,blockSize:d})},855792:a=>{e.$b(a)},855826:(a,b)=>e.bc(Number(a),Number(b),e.Gb.ec,e.Gb.errors)};function db(a,b,c){return Fc(async()=>{await e.Yb(Number(a),Number(b),Number(c))})}function cb(){return"undefined"!==typeof wasmOffsetConverter}
49 | class Gc{name="ExitStatus";constructor(a){this.message=`Program terminated with exit(${a})`;this.status=a}}
50 | var Hc=a=>{a.terminate();a.onmessage=()=>{}},Ic=[],Mc=a=>{0==N.length&&(Jc(),Kc(N[0]));var b=N.pop();if(!b)return 6;Lc.push(b);O[a.Bb]=b;b.Bb=a.Bb;var c={Cb:"run",hc:a.fc,Ib:a.Ib,Bb:a.Bb};n&&b.unref();b.postMessage(c,a.Nb);return 0},P=0,Q=(a,b,...c)=>{for(var d=2*c.length,f=Nc(),g=Oc(8*d),h=g>>>3,l=0;l<c.length;l++){var m=c[l];"bigint"==typeof m?(C[h+2*l]=1n,C[h+2*l+1]=m):(C[h+2*l]=0n,J()[h+2*l+1>>>0]=m)}a=Pc(a,0,d,g,b);Qc(f);return a};
51 | function Dc(a){if(q)return Q(0,1,a);wa=a;if(!(0<P)){for(var b of Lc)Hc(b);for(b of N)Hc(b);N=[];Lc=[];O={};A=!0}ma(a,new Gc(a))}function Rc(a){if(q)return Q(1,0,a);yc(a)}var yc=a=>{wa=a;if(q)throw Rc(a),"unwind";Dc(a)},N=[],Lc=[],Sc=[],O={};function Tc(){for(var a=e.numThreads-1;a--;)Jc();Ic.unshift(()=>{Ua++;Uc(()=>Wa())})}var Wc=a=>{var b=a.Bb;delete O[b];N.push(a);Lc.splice(Lc.indexOf(a),1);a.Bb=0;Vc(b)};function Na(){Sc.forEach(a=>a())}
52 | var Kc=a=>new Promise(b=>{a.onmessage=g=>{g=g.data;var h=g.Cb;if(g.Hb&&g.Hb!=Ka()){var l=O[g.Hb];l?l.postMessage(g,g.Nb):x(`Internal error! Worker sent a message "${h}" to target pthread ${g.Hb}, but that thread no longer exists!`)}else if("checkMailbox"===h)Ra();else if("spawnThread"===h)Mc(g);else if("cleanupThread"===h)Wc(O[g.ic]);else if("loaded"===h)a.loaded=!0,n&&!a.Bb&&a.unref(),b(a);else if("alert"===h)alert(`Thread ${g.jc}: ${g.text}`);else if("setimmediate"===g.target)a.postMessage(g);else if("callHandler"===
53 | h)e[g.Rb](...g.args);else h&&x(`worker sent an unknown command ${h}`)};a.onerror=g=>{x(`${"worker sent an error!"} ${g.filename}:${g.lineno}: ${g.message}`);throw g;};n&&(a.on("message",g=>a.onmessage({data:g})),a.on("error",g=>a.onerror(g)));var c=[],d=[],f;for(f of d)e.propertyIsEnumerable(f)&&c.push(f);a.postMessage({Cb:"load",Sb:c,lc:z,mc:va})});function Uc(a){q?a():Promise.all(N.map(Kc)).then(a)}
54 | function Jc(){var a=new Worker(new URL(import.meta.url),{type:"module",workerData:"em-pthread",name:"em-pthread"});N.push(a)}var La=a=>{E();var b=I()[a+52>>>2>>>0];a=I()[a+56>>>2>>>0];Xc(b,b-a);Qc(b)},Qa=(a,b)=>{P=0;a=Yc(a,b);0<P?wa=a:Zc(a)};class $c{constructor(a){this.Jb=a-24}}var ad=0,bd=0;function eb(a,b,c){a>>>=0;var d=new $c(a);b>>>=0;c>>>=0;I()[d.Jb+16>>>2>>>0]=0;I()[d.Jb+4>>>2>>>0]=b;I()[d.Jb+8>>>2>>>0]=c;ad=a;bd++;throw ad;}
55 | function cd(a,b,c,d){return q?Q(2,1,a,b,c,d):fb(a,b,c,d)}function fb(a,b,c,d){a>>>=0;b>>>=0;c>>>=0;d>>>=0;if("undefined"==typeof SharedArrayBuffer)return 6;var f=[];if(q&&0===f.length)return cd(a,b,c,d);a={fc:c,Bb:a,Ib:d,Nb:f};return q?(a.Cb="spawnThread",postMessage(a,f),0):Mc(a)}
56 | var dd="undefined"!=typeof TextDecoder?new TextDecoder:void 0,ed=(a,b=0,c=NaN)=>{b>>>=0;var d=b+c;for(c=b;a[c]&&!(c>=d);)++c;if(16<c-b&&a.buffer&&dd)return dd.decode(a.buffer instanceof ArrayBuffer?a.subarray(b,c):a.slice(b,c));for(d="";b<c;){var f=a[b++];if(f&128){var g=a[b++]&63;if(192==(f&224))d+=String.fromCharCode((f&31)<<6|g);else{var h=a[b++]&63;f=224==(f&240)?(f&15)<<12|g<<6|h:(f&7)<<18|g<<12|h<<6|a[b++]&63;65536>f?d+=String.fromCharCode(f):(f-=65536,d+=String.fromCharCode(55296|f>>10,56320|
57 | f&1023))}}else d+=String.fromCharCode(f)}return d},M=(a,b)=>(a>>>=0)?ed(F(),a,b):"";function gb(a,b,c){return q?Q(3,1,a,b,c):0}function hb(a,b){if(q)return Q(4,1,a,b)}
58 | var fd=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=d?(b+=4,++c):b+=3}return b},gd=(a,b,c)=>{var d=F();b>>>=0;if(0<c){var f=b;c=b+c-1;for(var g=0;g<a.length;++g){var h=a.charCodeAt(g);if(55296<=h&&57343>=h){var l=a.charCodeAt(++g);h=65536+((h&1023)<<10)|l&1023}if(127>=h){if(b>=c)break;d[b++>>>0]=h}else{if(2047>=h){if(b+1>=c)break;d[b++>>>0]=192|h>>6}else{if(65535>=h){if(b+2>=c)break;d[b++>>>0]=224|h>>12}else{if(b+3>=c)break;d[b++>>>0]=240|h>>18;
59 | d[b++>>>0]=128|h>>12&63}d[b++>>>0]=128|h>>6&63}d[b++>>>0]=128|h&63}}d[b>>>0]=0;a=b-f}else a=0;return a};function ib(a,b){if(q)return Q(5,1,a,b)}function jb(a,b,c){if(q)return Q(6,1,a,b,c)}function kb(a,b,c){return q?Q(7,1,a,b,c):0}function lb(a,b){if(q)return Q(8,1,a,b)}function mb(a,b,c){if(q)return Q(9,1,a,b,c)}function nb(a,b,c,d){if(q)return Q(10,1,a,b,c,d)}function ob(a,b,c,d){if(q)return Q(11,1,a,b,c,d)}function pb(a,b,c,d){if(q)return Q(12,1,a,b,c,d)}function qb(a){if(q)return Q(13,1,a)}
60 | function rb(a,b){if(q)return Q(14,1,a,b)}function sb(a,b,c){if(q)return Q(15,1,a,b,c)}var tb=()=>L(""),hd,R=a=>{for(var b="";F()[a>>>0];)b+=hd[F()[a++>>>0]];return b},jd={},kd={},ld={},S;function md(a,b,c={}){var d=b.name;if(!a)throw new S(`type "${d}" must have a positive integer typeid pointer`);if(kd.hasOwnProperty(a)){if(c.Tb)return;throw new S(`Cannot register type '${d}' twice`);}kd[a]=b;delete ld[a];jd.hasOwnProperty(a)&&(b=jd[a],delete jd[a],b.forEach(f=>f()))}
61 | function T(a,b,c={}){return md(a,b,c)}var nd=(a,b,c)=>{switch(b){case 1:return c?d=>D()[d>>>0]:d=>F()[d>>>0];case 2:return c?d=>G()[d>>>1>>>0]:d=>Fa()[d>>>1>>>0];case 4:return c?d=>H()[d>>>2>>>0]:d=>I()[d>>>2>>>0];case 8:return c?d=>C[d>>>3]:d=>Da[d>>>3];default:throw new TypeError(`invalid integer width (${b}): ${a}`);}};
62 | function ub(a,b,c){a>>>=0;c>>>=0;b=R(b>>>0);T(a,{name:b,fromWireType:d=>d,toWireType:function(d,f){if("bigint"!=typeof f&&"number"!=typeof f)throw null===f?f="null":(d=typeof f,f="object"===d||"array"===d||"function"===d?f.toString():""+f),new TypeError(`Cannot convert "${f}" to ${this.name}`);"number"==typeof f&&(f=BigInt(f));return f},Db:U,readValueFromPointer:nd(b,c,-1==b.indexOf("u")),Eb:null})}var U=8;
63 | function vb(a,b,c,d){a>>>=0;b=R(b>>>0);T(a,{name:b,fromWireType:function(f){return!!f},toWireType:function(f,g){return g?c:d},Db:U,readValueFromPointer:function(f){return this.fromWireType(F()[f>>>0])},Eb:null})}var od=[],V=[];function Ob(a){a>>>=0;9<a&&0===--V[a+1]&&(V[a]=void 0,od.push(a))}
64 | var W=a=>{if(!a)throw new S("Cannot use deleted val. handle = "+a);return V[a]},X=a=>{switch(a){case void 0:return 2;case null:return 4;case !0:return 6;case !1:return 8;default:const b=od.pop()||V.length;V[b]=a;V[b+1]=1;return b}};function pd(a){return this.fromWireType(I()[a>>>2>>>0])}var qd={name:"emscripten::val",fromWireType:a=>{var b=W(a);Ob(a);return b},toWireType:(a,b)=>X(b),Db:U,readValueFromPointer:pd,Eb:null};function wb(a){return T(a>>>0,qd)}
65 | var rd=(a,b)=>{switch(b){case 4:return function(c){return this.fromWireType(Ga()[c>>>2>>>0])};case 8:return function(c){return this.fromWireType(J()[c>>>3>>>0])};default:throw new TypeError(`invalid float width (${b}): ${a}`);}};function xb(a,b,c){a>>>=0;c>>>=0;b=R(b>>>0);T(a,{name:b,fromWireType:d=>d,toWireType:(d,f)=>f,Db:U,readValueFromPointer:rd(b,c),Eb:null})}
66 | function yb(a,b,c,d,f){a>>>=0;c>>>=0;b=R(b>>>0);-1===f&&(f=4294967295);f=l=>l;if(0===d){var g=32-8*c;f=l=>l<<g>>>g}var h=b.includes("unsigned")?function(l,m){return m>>>0}:function(l,m){return m};T(a,{name:b,fromWireType:f,toWireType:h,Db:U,readValueFromPointer:nd(b,c,0!==d),Eb:null})}
67 | function zb(a,b,c){function d(g){var h=I()[g>>>2>>>0];g=I()[g+4>>>2>>>0];return new f(D().buffer,g,h)}a>>>=0;var f=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,BigInt64Array,BigUint64Array][b];c=R(c>>>0);T(a,{name:c,fromWireType:d,Db:U,readValueFromPointer:d},{Tb:!0})}
68 | function Ab(a,b){a>>>=0;b=R(b>>>0);T(a,{name:b,fromWireType:function(c){for(var d=I()[c>>>2>>>0],f=c+4,g,h=f,l=0;l<=d;++l){var m=f+l;if(l==d||0==F()[m>>>0])h=M(h,m-h),void 0===g?g=h:(g+=String.fromCharCode(0),g+=h),h=m+1}Y(c);return g},toWireType:function(c,d){d instanceof ArrayBuffer&&(d=new Uint8Array(d));var f="string"==typeof d;if(!(f||d instanceof Uint8Array||d instanceof Uint8ClampedArray||d instanceof Int8Array))throw new S("Cannot pass non-string to std::string");var g=f?fd(d):d.length;var h=
69 | sd(4+g+1),l=h+4;I()[h>>>2>>>0]=g;if(f)gd(d,l,g+1);else if(f)for(f=0;f<g;++f){var m=d.charCodeAt(f);if(255<m)throw Y(h),new S("String has UTF-16 code units that do not fit in 8 bits");F()[l+f>>>0]=m}else for(f=0;f<g;++f)F()[l+f>>>0]=d[f];null!==c&&c.push(Y,h);return h},Db:U,readValueFromPointer:pd,Eb(c){Y(c)}})}
70 | var td="undefined"!=typeof TextDecoder?new TextDecoder("utf-16le"):void 0,ud=(a,b)=>{var c=a>>1;for(var d=c+b/2;!(c>=d)&&Fa()[c>>>0];)++c;c<<=1;if(32<c-a&&td)return td.decode(F().slice(a,c));c="";for(d=0;!(d>=b/2);++d){var f=G()[a+2*d>>>1>>>0];if(0==f)break;c+=String.fromCharCode(f)}return c},vd=(a,b,c)=>{c??=2147483647;if(2>c)return 0;c-=2;var d=b;c=c<2*a.length?c/2:a.length;for(var f=0;f<c;++f){var g=a.charCodeAt(f);G()[b>>>1>>>0]=g;b+=2}G()[b>>>1>>>0]=0;return b-d},wd=a=>2*a.length,xd=(a,b)=>{for(var c=
71 | 0,d="";!(c>=b/4);){var f=H()[a+4*c>>>2>>>0];if(0==f)break;++c;65536<=f?(f-=65536,d+=String.fromCharCode(55296|f>>10,56320|f&1023)):d+=String.fromCharCode(f)}return d},yd=(a,b,c)=>{b>>>=0;c??=2147483647;if(4>c)return 0;var d=b;c=d+c-4;for(var f=0;f<a.length;++f){var g=a.charCodeAt(f);if(55296<=g&&57343>=g){var h=a.charCodeAt(++f);g=65536+((g&1023)<<10)|h&1023}H()[b>>>2>>>0]=g;b+=4;if(b+4>c)break}H()[b>>>2>>>0]=0;return b-d},zd=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);55296<=d&&57343>=
72 | d&&++c;b+=4}return b};
73 | function Bb(a,b,c){a>>>=0;b>>>=0;c>>>=0;c=R(c);if(2===b){var d=ud;var f=vd;var g=wd;var h=l=>Fa()[l>>>1>>>0]}else 4===b&&(d=xd,f=yd,g=zd,h=l=>I()[l>>>2>>>0]);T(a,{name:c,fromWireType:l=>{for(var m=I()[l>>>2>>>0],p,r=l+4,u=0;u<=m;++u){var w=l+4+u*b;if(u==m||0==h(w))r=d(r,w-r),void 0===p?p=r:(p+=String.fromCharCode(0),p+=r),r=w+b}Y(l);return p},toWireType:(l,m)=>{if("string"!=typeof m)throw new S(`Cannot pass non-string to C++ string type ${c}`);var p=g(m),r=sd(4+p+b);I()[r>>>2>>>0]=p/b;f(m,r+4,p+b);
74 | null!==l&&l.push(Y,r);return r},Db:U,readValueFromPointer:pd,Eb(l){Y(l)}})}function Cb(a,b){a>>>=0;b=R(b>>>0);T(a,{Ub:!0,name:b,Db:0,fromWireType:()=>{},toWireType:()=>{}})}function Db(a){Ma(a>>>0,!k,1,!ea,131072,!1);Na()}var Ad=a=>{if(!A)try{if(a(),!(0<P))try{q?Zc(wa):yc(wa)}catch(b){b instanceof Gc||"unwind"==b||ma(1,b)}}catch(b){b instanceof Gc||"unwind"==b||ma(1,b)}};
75 | function Oa(a){a>>>=0;"function"===typeof Atomics.kc&&(Atomics.kc(H(),a>>>2,a).value.then(Ra),a+=128,Atomics.store(H(),a>>>2,1))}var Ra=()=>{var a=Ka();a&&(Oa(a),Ad(Bd))};function Eb(a,b){a>>>=0;a==b>>>0?setTimeout(Ra):q?postMessage({Hb:a,Cb:"checkMailbox"}):(a=O[a])&&a.postMessage({Cb:"checkMailbox"})}var Cd=[];function Fb(a,b,c,d,f){b>>>=0;d/=2;Cd.length=d;c=f>>>0>>>3;for(f=0;f<d;f++)Cd[f]=C[c+2*f]?C[c+2*f+1]:J()[c+2*f+1>>>0];return(b?Ec[b]:Dd[a])(...Cd)}var Gb=()=>{P=0};
76 | function Hb(a){a>>>=0;q?postMessage({Cb:"cleanupThread",ic:a}):Wc(O[a])}function Ib(a){n&&O[a>>>0].ref()}var Fd=(a,b)=>{var c=kd[a];if(void 0===c)throw a=Ed(a),c=R(a),Y(a),new S(`${b} has unknown type ${c}`);return c},Gd=(a,b,c)=>{var d=[];a=a.toWireType(d,c);d.length&&(I()[b>>>2>>>0]=X(d));return a};function Jb(a,b,c){b>>>=0;c>>>=0;a=W(a>>>0);b=Fd(b,"emval::as");return Gd(b,c,a)}function Kb(a,b){b>>>=0;a=W(a>>>0);b=Fd(b,"emval::as");return b.toWireType(null,a)}var Hd=a=>{try{a()}catch(b){L(b)}};
77 | function Id(){var a=K,b={};for(let [c,d]of Object.entries(a))b[c]="function"==typeof d?(...f)=>{Jd.push(c);try{return d(...f)}finally{A||(Jd.pop(),t&&1===Z&&0===Jd.length&&(Z=0,P+=1,Hd(Kd),"undefined"!=typeof Fibers&&Fibers.sc()))}}:d;return b}var Z=0,t=null,Ld=0,Jd=[],Md={},Nd={},Od=0,Pd=null,Qd=[];function ia(){return new Promise((a,b)=>{Pd={resolve:a,reject:b}})}
78 | function Rd(){var a=sd(65548),b=a+12;I()[a>>>2>>>0]=b;I()[a+4>>>2>>>0]=b+65536;b=Jd[0];var c=Md[b];void 0===c&&(c=Od++,Md[b]=c,Nd[c]=b);b=c;H()[a+8>>>2>>>0]=b;return a}function Sd(){var a=H()[t+8>>>2>>>0];a=K[Nd[a]];--P;return a()}
79 | function Td(a){if(!A){if(0===Z){var b=!1,c=!1;a((d=0)=>{if(!A&&(Ld=d,b=!0,c)){Z=2;Hd(()=>Ud(t));"undefined"!=typeof MainLoop&&MainLoop.Qb&&MainLoop.resume();d=!1;try{var f=Sd()}catch(l){f=l,d=!0}var g=!1;if(!t){var h=Pd;h&&(Pd=null,(d?h.reject:h.resolve)(f),g=!0)}if(d&&!g)throw f;}});c=!0;b||(Z=1,t=Rd(),"undefined"!=typeof MainLoop&&MainLoop.Qb&&MainLoop.pause(),Hd(()=>Vd(t)))}else 2===Z?(Z=0,Hd(Xd),Y(t),t=null,Qd.forEach(Ad)):L(`invalid state: ${Z}`);return Ld}}
80 | function Fc(a){return Td(b=>{a().then(b)})}function Lb(a){a>>>=0;return Fc(async()=>{var b=await W(a);return X(b)})}var Yd=[];function Mb(a,b,c,d){c>>>=0;d>>>=0;a=Yd[a>>>0];b=W(b>>>0);return a(null,b,c,d)}var Zd={},$d=a=>{var b=Zd[a];return void 0===b?R(a):b};function Nb(a,b,c,d,f){c>>>=0;d>>>=0;f>>>=0;a=Yd[a>>>0];b=W(b>>>0);c=$d(c);return a(b,b[c],d,f)}function Pb(a,b){b>>>=0;a=W(a>>>0);b=W(b);return a==b}var ae=()=>"object"==typeof globalThis?globalThis:Function("return this")();
81 | function Qb(a){a>>>=0;if(0===a)return X(ae());a=$d(a);return X(ae()[a])}var be=a=>{var b=Yd.length;Yd.push(a);return b},ce=(a,b)=>{for(var c=Array(a),d=0;d<a;++d)c[d]=Fd(I()[b+4*d>>>2>>>0],"parameter "+d);return c},de=(a,b)=>Object.defineProperty(b,"name",{value:a});
82 | function ee(a){var b=Function;if(!(b instanceof Function))throw new TypeError(`new_ called with constructor type ${typeof b} which is not a function`);var c=de(b.name||"unknownFunctionName",function(){});c.prototype=b.prototype;c=new c;a=b.apply(c,a);return a instanceof Object?a:c}
83 | function Rb(a,b,c){b=ce(a,b>>>0);var d=b.shift();a--;var f="return function (obj, func, destructorsRef, args) {\n",g=0,h=[];0===c&&h.push("obj");for(var l=["retType"],m=[d],p=0;p<a;++p)h.push("arg"+p),l.push("argType"+p),m.push(b[p]),f+=` var arg${p} = argType${p}.readValueFromPointer(args${g?"+"+g:""});\n`,g+=b[p].Db;f+=` var rv = ${1===c?"new func":"func.call"}(${h.join(", ")});\n`;d.Ub||(l.push("emval_returnValue"),m.push(Gd),f+=" return emval_returnValue(retType, destructorsRef, rv);\n");l.push(f+
84 | "};\n");a=ee(l)(...m);c=`methodCaller<(${b.map(r=>r.name).join(", ")}) => ${d.name}>`;return be(de(c,a))}function Sb(a){a=$d(a>>>0);return X(e[a])}function Tb(a,b){b>>>=0;a=W(a>>>0);b=W(b);return X(a[b])}function Ub(a){a>>>=0;9<a&&(V[a+1]+=1)}function Vb(){return X([])}function Wb(a){a=W(a>>>0);for(var b=Array(a.length),c=0;c<a.length;c++)b[c]=a[c];return X(b)}function Xb(a){return X($d(a>>>0))}function Yb(){return X({})}
85 | function Zb(a){a>>>=0;for(var b=W(a);b.length;){var c=b.pop();b.pop()(c)}Ob(a)}function $b(a,b,c){b>>>=0;c>>>=0;a=W(a>>>0);b=W(b);c=W(c);a[b]=c}function ac(a,b){b>>>=0;a=Fd(a>>>0,"_emval_take_value");a=a.readValueFromPointer(b);return X(a)}
86 | function bc(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);H()[b>>>2>>>0]=a.getUTCSeconds();H()[b+4>>>2>>>0]=a.getUTCMinutes();H()[b+8>>>2>>>0]=a.getUTCHours();H()[b+12>>>2>>>0]=a.getUTCDate();H()[b+16>>>2>>>0]=a.getUTCMonth();H()[b+20>>>2>>>0]=a.getUTCFullYear()-1900;H()[b+24>>>2>>>0]=a.getUTCDay();a=(a.getTime()-Date.UTC(a.getUTCFullYear(),0,1,0,0,0,0))/864E5|0;H()[b+28>>>2>>>0]=a}
87 | var fe=a=>0===a%4&&(0!==a%100||0===a%400),ge=[0,31,60,91,121,152,182,213,244,274,305,335],he=[0,31,59,90,120,151,181,212,243,273,304,334];
88 | function cc(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);H()[b>>>2>>>0]=a.getSeconds();H()[b+4>>>2>>>0]=a.getMinutes();H()[b+8>>>2>>>0]=a.getHours();H()[b+12>>>2>>>0]=a.getDate();H()[b+16>>>2>>>0]=a.getMonth();H()[b+20>>>2>>>0]=a.getFullYear()-1900;H()[b+24>>>2>>>0]=a.getDay();var c=(fe(a.getFullYear())?ge:he)[a.getMonth()]+a.getDate()-1|0;H()[b+28>>>2>>>0]=c;H()[b+36>>>2>>>0]=-(60*a.getTimezoneOffset());c=(new Date(a.getFullYear(),6,1)).getTimezoneOffset();
89 | var d=(new Date(a.getFullYear(),0,1)).getTimezoneOffset();a=(c!=d&&a.getTimezoneOffset()==Math.min(d,c))|0;H()[b+32>>>2>>>0]=a}
90 | function dc(a){a>>>=0;var b=new Date(H()[a+20>>>2>>>0]+1900,H()[a+16>>>2>>>0],H()[a+12>>>2>>>0],H()[a+8>>>2>>>0],H()[a+4>>>2>>>0],H()[a>>>2>>>0],0),c=H()[a+32>>>2>>>0],d=b.getTimezoneOffset(),f=(new Date(b.getFullYear(),6,1)).getTimezoneOffset(),g=(new Date(b.getFullYear(),0,1)).getTimezoneOffset(),h=Math.min(g,f);0>c?H()[a+32>>>2>>>0]=Number(f!=g&&h==d):0<c!=(h==d)&&(f=Math.max(g,f),b.setTime(b.getTime()+6E4*((0<c?h:f)-d)));H()[a+24>>>2>>>0]=b.getDay();c=(fe(b.getFullYear())?ge:he)[b.getMonth()]+
91 | b.getDate()-1|0;H()[a+28>>>2>>>0]=c;H()[a>>>2>>>0]=b.getSeconds();H()[a+4>>>2>>>0]=b.getMinutes();H()[a+8>>>2>>>0]=b.getHours();H()[a+12>>>2>>>0]=b.getDate();H()[a+16>>>2>>>0]=b.getMonth();H()[a+20>>>2>>>0]=b.getYear();a=b.getTime();return BigInt(isNaN(a)?-1:a/1E3)}function ec(a,b,c,d,f,g,h){return q?Q(16,1,a,b,c,d,f,g,h):-52}function fc(a,b,c,d,f,g){if(q)return Q(17,1,a,b,c,d,f,g)}var ie={},qc=()=>performance.timeOrigin+performance.now();
92 | function gc(a,b){if(q)return Q(18,1,a,b);ie[a]&&(clearTimeout(ie[a].id),delete ie[a]);if(!b)return 0;var c=setTimeout(()=>{delete ie[a];Ad(()=>je(a,performance.timeOrigin+performance.now()))},b);ie[a]={id:c,rc:b};return 0}
93 | function hc(a,b,c,d){a>>>=0;b>>>=0;c>>>=0;d>>>=0;var f=(new Date).getFullYear(),g=(new Date(f,0,1)).getTimezoneOffset();f=(new Date(f,6,1)).getTimezoneOffset();var h=Math.max(g,f);I()[a>>>2>>>0]=60*h;H()[b>>>2>>>0]=Number(g!=f);b=l=>{var m=Math.abs(l);return`UTC${0<=l?"-":"+"}${String(Math.floor(m/60)).padStart(2,"0")}${String(m%60).padStart(2,"0")}`};a=b(g);b=b(f);f<g?(gd(a,c,17),gd(b,d,17)):(gd(a,d,17),gd(b,c,17))}var mc=()=>Date.now(),ke=1;
94 | function ic(a,b,c){if(!(0<=a&&3>=a))return 28;if(0===a)a=Date.now();else if(ke)a=performance.timeOrigin+performance.now();else return 52;C[c>>>0>>>3]=BigInt(Math.round(1E6*a));return 0}var le=[],me=(a,b)=>{le.length=0;for(var c;c=F()[a++>>>0];){var d=105!=c;d&=112!=c;b+=d&&b%8?4:0;le.push(112==c?I()[b>>>2>>>0]:106==c?C[b>>>3]:105==c?H()[b>>>2>>>0]:J()[b>>>3>>>0]);b+=d?8:4}return le};function jc(a,b,c){a>>>=0;b=me(b>>>0,c>>>0);return Ec[a](...b)}
95 | function kc(a,b,c){a>>>=0;b=me(b>>>0,c>>>0);return Ec[a](...b)}var lc=()=>{};function nc(a,b){return x(M(a>>>0,b>>>0))}var oc=()=>{P+=1;throw"unwind";};function pc(){return 4294901760}var rc=()=>n?require("os").cpus().length:navigator.hardwareConcurrency;function sc(){L("Cannot use emscripten_pc_get_function without -sUSE_OFFSET_CONVERTER");return 0}
96 | function tc(a){a>>>=0;var b=F().length;if(a<=b||4294901760<a)return!1;for(var c=1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,a+100663296);a:{d=(Math.min(4294901760,65536*Math.ceil(Math.max(a,d)/65536))-z.buffer.byteLength+65535)/65536|0;try{z.grow(d);E();var f=1;break a}catch(g){}f=void 0}if(f)return!0}return!1}var ne=()=>{L("Cannot use convertFrameToPC (needed by __builtin_return_address) without -sUSE_OFFSET_CONVERTER");return 0},oe={},pe=a=>{a.forEach(b=>{var c=ne();c&&(oe[c]=b)})};
97 | function uc(){var a=Error().stack.toString().split("\n");"Error"==a[0]&&a.shift();pe(a);oe.Mb=ne();oe.dc=a;return oe.Mb}function vc(a,b,c){a>>>=0;b>>>=0;if(oe.Mb==a)var d=oe.dc;else d=Error().stack.toString().split("\n"),"Error"==d[0]&&d.shift(),pe(d);for(var f=3;d[f]&&ne()!=a;)++f;for(a=0;a<c&&d[a+f];++a)H()[b+4*a>>>2>>>0]=ne();return a}
98 | var qe={},se=()=>{if(!re){var a={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"==typeof navigator&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",_:la||"./this.program"},b;for(b in qe)void 0===qe[b]?delete a[b]:a[b]=qe[b];var c=[];for(b in a)c.push(`${b}=${a[b]}`);re=c}return re},re;
99 | function wc(a,b){if(q)return Q(19,1,a,b);a>>>=0;b>>>=0;var c=0;se().forEach((d,f)=>{var g=b+c;f=I()[a+4*f>>>2>>>0]=g;for(g=0;g<d.length;++g)D()[f++>>>0]=d.charCodeAt(g);D()[f>>>0]=0;c+=d.length+1});return 0}function xc(a,b){if(q)return Q(20,1,a,b);a>>>=0;b>>>=0;var c=se();I()[a>>>2>>>0]=c.length;var d=0;c.forEach(f=>d+=f.length+1);I()[b>>>2>>>0]=d;return 0}function zc(a){return q?Q(21,1,a):52}function Ac(a,b,c,d){return q?Q(22,1,a,b,c,d):52}function Bc(a,b,c,d){return q?Q(23,1,a,b,c,d):70}
100 | var te=[null,[],[]];function Cc(a,b,c,d){if(q)return Q(24,1,a,b,c,d);b>>>=0;c>>>=0;d>>>=0;for(var f=0,g=0;g<c;g++){var h=I()[b>>>2>>>0],l=I()[b+4>>>2>>>0];b+=8;for(var m=0;m<l;m++){var p=F()[h+m>>>0],r=te[a];0===p||10===p?((1===a?ta:x)(ed(r)),r.length=0):r.push(p)}f+=l}I()[d>>>2>>>0]=f;return 0}q||Tc();for(var ue=Array(256),ve=0;256>ve;++ve)ue[ve]=String.fromCharCode(ve);hd=ue;S=e.BindingError=class extends Error{constructor(a){super(a);this.name="BindingError"}};
101 | e.InternalError=class extends Error{constructor(a){super(a);this.name="InternalError"}};V.push(0,1,void 0,1,null,1,!0,1,!1,1);e.count_emval_handles=()=>V.length/2-5-od.length;var Dd=[Dc,Rc,cd,gb,hb,ib,jb,kb,lb,mb,nb,ob,pb,qb,rb,sb,ec,fc,gc,wc,xc,zc,Ac,Bc,Cc],bb,K;
102 | (async function(){function a(d,f){K=d.exports;K=Id();K=we();Sc.push(K.jb);va=f;Wa();return K}Ua++;var b=ab();if(e.instantiateWasm)return new Promise(d=>{e.instantiateWasm(b,(f,g)=>{a(f,g);d(f.exports)})});if(q)return new Promise(d=>{Ha=f=>{var g=new WebAssembly.Instance(f,ab());d(a(g,f))}});Xa??=e.locateFile?e.locateFile?e.locateFile("ort-wasm-simd-threaded.jsep.wasm",v):v+"ort-wasm-simd-threaded.jsep.wasm":(new URL("ort-wasm-simd-threaded.jsep.wasm",import.meta.url)).href;try{var c=await $a(b);
103 | return a(c.instance,c.module)}catch(d){return ca(d),Promise.reject(d)}})();var Ed=a=>(Ed=K.Ea)(a),Pa=()=>(Pa=K.Fa)();e._OrtInit=(a,b)=>(e._OrtInit=K.Ga)(a,b);e._OrtGetLastError=(a,b)=>(e._OrtGetLastError=K.Ha)(a,b);e._OrtCreateSessionOptions=(a,b,c,d,f,g,h,l,m,p)=>(e._OrtCreateSessionOptions=K.Ia)(a,b,c,d,f,g,h,l,m,p);e._OrtAppendExecutionProvider=(a,b,c,d,f)=>(e._OrtAppendExecutionProvider=K.Ja)(a,b,c,d,f);e._OrtAddFreeDimensionOverride=(a,b,c)=>(e._OrtAddFreeDimensionOverride=K.Ka)(a,b,c);
104 | e._OrtAddSessionConfigEntry=(a,b,c)=>(e._OrtAddSessionConfigEntry=K.La)(a,b,c);e._OrtReleaseSessionOptions=a=>(e._OrtReleaseSessionOptions=K.Ma)(a);e._OrtCreateSession=(a,b,c)=>(e._OrtCreateSession=K.Na)(a,b,c);e._OrtReleaseSession=a=>(e._OrtReleaseSession=K.Oa)(a);e._OrtGetInputOutputCount=(a,b,c)=>(e._OrtGetInputOutputCount=K.Pa)(a,b,c);e._OrtGetInputOutputMetadata=(a,b,c,d)=>(e._OrtGetInputOutputMetadata=K.Qa)(a,b,c,d);e._OrtFree=a=>(e._OrtFree=K.Ra)(a);
105 | e._OrtCreateTensor=(a,b,c,d,f,g)=>(e._OrtCreateTensor=K.Sa)(a,b,c,d,f,g);e._OrtGetTensorData=(a,b,c,d,f)=>(e._OrtGetTensorData=K.Ta)(a,b,c,d,f);e._OrtReleaseTensor=a=>(e._OrtReleaseTensor=K.Ua)(a);e._OrtCreateRunOptions=(a,b,c,d)=>(e._OrtCreateRunOptions=K.Va)(a,b,c,d);e._OrtAddRunConfigEntry=(a,b,c)=>(e._OrtAddRunConfigEntry=K.Wa)(a,b,c);e._OrtReleaseRunOptions=a=>(e._OrtReleaseRunOptions=K.Xa)(a);e._OrtCreateBinding=a=>(e._OrtCreateBinding=K.Ya)(a);
106 | e._OrtBindInput=(a,b,c)=>(e._OrtBindInput=K.Za)(a,b,c);e._OrtBindOutput=(a,b,c,d)=>(e._OrtBindOutput=K._a)(a,b,c,d);e._OrtClearBoundOutputs=a=>(e._OrtClearBoundOutputs=K.$a)(a);e._OrtReleaseBinding=a=>(e._OrtReleaseBinding=K.ab)(a);e._OrtRunWithBinding=(a,b,c,d,f)=>(e._OrtRunWithBinding=K.bb)(a,b,c,d,f);e._OrtRun=(a,b,c,d,f,g,h,l)=>(e._OrtRun=K.cb)(a,b,c,d,f,g,h,l);e._OrtEndProfiling=a=>(e._OrtEndProfiling=K.db)(a);e._JsepOutput=(a,b,c)=>(e._JsepOutput=K.eb)(a,b,c);
107 | e._JsepGetNodeName=a=>(e._JsepGetNodeName=K.fb)(a);
108 | var Ka=()=>(Ka=K.gb)(),Y=e._free=a=>(Y=e._free=K.hb)(a),sd=e._malloc=a=>(sd=e._malloc=K.ib)(a),Ma=(a,b,c,d,f,g)=>(Ma=K.lb)(a,b,c,d,f,g),Sa=()=>(Sa=K.mb)(),Pc=(a,b,c,d,f)=>(Pc=K.nb)(a,b,c,d,f),Vc=a=>(Vc=K.ob)(a),Zc=a=>(Zc=K.pb)(a),je=(a,b)=>(je=K.qb)(a,b),Bd=()=>(Bd=K.rb)(),Xc=(a,b)=>(Xc=K.sb)(a,b),Qc=a=>(Qc=K.tb)(a),Oc=a=>(Oc=K.ub)(a),Nc=()=>(Nc=K.vb)(),Yc=e.dynCall_ii=(a,b)=>(Yc=e.dynCall_ii=K.wb)(a,b),Vd=a=>(Vd=K.xb)(a),Kd=()=>(Kd=K.yb)(),Ud=a=>(Ud=K.zb)(a),Xd=()=>(Xd=K.Ab)();
109 | function we(){var a=K;a=Object.assign({},a);var b=d=>f=>d(f)>>>0,c=d=>()=>d()>>>0;a.Ea=b(a.Ea);a.gb=c(a.gb);a.ib=b(a.ib);a.ub=b(a.ub);a.vb=c(a.vb);a.__cxa_get_exception_ptr=b(a.__cxa_get_exception_ptr);return a}e.stackSave=()=>Nc();e.stackRestore=a=>Qc(a);e.stackAlloc=a=>Oc(a);
110 | e.setValue=function(a,b,c="i8"){c.endsWith("*")&&(c="*");switch(c){case "i1":D()[a>>>0]=b;break;case "i8":D()[a>>>0]=b;break;case "i16":G()[a>>>1>>>0]=b;break;case "i32":H()[a>>>2>>>0]=b;break;case "i64":C[a>>>3]=BigInt(b);break;case "float":Ga()[a>>>2>>>0]=b;break;case "double":J()[a>>>3>>>0]=b;break;case "*":I()[a>>>2>>>0]=b;break;default:L(`invalid type for setValue: ${c}`)}};
111 | e.getValue=function(a,b="i8"){b.endsWith("*")&&(b="*");switch(b){case "i1":return D()[a>>>0];case "i8":return D()[a>>>0];case "i16":return G()[a>>>1>>>0];case "i32":return H()[a>>>2>>>0];case "i64":return C[a>>>3];case "float":return Ga()[a>>>2>>>0];case "double":return J()[a>>>3>>>0];case "*":return I()[a>>>2>>>0];default:L(`invalid type for getValue: ${b}`)}};e.UTF8ToString=M;e.stringToUTF8=gd;e.lengthBytesUTF8=fd;
112 | function xe(){if(0<Ua)Va=xe;else if(q)aa(e),Ta();else{for(;0<Ic.length;)Ic.shift()(e);0<Ua?Va=xe:(e.calledRun=!0,A||(Ta(),aa(e)))}}xe();e.PTR_SIZE=4;moduleRtn=da;
113 |
114 |
115 | return moduleRtn;
116 | }
117 | );
118 | })();
119 | export default ortWasmThreaded;
120 | var isPthread = globalThis.self?.name?.startsWith('em-pthread');
121 | var isNode = typeof globalThis.process?.versions?.node == 'string';
122 | if (isNode) isPthread = (await import('worker_threads')).workerData === 'em-pthread';
123 |
124 | // When running as a pthread, construct a new instance on startup
125 | isPthread && ortWasmThreaded();
126 |
```