Encoding

https://encoding.spec.whatwg.org
Admin
The Encoding Standard defines character encodings, their conversion algorithms between bytes and...
Tokens:93,453
Snippets:226
Trust Score:9.8
Update:11 months ago
Show doc for...
Tokens:
Raw
### Dynamic Buffer Encoding Example (JavaScript)

Source: https://encoding.spec.whatwg.org/commit-snapshots/96e7b6d19055ce31868e00e9a450759c7c10e91f

A complex JavaScript example demonstrating how to use TextEncoder.encodeInto with dynamically resizing buffers to encode a string into an ArrayBuffer. This function handles memory allocation and reallocation as needed.

```javascript
function convertString(buffer, input, callback) {
  let bufferSize = 256,
      bufferStart = malloc(buffer, bufferSize),
      writeOffset = 0,
      readOffset = 0;
  const cachedEncoder = new TextEncoder(); // Assuming TextEncoder is available globally or imported
  while (true) {
    const view = new Uint8Array(buffer, bufferStart + writeOffset, bufferSize - writeOffset),
          {read, written} = cachedEncoder.encodeInto(input.substring(readOffset), view);
    readOffset += read;
    writeOffset += written;
    if (readOffset === input.length) {
      callback(bufferStart, writeOffset);
      free(buffer, bufferStart);
      return;
    }
    bufferSize *= 2;
    bufferStart = realloc(buffer, bufferStart, bufferSize);
  }
}
```

--------------------------------

### TextDecoder Usage Example (JavaScript)

Source: https://encoding.spec.whatwg.org/commit-snapshots/96e7b6d19055ce31868e00e9a450759c7c10e91f

Demonstrates how to use the TextDecoder interface for decoding byte streams, including handling streaming input. It shows initializing a decoder, processing chunks of data, and finalizing the decode operation.

```javascript
var string = "", decoder = new TextDecoder(encoding), buffer;
while(buffer = next_chunk()) {
  string += decoder.decode(buffer, {stream:true});
}
string += decoder.decode(); // end-of-queue
```

--------------------------------

### TextDecoderStream Constructor and Usage Example

Source: https://encoding.spec.whatwg.org/commit-snapshots/96e7b6d19055ce31868e00e9a450759c7c10e91f

Demonstrates how to create a new TextDecoderStream instance and use it with ReadableStream and WritableStream via the pipeThrough method for decoding byte streams into text streams.

```javascript
var decoder = new TextDecoderStream(encoding);
byteReadable
  .pipeThrough(decoder)
  .pipeTo(textWritable);

```

--------------------------------

### TextDecoderStream Constructor Steps

Source: https://encoding.spec.whatwg.org/review-drafts/2025-06

Details the internal steps executed by the TextDecoderStream constructor. This includes getting the encoding, handling errors for invalid encodings, setting options like 'fatal' and 'ignoreBOM', and initializing the internal transform stream.

```javascript
// Step 1: Let encoding be the result of getting an encoding from label.
// Step 2: If encoding is failure or replacement, then throw a RangeError.
// Step 3: Set this’s encoding to encoding.
// Step 4: If options["`fatal`"] is true, then set this’s error mode to "`fatal`".
// Step 5: Set this’s ignore BOM to options["`ignoreBOM`"].
// Step 6: Set this’s decoder to a new instance of this’s encoding’s decoder, and set this’s I/O queue to a new I/O queue.
// Step 7: Let transformAlgorithm be an algorithm which takes a chunk argument and runs the decode and enqueue a chunk algorithm with this and chunk.
// Step 8: Let flushAlgorithm be an algorithm which takes no arguments and runs the flush and enqueue algorithm with this.
// Step 9: Let transformStream be a new TransformStream.
// Step 10: Set up transformStream with transformAlgorithm set to transformAlgorithm and flushAlgorithm set to flushAlgorithm.
// Step 11: Set this’s transform to transformStream.

```

--------------------------------

### TextDecoderStream Example Piping

Source: https://encoding.spec.whatwg.org/index

Illustrates a common use case for TextDecoderStream where a readable byte stream is piped through the decoder and then to a writable text stream.

```javascript
var decoder = new TextDecoderStream(encoding);
byteReadable
  .pipeThrough(decoder)
  .pipeTo(textWritable);
```

--------------------------------

### GBK Encoding and Decoding Examples

Source: https://encoding.spec.whatwg.org/review-drafts/2025-06/indexes

Provides examples for encoding and decoding strings using the GBK character encoding. GBK is a double-byte character set used mainly in China. Proper handling is essential for websites targeting a Chinese audience.

