@pedrofariasx/qwenproxy 1.1.0

package/src/tests/linter.test.ts

@@ -0,0 +1,151 @@
+/*
+ * UltraToolCallLinter v1.0 - Edge Case Stress Tests
+ * Tests required by spec
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert'
+
+import { UltraToolCallLinter } from '../linter/index.js'
+import type { ParseResult, RawToolCandidate } from '../linter/types.js'
+
+// Helper functions to match the old bar.ts API using direct instantiation
+let globalLinter: UltraToolCallLinter | null = null
+
+function getGlobalLinter(): UltraToolCallLinter {
+  if (!globalLinter) globalLinter = new UltraToolCallLinter()
+  return globalLinter
+}
+
+function configure(config: { registry?: any; strictMode?: boolean; enableSecurityGate?: boolean; maxRecoveryAttempts?: number; minConfidenceThreshold?: number }): void {
+  globalLinter = new UltraToolCallLinter(config)
+}
+
+function parseText(input: string): ParseResult {
+  return getGlobalLinter().parseText(input)
+}
+
+function extract(input: string): RawToolCandidate[] {
+  return getGlobalLinter().extract(input)
+}
+
+function repair(input: string): string {
+  return getGlobalLinter().repair(input)
+}
+
+describe('UltraToolCallLinter Edge Cases', () => {
+  it('parses truncated JSON in the middle', () => {
+    configure({ minConfidenceThreshold: 0.1 })
+    const input = 'Here is the query: {"search": {"query": "test"}}'
+    const result = parseText(input)
+    assert.ok(result.toolCalls.length >= 1)
+    assert.equal(result.toolCalls[0].tool, 'search')
+  })
+
+  it('parses concatenated multiple JSONs', () => {
+    const input = '{"name":"search","arguments":{"query":"foo"}}{"name":"browser_open","arguments":{"url":"http://x"}}'
+    const candidates = extract(input)
+    assert.ok(candidates.length >= 1, 'Expected at least one candidate')
+  })
+
+  it('parses markdown-wrapped JSON', () => {
+    const input = '```json\n{"tool":"search","input":{"query":"beer"}}\n```'
+    const result = parseText(input)
+    assert.ok(result.toolCalls.length >= 1)
+    assert.equal(result.toolCalls[0].tool, 'search')
+  })
+
+  it('parses human text mixed with a tool call (ReAct)', () => {
+    const input =
+      'Sure, let me search that for you.\nAction: search\nAction Input: {"query": "breaking news"}'
+    const result = parseText(input)
+    assert.ok(result.toolCalls.length >= 1, 'Expected ReAct extraction')
+  })
+
+  it('recovers from broken escape sequences', () => {
+    const input = '{"tool":"search","input":{"query":"test\\\\n\\\\t\\\\"}}'
+    const result = parseText(input)
+    assert.ok(result.toolCalls.length >= 1)
+  })
+
+  it('recovers from unicode corruption', () => {
+    const input = '{"tool":"search","input":{"query":"caf\u0000\u001Fé"}}'
+    const result = parseText(input)
+    assert.ok(result.toolCalls.length >= 1)
+  })
+
+  it('handles streaming with repeated chunks', () => {
+    const linter = new UltraToolCallLinter({ minConfidenceThreshold: 0.1 })
+    const chunks = [
+      'S',
+      'Su',
+      'Sur',
+      'Sure! ',
+      'Here i',
+      'Here is ',
+      'Here is the ',
+      'Here is the result: ',
+      'Here is the result: {"tool":"search","input":{"query":"async"}}',
+    ]
+    for (const c of chunks) linter.push(c)
+    const result = linter.parse()
+    assert.ok(result.toolCalls.length >= 1)
+  })
+
+  it('extracts tool call inside a textual array', () => {
+    const input =
+      'Options:\n- `{"tool":"search","input":{"query":"foo"}}`\n- `{"tool":"search","input":{"query":"bar"}}`'
+    const candidates = extract(input)
+    assert.ok(candidates.length >= 1, 'Expected extraction from array-text format')
+  })
+
+  it('handles duplicate model output', () => {
+    const input =
+      '{"tool":"search","input":{"query":"dup"}}\n\n{"tool":"search","input":{"query":"dup"}}'
+    const result = parseText(input)
+    assert.ok(Array.isArray(result.toolCalls))
+  })
+
+  it('repair: single quotes to double quotes', () => {
+    const input = "{'tool': 'search', 'input': {'query': 'test'}}"
+    const repaired = repair(input)
+    assert.ok(repaired.includes('search'))
+  })
+
+  it('repair: trailing comma', () => {
+    const input = '{"tool": "search", "input": {"query": "test"},}'
+    const repaired = repair(input)
+    assert.ok(repaired.includes('search'))
+  })
+
+  it('repair: key without quotes', () => {
+    const input = '{tool: "search", input: {query: "test"}}'
+    const repaired = repair(input)
+    assert.ok(repaired.includes('search'))
+  })
+
+  it('security gate blocks destructive shell injection', () => {
+    configure({ minConfidenceThreshold: 0.0 })
+    const input = '{"tool":"search","input":{"query":"\'; rm -rf /; echo \'"}}'
+    const result = parseText(input)
+    const passed = result.toolCalls.some((call: any) => {
+      const val = (call.input.query ?? '') as string
+      return typeof val === 'string' && val.includes('rm -rf /')
+    })
+    assert.strictEqual(passed, false, 'Should not pass through destructive payload')
+  })
+
+  it('rejects empty string values per spec', () => {
+    configure({ minConfidenceThreshold: 0.0 })
+    const input = '{"tool":"search","input":{"query":""}}'
+    const result = parseText(input)
+    assert.ok(Array.isArray(result.toolCalls))
+  })
+
+  it('parseText returns canonical tool calls', () => {
+    configure({ minConfidenceThreshold: 0.1 })
+    const input = '{"tool":"search","input":{"query":"x"}}'
+    const result = parseText(input)
+    assert.ok(Array.isArray(result.toolCalls))
+  })
+})

package/src/tests/parallel.test.ts

@@ -0,0 +1,42 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { executeToolCalls } from '../tools/executor.ts';
+import { registry } from '../tools/registry.ts';
+import type { ToolContext } from '../tools/types.ts';
+
+test('executeToolCalls: parallel execution', async () => {
+  let activeCount = 0;
+  let maxParallel = 0;
+
+  registry.register(
+    'parallel_tool',
+    'A tool that waits to test parallelism',
+    { type: 'object', properties: {} },
+    async () => {
+      activeCount++;
+      maxParallel = Math.max(maxParallel, activeCount);
+      await new Promise(r => setTimeout(r, 100));
+      activeCount--;
+      return 'done';
+    }
+  );
+
+  const toolCalls = [
+    { id: '1', name: 'parallel_tool', arguments: {} },
+    { id: '2', name: 'parallel_tool', arguments: {} },
+    { id: '3', name: 'parallel_tool', arguments: {} },
+  ];
+
+  const context: ToolContext = {
+    messages: [],
+    turn: 0,
+    model: 'test'
+  };
+
+  const results = await executeToolCalls(toolCalls, context);
+  
+  assert.strictEqual(results.length, 3);
+  assert.ok(maxParallel > 1, `Max parallel should be > 1, got ${maxParallel}`);
+  
+  registry.unregister('parallel_tool');
+});

package/src/tests/parser.test.ts

@@ -0,0 +1,89 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { StreamingToolParser } from '../tools/parser.ts';
+
+test('StreamingToolParser: basic tool call', () => {
+  const parser = new StreamingToolParser();
+  
+  const result = parser.feed('Hello! <tool_call>{"name": "t1", "arguments": {"a": 1}}</tool_call>');
+  assert.strictEqual(result.text, 'Hello! ');
+  assert.strictEqual(result.toolCalls.length, 1);
+  assert.strictEqual(result.toolCalls[0].name, 't1');
+});
+
+test('StreamingToolParser: multiple tool calls', () => {
+  const parser = new StreamingToolParser();
+  
+  const result = parser.feed('<tool_call>{"name": "t2", "arguments": {}}</tool_call><tool_call>{"name": "t3", "arguments": {}}</tool_call>');
+  assert.strictEqual(result.text, '');
+  assert.strictEqual(result.toolCalls.length, 2);
+  assert.strictEqual(result.toolCalls[0].name, 't2');
+  assert.strictEqual(result.toolCalls[1].name, 't3');
+});
+
+test('StreamingToolParser: fragmented tool call', () => {
+  const parser = new StreamingToolParser();
+  
+  assert.strictEqual(parser.feed('Text <tool_').text, 'Text ');
+  assert.strictEqual(parser.feed('call>{"name": ').text, '');
+  const final = parser.feed('"frag", "arguments": {}}</tool_call> trailing');
+  
+  assert.strictEqual(final.toolCalls.length, 1);
+  assert.strictEqual(final.toolCalls[0].name, 'frag');
+  assert.strictEqual(final.text, ' trailing');
+});
+
+test('StreamingToolParser: flush partial content', () => {
+  const parser = new StreamingToolParser();
+  
+  parser.feed('Unfinished tag <tool_');
+  assert.strictEqual(parser.flush().text, '<tool_');
+
+  const parser2 = new StreamingToolParser();
+  parser2.feed('Broken tool <tool_call>{"name": "healable"');
+  const flushed = parser2.flush();
+  assert.strictEqual(flushed.toolCalls.length, 1);
+  assert.strictEqual(flushed.toolCalls[0].name, 'healable');
+  
+  const parser3 = new StreamingToolParser();
+  parser3.feed('Invalid <tool_call>NOT_JSON');
+  const flushed2 = parser3.flush();
+  assert.strictEqual(flushed2.text, '<tool_call>NOT_JSON</tool_call>');
+});
+
+test('StreamingToolParser: robust parsing of malformed JSON', () => {
+  const parser = new StreamingToolParser();
+  
+  const res = parser.feed('<tool_call>{"name": "broken", "arguments": {"a": 1</tool_call>');
+  assert.strictEqual(res.toolCalls.length, 1);
+  assert.strictEqual(res.toolCalls[0].name, 'broken');
+  assert.deepStrictEqual(res.toolCalls[0].arguments, { a: 1 });
+});
+
+test('StreamingToolParser: preserves tags in non-tool text', () => {
+  const parser = new StreamingToolParser();
+  
+  const res1 = parser.feed('Fake: <tool_call> { "only_args": 1 } </tool_call> ');
+  assert.ok(res1.text.includes('<tool_call>'), 'Should contain start tag');
+  assert.ok(res1.text.includes('</tool_call>'), 'Should contain end tag');
+  assert.strictEqual(res1.toolCalls.length, 0);
+
+  const res2 = parser.feed('Real: <tool_call>{"name":"r"}</tool_call>');
+  assert.strictEqual(res2.toolCalls.length, 1);
+  assert.strictEqual(res2.toolCalls[0].name, 'r');
+});
+
+test('StreamingToolParser: handles multiple tool calls in array format', () => {
+  const parser = new StreamingToolParser();
+  
+  const chunk = `<tool_call>[
+  {"name": "bash", "arguments": {"command": "ls", "description": "List files"}},
+  {"name": "read", "arguments": {"path": "test.txt"}}
+]</tool_call>`;
+  
+  const result = parser.feed(chunk);
+  assert.strictEqual(result.toolCalls.length, 2, 'Should extract both tool calls');
+  assert.strictEqual(result.toolCalls[0].name, 'bash');
+  assert.strictEqual(result.toolCalls[1].name, 'read');
+  assert.strictEqual(result.toolCalls[0].arguments.command, 'ls');
+});

package/src/tests/rotation.test.ts

@@ -0,0 +1,45 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { getNextAccount, invalidateAccountsCache } from '../core/account-manager.ts';
+import { addAccount, removeAccount, loadAccounts } from '../core/accounts.ts';
+
+test('Account Rotation: Round-Robin rotation cycle', async () => {
+  const originalAccounts = loadAccounts();
+  const originalIds = originalAccounts.map(a => a.id);
+
+  const mockAccounts = [
+    { email: 'account1@test.com', password: 'password1' },
+    { email: 'account2@test.com', password: 'password2' },
+    { email: 'account3@test.com', password: 'password3' },
+  ];
+
+  try {
+    for (const acc of mockAccounts) {
+      addAccount(acc.email, acc.password);
+    }
+    invalidateAccountsCache();
+
+    const first = getNextAccount(true);
+    const second = getNextAccount();
+    const third = getNextAccount();
+    const fourth = getNextAccount();
+
+    assert.ok(first);
+    assert.ok(second);
+    assert.ok(third);
+    assert.ok(fourth);
+
+    assert.strictEqual(first.email, 'account1@test.com');
+    assert.strictEqual(second.email, 'account2@test.com');
+    assert.strictEqual(third.email, 'account3@test.com');
+    assert.strictEqual(fourth.email, 'account1@test.com');
+  } finally {
+    const current = loadAccounts();
+    for (const acc of current) {
+      if (!originalIds.includes(acc.id)) {
+        removeAccount(acc.id);
+      }
+    }
+    invalidateAccountsCache();
+  }
+});

package/src/tests/streamingOptimizations.test.ts

@@ -0,0 +1,328 @@
+/*
+ * File: streamingOptimizations.test.ts
+ * Project: qwenproxy
+ * Author: Pedro Farias
+ * Created: 2026-06-02
+ * 
+ * Last Modified: Tue Jun 02 2026
+ * Modified By: Pedro Farias
+ */
+
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert';
+import { getIncrementalDelta, DeltaResult } from '../routes/chat.js';
+
+describe('Streaming Optimizations Tests', () => {
+  describe('getIncrementalDelta', () => {
+    it('should return full string as delta when oldStr is empty', () => {
+      const result = getIncrementalDelta('', 'Hello World');
+      assert.strictEqual(result.delta, 'Hello World');
+      assert.strictEqual(result.matchedContent, 'Hello World');
+    });
+
+    it('should return empty delta when strings are identical', () => {
+      const result = getIncrementalDelta('Hello World', 'Hello World');
+      assert.strictEqual(result.delta, '');
+      assert.strictEqual(result.matchedContent, 'Hello World');
+    });
+
+    it('should detect cumulative content and return incremental delta', () => {
+      const result = getIncrementalDelta('Hello ', 'Hello World');
+      assert.strictEqual(result.delta, 'World');
+      assert.strictEqual(result.matchedContent, 'Hello World');
+    });
+
+    it('should handle long string prefix matching efficiently', () => {
+      const longPrefix = 'a'.repeat(1000);
+      const oldStr = longPrefix + 'X';
+      const newStr = longPrefix + 'Y';
+      
+      const result = getIncrementalDelta(oldStr, newStr);
+      assert.strictEqual(result.delta, 'Y');
+      assert.strictEqual(result.matchedContent, newStr);
+    });
+
+    it('should handle prefix mismatch by treating as incremental', () => {
+      const result = getIncrementalDelta('abc', 'xyz');
+      // Since no common prefix of length >= 4, treated as incremental
+      assert.strictEqual(result.delta, 'xyz');
+      assert.strictEqual(result.matchedContent, 'abcxyz');
+    });
+
+    it('should handle short prefix matches (below threshold)', () => {
+      const result = getIncrementalDelta('ab', 'abc');
+      // Prefix match of length 2 is below threshold of 4
+      assert.strictEqual(result.delta, 'abc');
+      assert.strictEqual(result.matchedContent, 'ababc');
+    });
+
+    it('should handle threshold boundary correctly', () => {
+      const result = getIncrementalDelta('abcd', 'abcde');
+      // Prefix match of length 4 meets threshold
+      assert.strictEqual(result.delta, 'e');
+      assert.strictEqual(result.matchedContent, 'abcde');
+    });
+
+    it('should handle very long strings with segment-based matching', () => {
+      const base = 'x'.repeat(5000);
+      const oldStr = base;
+      const newStr = base + 'suffix';
+      
+      const result = getIncrementalDelta(oldStr, newStr);
+      assert.strictEqual(result.delta, 'suffix');
+      assert.strictEqual(result.matchedContent, newStr);
+    });
+
+    it('should handle empty new string correctly', () => {
+      const result = getIncrementalDelta('Hello', '');
+      assert.strictEqual(result.delta, '');
+      assert.strictEqual(result.matchedContent, 'Hello');
+    });
+
+    it('should handle unicode characters correctly', () => {
+      const result = getIncrementalDelta('Hello 🌍', 'Hello 🌍🌎');
+      assert.strictEqual(result.delta, '🌎');
+      assert.strictEqual(result.matchedContent, 'Hello 🌍🌎');
+    });
+  });
+
+  describe('Batch Flush Logic', () => {
+    it('should accumulate events until byte threshold', () => {
+      // Simulate batch accumulation logic
+      const MAX_BATCH_BYTES = 4096;
+      const MAX_BATCH_COUNT = 8;
+      
+      let batchBytes = 0;
+      let batchCount = 0;
+      let sseBatch = '';
+      const events: string[] = [];
+      
+      // Add small events
+      for (let i = 0; i < 5; i++) {
+        const evt = `data: {"id":"test","content":"chunk${i}"}\n\n`;
+        sseBatch += evt;
+        batchBytes += evt.length;
+        batchCount++;
+        
+        // Should not flush yet
+        if (batchBytes >= MAX_BATCH_BYTES || batchCount >= MAX_BATCH_COUNT) {
+          events.push(sseBatch);
+          sseBatch = '';
+          batchBytes = 0;
+          batchCount = 0;
+        }
+      }
+      
+      // Should not have flushed yet (5 events < 8 count threshold)
+      assert.strictEqual(batchCount, 5);
+      assert.strictEqual(events.length, 0);
+    });
+
+    it('should flush when count threshold is reached', () => {
+      const MAX_BATCH_BYTES = 4096;
+      const MAX_BATCH_COUNT = 8;
+      
+      let batchBytes = 0;
+      let batchCount = 0;
+      let sseBatch = '';
+      const events: string[] = [];
+      
+      for (let i = 0; i < 10; i++) {
+        const evt = `data: {"id":"test","content":"chunk${i}"}\n\n`;
+        sseBatch += evt;
+        batchBytes += evt.length;
+        batchCount++;
+        
+        if (batchBytes >= MAX_BATCH_BYTES || batchCount >= MAX_BATCH_COUNT) {
+          events.push(sseBatch);
+          sseBatch = '';
+          batchBytes = 0;
+          batchCount = 0;
+        }
+      }
+      
+      // Should have flushed once at 8 events, then accumulated 2 more
+      assert.strictEqual(events.length, 1);
+      assert.strictEqual(batchCount, 2);
+    });
+
+    it('should flush when byte threshold is reached', () => {
+      const MAX_BATCH_BYTES = 100;
+      const MAX_BATCH_COUNT = 8;
+      
+      let batchBytes = 0;
+      let batchCount = 0;
+      let sseBatch = '';
+      const events: string[] = [];
+      
+      // Add large events that will exceed byte threshold
+      for (let i = 0; i < 5; i++) {
+        const content = 'x'.repeat(30); // Each event ~42 bytes
+        const evt = `data: {"id":"test","content":"${content}"}\n\n`;
+        sseBatch += evt;
+        batchBytes += evt.length;
+        batchCount++;
+        
+        if (batchBytes >= MAX_BATCH_BYTES || batchCount >= MAX_BATCH_COUNT) {
+          events.push(sseBatch);
+          sseBatch = '';
+          batchBytes = 0;
+          batchCount = 0;
+        }
+      }
+      
+      // Should have flushed at least once due to byte threshold
+      assert.ok(events.length >= 1);
+    });
+  });
+
+  describe('Buffer Parsing Optimization', () => {
+    it('should parse SSE lines using index-based scanning', () => {
+      const buffer = 'data: chunk1\n\ndata: chunk2\n\ndata: chunk3\n\nremainder';
+      
+      const lines: string[] = [];
+      let startIdx = 0;
+      let newlineIdx: number;
+      
+      while ((newlineIdx = buffer.indexOf('\n', startIdx)) !== -1) {
+        const line = buffer.slice(startIdx, newlineIdx);
+        startIdx = newlineIdx + 1;
+        lines.push(line);
+      }
+      
+      const remainder = buffer.slice(startIdx);
+      
+      assert.deepStrictEqual(lines, ['data: chunk1\n', 'data: chunk2\n', 'data: chunk3\n']);
+      assert.strictEqual(remainder, 'remainder');
+    });
+
+    it('should handle buffer with no newlines correctly', () => {
+      const buffer = 'partial data line';
+      
+      const lines: string[] = [];
+      let startIdx = 0;
+      let newlineIdx: number;
+      
+      while ((newlineIdx = buffer.indexOf('\n', startIdx)) !== -1) {
+        const line = buffer.slice(startIdx, newlineIdx);
+        startIdx = newlineIdx + 1;
+        lines.push(line);
+      }
+      
+      const remainder = buffer.slice(startIdx);
+      
+      assert.deepStrictEqual(lines, []);
+      assert.strictEqual(remainder, 'partial data line');
+    });
+
+    it('should handle empty buffer correctly', () => {
+      const buffer = '';
+      
+      const lines: string[] = [];
+      let startIdx = 0;
+      let newlineIdx: number;
+      
+      while ((newlineIdx = buffer.indexOf('\n', startIdx)) !== -1) {
+        const line = buffer.slice(startIdx, newlineIdx);
+        startIdx = newlineIdx + 1;
+        lines.push(line);
+      }
+      
+      const remainder = buffer.slice(startIdx);
+      
+      assert.deepStrictEqual(lines, []);
+      assert.strictEqual(remainder, '');
+    });
+  });
+
+  describe('Target Response ID Optimization', () => {
+    it('should use boolean flag for targetResponseId check', () => {
+      // Simulate the optimized check pattern
+      let targetResponseId: string | null = null;
+      let targetResponseIdSet = false;
+      
+      // Before target is set
+      const chunk1ResponseId = 'resp-123';
+      const shouldProcess1 = !targetResponseIdSet || chunk1ResponseId === targetResponseId;
+      assert.strictEqual(shouldProcess1, true);
+      
+      // Set target
+      targetResponseId = chunk1ResponseId;
+      targetResponseIdSet = true;
+      
+      // After target is set, matching response_id
+      const chunk2ResponseId = 'resp-123';
+      const shouldProcess2 = !targetResponseIdSet || chunk2ResponseId === targetResponseId;
+      assert.strictEqual(shouldProcess2, true);
+      
+      // Non-matching response_id
+      const chunk3ResponseId = 'resp-456';
+      const shouldProcess3 = !targetResponseIdSet || chunk3ResponseId === targetResponseId;
+      assert.strictEqual(shouldProcess3, false);
+    });
+  });
+
+  describe('Timestamp Pre-computation', () => {
+    it('should use pre-computed timestamp consistently', () => {
+      const createdTimestamp = Math.floor(Date.now() / 1000);
+      
+      // Simulate multiple events using the same timestamp
+      const events = [];
+      for (let i = 0; i < 5; i++) {
+        events.push({
+          id: 'test',
+          object: 'chat.completion.chunk',
+          created: createdTimestamp,
+          model: 'test-model',
+          choices: [{ index: 0, delta: { content: `chunk${i}` } }]
+        });
+      }
+      
+      // All events should have the same timestamp
+      const timestamps = events.map(e => e.created);
+      assert.ok(timestamps.every(t => t === createdTimestamp));
+    });
+  });
+
+  describe('WriteEvent Optimization', () => {
+    it('should use fire-and-forget pattern', () => {
+      // Simulate the writeEvent function
+      const writes: string[] = [];
+      const streamWriter = {
+        write: (data: string) => {
+          writes.push(data);
+          return Promise.resolve();
+        }
+      };
+      
+      const writeEvent = (data: any) => {
+        streamWriter.write(`data: ${JSON.stringify(data)}\n\n`);
+      };
+      
+      writeEvent({ id: 'test', content: 'hello' });
+      writeEvent({ id: 'test', content: 'world' });
+      
+      assert.strictEqual(writes.length, 2);
+      assert.ok(writes[0].includes('hello'));
+      assert.ok(writes[1].includes('world'));
+    });
+  });
+
+  describe('SetImmediate Yielding', () => {
+    it('should yield every 100 chunks to prevent event loop starvation', async () => {
+      const yields: number[] = [];
+      let chunkCount = 0;
+      
+      // Simulate processing 250 chunks
+      for (let i = 0; i < 250; i++) {
+        chunkCount++;
+        if (chunkCount % 100 === 0) {
+          yields.push(chunkCount);
+          await new Promise(r => setImmediate(r));
+        }
+      }
+      
+      assert.deepStrictEqual(yields, [100, 200]);
+    });
+  });
+});