Introduction

This is a comprehensive demonstration of every markdown feature available. We’ll explore various formatting options with different lengths to see how they render.

Short Subheading

Brief paragraph with inline code to demonstrate basic styling.

This Is a Much Longer Subheading to Test How Extended Titles Wrap and Display Across Multiple Lines

Here’s a longer paragraph that contains multiple sentences to demonstrate how body text flows and wraps. This paragraph includes bold text, italic text, and even bold italic text to show different emphasis styles. Sometimes you need longer content to truly see how the typography and spacing work together in a real-world scenario.

Text Formatting

You can use bold for emphasis, italics for subtle emphasis, and both combined for maximum impact. You can also use strikethrough text when needed.

Here’s a paragraph with inline code snippets mixed with regular text. The inline code should stand out but not overwhelm the surrounding content.

Headings Hierarchy

Heading 1: Main Title

Heading 2: Section Header

Heading 3: Subsection

Heading 4: Minor Section

Heading 5: Small Heading

Heading 6: Tiny

Code Blocks

Short Code Block

const x = 42;

Medium Code Block

function greet(name) {
  return `Hello, ${name}!`;
}

const message = greet("World");
console.log(message);

Long Code Block with Multiple Concepts

interface User {
  id: string;
  name: string;
  email: string;
  age?: number;
}

class UserRepository {
  private users: Map<string, User> = new Map();

  async create(user: User): Promise<User> {
    if (this.users.has(user.id)) {
      throw new Error(`User with id ${user.id} already exists`);
    }
    this.users.set(user.id, user);
    return user;
  }

  async findById(id: string): Promise<User | undefined> {
    return this.users.get(id);
  }

  async update(id: string, updates: Partial<User>): Promise<User> {
    const user = this.users.get(id);
    if (!user) {
      throw new Error(`User with id ${id} not found`);
    }
    const updatedUser = { ...user, ...updates };
    this.users.set(id, updatedUser);
    return updatedUser;
  }

  async delete(id: string): Promise<boolean> {
    return this.users.delete(id);
  }
}

Python Example

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# Generate first 10 fibonacci numbers
for i in range(10):
    print(f"F({i}) = {fibonacci(i)}")

Code Block with Very Long Lines

// This is a very long line of code that extends far beyond the normal viewport width to test horizontal scrolling behavior in code blocks
const veryLongVariableName =
  "This is a really long string value that goes on and on and on to demonstrate how the code block handles overflow and horizontal scrolling when lines exceed the container width";

function anotherFunctionWithAReallyLongName(
  parameterOne,
  parameterTwo,
  parameterThree,
  parameterFour,
  parameterFive,
  parameterSix,
) {
  return (
    parameterOne +
    parameterTwo +
    parameterThree +
    parameterFour +
    parameterFive +
    parameterSix
  );
}

// Another extremely long comment that just keeps going and going to show what happens when a single line of text in a code block is much wider than the available space
const result = anotherFunctionWithAReallyLongName(
  "value1",
  "value2",
  "value3",
  "value4",
  "value5",
  "value6",
);

Lists

Unordered List

• First item
• Second item with more text to see how longer items wrap and align with the bullet point
• Third item
  • Nested item one
  • Nested item two with extended text that goes on for a while to test wrapping behavior
    • Deeply nested item
• Fourth item

Ordered List

1. First step
2. Second step with detailed explanation that spans multiple lines to demonstrate how numbered lists handle longer content
3. Third step
   1. Sub-step A
   2. Sub-step B with additional context
   3. Sub-step C
4. Final step

Mixed List

1. Start with ordered
2. Continue ordered
   • Switch to unordered
   • More unordered items
     1. Back to ordered
     2. Nested ordered
   • Return to unordered
3. Back to top-level ordered

Blockquotes

Simple quote.

This is a longer blockquote that spans multiple lines to demonstrate how quoted text is styled and formatted. It should be visually distinct from regular paragraphs while maintaining readability.

Nested quote example:

This is a quote within a quote, demonstrating how deeper levels of quotation are rendered.

Links

Here’s a simple link in text.

This paragraph contains multiple different links to show how they appear in context with regular text flow.

Horizontal Rules

Content above the line.

---

Content below the line.

---

Another section.

Combining Elements

Here’s a paragraph that combines multiple formatting options including inline code, links, and heavy emphasis.

Complex Example

Here’s a real-world example combining several elements:

1. Step 1: Install the package using npm install package-name
2. Step 2: Import it in your code:

import { Component } from "package-name";

const instance = new Component({
  option1: true,
  option2: "value",
});

3. Step 3: Use it in your application with proper configuration

Note: Make sure to configure environment variables before running in production.

Tables

Feature	Support	Notes
Headers	✓	All levels H1-H6
Bold	✓	Using ** or __
Italic	✓	Using * or _
Code	✓	Inline and blocks
Lists	✓	Ordered and unordered
Links	✓	Standard markdown syntax
Tables	✓	As shown here

Short	Med	This is a very long column header
A	Data	Extended data entry here
B	More	Additional information
C	Even more	Complex nested information goes in this cell

Edge Cases

Multiple Code Blocks in Sequence

npm install

npm run dev

npm run build

Lists with Code

• Item with inline code
• Item with code block:

const x = 1;

• Item after code block

Quote with Code

Here’s a quote with inline code inside it.

const quoted = true;

Conclusion

This document demonstrates all major markdown features including:

• Multiple heading levels (H1-H6)
• Text formatting (bold, italic, combinations)
• Code blocks (short, medium, long)
• Various list types (ordered, unordered, nested)
• Blockquotes (simple and nested)
• Links and inline code
• Tables with various column widths
• Horizontal rules
• Complex combinations of elements

Everything should render properly with appropriate spacing, typography, and visual hierarchy.