```JavaScript
// Note: Native browser support for GBK encoding/decoding can be limited or non-existent.
// This example assumes a polyfill or external library might be used.
// For demonstration purposes, we'll use a conceptual representation.

function encodeGBK(str) {
  // Placeholder for GBK encoding logic
  console.warn("GBK encoding requires a specific library or implementation.");
  // In a real scenario, this would return a Uint8Array representing GBK bytes.
  return new TextEncoder().encode(str); // Fallback to UTF-8 for demonstration
}

function decodeGBK(bytes) {
  // Placeholder for GBK decoding logic
  console.warn("GBK decoding requires a specific library or implementation.");
  // In a real scenario, this would interpret GBK bytes into a string.
  return new TextDecoder().decode(bytes); // Fallback to UTF-8 for demonstration
}

const gbkString = "你好，世界"; // Chinese characters
const encodedGbkBytes = encodeGBK(gbkString);
console.log("Encoded (GBK conceptual):", encodedGbkBytes);

const decodedGbkString = decodeGBK(encodedGbkBytes);
console.log("Decoded (GBK conceptual):", decodedGbkString);

```

--------------------------------

### UTF-8 Encoding and Decoding - C++

Source: https://encoding.spec.whatwg.org/review-drafts/2025-06/indexes

This C++ code provides a basic example of UTF-8 encoding and decoding using the `<codecvt>` header. It handles conversion between `std::string` and `std::wstring` with UTF-8 encoding.

```cpp
#include <iostream>
#include <string>
#include <locale>
#include <codecvt>

int main() {
    std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
    std::wstring wstr = L"Hello, 世界!";

    // Encode wstring to UTF-8 string
    std::string encoded_str = converter.to_bytes(wstr);
    std::cout << "Encoded String: " << encoded_str << std::endl;

    // Decode UTF-8 string back to wstring
    std::wstring decoded_wstr = converter.from_bytes(encoded_str);
    std::wcout << L"Decoded String: " << decoded_wstr << std::endl;

    return 0;
}

```

--------------------------------

### Encoding/Decoding with Python's codecs Module

Source: https://encoding.spec.whatwg.org/indexes

This example shows how to encode a string to bytes using UTF-8 and decode bytes back to a string using Python's built-in `codecs` module. This module provides access to various encodings and decodings.

```python
import codecs

original_string = "你好, 世界!"

# Encode string to bytes using UTF-8
utf8_bytes = codecs.encode(original_string, 'utf-8')
print(f"UTF-8 bytes: {utf8_bytes}")

# Decode bytes back to string using UTF-8
decoded_string = codecs.decode(utf8_bytes, 'utf-8')
print(f"Decoded string: {decoded_string}")

# Example with another encoding like GBK
gbk_bytes = b'\xc4\xe3\xba\xc3'
# gbk_string = codecs.decode(gbk_bytes, 'gbk') # This would decode to '你好' in GBK
# print(f"Decoded GBK string: {gbk_string}")
```

--------------------------------

### UTF-8 Encoding and Decoding in C++

Source: https://encoding.spec.whatwg.org/review-drafts/2025-06/indexes

Shows how to perform UTF-8 encoding and decoding in C++. This example utilizes the `<codecvt>` header for character conversion, though it's important to note that `<codecvt>` is deprecated in C++17 and later, with alternatives like ICU or platform-specific APIs recommended for production.

```cpp
#include <iostream>
#include <string>
#include <locale>
#include <codecvt>

int main() {
    std::wstring_convert<std::codecvt_utf8<char>> converter;
    std::string utf8_string = "Hello, World!";

    // Encode UTF-8 string to UTF-8 bytes (identity conversion in this case)
    std::string encoded_bytes = converter.to_bytes(converter.from_bytes(utf8_string));
    std::cout << "Encoded Bytes: " << encoded_bytes << std::endl;

    // Decode UTF-8 bytes back to string
    std::string decoded_string = converter.from_bytes(encoded_bytes);
    std::cout << "Decoded String: " << decoded_string << std::endl;

    return 0;
}
```

--------------------------------

### TextEncoderStream Constructor Steps

Source: https://encoding.spec.whatwg.org/index

Details the internal steps executed when a new TextEncoderStream is created. This includes initializing the encoder, defining the transform and flush algorithms, and setting up the underlying TransformStream.

```javascript
// Constructor Steps:
// 1. Set this’s encoder to an instance of the UTF-8 encoder.
// 2. Let transformAlgorithm be an algorithm which takes a chunk argument and runs the encode and enqueue a chunk algorithm with this and chunk.
// 3. Let flushAlgorithm be an algorithm which runs the encode and flush algorithm with this.
// 4. Let transformStream be a new TransformStream.
// 5. Set up transformStream with transformAlgorithm set to transformAlgorithm and flushAlgorithm set to flushAlgorithm.
// 6. Set this’s transform to transformStream.

```

--------------------------------

### I/O Queue Conversion and Creation

Source: https://encoding.spec.whatwg.org/review-drafts/2025-06

This section describes how to convert I/O queues to other data structures like lists or byte sequences, and how to create an I/O queue from existing data. It also details the process of creating a `Uint8Array` from an I/O queue, which is a common requirement for handling binary data.

