Replace deprecated escape() with proper UTF-8 decoding using TextDecoder

The escape/unescape pattern works but uses deprecated methods. This replaces it with the modern TextDecoder API which properly handles UTF-8 multi-byte characters like emojis.

Why the deprecated pattern worked:
- atob() decodes base64 but treats bytes as Latin-1
- escape() percent-encodes the malformed string
- decodeURIComponent() interprets percent-encoded bytes as UTF-8

Modern solution:
- atob() decodes base64 to binary string
- Convert to Uint8Array byte array
- TextDecoder properly interprets bytes as UTF-8

Added comprehensive tests verifying both patterns give identical results.

Co-authored-by: dwjohnston <2467377+dwjohnston@users.noreply.github.com>

Author: Copilot

src/library/config/defaultFunctions.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from 'vitest';
+
+/**
+ * This is a copy of the helper function from defaultFunctions.ts for testing purposes.
+ */
+function decodeBase64WithUTF8(base64: string): string {
+    const cleanedBase64 = base64.replace(/\s/g, '');
+    const binaryString = atob(cleanedBase64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    const decoder = new TextDecoder('utf-8');
+    return decoder.decode(bytes);
+}
+
+describe('Base64 UTF-8 Decoding', () => {
+    it('should correctly decode base64 with ASCII text', () => {
+        // Simple ASCII text
+        const text = 'Hello World';
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(text);
+        const binaryString = String.fromCharCode(...bytes);
+        const base64 = btoa(binaryString);
+        
+        const result = decodeBase64WithUTF8(base64);
+        expect(result).toBe(text);
+    });
+
+    it('should correctly decode base64 with emoji', () => {
+        // Text with emoji - the actual issue from GitHub
+        const text = '// 👇 Check this out';
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(text);
+        const binaryString = String.fromCharCode(...bytes);
+        const base64 = btoa(binaryString);
+        
+        const result = decodeBase64WithUTF8(base64);
+        expect(result).toBe(text);
+        expect(result).toContain('👇');
+    });
+
+    it('should correctly decode base64 with pointing up emoji', () => {
+        // The specific emoji mentioned in the user's comment
+        const text = '☝️';
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(text);
+        const binaryString = String.fromCharCode(...bytes);
+        const base64 = btoa(binaryString);
+        
+        const result = decodeBase64WithUTF8(base64);
+        expect(result).toBe(text);
+    });
+
+    it('should correctly decode base64 with multiple emojis', () => {
+        const text = '👍 👎 😕 ❤️ 🎉';
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(text);
+        const binaryString = String.fromCharCode(...bytes);
+        const base64 = btoa(binaryString);
+        
+        const result = decodeBase64WithUTF8(base64);
+        expect(result).toBe(text);
+    });
+
+    it('should correctly decode base64 with mixed content', () => {
+        const text = 'export function Example() {\n    // 👇 This is a comment\n    return <div>Hello</div>;\n}';
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(text);
+        const binaryString = String.fromCharCode(...bytes);
+        const base64 = btoa(binaryString);
+        
+        const result = decodeBase64WithUTF8(base64);
+        expect(result).toBe(text);
+        expect(result).toContain('👇');
+    });
+
+    it('should handle base64 with whitespace (as GitHub API might return)', () => {
+        const text = 'Test 👍';
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(text);
+        const binaryString = String.fromCharCode(...bytes);
+        const base64 = btoa(binaryString);
+        const base64WithWhitespace = base64.slice(0, 5) + '\n' + base64.slice(5);
+        
+        const result = decodeBase64WithUTF8(base64WithWhitespace);
+        expect(result).toBe(text);
+    });
+
+    it('should match the deprecated escape/unescape pattern behavior', () => {
+        // Verify our solution gives the same result as the deprecated method
+        const text = '// 👇 This is a comment with emoji';
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(text);
+        const binaryString = String.fromCharCode(...bytes);
+        const base64 = btoa(binaryString);
+        
+        const modernResult = decodeBase64WithUTF8(base64);
+        
+        // The deprecated pattern: decodeURIComponent(escape(atob(base64)))
+        // escape() converts the incorrectly-decoded UTF-8 bytes to percent-encoding
+        // decodeURIComponent() then interprets those percent-encoded bytes as UTF-8
+        const deprecatedResult = decodeURIComponent(escape(atob(base64)));
+        
+        expect(modernResult).toBe(deprecatedResult);
+        expect(modernResult).toBe(text);
+    });
+});

src/library/config/defaultFunctions.ts

@@ -3,6 +3,34 @@ import { parseGithubIssueLink, parseGithubPermalinkUrl } from "../utils/urlParse
 import { GithubPermalinkDataResponse } from "./GithubPermalinkContext";
 import { ErrorResponses } from "./GithubPermalinkContext";
 
+/**
+ * Properly decode base64 string with UTF-8 support.
+ * GitHub API returns base64-encoded content that may contain UTF-8 characters like emojis.
+ * 
+ * The issue: atob() decodes base64 to a binary string, but treats each byte as a Latin-1 character.
+ * For UTF-8 multi-byte characters (like emojis), this corrupts the data.
+ * 
+ * The solution: Convert the binary string to a byte array, then use TextDecoder to properly
+ * interpret those bytes as UTF-8.
+ */
+function decodeBase64WithUTF8(base64: string): string {
+    // Remove whitespace that GitHub API might include
+    const cleanedBase64 = base64.replace(/\s/g, '');
+    
+    // Decode base64 to binary string (each character represents a byte)
+    const binaryString = atob(cleanedBase64);
+    
+    // Convert binary string to byte array
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    
+    // Decode UTF-8 bytes to string
+    const decoder = new TextDecoder('utf-8');
+    return decoder.decode(bytes);
+}
+
 
 export async function defaultGetIssueFn(issueLink: string, githubToken?: string, onError?: (err: unknown) => void): Promise<GithubIssueLinkDataResponse> {
     const config = parseGithubIssueLink(issueLink);
@@ -61,7 +89,7 @@ export async function defaultGetIssueFn(issueLink: string, githubToken?: string,
     }
 
     const [contentJson, commitJson] = await Promise.all([contentResult.json(), commitResult.json()]);
-    const content = decodeURIComponent(escape(atob(contentJson.content)));
+    const content = decodeBase64WithUTF8(contentJson.content);
     const lines = content.split("\n");
 
     return {