@solana/codecs-strings 2.0.0-20241006045741

package/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2023 Solana Labs, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,201 @@
+[![npm][npm-image]][npm-url]
+[![npm-downloads][npm-downloads-image]][npm-url]
+[![semantic-release][semantic-release-image]][semantic-release-url]
+<br />
+[![code-style-prettier][code-style-prettier-image]][code-style-prettier-url]
+
+[code-style-prettier-image]: https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square
+[code-style-prettier-url]: https://github.com/prettier/prettier
+[npm-downloads-image]: https://img.shields.io/npm/dm/@solana/codecs-strings/rc.svg?style=flat
+[npm-image]: https://img.shields.io/npm/v/@solana/codecs-strings/rc.svg?style=flat
+[npm-url]: https://www.npmjs.com/package/@solana/codecs-strings/v/rc
+[semantic-release-image]: https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg
+[semantic-release-url]: https://github.com/semantic-release/semantic-release
+
+# @solana/codecs-strings
+
+This package contains codecs for strings of different sizes and encodings. It can be used standalone, but it is also exported as part of the Solana JavaScript SDK [`@solana/web3.js@rc`](https://github.com/solana-labs/solana-web3.js/tree/master/packages/library).
+
+This package is also part of the [`@solana/codecs` package](https://github.com/solana-labs/solana-web3.js/tree/master/packages/codecs) which acts as an entry point for all codec packages as well as for their documentation.
+
+## Sizing string codecs
+
+The `@solana/codecs-strings` package offers a variety of string codecs such as `utf8`, `base58`, `base64`, etc — which we will discuss in more detail below. However, before digging into the available string codecs, it's important to understand the different sizing strategies available for string codecs.
+
+By default, all available string codecs will return a `VariableSizeCodec<string>` meaning that:
+
+-   When encoding a string, all bytes necessary to encode the string will be used.
+-   When decoding a byte array at a given offset, all bytes starting from that offset will be decoded as a string.
+
+For instance, here's how you can encode/decode `utf8` strings without any size boundary:
+
+```ts
+const codec = getUtf8Codec();
+
+codec.encode('hello');
+// 0x68656c6c6f
+//   └-- Any bytes necessary to encode our content.
+
+codec.decode(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f]));
+// 'hello'
+```
+
+This might be what you want — e.g. when having a string at the end of a data structure — but in many cases, you might want to have a size boundary for your string. You may achieve this by composing your string codec with the [`fixCodecSize`](https://github.com/solana-labs/solana-web3.js/tree/master/packages/codecs-core#fixing-the-size-of-codecs) or [`addCodecSizePrefix`](https://github.com/solana-labs/solana-web3.js/tree/master/packages/codecs-core#prefixing-the-size-of-codecs) functions.
+
+The `fixCodecSize` function accepts a fixed byte length and returns a `FixedSizeCodec<string>` that will always use that amount of bytes to encode and decode a string. Any string longer or smaller than that size will be truncated or padded respectively. Here's how you can use it with a `utf8` codec:
+
+```ts
+const codec = fixCodecSize(getUtf8Codec(), 5);
+
+codec.encode('hello');
+// 0x68656c6c6f
+//   └-- The exact 5 bytes of content.
+
+codec.encode('hello world');
+// 0x68656c6c6f
+//   └-- The truncated 5 bytes of content.
+
+codec.encode('hell');
+// 0x68656c6c00
+//   └-- The padded 5 bytes of content.
+
+codec.decode(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xff, 0xff, 0xff, 0xff]));
+// 'hello'
+```
+
+The `addCodecSizePrefix` function accepts an additional number codec that will be used to encode and decode a size prefix for the string. This prefix allows us to know when to stop reading the string when decoding a given byte array. Here's how you can use it with a `utf8` codec:
+
+```ts
+const codec = addCodecSizePrefix(getUtf8Codec(), getU32Codec());
+
+codec.encode('hello');
+// 0x0500000068656c6c6f
+//   |       └-- The 5 bytes of content.
+//   └-- 4-byte prefix telling us to read 5 bytes.
+
+codec.decode(new Uint8Array([0x05, 0x00, 0x00, 0x00, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xff, 0xff, 0xff, 0xff]));
+// "hello"
+```
+
+Now, let's take a look at the available string encodings. Just remember that you can use the `fixSizeCodec` or `prefixSizeCodec` functions on any of these encodings to add a size boundary to them.
+
+## Utf8 codec
+
+The `getUtf8Codec` function encodes and decodes a UTF-8 string to and from a byte array.
+
+```ts
+const bytes = getUtf8Codec().encode('hello'); // 0x68656c6c6f
+const value = getUtf8Codec().decode(bytes); // "hello"
+```
+
+As usual, separate `getUtf8Encoder` and `getUtf8Decoder` functions are also available.
+
+```ts
+const bytes = getUtf8Encoder().encode('hello'); // 0x68656c6c6f
+const value = getUtf8Decoder().decode(bytes); // "hello"
+```
+
+## Base 64 codec
+
+The `getBase64Codec` function encodes and decodes a base-64 string to and from a byte array.
+
+```ts
+const bytes = getBase64Codec().encode('hello+world'); // 0x85e965a3ec28ae57
+const value = getBase64Codec().decode(bytes); // "hello+world"
+```
+
+As usual, separate `getBase64Encoder` and `getBase64Decoder` functions are also available.
+
+```ts
+const bytes = getBase64Encoder().encode('hello+world'); // 0x85e965a3ec28ae57
+const value = getBase64Decoder().decode(bytes); // "hello+world"
+```
+
+## Base 58 codec
+
+The `getBase58Codec` function encodes and decodes a base-58 string to and from a byte array.
+
+```ts
+const bytes = getBase58Codec().encode('heLLo'); // 0x1b6a3070
+const value = getBase58Codec().decode(bytes); // "heLLo"
+```
+
+As usual, separate `getBase58Encoder` and `getBase58Decoder` functions are also available.
+
+```ts
+const bytes = getBase58Encoder().encode('heLLo'); // 0x1b6a3070
+const value = getBase58Decoder().decode(bytes); // "heLLo"
+```
+
+## Base 16 codec
+
+The `getBase16Codec` function encodes and decodes a base-16 string to and from a byte array.
+
+```ts
+const bytes = getBase16Codec().encode('deadface'); // 0xdeadface
+const value = getBase16Codec().decode(bytes); // "deadface"
+```
+
+As usual, separate `getBase16Encoder` and `getBase16Decoder` functions are also available.
+
+```ts
+const bytes = getBase16Encoder().encode('deadface'); // 0xdeadface
+const value = getBase16Decoder().decode(bytes); // "deadface"
+```
+
+## Base 10 codec
+
+The `getBase10Codec` function encodes and decodes a base-10 string to and from a byte array.
+
+```ts
+const bytes = getBase10Codec().encode('1024'); // 0x0400
+const value = getBase10Codec().decode(bytes); // "1024"
+```
+
+As usual, separate `getBase10Encoder` and `getBase10Decoder` functions are also available.
+
+```ts
+const bytes = getBase10Encoder().encode('1024'); // 0x0400
+const value = getBase10Decoder().decode(bytes); // "1024"
+```
+
+## Base X codec
+
+The `getBaseXCodec` accepts a custom `alphabet` of `X` characters and creates a base-X codec using that alphabet. It does so by iteratively dividing by `X` and handling leading zeros.
+
+The base-10 and base-58 codecs use this base-x codec under the hood.
+
+```ts
+const alphabet = '0ehlo';
+const bytes = getBaseXCodec(alphabet).encode('hello'); // 0x05bd
+const value = getBaseXCodec(alphabet).decode(bytes); // "hello"
+```
+
+As usual, separate `getBaseXEncoder` and `getBaseXDecoder` functions are also available.
+
+```ts
+const bytes = getBaseXEncoder(alphabet).encode('hello'); // 0x05bd
+const value = getBaseXDecoder(alphabet).decode(bytes); // "hello"
+```
+
+## Re-slicing base X codec
+
+The `getBaseXResliceCodec` also creates a base-x codec but uses a different strategy. It re-slices bytes into custom chunks of bits that are then mapped to a provided `alphabet`. The number of bits per chunk is also provided and should typically be set to `log2(alphabet.length)`.
+
+This is typically used to create codecs whose alphabet’s length is a power of 2 such as base-16 or base-64.
+
+```ts
+const bytes = getBaseXResliceCodec('elho', 2).encode('hellolol'); // 0x4aee
+const value = getBaseXResliceCodec('elho', 2).decode(bytes); // "hellolol"
+```
+
+As usual, separate `getBaseXResliceEncoder` and `getBaseXResliceDecoder` functions are also available.
+
+```ts
+const bytes = getBaseXResliceEncoder('elho', 2).encode('hellolol'); // 0x4aee
+const value = getBaseXResliceDecoder('elho', 2).decode(bytes); // "hellolol"
+```
+
+---
+
+To read more about the available codecs and how to use them, check out the documentation of the main [`@solana/codecs` package](https://github.com/solana-labs/solana-web3.js/tree/master/packages/codecs).

package/dist/index.browser.cjs

@@ -0,0 +1,288 @@
+'use strict';
+
+var errors = require('@solana/errors');
+var codecsCore = require('@solana/codecs-core');
+
+// src/assertions.ts
+function assertValidBaseString(alphabet4, testValue, givenValue = testValue) {
+  if (!testValue.match(new RegExp(`^[${alphabet4}]*$`))) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {
+      alphabet: alphabet4,
+      base: alphabet4.length,
+      value: givenValue
+    });
+  }
+}
+var getBaseXEncoder = (alphabet4) => {
+  return codecsCore.createEncoder({
+    getSizeFromValue: (value) => {
+      const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
+      if (!tailChars) return value.length;
+      const base10Number = getBigIntFromBaseX(tailChars, alphabet4);
+      return leadingZeroes.length + Math.ceil(base10Number.toString(16).length / 2);
+    },
+    write(value, bytes, offset) {
+      assertValidBaseString(alphabet4, value);
+      if (value === "") return offset;
+      const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
+      if (!tailChars) {
+        bytes.set(new Uint8Array(leadingZeroes.length).fill(0), offset);
+        return offset + leadingZeroes.length;
+      }
+      let base10Number = getBigIntFromBaseX(tailChars, alphabet4);
+      const tailBytes = [];
+      while (base10Number > 0n) {
+        tailBytes.unshift(Number(base10Number % 256n));
+        base10Number /= 256n;
+      }
+      const bytesToAdd = [...Array(leadingZeroes.length).fill(0), ...tailBytes];
+      bytes.set(bytesToAdd, offset);
+      return offset + bytesToAdd.length;
+    }
+  });
+};
+var getBaseXDecoder = (alphabet4) => {
+  return codecsCore.createDecoder({
+    read(rawBytes, offset) {
+      const bytes = offset === 0 ? rawBytes : rawBytes.slice(offset);
+      if (bytes.length === 0) return ["", 0];
+      let trailIndex = bytes.findIndex((n) => n !== 0);
+      trailIndex = trailIndex === -1 ? bytes.length : trailIndex;
+      const leadingZeroes = alphabet4[0].repeat(trailIndex);
+      if (trailIndex === bytes.length) return [leadingZeroes, rawBytes.length];
+      const base10Number = bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);
+      const tailChars = getBaseXFromBigInt(base10Number, alphabet4);
+      return [leadingZeroes + tailChars, rawBytes.length];
+    }
+  });
+};
+var getBaseXCodec = (alphabet4) => codecsCore.combineCodec(getBaseXEncoder(alphabet4), getBaseXDecoder(alphabet4));
+function partitionLeadingZeroes(value, zeroCharacter) {
+  const [leadingZeros, tailChars] = value.split(new RegExp(`((?!${zeroCharacter}).*)`));
+  return [leadingZeros, tailChars];
+}
+function getBigIntFromBaseX(value, alphabet4) {
+  const base = BigInt(alphabet4.length);
+  let sum = 0n;
+  for (const char of value) {
+    sum *= base;
+    sum += BigInt(alphabet4.indexOf(char));
+  }
+  return sum;
+}
+function getBaseXFromBigInt(value, alphabet4) {
+  const base = BigInt(alphabet4.length);
+  const tailChars = [];
+  while (value > 0n) {
+    tailChars.unshift(alphabet4[Number(value % base)]);
+    value /= base;
+  }
+  return tailChars.join("");
+}
+
+// src/base10.ts
+var alphabet = "0123456789";
+var getBase10Encoder = () => getBaseXEncoder(alphabet);
+var getBase10Decoder = () => getBaseXDecoder(alphabet);
+var getBase10Codec = () => getBaseXCodec(alphabet);
+var INVALID_STRING_ERROR_BASE_CONFIG = {
+  alphabet: "0123456789abcdef",
+  base: 16
+};
+function charCodeToBase16(char) {
+  if (char >= 48 /* ZERO */ && char <= 57 /* NINE */) return char - 48 /* ZERO */;
+  if (char >= 65 /* A_UP */ && char <= 70 /* F_UP */) return char - (65 /* A_UP */ - 10);
+  if (char >= 97 /* A_LO */ && char <= 102 /* F_LO */) return char - (97 /* A_LO */ - 10);
+}
+var getBase16Encoder = () => codecsCore.createEncoder({
+  getSizeFromValue: (value) => Math.ceil(value.length / 2),
+  write(value, bytes, offset) {
+    const len = value.length;
+    const al = len / 2;
+    if (len === 1) {
+      const c = value.charCodeAt(0);
+      const n = charCodeToBase16(c);
+      if (n === void 0) {
+        throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {
+          ...INVALID_STRING_ERROR_BASE_CONFIG,
+          value
+        });
+      }
+      bytes.set([n], offset);
+      return 1 + offset;
+    }
+    const hexBytes = new Uint8Array(al);
+    for (let i = 0, j = 0; i < al; i++) {
+      const c1 = value.charCodeAt(j++);
+      const c2 = value.charCodeAt(j++);
+      const n1 = charCodeToBase16(c1);
+      const n2 = charCodeToBase16(c2);
+      if (n1 === void 0 || n2 === void 0 && !Number.isNaN(c2)) {
+        throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {
+          ...INVALID_STRING_ERROR_BASE_CONFIG,
+          value
+        });
+      }
+      hexBytes[i] = !Number.isNaN(c2) ? n1 << 4 | (n2 ?? 0) : n1;
+    }
+    bytes.set(hexBytes, offset);
+    return hexBytes.length + offset;
+  }
+});
+var getBase16Decoder = () => codecsCore.createDecoder({
+  read(bytes, offset) {
+    const value = bytes.slice(offset).reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+    return [value, bytes.length];
+  }
+});
+var getBase16Codec = () => codecsCore.combineCodec(getBase16Encoder(), getBase16Decoder());
+
+// src/base58.ts
+var alphabet2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var getBase58Encoder = () => getBaseXEncoder(alphabet2);
+var getBase58Decoder = () => getBaseXDecoder(alphabet2);
+var getBase58Codec = () => getBaseXCodec(alphabet2);
+var getBaseXResliceEncoder = (alphabet4, bits) => codecsCore.createEncoder({
+  getSizeFromValue: (value) => Math.floor(value.length * bits / 8),
+  write(value, bytes, offset) {
+    assertValidBaseString(alphabet4, value);
+    if (value === "") return offset;
+    const charIndices = [...value].map((c) => alphabet4.indexOf(c));
+    const reslicedBytes = reslice(charIndices, bits, 8, false);
+    bytes.set(reslicedBytes, offset);
+    return reslicedBytes.length + offset;
+  }
+});
+var getBaseXResliceDecoder = (alphabet4, bits) => codecsCore.createDecoder({
+  read(rawBytes, offset = 0) {
+    const bytes = offset === 0 ? rawBytes : rawBytes.slice(offset);
+    if (bytes.length === 0) return ["", rawBytes.length];
+    const charIndices = reslice([...bytes], 8, bits, true);
+    return [charIndices.map((i) => alphabet4[i]).join(""), rawBytes.length];
+  }
+});
+var getBaseXResliceCodec = (alphabet4, bits) => codecsCore.combineCodec(getBaseXResliceEncoder(alphabet4, bits), getBaseXResliceDecoder(alphabet4, bits));
+function reslice(input, inputBits, outputBits, useRemainder) {
+  const output = [];
+  let accumulator = 0;
+  let bitsInAccumulator = 0;
+  const mask = (1 << outputBits) - 1;
+  for (const value of input) {
+    accumulator = accumulator << inputBits | value;
+    bitsInAccumulator += inputBits;
+    while (bitsInAccumulator >= outputBits) {
+      bitsInAccumulator -= outputBits;
+      output.push(accumulator >> bitsInAccumulator & mask);
+    }
+  }
+  if (useRemainder && bitsInAccumulator > 0) {
+    output.push(accumulator << outputBits - bitsInAccumulator & mask);
+  }
+  return output;
+}
+
+// src/base64.ts
+var alphabet3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var getBase64Encoder = () => {
+  {
+    return codecsCore.createEncoder({
+      getSizeFromValue: (value) => {
+        try {
+          return atob(value).length;
+        } catch (e2) {
+          throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {
+            alphabet: alphabet3,
+            base: 64,
+            value
+          });
+        }
+      },
+      write(value, bytes, offset) {
+        try {
+          const bytesToAdd = atob(value).split("").map((c) => c.charCodeAt(0));
+          bytes.set(bytesToAdd, offset);
+          return bytesToAdd.length + offset;
+        } catch (e2) {
+          throw new errors.SolanaError(errors.SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {
+            alphabet: alphabet3,
+            base: 64,
+            value
+          });
+        }
+      }
+    });
+  }
+};
+var getBase64Decoder = () => {
+  {
+    return codecsCore.createDecoder({
+      read(bytes, offset = 0) {
+        const slice = bytes.slice(offset);
+        const value = btoa(String.fromCharCode(...slice));
+        return [value, bytes.length];
+      }
+    });
+  }
+};
+var getBase64Codec = () => codecsCore.combineCodec(getBase64Encoder(), getBase64Decoder());
+
+// src/null-characters.ts
+var removeNullCharacters = (value) => (
+  // eslint-disable-next-line no-control-regex
+  value.replace(/\u0000/g, "")
+);
+var padNullCharacters = (value, chars) => value.padEnd(chars, "\0");
+
+// ../text-encoding-impl/dist/index.browser.mjs
+var e = globalThis.TextDecoder;
+var o = globalThis.TextEncoder;
+
+// src/utf8.ts
+var getUtf8Encoder = () => {
+  let textEncoder;
+  return codecsCore.createEncoder({
+    getSizeFromValue: (value) => (textEncoder ||= new o()).encode(value).length,
+    write: (value, bytes, offset) => {
+      const bytesToAdd = (textEncoder ||= new o()).encode(value);
+      bytes.set(bytesToAdd, offset);
+      return offset + bytesToAdd.length;
+    }
+  });
+};
+var getUtf8Decoder = () => {
+  let textDecoder;
+  return codecsCore.createDecoder({
+    read(bytes, offset) {
+      const value = (textDecoder ||= new e()).decode(bytes.slice(offset));
+      return [removeNullCharacters(value), bytes.length];
+    }
+  });
+};
+var getUtf8Codec = () => codecsCore.combineCodec(getUtf8Encoder(), getUtf8Decoder());
+
+exports.assertValidBaseString = assertValidBaseString;
+exports.getBase10Codec = getBase10Codec;
+exports.getBase10Decoder = getBase10Decoder;
+exports.getBase10Encoder = getBase10Encoder;
+exports.getBase16Codec = getBase16Codec;
+exports.getBase16Decoder = getBase16Decoder;
+exports.getBase16Encoder = getBase16Encoder;
+exports.getBase58Codec = getBase58Codec;
+exports.getBase58Decoder = getBase58Decoder;
+exports.getBase58Encoder = getBase58Encoder;
+exports.getBase64Codec = getBase64Codec;
+exports.getBase64Decoder = getBase64Decoder;
+exports.getBase64Encoder = getBase64Encoder;
+exports.getBaseXCodec = getBaseXCodec;
+exports.getBaseXDecoder = getBaseXDecoder;
+exports.getBaseXEncoder = getBaseXEncoder;
+exports.getBaseXResliceCodec = getBaseXResliceCodec;
+exports.getBaseXResliceDecoder = getBaseXResliceDecoder;
+exports.getBaseXResliceEncoder = getBaseXResliceEncoder;
+exports.getUtf8Codec = getUtf8Codec;
+exports.getUtf8Decoder = getUtf8Decoder;
+exports.getUtf8Encoder = getUtf8Encoder;
+exports.padNullCharacters = padNullCharacters;
+exports.removeNullCharacters = removeNullCharacters;
+//# sourceMappingURL=index.browser.cjs.map
+//# sourceMappingURL=index.browser.cjs.map