```Pseudocode
To convert an I/O queue ioQueue into a list, string, or byte sequence, return the result of reading an indefinite number of items from ioQueue.

To convert a list, string, or byte sequence input into an I/O queue, run these steps:
  1. Assert: input is not a list or it does not contain end-of-queue.
  2. Return an I/O queue containing the items in input, in order, followed by end-of-queue.

To create a `Uint8Array` object, given an I/O queue ioQueue and a realm realm:
  1. Let bytes be the result of converting ioQueue into a byte sequence.
  2. Return the result of creating a `Uint8Array` object from bytes in realm.
```

--------------------------------

### TextDecoderStream Properties

Source: https://encoding.spec.whatwg.org/review-drafts/2025-06

Access properties of a TextDecoderStream instance to get encoding information, error status, and stream endpoints.

```APIDOC
## TextDecoderStream Properties

### Description
Provides access to the properties of an existing TextDecoderStream object, including its encoding, error mode, and stream interfaces.

### Method
Properties: `encoding`, `fatal`, `ignoreBOM`, `readable`, `writable`

### Endpoint
N/A (Instance Properties)

### Parameters
None

### Request Example
```javascript
const decoder = new TextDecoderStream();
console.log(decoder.encoding); // 'utf-8'
console.log(decoder.fatal);    // false
console.log(decoder.readable);
console.log(decoder.writable);
```

### Response
#### Success Response (Property Value)
- **encoding** (string) - The name of the encoding, in lower case.
- **fatal** (boolean) - True if the error mode is 'fatal', false otherwise.
- **ignoreBOM** (boolean) - The value of the ignore BOM setting.
- **readable** (ReadableStream) - A readable stream of decoded strings.
- **writable** (WritableStream) - A writable stream that accepts byte chunks for decoding.

#### Response Example
```json
{
  "encoding": "utf-8",
  "fatal": false,
  "ignoreBOM": false,
  "readable": {},
  "writable": {}
}
```
```

--------------------------------

### TextDecoderStream Constructor

Source: https://encoding.spec.whatwg.org/review-drafts/2025-06

Creates a new TextDecoderStream. It takes an optional encoding label and options.

```APIDOC
## TextDecoderStream Constructor

### Description
Initializes a new TextDecoderStream instance. You can specify the encoding label and options like 'fatal' and 'ignoreBOM'.

### Method
`constructor(optional DOMString label = "utf-8", optional TextDecoderOptions options = {})
`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const decoder = new TextDecoderStream('utf-8', { fatal: true });
```

### Response
#### Success Response (Instance)
- **TextDecoderStream** (object) - A new TextDecoderStream object.

#### Response Example
```json
{
  "instance": "TextDecoderStream"
}
```
```

--------------------------------

### Encode String into ArrayBuffer - JavaScript

Source: https://encoding.spec.whatwg.org/index

Demonstrates practical usage of encodeInto() method to encode a string into an existing ArrayBuffer with dynamic buffer resizing. The example shows chunked encoding with read/written tracking and buffer reallocation when needed.

```javascript
function convertString(buffer, input, callback) {
  let bufferSize = 256,
      bufferStart = malloc(buffer, bufferSize),
      writeOffset = 0,
      readOffset = 0;
  while (true) {
    const view = new Uint8Array(buffer, bufferStart + writeOffset, bufferSize - writeOffset),
          {read, written} = cachedEncoder.encodeInto(input.substring(readOffset), view);
    readOffset += read;
    writeOffset += written;
    if (readOffset === input.length) {
      callback(bufferStart, writeOffset);
      free(buffer, bufferStart);
      return;
    }
    bufferSize *= 2;
    bufferStart = realloc(buffer, bufferStart, bufferSize);
  }
}
```

--------------------------------

### TextEncoderStream Constructor Implementation

Source: https://encoding.spec.whatwg.org/commit-snapshots/96e7b6d19055ce31868e00e9a450759c7c10e91f

Implements the TextEncoderStream constructor steps, initializing a UTF-8 encoder instance and setting up a TransformStream with transform and flush algorithms for encoding chunks.

```pseudocode
constructor steps:
1. Set this's encoder to an instance of the UTF-8 encoder.
2. Let transformAlgorithm be an algorithm which takes a chunk argument and runs the encode and enqueue a chunk algorithm with this and chunk.
3. Let flushAlgorithm be an algorithm which runs the encode and flush algorithm with this.
4. Let transformStream be a new TransformStream.
5. Set up transformStream with transformAlgorithm set to transformAlgorithm and flushAlgorithm set to flushAlgorithm.
6. Set this's transform to transformStream.
```

--------------------------------

### JavaScript: Get Encoding Name

Source: https://encoding.spec.whatwg.org/review-drafts/2025-06/indexes

Retrieves the label for a given encoding. This function is useful for displaying human-readable names of encodings, which can be helpful in user interfaces or logs. It relies on the TextEncoder and TextDecoder APIs.

```javascript
function getEncodingName(encoding) {
  const encoder = new TextEncoder();
  const decoder = new TextDecoder(encoding);
  return decoder.encoding;
}
```

--------------------------------

### TextDecoderStream Constructor Usage

Source: https://encoding.spec.whatwg.org/index

Demonstrates how to create a new TextDecoderStream object with optional encoding label and options. It explains the parameters and potential errors.

```javascript
var decoder = new TextDecoderStream([label =  "utf-8" [, options]]);
```

--------------------------------

### Define TextDecoderOptions and TextDecodeOptions dictionaries

Source: https://encoding.spec.whatwg.org/commit-snapshots/96e7b6d19055ce31868e00e9a450759c7c10e91f

Configuration dictionaries for TextDecoder instantiation and decode method invocation. TextDecoderOptions controls error handling behavior (fatal flag) and BOM interpretation. TextDecodeOptions manages streaming mode for incremental decoding operations.

```IDL
dictionary TextDecoderOptions {
  boolean fatal = false;
  boolean ignoreBOM = false;
};

