Refactor routing in App component to enhance navigation and improve error handling by integrating dynamic routes and updating the NotFound route.

node_modules/@oslojs/encoding/dist/base32.d.ts

@@ -0,0 +1,10 @@
+export declare function encodeBase32UpperCase(bytes: Uint8Array): string;
+export declare function encodeBase32UpperCaseNoPadding(bytes: Uint8Array): string;
+export declare function encodeBase32LowerCase(bytes: Uint8Array): string;
+export declare function encodeBase32LowerCaseNoPadding(bytes: Uint8Array): string;
+/** Replaced: Use encodeBase32UpperCase() instead. */
+export declare function encodeBase32(bytes: Uint8Array): string;
+/** Replaced: Use encodeBase32UpperCaseNoPadding() instead. */
+export declare function encodeBase32NoPadding(bytes: Uint8Array): string;
+export declare function decodeBase32(encoded: string): Uint8Array;
+export declare function decodeBase32IgnorePadding(encoded: string): Uint8Array;

node_modules/@oslojs/encoding/dist/base32.js

@@ -0,0 +1,185 @@
+export function encodeBase32UpperCase(bytes) {
+    return encodeBase32_internal(bytes, base32UpperCaseAlphabet, EncodingPadding.Include);
+}
+export function encodeBase32UpperCaseNoPadding(bytes) {
+    return encodeBase32_internal(bytes, base32UpperCaseAlphabet, EncodingPadding.None);
+}
+export function encodeBase32LowerCase(bytes) {
+    return encodeBase32_internal(bytes, base32LowerCaseAlphabet, EncodingPadding.Include);
+}
+export function encodeBase32LowerCaseNoPadding(bytes) {
+    return encodeBase32_internal(bytes, base32LowerCaseAlphabet, EncodingPadding.None);
+}
+/** Replaced: Use encodeBase32UpperCase() instead. */
+export function encodeBase32(bytes) {
+    return encodeBase32UpperCase(bytes);
+}
+/** Replaced: Use encodeBase32UpperCaseNoPadding() instead. */
+export function encodeBase32NoPadding(bytes) {
+    return encodeBase32UpperCaseNoPadding(bytes);
+}
+function encodeBase32_internal(bytes, alphabet, padding) {
+    let result = "";
+    for (let i = 0; i < bytes.byteLength; i += 5) {
+        let buffer = 0n;
+        let bufferBitSize = 0;
+        for (let j = 0; j < 5 && i + j < bytes.byteLength; j++) {
+            buffer = (buffer << 8n) | BigInt(bytes[i + j]);
+            bufferBitSize += 8;
+        }
+        if (bufferBitSize % 5 !== 0) {
+            buffer = buffer << BigInt(5 - (bufferBitSize % 5));
+            bufferBitSize += 5 - (bufferBitSize % 5);
+        }
+        for (let j = 0; j < 8; j++) {
+            if (bufferBitSize >= 5) {
+                result += alphabet[Number((buffer >> BigInt(bufferBitSize - 5)) & 0x1fn)];
+                bufferBitSize -= 5;
+            }
+            else if (bufferBitSize > 0) {
+                result += alphabet[Number((buffer << BigInt(6 - bufferBitSize)) & 0x3fn)];
+                bufferBitSize = 0;
+            }
+            else if (padding === EncodingPadding.Include) {
+                result += "=";
+            }
+        }
+    }
+    return result;
+}
+export function decodeBase32(encoded) {
+    return decodeBase32_internal(encoded, base32DecodeMap, DecodingPadding.Required);
+}
+export function decodeBase32IgnorePadding(encoded) {
+    return decodeBase32_internal(encoded, base32DecodeMap, DecodingPadding.Ignore);
+}
+function decodeBase32_internal(encoded, decodeMap, padding) {
+    const result = new Uint8Array(Math.ceil(encoded.length / 8) * 5);
+    let totalBytes = 0;
+    for (let i = 0; i < encoded.length; i += 8) {
+        let chunk = 0n;
+        let bitsRead = 0;
+        for (let j = 0; j < 8; j++) {
+            if (padding === DecodingPadding.Required) {
+                if (encoded[i + j] === "=") {
+                    continue;
+                }
+                if (i + j >= encoded.length) {
+                    throw new Error("Invalid padding");
+                }
+            }
+            if (padding === DecodingPadding.Ignore) {
+                if (i + j >= encoded.length || encoded[i + j] === "=") {
+                    continue;
+                }
+            }
+            if (j > 0 && encoded[i + j - 1] === "=") {
+                throw new Error("Invalid padding");
+            }
+            if (!(encoded[i + j] in decodeMap)) {
+                throw new Error("Invalid character");
+            }
+            chunk |= BigInt(decodeMap[encoded[i + j]]) << BigInt((7 - j) * 5);
+            bitsRead += 5;
+        }
+        if (bitsRead < 40) {
+            let unused;
+            if (bitsRead === 10) {
+                unused = chunk & 0xffffffffn;
+            }
+            else if (bitsRead === 20) {
+                unused = chunk & 0xffffffn;
+            }
+            else if (bitsRead === 25) {
+                unused = chunk & 0xffffn;
+            }
+            else if (bitsRead === 35) {
+                unused = chunk & 0xffn;
+            }
+            else {
+                throw new Error("Invalid padding");
+            }
+            if (unused !== 0n) {
+                throw new Error("Invalid padding");
+            }
+        }
+        const byteLength = Math.floor(bitsRead / 8);
+        for (let i = 0; i < byteLength; i++) {
+            result[totalBytes] = Number((chunk >> BigInt(32 - i * 8)) & 0xffn);
+            totalBytes++;
+        }
+    }
+    return result.slice(0, totalBytes);
+}
+const base32UpperCaseAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+const base32LowerCaseAlphabet = "abcdefghijklmnopqrstuvwxyz234567";
+const base32DecodeMap = {
+    A: 0,
+    B: 1,
+    C: 2,
+    D: 3,
+    E: 4,
+    F: 5,
+    G: 6,
+    H: 7,
+    I: 8,
+    J: 9,
+    K: 10,
+    L: 11,
+    M: 12,
+    N: 13,
+    O: 14,
+    P: 15,
+    Q: 16,
+    R: 17,
+    S: 18,
+    T: 19,
+    U: 20,
+    V: 21,
+    W: 22,
+    X: 23,
+    Y: 24,
+    Z: 25,
+    a: 0,
+    b: 1,
+    c: 2,
+    d: 3,
+    e: 4,
+    f: 5,
+    g: 6,
+    h: 7,
+    i: 8,
+    j: 9,
+    k: 10,
+    l: 11,
+    m: 12,
+    n: 13,
+    o: 14,
+    p: 15,
+    q: 16,
+    r: 17,
+    s: 18,
+    t: 19,
+    u: 20,
+    v: 21,
+    w: 22,
+    x: 23,
+    y: 24,
+    z: 25,
+    "2": 26,
+    "3": 27,
+    "4": 28,
+    "5": 29,
+    "6": 30,
+    "7": 31
+};
+var EncodingPadding;
+(function (EncodingPadding) {
+    EncodingPadding[EncodingPadding["Include"] = 0] = "Include";
+    EncodingPadding[EncodingPadding["None"] = 1] = "None";
+})(EncodingPadding || (EncodingPadding = {}));
+var DecodingPadding;
+(function (DecodingPadding) {
+    DecodingPadding[DecodingPadding["Required"] = 0] = "Required";
+    DecodingPadding[DecodingPadding["Ignore"] = 1] = "Ignore";
+})(DecodingPadding || (DecodingPadding = {}));

