@bash0816/claude-code 2.1.270 → 2.1.276

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,569 @@
1
+ module.exports = function createBunCellSegmenterShim({ graphemeWidth }) {
2
+ // Constants and bit masks (from vendor bundle analysis)
3
+ const pn = 3; // width mask (2 bits)
4
+ const Ub = 10; // runIndex shift
5
+ const fC = 255; // width mask (8 bits)
6
+ const dC = 256; // tab flag bit
7
+
8
+ // BiDi control character codepoint ranges (U+061C, U+202A-U+202E, U+2066-U+2069)
9
+ const aXe = [[1564, 1564], [8234, 8238], [8294, 8297]];
10
+
11
+ // Build regex for BiDi control character detection
12
+ const Nc = aXe.map(([n, s]) => `\\u{${n.toString(16)}}` + (s > n ? `-\\u{${s.toString(16)}}` : '')).join('');
13
+ const mSn = new RegExp(`[${Nc}]`, 'gu');
14
+
15
+ // Intl.Segmenter instance for grapheme segmentation (reuse across calls)
16
+ const globalSegmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
17
+
18
+ // ============================================================
19
+ // sliceAnsi: Split string by display columns using grapheme units
20
+ // ============================================================
21
+ function sliceAnsi(str, start, end) {
22
+ let visibleCol = 0;
23
+ let result = '';
24
+ let i = 0;
25
+
26
+ // Regex for non-SGR CSI sequences: ESC [ ... (@ to ~, excluding m)
27
+ const csiNonSgrRegex = /^\x1b\[[0-?]*[ -/]*[@-~]/;
28
+
29
+ while (i < str.length) {
30
+ // Invariant: must advance i by at least 1 per iteration
31
+ // Four-way dispatch with catch-all fallback (§9-6)
32
+
33
+ // 1. Complete SGR code: \x1b[...m with params (\d, ;, :)
34
+ if (str[i] === '\x1b' && str[i + 1] === '[') {
35
+ let j = i + 2;
36
+ // Find 'm' terminator, accepting digits, ;, and : (colon for kitty underline)
37
+ while (j < str.length && /[\d;:]/.test(str[j])) {
38
+ j++;
39
+ }
40
+ if (j < str.length && str[j] === 'm') {
41
+ // Match complete SGR
42
+ result += str.slice(i, j + 1);
43
+ i = j + 1;
44
+ continue;
45
+ }
46
+ // Otherwise fall through to catch-all
47
+ }
48
+
49
+ // 2. Complete OSC8 sequence: \x1b]8;;...BEL or \x1b]8...ST
50
+ if (str[i] === '\x1b' && str[i + 1] === ']' && str[i + 2] === '8' && str[i + 3] === ';') {
51
+ let j = i + 4;
52
+ let foundEnd = false;
53
+ while (j < str.length) {
54
+ if (str[j] === '\x07') {
55
+ // BEL terminator
56
+ result += str.slice(i, j + 1);
57
+ i = j + 1;
58
+ foundEnd = true;
59
+ break;
60
+ }
61
+ if (str[j] === '\x1b' && j + 1 < str.length && str[j + 1] === '\\') {
62
+ // ST terminator
63
+ result += str.slice(i, j + 2);
64
+ i = j + 2;
65
+ foundEnd = true;
66
+ break;
67
+ }
68
+ j++;
69
+ }
70
+ if (foundEnd) continue;
71
+ // Otherwise fall through to catch-all (incomplete OSC8)
72
+ }
73
+
74
+ // 3. Non-SGR CSI sequence: match and skip (skip without adding to result)
75
+ if (str[i] === '\x1b' && str[i + 1] === '[') {
76
+ const remaining = str.slice(i);
77
+ const csiMatch = remaining.match(csiNonSgrRegex);
78
+ if (csiMatch) {
79
+ // Skip CSI sequence without adding to result (consumed but not output)
80
+ i += csiMatch[0].length;
81
+ continue;
82
+ }
83
+ // Otherwise fall through to catch-all (malformed CSI)
84
+ }
85
+
86
+ // 4. Catch-all: any other character (ESC alone or normal char)
87
+ // Distinguish between lone ESC and normal text
88
+ if (str[i] === '\x1b') {
89
+ // Single ESC character (incomplete sequence) - consume it as-is
90
+ result += str[i];
91
+ i += 1;
92
+ continue;
93
+ }
94
+
95
+ // Normal character: find the next ESC and segment everything up to it
96
+ let chunkEnd = str.length; // Default: rest of string (no more ESCs)
97
+ for (let j = i + 1; j < str.length; j++) {
98
+ if (str[j] === '\x1b') {
99
+ chunkEnd = j;
100
+ break;
101
+ }
102
+ }
103
+
104
+ const chunk = str.slice(i, chunkEnd);
105
+ const graphemes = Array.from(globalSegmenter.segment(chunk)).map(seg => seg.segment);
106
+
107
+ for (const grapheme of graphemes) {
108
+ const charWidth = graphemeWidth(grapheme);
109
+ const nextCol = visibleCol + charWidth;
110
+
111
+ // Include if entirely within [start, end)
112
+ if (nextCol <= end && visibleCol < end) {
113
+ if (visibleCol >= start) {
114
+ result += grapheme;
115
+ }
116
+ visibleCol = nextCol;
117
+ } else if (visibleCol >= end) {
118
+ break;
119
+ } else {
120
+ visibleCol = nextCol;
121
+ }
122
+ }
123
+
124
+ if (visibleCol >= end) {
125
+ break;
126
+ }
127
+
128
+ i = chunkEnd;
129
+ }
130
+
131
+ return result;
132
+ }
133
+
134
+ // ============================================================
135
+ // sleepSync: Sleep using Atomics.wait (blocking)
136
+ // ============================================================
137
+ function sleepSync(ms) {
138
+ const buf = new Int32Array(new SharedArrayBuffer(4));
139
+ Atomics.wait(buf, 0, 0, ms);
140
+ }
141
+
142
+ // ============================================================
143
+ // CellSegmenter: Main text segmentation and painting class
144
+ // ============================================================
145
+ class CellSegmenter {
146
+ constructor(config) {
147
+ this.ambiguousIsNarrow = config.ambiguousIsNarrow ?? true;
148
+ this.substitute = config.substitute || [];
149
+ this.screen = config.screen || {
150
+ widthMask: pn,
151
+ narrow: 0,
152
+ wide: 1,
153
+ spacerTail: 2,
154
+ spacerHead: 3,
155
+ emptyCharIndex: 0,
156
+ spacerCharIndex: 1,
157
+ emptyWord: 0,
158
+ tabWidth: 8,
159
+ };
160
+
161
+ // GraphemeIndex to charPoolIndex mapping (per-instance state)
162
+ this.graphemes = [];
163
+ this.sgrKeys = ['']; // Index 0 = default (no style applied)
164
+ this.sgrCloseKeys = [''];
165
+ this.uris = ['']; // Index 0 = no link (reserved dummy), per §9-2
166
+ }
167
+
168
+ // ============================================================
169
+ // setCell: Write single cell to destination buffer
170
+ // ============================================================
171
+ setCell(destCells, destWidth, x, y, charPoolIndex, packedStyleHyperlinkWidth) {
172
+ // Clamp to screen width
173
+ if (x < 0 || x >= destWidth || y < 0) {
174
+ return 0;
175
+ }
176
+
177
+ // Calculate cell index: must bind the shift result before adding 1
178
+ const idx = (y * destWidth + x) << 1;
179
+ if (idx + 1 >= destCells.length) {
180
+ return 0; // Out of bounds
181
+ }
182
+
183
+ destCells[idx] = charPoolIndex;
184
+ destCells[idx + 1] = packedStyleHyperlinkWidth;
185
+
186
+ // Return damage rect: xStart * 2^20 + endCol * 2^36
187
+ const xStart = x;
188
+ const endCol = x + 1;
189
+ return endCol + xStart * (2 ** 20) + endCol * (2 ** 36);
190
+ }
191
+
192
+ // ============================================================
193
+ // segment: Parse text into grapheme cells, SGR styles, and URIs (BL-1,2,3,4,5,6,7 fixes)
194
+ // ============================================================
195
+ segment(text, cells, runs, reordered) {
196
+ // Apply BiDi character substitution
197
+ const processedText = text.replace(mSn, '�');
198
+
199
+ // Pre-allocate capacity check
200
+ const estimatedGraphemes = processedText.length;
201
+ if (cells.length < estimatedGraphemes * 2) {
202
+ return -(estimatedGraphemes);
203
+ }
204
+ if (runs.length < estimatedGraphemes * 2) {
205
+ return -(estimatedGraphemes);
206
+ }
207
+
208
+ let graphemeIndex = this.graphemes.length;
209
+ let cellCount = 0;
210
+ let localRunIndex = 0;
211
+ let currentUri = 0;
212
+
213
+ // Track current active style attributes by category (§9-4, BL-6)
214
+ let fgColor = null; // Current foreground color code (null = none)
215
+ let bgColor = null; // Current background color code (null = none)
216
+ const booleanAttrs = new Set(); // bold, dim, italic, underline, blink, reverse, hidden, strikethrough
217
+
218
+ // Track run states to fill runs array later
219
+ const runToState = new Map(); // Map of runIdx -> {sgrCodes, uriIdx}
220
+
221
+ // Helper: build SGR code array from current state
222
+ const buildSgrCodes = () => {
223
+ const codes = [];
224
+ if (fgColor !== null) codes.push(fgColor);
225
+ if (bgColor !== null) codes.push(bgColor);
226
+ for (const attr of booleanAttrs) codes.push(attr);
227
+ return codes.sort();
228
+ };
229
+
230
+ // Helper: get close codes corresponding to open codes (§9-5)
231
+ // Returns codes in escape sequence format: \x1b[...m (not raw codes)
232
+ const getCloseCodes = (openCodes) => {
233
+ const closeMap = {
234
+ '1': '22', '2': '22',
235
+ '3': '23', '4': '24', '5': '25', '6': '25',
236
+ '7': '27', '8': '28', '9': '29'
237
+ };
238
+ return openCodes.map(code => {
239
+ let closeCode = '';
240
+ // Check for composite color codes first
241
+ if (/^38/.test(code)) closeCode = '39'; // Foreground color (38;5;n or 38;2;r;g;b)
242
+ else if (/^48/.test(code)) closeCode = '49'; // Background color (48;5;n or 48;2;r;g;b)
243
+ // Check for basic foreground colors (30-37, 90-97)
244
+ else if (/^(30|31|32|33|34|35|36|37|90|91|92|93|94|95|96|97)$/.test(code)) closeCode = '39';
245
+ // Check for basic background colors (40-47, 100-107)
246
+ else if (/^(40|41|42|43|44|45|46|47|100|101|102|103|104|105|106|107)$/.test(code)) closeCode = '49';
247
+ // Check for other attributes
248
+ else if (/^\d+$/.test(code)) closeCode = closeMap[code] || '';
249
+ // Return as escape sequence: \x1b[...m, or empty if no mapping
250
+ return closeCode ? `\x1b[${closeCode}m` : '';
251
+ });
252
+ };
253
+
254
+ // Helper: parse SGR parameter and update state (BL-6)
255
+ const applySgrParam = (param) => {
256
+ if (param === '0' || param === '') {
257
+ fgColor = null;
258
+ bgColor = null;
259
+ booleanAttrs.clear();
260
+ } else if (param === '1' || param === '2') {
261
+ booleanAttrs.add(param);
262
+ } else if (param === '3') {
263
+ booleanAttrs.add(param);
264
+ } else if (param === '4') {
265
+ booleanAttrs.add(param);
266
+ } else if (param === '5' || param === '6') {
267
+ booleanAttrs.add(param);
268
+ } else if (param === '7') {
269
+ booleanAttrs.add(param);
270
+ } else if (param === '8') {
271
+ booleanAttrs.add(param);
272
+ } else if (param === '9') {
273
+ booleanAttrs.add(param);
274
+ } else if (param === '22') {
275
+ booleanAttrs.delete('1');
276
+ booleanAttrs.delete('2');
277
+ } else if (param === '23') {
278
+ booleanAttrs.delete('3');
279
+ } else if (param === '24') {
280
+ booleanAttrs.delete('4');
281
+ } else if (param === '25') {
282
+ booleanAttrs.delete('5');
283
+ booleanAttrs.delete('6');
284
+ } else if (param === '27') {
285
+ booleanAttrs.delete('7');
286
+ } else if (param === '28') {
287
+ booleanAttrs.delete('8');
288
+ } else if (param === '29') {
289
+ booleanAttrs.delete('9');
290
+ } else if (param === '39') {
291
+ fgColor = null;
292
+ } else if (param === '49') {
293
+ bgColor = null;
294
+ } else if (/^(30|31|32|33|34|35|36|37|90|91|92|93|94|95|96|97)$/.test(param)) {
295
+ fgColor = param;
296
+ } else if (/^(40|41|42|43|44|45|46|47|100|101|102|103|104|105|106|107)$/.test(param)) {
297
+ bgColor = param;
298
+ }
299
+ };
300
+
301
+ // Helper: parse full SGR sequence
302
+ const parseSgrSequence = (paramStr) => {
303
+ if (!paramStr) {
304
+ applySgrParam('0');
305
+ return;
306
+ }
307
+ const parts = paramStr.split(';');
308
+ let k = 0;
309
+ while (k < parts.length) {
310
+ const p = parts[k];
311
+ if ((p === '38' || p === '48') && parts[k + 1] === '5' && k + 2 < parts.length) {
312
+ const composite = `${p};5;${parts[k + 2]}`;
313
+ if (p === '38') fgColor = composite;
314
+ else bgColor = composite;
315
+ k += 3;
316
+ continue;
317
+ } else if ((p === '38' || p === '48') && parts[k + 1] === '2' && k + 4 < parts.length) {
318
+ const composite = `${p};2;${parts[k + 2]};${parts[k + 3]};${parts[k + 4]}`;
319
+ if (p === '38') fgColor = composite;
320
+ else bgColor = composite;
321
+ k += 5;
322
+ continue;
323
+ }
324
+ applySgrParam(p);
325
+ k++;
326
+ }
327
+ };
328
+
329
+ // Regex for non-SGR CSI sequences (with ^ anchor to match at current position)
330
+ const csiNonSgrRegex = /^\x1b\[[0-?]*[ -/]*[@-~]/;
331
+
332
+ let i = 0;
333
+ let prevState = null; // Previous SGR+URI state for BL-3 (monotonic run allocation)
334
+
335
+ while (i < processedText.length) {
336
+ // Invariant: must advance i by at least 1 per iteration (§9-6)
337
+ // Four-way dispatch with catch-all fallback
338
+
339
+ // 1. Complete SGR code: \x1b[...m
340
+ if (processedText[i] === '\x1b' && processedText[i + 1] === '[') {
341
+ let j = i + 2;
342
+ while (j < processedText.length && /[\d;:]/.test(processedText[j])) {
343
+ j++;
344
+ }
345
+ if (j < processedText.length && processedText[j] === 'm') {
346
+ const params = processedText.slice(i + 2, j);
347
+ parseSgrSequence(params);
348
+ i = j + 1;
349
+ continue;
350
+ }
351
+ }
352
+
353
+ // 2. Complete OSC8 sequence: \x1b]8;;...
354
+ if (processedText[i] === '\x1b' && processedText[i + 1] === ']' && processedText[i + 2] === '8' && processedText[i + 3] === ';') {
355
+ let j = i + 4;
356
+ let foundEnd = false;
357
+ while (j < processedText.length) {
358
+ if (processedText[j] === '\x07') {
359
+ const oscSeq = processedText.slice(i + 4, j);
360
+ const semicolonPos = oscSeq.indexOf(';');
361
+ if (semicolonPos >= 0) {
362
+ const url = oscSeq.slice(semicolonPos + 1);
363
+ if (url) {
364
+ let uriIdx = this.uris.indexOf(url);
365
+ if (uriIdx === -1) {
366
+ uriIdx = this.uris.length;
367
+ this.uris.push(url);
368
+ }
369
+ currentUri = uriIdx;
370
+ } else {
371
+ currentUri = 0;
372
+ }
373
+ }
374
+ i = j + 1;
375
+ foundEnd = true;
376
+ break;
377
+ }
378
+ if (processedText[j] === '\x1b' && j + 1 < processedText.length && processedText[j + 1] === '\\') {
379
+ const oscSeq = processedText.slice(i + 4, j);
380
+ const semicolonPos = oscSeq.indexOf(';');
381
+ if (semicolonPos >= 0) {
382
+ const url = oscSeq.slice(semicolonPos + 1);
383
+ if (url) {
384
+ let uriIdx = this.uris.indexOf(url);
385
+ if (uriIdx === -1) {
386
+ uriIdx = this.uris.length;
387
+ this.uris.push(url);
388
+ }
389
+ currentUri = uriIdx;
390
+ } else {
391
+ currentUri = 0;
392
+ }
393
+ }
394
+ i = j + 2;
395
+ foundEnd = true;
396
+ break;
397
+ }
398
+ j++;
399
+ }
400
+ if (foundEnd) continue;
401
+ }
402
+
403
+ // 3. Non-SGR CSI sequence: match and skip
404
+ if (processedText[i] === '\x1b' && processedText[i + 1] === '[') {
405
+ const remaining = processedText.slice(i);
406
+ const csiMatch = remaining.match(csiNonSgrRegex);
407
+ if (csiMatch) {
408
+ i += csiMatch[0].length;
409
+ continue;
410
+ }
411
+ }
412
+
413
+ // 4. Catch-all: lone ESC or normal character
414
+ // Distinguish between lone ESC and normal text
415
+ if (processedText[i] === '\x1b') {
416
+ // Single ESC character (incomplete sequence) - consume it as-is, don't segment
417
+ i += 1;
418
+ continue;
419
+ }
420
+
421
+ // Normal character: find the next ESC and segment everything up to it
422
+ let chunkEnd = processedText.length; // Default: rest of string (no more ESCs)
423
+ for (let j = i + 1; j < processedText.length; j++) {
424
+ if (processedText[j] === '\x1b') {
425
+ chunkEnd = j;
426
+ break;
427
+ }
428
+ }
429
+
430
+ const chunk = processedText.slice(i, chunkEnd);
431
+ const graphemeArray = Array.from(globalSegmenter.segment(chunk)).map(seg => seg.segment);
432
+
433
+ for (const grapheme of graphemeArray) {
434
+ // Determine run index: compare current state with previous (BL-3)
435
+ const currentSgrCodes = buildSgrCodes();
436
+ const currentState = JSON.stringify({ sgr: currentSgrCodes, uri: currentUri });
437
+
438
+ let runIdx;
439
+ if (prevState !== currentState) {
440
+ runIdx = localRunIndex++;
441
+ prevState = currentState;
442
+
443
+ // Register in sgrKeys/sgrCloseKeys pool if needed
444
+ if (currentSgrCodes.length > 0) {
445
+ const poolEntry = currentSgrCodes.map(code => `\x1b[${code}m`).join('\x00');
446
+ let poolIdx = this.sgrKeys.indexOf(poolEntry);
447
+ if (poolIdx === -1) {
448
+ poolIdx = this.sgrKeys.length;
449
+ this.sgrKeys.push(poolEntry);
450
+ const closeCodes = getCloseCodes(currentSgrCodes);
451
+ this.sgrCloseKeys.push(closeCodes.join('\x00'));
452
+ }
453
+ }
454
+
455
+ // Store state for this run
456
+ runToState.set(runIdx, { sgrCodes: currentSgrCodes, uriIdx: currentUri });
457
+ } else {
458
+ // Reuse previous run
459
+ runIdx = localRunIndex - 1;
460
+ }
461
+
462
+ // Add grapheme to pool
463
+ this.graphemes.push(grapheme);
464
+ const width = graphemeWidth(grapheme);
465
+
466
+ cells[cellCount * 2] = graphemeIndex;
467
+ cells[cellCount * 2 + 1] = (runIdx << Ub) | (width & fC);
468
+
469
+ if (grapheme === '\t') {
470
+ cells[cellCount * 2 + 1] |= dC;
471
+ }
472
+
473
+ graphemeIndex++;
474
+ cellCount++;
475
+ }
476
+
477
+ i = chunkEnd;
478
+ }
479
+
480
+ // Build runs array from tracked run states
481
+ for (let runIdx = 0; runIdx < localRunIndex; runIdx++) {
482
+ const state = runToState.get(runIdx) || { sgrCodes: [], uriIdx: 0 };
483
+ let poolIdx = 0;
484
+ if (state.sgrCodes.length > 0) {
485
+ const poolEntry = state.sgrCodes.map(code => `\x1b[${code}m`).join('\x00');
486
+ poolIdx = this.sgrKeys.indexOf(poolEntry);
487
+ if (poolIdx === -1) poolIdx = 0;
488
+ }
489
+ runs[runIdx * 2] = poolIdx;
490
+ runs[runIdx * 2 + 1] = state.uriIdx;
491
+ }
492
+
493
+ return cellCount;
494
+ }
495
+
496
+ // ============================================================
497
+ // paint: Render segmented cells to destination screen buffer
498
+ // ============================================================
499
+ paint(destCells, destWidth, x, y, srcCells, srcCount, unused, charIndices, runWords) {
500
+ let col = x;
501
+ let maxX = x;
502
+
503
+ for (let i = 0; i < srcCount; i++) {
504
+ if (col < 0) {
505
+ col++;
506
+ continue;
507
+ }
508
+
509
+ if (col >= destWidth) {
510
+ break;
511
+ }
512
+
513
+ const graphemeIndex = srcCells[i * 2];
514
+ const width = srcCells[i * 2 + 1] & fC;
515
+ const tab = (srcCells[i * 2 + 1] & dC) !== 0;
516
+ const runIndex = srcCells[i * 2 + 1] >>> Ub;
517
+ const word = runWords[runIndex] || 0;
518
+
519
+ // Skip wide characters that would overshoot screen width
520
+ if (width === 2 && col + 1 >= destWidth) {
521
+ break;
522
+ }
523
+
524
+ // Calculate cell index: bind result to variable before adding 1
525
+ const idx = (y * destWidth + col) << 1;
526
+
527
+ if (tab) {
528
+ // Fill tab stops with spaces (use this.screen.emptyCharIndex for space)
529
+ const tabWidth = this.screen.tabWidth || 8;
530
+ const nextTabStop = Math.min(((Math.floor(col / tabWidth) + 1) * tabWidth), destWidth);
531
+ while (col < nextTabStop && col < destWidth) {
532
+ const cellIdx = (y * destWidth + col) << 1;
533
+ destCells[cellIdx] = this.screen.emptyCharIndex;
534
+ destCells[cellIdx + 1] = word | 0; // width code 0 for space
535
+ col++;
536
+ }
537
+ maxX = col;
538
+ } else {
539
+ destCells[idx] = charIndices[graphemeIndex] || 0;
540
+ destCells[idx + 1] = word | (width === 2 ? 1 : 0);
541
+
542
+ if (width === 2) {
543
+ // Wide character: write spacer tail to next cell
544
+ const spacerIdx = idx + 2;
545
+ if (col + 1 < destWidth && spacerIdx + 1 < destCells.length) {
546
+ destCells[spacerIdx] = this.screen.spacerCharIndex;
547
+ destCells[spacerIdx + 1] = word | 2; // width code 2 (spacerTail)
548
+ }
549
+ col += 2;
550
+ maxX = col;
551
+ } else {
552
+ col++;
553
+ maxX = col;
554
+ }
555
+ }
556
+ }
557
+
558
+ // Return damage rect: must use * and + only, not <<
559
+ const endCol = Math.min(col, destWidth);
560
+ const xStart = x;
561
+ return endCol + xStart * (2 ** 20) + endCol * (2 ** 36);
562
+ }
563
+ }
564
+
565
+ // ============================================================
566
+ // Return factory exports
567
+ // ============================================================
568
+ return { sliceAnsi, sleepSync, CellSegmenter };
569
+ };
@@ -305,6 +305,12 @@ function stableHash(value, seed) {
305
305
  return hash >>> 0;
306
306
  }
307
307
 
308
+ stableHash.xxHash64 = function bunHashXxHash64(value, seed) {
309
+ const lo = stableHash(value, seed);
310
+ const hi = stableHash(value, lo ^ 0x85ebca6b);
311
+ return (BigInt(hi) << 32n) | BigInt(lo);
312
+ };
313
+
308
314
  function replaceRequired(source, pattern, replacement, label, expectedCount) {
309
315
  const text = String(source);
310
316
  const matches = text.match(pattern);
@@ -673,6 +679,7 @@ async function esmChunkedMain() {
673
679
  const libDir = path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib');
674
680
 
675
681
  globalThis.__claudeYaml = createYamlShim();
682
+ const { sliceAnsi, sleepSync, CellSegmenter } = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib', 'bun-cellsegmenter-shim.js'))({ stringWidth, graphemeWidth });
676
683
  globalThis.Bun = {
677
684
  version: '1.1.8',
678
685
  stringWidth,
@@ -692,6 +699,9 @@ async function esmChunkedMain() {
692
699
  unsafe: {
693
700
  setJITPolicy: () => undefined,
694
701
  },
702
+ sliceAnsi,
703
+ sleepSync,
704
+ ant: { CellSegmenter },
695
705
  };
696
706
  Object.defineProperty(process.versions, 'bun', { value: '1.1.8', configurable: true });
697
707
  globalThis.__claudeBunShim = globalThis.Bun;
@@ -930,6 +940,7 @@ async function legacyCjsMain() {
930
940
  process.once('uncaughtException', onAsyncError);
931
941
  process.once('unhandledRejection', onAsyncError);
932
942
  Object.defineProperty(process.versions, 'bun', { value: '1.1.8', configurable: true });
943
+ const { sliceAnsi, sleepSync, CellSegmenter } = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib', 'bun-cellsegmenter-shim.js'))({ stringWidth, graphemeWidth });
933
944
  const _realChild = require('child_process');
934
945
  globalThis.Bun = {
935
946
  version: '1.1.8',
@@ -1016,6 +1027,9 @@ async function legacyCjsMain() {
1016
1027
  unsafe: {
1017
1028
  setJITPolicy: () => undefined,
1018
1029
  },
1030
+ sliceAnsi,
1031
+ sleepSync,
1032
+ ant: { CellSegmenter },
1019
1033
  };
1020
1034
  Object.assign(globalThis.__claudeBunShim, globalThis.Bun);
1021
1035
  if (typeof globalThis.__claudeBunShim.gc !== 'function') {
@@ -1341,6 +1355,12 @@ function stableHash(value, seed) {
1341
1355
  return hash >>> 0;
1342
1356
  }
1343
1357
 
1358
+ stableHash.xxHash64 = function bunHashXxHash64(value, seed) {
1359
+ const lo = stableHash(value, seed);
1360
+ const hi = stableHash(value, lo ^ 0x85ebca6b);
1361
+ return (BigInt(hi) << 32n) | BigInt(lo);
1362
+ };
1363
+
1344
1364
  function replaceRequired(source, pattern, replacement, label, expectedCount) {
1345
1365
  const text = String(source);
1346
1366
  const matches = text.match(pattern);
@@ -1709,6 +1729,7 @@ async function esmChunkedMain() {
1709
1729
  const libDir = path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib');
1710
1730
 
1711
1731
  globalThis.__claudeYaml = createYamlShim();
1732
+ const { sliceAnsi, sleepSync, CellSegmenter } = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib', 'bun-cellsegmenter-shim.js'))({ stringWidth, graphemeWidth });
1712
1733
  globalThis.Bun = {
1713
1734
  version: '1.1.8',
1714
1735
  stringWidth,
@@ -1728,6 +1749,9 @@ async function esmChunkedMain() {
1728
1749
  unsafe: {
1729
1750
  setJITPolicy: () => undefined,
1730
1751
  },
1752
+ sliceAnsi,
1753
+ sleepSync,
1754
+ ant: { CellSegmenter },
1731
1755
  };
1732
1756
  Object.defineProperty(process.versions, 'bun', { value: '1.1.8', configurable: true });
1733
1757
  globalThis.__claudeBunShim = globalThis.Bun;
@@ -1968,6 +1992,7 @@ async function legacyCjsMain() {
1968
1992
  process.once('uncaughtException', onAsyncError);
1969
1993
  process.once('unhandledRejection', onAsyncError);
1970
1994
  Object.defineProperty(process.versions, 'bun', { value: '1.1.8', configurable: true });
1995
+ const { sliceAnsi, sleepSync, CellSegmenter } = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib', 'bun-cellsegmenter-shim.js'))({ stringWidth, graphemeWidth });
1971
1996
  const _realChild = require('child_process');
1972
1997
  globalThis.Bun = {
1973
1998
  version: '1.1.8',
@@ -2054,6 +2079,9 @@ async function legacyCjsMain() {
2054
2079
  unsafe: {
2055
2080
  setJITPolicy: () => undefined,
2056
2081
  },
2082
+ sliceAnsi,
2083
+ sleepSync,
2084
+ ant: { CellSegmenter },
2057
2085
  };
2058
2086
  Object.assign(globalThis.__claudeBunShim, globalThis.Bun);
2059
2087
  if (typeof globalThis.__claudeBunShim.gc !== 'function') {