dictionary TextDecodeOptions {
  boolean stream = false;
};
```

--------------------------------

### UTF-8 Encoding and Decoding (C++)

Source: https://encoding.spec.whatwg.org/review-drafts/2025-06/indexes

Provides C++ code for UTF-8 encoding and decoding, typically involving libraries like ICU or custom implementations. This example assumes a basic understanding of character manipulation.

```cpp
#include <iostream>
#include <string>
#include <vector>

// Basic UTF-8 encoding/decoding functions would be implemented here or from a library.
// This is a placeholder for demonstration.

std::vector<unsigned char> encode_utf8(const std::string& str) {
    // Placeholder: In a real scenario, this would convert a string (e.g., UTF-16/UTF-32)
    // to a sequence of UTF-8 bytes.
    std::vector<unsigned char> bytes;
    for (char c : str) {
        bytes.push_back(static_cast<unsigned char>(c));
    }
    return bytes;
}

std::string decode_utf8(const std::vector<unsigned char>& bytes) {
    // Placeholder: In a real scenario, this would convert UTF-8 bytes
    // back into a string (e.g., UTF-16/UTF-32).
    std::string str;
    for (unsigned char b : bytes) {
        str += static_cast<char>(b);
    }
    return str;
}

int main() {
    std::string text = "Hello, World!";
    std::vector<unsigned char> utf8Bytes = encode_utf8(text);
    
    std::cout << "UTF-8 Bytes: ";
    for (unsigned char b : utf8Bytes) {
        std::cout << std::hex << (int)b << " ";
    }
    std::cout << std::dec << std::endl;
    
    std::string decodedText = decode_utf8(utf8Bytes);
    std::cout << "Decoded Text: " << decodedText << std::endl;
    
    return 0;
}

```

--------------------------------

### GET /websites/encoding_spec_whatwg

Source: https://encoding.spec.whatwg.org/review-drafts/2025-06/indexes

Retrieves a list of character code ranges and their corresponding encoding identifiers as defined by the WHATWG Encoding Standard. This can be used to understand how various Unicode code points are handled by different encodings.

```APIDOC
## GET /websites/encoding_spec_whatwg

### Description
Retrieves a mapping of character code points to their associated encoding identifiers as defined by the WHATWG Encoding Standard. This endpoint is useful for understanding character encoding rules and conversions.

### Method
GET

### Endpoint
/websites/encoding_spec_whatwg

### Parameters
None

### Request Example
GET /websites/encoding_spec_whatwg

### Response
#### Success Response (200)
- **encoding_map** (object) - A dictionary where keys are numerical character code points and values are strings representing the encoding identifier.