package/dist/index.browser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/assertions.ts","../src/baseX.ts","../src/base10.ts","../src/base16.ts","../src/base58.ts","../src/baseX-reslice.ts","../src/base64.ts","../src/null-characters.ts","../../text-encoding-impl/src/index.browser.ts","../src/utf8.ts"],"names":["alphabet","SolanaError","SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE","createEncoder","createDecoder","combineCodec","e","TextDecoder","TextEncoder"],"mappings":"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","file":"index.browser.cjs","sourcesContent":["import { SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, SolanaError } from '@solana/errors';\n\n/**\n * Asserts that a given string matches a given alphabet.\n */\nexport function assertValidBaseString(alphabet: string, testValue: string, givenValue = testValue) {\n    if (!testValue.match(new RegExp(`^[${alphabet}]*$`))) {\n        throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {\n            alphabet,\n            base: alphabet.length,\n            value: givenValue,\n        });\n    }\n}\n","import {\n    combineCodec,\n    createDecoder,\n    createEncoder,\n    VariableSizeCodec,\n    VariableSizeDecoder,\n    VariableSizeEncoder,\n} from '@solana/codecs-core';\n\nimport { assertValidBaseString } from './assertions';\n\n/**\n * Encodes a string using a custom alphabet by dividing\n * by the base and handling leading zeroes.\n * @see {@link getBaseXCodec} for a more detailed description.\n */\nexport const getBaseXEncoder = (alphabet: string): VariableSizeEncoder<string> => {\n    return createEncoder({\n        getSizeFromValue: (value: string): number => {\n            const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet[0]);\n            if (!tailChars) return value.length;\n\n            const base10Number = getBigIntFromBaseX(tailChars, alphabet);\n            return leadingZeroes.length + Math.ceil(base10Number.toString(16).length / 2);\n        },\n        write(value: string, bytes, offset) {\n            // Check if the value is valid.\n            assertValidBaseString(alphabet, value);\n            if (value === '') return offset;\n\n            // Handle leading zeroes.\n            const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet[0]);\n            if (!tailChars) {\n                bytes.set(new Uint8Array(leadingZeroes.length).fill(0), offset);\n                return offset + leadingZeroes.length;\n            }\n\n            // From baseX to base10.\n            let base10Number = getBigIntFromBaseX(tailChars, alphabet);\n\n            // From base10 to bytes.\n            const tailBytes: number[] = [];\n            while (base10Number > 0n) {\n                tailBytes.unshift(Number(base10Number % 256n));\n                base10Number /= 256n;\n            }\n\n            const bytesToAdd = [...Array(leadingZeroes.length).fill(0), ...tailBytes];\n            bytes.set(bytesToAdd, offset);\n            return offset + bytesToAdd.length;\n        },\n    });\n};\n\n/**\n * Decodes a string using a custom alphabet by dividing\n * by the base and handling leading zeroes.\n * @see {@link getBaseXCodec} for a more detailed description.\n */\nexport const getBaseXDecoder = (alphabet: string): VariableSizeDecoder<string> => {\n    return createDecoder({\n        read(rawBytes, offset): [string, number] {\n            const bytes = offset === 0 ? rawBytes : rawBytes.slice(offset);\n            if (bytes.length === 0) return ['', 0];\n\n            // Handle leading zeroes.\n            let trailIndex = bytes.findIndex(n => n !== 0);\n            trailIndex = trailIndex === -1 ? bytes.length : trailIndex;\n            const leadingZeroes = alphabet[0].repeat(trailIndex);\n            if (trailIndex === bytes.length) return [leadingZeroes, rawBytes.length];\n\n            // From bytes to base10.\n            const base10Number = bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);\n\n            // From base10 to baseX.\n            const tailChars = getBaseXFromBigInt(base10Number, alphabet);\n\n            return [leadingZeroes + tailChars, rawBytes.length];\n        },\n    });\n};\n\n/**\n * A string codec that requires a custom alphabet and uses\n * the length of that alphabet as the base. It then divides\n * the input by the base as many times as necessary to get\n * the output. It also supports leading zeroes by using the\n * first character of the alphabet as the zero character.\n *\n * This can be used to create codecs such as base10 or base58.\n */\nexport const getBaseXCodec = (alphabet: string): VariableSizeCodec<string> =>\n    combineCodec(getBaseXEncoder(alphabet), getBaseXDecoder(alphabet));\n\nfunction partitionLeadingZeroes(\n    value: string,\n    zeroCharacter: string,\n): [leadingZeros: string, tailChars: string | undefined] {\n    const [leadingZeros, tailChars] = value.split(new RegExp(`((?!${zeroCharacter}).*)`));\n    return [leadingZeros, tailChars];\n}\n\nfunction getBigIntFromBaseX(value: string, alphabet: string): bigint {\n    const base = BigInt(alphabet.length);\n    let sum = 0n;\n    for (const char of value) {\n        sum *= base;\n        sum += BigInt(alphabet.indexOf(char));\n    }\n    return sum;\n}\n\nfunction getBaseXFromBigInt(value: bigint, alphabet: string): string {\n    const base = BigInt(alphabet.length);\n    const tailChars = [];\n    while (value > 0n) {\n        tailChars.unshift(alphabet[Number(value % base)]);\n        value /= base;\n    }\n    return tailChars.join('');\n}\n","import { getBaseXCodec, getBaseXDecoder, getBaseXEncoder } from './baseX';\n\nconst alphabet = '0123456789';\n\n/** Encodes strings in base10. */\nexport const getBase10Encoder = () => getBaseXEncoder(alphabet);\n\n/** Decodes strings in base10. */\nexport const getBase10Decoder = () => getBaseXDecoder(alphabet);\n\n/** Encodes and decodes strings in base10. */\nexport const getBase10Codec = () => getBaseXCodec(alphabet);\n","import {\n    combineCodec,\n    createDecoder,\n    createEncoder,\n    VariableSizeCodec,\n    VariableSizeDecoder,\n    VariableSizeEncoder,\n} from '@solana/codecs-core';\nimport { SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, SolanaError } from '@solana/errors';\n\nconst enum HexC {\n    ZERO = 48, // 0\n    NINE = 57, // 9\n    A_UP = 65, // A\n    F_UP = 70, // F\n    A_LO = 97, // a\n    F_LO = 102, // f\n}\n\nconst INVALID_STRING_ERROR_BASE_CONFIG = {\n    alphabet: '0123456789abcdef',\n    base: 16,\n} as const;\n\nfunction charCodeToBase16(char: number) {\n    if (char >= HexC.ZERO && char <= HexC.NINE) return char - HexC.ZERO;\n    if (char >= HexC.A_UP && char <= HexC.F_UP) return char - (HexC.A_UP - 10);\n    if (char >= HexC.A_LO && char <= HexC.F_LO) return char - (HexC.A_LO - 10);\n}\n\n/** Encodes strings in base16. */\nexport const getBase16Encoder = (): VariableSizeEncoder<string> =>\n    createEncoder({\n        getSizeFromValue: (value: string) => Math.ceil(value.length / 2),\n        write(value: string, bytes, offset) {\n            const len = value.length;\n            const al = len / 2;\n            if (len === 1) {\n                const c = value.charCodeAt(0);\n                const n = charCodeToBase16(c);\n                if (n === undefined) {\n                    throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {\n                        ...INVALID_STRING_ERROR_BASE_CONFIG,\n                        value,\n                    });\n                }\n                bytes.set([n], offset);\n                return 1 + offset;\n            }\n            const hexBytes = new Uint8Array(al);\n            for (let i = 0, j = 0; i < al; i++) {\n                const c1 = value.charCodeAt(j++);\n                const c2 = value.charCodeAt(j++);\n\n                const n1 = charCodeToBase16(c1);\n                const n2 = charCodeToBase16(c2);\n                if (n1 === undefined || (n2 === undefined && !Number.isNaN(c2))) {\n                    throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {\n                        ...INVALID_STRING_ERROR_BASE_CONFIG,\n                        value,\n                    });\n                }\n                hexBytes[i] = !Number.isNaN(c2) ? (n1 << 4) | (n2 ?? 0) : n1;\n            }\n\n            bytes.set(hexBytes, offset);\n            return hexBytes.length + offset;\n        },\n    });\n\n/** Decodes strings in base16. */\nexport const getBase16Decoder = (): VariableSizeDecoder<string> =>\n    createDecoder({\n        read(bytes, offset) {\n            const value = bytes.slice(offset).reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');\n            return [value, bytes.length];\n        },\n    });\n\n/** Encodes and decodes strings in base16. */\nexport const getBase16Codec = (): VariableSizeCodec<string> => combineCodec(getBase16Encoder(), getBase16Decoder());\n","import { getBaseXCodec, getBaseXDecoder, getBaseXEncoder } from './baseX';\n\nconst alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';\n\n/** Encodes strings in base58. */\nexport const getBase58Encoder = () => getBaseXEncoder(alphabet);\n\n/** Decodes strings in base58. */\nexport const getBase58Decoder = () => getBaseXDecoder(alphabet);\n\n/** Encodes and decodes strings in base58. */\nexport const getBase58Codec = () => getBaseXCodec(alphabet);\n","import {\n    combineCodec,\n    createDecoder,\n    createEncoder,\n    VariableSizeCodec,\n    VariableSizeDecoder,\n    VariableSizeEncoder,\n} from '@solana/codecs-core';\n\nimport { assertValidBaseString } from './assertions';\n\n/**\n * Encodes a string using a custom alphabet by reslicing the bits of the byte array.\n * @see {@link getBaseXResliceCodec} for a more detailed description.\n */\nexport const getBaseXResliceEncoder = (alphabet: string, bits: number): VariableSizeEncoder<string> =>\n    createEncoder({\n        getSizeFromValue: (value: string) => Math.floor((value.length * bits) / 8),\n        write(value: string, bytes, offset) {\n            assertValidBaseString(alphabet, value);\n            if (value === '') return offset;\n            const charIndices = [...value].map(c => alphabet.indexOf(c));\n            const reslicedBytes = reslice(charIndices, bits, 8, false);\n            bytes.set(reslicedBytes, offset);\n            return reslicedBytes.length + offset;\n        },\n    });\n\n/**\n * Decodes a string using a custom alphabet by reslicing the bits of the byte array.\n * @see {@link getBaseXResliceCodec} for a more detailed description.\n */\nexport const getBaseXResliceDecoder = (alphabet: string, bits: number): VariableSizeDecoder<string> =>\n    createDecoder({\n        read(rawBytes, offset = 0): [string, number] {\n            const bytes = offset === 0 ? rawBytes : rawBytes.slice(offset);\n            if (bytes.length === 0) return ['', rawBytes.length];\n            const charIndices = reslice([...bytes], 8, bits, true);\n            return [charIndices.map(i => alphabet[i]).join(''), rawBytes.length];\n        },\n    });\n\n/**\n * A string serializer that reslices bytes into custom chunks\n * of bits that are then mapped to a custom alphabet.\n *\n * This can be used to create serializers whose alphabet\n * is a power of 2 such as base16 or base64.\n */\nexport const getBaseXResliceCodec = (alphabet: string, bits: number): VariableSizeCodec<string> =>\n    combineCodec(getBaseXResliceEncoder(alphabet, bits), getBaseXResliceDecoder(alphabet, bits));\n\n/** Helper function to reslice the bits inside bytes. */\nfunction reslice(input: number[], inputBits: number, outputBits: number, useRemainder: boolean): number[] {\n    const output = [];\n    let accumulator = 0;\n    let bitsInAccumulator = 0;\n    const mask = (1 << outputBits) - 1;\n    for (const value of input) {\n        accumulator = (accumulator << inputBits) | value;\n        bitsInAccumulator += inputBits;\n        while (bitsInAccumulator >= outputBits) {\n            bitsInAccumulator -= outputBits;\n            output.push((accumulator >> bitsInAccumulator) & mask);\n        }\n    }\n    if (useRemainder && bitsInAccumulator > 0) {\n        output.push((accumulator << (outputBits - bitsInAccumulator)) & mask);\n    }\n    return output;\n}\n","import {\n    combineCodec,\n    createDecoder,\n    createEncoder,\n    transformDecoder,\n    transformEncoder,\n    VariableSizeCodec,\n    VariableSizeDecoder,\n    VariableSizeEncoder,\n} from '@solana/codecs-core';\nimport { SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, SolanaError } from '@solana/errors';\n\nimport { assertValidBaseString } from './assertions';\nimport { getBaseXResliceDecoder, getBaseXResliceEncoder } from './baseX-reslice';\n\nconst alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\n/** Encodes strings in base64. */\nexport const getBase64Encoder = (): VariableSizeEncoder<string> => {\n    if (__BROWSER__) {\n        return createEncoder({\n            getSizeFromValue: (value: string) => {\n                try {\n                    return (atob as Window['atob'])(value).length;\n                } catch (e) {\n                    throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {\n                        alphabet,\n                        base: 64,\n                        value,\n                    });\n                }\n            },\n            write(value: string, bytes, offset) {\n                try {\n                    const bytesToAdd = (atob as Window['atob'])(value)\n                        .split('')\n                        .map(c => c.charCodeAt(0));\n                    bytes.set(bytesToAdd, offset);\n                    return bytesToAdd.length + offset;\n                } catch (e) {\n                    throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {\n                        alphabet,\n                        base: 64,\n                        value,\n                    });\n                }\n            },\n        });\n    }\n\n    if (__NODEJS__) {\n        return createEncoder({\n            getSizeFromValue: (value: string) => Buffer.from(value, 'base64').length,\n            write(value: string, bytes, offset) {\n                assertValidBaseString(alphabet, value.replace(/=/g, ''));\n                const buffer = Buffer.from(value, 'base64');\n                bytes.set(buffer, offset);\n                return buffer.length + offset;\n            },\n        });\n    }\n\n    return transformEncoder(getBaseXResliceEncoder(alphabet, 6), (value: string): string => value.replace(/=/g, ''));\n};\n\n/** Decodes strings in base64. */\nexport const getBase64Decoder = (): VariableSizeDecoder<string> => {\n    if (__BROWSER__) {\n        return createDecoder({\n            read(bytes, offset = 0) {\n                const slice = bytes.slice(offset);\n                const value = (btoa as Window['btoa'])(String.fromCharCode(...slice));\n                return [value, bytes.length];\n            },\n        });\n    }\n\n    if (__NODEJS__) {\n        return createDecoder({\n            read: (bytes, offset = 0) => [Buffer.from(bytes, offset).toString('base64'), bytes.length],\n        });\n    }\n\n    return transformDecoder(getBaseXResliceDecoder(alphabet, 6), (value: string): string =>\n        value.padEnd(Math.ceil(value.length / 4) * 4, '='),\n    );\n};\n\n/** Encodes and decodes strings in base64. */\nexport const getBase64Codec = (): VariableSizeCodec<string> => combineCodec(getBase64Encoder(), getBase64Decoder());\n","/**Removes null characters from a string. */\nexport const removeNullCharacters = (value: string) =>\n    // eslint-disable-next-line no-control-regex\n    value.replace(/\\u0000/g, '');\n\n/** Pads a string with null characters at the end. */\nexport const padNullCharacters = (value: string, chars: number) => value.padEnd(chars, '\\u0000');\n","export const TextDecoder = globalThis.TextDecoder;\nexport const TextEncoder = globalThis.TextEncoder;\n","import {\n    combineCodec,\n    createDecoder,\n    createEncoder,\n    VariableSizeCodec,\n    VariableSizeDecoder,\n    VariableSizeEncoder,\n} from '@solana/codecs-core';\nimport { TextDecoder, TextEncoder } from '@solana/text-encoding-impl';\n\nimport { removeNullCharacters } from './null-characters';\n\n/** Encodes UTF-8 strings using the native `TextEncoder` API. */\nexport const getUtf8Encoder = (): VariableSizeEncoder<string> => {\n    let textEncoder: TextEncoder;\n    return createEncoder({\n        getSizeFromValue: value => (textEncoder ||= new TextEncoder()).encode(value).length,\n        write: (value: string, bytes, offset) => {\n            const bytesToAdd = (textEncoder ||= new TextEncoder()).encode(value);\n            bytes.set(bytesToAdd, offset);\n            return offset + bytesToAdd.length;\n        },\n    });\n};\n\n/** Decodes UTF-8 strings using the native `TextDecoder` API. */\nexport const getUtf8Decoder = (): VariableSizeDecoder<string> => {\n    let textDecoder: TextDecoder;\n    return createDecoder({\n        read(bytes, offset) {\n            const value = (textDecoder ||= new TextDecoder()).decode(bytes.slice(offset));\n            return [removeNullCharacters(value), bytes.length];\n        },\n    });\n};\n\n/** Encodes and decodes UTF-8 strings using the native `TextEncoder` and `TextDecoder` API. */\nexport const getUtf8Codec = (): VariableSizeCodec<string> => combineCodec(getUtf8Encoder(), getUtf8Decoder());\n"]}