@yume-chan/adb 0.0.18 → 0.0.20

package/esm/utils/auto-reset-event.d.ts

@@ -1,10 +1,9 @@
-import { type Disposable } from "@yume-chan/event";
-export declare class AutoResetEvent implements Disposable {
-    private readonly list;
-    private blocking;
-    constructor(initialSet?: boolean);
-    wait(): Promise<void>;
-    notify(): void;
-    dispose(): void;
-}
+import type { Disposable } from "@yume-chan/event";
+export declare class AutoResetEvent implements Disposable {
+    #private;
+    constructor(initialSet?: boolean);
+    wait(): Promise<void>;
+    notifyOne(): void;
+    dispose(): void;
+}
 //# sourceMappingURL=auto-reset-event.d.ts.map

package/esm/utils/auto-reset-event.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auto-reset-event.d.ts","sourceRoot":"","sources":["../../src/utils/auto-reset-event.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,qBAAa,cAAe,YAAW,UAAU;IAC7C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA+B;IAEpD,OAAO,CAAC,QAAQ,CAAU;gBAEP,UAAU,UAAQ;IAI9B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAcrB,MAAM;IAQN,OAAO;CAMjB"}
+{"version":3,"file":"auto-reset-event.d.ts","sourceRoot":"","sources":["../../src/utils/auto-reset-event.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,qBAAa,cAAe,YAAW,UAAU;;gBAI1B,UAAU,UAAQ;IAI9B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAcrB,SAAS;IAQT,OAAO;CAMjB"}

package/esm/utils/auto-reset-event.js

@@ -1,34 +1,34 @@
-import { PromiseResolver } from "@yume-chan/async";
-export class AutoResetEvent {
-    list = [];
-    blocking;
-    constructor(initialSet = false) {
-        this.blocking = initialSet;
-    }
-    wait() {
-        if (!this.blocking) {
-            this.blocking = true;
-            if (this.list.length === 0) {
-                return Promise.resolve();
-            }
-        }
-        const resolver = new PromiseResolver();
-        this.list.push(resolver);
-        return resolver.promise;
-    }
-    notify() {
-        if (this.list.length !== 0) {
-            this.list.pop().resolve();
-        }
-        else {
-            this.blocking = false;
-        }
-    }
-    dispose() {
-        for (const item of this.list) {
-            item.reject(new Error("The AutoResetEvent has been disposed"));
-        }
-        this.list.length = 0;
-    }
-}
+import { PromiseResolver } from "@yume-chan/async";
+export class AutoResetEvent {
+    #set;
+    #queue = [];
+    constructor(initialSet = false) {
+        this.#set = initialSet;
+    }
+    wait() {
+        if (!this.#set) {
+            this.#set = true;
+            if (this.#queue.length === 0) {
+                return Promise.resolve();
+            }
+        }
+        const resolver = new PromiseResolver();
+        this.#queue.push(resolver);
+        return resolver.promise;
+    }
+    notifyOne() {
+        if (this.#queue.length !== 0) {
+            this.#queue.pop().resolve();
+        }
+        else {
+            this.#set = false;
+        }
+    }
+    dispose() {
+        for (const item of this.#queue) {
+            item.reject(new Error("The AutoResetEvent has been disposed"));
+        }
+        this.#queue.length = 0;
+    }
+}
 //# sourceMappingURL=auto-reset-event.js.map

package/esm/utils/auto-reset-event.js.map

@@ -1 +1 @@
-{"version":3,"file":"auto-reset-event.js","sourceRoot":"","sources":["../../src/utils/auto-reset-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGnD,MAAM,OAAO,cAAc;IACN,IAAI,GAA4B,EAAE,CAAC;IAE5C,QAAQ,CAAU;IAE1B,YAAmB,UAAU,GAAG,KAAK;QACjC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;IAC/B,CAAC;IAEM,IAAI;QACP,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAChB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YAErB,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;gBACxB,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;aAC5B;SACJ;QAED,MAAM,QAAQ,GAAG,IAAI,eAAe,EAAQ,CAAC;QAC7C,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACzB,OAAO,QAAQ,CAAC,OAAO,CAAC;IAC5B,CAAC;IAEM,MAAM;QACT,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;YACxB,IAAI,CAAC,IAAI,CAAC,GAAG,EAAG,CAAC,OAAO,EAAE,CAAC;SAC9B;aAAM;YACH,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;SACzB;IACL,CAAC;IAEM,OAAO;QACV,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE;YAC1B,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC,CAAC;SAClE;QACD,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;IACzB,CAAC;CACJ"}
+{"version":3,"file":"auto-reset-event.js","sourceRoot":"","sources":["../../src/utils/auto-reset-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGnD,MAAM,OAAO,cAAc;IACvB,IAAI,CAAU;IACL,MAAM,GAA4B,EAAE,CAAC;IAE9C,YAAmB,UAAU,GAAG,KAAK;QACjC,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC;IAC3B,CAAC;IAEM,IAAI;QACP,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;YACZ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;YAEjB,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;gBAC1B,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;aAC5B;SACJ;QAED,MAAM,QAAQ,GAAG,IAAI,eAAe,EAAQ,CAAC;QAC7C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC3B,OAAO,QAAQ,CAAC,OAAO,CAAC;IAC5B,CAAC;IAEM,SAAS;QACZ,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;YAC1B,IAAI,CAAC,MAAM,CAAC,GAAG,EAAG,CAAC,OAAO,EAAE,CAAC;SAChC;aAAM;YACH,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;SACrB;IACL,CAAC;IAEM,OAAO;QACV,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,MAAM,EAAE;YAC5B,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC,CAAC;SAClE;QACD,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IAC3B,CAAC;CACJ"}

package/esm/utils/base64.d.ts

@@ -1,28 +1,28 @@
-/**
- * Calculate the required length of the output buffer for the given input length.
- *
- * @param inputLength Length of the input in bytes
- * @returns Length of the output in bytes
- */
-export declare function calculateBase64EncodedLength(inputLength: number): [outputLength: number, paddingLength: number];
-/**
- * Encode the given input buffer into base64.
- *
- * @param input The input buffer
- * @returns The encoded output buffer
- */
-export declare function encodeBase64(input: Uint8Array): Uint8Array;
-/**
- * Encode the given input into base64 and write it to the output buffer.
- *
- * The output buffer must be at least as long as the value returned by `calculateBase64EncodedLength`.
- * It can points to the same buffer as the input, as long as `output.offset <= input.offset - input.length / 3`,
- * or `output.offset >= input.offset - 1`
- *
- * @param input The input buffer
- * @param output The output buffer
- * @returns The number of bytes written to the output buffer
- */
-export declare function encodeBase64(input: Uint8Array, output: Uint8Array): number;
-export declare function decodeBase64(input: string): Uint8Array;
+/**
+ * Calculate the required length of the output buffer for the given input length.
+ *
+ * @param inputLength Length of the input in bytes
+ * @returns Length of the output in bytes
+ */
+export declare function calculateBase64EncodedLength(inputLength: number): [outputLength: number, paddingLength: number];
+/**
+ * Encode the given input buffer into base64.
+ *
+ * @param input The input buffer
+ * @returns The encoded output buffer
+ */
+export declare function encodeBase64(input: Uint8Array): Uint8Array;
+/**
+ * Encode the given input into base64 and write it to the output buffer.
+ *
+ * The output buffer must be at least as long as the value returned by `calculateBase64EncodedLength`.
+ * It can points to the same buffer as the input, as long as `output.offset <= input.offset - input.length / 3`,
+ * or `output.offset >= input.offset - 1`
+ *
+ * @param input The input buffer
+ * @param output The output buffer
+ * @returns The number of bytes written to the output buffer
+ */
+export declare function encodeBase64(input: Uint8Array, output: Uint8Array): number;
+export declare function decodeBase64(input: string): Uint8Array;
 //# sourceMappingURL=base64.d.ts.map

package/esm/utils/base64.js

@@ -1,247 +1,247 @@
-// Array is faster than object literal or `Map`
-const charToIndex = [];
-const indexToChar = [];
-const paddingChar = "=".charCodeAt(0);
-function addRange(start, end) {
-    const charCodeStart = start.charCodeAt(0);
-    const charCodeEnd = end.charCodeAt(0);
-    for (let charCode = charCodeStart; charCode <= charCodeEnd; charCode += 1) {
-        charToIndex[charCode] = indexToChar.length;
-        indexToChar.push(charCode);
-    }
-}
-addRange("A", "Z");
-addRange("a", "z");
-addRange("0", "9");
-addRange("+", "+");
-addRange("/", "/");
-/**
- * Calculate the required length of the output buffer for the given input length.
- *
- * @param inputLength Length of the input in bytes
- * @returns Length of the output in bytes
- */
-export function calculateBase64EncodedLength(inputLength) {
-    const remainder = inputLength % 3;
-    const paddingLength = remainder !== 0 ? 3 - remainder : 0;
-    return [((inputLength + paddingLength) / 3) * 4, paddingLength];
-}
-export function encodeBase64(input, output) {
-    const [outputLength, paddingLength] = calculateBase64EncodedLength(input.length);
-    if (!output) {
-        output = new Uint8Array(outputLength);
-        encodeForward(input, output, paddingLength);
-        return output;
-    }
-    else {
-        if (output.length < outputLength) {
-            throw new Error("output buffer is too small");
-        }
-        output = output.subarray(0, outputLength);
-        // When input and output are on same ArrayBuffer,
-        // we check if it's possible to encode in-place.
-        if (input.buffer !== output.buffer) {
-            encodeForward(input, output, paddingLength);
-        }
-        else if (output.byteOffset + output.length - (paddingLength + 1) <=
-            input.byteOffset + input.length) {
-            // Output ends before input ends
-            // So output won't catch up with input.
-            // Depends on padding length,
-            // it's possible to write 1-3 bytes after input ends.
-            // spell: disable-next-line
-            // | aaaaaabb |          |          |          |
-            // |  aaaaaa  |  bb0000  |    =     |    =     |
-            //
-            // spell: disable-next-line
-            // | aaaaaabb | bbbbcccc |          |          |
-            // |  aaaaaa  |  bbbbbb  |  cccc00  |    =     |
-            //
-            // spell: disable-next-line
-            // | aaaaaabb | bbbbcccc | ccdddddd |          |
-            // |  aaaaaa  |  bbbbbb  |  cccccc  |  dddddd  |
-            // Must encode forwards.
-            encodeForward(input, output, paddingLength);
-        }
-        else if (output.byteOffset >= input.byteOffset - 1) {
-            // Output starts after input starts
-            // So in backwards, output can't catch up with input.
-            // Because first 3 bytes becomes 4 bytes,
-            // it's possible to write 1 byte before input starts.
-            // spell: disable-next-line
-            // |          | aaaaaabb | bbbbcccc | ccdddddd |
-            // |  aaaaaa  |  bbbbbb  |  cccccc  |  dddddd  |
-            // Must encode backwards.
-            encodeBackward(input, output, paddingLength);
-        }
-        else {
-            // Input is in the middle of output,
-            // not possible to read neither first or last three bytes,
-            throw new Error("input and output cannot overlap");
-        }
-        return outputLength;
-    }
-}
-function encodeForward(input, output, paddingLength) {
-    let inputIndex = 0;
-    let outputIndex = 0;
-    while (inputIndex < input.length - 2) {
-        /* cspell: disable-next-line */
-        // aaaaaabb
-        const x = input[inputIndex];
-        inputIndex += 1;
-        /* cspell: disable-next-line */
-        // bbbbcccc
-        const y = input[inputIndex];
-        inputIndex += 1;
-        /* cspell: disable-next-line */
-        // ccdddddd
-        const z = input[inputIndex];
-        inputIndex += 1;
-        output[outputIndex] = indexToChar[x >> 2];
-        outputIndex += 1;
-        output[outputIndex] = indexToChar[((x & 0b11) << 4) | (y >> 4)];
-        outputIndex += 1;
-        output[outputIndex] = indexToChar[((y & 0b1111) << 2) | (z >> 6)];
-        outputIndex += 1;
-        output[outputIndex] = indexToChar[z & 0b111111];
-        outputIndex += 1;
-    }
-    if (paddingLength === 2) {
-        /* cspell: disable-next-line */
-        // aaaaaabb
-        const x = input[inputIndex];
-        inputIndex += 1;
-        output[outputIndex] = indexToChar[x >> 2];
-        outputIndex += 1;
-        output[outputIndex] = indexToChar[(x & 0b11) << 4];
-        outputIndex += 1;
-        output[outputIndex] = paddingChar;
-        outputIndex += 1;
-        output[outputIndex] = paddingChar;
-    }
-    else if (paddingLength === 1) {
-        /* cspell: disable-next-line */
-        // aaaaaabb
-        const x = input[inputIndex];
-        inputIndex += 1;
-        /* cspell: disable-next-line */
-        // bbbbcccc
-        const y = input[inputIndex];
-        inputIndex += 1;
-        output[outputIndex] = indexToChar[x >> 2];
-        outputIndex += 1;
-        output[outputIndex] = indexToChar[((x & 0b11) << 4) | (y >> 4)];
-        outputIndex += 1;
-        output[outputIndex] = indexToChar[(y & 0b1111) << 2];
-        outputIndex += 1;
-        output[outputIndex] = paddingChar;
-    }
-}
-function encodeBackward(input, output, paddingLength) {
-    let inputIndex = input.length - 1;
-    let outputIndex = output.length - 1;
-    if (paddingLength === 2) {
-        /* cspell: disable-next-line */
-        // aaaaaabb
-        const x = input[inputIndex];
-        inputIndex -= 1;
-        output[outputIndex] = paddingChar;
-        outputIndex -= 1;
-        output[outputIndex] = paddingChar;
-        outputIndex -= 1;
-        output[outputIndex] = indexToChar[(x & 0b11) << 4];
-        outputIndex -= 1;
-        output[outputIndex] = indexToChar[x >> 2];
-        outputIndex -= 1;
-    }
-    else if (paddingLength === 1) {
-        /* cspell: disable-next-line */
-        // bbbbcccc
-        const y = input[inputIndex];
-        inputIndex -= 1;
-        /* cspell: disable-next-line */
-        // aaaaaabb
-        const x = input[inputIndex];
-        inputIndex -= 1;
-        output[outputIndex] = paddingChar;
-        outputIndex -= 1;
-        output[outputIndex] = indexToChar[(y & 0b1111) << 2];
-        outputIndex -= 1;
-        output[outputIndex] = indexToChar[((x & 0b11) << 4) | (y >> 4)];
-        outputIndex -= 1;
-        output[outputIndex] = indexToChar[x >> 2];
-        outputIndex -= 1;
-    }
-    while (inputIndex >= 0) {
-        /* cspell: disable-next-line */
-        // ccdddddd
-        const z = input[inputIndex];
-        inputIndex -= 1;
-        /* cspell: disable-next-line */
-        // bbbbcccc
-        const y = input[inputIndex];
-        inputIndex -= 1;
-        /* cspell: disable-next-line */
-        // aaaaaabb
-        const x = input[inputIndex];
-        inputIndex -= 1;
-        output[outputIndex] = indexToChar[z & 0b111111];
-        outputIndex -= 1;
-        output[outputIndex] = indexToChar[((y & 0b1111) << 2) | (z >> 6)];
-        outputIndex -= 1;
-        output[outputIndex] = indexToChar[((x & 0b11) << 4) | (y >> 4)];
-        outputIndex -= 1;
-        output[outputIndex] = indexToChar[x >> 2];
-        outputIndex -= 1;
-    }
-}
-export function decodeBase64(input) {
-    let padding;
-    if (input[input.length - 2] === "=") {
-        padding = 2;
-    }
-    else if (input[input.length - 1] === "=") {
-        padding = 1;
-    }
-    else {
-        padding = 0;
-    }
-    const result = new Uint8Array((input.length / 4) * 3 - padding);
-    let sIndex = 0;
-    let dIndex = 0;
-    while (sIndex < input.length - (padding !== 0 ? 4 : 0)) {
-        const a = charToIndex[input.charCodeAt(sIndex)];
-        sIndex += 1;
-        const b = charToIndex[input.charCodeAt(sIndex)];
-        sIndex += 1;
-        const c = charToIndex[input.charCodeAt(sIndex)];
-        sIndex += 1;
-        const d = charToIndex[input.charCodeAt(sIndex)];
-        sIndex += 1;
-        result[dIndex] = (a << 2) | ((b & 48) >> 4);
-        dIndex += 1;
-        result[dIndex] = ((b & 0b1111) << 4) | ((c & 60) >> 2);
-        dIndex += 1;
-        result[dIndex] = ((c & 0b11) << 6) | d;
-        dIndex += 1;
-    }
-    if (padding === 1) {
-        const a = charToIndex[input.charCodeAt(sIndex)];
-        sIndex += 1;
-        const b = charToIndex[input.charCodeAt(sIndex)];
-        sIndex += 1;
-        const c = charToIndex[input.charCodeAt(sIndex)];
-        result[dIndex] = (a << 2) | ((b & 48) >> 4);
-        dIndex += 1;
-        result[dIndex] = ((b & 0b1111) << 4) | ((c & 60) >> 2);
-    }
-    else if (padding === 2) {
-        const a = charToIndex[input.charCodeAt(sIndex)];
-        sIndex += 1;
-        const b = charToIndex[input.charCodeAt(sIndex)];
-        result[dIndex] = (a << 2) | ((b & 48) >> 4);
-    }
-    return result;
-}
+// Array is faster than object literal or `Map`
+const charToIndex = [];
+const indexToChar = [];
+const paddingChar = "=".charCodeAt(0);
+function addRange(start, end) {
+    const charCodeStart = start.charCodeAt(0);
+    const charCodeEnd = end.charCodeAt(0);
+    for (let charCode = charCodeStart; charCode <= charCodeEnd; charCode += 1) {
+        charToIndex[charCode] = indexToChar.length;
+        indexToChar.push(charCode);
+    }
+}
+addRange("A", "Z");
+addRange("a", "z");
+addRange("0", "9");
+addRange("+", "+");
+addRange("/", "/");
+/**
+ * Calculate the required length of the output buffer for the given input length.
+ *
+ * @param inputLength Length of the input in bytes
+ * @returns Length of the output in bytes
+ */
+export function calculateBase64EncodedLength(inputLength) {
+    const remainder = inputLength % 3;
+    const paddingLength = remainder !== 0 ? 3 - remainder : 0;
+    return [((inputLength + paddingLength) / 3) * 4, paddingLength];
+}
+export function encodeBase64(input, output) {
+    const [outputLength, paddingLength] = calculateBase64EncodedLength(input.length);
+    if (!output) {
+        output = new Uint8Array(outputLength);
+        encodeForward(input, output, paddingLength);
+        return output;
+    }
+    else {
+        if (output.length < outputLength) {
+            throw new Error("output buffer is too small");
+        }
+        output = output.subarray(0, outputLength);
+        // When input and output are on same ArrayBuffer,
+        // we check if it's possible to encode in-place.
+        if (input.buffer !== output.buffer) {
+            encodeForward(input, output, paddingLength);
+        }
+        else if (output.byteOffset + output.length - (paddingLength + 1) <=
+            input.byteOffset + input.length) {
+            // Output ends before input ends
+            // So output won't catch up with input.
+            // Depends on padding length,
+            // it's possible to write 1-3 bytes after input ends.
+            // spell: disable-next-line
+            // | aaaaaabb |          |          |          |
+            // |  aaaaaa  |  bb0000  |    =     |    =     |
+            //
+            // spell: disable-next-line
+            // | aaaaaabb | bbbbcccc |          |          |
+            // |  aaaaaa  |  bbbbbb  |  cccc00  |    =     |
+            //
+            // spell: disable-next-line
+            // | aaaaaabb | bbbbcccc | ccdddddd |          |
+            // |  aaaaaa  |  bbbbbb  |  cccccc  |  dddddd  |
+            // Must encode forwards.
+            encodeForward(input, output, paddingLength);
+        }
+        else if (output.byteOffset >= input.byteOffset - 1) {
+            // Output starts after input starts
+            // So in backwards, output can't catch up with input.
+            // Because first 3 bytes becomes 4 bytes,
+            // it's possible to write 1 byte before input starts.
+            // spell: disable-next-line
+            // |          | aaaaaabb | bbbbcccc | ccdddddd |
+            // |  aaaaaa  |  bbbbbb  |  cccccc  |  dddddd  |
+            // Must encode backwards.
+            encodeBackward(input, output, paddingLength);
+        }
+        else {
+            // Input is in the middle of output,
+            // not possible to read neither first or last three bytes,
+            throw new Error("input and output cannot overlap");
+        }
+        return outputLength;
+    }
+}
+function encodeForward(input, output, paddingLength) {
+    let inputIndex = 0;
+    let outputIndex = 0;
+    while (inputIndex < input.length - 2) {
+        /* cspell: disable-next-line */
+        // aaaaaabb
+        const x = input[inputIndex];
+        inputIndex += 1;
+        /* cspell: disable-next-line */
+        // bbbbcccc
+        const y = input[inputIndex];
+        inputIndex += 1;
+        /* cspell: disable-next-line */
+        // ccdddddd
+        const z = input[inputIndex];
+        inputIndex += 1;
+        output[outputIndex] = indexToChar[x >> 2];
+        outputIndex += 1;
+        output[outputIndex] = indexToChar[((x & 0b11) << 4) | (y >> 4)];
+        outputIndex += 1;
+        output[outputIndex] = indexToChar[((y & 0b1111) << 2) | (z >> 6)];
+        outputIndex += 1;
+        output[outputIndex] = indexToChar[z & 0b111111];
+        outputIndex += 1;
+    }
+    if (paddingLength === 2) {
+        /* cspell: disable-next-line */
+        // aaaaaabb
+        const x = input[inputIndex];
+        inputIndex += 1;
+        output[outputIndex] = indexToChar[x >> 2];
+        outputIndex += 1;
+        output[outputIndex] = indexToChar[(x & 0b11) << 4];
+        outputIndex += 1;
+        output[outputIndex] = paddingChar;
+        outputIndex += 1;
+        output[outputIndex] = paddingChar;
+    }
+    else if (paddingLength === 1) {
+        /* cspell: disable-next-line */
+        // aaaaaabb
+        const x = input[inputIndex];
+        inputIndex += 1;
+        /* cspell: disable-next-line */
+        // bbbbcccc
+        const y = input[inputIndex];
+        inputIndex += 1;
+        output[outputIndex] = indexToChar[x >> 2];
+        outputIndex += 1;
+        output[outputIndex] = indexToChar[((x & 0b11) << 4) | (y >> 4)];
+        outputIndex += 1;
+        output[outputIndex] = indexToChar[(y & 0b1111) << 2];
+        outputIndex += 1;
+        output[outputIndex] = paddingChar;
+    }
+}
+function encodeBackward(input, output, paddingLength) {
+    let inputIndex = input.length - 1;
+    let outputIndex = output.length - 1;
+    if (paddingLength === 2) {
+        /* cspell: disable-next-line */
+        // aaaaaabb
+        const x = input[inputIndex];
+        inputIndex -= 1;
+        output[outputIndex] = paddingChar;
+        outputIndex -= 1;
+        output[outputIndex] = paddingChar;
+        outputIndex -= 1;
+        output[outputIndex] = indexToChar[(x & 0b11) << 4];
+        outputIndex -= 1;
+        output[outputIndex] = indexToChar[x >> 2];
+        outputIndex -= 1;
+    }
+    else if (paddingLength === 1) {
+        /* cspell: disable-next-line */
+        // bbbbcccc
+        const y = input[inputIndex];
+        inputIndex -= 1;
+        /* cspell: disable-next-line */
+        // aaaaaabb
+        const x = input[inputIndex];
+        inputIndex -= 1;
+        output[outputIndex] = paddingChar;
+        outputIndex -= 1;
+        output[outputIndex] = indexToChar[(y & 0b1111) << 2];
+        outputIndex -= 1;
+        output[outputIndex] = indexToChar[((x & 0b11) << 4) | (y >> 4)];
+        outputIndex -= 1;
+        output[outputIndex] = indexToChar[x >> 2];
+        outputIndex -= 1;
+    }
+    while (inputIndex >= 0) {
+        /* cspell: disable-next-line */
+        // ccdddddd
+        const z = input[inputIndex];
+        inputIndex -= 1;
+        /* cspell: disable-next-line */
+        // bbbbcccc
+        const y = input[inputIndex];
+        inputIndex -= 1;
+        /* cspell: disable-next-line */
+        // aaaaaabb
+        const x = input[inputIndex];
+        inputIndex -= 1;
+        output[outputIndex] = indexToChar[z & 0b111111];
+        outputIndex -= 1;
+        output[outputIndex] = indexToChar[((y & 0b1111) << 2) | (z >> 6)];
+        outputIndex -= 1;
+        output[outputIndex] = indexToChar[((x & 0b11) << 4) | (y >> 4)];
+        outputIndex -= 1;
+        output[outputIndex] = indexToChar[x >> 2];
+        outputIndex -= 1;
+    }
+}
+export function decodeBase64(input) {
+    let padding;
+    if (input[input.length - 2] === "=") {
+        padding = 2;
+    }
+    else if (input[input.length - 1] === "=") {
+        padding = 1;
+    }
+    else {
+        padding = 0;
+    }
+    const result = new Uint8Array((input.length / 4) * 3 - padding);
+    let sIndex = 0;
+    let dIndex = 0;
+    while (sIndex < input.length - (padding !== 0 ? 4 : 0)) {
+        const a = charToIndex[input.charCodeAt(sIndex)];
+        sIndex += 1;
+        const b = charToIndex[input.charCodeAt(sIndex)];
+        sIndex += 1;
+        const c = charToIndex[input.charCodeAt(sIndex)];
+        sIndex += 1;
+        const d = charToIndex[input.charCodeAt(sIndex)];
+        sIndex += 1;
+        result[dIndex] = (a << 2) | ((b & 0b11_0000) >> 4);
+        dIndex += 1;
+        result[dIndex] = ((b & 0b1111) << 4) | ((c & 0b11_1100) >> 2);
+        dIndex += 1;
+        result[dIndex] = ((c & 0b11) << 6) | d;
+        dIndex += 1;
+    }
+    if (padding === 1) {
+        const a = charToIndex[input.charCodeAt(sIndex)];
+        sIndex += 1;
+        const b = charToIndex[input.charCodeAt(sIndex)];
+        sIndex += 1;
+        const c = charToIndex[input.charCodeAt(sIndex)];
+        result[dIndex] = (a << 2) | ((b & 0b11_0000) >> 4);
+        dIndex += 1;
+        result[dIndex] = ((b & 0b1111) << 4) | ((c & 0b11_1100) >> 2);
+    }
+    else if (padding === 2) {
+        const a = charToIndex[input.charCodeAt(sIndex)];
+        sIndex += 1;
+        const b = charToIndex[input.charCodeAt(sIndex)];
+        result[dIndex] = (a << 2) | ((b & 0b11_0000) >> 4);
+    }
+    return result;
+}
 //# sourceMappingURL=base64.js.map