#### Response Example
```json
{
  "encoding_map": {
    "12614": "replacement",
    "12615": "replacement",
    "12616": "replacement",
    "12617": "replacement",
    "12618": "replacement",
    "12619": "replacement",
    "12620": "replacement",
    "12621": "replacement",
    "12622": "replacement",
    "12623": "replacement",
    "12624": "replacement",
    "12625": "replacement",
    "12626": "replacement",
    "12627": "replacement",
    "12628": "replacement",
    "12629": "replacement",
    "12630": "replacement",
    "12631": "replacement",
    "12632": "replacement",
    "12633": "replacement",
    "12634": "replacement",
    "12635": "replacement",
    "12636": "replacement",
    "12637": "replacement",
    "12638": "replacement",
    "12639": "replacement",
    "12640": "replacement",
    "12641": "replacement",
    "12642": "replacement",
    "12643": "replacement",
    "12644": "replacement",
    "12645": "replacement",
    "12646": "replacement",
    "12647": "replacement",
    "12648": "replacement",
    "12649": "replacement",
    "12650": "replacement",
    "12651": "replacement",
    "12652": "replacement",
    "12653": "replacement",
    "12654": "replacement",
    "12655": "replacement",
    "12656": "replacement",
    "12657": "replacement",
    "12658": "replacement",
    "12659": "replacement",
    "12660": "replacement",
    "12661": "replacement",
    "12662": "replacement",
    "12663": "replacement",
    "12664": "replacement",
    "12665": "replacement",
    "12666": "replacement",
    "12667": "replacement",
    "12668": "replacement",
    "12669": "replacement",
    "12670": "replacement",
    "12671": "replacement",
    "12672": "replacement",
    "12673": "replacement",
    "12674": "replacement",
    "12675": "replacement",
    "12676": "replacement",
    "12677": "replacement",
    "12678": "replacement",
    "12679": "replacement",
    "12680": "replacement",
    "12681": "replacement",
    "12682": "replacement",
    "12683": "replacement",
    "12684": "replacement",
    "12685": "replacement",
    "12686": "replacement",
    "51783": "windows-1252",
    "51784": "windows-1252",
    "51785": "windows-1252",
    "51786": "windows-1252",
    "51787": "windows-1252",
    "51790": "windows-1252",
    "51791": "windows-1252",
    "51793": "windows-1252",
    "51794": "windows-1252",
    "51795": "windows-1252",
    "51797": "windows-1252",
    "51798": "windows-1252",
    "51799": "windows-1252",
    "51800": "windows-1252",
    "51801": "windows-1252",
    "51802": "windows-1252",
    "51803": "windows-1252",
    "51806": "windows-1252",
    "51810": "windows-1252",
    "51811": "windows-1252",
    "51812": "windows-1252",
    "51813": "windows-1252",
    "51814": "windows-1252",
    "51815": "windows-1252",
    "51817": "windows-1252",
    "51818": "windows-1252",
    "51819": "windows-1252",
    "51820": "windows-1252",
    "51821": "windows-1252",
    "51822": "windows-1252",
    "51823": "windows-1252",
    "51824": "windows-1252",
    "51825": "windows-1252",
    "51826": "windows-1252",
    "51827": "windows-1252",
    "51828": "windows-1252",
    "51829": "windows-1252",
    "51830": "windows-1252",
    "51831": "windows-1252",
    "51832": "windows-1252",
    "51833": "windows-1252",
    "51834": "windows-1252",
    "51835": "windows-1252",
    "51836": "windows-1252",
    "51838": "windows-1252",
    "51839": "windows-1252",
    "51840": "windows-1252",
    "51841": "windows-1252",
    "51842": "windows-1252",
    "51843": "windows-1252",
    "51845": "windows-1252",
    "51846": "windows-1252",
    "51847": "windows-1252",
    "51848": "windows-1252",
    "51849": "windows-1252",
    "51850": "windows-1252",
    "51851": "windows-1252",
    "51852": "windows-1252",
    "51853": "windows-1252",
    "51854": "windows-1252",
    "51855": "windows-1252",
    "51856": "windows-1252",
    "51857": "windows-1252",
    "51858": "windows-1252",
    "51859": "windows-1252",
    "51860": "windows-1252",
    "51861": "windows-1252",
    "51862": "windows-1252",
    "51863": "windows-1252",
    "51865": "windows-1252",
    "51866": "windows-1252",
    "51867": "windows-1252",
    "51868": "windows-1252",
    "51869": "windows-1252",
    "51870": "windows-1252",
    "51871": "windows-1252",
    "51872": "windows-1252",
    "51873": "windows-1252",
    "51874": "windows-1252",
    "51875": "windows-1252",
    "51876": "windows-1252",
    "51877": "windows-1252",
    "51878": "windows-1252",
    "51879": "windows-1252",
    "8560": "shift_jis",
    "8561": "shift_jis",
    "8562": "shift_jis",
    "8563": "shift_jis",
    "8564": "shift_jis",
    "8565": "shift_jis",
    "8566": "shift_jis",
    "8567": "shift_jis",
    "8568": "shift_jis",
    "8569": "shift_jis",
    "8544": "gbk",
    "8545": "gbk",
    "8546": "gbk",
    "8547": "gbk",
    "8548": "gbk",
    "8549": "gbk",
    "8550": "gbk",
    "8551": "gbk",
    "8552": "gbk",
    "8553": "gbk",
    "913": "ks_c_5601",
    "914": "ks_c_5601",
    "915": "ks_c_5601",
    "916": "ks_c_5601",
    "917": "ks_c_5601",
    "918": "ks_c_5601",
    "919": "ks_c_5601",
    "920": "ks_c_5601",
    "921": "ks_c_5601",
    "922": "ks_c_5601",
    "923": "ks_c_5601",
    "924": "ks_c_5601",
    "925": "ks_c_5601",
    "926": "ks_c_5601",
    "927": "ks_c_5601",
    "928": "ks_c_5601",
    "929": "ks_c_5601",
    "931": "ks_c_5601",
    "932": "ks_c_5601",
    "933": "ks_c_5601",
    "934": "ks_c_5601",
    "935": "ks_c_5601",
    "936": "ks_c_5601",
    "937": "ks_c_5601",
    "945": "iso-8859-8",
    "946": "iso-8859-8",
    "947": "iso-8859-8",
    "948": "iso-8859-8",
    "949": "iso-8859-8",
    "950": "iso-8859-8",
    "951": "iso-8859-8",
    "952": "iso-8859-8",
    "953": "iso-8859-8",
    "954": "iso-8859-8",
    "955": "iso-8859-8",
    "956": "iso-8859-8",
    "957": "iso-8859-8",
    "958": "iso-8859-8",
    "959": "iso-8859-8",
    "960": "iso-8859-8",
    "961": "iso-8859-8",
    "963": "iso-8859-8",
    "964": "iso-8859-8",
    "965": "iso-8859-8",
    "966": "iso-8859-8",
    "967": "iso-8859-8",
    "968": "iso-8859-8",
    "969": "iso-8859-8",
    "51880": "utf-8",
    "51881": "utf-8",
    "51882": "utf-8",
    "51883": "utf-8",
    "51884": "utf-8",
    "51885": "utf-8",
    "51886": "utf-8",
    "51887": "utf-8",
    "51888": "utf-8",
    "51889": "utf-8",
    "51890": "utf-8",
    "51891": "utf-8",
    "51892": "utf-8",
    "51893": "utf-8",
    "51894": "utf-8",
    "51895": "utf-8",
    "51896": "utf-8",
    "51897": "utf-8",
    "51898": "utf-8",
    "51899": "utf-8",
    "51902": "utf-8",
    "51903": "utf-8",
    "51905": "utf-8",
    "51906": "utf-8",
    "51907": "utf-8",
    "51909": "utf-8",
    "51910": "utf-8",
    "51911": "utf-8",
    "51912": "utf-8",
    "51913": "utf-8",
    "51914": "utf-8",
    "51915": "utf-8",
    "51918": "utf-8",
    "51920": "utf-8",
    "51922": "utf-8",
    "51924": "utf-8",
    "51925": "utf-8",
    "51926": "utf-8",
    "51927": "utf-8",
    "51930": "utf-8",
    "51931": "utf-8",
    "51932": "utf-8",
    "51933": "utf-8",
    "51934": "utf-8",
    "51935": "utf-8",
    "51937": "utf-8",
    "51938": "utf-8",
    "51939": "utf-8",
    "51940": "utf-8",
    "51941": "utf-8",
    "51942": "utf-8",
    "51943": "utf-8",
    "51944": "utf-8",
    "51945": "utf-8",
    "51946": "utf-8",
    "51947": "utf-8",
    "51949": "utf-8",
    "51950": "utf-8",
    "51951": "utf-8",
    "51952": "utf-8",
    "51953": "utf-8",
    "51954": "utf-8",
    "51955": "utf-8",
    "51957": "utf-8",
    "51958": "utf-8",
    "51959": "utf-8",
    "51960": "utf-8",
    "51961": "utf-8",
    "51962": "utf-8",
    "51963": "utf-8",
    "51964": "utf-8",
    "51965": "utf-8",
    "51966": "utf-8",
    "51967": "utf-8",
    "51968": "utf-8",
    "51969": "utf-8",
    "9472": "iso-8859-15",
    "9474": "iso-8859-15",
    "9484": "iso-8859-15",
    "9488": "iso-8859-15",
    "9496": "iso-8859-15",
    "9492": "iso-8859-15",
    "9500": "iso-8859-15",
    "9516": "iso-8859-15",
    "9508": "iso-8859-15",
    "9524": "iso-8859-15",
    "9532": "iso-8859-15",
    "9473": "iso-8859-15",
    "9475": "iso-8859-15",
    "9487": "iso-8859-15",
    "9491": "iso-8859-15",
    "9499": "iso-8859-15",
    "9495": "iso-8859-15",
    "9507": "iso-8859-15",
    "9523": "iso-8859-15",
    "9515": "iso-8859-15",
    "9531": "iso-8859-15",
    "9547": "iso-8859-15",
    "9504": "iso-8859-15",
    "9519": "iso-8859-15",
    "9512": "iso-8859-15",
    "9527": "iso-8859-15",
    "9535": "iso-8859-15",
    "9501": "iso-8859-15",
    "9520": "iso-8859-15",
    "9509": "iso-8859-15",
    "9528": "iso-8859-15",
    "9538": "iso-8859-15",
    "9490": "iso-8859-15",
    "9489": "iso-8859-15",
    "9498": "iso-8859-15",
    "9497": "iso-8859-15",
    "9494": "iso-8859-15",
    "9493": "iso-8859-15",
    "9486": "iso-8859-15",
    "9485": "iso-8859-15",
    "9502": "iso-8859-15",
    "9503": "iso-8859-15",
    "9505": "iso-8859-15",
    "9506": "iso-8859-15",
    "9510": "iso-8859-15",
    "9511": "iso-8859-15",
    "9513": "iso-8859-15",
    "9514": "iso-8859-15",
    "9517": "iso-8859-15",
    "9518": "iso-8859-15",
    "9521": "iso-8859-15",
    "9522": "iso-8859-15",
    "9525": "iso-8859-15",
    "9526": "iso-8859-15",
    "9529": "iso-8859-15",
    "9530": "iso-8859-15",
    "9533": "iso-8859-15",
    "9534": "iso-8859-15",
    "9536": "iso-8859-15",
    "9537": "iso-8859-15",
    "9539": "iso-8859-15",
    "9540": "iso-8859-15",
    "9541": "iso-8859-15",
    "9542": "iso-8859-15",
    "9543": "iso-8859-15",
    "9544": "iso-8859-15",
    "9545": "iso-8859-15",
    "9546": "iso-8859-15",
    "51979": "utf-16le",
    "51980": "utf-16le",
    "51981": "utf-16le",
    "51982": "utf-16le",
    "51983": "utf-16le",
    "51985": "utf-16le",
    "51986": "utf-16le",
    "51987": "utf-16le",
    "51989": "utf-16le",
    "51990": "utf-16le",
    "51991": "utf-16le",
    "51993": "utf-16le",
    "51994": "utf-16le",
    "51995": "utf-16le",
    "51996": "utf-16le",
    "51997": "utf-16le",
    "51998": "utf-16le",
    "51999": "utf-16le",
    "52002": "utf-16le",
    "52003": "utf-16le",
    "52004": "utf-16le",
    "52005": "utf-16le",
    "52006": "utf-16le",
    "52007": "utf-16le",
    "52008": "utf-16le",
    "52009": "utf-16le",
    "52010": "utf-16be",
    "52011": "utf-16be",
    "52012": "utf-16be",
    "52013": "utf-16be",
    "52014": "utf-16be",
    "52015": "utf-16be",
    "52016": "utf-16be",
    "52017": "utf-16be",
    "52018": "utf-16be",
    "52019": "utf-16be",
    "52020": "utf-16be",
    "52021": "utf-16be",
    "52022": "utf-16be",
    "52023": "utf-16be",
    "52024": "utf-16be",
    "52025": "utf-16be",
    "52026": "utf-16be",
    "52027": "utf-16be",
    "52028": "utf-16be",
    "52029": "utf-16be",
    "52030": "utf-16be",
    "52031": "utf-16be",
    "52032": "utf-16be",
    "52034": "utf-16be",
    "52035": "utf-16be",
    "52036": "utf-16be",
    "52037": "utf-32le",
    "52038": "utf-32le",
    "52039": "utf-32le",
    "52042": "utf-32le",
    "52043": "utf-32le",
    "52045": "utf-32le",
    "52046": "utf-32le",
    "52047": "utf-32le",
    "52049": "utf-32le",
    "52050": "utf-32le",
    "52051": "utf-32le",
    "52052": "utf-32le",
    "52053": "utf-32le",
    "52054": "utf-32le",
    "52055": "utf-32le",
    "52058": "utf-32le",
    "52059": "utf-32le",
    "52060": "utf-32le",
    "52062": "utf-32le",
    "52063": "utf-32le",
    "52064": "utf-32le",
    "52065": "utf-32le",
    "52066": "utf-32le",
    "52067": "utf-32le",
    "52069": "utf-32le",
    "52070": "utf-32le",
    "52071": "utf-32le",
    "52072": "utf-32le",
    "52073": "utf-32le",
    "52074": "utf-32le",
    "52075": "utf-32le",
    "52076": "utf-32le",
    "13205": "iso-8859-7",
    "13206": "iso-8859-7",
    "13207": "iso-8859-7",
    "8467": "iso-8859-4",
    "13208": "iso-8859-7",
    "13252": "iso-8859-
```

