Markdown Testsuite 📝

1// Regular JavaScript example
2function calculateTotal(items) {
3    return items
4        .filter((item) => item.price > 0)
5        .map((item) => item.price * item.quantity)
6        .reduce((total, price) => total + price, 0);
7}
8
9const total = calculateTotal([
10    { name: "Keyboard", price: 89.99, quantity: 1 },
11    { name: "Mouse", price: 49.99, quantity: 1 },
12    { name: "Monitor", price: 199.99, quantity: 2 }
13]);
14
15console.log(`Total: $${total.toFixed(2)}`); // Total: $539.96

1// TypeScript example with type annotations
2interface Product {
3    Product.name: stringname: string;
4    Product.price: numberprice: number;
5    Product.quantity: numberquantity: number;
6}
7
8function function calculateDiscount(products: Product[], discountRate: number): numbercalculateDiscount(products: Product[]products: 
Product[], discountRate: numberdiscountRate: number): number {
9    const const total: numbertotal = products: Product[]products.Array<Product>.reduce<number>(callbackfn: (previousValue: number, currentValue: Product, currentIndex: number, array: Product[]) => number, initialValue: number): number (+2 overloads)
Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
@paramcallbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.@paraminitialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.reduce((sum: numbersum, product: Productproduct) => {
10        return sum: numbersum + product: Productproduct.Product.price: numberprice * product: Productproduct.Product.quantity: numberquantity;
11    }, 0);
12
13    return const total: numbertotal * discountRate: numberdiscountRate;
14}
15
16const 
const products: {
    name: string;
    price: number;
    quantity: number;
}[]products = [
17    { name: stringname: "Keyboard", price: numberprice: 89.99, quantity: numberquantity: 1 },
18    { name: stringname: "Mouse", price: numberprice: 49.99, quantity: numberquantity: 1 }
19];
20
21const 
const discount: numberdiscount = function calculateDiscount(products: Product[], discountRate: number): numbercalculateDiscount(
const products: {
    name: string;
    price: number;
    quantity: number;
}[]products, 0.1);
22var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v22.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log(`Discount: $${const discount: numberdiscount.Number.toFixed(fractionDigits?: number): string
Returns a string representing a number in fixed-point notation.
@paramfractionDigits Number of digits after the decimal point. Must be in the range 0 - 20, inclusive.toFixed(2)}`);

1function sendWelcomeEmail(user) {
-2    const subject = "Welcome to our service"; 
+3    const subject = `Welcome to our service, ${user.name}!`; 
4
-5    const body = "Thanks for signing up."; 
6    const body = `
7    <h1>Welcome aboard, ${user.name}!</h1>
8    <p>We're excited to have you join our community.</p>
9    <p>Your account is now active.</p>
+10  `; 
11
12    return sendEmail(user.email, subject, body);
13}

1// Authentication middleware
2type type NextFunction = (err?: any) => voidNextFunction = (err: anyerr?: any) => void;
3type 
type Request = {
    headers: {
        authorization: string;
    };
    user?: {
        id: string;
        roles: string[];
    };
}Request = { 
headers: {
    authorization: string;
}headers: { authorization: stringauthorization: string }; 
user?: {
    id: string;
    roles: string[];
} | undefineduser?: { id: stringid: string; roles: string[]roles: string[] } };
4type 
type Response = {
    status: (code: number) => {
        json: (data: any) => void;
    };
}Response = { 
status: (code: number) => {
    json: (data: any) => void;
}status: (code: numbercode: number) => { json: (data: any) => voidjson: (data: anydata: any) => void } };
5const 
const jwt: {
    verify: (token: string, secret: string) => {
        id: string;
        roles: string[];
    };
}jwt = { 
verify: (token: string, secret: string) => {
    id: string;
    roles: string[];
}verify: (token: stringtoken: string, secret: stringsecret: string) => ({ id: stringid: "123", roles: string[]roles: ["user"] }) };
6const 
const process: {
    env: {
        JWT_SECRET: string;
    };
}process = { 
env: {
    JWT_SECRET: string;
}env: { type JWT_SECRET: stringJWT_SECRET: "supersecret" } };
7export const const authMiddleware: (req: Request, res: Response, next: NextFunction) => Promise<void>authMiddleware = async (req: Requestreq: 
type Request = {
    headers: {
        authorization: string;
    };
    user?: {
        id: string;
        roles: string[];
    };
}Request, res: Responseres: 
type Response = {
    status: (code: number) => {
        json: (data: any) => void;
    };
}Response, next: NextFunctionnext: type NextFunction = (err?: any) => voidNextFunction) => {
8    try {
9        // Extract token from Authorization header
10        const const authHeader: stringauthHeader = req: Requestreq.
headers: {
    authorization: string;
}headers.authorization: stringauthorization;
11        if (!const authHeader: stringauthHeader?.String.startsWith(searchString: string, position?: number): boolean
Returns true if the sequence of elements of searchString converted to a String is the
same as the corresponding elements of this object (converted to a String) starting at
position. Otherwise returns false.startsWith("Bearer ")) {
*12
13            return res: Responseres.
status: (code: number) => {
    json: (data: any) => void;
}status(401).json: (data: any) => voidjson({ message: stringmessage: "Authentication token required" });
14        }
15
16        const const token: stringtoken = const authHeader: stringauthHeader.String.split(separator: string | RegExp, limit?: number): string[] (+1 overload)
Split a string into substrings using the specified separator and return them as an array.
@paramseparator A string that identifies character or characters to use in separating the string. If omitted, a single-element array containing the entire string is returned.@paramlimit A value used to limit the number of elements returned in the array.split(" ")[1];
17        if (!const token: stringtoken) {
*18
19            return res: Responseres.
status: (code: number) => {
    json: (data: any) => void;
}status(401).json: (data: any) => voidjson({ message: stringmessage: "Invalid authentication token" });
20        }
21
22        // Verify JWT token
23        const 
const decoded: {
    id: string;
    roles: string[];
}decoded = 
const jwt: {
    verify: (token: string, secret: string) => {
        id: string;
        roles: string[];
    };
}jwt.
verify: (token: string, secret: string) => {
    id: string;
    roles: string[];
}verify(const token: stringtoken, 
const process: {
    env: {
        JWT_SECRET: string;
    };
}process.
env: {
    JWT_SECRET: string;
}env.type JWT_SECRET: stringJWT_SECRET); 
24
25        // Attach user information to request
26        req: Requestreq.
user?: {
    id: string;
    roles: string[];
} | undefineduser = 
const decoded: {
    id: string;
    roles: string[];
}decoded;
27
28        next: (err?: any) => voidnext();
29    } catch (function (local var) error: unknownerror) {
30        return res: Responseres.
status: (code: number) => {
    json: (data: any) => void;
}status(401).json: (data: any) => voidjson({ message: stringmessage: "Invalid or expired token" });
31    }
32};