node_modules/@oslojs/encoding/dist/base64.d.ts

@@ -0,0 +1,8 @@
+export declare function encodeBase64(bytes: Uint8Array): string;
+export declare function encodeBase64NoPadding(bytes: Uint8Array): string;
+export declare function encodeBase64url(bytes: Uint8Array): string;
+export declare function encodeBase64urlNoPadding(bytes: Uint8Array): string;
+export declare function decodeBase64(encoded: string): Uint8Array;
+export declare function decodeBase64IgnorePadding(encoded: string): Uint8Array;
+export declare function decodeBase64url(encoded: string): Uint8Array;
+export declare function decodeBase64urlIgnorePadding(encoded: string): Uint8Array;

node_modules/@oslojs/encoding/dist/base64.js

@@ -0,0 +1,239 @@
+export function encodeBase64(bytes) {
+    return encodeBase64_internal(bytes, base64Alphabet, EncodingPadding.Include);
+}
+export function encodeBase64NoPadding(bytes) {
+    return encodeBase64_internal(bytes, base64Alphabet, EncodingPadding.None);
+}
+export function encodeBase64url(bytes) {
+    return encodeBase64_internal(bytes, base64urlAlphabet, EncodingPadding.Include);
+}
+export function encodeBase64urlNoPadding(bytes) {
+    return encodeBase64_internal(bytes, base64urlAlphabet, EncodingPadding.None);
+}
+function encodeBase64_internal(bytes, alphabet, padding) {
+    let result = "";
+    for (let i = 0; i < bytes.byteLength; i += 3) {
+        let buffer = 0;
+        let bufferBitSize = 0;
+        for (let j = 0; j < 3 && i + j < bytes.byteLength; j++) {
+            buffer = (buffer << 8) | bytes[i + j];
+            bufferBitSize += 8;
+        }
+        for (let j = 0; j < 4; j++) {
+            if (bufferBitSize >= 6) {
+                result += alphabet[(buffer >> (bufferBitSize - 6)) & 0x3f];
+                bufferBitSize -= 6;
+            }
+            else if (bufferBitSize > 0) {
+                result += alphabet[(buffer << (6 - bufferBitSize)) & 0x3f];
+                bufferBitSize = 0;
+            }
+            else if (padding === EncodingPadding.Include) {
+                result += "=";
+            }
+        }
+    }
+    return result;
+}
+const base64Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const base64urlAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+export function decodeBase64(encoded) {
+    return decodeBase64_internal(encoded, base64DecodeMap, DecodingPadding.Required);
+}
+export function decodeBase64IgnorePadding(encoded) {
+    return decodeBase64_internal(encoded, base64DecodeMap, DecodingPadding.Ignore);
+}
+export function decodeBase64url(encoded) {
+    return decodeBase64_internal(encoded, base64urlDecodeMap, DecodingPadding.Required);
+}
+export function decodeBase64urlIgnorePadding(encoded) {
+    return decodeBase64_internal(encoded, base64urlDecodeMap, DecodingPadding.Ignore);
+}
+function decodeBase64_internal(encoded, decodeMap, padding) {
+    const result = new Uint8Array(Math.ceil(encoded.length / 4) * 3);
+    let totalBytes = 0;
+    for (let i = 0; i < encoded.length; i += 4) {
+        let chunk = 0;
+        let bitsRead = 0;
+        for (let j = 0; j < 4; j++) {
+            if (padding === DecodingPadding.Required && encoded[i + j] === "=") {
+                continue;
+            }
+            if (padding === DecodingPadding.Ignore &&
+                (i + j >= encoded.length || encoded[i + j] === "=")) {
+                continue;
+            }
+            if (j > 0 && encoded[i + j - 1] === "=") {
+                throw new Error("Invalid padding");
+            }
+            if (!(encoded[i + j] in decodeMap)) {
+                throw new Error("Invalid character");
+            }
+            chunk |= decodeMap[encoded[i + j]] << ((3 - j) * 6);
+            bitsRead += 6;
+        }
+        if (bitsRead < 24) {
+            let unused;
+            if (bitsRead === 12) {
+                unused = chunk & 0xffff;
+            }
+            else if (bitsRead === 18) {
+                unused = chunk & 0xff;
+            }
+            else {
+                throw new Error("Invalid padding");
+            }
+            if (unused !== 0) {
+                throw new Error("Invalid padding");
+            }
+        }
+        const byteLength = Math.floor(bitsRead / 8);
+        for (let i = 0; i < byteLength; i++) {
+            result[totalBytes] = (chunk >> (16 - i * 8)) & 0xff;
+            totalBytes++;
+        }
+    }
+    return result.slice(0, totalBytes);
+}
+var EncodingPadding;
+(function (EncodingPadding) {
+    EncodingPadding[EncodingPadding["Include"] = 0] = "Include";
+    EncodingPadding[EncodingPadding["None"] = 1] = "None";
+})(EncodingPadding || (EncodingPadding = {}));
+var DecodingPadding;
+(function (DecodingPadding) {
+    DecodingPadding[DecodingPadding["Required"] = 0] = "Required";
+    DecodingPadding[DecodingPadding["Ignore"] = 1] = "Ignore";
+})(DecodingPadding || (DecodingPadding = {}));
+const base64DecodeMap = {
+    "0": 52,
+    "1": 53,
+    "2": 54,
+    "3": 55,
+    "4": 56,
+    "5": 57,
+    "6": 58,
+    "7": 59,
+    "8": 60,
+    "9": 61,
+    A: 0,
+    B: 1,
+    C: 2,
+    D: 3,
+    E: 4,
+    F: 5,
+    G: 6,
+    H: 7,
+    I: 8,
+    J: 9,
+    K: 10,
+    L: 11,
+    M: 12,
+    N: 13,
+    O: 14,
+    P: 15,
+    Q: 16,
+    R: 17,
+    S: 18,
+    T: 19,
+    U: 20,
+    V: 21,
+    W: 22,
+    X: 23,
+    Y: 24,
+    Z: 25,
+    a: 26,
+    b: 27,
+    c: 28,
+    d: 29,
+    e: 30,
+    f: 31,
+    g: 32,
+    h: 33,
+    i: 34,
+    j: 35,
+    k: 36,
+    l: 37,
+    m: 38,
+    n: 39,
+    o: 40,
+    p: 41,
+    q: 42,
+    r: 43,
+    s: 44,
+    t: 45,
+    u: 46,
+    v: 47,
+    w: 48,
+    x: 49,
+    y: 50,
+    z: 51,
+    "+": 62,
+    "/": 63
+};
+const base64urlDecodeMap = {
+    "0": 52,
+    "1": 53,
+    "2": 54,
+    "3": 55,
+    "4": 56,
+    "5": 57,
+    "6": 58,
+    "7": 59,
+    "8": 60,
+    "9": 61,
+    A: 0,
+    B: 1,
+    C: 2,
+    D: 3,
+    E: 4,
+    F: 5,
+    G: 6,
+    H: 7,
+    I: 8,
+    J: 9,
+    K: 10,
+    L: 11,
+    M: 12,
+    N: 13,
+    O: 14,
+    P: 15,
+    Q: 16,
+    R: 17,
+    S: 18,
+    T: 19,
+    U: 20,
+    V: 21,
+    W: 22,
+    X: 23,
+    Y: 24,
+    Z: 25,
+    a: 26,
+    b: 27,
+    c: 28,
+    d: 29,
+    e: 30,
+    f: 31,
+    g: 32,
+    h: 33,
+    i: 34,
+    j: 35,
+    k: 36,
+    l: 37,
+    m: 38,
+    n: 39,
+    o: 40,
+    p: 41,
+    q: 42,
+    r: 43,
+    s: 44,
+    t: 45,
+    u: 46,
+    v: 47,
+    w: 48,
+    x: 49,
+    y: 50,
+    z: 51,
+    "-": 62,
+    _: 63
+};