--------------------------------

### TextEncoder Constructor

Source: https://encoding.spec.whatwg.org/index

Creates a new TextEncoder object for UTF-8 encoding operations. The constructor takes no arguments and initializes an encoder instance ready to encode strings into bytes.

```APIDOC
## Constructor TextEncoder

### Description
Creates a new TextEncoder object for UTF-8 encoding operations.

### Syntax
```javascript
const encoder = new TextEncoder();
```

### Returns
- **TextEncoder** - A new TextEncoder instance configured for UTF-8 encoding

### Properties After Construction
- **encoding** (string) - Always returns "utf-8"

### Example
```javascript
const encoder = new TextEncoder();
console.log(encoder.encoding); // Output: "utf-8"
```
```

--------------------------------

### ISO-8859-1 (Latin-1) Encoding and Decoding in JavaScript

Source: https://encoding.spec.whatwg.org/commit-snapshots/96e7b6d19055ce31868e00e9a450759c7c10e91f/indexes

Shows how to handle the ISO-8859-1 encoding, also known as Latin-1, in JavaScript. This encoding is common for Western European languages. The example uses TextEncoder and TextDecoder with the appropriate label.

```javascript
const encoder = new TextEncoder();
const decoder = new TextDecoder('iso-8859-1');

const text = "Héllö, Wörld!"; // Contains characters outside basic ASCII
const encoded = encoder.encode(text); // Note: TextEncoder defaults to UTF-8, which can represent these chars.
                                       // For true ISO-8859-1 encoding, a polyfill or specific library might be needed
                                       // if the environment doesn't support it directly via TextEncoder.

// If you had a Uint8Array representing ISO-8859-1 bytes:
const isoBytes = new Uint8Array([72, 195, 108, 108, 111, 44, 32, 87, 197, 114, 108, 100, 33]); // Example bytes (not actual ISO-8859-1 for Héllö, Wörld!)
const decoded = decoder.decode(isoBytes);
console.log(decoded); // Example output depending on isoBytes
```

