summaryrefslogtreecommitdiffstats
path: root/third_party/rust/data-encoding/src/lib.rs
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/rust/data-encoding/src/lib.rs')
-rw-r--r--third_party/rust/data-encoding/src/lib.rs2394
1 files changed, 2394 insertions, 0 deletions
diff --git a/third_party/rust/data-encoding/src/lib.rs b/third_party/rust/data-encoding/src/lib.rs
new file mode 100644
index 0000000000..31df668d96
--- /dev/null
+++ b/third_party/rust/data-encoding/src/lib.rs
@@ -0,0 +1,2394 @@
+//! Efficient and customizable data-encoding functions like base64, base32, and hex
+//!
+//! This [crate] provides little-endian ASCII base-conversion encodings for
+//! bases of size 2, 4, 8, 16, 32, and 64. It supports:
+//!
+//! - [padding] for streaming
+//! - canonical encodings (e.g. [trailing bits] are checked)
+//! - in-place [encoding] and [decoding] functions
+//! - partial [decoding] functions (e.g. for error recovery)
+//! - character [translation] (e.g. for case-insensitivity)
+//! - most and least significant [bit-order]
+//! - [ignoring] characters when decoding (e.g. for skipping newlines)
+//! - [wrapping] the output when encoding
+//! - no-std environments with `default-features = false, features = ["alloc"]`
+//! - no-alloc environments with `default-features = false`
+//!
+//! You may use the [binary] or the [website] to play around.
+//!
+//! # Examples
+//!
+//! This crate provides predefined encodings as [constants]. These constants are of type
+//! [`Encoding`]. This type provides encoding and decoding functions with in-place or allocating
+//! variants. Here is an example using the allocating encoding function of [`BASE64`]:
+//!
+//! ```rust
+//! use data_encoding::BASE64;
+//! assert_eq!(BASE64.encode(b"Hello world"), "SGVsbG8gd29ybGQ=");
+//! ```
+//!
+//! Here is an example using the in-place decoding function of [`BASE32`]:
+//!
+//! ```rust
+//! use data_encoding::BASE32;
+//! let input = b"JBSWY3DPEB3W64TMMQ======";
+//! let mut output = vec![0; BASE32.decode_len(input.len()).unwrap()];
+//! let len = BASE32.decode_mut(input, &mut output).unwrap();
+//! assert_eq!(&output[0 .. len], b"Hello world");
+//! ```
+//!
+//! You are not limited to the predefined encodings. You may define your own encodings (with the
+//! same correctness and performance properties as the predefined ones) using the [`Specification`]
+//! type:
+//!
+//! ```rust
+//! use data_encoding::Specification;
+//! let hex = {
+//! let mut spec = Specification::new();
+//! spec.symbols.push_str("0123456789abcdef");
+//! spec.encoding().unwrap()
+//! };
+//! assert_eq!(hex.encode(b"hello"), "68656c6c6f");
+//! ```
+//!
+//! You may use the [macro] library to define a compile-time custom encoding:
+//!
+//! ```rust,ignore
+//! use data_encoding::Encoding;
+//! use data_encoding_macro::new_encoding;
+//! const HEX: Encoding = new_encoding!{
+//! symbols: "0123456789abcdef",
+//! translate_from: "ABCDEF",
+//! translate_to: "abcdef",
+//! };
+//! const BASE64: Encoding = new_encoding!{
+//! symbols: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+//! padding: '=',
+//! };
+//! ```
+//!
+//! # Properties
+//!
+//! The [`HEXUPPER`], [`BASE32`], [`BASE32HEX`], [`BASE64`], and [`BASE64URL`] predefined encodings
+//! are conform to [RFC4648].
+//!
+//! In general, the encoding and decoding functions satisfy the following properties:
+//!
+//! - They are deterministic: their output only depends on their input
+//! - They have no side-effects: they do not modify a hidden mutable state
+//! - They are correct: encoding then decoding gives the initial data
+//! - They are canonical (unless [`is_canonical`] returns false): decoding then encoding gives the
+//! initial data
+//!
+//! This last property is usually not satisfied by base64 implementations. This is a matter of
+//! choice and this crate has made the choice to let the user choose. Support for canonical encoding
+//! as described by the [RFC][canonical] is provided. But it is also possible to disable checking
+//! trailing bits, to add characters translation, to decode concatenated padded inputs, and to
+//! ignore some characters.
+//!
+//! Since the RFC specifies the encoding function on all inputs and the decoding function on all
+//! possible encoded outputs, the differences between implementations come from the decoding
+//! function which may be more or less permissive. In this crate, the decoding function of canonical
+//! encodings rejects all inputs that are not a possible output of the encoding function. Here are
+//! some concrete examples of decoding differences between this crate, the `base64` crate, and the
+//! `base64` GNU program:
+//!
+//! | Input | `data-encoding` | `base64` | GNU `base64` |
+//! | ---------- | --------------- | --------- | ------------- |
+//! | `AAB=` | `Trailing(2)` | `Last(2)` | `\x00\x00` |
+//! | `AA\nB=` | `Length(4)` | `Length` | `\x00\x00` |
+//! | `AAB` | `Length(0)` | `Last(2)` | Invalid input |
+//! | `AAA` | `Length(0)` | `[0, 0]` | Invalid input |
+//! | `A\rA\nB=` | `Length(4)` | `Byte(1)` | Invalid input |
+//! | `-_\r\n` | `Symbol(0)` | `Byte(0)` | Invalid input |
+//! | `AA==AA==` | `[0, 0]` | `Byte(2)` | `\x00\x00` |
+//!
+//! We can summarize these discrepancies as follows:
+//!
+//! | Discrepancy | `data-encoding` | `base64` | GNU `base64` |
+//! | -------------------------- | --------------- | -------- | ------------ |
+//! | Check trailing bits | Yes | Yes | No |
+//! | Ignored characters | None | None | `\n` |
+//! | Translated characters | None | None | None |
+//! | Check padding | Yes | No | Yes |
+//! | Support concatenated input | Yes | No | Yes |
+//!
+//! This crate permits to disable checking trailing bits. It permits to ignore some characters. It
+//! permits to translate characters. It permits to use unpadded encodings. However, for padded
+//! encodings, support for concatenated inputs cannot be disabled. This is simply because it doesn't
+//! make sense to use padding if it is not to support concatenated inputs.
+//!
+//! [RFC4648]: https://tools.ietf.org/html/rfc4648
+//! [`BASE32HEX`]: constant.BASE32HEX.html
+//! [`BASE32`]: constant.BASE32.html
+//! [`BASE64URL`]: constant.BASE64URL.html
+//! [`BASE64`]: constant.BASE64.html
+//! [`Encoding`]: struct.Encoding.html
+//! [`HEXUPPER`]: constant.HEXUPPER.html
+//! [`Specification`]: struct.Specification.html
+//! [`is_canonical`]: struct.Encoding.html#method.is_canonical
+//! [binary]: https://crates.io/crates/data-encoding-bin
+//! [bit-order]: struct.Specification.html#structfield.bit_order
+//! [canonical]: https://tools.ietf.org/html/rfc4648#section-3.5
+//! [constants]: index.html#constants
+//! [crate]: https://crates.io/crates/data-encoding
+//! [decoding]: struct.Encoding.html#method.decode_mut
+//! [encoding]: struct.Encoding.html#method.encode_mut
+//! [ignoring]: struct.Specification.html#structfield.ignore
+//! [macro]: https://crates.io/crates/data-encoding-macro
+//! [padding]: struct.Specification.html#structfield.padding
+//! [trailing bits]: struct.Specification.html#structfield.check_trailing_bits
+//! [translation]: struct.Specification.html#structfield.translate
+//! [website]: https://data-encoding.rs
+//! [wrapping]: struct.Specification.html#structfield.wrap
+
+#![no_std]
+#![warn(unused_results, missing_docs)]
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
+
+#[cfg(feature = "alloc")]
+use alloc::borrow::{Cow, ToOwned};
+#[cfg(feature = "alloc")]
+use alloc::string::String;
+#[cfg(feature = "alloc")]
+use alloc::vec;
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
+
+macro_rules! check {
+ ($e: expr, $c: expr) => {
+ if !$c {
+ return Err($e);
+ }
+ };
+}
+
+trait Static<T: Copy>: Copy {
+ fn val(self) -> T;
+}
+
+macro_rules! define {
+ ($name: ident: $type: ty = $val: expr) => {
+ #[derive(Copy, Clone)]
+ struct $name;
+ impl Static<$type> for $name {
+ fn val(self) -> $type {
+ $val
+ }
+ }
+ };
+}
+
+define!(Bf: bool = false);
+define!(Bt: bool = true);
+define!(N1: usize = 1);
+define!(N2: usize = 2);
+define!(N3: usize = 3);
+define!(N4: usize = 4);
+define!(N5: usize = 5);
+define!(N6: usize = 6);
+
+#[derive(Copy, Clone)]
+struct On;
+
+impl<T: Copy> Static<Option<T>> for On {
+ fn val(self) -> Option<T> {
+ None
+ }
+}
+
+#[derive(Copy, Clone)]
+struct Os<T>(T);
+
+impl<T: Copy> Static<Option<T>> for Os<T> {
+ fn val(self) -> Option<T> {
+ Some(self.0)
+ }
+}
+
+macro_rules! dispatch {
+ (let $var: ident: bool = $val: expr; $($body: tt)*) => {
+ if $val {
+ let $var = Bt; dispatch!($($body)*)
+ } else {
+ let $var = Bf; dispatch!($($body)*)
+ }
+ };
+ (let $var: ident: usize = $val: expr; $($body: tt)*) => {
+ match $val {
+ 1 => { let $var = N1; dispatch!($($body)*) },
+ 2 => { let $var = N2; dispatch!($($body)*) },
+ 3 => { let $var = N3; dispatch!($($body)*) },
+ 4 => { let $var = N4; dispatch!($($body)*) },
+ 5 => { let $var = N5; dispatch!($($body)*) },
+ 6 => { let $var = N6; dispatch!($($body)*) },
+ _ => panic!(),
+ }
+ };
+ (let $var: ident: Option<$type: ty> = $val: expr; $($body: tt)*) => {
+ match $val {
+ None => { let $var = On; dispatch!($($body)*) },
+ Some(x) => { let $var = Os(x); dispatch!($($body)*) },
+ }
+ };
+ ($body: expr) => { $body };
+}
+
+unsafe fn chunk_unchecked(x: &[u8], n: usize, i: usize) -> &[u8] {
+ debug_assert!((i + 1) * n <= x.len());
+ let ptr = x.as_ptr().add(n * i);
+ core::slice::from_raw_parts(ptr, n)
+}
+
+unsafe fn chunk_mut_unchecked(x: &mut [u8], n: usize, i: usize) -> &mut [u8] {
+ debug_assert!((i + 1) * n <= x.len());
+ let ptr = x.as_mut_ptr().add(n * i);
+ core::slice::from_raw_parts_mut(ptr, n)
+}
+
+unsafe fn as_array(x: &[u8]) -> &[u8; 256] {
+ debug_assert_eq!(x.len(), 256);
+ &*(x.as_ptr() as *const [u8; 256])
+}
+
+fn div_ceil(x: usize, m: usize) -> usize {
+ (x + m - 1) / m
+}
+
+fn floor(x: usize, m: usize) -> usize {
+ x / m * m
+}
+
+fn vectorize<F: FnMut(usize)>(n: usize, bs: usize, mut f: F) {
+ for k in 0 .. n / bs {
+ for i in k * bs .. (k + 1) * bs {
+ f(i);
+ }
+ }
+ for i in floor(n, bs) .. n {
+ f(i);
+ }
+}
+
+/// Decoding error kind
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum DecodeKind {
+ /// Invalid length
+ Length,
+
+ /// Invalid symbol
+ Symbol,
+
+ /// Non-zero trailing bits
+ Trailing,
+
+ /// Invalid padding length
+ Padding,
+}
+
+impl core::fmt::Display for DecodeKind {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ let description = match self {
+ DecodeKind::Length => "invalid length",
+ DecodeKind::Symbol => "invalid symbol",
+ DecodeKind::Trailing => "non-zero trailing bits",
+ DecodeKind::Padding => "invalid padding length",
+ };
+ write!(f, "{}", description)
+ }
+}
+
+/// Decoding error
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct DecodeError {
+ /// Error position
+ ///
+ /// This position is always a valid input position and represents the first encountered error.
+ pub position: usize,
+
+ /// Error kind
+ pub kind: DecodeKind,
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for DecodeError {}
+
+impl core::fmt::Display for DecodeError {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ write!(f, "{} at {}", self.kind, self.position)
+ }
+}
+
+/// Decoding error with partial result
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct DecodePartial {
+ /// Number of bytes read from input
+ ///
+ /// This number does not exceed the error position: `read <= error.position`.
+ pub read: usize,
+
+ /// Number of bytes written to output
+ ///
+ /// This number does not exceed the decoded length: `written <= decode_len(read)`.
+ pub written: usize,
+
+ /// Decoding error
+ pub error: DecodeError,
+}
+
+const INVALID: u8 = 128;
+const IGNORE: u8 = 129;
+const PADDING: u8 = 130;
+
+fn order(msb: bool, n: usize, i: usize) -> usize {
+ if msb {
+ n - 1 - i
+ } else {
+ i
+ }
+}
+
+fn enc(bit: usize) -> usize {
+ match bit {
+ 1 | 2 | 4 => 1,
+ 3 | 6 => 3,
+ 5 => 5,
+ _ => unreachable!(),
+ }
+}
+
+fn dec(bit: usize) -> usize {
+ enc(bit) * 8 / bit
+}
+
+fn encode_len<B: Static<usize>>(bit: B, len: usize) -> usize {
+ div_ceil(8 * len, bit.val())
+}
+
+fn encode_block<B: Static<usize>, M: Static<bool>>(
+ bit: B, msb: M, symbols: &[u8; 256], input: &[u8], output: &mut [u8],
+) {
+ debug_assert!(input.len() <= enc(bit.val()));
+ debug_assert_eq!(output.len(), encode_len(bit, input.len()));
+ let bit = bit.val();
+ let msb = msb.val();
+ let mut x = 0u64;
+ for (i, input) in input.iter().enumerate() {
+ x |= u64::from(*input) << (8 * order(msb, enc(bit), i));
+ }
+ for (i, output) in output.iter_mut().enumerate() {
+ let y = x >> (bit * order(msb, dec(bit), i));
+ *output = symbols[y as usize % 256];
+ }
+}
+
+fn encode_mut<B: Static<usize>, M: Static<bool>>(
+ bit: B, msb: M, symbols: &[u8; 256], input: &[u8], output: &mut [u8],
+) {
+ debug_assert_eq!(output.len(), encode_len(bit, input.len()));
+ let enc = enc(bit.val());
+ let dec = dec(bit.val());
+ let n = input.len() / enc;
+ let bs = match bit.val() {
+ 5 => 2,
+ 6 => 4,
+ _ => 1,
+ };
+ vectorize(n, bs, |i| {
+ let input = unsafe { chunk_unchecked(input, enc, i) };
+ let output = unsafe { chunk_mut_unchecked(output, dec, i) };
+ encode_block(bit, msb, symbols, input, output);
+ });
+ encode_block(bit, msb, symbols, &input[enc * n ..], &mut output[dec * n ..]);
+}
+
+// Fails if an input character does not translate to a symbol. The error is the
+// lowest index of such character. The output is not written to.
+fn decode_block<B: Static<usize>, M: Static<bool>>(
+ bit: B, msb: M, values: &[u8; 256], input: &[u8], output: &mut [u8],
+) -> Result<(), usize> {
+ debug_assert!(output.len() <= enc(bit.val()));
+ debug_assert_eq!(input.len(), encode_len(bit, output.len()));
+ let bit = bit.val();
+ let msb = msb.val();
+ let mut x = 0u64;
+ for j in 0 .. input.len() {
+ let y = values[input[j] as usize];
+ check!(j, y < 1 << bit);
+ x |= u64::from(y) << (bit * order(msb, dec(bit), j));
+ }
+ for (j, output) in output.iter_mut().enumerate() {
+ *output = (x >> (8 * order(msb, enc(bit), j))) as u8;
+ }
+ Ok(())
+}
+
+// Fails if an input character does not translate to a symbol. The error `pos`
+// is the lowest index of such character. The output is valid up to `pos / dec *
+// enc` excluded.
+fn decode_mut<B: Static<usize>, M: Static<bool>>(
+ bit: B, msb: M, values: &[u8; 256], input: &[u8], output: &mut [u8],
+) -> Result<(), usize> {
+ debug_assert_eq!(input.len(), encode_len(bit, output.len()));
+ let enc = enc(bit.val());
+ let dec = dec(bit.val());
+ let n = input.len() / dec;
+ for i in 0 .. n {
+ let input = unsafe { chunk_unchecked(input, dec, i) };
+ let output = unsafe { chunk_mut_unchecked(output, enc, i) };
+ decode_block(bit, msb, values, input, output).map_err(|e| dec * i + e)?;
+ }
+ decode_block(bit, msb, values, &input[dec * n ..], &mut output[enc * n ..])
+ .map_err(|e| dec * n + e)
+}
+
+// Fails if there are non-zero trailing bits.
+fn check_trail<B: Static<usize>, M: Static<bool>>(
+ bit: B, msb: M, ctb: bool, values: &[u8; 256], input: &[u8],
+) -> Result<(), ()> {
+ if 8 % bit.val() == 0 || !ctb {
+ return Ok(());
+ }
+ let trail = bit.val() * input.len() % 8;
+ if trail == 0 {
+ return Ok(());
+ }
+ let mut mask = (1 << trail) - 1;
+ if !msb.val() {
+ mask <<= bit.val() - trail;
+ }
+ check!((), values[input[input.len() - 1] as usize] & mask == 0);
+ Ok(())
+}
+
+// Fails if the padding length is invalid. The error is the index of the first
+// padding character.
+fn check_pad<B: Static<usize>>(bit: B, values: &[u8; 256], input: &[u8]) -> Result<usize, usize> {
+ let bit = bit.val();
+ debug_assert_eq!(input.len(), dec(bit));
+ let is_pad = |x: &&u8| values[**x as usize] == PADDING;
+ let count = input.iter().rev().take_while(is_pad).count();
+ let len = input.len() - count;
+ check!(len, len > 0 && bit * len % 8 < bit);
+ Ok(len)
+}
+
+fn encode_base_len<B: Static<usize>>(bit: B, len: usize) -> usize {
+ encode_len(bit, len)
+}
+
+fn encode_base<B: Static<usize>, M: Static<bool>>(
+ bit: B, msb: M, symbols: &[u8; 256], input: &[u8], output: &mut [u8],
+) {
+ debug_assert_eq!(output.len(), encode_base_len(bit, input.len()));
+ encode_mut(bit, msb, symbols, input, output);
+}
+
+fn encode_pad_len<B: Static<usize>, P: Static<Option<u8>>>(bit: B, pad: P, len: usize) -> usize {
+ match pad.val() {
+ None => encode_base_len(bit, len),
+ Some(_) => div_ceil(len, enc(bit.val())) * dec(bit.val()),
+ }
+}
+
+fn encode_pad<B: Static<usize>, M: Static<bool>, P: Static<Option<u8>>>(
+ bit: B, msb: M, symbols: &[u8; 256], spad: P, input: &[u8], output: &mut [u8],
+) {
+ let pad = match spad.val() {
+ None => return encode_base(bit, msb, symbols, input, output),
+ Some(pad) => pad,
+ };
+ debug_assert_eq!(output.len(), encode_pad_len(bit, spad, input.len()));
+ let olen = encode_base_len(bit, input.len());
+ encode_base(bit, msb, symbols, input, &mut output[.. olen]);
+ for output in output.iter_mut().skip(olen) {
+ *output = pad;
+ }
+}
+
+fn encode_wrap_len<
+ 'a,
+ B: Static<usize>,
+ P: Static<Option<u8>>,
+ W: Static<Option<(usize, &'a [u8])>>,
+>(
+ bit: B, pad: P, wrap: W, ilen: usize,
+) -> usize {
+ let olen = encode_pad_len(bit, pad, ilen);
+ match wrap.val() {
+ None => olen,
+ Some((col, end)) => olen + end.len() * div_ceil(olen, col),
+ }
+}
+
+fn encode_wrap_mut<
+ 'a,
+ B: Static<usize>,
+ M: Static<bool>,
+ P: Static<Option<u8>>,
+ W: Static<Option<(usize, &'a [u8])>>,
+>(
+ bit: B, msb: M, symbols: &[u8; 256], pad: P, wrap: W, input: &[u8], output: &mut [u8],
+) {
+ let (col, end) = match wrap.val() {
+ None => return encode_pad(bit, msb, symbols, pad, input, output),
+ Some((col, end)) => (col, end),
+ };
+ debug_assert_eq!(output.len(), encode_wrap_len(bit, pad, wrap, input.len()));
+ debug_assert_eq!(col % dec(bit.val()), 0);
+ let col = col / dec(bit.val());
+ let enc = col * enc(bit.val());
+ let dec = col * dec(bit.val()) + end.len();
+ let olen = dec - end.len();
+ let n = input.len() / enc;
+ for i in 0 .. n {
+ let input = unsafe { chunk_unchecked(input, enc, i) };
+ let output = unsafe { chunk_mut_unchecked(output, dec, i) };
+ encode_base(bit, msb, symbols, input, &mut output[.. olen]);
+ output[olen ..].copy_from_slice(end);
+ }
+ if input.len() > enc * n {
+ let olen = dec * n + encode_pad_len(bit, pad, input.len() - enc * n);
+ encode_pad(bit, msb, symbols, pad, &input[enc * n ..], &mut output[dec * n .. olen]);
+ output[olen ..].copy_from_slice(end);
+ }
+}
+
+// Returns the longest valid input length and associated output length.
+fn decode_wrap_len<B: Static<usize>, P: Static<bool>>(
+ bit: B, pad: P, len: usize,
+) -> (usize, usize) {
+ let bit = bit.val();
+ if pad.val() {
+ (floor(len, dec(bit)), len / dec(bit) * enc(bit))
+ } else {
+ let trail = bit * len % 8;
+ (len - trail / bit, bit * len / 8)
+ }
+}
+
+// Fails with Length if length is invalid. The error is the largest valid
+// length.
+fn decode_pad_len<B: Static<usize>, P: Static<bool>>(
+ bit: B, pad: P, len: usize,
+) -> Result<usize, DecodeError> {
+ let (ilen, olen) = decode_wrap_len(bit, pad, len);
+ check!(DecodeError { position: ilen, kind: DecodeKind::Length }, ilen == len);
+ Ok(olen)
+}
+
+// Fails with Length if length is invalid. The error is the largest valid
+// length.
+fn decode_base_len<B: Static<usize>>(bit: B, len: usize) -> Result<usize, DecodeError> {
+ decode_pad_len(bit, Bf, len)
+}
+
+// Fails with Symbol if an input character does not translate to a symbol. The
+// error is the lowest index of such character.
+// Fails with Trailing if there are non-zero trailing bits.
+fn decode_base_mut<B: Static<usize>, M: Static<bool>>(
+ bit: B, msb: M, ctb: bool, values: &[u8; 256], input: &[u8], output: &mut [u8],
+) -> Result<usize, DecodePartial> {
+ debug_assert_eq!(Ok(output.len()), decode_base_len(bit, input.len()));
+ let fail = |pos, kind| DecodePartial {
+ read: pos / dec(bit.val()) * dec(bit.val()),
+ written: pos / dec(bit.val()) * enc(bit.val()),
+ error: DecodeError { position: pos, kind },
+ };
+ decode_mut(bit, msb, values, input, output).map_err(|pos| fail(pos, DecodeKind::Symbol))?;
+ check_trail(bit, msb, ctb, values, input)
+ .map_err(|()| fail(input.len() - 1, DecodeKind::Trailing))?;
+ Ok(output.len())
+}
+
+// Fails with Symbol if an input character does not translate to a symbol. The
+// error is the lowest index of such character.
+// Fails with Padding if some padding length is invalid. The error is the index
+// of the first padding character of the invalid padding.
+// Fails with Trailing if there are non-zero trailing bits.
+fn decode_pad_mut<B: Static<usize>, M: Static<bool>, P: Static<bool>>(
+ bit: B, msb: M, ctb: bool, values: &[u8; 256], pad: P, input: &[u8], output: &mut [u8],
+) -> Result<usize, DecodePartial> {
+ if !pad.val() {
+ return decode_base_mut(bit, msb, ctb, values, input, output);
+ }
+ debug_assert_eq!(Ok(output.len()), decode_pad_len(bit, pad, input.len()));
+ let enc = enc(bit.val());
+ let dec = dec(bit.val());
+ let mut inpos = 0;
+ let mut outpos = 0;
+ let mut outend = output.len();
+ while inpos < input.len() {
+ match decode_base_mut(
+ bit,
+ msb,
+ ctb,
+ values,
+ &input[inpos ..],
+ &mut output[outpos .. outend],
+ ) {
+ Ok(written) => {
+ if cfg!(debug_assertions) {
+ inpos = input.len();
+ }
+ outpos += written;
+ break;
+ }
+ Err(partial) => {
+ inpos += partial.read;
+ outpos += partial.written;
+ }
+ }
+ let inlen =
+ check_pad(bit, values, &input[inpos .. inpos + dec]).map_err(|pos| DecodePartial {
+ read: inpos,
+ written: outpos,
+ error: DecodeError { position: inpos + pos, kind: DecodeKind::Padding },
+ })?;
+ let outlen = decode_base_len(bit, inlen).unwrap();
+ let written = decode_base_mut(
+ bit,
+ msb,
+ ctb,
+ values,
+ &input[inpos .. inpos + inlen],
+ &mut output[outpos .. outpos + outlen],
+ )
+ .map_err(|partial| {
+ debug_assert_eq!(partial.read, 0);
+ debug_assert_eq!(partial.written, 0);
+ DecodePartial {
+ read: inpos,
+ written: outpos,
+ error: DecodeError {
+ position: inpos + partial.error.position,
+ kind: partial.error.kind,
+ },
+ }
+ })?;
+ debug_assert_eq!(written, outlen);
+ inpos += dec;
+ outpos += outlen;
+ outend -= enc - outlen;
+ }
+ debug_assert_eq!(inpos, input.len());
+ debug_assert_eq!(outpos, outend);
+ Ok(outend)
+}
+
+fn skip_ignore(values: &[u8; 256], input: &[u8], mut inpos: usize) -> usize {
+ while inpos < input.len() && values[input[inpos] as usize] == IGNORE {
+ inpos += 1;
+ }
+ inpos
+}
+
+// Returns next input and output position.
+// Fails with Symbol if an input character does not translate to a symbol. The
+// error is the lowest index of such character.
+// Fails with Padding if some padding length is invalid. The error is the index
+// of the first padding character of the invalid padding.
+// Fails with Trailing if there are non-zero trailing bits.
+fn decode_wrap_block<B: Static<usize>, M: Static<bool>, P: Static<bool>>(
+ bit: B, msb: M, ctb: bool, values: &[u8; 256], pad: P, input: &[u8], output: &mut [u8],
+) -> Result<(usize, usize), DecodeError> {
+ let dec = dec(bit.val());
+ let mut buf = [0u8; 8];
+ let mut shift = [0usize; 8];
+ let mut bufpos = 0;
+ let mut inpos = 0;
+ while bufpos < dec {
+ inpos = skip_ignore(values, input, inpos);
+ if inpos == input.len() {
+ break;
+ }
+ shift[bufpos] = inpos;
+ buf[bufpos] = input[inpos];
+ bufpos += 1;
+ inpos += 1;
+ }
+ let olen = decode_pad_len(bit, pad, bufpos).map_err(|mut e| {
+ e.position = shift[e.position];
+ e
+ })?;
+ let written = decode_pad_mut(bit, msb, ctb, values, pad, &buf[.. bufpos], &mut output[.. olen])
+ .map_err(|partial| {
+ debug_assert_eq!(partial.read, 0);
+ debug_assert_eq!(partial.written, 0);
+ DecodeError { position: shift[partial.error.position], kind: partial.error.kind }
+ })?;
+ Ok((inpos, written))
+}
+
+// Fails with Symbol if an input character does not translate to a symbol. The
+// error is the lowest index of such character.
+// Fails with Padding if some padding length is invalid. The error is the index
+// of the first padding character of the invalid padding.
+// Fails with Trailing if there are non-zero trailing bits.
+// Fails with Length if input length (without ignored characters) is invalid.
+#[allow(clippy::too_many_arguments)]
+fn decode_wrap_mut<B: Static<usize>, M: Static<bool>, P: Static<bool>, I: Static<bool>>(
+ bit: B, msb: M, ctb: bool, values: &[u8; 256], pad: P, has_ignore: I, input: &[u8],
+ output: &mut [u8],
+) -> Result<usize, DecodePartial> {
+ if !has_ignore.val() {
+ return decode_pad_mut(bit, msb, ctb, values, pad, input, output);
+ }
+ debug_assert_eq!(output.len(), decode_wrap_len(bit, pad, input.len()).1);
+ let mut inpos = 0;
+ let mut outpos = 0;
+ while inpos < input.len() {
+ let (inlen, outlen) = decode_wrap_len(bit, pad, input.len() - inpos);
+ match decode_pad_mut(
+ bit,
+ msb,
+ ctb,
+ values,
+ pad,
+ &input[inpos .. inpos + inlen],
+ &mut output[outpos .. outpos + outlen],
+ ) {
+ Ok(written) => {
+ inpos += inlen;
+ outpos += written;
+ break;
+ }
+ Err(partial) => {
+ inpos += partial.read;
+ outpos += partial.written;
+ }
+ }
+ let (ipos, opos) =
+ decode_wrap_block(bit, msb, ctb, values, pad, &input[inpos ..], &mut output[outpos ..])
+ .map_err(|mut error| {
+ error.position += inpos;
+ DecodePartial { read: inpos, written: outpos, error }
+ })?;
+ inpos += ipos;
+ outpos += opos;
+ }
+ let inpos = skip_ignore(values, input, inpos);
+ if inpos == input.len() {
+ Ok(outpos)
+ } else {
+ Err(DecodePartial {
+ read: inpos,
+ written: outpos,
+ error: DecodeError { position: inpos, kind: DecodeKind::Length },
+ })
+ }
+}
+
+/// Order in which bits are read from a byte
+///
+/// The base-conversion encoding is always little-endian. This means that the least significant
+/// **byte** is always first. However, we can still choose whether, within a byte, this is the most
+/// significant or the least significant **bit** that is first. If the terminology is confusing,
+/// testing on an asymmetrical example should be enough to choose the correct value.
+///
+/// # Examples
+///
+/// In the following example, we can see that a base with the `MostSignificantFirst` bit-order has
+/// the most significant bit first in the encoded output. In particular, the output is in the same
+/// order as the bits in the byte. The opposite happens with the `LeastSignificantFirst` bit-order.
+/// The least significant bit is first and the output is in the reverse order.
+///
+/// ```rust
+/// use data_encoding::{BitOrder, Specification};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("01");
+/// spec.bit_order = BitOrder::MostSignificantFirst; // default
+/// let msb = spec.encoding().unwrap();
+/// spec.bit_order = BitOrder::LeastSignificantFirst;
+/// let lsb = spec.encoding().unwrap();
+/// assert_eq!(msb.encode(&[0b01010011]), "01010011");
+/// assert_eq!(lsb.encode(&[0b01010011]), "11001010");
+/// ```
+///
+/// # Features
+///
+/// Requires the `alloc` feature.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg(feature = "alloc")]
+pub enum BitOrder {
+ /// Most significant bit first
+ ///
+ /// This is the most common and most intuitive bit-order. In particular, this is the bit-order
+ /// used by [RFC4648] and thus the usual hexadecimal, base64, base32, base64url, and base32hex
+ /// encodings. This is the default bit-order when [specifying](struct.Specification.html) a
+ /// base.
+ ///
+ /// [RFC4648]: https://tools.ietf.org/html/rfc4648
+ MostSignificantFirst,
+
+ /// Least significant bit first
+ ///
+ /// # Examples
+ ///
+ /// DNSCurve [base32] uses least significant bit first:
+ ///
+ /// ```rust
+ /// use data_encoding::BASE32_DNSCURVE;
+ /// assert_eq!(BASE32_DNSCURVE.encode(&[0x64, 0x88]), "4321");
+ /// assert_eq!(BASE32_DNSCURVE.decode(b"4321").unwrap(), vec![0x64, 0x88]);
+ /// ```
+ ///
+ /// [base32]: constant.BASE32_DNSCURVE.html
+ LeastSignificantFirst,
+}
+#[cfg(feature = "alloc")]
+use crate::BitOrder::*;
+
+#[doc(hidden)]
+#[cfg(feature = "alloc")]
+pub type InternalEncoding = Cow<'static, [u8]>;
+
+#[doc(hidden)]
+#[cfg(not(feature = "alloc"))]
+pub type InternalEncoding = &'static [u8];
+
+/// Base-conversion encoding
+///
+/// See [Specification](struct.Specification.html) for technical details or how to define a new one.
+// Required fields:
+// 0 - 256 (256) symbols
+// 256 - 512 (256) values
+// 512 - 513 ( 1) padding
+// 513 - 514 ( 1) reserved(3),ctb(1),msb(1),bit(3)
+// Optional fields:
+// 514 - 515 ( 1) width
+// 515 - * ( N) separator
+// Invariants:
+// - symbols is 2^bit unique characters repeated 2^(8-bit) times
+// - values[128 ..] are INVALID
+// - values[0 .. 128] are either INVALID, IGNORE, PADDING, or < 2^bit
+// - padding is either < 128 or INVALID
+// - values[padding] is PADDING if padding < 128
+// - values and symbols are inverse
+// - ctb is true if 8 % bit == 0
+// - width is present if there is x such that values[x] is IGNORE
+// - width % dec(bit) == 0
+// - for all x in separator values[x] is IGNORE
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Encoding(pub InternalEncoding);
+
+/// How to translate characters when decoding
+///
+/// The order matters. The first character of the `from` field is translated to the first character
+/// of the `to` field. The second to the second. Etc.
+///
+/// See [Specification](struct.Specification.html) for more information.
+///
+/// # Features
+///
+/// Requires the `alloc` feature.
+#[derive(Debug, Clone)]
+#[cfg(feature = "alloc")]
+pub struct Translate {
+ /// Characters to translate from
+ pub from: String,
+
+ /// Characters to translate to
+ pub to: String,
+}
+
+/// How to wrap the output when encoding
+///
+/// See [Specification](struct.Specification.html) for more information.
+///
+/// # Features
+///
+/// Requires the `alloc` feature.
+#[derive(Debug, Clone)]
+#[cfg(feature = "alloc")]
+pub struct Wrap {
+ /// Wrapping width
+ ///
+ /// Must be a multiple of:
+ ///
+ /// - 8 for a bit-width of 1 (binary), 3 (octal), and 5 (base32)
+ /// - 4 for a bit-width of 2 (base4) and 6 (base64)
+ /// - 2 for a bit-width of 4 (hexadecimal)
+ ///
+ /// Wrapping is disabled if null.
+ pub width: usize,
+
+ /// Wrapping characters
+ ///
+ /// Wrapping is disabled if empty.
+ pub separator: String,
+}
+
+/// Base-conversion specification
+///
+/// It is possible to define custom encodings given a specification. To do so, it is important to
+/// understand the theory first.
+///
+/// # Theory
+///
+/// Each subsection has an equivalent subsection in the [Practice](#practice) section.
+///
+/// ## Basics
+///
+/// The main idea of a [base-conversion] encoding is to see `[u8]` as numbers written in
+/// little-endian base256 and convert them in another little-endian base. For performance reasons,
+/// this crate restricts this other base to be of size 2 (binary), 4 (base4), 8 (octal), 16
+/// (hexadecimal), 32 (base32), or 64 (base64). The converted number is written as `[u8]` although
+/// it doesn't use all the 256 possible values of `u8`. This crate encodes to ASCII, so only values
+/// smaller than 128 are allowed.
+///
+/// More precisely, we need the following elements:
+///
+/// - The bit-width N: 1 for binary, 2 for base4, 3 for octal, 4 for hexadecimal, 5 for base32, and
+/// 6 for base64
+/// - The [bit-order](enum.BitOrder.html): most or least significant bit first
+/// - The symbols function S from [0, 2<sup>N</sup>) (called values and written `uN`) to symbols
+/// (represented as `u8` although only ASCII symbols are allowed, i.e. smaller than 128)
+/// - The values partial function V from ASCII to [0, 2<sup>N</sup>), i.e. from `u8` to `uN`
+/// - Whether trailing bits are checked: trailing bits are leading zeros in theory, but since
+/// numbers are little-endian they come last
+///
+/// For the encoding to be correct (i.e. encoding then decoding gives back the initial input),
+/// V(S(i)) must be defined and equal to i for all i in [0, 2<sup>N</sup>). For the encoding to be
+/// [canonical][canonical] (i.e. different inputs decode to different outputs, or equivalently,
+/// decoding then encoding gives back the initial input), trailing bits must be checked and if V(i)
+/// is defined then S(V(i)) is equal to i for all i.
+///
+/// Encoding and decoding are given by the following pipeline:
+///
+/// ```text
+/// [u8] <--1--> [[bit; 8]] <--2--> [[bit; N]] <--3--> [uN] <--4--> [u8]
+/// 1: Map bit-order between each u8 and [bit; 8]
+/// 2: Base conversion between base 2^8 and base 2^N (check trailing bits)
+/// 3: Map bit-order between each [bit; N] and uN
+/// 4: Map symbols/values between each uN and u8 (values must be defined)
+/// ```
+///
+/// ## Extensions
+///
+/// All these extensions make the encoding not canonical.
+///
+/// ### Padding
+///
+/// Padding is useful if the following conditions are met:
+///
+/// - the bit-width is 3 (octal), 5 (base32), or 6 (base64)
+/// - the length of the data to encode is not known in advance
+/// - the data must be sent without buffering
+///
+/// Bases for which the bit-width N does not divide 8 may not concatenate encoded data. This comes
+/// from the fact that it is not possible to make the difference between trailing bits and encoding
+/// bits. Padding solves this issue by adding a new character to discriminate between trailing bits
+/// and encoding bits. The idea is to work by blocks of lcm(8, N) bits, where lcm(8, N) is the least
+/// common multiple of 8 and N. When such block is not complete, it is padded.
+///
+/// To preserve correctness, the padding character must not be a symbol.
+///
+/// ### Ignore characters when decoding
+///
+/// Ignoring characters when decoding is useful if after encoding some characters are added for
+/// convenience or any other reason (like wrapping). In that case we want to first ignore thoses
+/// characters before decoding.
+///
+/// To preserve correctness, ignored characters must not contain symbols or the padding character.
+///
+/// ### Wrap output when encoding
+///
+/// Wrapping output when encoding is useful if the output is meant to be printed in a document where
+/// width is limited (typically 80-columns documents). In that case, the wrapping width and the
+/// wrapping separator have to be defined.
+///
+/// To preserve correctness, the wrapping separator characters must be ignored (see previous
+/// subsection). As such, wrapping separator characters must also not contain symbols or the padding
+/// character.
+///
+/// ### Translate characters when decoding
+///
+/// Translating characters when decoding is useful when encoded data may be copied by a humain
+/// instead of a machine. Humans tend to confuse some characters for others. In that case we want to
+/// translate those characters before decoding.
+///
+/// To preserve correctness, the characters we translate _from_ must not contain symbols or the
+/// padding character, and the characters we translate _to_ must only contain symbols or the padding
+/// character.
+///
+/// # Practice
+///
+/// ## Basics
+///
+/// ```rust
+/// use data_encoding::{Encoding, Specification};
+/// fn make_encoding(symbols: &str) -> Encoding {
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str(symbols);
+/// spec.encoding().unwrap()
+/// }
+/// let binary = make_encoding("01");
+/// let octal = make_encoding("01234567");
+/// let hexadecimal = make_encoding("0123456789abcdef");
+/// assert_eq!(binary.encode(b"Bit"), "010000100110100101110100");
+/// assert_eq!(octal.encode(b"Bit"), "20464564");
+/// assert_eq!(hexadecimal.encode(b"Bit"), "426974");
+/// ```
+///
+/// The `binary` base has 2 symbols `0` and `1` with value 0 and 1 respectively. The `octal` base
+/// has 8 symbols `0` to `7` with value 0 to 7. The `hexadecimal` base has 16 symbols `0` to `9` and
+/// `a` to `f` with value 0 to 15. The following diagram gives the idea of how encoding works in the
+/// previous example (note that we can actually write such diagram only because the bit-order is
+/// most significant first):
+///
+/// ```text
+/// [ octal] | 2 : 0 : 4 : 6 : 4 : 5 : 6 : 4 |
+/// [ binary] |0 1 0 0 0 0 1 0|0 1 1 0 1 0 0 1|0 1 1 1 0 1 0 0|
+/// [hexadecimal] | 4 : 2 | 6 : 9 | 7 : 4 |
+/// ^-- LSB ^-- MSB
+/// ```
+///
+/// Note that in theory, these little-endian numbers are read from right to left (the most
+/// significant bit is at the right). Since leading zeros are meaningless (in our usual decimal
+/// notation 0123 is the same as 123), it explains why trailing bits must be zero. Trailing bits may
+/// occur when the bit-width of a base does not divide 8. Only binary, base4, and hexadecimal don't
+/// have trailing bits issues. So let's consider octal and base64, which have trailing bits in
+/// similar circumstances:
+///
+/// ```rust
+/// use data_encoding::{Specification, BASE64_NOPAD};
+/// let octal = {
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("01234567");
+/// spec.encoding().unwrap()
+/// };
+/// assert_eq!(BASE64_NOPAD.encode(b"B"), "Qg");
+/// assert_eq!(octal.encode(b"B"), "204");
+/// ```
+///
+/// We have the following diagram, where the base64 values are written between parentheses:
+///
+/// ```text
+/// [base64] | Q(16) : g(32) : [has 4 zero trailing bits]
+/// [ octal] | 2 : 0 : 4 : [has 1 zero trailing bit ]
+/// |0 1 0 0 0 0 1 0|0 0 0 0
+/// [ ascii] | B |
+/// ^-^-^-^-- leading zeros / trailing bits
+/// ```
+///
+/// ## Extensions
+///
+/// ### Padding
+///
+/// For octal and base64, lcm(8, 3) == lcm(8, 6) == 24 bits or 3 bytes. For base32, lcm(8, 5) is 40
+/// bits or 5 bytes. Let's consider octal and base64:
+///
+/// ```rust
+/// use data_encoding::{Specification, BASE64};
+/// let octal = {
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("01234567");
+/// spec.padding = Some('=');
+/// spec.encoding().unwrap()
+/// };
+/// // We start encoding but we only have "B" for now.
+/// assert_eq!(BASE64.encode(b"B"), "Qg==");
+/// assert_eq!(octal.encode(b"B"), "204=====");
+/// // Now we have "it".
+/// assert_eq!(BASE64.encode(b"it"), "aXQ=");
+/// assert_eq!(octal.encode(b"it"), "322720==");
+/// // By concatenating everything, we may decode the original data.
+/// assert_eq!(BASE64.decode(b"Qg==aXQ=").unwrap(), b"Bit");
+/// assert_eq!(octal.decode(b"204=====322720==").unwrap(), b"Bit");
+/// ```
+///
+/// We have the following diagrams:
+///
+/// ```text
+/// [base64] | Q(16) : g(32) : = : = |
+/// [ octal] | 2 : 0 : 4 : = : = : = : = : = |
+/// |0 1 0 0 0 0 1 0|. . . . . . . .|. . . . . . . .|
+/// [ ascii] | B | end of block aligned --^
+/// ^-- beginning of block aligned
+///
+/// [base64] | a(26) : X(23) : Q(16) : = |
+/// [ octal] | 3 : 2 : 2 : 7 : 2 : 0 : = : = |
+/// |0 1 1 0 1 0 0 1|0 1 1 1 0 1 0 0|. . . . . . . .|
+/// [ ascii] | i | t |
+/// ```
+///
+/// ### Ignore characters when decoding
+///
+/// The typical use-case is to ignore newlines (`\r` and `\n`). But to keep the example small, we
+/// will ignore spaces.
+///
+/// ```rust
+/// let mut spec = data_encoding::HEXLOWER.specification();
+/// spec.ignore.push_str(" \t");
+/// let base = spec.encoding().unwrap();
+/// assert_eq!(base.decode(b"42 69 74"), base.decode(b"426974"));
+/// ```
+///
+/// ### Wrap output when encoding
+///
+/// The typical use-case is to wrap after 64 or 76 characters with a newline (`\r\n` or `\n`). But
+/// to keep the example small, we will wrap after 8 characters with a space.
+///
+/// ```rust
+/// let mut spec = data_encoding::BASE64.specification();
+/// spec.wrap.width = 8;
+/// spec.wrap.separator.push_str(" ");
+/// let base64 = spec.encoding().unwrap();
+/// assert_eq!(base64.encode(b"Hey you"), "SGV5IHlv dQ== ");
+/// ```
+///
+/// Note that the output always ends with the separator.
+///
+/// ### Translate characters when decoding
+///
+/// The typical use-case is to translate lowercase to uppercase or reciprocally, but it is also used
+/// for letters that look alike, like `O0` or `Il1`. Let's illustrate both examples.
+///
+/// ```rust
+/// let mut spec = data_encoding::HEXLOWER.specification();
+/// spec.translate.from.push_str("ABCDEFOIl");
+/// spec.translate.to.push_str("abcdef011");
+/// let base = spec.encoding().unwrap();
+/// assert_eq!(base.decode(b"BOIl"), base.decode(b"b011"));
+/// ```
+///
+/// # Features
+///
+/// Requires the `alloc` feature.
+///
+/// [base-conversion]: https://en.wikipedia.org/wiki/Positional_notation#Base_conversion
+/// [canonical]: https://tools.ietf.org/html/rfc4648#section-3.5
+#[derive(Debug, Clone)]
+#[cfg(feature = "alloc")]
+pub struct Specification {
+ /// Symbols
+ ///
+ /// The number of symbols must be 2, 4, 8, 16, 32, or 64. Symbols must be ASCII characters
+ /// (smaller than 128) and they must be unique.
+ pub symbols: String,
+
+ /// Bit-order
+ ///
+ /// The default is to use most significant bit first since it is the most common.
+ pub bit_order: BitOrder,
+
+ /// Check trailing bits
+ ///
+ /// The default is to check trailing bits. This field is ignored when unnecessary (i.e. for
+ /// base2, base4, and base16).
+ pub check_trailing_bits: bool,
+
+ /// Padding
+ ///
+ /// The default is to not use padding. The padding character must be ASCII and must not be a
+ /// symbol.
+ pub padding: Option<char>,
+
+ /// Characters to ignore when decoding
+ ///
+ /// The default is to not ignore characters when decoding. The characters to ignore must be
+ /// ASCII and must not be symbols or the padding character.
+ pub ignore: String,
+
+ /// How to wrap the output when encoding
+ ///
+ /// The default is to not wrap the output when encoding. The wrapping characters must be ASCII
+ /// and must not be symbols or the padding character.
+ pub wrap: Wrap,
+
+ /// How to translate characters when decoding
+ ///
+ /// The default is to not translate characters when decoding. The characters to translate from
+ /// must be ASCII and must not have already been assigned a semantics. The characters to
+ /// translate to must be ASCII and must have been assigned a semantics (symbol, padding
+ /// character, or ignored character).
+ pub translate: Translate,
+}
+
+#[cfg(feature = "alloc")]
+impl Default for Specification {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl Encoding {
+ fn sym(&self) -> &[u8; 256] {
+ unsafe { as_array(&self.0[0 .. 256]) }
+ }
+
+ fn val(&self) -> &[u8; 256] {
+ unsafe { as_array(&self.0[256 .. 512]) }
+ }
+
+ fn pad(&self) -> Option<u8> {
+ if self.0[512] < 128 {
+ Some(self.0[512])
+ } else {
+ None
+ }
+ }
+
+ fn ctb(&self) -> bool {
+ self.0[513] & 0x10 != 0
+ }
+
+ fn msb(&self) -> bool {
+ self.0[513] & 0x8 != 0
+ }
+
+ fn bit(&self) -> usize {
+ (self.0[513] & 0x7) as usize
+ }
+
+ fn wrap(&self) -> Option<(usize, &[u8])> {
+ if self.0.len() <= 515 {
+ return None;
+ }
+ Some((self.0[514] as usize, &self.0[515 ..]))
+ }
+
+ fn has_ignore(&self) -> bool {
+ self.0.len() >= 515
+ }
+
+ /// Returns the encoded length of an input of length `len`
+ ///
+ /// See [`encode_mut`] for when to use it.
+ ///
+ /// [`encode_mut`]: struct.Encoding.html#method.encode_mut
+ pub fn encode_len(&self, len: usize) -> usize {
+ dispatch! {
+ let bit: usize = self.bit();
+ let pad: Option<u8> = self.pad();
+ let wrap: Option<(usize, &[u8])> = self.wrap();
+ encode_wrap_len(bit, pad, wrap, len)
+ }
+ }
+
+ /// Encodes `input` in `output`
+ ///
+ /// # Panics
+ ///
+ /// Panics if the `output` length does not match the result of [`encode_len`] for the `input`
+ /// length.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// use data_encoding::BASE64;
+ /// # let mut buffer = vec![0; 100];
+ /// let input = b"Hello world";
+ /// let output = &mut buffer[0 .. BASE64.encode_len(input.len())];
+ /// BASE64.encode_mut(input, output);
+ /// assert_eq!(output, b"SGVsbG8gd29ybGQ=");
+ /// ```
+ ///
+ /// [`encode_len`]: struct.Encoding.html#method.encode_len
+ #[allow(clippy::cognitive_complexity)]
+ pub fn encode_mut(&self, input: &[u8], output: &mut [u8]) {
+ assert_eq!(output.len(), self.encode_len(input.len()));
+ dispatch! {
+ let bit: usize = self.bit();
+ let msb: bool = self.msb();
+ let pad: Option<u8> = self.pad();
+ let wrap: Option<(usize, &[u8])> = self.wrap();
+ encode_wrap_mut(bit, msb, self.sym(), pad, wrap, input, output)
+ }
+ }
+
+ /// Appends the encoding of `input` to `output`
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// use data_encoding::BASE64;
+ /// # let mut buffer = vec![0; 100];
+ /// let input = b"Hello world";
+ /// let mut output = "Result: ".to_string();
+ /// BASE64.encode_append(input, &mut output);
+ /// assert_eq!(output, "Result: SGVsbG8gd29ybGQ=");
+ /// ```
+ ///
+ /// # Features
+ ///
+ /// Requires the `alloc` feature.
+ #[cfg(feature = "alloc")]
+ pub fn encode_append(&self, input: &[u8], output: &mut String) {
+ let output = unsafe { output.as_mut_vec() };
+ let output_len = output.len();
+ output.resize(output_len + self.encode_len(input.len()), 0u8);
+ self.encode_mut(input, &mut output[output_len ..]);
+ }
+
+ /// Returns encoded `input`
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// use data_encoding::BASE64;
+ /// assert_eq!(BASE64.encode(b"Hello world"), "SGVsbG8gd29ybGQ=");
+ /// ```
+ ///
+ /// # Features
+ ///
+ /// Requires the `alloc` feature.
+ #[cfg(feature = "alloc")]
+ pub fn encode(&self, input: &[u8]) -> String {
+ let mut output = vec![0u8; self.encode_len(input.len())];
+ self.encode_mut(input, &mut output);
+ unsafe { String::from_utf8_unchecked(output) }
+ }
+
+ /// Returns the decoded length of an input of length `len`
+ ///
+ /// See [`decode_mut`] for when to use it.
+ ///
+ /// # Errors
+ ///
+ /// Returns an error if `len` is invalid. The error kind is [`Length`] and the [position] is the
+ /// greatest valid input length.
+ ///
+ /// [`decode_mut`]: struct.Encoding.html#method.decode_mut
+ /// [`Length`]: enum.DecodeKind.html#variant.Length
+ /// [position]: struct.DecodeError.html#structfield.position
+ pub fn decode_len(&self, len: usize) -> Result<usize, DecodeError> {
+ let (ilen, olen) = dispatch! {
+ let bit: usize = self.bit();
+ let pad: bool = self.pad().is_some();
+ decode_wrap_len(bit, pad, len)
+ };
+ check!(
+ DecodeError { position: ilen, kind: DecodeKind::Length },
+ self.has_ignore() || len == ilen
+ );
+ Ok(olen)
+ }
+
+ /// Decodes `input` in `output`
+ ///
+ /// Returns the length of the decoded output. This length may be smaller than the output length
+ /// if the input contained padding or ignored characters. The output bytes after the returned
+ /// length are not initialized and should not be read.
+ ///
+ /// # Panics
+ ///
+ /// Panics if the `output` length does not match the result of [`decode_len`] for the `input`
+ /// length. Also panics if `decode_len` fails for the `input` length.
+ ///
+ /// # Errors
+ ///
+ /// Returns an error if `input` is invalid. See [`decode`] for more details. The are two
+ /// differences though:
+ ///
+ /// - [`Length`] may be returned only if the encoding allows ignored characters, because
+ /// otherwise this is already checked by [`decode_len`].
+ /// - The [`read`] first bytes of the input have been successfully decoded to the [`written`]
+ /// first bytes of the output.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// use data_encoding::BASE64;
+ /// # let mut buffer = vec![0; 100];
+ /// let input = b"SGVsbA==byB3b3JsZA==";
+ /// let output = &mut buffer[0 .. BASE64.decode_len(input.len()).unwrap()];
+ /// let len = BASE64.decode_mut(input, output).unwrap();
+ /// assert_eq!(&output[0 .. len], b"Hello world");
+ /// ```
+ ///
+ /// [`decode_len`]: struct.Encoding.html#method.decode_len
+ /// [`decode`]: struct.Encoding.html#method.decode
+ /// [`Length`]: enum.DecodeKind.html#variant.Length
+ /// [`read`]: struct.DecodePartial.html#structfield.read
+ /// [`written`]: struct.DecodePartial.html#structfield.written
+ #[allow(clippy::cognitive_complexity)]
+ pub fn decode_mut(&self, input: &[u8], output: &mut [u8]) -> Result<usize, DecodePartial> {
+ assert_eq!(Ok(output.len()), self.decode_len(input.len()));
+ dispatch! {
+ let bit: usize = self.bit();
+ let msb: bool = self.msb();
+ let pad: bool = self.pad().is_some();
+ let has_ignore: bool = self.has_ignore();
+ decode_wrap_mut(bit, msb, self.ctb(), self.val(), pad, has_ignore,
+ input, output)
+ }
+ }
+
+ /// Returns decoded `input`
+ ///
+ /// # Errors
+ ///
+ /// Returns an error if `input` is invalid. The error kind can be:
+ ///
+ /// - [`Length`] if the input length is invalid. The [position] is the greatest valid input
+ /// length.
+ /// - [`Symbol`] if the input contains an invalid character. The [position] is the first invalid
+ /// character.
+ /// - [`Trailing`] if the input has non-zero trailing bits. This is only possible if the
+ /// encoding checks trailing bits. The [position] is the first character containing non-zero
+ /// trailing bits.
+ /// - [`Padding`] if the input has an invalid padding length. This is only possible if the
+ /// encoding uses padding. The [position] is the first padding character of the first padding
+ /// of invalid length.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// use data_encoding::BASE64;
+ /// assert_eq!(BASE64.decode(b"SGVsbA==byB3b3JsZA==").unwrap(), b"Hello world");
+ /// ```
+ ///
+ /// # Features
+ ///
+ /// Requires the `alloc` feature.
+ ///
+ /// [`Length`]: enum.DecodeKind.html#variant.Length
+ /// [`Symbol`]: enum.DecodeKind.html#variant.Symbol
+ /// [`Trailing`]: enum.DecodeKind.html#variant.Trailing
+ /// [`Padding`]: enum.DecodeKind.html#variant.Padding
+ /// [position]: struct.DecodeError.html#structfield.position
+ #[cfg(feature = "alloc")]
+ pub fn decode(&self, input: &[u8]) -> Result<Vec<u8>, DecodeError> {
+ let mut output = vec![0u8; self.decode_len(input.len())?];
+ let len = self.decode_mut(input, &mut output).map_err(|partial| partial.error)?;
+ output.truncate(len);
+ Ok(output)
+ }
+
+ /// Returns the bit-width
+ pub fn bit_width(&self) -> usize {
+ self.bit()
+ }
+
+ /// Returns whether the encoding is canonical
+ ///
+ /// An encoding is not canonical if one of the following conditions holds:
+ ///
+ /// - trailing bits are not checked
+ /// - padding is used
+ /// - characters are ignored
+ /// - characters are translated
+ pub fn is_canonical(&self) -> bool {
+ if !self.ctb() {
+ return false;
+ }
+ let bit = self.bit();
+ let sym = self.sym();
+ let val = self.val();
+ for i in 0 .. 256 {
+ if val[i] == INVALID {
+ continue;
+ }
+ if val[i] >= 1 << bit {
+ return false;
+ }
+ if sym[val[i] as usize] != i as u8 {
+ return false;
+ }
+ }
+ true
+ }
+
+ /// Returns the encoding specification
+ ///
+ /// # Features
+ ///
+ /// Requires the `alloc` feature.
+ #[cfg(feature = "alloc")]
+ pub fn specification(&self) -> Specification {
+ let mut specification = Specification::new();
+ specification
+ .symbols
+ .push_str(core::str::from_utf8(&self.sym()[0 .. 1 << self.bit()]).unwrap());
+ specification.bit_order =
+ if self.msb() { MostSignificantFirst } else { LeastSignificantFirst };
+ specification.check_trailing_bits = self.ctb();
+ if let Some(pad) = self.pad() {
+ specification.padding = Some(pad as char);
+ }
+ for i in 0 .. 128u8 {
+ if self.val()[i as usize] != IGNORE {
+ continue;
+ }
+ specification.ignore.push(i as char);
+ }
+ if let Some((col, end)) = self.wrap() {
+ specification.wrap.width = col;
+ specification.wrap.separator = core::str::from_utf8(end).unwrap().to_owned();
+ }
+ for i in 0 .. 128u8 {
+ let canonical = if self.val()[i as usize] < 1 << self.bit() {
+ self.sym()[self.val()[i as usize] as usize]
+ } else if self.val()[i as usize] == PADDING {
+ self.pad().unwrap()
+ } else {
+ continue;
+ };
+ if i == canonical {
+ continue;
+ }
+ specification.translate.from.push(i as char);
+ specification.translate.to.push(canonical as char);
+ }
+ specification
+ }
+
+ #[doc(hidden)]
+ pub const fn internal_new(implementation: &'static [u8]) -> Encoding {
+ #[cfg(feature = "alloc")]
+ let encoding = Encoding(Cow::Borrowed(implementation));
+ #[cfg(not(feature = "alloc"))]
+ let encoding = Encoding(implementation);
+ encoding
+ }
+
+ #[doc(hidden)]
+ pub fn internal_implementation(&self) -> &[u8] {
+ &self.0
+ }
+}
+
+#[derive(Debug, Copy, Clone)]
+#[cfg(feature = "alloc")]
+enum SpecificationErrorImpl {
+ BadSize,
+ NotAscii,
+ Duplicate(u8),
+ ExtraPadding,
+ WrapLength,
+ WrapWidth(u8),
+ FromTo,
+ Undefined(u8),
+}
+#[cfg(feature = "alloc")]
+use crate::SpecificationErrorImpl::*;
+
+/// Specification error
+///
+/// # Features
+///
+/// Requires the `alloc` feature.
+#[derive(Debug, Copy, Clone)]
+#[cfg(feature = "alloc")]
+pub struct SpecificationError(SpecificationErrorImpl);
+
+#[cfg(feature = "alloc")]
+impl core::fmt::Display for SpecificationError {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ match self.0 {
+ BadSize => write!(f, "invalid number of symbols"),
+ NotAscii => write!(f, "non-ascii character"),
+ Duplicate(c) => write!(f, "{:?} has conflicting definitions", c as char),
+ ExtraPadding => write!(f, "unnecessary padding"),
+ WrapLength => write!(f, "invalid wrap width or separator length"),
+ WrapWidth(x) => write!(f, "wrap width not a multiple of {}", x),
+ FromTo => write!(f, "translate from/to length mismatch"),
+ Undefined(c) => write!(f, "{:?} is undefined", c as char),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for SpecificationError {
+ fn description(&self) -> &str {
+ match self.0 {
+ BadSize => "invalid number of symbols",
+ NotAscii => "non-ascii character",
+ Duplicate(_) => "conflicting definitions",
+ ExtraPadding => "unnecessary padding",
+ WrapLength => "invalid wrap width or separator length",
+ WrapWidth(_) => "wrap width not a multiple",
+ FromTo => "translate from/to length mismatch",
+ Undefined(_) => "undefined character",
+ }
+ }
+}
+
+#[cfg(feature = "alloc")]
+impl Specification {
+ /// Returns a default specification
+ pub fn new() -> Specification {
+ Specification {
+ symbols: String::new(),
+ bit_order: MostSignificantFirst,
+ check_trailing_bits: true,
+ padding: None,
+ ignore: String::new(),
+ wrap: Wrap { width: 0, separator: String::new() },
+ translate: Translate { from: String::new(), to: String::new() },
+ }
+ }
+
+ /// Returns the specified encoding
+ ///
+ /// # Errors
+ ///
+ /// Returns an error if the specification is invalid.
+ pub fn encoding(&self) -> Result<Encoding, SpecificationError> {
+ let symbols = self.symbols.as_bytes();
+ let bit: usize = match symbols.len() {
+ 2 => 1,
+ 4 => 2,
+ 8 => 3,
+ 16 => 4,
+ 32 => 5,
+ 64 => 6,
+ _ => return Err(SpecificationError(BadSize)),
+ };
+ let mut values = [INVALID; 128];
+ let set = |v: &mut [u8; 128], i: u8, x: u8| {
+ check!(SpecificationError(NotAscii), i < 128);
+ if v[i as usize] == x {
+ return Ok(());
+ }
+ check!(SpecificationError(Duplicate(i)), v[i as usize] == INVALID);
+ v[i as usize] = x;
+ Ok(())
+ };
+ for (v, symbols) in symbols.iter().enumerate() {
+ set(&mut values, *symbols, v as u8)?;
+ }
+ let msb = self.bit_order == MostSignificantFirst;
+ let ctb = self.check_trailing_bits || 8 % bit == 0;
+ let pad = match self.padding {
+ None => None,
+ Some(pad) => {
+ check!(SpecificationError(ExtraPadding), 8 % bit != 0);
+ check!(SpecificationError(NotAscii), pad.len_utf8() == 1);
+ set(&mut values, pad as u8, PADDING)?;
+ Some(pad as u8)
+ }
+ };
+ for i in self.ignore.bytes() {
+ set(&mut values, i, IGNORE)?;
+ }
+ let wrap = if self.wrap.separator.is_empty() || self.wrap.width == 0 {
+ None
+ } else {
+ Some((self.wrap.width, self.wrap.separator.as_bytes()))
+ };
+ if let Some((col, end)) = wrap {
+ check!(SpecificationError(WrapLength), col < 256 && end.len() < 256);
+ check!(SpecificationError(WrapWidth(dec(bit) as u8)), col % dec(bit) == 0);
+ for i in end.iter() {
+ set(&mut values, *i, IGNORE)?;
+ }
+ }
+ let from = self.translate.from.as_bytes();
+ let to = self.translate.to.as_bytes();
+ check!(SpecificationError(FromTo), from.len() == to.len());
+ for i in 0 .. from.len() {
+ check!(SpecificationError(NotAscii), to[i] < 128);
+ let v = values[to[i] as usize];
+ check!(SpecificationError(Undefined(to[i])), v != INVALID);
+ set(&mut values, from[i], v)?;
+ }
+ let mut encoding = Vec::new();
+ for _ in 0 .. 256 / symbols.len() {
+ encoding.extend_from_slice(symbols);
+ }
+ encoding.extend_from_slice(&values);
+ encoding.extend_from_slice(&[INVALID; 128]);
+ match pad {
+ None => encoding.push(INVALID),
+ Some(pad) => encoding.push(pad),
+ }
+ encoding.push(bit as u8);
+ if msb {
+ encoding[513] |= 0x08;
+ }
+ if ctb {
+ encoding[513] |= 0x10;
+ }
+ if let Some((col, end)) = wrap {
+ encoding.push(col as u8);
+ encoding.extend_from_slice(end);
+ } else if values.contains(&IGNORE) {
+ encoding.push(0);
+ }
+ Ok(Encoding(Cow::Owned(encoding)))
+ }
+}
+
+/// Lowercase hexadecimal encoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, HEXLOWER};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("0123456789abcdef");
+/// assert_eq!(HEXLOWER, spec.encoding().unwrap());
+/// ```
+///
+/// # Examples
+///
+/// ```rust
+/// use data_encoding::HEXLOWER;
+/// let deadbeef = vec![0xde, 0xad, 0xbe, 0xef];
+/// assert_eq!(HEXLOWER.decode(b"deadbeef").unwrap(), deadbeef);
+/// assert_eq!(HEXLOWER.encode(&deadbeef), "deadbeef");
+/// ```
+pub const HEXLOWER: Encoding = Encoding::internal_new(HEXLOWER_IMPL);
+const HEXLOWER_IMPL: &[u8] = &[
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54,
+ 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100,
+ 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51,
+ 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
+ 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48,
+ 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100,
+ 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51,
+ 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
+ 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48,
+ 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 97, 98, 99, 100, 101, 102, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 0, 1, 2,
+ 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 28,
+];
+
+/// Lowercase hexadecimal encoding with case-insensitive decoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, HEXLOWER_PERMISSIVE};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("0123456789abcdef");
+/// spec.translate.from.push_str("ABCDEF");
+/// spec.translate.to.push_str("abcdef");
+/// assert_eq!(HEXLOWER_PERMISSIVE, spec.encoding().unwrap());
+/// ```
+///
+/// # Examples
+///
+/// ```rust
+/// use data_encoding::HEXLOWER_PERMISSIVE;
+/// let deadbeef = vec![0xde, 0xad, 0xbe, 0xef];
+/// assert_eq!(HEXLOWER_PERMISSIVE.decode(b"DeadBeef").unwrap(), deadbeef);
+/// assert_eq!(HEXLOWER_PERMISSIVE.encode(&deadbeef), "deadbeef");
+/// ```
+///
+/// You can also define a shorter name:
+///
+/// ```rust
+/// use data_encoding::{Encoding, HEXLOWER_PERMISSIVE};
+/// const HEX: Encoding = HEXLOWER_PERMISSIVE;
+/// ```
+pub const HEXLOWER_PERMISSIVE: Encoding = Encoding::internal_new(HEXLOWER_PERMISSIVE_IMPL);
+const HEXLOWER_PERMISSIVE_IMPL: &[u8] = &[
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54,
+ 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100,
+ 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51,
+ 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
+ 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48,
+ 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100,
+ 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51,
+ 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
+ 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48,
+ 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 97, 98, 99, 100, 101, 102, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 0, 1, 2,
+ 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 28,
+];
+
+/// Uppercase hexadecimal encoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, HEXUPPER};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("0123456789ABCDEF");
+/// assert_eq!(HEXUPPER, spec.encoding().unwrap());
+/// ```
+///
+/// It is compliant with [RFC4648] and known as "base16" or "hex".
+///
+/// # Examples
+///
+/// ```rust
+/// use data_encoding::HEXUPPER;
+/// let deadbeef = vec![0xde, 0xad, 0xbe, 0xef];
+/// assert_eq!(HEXUPPER.decode(b"DEADBEEF").unwrap(), deadbeef);
+/// assert_eq!(HEXUPPER.encode(&deadbeef), "DEADBEEF");
+/// ```
+///
+/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-8
+pub const HEXUPPER: Encoding = Encoding::internal_new(HEXUPPER_IMPL);
+const HEXUPPER_IMPL: &[u8] = &[
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11,
+ 12, 13, 14, 15, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 28,
+];
+
+/// Uppercase hexadecimal encoding with case-insensitive decoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, HEXUPPER_PERMISSIVE};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("0123456789ABCDEF");
+/// spec.translate.from.push_str("abcdef");
+/// spec.translate.to.push_str("ABCDEF");
+/// assert_eq!(HEXUPPER_PERMISSIVE, spec.encoding().unwrap());
+/// ```
+///
+/// # Examples
+///
+/// ```rust
+/// use data_encoding::HEXUPPER_PERMISSIVE;
+/// let deadbeef = vec![0xde, 0xad, 0xbe, 0xef];
+/// assert_eq!(HEXUPPER_PERMISSIVE.decode(b"DeadBeef").unwrap(), deadbeef);
+/// assert_eq!(HEXUPPER_PERMISSIVE.encode(&deadbeef), "DEADBEEF");
+/// ```
+pub const HEXUPPER_PERMISSIVE: Encoding = Encoding::internal_new(HEXUPPER_PERMISSIVE_IMPL);
+const HEXUPPER_PERMISSIVE_IMPL: &[u8] = &[
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11,
+ 12, 13, 14, 15, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 28,
+];
+
+/// Padded base32 encoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, BASE32};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
+/// spec.padding = Some('=');
+/// assert_eq!(BASE32, spec.encoding().unwrap());
+/// ```
+///
+/// It is conform to [RFC4648].
+///
+/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-6
+pub const BASE32: Encoding = Encoding::internal_new(BASE32_IMPL);
+const BASE32_IMPL: &[u8] = &[
+ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
+ 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
+ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
+ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
+ 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
+ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
+ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
+ 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 128, 128, 128, 128, 128, 130, 128, 128,
+ 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+ 25, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 29,
+];
+
+/// Unpadded base32 encoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, BASE32_NOPAD};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
+/// assert_eq!(BASE32_NOPAD, spec.encoding().unwrap());
+/// ```
+pub const BASE32_NOPAD: Encoding = Encoding::internal_new(BASE32_NOPAD_IMPL);
+const BASE32_NOPAD_IMPL: &[u8] = &[
+ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
+ 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
+ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
+ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
+ 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
+ 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
+ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
+ 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+ 25, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 29,
+];
+
+/// Padded base32hex encoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, BASE32HEX};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("0123456789ABCDEFGHIJKLMNOPQRSTUV");
+/// spec.padding = Some('=');
+/// assert_eq!(BASE32HEX, spec.encoding().unwrap());
+/// ```
+///
+/// It is conform to [RFC4648].
+///
+/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-7
+pub const BASE32HEX: Encoding = Encoding::internal_new(BASE32HEX_IMPL);
+const BASE32HEX_IMPL: &[u8] = &[
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
+ 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
+ 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
+ 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 130, 128, 128, 128, 10, 11,
+ 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 29,
+];
+
+/// Unpadded base32hex encoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, BASE32HEX_NOPAD};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("0123456789ABCDEFGHIJKLMNOPQRSTUV");
+/// assert_eq!(BASE32HEX_NOPAD, spec.encoding().unwrap());
+/// ```
+pub const BASE32HEX_NOPAD: Encoding = Encoding::internal_new(BASE32HEX_NOPAD_IMPL);
+const BASE32HEX_NOPAD_IMPL: &[u8] = &[
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
+ 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
+ 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
+ 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
+ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11,
+ 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 29,
+];
+
+/// DNSSEC base32 encoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, BASE32_DNSSEC};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("0123456789abcdefghijklmnopqrstuv");
+/// spec.translate.from.push_str("ABCDEFGHIJKLMNOPQRSTUV");
+/// spec.translate.to.push_str("abcdefghijklmnopqrstuv");
+/// assert_eq!(BASE32_DNSSEC, spec.encoding().unwrap());
+/// ```
+///
+/// It is conform to [RFC5155]:
+///
+/// - It uses a base32 extended hex alphabet.
+/// - It is case-insensitive when decoding and uses lowercase when encoding.
+/// - It does not use padding.
+///
+/// [RFC5155]: https://tools.ietf.org/html/rfc5155
+pub const BASE32_DNSSEC: Encoding = Encoding::internal_new(BASE32_DNSSEC_IMPL);
+const BASE32_DNSSEC_IMPL: &[u8] = &[
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
+ 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+ 116, 117, 118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104,
+ 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 48, 49, 50, 51, 52, 53,
+ 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
+ 113, 114, 115, 116, 117, 118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101,
+ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 48, 49,
+ 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
+ 110, 111, 112, 113, 114, 115, 116, 117, 118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98,
+ 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
+ 118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
+ 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11, 12, 13,
+ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+ 26, 27, 28, 29, 30, 31, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 29,
+];
+
+/// DNSCurve base32 encoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{BitOrder, Specification, BASE32_DNSCURVE};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("0123456789bcdfghjklmnpqrstuvwxyz");
+/// spec.bit_order = BitOrder::LeastSignificantFirst;
+/// spec.translate.from.push_str("BCDFGHJKLMNPQRSTUVWXYZ");
+/// spec.translate.to.push_str("bcdfghjklmnpqrstuvwxyz");
+/// assert_eq!(BASE32_DNSCURVE, spec.encoding().unwrap());
+/// ```
+///
+/// It is conform to [DNSCurve].
+///
+/// [DNSCurve]: https://dnscurve.org/in-implement.html
+pub const BASE32_DNSCURVE: Encoding = Encoding::internal_new(BASE32_DNSCURVE_IMPL);
+const BASE32_DNSCURVE_IMPL: &[u8] = &[
+ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107, 108, 109, 110,
+ 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
+ 98, 99, 100, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119,
+ 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107,
+ 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53,
+ 54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116,
+ 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103,
+ 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49,
+ 50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113,
+ 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99,
+ 100, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
+ 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107, 108, 109,
+ 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 128, 10, 11,
+ 12, 128, 13, 14, 15, 128, 16, 17, 18, 19, 20, 128, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ 128, 128, 128, 128, 128, 128, 128, 10, 11, 12, 128, 13, 14, 15, 128, 16, 17, 18, 19, 20, 128,
+ 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 21,
+];
+
+/// Padded base64 encoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, BASE64};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
+/// spec.padding = Some('=');
+/// assert_eq!(BASE64, spec.encoding().unwrap());
+/// ```
+///
+/// It is conform to [RFC4648].
+///
+/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-4
+pub const BASE64: Encoding = Encoding::internal_new(BASE64_IMPL);
+const BASE64_IMPL: &[u8] = &[
+ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
+ 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66,
+ 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
+ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+ 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67,
+ 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
+ 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
+ 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67, 68,
+ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
+ 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
+ 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 130, 128,
+ 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 30,
+];
+
+/// Unpadded base64 encoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, BASE64_NOPAD};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
+/// assert_eq!(BASE64_NOPAD, spec.encoding().unwrap());
+/// ```
+pub const BASE64_NOPAD: Encoding = Encoding::internal_new(BASE64_NOPAD_IMPL);
+const BASE64_NOPAD_IMPL: &[u8] = &[
+ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
+ 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66,
+ 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
+ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+ 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67,
+ 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
+ 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
+ 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67, 68,
+ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
+ 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
+ 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 128, 128,
+ 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 30,
+];
+
+/// MIME base64 encoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, Wrap, BASE64_MIME};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
+/// spec.padding = Some('=');
+/// spec.wrap.width = 76;
+/// spec.wrap.separator.push_str("\r\n");
+/// assert_eq!(BASE64_MIME, spec.encoding().unwrap());
+/// ```
+///
+/// It is not exactly conform to [RFC2045] because it does not print the header
+/// and does not ignore all characters.
+///
+/// [RFC2045]: https://tools.ietf.org/html/rfc2045
+pub const BASE64_MIME: Encoding = Encoding::internal_new(BASE64_MIME_IMPL);
+const BASE64_MIME_IMPL: &[u8] = &[
+ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
+ 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66,
+ 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
+ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+ 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67,
+ 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
+ 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
+ 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67, 68,
+ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
+ 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
+ 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 129, 128, 128, 129, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 130, 128,
+ 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 30, 76, 13, 10,
+];
+
+/// Padded base64url encoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, BASE64URL};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_");
+/// spec.padding = Some('=');
+/// assert_eq!(BASE64URL, spec.encoding().unwrap());
+/// ```
+///
+/// It is conform to [RFC4648].
+///
+/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-5
+pub const BASE64URL: Encoding = Encoding::internal_new(BASE64URL_IMPL);
+const BASE64URL_IMPL: &[u8] = &[
+ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
+ 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66,
+ 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
+ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+ 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66, 67,
+ 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
+ 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
+ 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66, 67, 68,
+ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
+ 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
+ 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 62, 128, 128, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 130, 128,
+ 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, 128, 128, 128, 128, 63, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 30,
+];
+
+/// Unpadded base64url encoding
+///
+/// This encoding is a static version of:
+///
+/// ```rust
+/// # use data_encoding::{Specification, BASE64URL_NOPAD};
+/// let mut spec = Specification::new();
+/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_");
+/// assert_eq!(BASE64URL_NOPAD, spec.encoding().unwrap());
+/// ```
+pub const BASE64URL_NOPAD: Encoding = Encoding::internal_new(BASE64URL_NOPAD_IMPL);
+const BASE64URL_NOPAD_IMPL: &[u8] = &[
+ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
+ 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66,
+ 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
+ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+ 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66, 67,
+ 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
+ 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
+ 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66, 67, 68,
+ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
+ 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
+ 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 62, 128, 128, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 128, 128,
+ 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, 128, 128, 128, 128, 63, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 30,
+];