Edge Cases & Stress Tests

// This line is intentionally very long to test horizontal scrolling behavior in code blocks - it should scroll horizontally rather than wrap, and the scrollbar should be styled appropriately for the theme
const reallyLongVariableName = someFunction(parameterOne, parameterTwo, parameterThree, parameterFour, parameterFive, { optionA: true, optionB: false, optionC: 'some string value' });
 
// Normal length lines for comparison
function normalFunction() {
  return 'this is normal';
}
 
// Another extremely long line with a complex type annotation that would typically be found in real-world TypeScript code and should definitely trigger horizontal scrolling
type ComplexGenericType<T extends Record<string, unknown>, U extends keyof T, V extends T[U]> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T];
 
// More normal code
const config = {
  apiKey: process.env.API_KEY,
  timeout: 30000,
};

# Very long bash command that should scroll
curl -X POST https://api.example.com/v1/very/long/endpoint/path/that/keeps/going -H "Authorization: Bearer your-very-long-api-key-that-is-quite-lengthy" -H "Content-Type: application/json" -d '{"key": "value", "another_key": "another_value", "nested": {"deeply": {"nested": "object"}}}'

// 50+ lines to test vertical scrolling and line numbers
import { createClient } from '@example/sdk';
import type { User, Config, ApiError } from '@example/sdk';
 
interface AppConfig extends Config {
  customField: string;
  anotherField: number;
}
 
const config: AppConfig = {
  apiKey: process.env.API_KEY!,
  apiUrl: 'https://api.example.com',
  timeout: 30000,
  retries: 3,
  customField: 'custom',
  anotherField: 42,
};
 
const client = createClient(config);
 
async function fetchAllUsers(): Promise<User[]> {
  const users: User[] = [];
  let cursor: string | undefined;
 
  do {
    const response = await client.users.list({
      limit: 100,
      cursor,
    });
 
    users.push(...response.data);
    cursor = response.hasMore ? response.nextCursor : undefined;
 
    console.log(`Fetched ${users.length} users so far...`);
  } while (cursor);
 
  return users;
}
 
async function processUser(user: User): Promise<void> {
  console.log(`Processing user: ${user.name}`);
 
  if (user.status === 'inactive') {
    console.log('Skipping inactive user');
    return;
  }
 
  await client.users.update(user.id, {
    lastProcessed: new Date().toISOString(),
  });
}
 
async function main(): Promise<void> {
  try {
    const users = await fetchAllUsers();
    console.log(`Total users: ${users.length}`);
 
    for (const user of users) {
      await processUser(user);
    }
 
    console.log('Done!');
  } catch (error) {
    console.error('Failed:', error);
    process.exit(1);
  }
}
 
main();

# Unicode in code
greeting = "Hello, 世界! 🌍"
math_symbols = "∑(i=1 to n) = n(n+1)/2"
arrow_function = "f: A → B"
print(f"Result: {greeting} | {math_symbols}")

const example = {
  nested: {
    code: 'inside callout',
  },
};