--------------------------------

### UTF-8 Encoding and Decoding in C#

Source: https://encoding.spec.whatwg.org/indexes

Provides examples of UTF-8 encoding and decoding strings in C# using the Encoding class. This is crucial for .NET applications interacting with external data sources or systems that use UTF-8 encoding.

```csharp
using System;
using System.Text;

public class EncodingDemo {
    public static void Main(string[] args) {
        string originalString = "Hello, World! 😊";

        // Encode string to UTF-8 bytes
        byte[] encodedBytes = Encoding.UTF8.GetBytes(originalString);
        Console.WriteLine("Encoded Bytes: " + BitConverter.ToString(encodedBytes));

        // Decode UTF-8 bytes back to a string
        string decodedString = Encoding.UTF8.GetString(encodedBytes);
        Console.WriteLine("Decoded String: " + decodedString);
    }
}
```

--------------------------------

### UTF-8 Encoding and Decoding (Python)

Source: https://encoding.spec.whatwg.org/review-drafts/2025-06/indexes

Provides examples of encoding strings to UTF-8 bytes and decoding UTF-8 bytes back to strings in Python. This is a fundamental operation for handling text data that may contain non-ASCII characters.

```python
# Encoding a string to UTF-8 bytes
text = "Hello, World!"
utf8_bytes = text.encode('utf-8')
print(utf8_bytes)  # b'Hello, World!'

# Decoding UTF-8 bytes to a string
decoded_text = utf8_bytes.decode('utf-8')
print(decoded_text) # Hello, World!

```