node_modules/@oslojs/encoding/dist/hex.d.ts

@@ -0,0 +1,3 @@
+export declare function encodeHexUpperCase(data: Uint8Array): string;
+export declare function encodeHexLowerCase(data: Uint8Array): string;
+export declare function decodeHex(data: string): Uint8Array;

node_modules/@oslojs/encoding/dist/hex.js

@@ -0,0 +1,59 @@
+export function encodeHexUpperCase(data) {
+    let result = "";
+    for (let i = 0; i < data.length; i++) {
+        result += alphabetUpperCase[data[i] >> 4];
+        result += alphabetUpperCase[data[i] & 0x0f];
+    }
+    return result;
+}
+export function encodeHexLowerCase(data) {
+    let result = "";
+    for (let i = 0; i < data.length; i++) {
+        result += alphabetLowerCase[data[i] >> 4];
+        result += alphabetLowerCase[data[i] & 0x0f];
+    }
+    return result;
+}
+export function decodeHex(data) {
+    if (data.length % 2 !== 0) {
+        throw new Error("Invalid hex string");
+    }
+    const result = new Uint8Array(data.length / 2);
+    for (let i = 0; i < data.length; i += 2) {
+        if (!(data[i] in decodeMap)) {
+            throw new Error("Invalid character");
+        }
+        if (!(data[i + 1] in decodeMap)) {
+            throw new Error("Invalid character");
+        }
+        result[i / 2] |= decodeMap[data[i]] << 4;
+        result[i / 2] |= decodeMap[data[i + 1]];
+    }
+    return result;
+}
+const alphabetUpperCase = "0123456789ABCDEF";
+const alphabetLowerCase = "0123456789abcdef";
+const decodeMap = {
+    "0": 0,
+    "1": 1,
+    "2": 2,
+    "3": 3,
+    "4": 4,
+    "5": 5,
+    "6": 6,
+    "7": 7,
+    "8": 8,
+    "9": 9,
+    a: 10,
+    A: 10,
+    b: 11,
+    B: 11,
+    c: 12,
+    C: 12,
+    d: 13,
+    D: 13,
+    e: 14,
+    E: 14,
+    f: 15,
+    F: 15
+};

