nokolexbor 0.3.3 → 0.3.5

data/vendor/lexbor/source/lexbor/encoding/encode.c

@@ -1,1931 +0,0 @@
-/*
- * Copyright (C) 2019 Alexander Borisov
- *
- * Author: Alexander Borisov <borisov@lexbor.com>
- */
-
-#include "lexbor/encoding/encode.h"
-#include "lexbor/encoding/single.h"
-#include "lexbor/encoding/multi.h"
-#include "lexbor/encoding/range.h"
-
-
-#define LXB_ENCODING_ENCODE_APPEND(ctx, cp)                                    \
-    do {                                                                       \
-        if ((ctx)->buffer_used == (ctx)->buffer_length) {                      \
-            return LXB_STATUS_SMALL_BUFFER;                                    \
-        }                                                                      \
-                                                                               \
-        (ctx)->buffer_out[(ctx)->buffer_used++] = (lxb_char_t) cp;             \
-    }                                                                          \
-    while (0)
-
-#define LXB_ENCODING_ENCODE_APPEND_P(ctx, cp)                                  \
-    do {                                                                       \
-        if ((ctx)->buffer_used == (ctx)->buffer_length) {                      \
-            *cps = p;                                                          \
-            return LXB_STATUS_SMALL_BUFFER;                                    \
-        }                                                                      \
-                                                                               \
-        (ctx)->buffer_out[(ctx)->buffer_used++] = (lxb_char_t) cp;             \
-    }                                                                          \
-    while (0)
-
-#define LXB_ENCODING_ENCODE_ERROR(ctx)                                         \
-    do {                                                                       \
-        if (ctx->replace_to == NULL) {                                         \
-            return LXB_STATUS_ERROR;                                           \
-        }                                                                      \
-                                                                               \
-        if ((ctx->buffer_used + ctx->replace_len) > ctx->buffer_length) {      \
-            return LXB_STATUS_SMALL_BUFFER;                                    \
-        }                                                                      \
-                                                                               \
-        memcpy(&ctx->buffer_out[ctx->buffer_used], ctx->replace_to,            \
-               ctx->replace_len);                                              \
-                                                                               \
-        ctx->buffer_used += ctx->replace_len;                                  \
-    }                                                                          \
-    while (0)
-
-#define LXB_ENCODING_ENCODE_ERROR_P(ctx)                                       \
-    do {                                                                       \
-        if (ctx->replace_to == NULL) {                                         \
-            *cps = p;                                                          \
-            return LXB_STATUS_ERROR;                                           \
-        }                                                                      \
-                                                                               \
-        if ((ctx->buffer_used + ctx->replace_len) > ctx->buffer_length) {      \
-            *cps = p;                                                          \
-            return LXB_STATUS_SMALL_BUFFER;                                    \
-        }                                                                      \
-                                                                               \
-        memcpy(&ctx->buffer_out[ctx->buffer_used], ctx->replace_to,            \
-               ctx->replace_len);                                              \
-                                                                               \
-        ctx->buffer_used += ctx->replace_len;                                  \
-    }                                                                          \
-    while (0)
-
-#define LXB_ENCODING_ENCODE_SINGLE_BYTE(table, table_size)                     \
-    do {                                                                       \
-        lxb_codepoint_t cp;                                                    \
-        const lxb_codepoint_t *p = *cps;                                       \
-        const lexbor_shs_hash_t *hash;                                         \
-                                                                               \
-        for (; p < end; p++) {                                                 \
-            cp = *p;                                                           \
-                                                                               \
-            if (cp < 0x80) {                                                   \
-                LXB_ENCODING_ENCODE_APPEND_P(ctx, cp);                         \
-                continue;                                                      \
-            }                                                                  \
-                                                                               \
-            hash = lexbor_shs_hash_get_static(table, table_size, cp);          \
-            if (hash == NULL) {                                                \
-                LXB_ENCODING_ENCODE_ERROR_P(ctx);                              \
-                continue;                                                      \
-            }                                                                  \
-                                                                               \
-            LXB_ENCODING_ENCODE_APPEND_P(ctx, (uintptr_t) hash->value);        \
-        }                                                                      \
-                                                                               \
-        return LXB_STATUS_OK;                                                  \
-    }                                                                          \
-    while (0)
-
-#define LXB_ENCODING_ENCODE_BYTE_SINGLE(table, table_size)                     \
-    const lexbor_shs_hash_t *hash;                                             \
-                                                                               \
-    if (cp < 0x80) {                                                           \
-        *(*data)++ = (lxb_char_t) cp;                                          \
-        return 1;                                                              \
-    }                                                                          \
-                                                                               \
-    hash = lexbor_shs_hash_get_static(table, table_size, cp);                  \
-    if (hash == NULL) {                                                        \
-        return LXB_ENCODING_ENCODE_ERROR;                                      \
-    }                                                                          \
-                                                                               \
-    *(*data)++ = (lxb_char_t) (uintptr_t) hash->value;                         \
-    return 1
-
-
-lxb_status_t
-lxb_encoding_encode_default(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                            const lxb_codepoint_t *end)
-{
-    return lxb_encoding_encode_utf_8(ctx, cps, end);
-}
-
-lxb_status_t
-lxb_encoding_encode_auto(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                         const lxb_codepoint_t *end)
-{
-    *cps = end;
-    return LXB_STATUS_ERROR;
-}
-
-lxb_status_t
-lxb_encoding_encode_undefined(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                              const lxb_codepoint_t *end)
-{
-    *cps = end;
-    return LXB_STATUS_ERROR;
-}
-
-lxb_status_t
-lxb_encoding_encode_big5(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                         const lxb_codepoint_t *end)
-{
-    lxb_codepoint_t cp;
-    const lexbor_shs_hash_t *hash;
-
-    for (; *cps < end; (*cps)++) {
-        cp = **cps;
-
-        if (cp < 0x80) {
-            LXB_ENCODING_ENCODE_APPEND(ctx, cp);
-            continue;
-        }
-
-        hash = lexbor_shs_hash_get_static(lxb_encoding_multi_hash_big5,
-                                          LXB_ENCODING_MULTI_HASH_BIG5_SIZE, cp);
-        if (hash == NULL) {
-            LXB_ENCODING_ENCODE_ERROR(ctx);
-            continue;
-        }
-
-        if ((ctx->buffer_used + 2) > ctx->buffer_length) {
-            return LXB_STATUS_SMALL_BUFFER;
-        }
-
-        ctx->buffer_out[ ctx->buffer_used++ ] = ((uint32_t) (uintptr_t) hash->value) / 157 + 0x81;
-
-        if ((((uint32_t) (uintptr_t) hash->value) % 157) < 0x3F) {
-            ctx->buffer_out[ ctx->buffer_used++ ] = (((uint32_t) (uintptr_t) hash->value) % 157) + 0x40;
-        }
-        else {
-            ctx->buffer_out[ ctx->buffer_used++ ] = (((uint32_t) (uintptr_t) hash->value) % 157) + 0x62;
-        }
-    }
-
-    return LXB_STATUS_OK;
-}
-
-lxb_status_t
-lxb_encoding_encode_euc_jp(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                           const lxb_codepoint_t *end)
-{
-    lxb_codepoint_t cp;
-    const lexbor_shs_hash_t *hash;
-
-    for (; *cps < end; (*cps)++) {
-        cp = **cps;
-
-        if (cp < 0x80) {
-            LXB_ENCODING_ENCODE_APPEND(ctx, cp);
-            continue;
-        }
-
-        if (cp == 0x00A5) {
-            LXB_ENCODING_ENCODE_APPEND(ctx, 0x5C);
-            continue;
-        }
-
-        if (cp == 0x203E) {
-            LXB_ENCODING_ENCODE_APPEND(ctx, 0x7E);
-            continue;
-        }
-
-        if ((unsigned) (cp - 0xFF61) <= (0xFF9F - 0xFF61)) {
-            if ((ctx->buffer_used + 2) > ctx->buffer_length) {
-                return LXB_STATUS_SMALL_BUFFER;
-            }
-
-            ctx->buffer_out[ ctx->buffer_used++ ] = 0x8E;
-            ctx->buffer_out[ ctx->buffer_used++ ] = cp - 0xFF61 + 0xA1;
-
-            continue;
-        }
-
-        if (cp == 0x2212) {
-            cp = 0xFF0D;
-        }
-
-        hash = lexbor_shs_hash_get_static(lxb_encoding_multi_hash_jis0208,
-                                          LXB_ENCODING_MULTI_HASH_JIS0208_SIZE, cp);
-        if (hash == NULL) {
-            LXB_ENCODING_ENCODE_ERROR(ctx);
-            continue;
-        }
-
-        if ((ctx->buffer_used + 2) > ctx->buffer_length) {
-            return LXB_STATUS_SMALL_BUFFER;
-        }
-
-        ctx->buffer_out[ ctx->buffer_used++ ] = (uint32_t) (uintptr_t) hash->value / 94 + 0xA1;
-        ctx->buffer_out[ ctx->buffer_used++ ] = (uint32_t) (uintptr_t) hash->value % 94 + 0xA1;
-    }
-
-    return LXB_STATUS_OK;
-}
-
-lxb_status_t
-lxb_encoding_encode_euc_kr(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                           const lxb_codepoint_t *end)
-{
-    lxb_codepoint_t cp;
-    const lexbor_shs_hash_t *hash;
-
-    for (; *cps < end; (*cps)++) {
-        cp = **cps;
-
-        if (cp < 0x80) {
-            LXB_ENCODING_ENCODE_APPEND(ctx, cp);
-            continue;
-        }
-
-        hash = lexbor_shs_hash_get_static(lxb_encoding_multi_hash_euc_kr,
-                                          LXB_ENCODING_MULTI_HASH_EUC_KR_SIZE, cp);
-        if (hash == NULL) {
-            LXB_ENCODING_ENCODE_ERROR(ctx);
-            continue;
-        }
-
-        if ((ctx->buffer_used + 2) > ctx->buffer_length) {
-            return LXB_STATUS_SMALL_BUFFER;
-        }
-
-        ctx->buffer_out[ ctx->buffer_used++ ] = (uint32_t) (uintptr_t) hash->value / 190 + 0x81;
-        ctx->buffer_out[ ctx->buffer_used++ ] = (uint32_t) (uintptr_t) hash->value % 190 + 0x41;
-    }
-
-    return LXB_STATUS_OK;
-}
-
-lxb_status_t
-lxb_encoding_encode_gbk(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                        const lxb_codepoint_t *end)
-{
-    lxb_codepoint_t cp;
-    const lexbor_shs_hash_t *hash;
-
-    for (; *cps < end; (*cps)++) {
-        cp = **cps;
-
-        if (cp < 0x80) {
-            LXB_ENCODING_ENCODE_APPEND(ctx, cp);
-            continue;
-        }
-
-        if (cp == 0xE5E5) {
-            LXB_ENCODING_ENCODE_ERROR(ctx);
-            continue;
-        }
-
-        if (cp == 0x20AC) {
-            LXB_ENCODING_ENCODE_APPEND(ctx, 0x80);
-            continue;
-        }
-
-        hash = lexbor_shs_hash_get_static(lxb_encoding_multi_hash_gb18030,
-                                          LXB_ENCODING_MULTI_HASH_GB18030_SIZE, cp);
-        if (hash == NULL) {
-            LXB_ENCODING_ENCODE_ERROR(ctx);
-            continue;
-        }
-
-        if ((ctx->buffer_used + 2) > ctx->buffer_length) {
-            return LXB_STATUS_SMALL_BUFFER;
-        }
-
-        ctx->buffer_out[ ctx->buffer_used++ ] = (lxb_char_t) (uintptr_t) hash->value / 190 + 0x81;
-
-        if (((lxb_char_t) (uintptr_t) hash->value % 190) < 0x3F) {
-            ctx->buffer_out[ ctx->buffer_used++ ] = ((lxb_char_t) (uintptr_t) hash->value % 190) + 0x40;
-        }
-        else {
-            ctx->buffer_out[ ctx->buffer_used++ ] = ((lxb_char_t) (uintptr_t) hash->value % 190) + 0x41;
-        }
-    }
-
-    return LXB_STATUS_OK;
-}
-
-lxb_status_t
-lxb_encoding_encode_ibm866(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                           const lxb_codepoint_t *end)
-{
-
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_ibm866,
-                                    LXB_ENCODING_SINGLE_HASH_IBM866_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_2022_jp(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                const lxb_codepoint_t *end)
-{
-    int8_t size;
-    unsigned state;
-    lxb_codepoint_t cp;
-    const lexbor_shs_hash_t *hash;
-
-    size = 0;
-    state = ctx->state;
-
-    for (; *cps < end; (*cps)++) {
-        cp = **cps;
-
-    begin:
-
-        switch (ctx->state) {
-            case LXB_ENCODING_ENCODE_2022_JP_ASCII:
-                if (cp == 0x000E || cp == 0x000F || cp == 0x001B) {
-                    goto failed;
-                }
-
-                if (cp < 0x80) {
-                    LXB_ENCODING_ENCODE_APPEND(ctx, cp);
-                    continue;
-                }
-
-                if (cp == 0x00A5 || cp == 0x203E) {
-                    /*
-                     * Do not switch to the ROMAN stage with prepend code point
-                     * to stream, add it immediately.
-                     */
-                    if ((ctx->buffer_used + 4) > ctx->buffer_length) {
-                        goto small_buffer;
-                    }
-
-                    ctx->state = LXB_ENCODING_ENCODE_2022_JP_ROMAN;
-
-                    if (cp == 0x00A5) {
-                        memcpy(&ctx->buffer_out[ctx->buffer_used],
-                               "\x1B\x28\x4A\x5C", 4);
-                        ctx->buffer_used += 4;
-
-                        continue;
-                    }
-
-                    memcpy(&ctx->buffer_out[ctx->buffer_used],
-                           "\x1B\x28\x4A\x7E", 4);
-                    ctx->buffer_used += 4;
-
-                    continue;
-                }
-
-                break;
-
-            case LXB_ENCODING_ENCODE_2022_JP_ROMAN:
-                if (cp == 0x000E || cp == 0x000F || cp == 0x001B) {
-                    goto failed;
-                }
-
-                if (cp < 0x80) {
-                    switch (cp) {
-                        case 0x005C:
-                        case 0x007E:
-                            break;
-
-                        case 0x00A5:
-                            LXB_ENCODING_ENCODE_APPEND(ctx, 0x5C);
-                            continue;
-
-                        case 0x203E:
-                            LXB_ENCODING_ENCODE_APPEND(ctx, 0x7E);
-                            continue;
-
-                        default:
-                            LXB_ENCODING_ENCODE_APPEND(ctx, cp);
-                            continue;
-                    }
-
-                    /*
-                     * Do not switch to the ANSI stage with prepend code point
-                     * to stream, add it immediately.
-                     */
-                    if ((ctx->buffer_used + 4) > ctx->buffer_length) {
-                        goto small_buffer;
-                    }
-
-                    ctx->state = LXB_ENCODING_ENCODE_2022_JP_ASCII;
-
-                    memcpy(&ctx->buffer_out[ctx->buffer_used], "\x1B\x28\x42", 3);
-                    ctx->buffer_used += 3;
-
-                    ctx->buffer_out[ ctx->buffer_used++ ] = (lxb_char_t) cp;
-                    continue;
-                }
-
-                break;
-
-            case LXB_ENCODING_ENCODE_2022_JP_JIS0208:
-                if (cp < 0x80) {
-                    if ((ctx->buffer_used + 4) > ctx->buffer_length) {
-                        goto small_buffer;
-                    }
-
-                    ctx->state = LXB_ENCODING_ENCODE_2022_JP_ASCII;
-
-                    memcpy(&ctx->buffer_out[ctx->buffer_used], "\x1B\x28\x42", 3);
-                    ctx->buffer_used += 3;
-
-                    ctx->buffer_out[ ctx->buffer_used++ ] = (lxb_char_t) cp;
-                    continue;
-                }
-
-                if (cp == 0x00A5 || cp == 0x203E) {
-                    if ((ctx->buffer_used + 4) > ctx->buffer_length) {
-                        goto small_buffer;
-                    }
-
-                    ctx->state = LXB_ENCODING_ENCODE_2022_JP_ROMAN;
-
-                    if (cp == 0x00A5) {
-                        memcpy(&ctx->buffer_out[ctx->buffer_used],
-                               "\x1B\x28\x4A\x5C", 4);
-                        ctx->buffer_used += 4;
-
-                        continue;
-                    }
-
-                    memcpy(&ctx->buffer_out[ctx->buffer_used],
-                           "\x1B\x28\x4A\x7E", 4);
-                    ctx->buffer_used += 4;
-
-                    continue;
-                }
-
-                break;
-        }
-
-        if ((ctx->buffer_used + 2) > ctx->buffer_length) {
-            goto small_buffer;
-        }
-
-        if (cp == 0x2212) {
-            cp = 0xFF0D;
-        }
-
-        if ((unsigned) (cp - 0xFF61) <= (0xFF9F - 0xFF61)) {
-            cp = lxb_encoding_multi_index_iso_2022_jp_katakana[cp - 0xFF61].codepoint;
-        }
-
-        hash = lexbor_shs_hash_get_static(lxb_encoding_multi_hash_jis0208,
-                                          LXB_ENCODING_MULTI_HASH_JIS0208_SIZE, cp);
-        if (hash == NULL) {
-            goto failed;
-        }
-
-        if (ctx->state != LXB_ENCODING_ENCODE_2022_JP_JIS0208) {
-            if ((ctx->buffer_used + 3) > ctx->buffer_length) {
-                goto small_buffer;
-            }
-
-            memcpy(&ctx->buffer_out[ctx->buffer_used], "\x1B\x24\x42", 3);
-            ctx->buffer_used += 3;
-
-            ctx->state = LXB_ENCODING_ENCODE_2022_JP_JIS0208;
-            size += 3;
-
-            goto begin;
-        }
-
-        ctx->buffer_out[ ctx->buffer_used++ ] = (uint32_t) (uintptr_t) hash->value / 94 + 0x21;
-        ctx->buffer_out[ ctx->buffer_used++ ] = (uint32_t) (uintptr_t) hash->value % 94 + 0x21;
-
-        continue;
-
-    small_buffer:
-
-        ctx->state = state;
-        ctx->buffer_used -= size;
-
-        return LXB_STATUS_SMALL_BUFFER;
-
-    failed:
-
-        ctx->buffer_used -= size;
-        LXB_ENCODING_ENCODE_ERROR(ctx);
-    }
-
-    return LXB_STATUS_OK;
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_2022_jp_eof(lxb_encoding_encode_t *ctx)
-{
-    if (ctx->state != LXB_ENCODING_ENCODE_2022_JP_ASCII) {
-        if ((ctx->buffer_used + 3) > ctx->buffer_length) {
-            return LXB_STATUS_SMALL_BUFFER;
-        }
-
-        memcpy(&ctx->buffer_out[ctx->buffer_used], "\x1B\x28\x42", 3);
-        ctx->buffer_used += 3;
-    }
-
-    return LXB_STATUS_OK;
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_8859_10(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_iso_8859_10,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_10_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_8859_13(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_iso_8859_13,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_13_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_8859_14(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_iso_8859_14,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_14_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_8859_15(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_iso_8859_15,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_15_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_8859_16(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_iso_8859_16,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_16_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_8859_2(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                               const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_iso_8859_2,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_2_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_8859_3(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                               const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_iso_8859_3,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_3_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_8859_4(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                               const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_iso_8859_4,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_4_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_8859_5(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                               const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_iso_8859_5,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_5_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_8859_6(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                               const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_iso_8859_6,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_6_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_8859_7(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                               const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_iso_8859_7,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_7_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_8859_8(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                               const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_iso_8859_8,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_8_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_iso_8859_8_i(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                 const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_iso_8859_8,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_8_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_koi8_r(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                           const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_koi8_r,
-                                    LXB_ENCODING_SINGLE_HASH_KOI8_R_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_koi8_u(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                           const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_koi8_u,
-                                    LXB_ENCODING_SINGLE_HASH_KOI8_U_SIZE);
-}
-
-lxb_inline const lexbor_shs_hash_t *
-lxb_encoding_encode_shift_jis_index(lxb_codepoint_t cp)
-{
-    const lexbor_shs_hash_t *entry;
-
-    entry = &lxb_encoding_multi_hash_jis0208[ (cp % LXB_ENCODING_MULTI_HASH_JIS0208_SIZE) + 1 ];
-
-    do {
-        if (entry->key == cp) {
-            if ((unsigned) ((uint32_t) (uintptr_t) entry->value - 8272) > (8835 - 8272)) {
-                return entry;
-            }
-        }
-
-        entry = &lxb_encoding_multi_hash_jis0208[entry->next];
-    }
-    while (entry != lxb_encoding_multi_hash_jis0208);
-
-    return NULL;
-}
-
-lxb_status_t
-lxb_encoding_encode_shift_jis(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                              const lxb_codepoint_t *end)
-{
-    uint32_t lead, trail;
-    lxb_codepoint_t cp;
-    const lexbor_shs_hash_t *hash;
-
-    for (; *cps < end; (*cps)++) {
-        cp = **cps;
-
-        if (cp <= 0x80) {
-            LXB_ENCODING_ENCODE_APPEND(ctx, cp);
-            continue;
-        }
-
-        if ((unsigned) (cp - 0xFF61) <= (0xFF9F - 0xFF61)) {
-            LXB_ENCODING_ENCODE_APPEND(ctx, cp - 0xFF61 + 0xA1);
-            continue;
-        }
-
-        switch (cp) {
-            case 0x00A5:
-                LXB_ENCODING_ENCODE_APPEND(ctx, 0x5C);
-                continue;
-
-            case 0x203E:
-                LXB_ENCODING_ENCODE_APPEND(ctx, 0x7E);
-                continue;
-
-            case 0x2212:
-                cp = 0xFF0D;
-                break;
-        }
-
-        hash = lxb_encoding_encode_shift_jis_index(cp);
-        if (hash == NULL) {
-            LXB_ENCODING_ENCODE_ERROR(ctx);
-            continue;
-        }
-
-        if ((ctx->buffer_used + 2) > ctx->buffer_length) {
-            return LXB_STATUS_SMALL_BUFFER;
-        }
-
-        lead = (uint32_t) (uintptr_t) hash->value / 188;
-        trail = (uint32_t) (uintptr_t) hash->value % 188;
-
-        ctx->buffer_out[ctx->buffer_used++ ] = lead + ((lead < 0x1F) ? 0x81 : 0xC1);
-        ctx->buffer_out[ctx->buffer_used++ ] = trail + ((trail < 0x3F) ? 0x40 : 0x41);
-    }
-
-    return LXB_STATUS_OK;
-}
-
-lxb_inline void
-lxb_encoding_encode_utf_16_write(lxb_encoding_encode_t *ctx, bool is_be,
-                                 lxb_codepoint_t cp)
-{
-    if (is_be) {
-        ctx->buffer_out[ctx->buffer_used++] = cp >> 8;
-        ctx->buffer_out[ctx->buffer_used++] = cp & 0x00FF;
-
-        return;
-    }
-
-    ctx->buffer_out[ctx->buffer_used++] = cp & 0x00FF;
-    ctx->buffer_out[ctx->buffer_used++] = cp >> 8;
-}
-
-lxb_inline int8_t
-lxb_encoding_encode_utf_16(lxb_encoding_encode_t *ctx, bool is_be,
-                        const lxb_codepoint_t **cps, const lxb_codepoint_t *end)
-{
-    lxb_codepoint_t cp;
-
-    for (; *cps < end; (*cps)++) {
-        cp = **cps;
-
-        if (cp < 0x10000) {
-            if ((ctx->buffer_used + 2) > ctx->buffer_length) {
-                return LXB_STATUS_SMALL_BUFFER;
-            }
-
-            lxb_encoding_encode_utf_16_write(ctx, is_be, cp);
-
-            continue;
-        }
-
-        if ((ctx->buffer_used + 4) > ctx->buffer_length) {
-            return LXB_STATUS_SMALL_BUFFER;
-        }
-
-        cp -= 0x10000;
-
-        lxb_encoding_encode_utf_16_write(ctx, is_be, (0xD800 | (cp >> 0x0A)));
-        lxb_encoding_encode_utf_16_write(ctx, is_be, (0xDC00 | (cp & 0x03FF)));
-    }
-
-    return LXB_STATUS_OK;
-}
-
-lxb_status_t
-lxb_encoding_encode_utf_16be(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                             const lxb_codepoint_t *end)
-{
-    return lxb_encoding_encode_utf_16(ctx, true, cps, end);
-}
-
-lxb_status_t
-lxb_encoding_encode_utf_16le(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                             const lxb_codepoint_t *end)
-{
-    return lxb_encoding_encode_utf_16(ctx, false, cps, end);
-}
-
-lxb_status_t
-lxb_encoding_encode_utf_8(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                          const lxb_codepoint_t *end)
-{
-    lxb_codepoint_t cp;
-    const lxb_codepoint_t *p = *cps;
-
-    for (; p < end; p++) {
-        cp = *p;
-
-        if (cp < 0x80) {
-            if ((ctx->buffer_used + 1) > ctx->buffer_length) {
-                *cps = p;
-
-                return LXB_STATUS_SMALL_BUFFER;
-            }
-
-            /* 0xxxxxxx */
-            ctx->buffer_out[ ctx->buffer_used++ ] = (lxb_char_t) cp;
-        }
-        else if (cp < 0x800) {
-            if ((ctx->buffer_used + 2) > ctx->buffer_length) {
-                *cps = p;
-
-                return LXB_STATUS_SMALL_BUFFER;
-            }
-
-            /* 110xxxxx 10xxxxxx */
-            ctx->buffer_out[ ctx->buffer_used++ ] = (lxb_char_t) (0xC0 | (cp >> 6  ));
-            ctx->buffer_out[ ctx->buffer_used++ ] = (lxb_char_t) (0x80 | (cp & 0x3F));
-        }
-        else if (cp < 0x10000) {
-            if ((ctx->buffer_used + 3) > ctx->buffer_length) {
-                *cps = p;
-
-                return LXB_STATUS_SMALL_BUFFER;
-            }
-
-            /* 1110xxxx 10xxxxxx 10xxxxxx */
-            ctx->buffer_out[ ctx->buffer_used++ ] = (lxb_char_t) (0xE0 | ((cp >> 12)));
-            ctx->buffer_out[ ctx->buffer_used++ ] = (lxb_char_t) (0x80 | ((cp >> 6 ) & 0x3F));
-            ctx->buffer_out[ ctx->buffer_used++ ] = (lxb_char_t) (0x80 | ( cp        & 0x3F));
-        }
-        else if (cp < 0x110000) {
-            if ((ctx->buffer_used + 4) > ctx->buffer_length) {
-                *cps = p;
-
-                return LXB_STATUS_SMALL_BUFFER;
-            }
-
-            /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
-            ctx->buffer_out[ ctx->buffer_used++ ] = (lxb_char_t) (0xF0 | ( cp >> 18));
-            ctx->buffer_out[ ctx->buffer_used++ ] = (lxb_char_t) (0x80 | ((cp >> 12) & 0x3F));
-            ctx->buffer_out[ ctx->buffer_used++ ] = (lxb_char_t) (0x80 | ((cp >> 6 ) & 0x3F));
-            ctx->buffer_out[ ctx->buffer_used++ ] = (lxb_char_t) (0x80 | ( cp        & 0x3F));
-        }
-        else {
-            *cps = p;
-            LXB_ENCODING_ENCODE_ERROR(ctx);
-        }
-    }
-
-    *cps = p;
-
-    return LXB_STATUS_OK;
-}
-
-lxb_inline uint32_t
-lxb_encoding_encode_gb18030_range(lxb_codepoint_t cp)
-{
-    size_t mid, left, right;
-    const lxb_encoding_range_index_t *range;
-
-    if (cp == 0xE7C7) {
-        return 7457;
-    }
-
-    left = 0;
-    right = LXB_ENCODING_RANGE_INDEX_GB18030_SIZE;
-    range = lxb_encoding_range_index_gb18030;
-
-    /* Some compilers say about uninitialized mid */
-    mid = 0;
-
-    while (left < right) {
-        mid = left + (right - left) / 2;
-
-        if (range[mid].codepoint < cp) {
-            left = mid + 1;
-
-            if (left < right && range[left].codepoint > cp) {
-                break;
-            }
-        }
-        else if (range[mid].codepoint > cp) {
-            right = mid - 1;
-
-            if (right > 0 && range[right].codepoint <= cp) {
-                mid = right;
-                break;
-            }
-        }
-        else {
-            break;
-        }
-    }
-
-    return range[mid].index + cp - range[mid].codepoint;
-}
-
-lxb_status_t
-lxb_encoding_encode_gb18030(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                            const lxb_codepoint_t *end)
-{
-    uint32_t index;
-    lxb_codepoint_t cp;
-    const lexbor_shs_hash_t *hash;
-
-    for (; *cps < end; (*cps)++) {
-        cp = **cps;
-
-        if (cp < 0x80) {
-            LXB_ENCODING_ENCODE_APPEND(ctx, cp);
-            continue;
-        }
-
-        if (cp == 0xE5E5) {
-            LXB_ENCODING_ENCODE_ERROR(ctx);
-            continue;
-        }
-
-        hash = lexbor_shs_hash_get_static(lxb_encoding_multi_hash_gb18030,
-                                          LXB_ENCODING_MULTI_HASH_GB18030_SIZE, cp);
-        if (hash != NULL) {
-            if ((ctx->buffer_used + 2) > ctx->buffer_length) {
-                return LXB_STATUS_SMALL_BUFFER;
-            }
-
-            ctx->buffer_out[ ctx->buffer_used++ ] = (uint32_t) (uintptr_t) hash->value / 190 + 0x81;
-
-            if (((uint32_t) (uintptr_t) hash->value % 190) < 0x3F) {
-                ctx->buffer_out[ ctx->buffer_used++ ] = ((uint32_t) (uintptr_t) hash->value % 190) + 0x40;
-            }
-            else {
-                ctx->buffer_out[ ctx->buffer_used++ ] = ((uint32_t) (uintptr_t) hash->value % 190) + 0x41;
-            }
-
-            continue;
-        }
-
-        if ((ctx->buffer_used + 4) > ctx->buffer_length) {
-            return LXB_STATUS_SMALL_BUFFER;
-        }
-
-        index = lxb_encoding_encode_gb18030_range(cp);
-
-        ctx->buffer_out[ ctx->buffer_used++ ] = (index / (10 * 126 * 10)) + 0x81;
-        ctx->buffer_out[ ctx->buffer_used++ ] = ((index % (10 * 126 * 10)) / (10 * 126)) + 0x30;
-
-        index = (index % (10 * 126 * 10)) % (10 * 126);
-
-        ctx->buffer_out[ ctx->buffer_used++ ] = (index / 10) + 0x81;
-        ctx->buffer_out[ ctx->buffer_used++ ] = (index % 10) + 0x30;
-    }
-
-    return LXB_STATUS_OK;
-}
-
-lxb_status_t
-lxb_encoding_encode_macintosh(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                              const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_macintosh,
-                                    LXB_ENCODING_SINGLE_HASH_MACINTOSH_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_replacement(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                const lxb_codepoint_t *end)
-{
-    *cps = end;
-    return LXB_STATUS_ERROR;
-}
-
-lxb_status_t
-lxb_encoding_encode_windows_1250(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                 const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_windows_1250,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1250_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_windows_1251(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                 const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_windows_1251,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1251_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_windows_1252(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                 const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_windows_1252,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1252_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_windows_1253(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                 const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_windows_1253,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1253_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_windows_1254(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                 const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_windows_1254,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1254_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_windows_1255(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                 const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_windows_1255,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1255_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_windows_1256(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                 const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_windows_1256,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1256_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_windows_1257(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                 const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_windows_1257,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1257_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_windows_1258(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                 const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_windows_1258,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1258_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_windows_874(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_windows_874,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_874_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_x_mac_cyrillic(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                   const lxb_codepoint_t *end)
-{
-    LXB_ENCODING_ENCODE_SINGLE_BYTE(lxb_encoding_single_hash_x_mac_cyrillic,
-                                  LXB_ENCODING_SINGLE_HASH_X_MAC_CYRILLIC_SIZE);
-}
-
-lxb_status_t
-lxb_encoding_encode_x_user_defined(lxb_encoding_encode_t *ctx, const lxb_codepoint_t **cps,
-                                   const lxb_codepoint_t *end)
-{
-    lxb_codepoint_t cp;
-
-    for (; *cps < end; (*cps)++) {
-        cp = **cps;
-
-        if (cp < 0x80) {
-            LXB_ENCODING_ENCODE_APPEND(ctx, cp);
-        }
-        else if (cp >= 0xF780 && cp <= 0xF7FF) {
-            LXB_ENCODING_ENCODE_APPEND(ctx, (cp - 0xF780 + 0x80));
-        }
-        else {
-            LXB_ENCODING_ENCODE_ERROR(ctx);
-        }
-    }
-
-    return LXB_STATUS_OK;
-}
-
-/*
- * Single
- */
-int8_t
-lxb_encoding_encode_default_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                   const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    return lxb_encoding_encode_utf_8_single(ctx, data, end, cp);
-}
-
-int8_t
-lxb_encoding_encode_auto_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    return LXB_ENCODING_ENCODE_ERROR;
-}
-
-int8_t
-lxb_encoding_encode_undefined_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                     const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    return LXB_ENCODING_ENCODE_ERROR;
-}
-
-int8_t
-lxb_encoding_encode_big5_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    const lexbor_shs_hash_t *hash;
-
-    if (cp < 0x80) {
-        *(*data)++ = (lxb_char_t) cp;
-
-        return 1;
-    }
-
-    hash = lexbor_shs_hash_get_static(lxb_encoding_multi_hash_big5,
-                                      LXB_ENCODING_MULTI_HASH_BIG5_SIZE, cp);
-    if (hash == NULL) {
-        return LXB_ENCODING_ENCODE_ERROR;
-    }
-
-    if ((*data + 2) > end) {
-        return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-    }
-
-    *(*data)++ = ((uint32_t) (uintptr_t) hash->value) / 157 + 0x81;
-
-    if ((((uint32_t) (uintptr_t) hash->value) % 157) < 0x3F) {
-        *(*data)++ = (((uint32_t) (uintptr_t) hash->value) % 157) + 0x40;
-    }
-    else {
-        *(*data)++ = (((uint32_t) (uintptr_t) hash->value) % 157) + 0x62;
-    }
-
-    return 2;
-}
-
-int8_t
-lxb_encoding_encode_euc_jp_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                  const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    const lexbor_shs_hash_t *hash;
-
-    if (cp < 0x80) {
-        *(*data)++ = (lxb_char_t) cp;
-
-        return 1;
-    }
-
-    if (cp == 0x00A5) {
-        *(*data)++ = 0x5C;
-
-        return 1;
-    }
-
-    if (cp == 0x203E) {
-        *(*data)++ = 0x7E;
-
-        return 1;
-    }
-
-    if ((*data + 2) > end) {
-        return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-    }
-
-    if ((unsigned) (cp - 0xFF61) <= (0xFF9F - 0xFF61)) {
-        *(*data)++ = 0x8E;
-        *(*data)++ = cp - 0xFF61 + 0xA1;
-
-        return 2;
-    }
-
-    if (cp == 0x2212) {
-        cp = 0xFF0D;
-    }
-
-    hash = lexbor_shs_hash_get_static(lxb_encoding_multi_hash_jis0208,
-                                      LXB_ENCODING_MULTI_HASH_JIS0208_SIZE, cp);
-    if (hash == NULL) {
-        return LXB_ENCODING_ENCODE_ERROR;
-    }
-
-    *(*data)++ = (uint32_t) (uintptr_t) hash->value / 94 + 0xA1;
-    *(*data)++ = (uint32_t) (uintptr_t) hash->value % 94 + 0xA1;
-
-    return 2;
-}
-
-int8_t
-lxb_encoding_encode_euc_kr_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                  const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    const lexbor_shs_hash_t *hash;
-
-    if (cp < 0x80) {
-        *(*data)++ = (lxb_char_t) cp;
-
-        return 1;
-    }
-
-    if ((*data + 2) > end) {
-        return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-    }
-
-    hash = lexbor_shs_hash_get_static(lxb_encoding_multi_hash_euc_kr,
-                                      LXB_ENCODING_MULTI_HASH_EUC_KR_SIZE, cp);
-    if (hash == NULL) {
-        return LXB_ENCODING_ENCODE_ERROR;
-    }
-
-    *(*data)++ = (uint32_t) (uintptr_t) hash->value / 190 + 0x81;
-    *(*data)++ = (uint32_t) (uintptr_t) hash->value % 190 + 0x41;
-
-    return 2;
-}
-
-int8_t
-lxb_encoding_encode_gbk_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                               const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    const lexbor_shs_hash_t *hash;
-
-    if (cp < 0x80) {
-        *(*data)++ = (lxb_char_t) cp;
-
-        return 1;
-    }
-
-    if (cp == 0xE5E5) {
-        return LXB_ENCODING_ENCODE_ERROR;
-    }
-
-    if (cp == 0x20AC) {
-        *(*data)++ = 0x80;
-
-        return 1;
-    }
-
-    hash = lexbor_shs_hash_get_static(lxb_encoding_multi_hash_gb18030,
-                                      LXB_ENCODING_MULTI_HASH_GB18030_SIZE, cp);
-    if (hash != NULL) {
-        if ((*data + 2) > end) {
-            return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-        }
-
-        *(*data)++ = (lxb_char_t) (uintptr_t) hash->value / 190 + 0x81;
-
-        if (((lxb_char_t) (uintptr_t) hash->value % 190) < 0x3F) {
-            *(*data)++ = ((lxb_char_t) (uintptr_t) hash->value % 190) + 0x40;
-        }
-        else {
-            *(*data)++ = ((lxb_char_t) (uintptr_t) hash->value % 190) + 0x41;
-        }
-
-        return 2;
-    }
-
-    return LXB_ENCODING_ENCODE_ERROR;
-}
-
-int8_t
-lxb_encoding_encode_ibm866_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                  const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_ibm866,
-                                    LXB_ENCODING_SINGLE_HASH_IBM866_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_iso_2022_jp_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                       const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    int8_t size;
-    unsigned state;
-    const lexbor_shs_hash_t *hash;
-
-    size = 0;
-    state = ctx->state;
-
-begin:
-
-    switch (ctx->state) {
-        case LXB_ENCODING_ENCODE_2022_JP_ASCII:
-            if (cp == 0x000E || cp == 0x000F || cp == 0x001B) {
-                goto failed;
-            }
-
-            if (cp < 0x80) {
-                *(*data)++ = (lxb_char_t) cp;
-
-                return size + 1;
-            }
-
-            if (cp == 0x00A5 || cp == 0x203E) {
-                /*
-                 * Do not switch to the ROMAN stage with prepend code point
-                 * to stream, add it immediately.
-                 */
-                if ((*data + 4) > end) {
-                    goto small_buffer;
-                }
-
-                ctx->state = LXB_ENCODING_ENCODE_2022_JP_ROMAN;
-
-                if (cp == 0x00A5) {
-                    memcpy(*data, "\x1B\x28\x4A\x5C", 4);
-                    *data = *data + 4;
-
-                    return size + 4;
-                }
-
-                memcpy(*data, "\x1B\x28\x4A\x7E", 4);
-                *data = *data + 4;
-
-                return size + 4;
-            }
-
-            break;
-
-        case LXB_ENCODING_ENCODE_2022_JP_ROMAN:
-            if (cp == 0x000E || cp == 0x000F || cp == 0x001B) {
-                goto failed;
-            }
-
-            if (cp < 0x80) {
-                switch (cp) {
-                    case 0x005C:
-                    case 0x007E:
-                        break;
-
-                    case 0x00A5:
-                        *(*data)++ = 0x5C;
-                        return size + 1;
-
-                    case 0x203E:
-                        *(*data)++ = 0x7E;
-                        return size + 1;
-
-                    default:
-                        *(*data)++ = (lxb_char_t) cp;
-                        return size + 1;
-                }
-
-                /*
-                 * Do not switch to the ANSI stage with prepend code point
-                 * to stream, add it immediately.
-                 */
-                if ((*data + 4) > end) {
-                    goto small_buffer;
-                }
-
-                ctx->state = LXB_ENCODING_ENCODE_2022_JP_ASCII;
-
-                memcpy(*data, "\x1B\x28\x42", 3);
-                *data = *data + 3;
-
-                *(*data)++ = (lxb_char_t) cp;
-
-                return size + 4;
-            }
-
-            break;
-
-        case LXB_ENCODING_ENCODE_2022_JP_JIS0208:
-            if (cp < 0x80) {
-                if ((*data + 4) > end) {
-                    goto small_buffer;
-                }
-
-                ctx->state = LXB_ENCODING_ENCODE_2022_JP_ASCII;
-
-                memcpy(*data, "\x1B\x28\x42", 3);
-                *data = *data + 3;
-
-                *(*data)++ = (lxb_char_t) cp;
-
-                return size + 4;
-            }
-
-            if (cp == 0x00A5 || cp == 0x203E) {
-                if ((*data + 4) > end) {
-                    goto small_buffer;
-                }
-
-                ctx->state = LXB_ENCODING_ENCODE_2022_JP_ROMAN;
-
-                if (cp == 0x00A5) {
-                    memcpy(*data, "\x1B\x28\x4A\x5C", 4);
-                    *data = *data + 4;
-
-                    return size + 4;
-                }
-
-                memcpy(*data, "\x1B\x28\x4A\x7E", 4);
-                *data = *data + 4;
-
-                return size + 4;
-            }
-
-            break;
-    }
-
-    if ((*data + 2) > end) {
-        goto small_buffer;
-    }
-
-    if (cp == 0x2212) {
-        cp = 0xFF0D;
-    }
-
-    if ((unsigned) (cp - 0xFF61) <= (0xFF9F - 0xFF61)) {
-        cp = lxb_encoding_multi_index_iso_2022_jp_katakana[cp - 0xFF61].codepoint;
-    }
-
-    hash = lexbor_shs_hash_get_static(lxb_encoding_multi_hash_jis0208,
-                                      LXB_ENCODING_MULTI_HASH_JIS0208_SIZE, cp);
-    if (hash == NULL) {
-        goto failed;
-    }
-
-    if (ctx->state != LXB_ENCODING_ENCODE_2022_JP_JIS0208) {
-        if ((*data + 3) > end) {
-            goto small_buffer;
-        }
-
-        memcpy(*data, "\x1B\x24\x42", 3);
-        *data = *data + 3;
-
-        ctx->state = LXB_ENCODING_ENCODE_2022_JP_JIS0208;
-        size += 3;
-
-        goto begin;
-    }
-
-    *(*data)++ = (uint32_t) (uintptr_t) hash->value / 94 + 0x21;
-    *(*data)++ = (uint32_t) (uintptr_t) hash->value % 94 + 0x21;
-
-    return size + 2;
-
-small_buffer:
-
-    ctx->state = state;
-    *data = *data - size;
-
-    return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-
-failed:
-
-    *data = *data - size;
-
-    return LXB_ENCODING_ENCODE_ERROR;
-}
-
-int8_t
-lxb_encoding_encode_iso_2022_jp_eof_single(lxb_encoding_encode_t *ctx,
-                                       lxb_char_t **data, const lxb_char_t *end)
-{
-    if (ctx->state != LXB_ENCODING_ENCODE_2022_JP_ASCII) {
-        if ((*data + 3) > end) {
-            return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-        }
-
-        memcpy(*data, "\x1B\x28\x42", 3);
-        *data = *data + 3;
-
-        ctx->state = LXB_ENCODING_ENCODE_2022_JP_ASCII;
-
-        return 3;
-    }
-
-    return 0;
-}
-
-int8_t
-lxb_encoding_encode_iso_8859_10_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                       const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_iso_8859_10,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_10_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_iso_8859_13_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                       const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_iso_8859_13,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_13_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_iso_8859_14_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                       const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_iso_8859_14,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_14_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_iso_8859_15_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                       const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_iso_8859_15,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_15_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_iso_8859_16_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                       const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_iso_8859_16,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_16_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_iso_8859_2_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                      const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_iso_8859_2,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_2_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_iso_8859_3_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                      const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_iso_8859_3,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_3_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_iso_8859_4_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                      const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_iso_8859_4,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_4_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_iso_8859_5_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                      const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_iso_8859_5,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_5_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_iso_8859_6_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                      const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_iso_8859_6,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_6_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_iso_8859_7_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                      const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_iso_8859_7,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_7_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_iso_8859_8_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                      const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_iso_8859_8,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_8_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_iso_8859_8_i_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                        const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_iso_8859_8,
-                                    LXB_ENCODING_SINGLE_HASH_ISO_8859_8_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_koi8_r_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                  const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_koi8_r,
-                                    LXB_ENCODING_SINGLE_HASH_KOI8_R_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_koi8_u_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                  const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_koi8_u,
-                                    LXB_ENCODING_SINGLE_HASH_KOI8_U_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_shift_jis_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                     const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    uint32_t lead, trail;
-    const lexbor_shs_hash_t *hash;
-
-    if (cp <= 0x80) {
-        *(*data)++ = (lxb_char_t) cp;
-
-        return 1;
-    }
-
-    if ((unsigned) (cp - 0xFF61) <= (0xFF9F - 0xFF61)) {
-        *(*data)++ = cp - 0xFF61 + 0xA1;
-
-        return 1;
-    }
-
-    switch (cp) {
-        case 0x00A5:
-            *(*data)++ = 0x5C;
-            return 1;
-
-        case 0x203E:
-            *(*data)++ = 0x7E;
-            return 1;
-
-        case 0x2212:
-            cp = 0xFF0D;
-            break;
-    }
-
-    hash = lxb_encoding_encode_shift_jis_index(cp);
-    if (hash == NULL) {
-        return LXB_ENCODING_ENCODE_ERROR;
-    }
-
-    if ((*data + 2) > end) {
-        return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-    }
-
-    lead = (uint32_t) (uintptr_t) hash->value / 188;
-    trail = (uint32_t) (uintptr_t) hash->value % 188;
-
-    *(*data)++ = lead + ((lead < 0x1F) ? 0x81 : 0xC1);
-    *(*data)++ = trail + ((trail < 0x3F) ? 0x40 : 0x41);
-
-    return 2;
-}
-
-lxb_inline void
-lxb_encoding_encode_utf_16_write_single(bool is_be, lxb_char_t **data,
-                                        lxb_codepoint_t cp)
-{
-    if (is_be) {
-        *(*data)++ = cp >> 8;
-        *(*data)++ = cp & 0x00FF;
-
-        return;
-    }
-
-    *(*data)++ = cp & 0x00FF;
-    *(*data)++ = cp >> 8;
-}
-
-lxb_inline int8_t
-lxb_encoding_encode_utf_16_single(lxb_encoding_encode_t *ctx, bool is_be,
-                   lxb_char_t **data, const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    if ((*data + 2) > end) {
-        return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-    }
-
-    if (cp < 0x10000) {
-        lxb_encoding_encode_utf_16_write_single(is_be, data, cp);
-
-        return 2;
-    }
-
-    if ((*data + 4) > end) {
-        return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-    }
-
-    cp -= 0x10000;
-
-    lxb_encoding_encode_utf_16_write_single(is_be, data, (0xD800 | (cp >> 0x0A)));
-    lxb_encoding_encode_utf_16_write_single(is_be, data, (0xDC00 | (cp & 0x03FF)));
-
-    return 4;
-}
-
-int8_t
-lxb_encoding_encode_utf_16be_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                    const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    return lxb_encoding_encode_utf_16_single(ctx, true, data, end, cp);
-}
-
-int8_t
-lxb_encoding_encode_utf_16le_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                    const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    return lxb_encoding_encode_utf_16_single(ctx, false, data, end, cp);
-}
-
-int8_t
-lxb_encoding_encode_utf_8_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                 const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    if (cp < 0x80) {
-        /* 0xxxxxxx */
-        *(*data)++ = (lxb_char_t) cp;
-
-        return 1;
-    }
-
-    if (cp < 0x800) {
-        if ((*data + 2) > end) {
-            return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-        }
-
-        /* 110xxxxx 10xxxxxx */
-        *(*data)++ = (lxb_char_t) (0xC0 | (cp >> 6  ));
-        *(*data)++ = (lxb_char_t) (0x80 | (cp & 0x3F));
-
-        return 2;
-    }
-
-    if (cp < 0x10000) {
-        if ((*data + 3) > end) {
-            return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-        }
-
-        /* 1110xxxx 10xxxxxx 10xxxxxx */
-        *(*data)++ = (lxb_char_t) (0xE0 | ((cp >> 12)));
-        *(*data)++ = (lxb_char_t) (0x80 | ((cp >> 6 ) & 0x3F));
-        *(*data)++ = (lxb_char_t) (0x80 | ( cp        & 0x3F));
-
-        return 3;
-    }
-
-    if (cp < 0x110000) {
-        if ((*data + 4) > end) {
-            return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-        }
-
-        /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
-        *(*data)++ = (lxb_char_t) (0xF0 | ( cp >> 18));
-        *(*data)++ = (lxb_char_t) (0x80 | ((cp >> 12) & 0x3F));
-        *(*data)++ = (lxb_char_t) (0x80 | ((cp >> 6 ) & 0x3F));
-        *(*data)++ = (lxb_char_t) (0x80 | ( cp        & 0x3F));
-
-        return 4;
-    }
-
-    return LXB_ENCODING_ENCODE_ERROR;
-}
-
-int8_t
-lxb_encoding_encode_gb18030_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                   const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    uint32_t index;
-    const lexbor_shs_hash_t *hash;
-
-    if (cp < 0x80) {
-        *(*data)++ = (lxb_char_t) cp;
-
-        return 1;
-    }
-
-    if (cp == 0xE5E5) {
-        return LXB_ENCODING_ENCODE_ERROR;
-    }
-
-    hash = lexbor_shs_hash_get_static(lxb_encoding_multi_hash_gb18030,
-                                      LXB_ENCODING_MULTI_HASH_GB18030_SIZE, cp);
-    if (hash != NULL) {
-        if ((*data + 2) > end) {
-            return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-        }
-
-        *(*data)++ = (uint32_t) (uintptr_t) hash->value / 190 + 0x81;
-
-        if (((uint32_t) (uintptr_t) hash->value % 190) < 0x3F) {
-            *(*data)++ = ((uint32_t) (uintptr_t) hash->value % 190) + 0x40;
-        }
-        else {
-            *(*data)++ = ((uint32_t) (uintptr_t) hash->value % 190) + 0x41;
-        }
-
-        return 2;
-    }
-
-    if ((*data + 4) > end) {
-        return LXB_ENCODING_ENCODE_SMALL_BUFFER;
-    }
-
-    index = lxb_encoding_encode_gb18030_range(cp);
-
-    *(*data)++ = (index / (10 * 126 * 10)) + 0x81;
-    *(*data)++ = ((index % (10 * 126 * 10)) / (10 * 126)) + 0x30;
-
-    index = (index % (10 * 126 * 10)) % (10 * 126);
-
-    *(*data)++ = (index / 10) + 0x81;
-    *(*data)++ = (index % 10) + 0x30;
-
-    return 4;
-}
-
-int8_t
-lxb_encoding_encode_macintosh_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                     const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_macintosh,
-                                    LXB_ENCODING_SINGLE_HASH_MACINTOSH_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_replacement_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                       const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    (*data)++;
-    return LXB_ENCODING_ENCODE_ERROR;
-}
-
-int8_t
-lxb_encoding_encode_windows_1250_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                        const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_windows_1250,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1250_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_windows_1251_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                        const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_windows_1251,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1251_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_windows_1252_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                        const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_windows_1252,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1252_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_windows_1253_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                        const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_windows_1253,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1253_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_windows_1254_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                        const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_windows_1254,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1254_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_windows_1255_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                        const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_windows_1255,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1255_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_windows_1256_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                        const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_windows_1256,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1256_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_windows_1257_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                        const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_windows_1257,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1257_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_windows_1258_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                        const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_windows_1258,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_1258_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_windows_874_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                       const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_windows_874,
-                                    LXB_ENCODING_SINGLE_HASH_WINDOWS_874_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_x_mac_cyrillic_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                          const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    LXB_ENCODING_ENCODE_BYTE_SINGLE(lxb_encoding_single_hash_x_mac_cyrillic,
-                                  LXB_ENCODING_SINGLE_HASH_X_MAC_CYRILLIC_SIZE);
-}
-
-int8_t
-lxb_encoding_encode_x_user_defined_single(lxb_encoding_encode_t *ctx, lxb_char_t **data,
-                                          const lxb_char_t *end, lxb_codepoint_t cp)
-{
-    if (cp < 0x80) {
-        *(*data)++ = (lxb_char_t) cp;
-
-        return 1;
-    }
-
-    if (cp >= 0xF780 && cp <= 0xF7FF) {
-        *(*data)++ = (lxb_char_t) (cp - 0xF780 + 0x80);
-
-        return 1;
-    }
-
-    return LXB_ENCODING_ENCODE_ERROR;
-}