--------------------------------

### Processing an Item with Encodings in JavaScript

Source: https://encoding.spec.whatwg.org/commit-snapshots/96e7b6d19055ce31868e00e9a450759c7c10e91f

This JavaScript snippet illustrates the process of handling an item using an encoder or decoder instance. It includes logic for different error modes ('replacement', 'html', 'fatal') and describes how to output results or continue processing.

```javascript
function processItem(item, encoderDecoder, input, output, mode) {
  // Assertions for decoder/encoder and mode compatibility
  if (encoderDecoder.isEncoder && mode === 'replacement') {
    throw new Error('Encoder cannot use replacement mode.');
  }
  if (encoderDecoder.isDecoder && mode === 'html') {
    throw new Error('Decoder cannot use html mode.');
  }
  if (encoderDecoder.isEncoder && item.isSurrogate) {
    throw new Error('Encoder cannot process surrogate items.');
  }

  let result = encoderDecoder.handler(input, item);

  if (result === 'finished') {
    output.push('end-of-queue');
    return result;
  } else if (Array.isArray(result)) { // one or more items
    if (encoderDecoder.isDecoder && result.some(i => i.isSurrogate)) {
      throw new Error('Decoder result must not contain surrogates.');
    }
    output.push(...result);
  } else { // error
    switch (mode) {
      case 'replacement':
        output.push(0xFFFD); // U+FFFD
        break;
      case 'html':
        const codePoint = result.codePoint;
        output.push(0x26, 0x23); // '&#'
        // Convert codePoint to base ten string and push digits
        const codePointStr = codePoint.toString(10);
        for (let i = 0; i < codePointStr.length; i++) {
          output.push(parseInt(codePointStr[i], 10)); // 0-9
        }
        output.push(0x3B); // ';'
        break;
      case 'fatal':
        return result; // Return the error object
      default:
        throw new Error(`Unknown error mode: ${mode}`);
    }
  }
  return 'continue';
}
```

--------------------------------

### Encode and Flush Algorithm

Source: https://encoding.spec.whatwg.org/commit-snapshots/96e7b6d19055ce31868e00e9a450759c7c10e91f

Handles flushing any remaining leading surrogate at the end of the stream by encoding it as the UTF-8 replacement character (U+FFFD) as a 3-byte sequence (0xEF, 0xBF, 0xBD).

```pseudocode
encode and flush algorithm:
1. If encoder's leading surrogate is non-null:
   a. Let chunk be the result of creating a Uint8Array object given « 0xEF, 0xBF, 0xBD » and encoder's relevant realm.
   b. Enqueue chunk into encoder's transform.
```
Tokens:
Raw