node_modules/@oslojs/encoding/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { encodeHexLowerCase, encodeHexUpperCase, decodeHex } from "./hex.js";
+export { encodeBase32, encodeBase32NoPadding, encodeBase32LowerCase, encodeBase32LowerCaseNoPadding, encodeBase32UpperCase, encodeBase32UpperCaseNoPadding, decodeBase32, decodeBase32IgnorePadding } from "./base32.js";
+export { encodeBase64, encodeBase64NoPadding, encodeBase64url, encodeBase64urlNoPadding, decodeBase64, decodeBase64IgnorePadding, decodeBase64url, decodeBase64urlIgnorePadding } from "./base64.js";

node_modules/@oslojs/encoding/dist/index.js

@@ -0,0 +1,3 @@
+export { encodeHexLowerCase, encodeHexUpperCase, decodeHex } from "./hex.js";
+export { encodeBase32, encodeBase32NoPadding, encodeBase32LowerCase, encodeBase32LowerCaseNoPadding, encodeBase32UpperCase, encodeBase32UpperCaseNoPadding, decodeBase32, decodeBase32IgnorePadding } from "./base32.js";
+export { encodeBase64, encodeBase64NoPadding, encodeBase64url, encodeBase64urlNoPadding, decodeBase64, decodeBase64IgnorePadding, decodeBase64url, decodeBase64urlIgnorePadding } from "./base64.js";