\n \n \n \n \n \n \n \n `,\n {\n headers: {\n \"content-type\": \"text/html\",\n },\n }\n );\n}\n","bao-cipher",[277],"02f17e2c-e28c-11f0-a32d-42dde27851f2","letterReplacement.test.ts","02f17ec2-e28c-11f0-a32d-42dde27851f2",523,["D",1766775142106],"import { assertEquals } from \"https://deno.land/std@0.208.0/assert/mod.ts\";\n\n/**\n * Test for letter replacement functionality\n * \n * This test verifies that users can replace letters in filled input boxes\n * without having to hit backspace first. The feature should:\n * 1. Detect when a letter key is pressed on a filled input\n * 2. Clear the old letter from all matching positions\n * 3. Fill the new letter in all matching positions\n * 4. Move focus to the next empty input\n */\n\nDeno.test(\"Letter replacement - simulates the desired behavior\", () => {\n // Simulate initial state with some letters filled\n const decryptionAttempt = [\"A\", \"B\", \"C\", \"\", \"\", \"A\", \"\", \"B\"];\n const encodedLettersOnly = \"XYZWQXRY\"; // Encoded cipher text (letters only)\n const letterIndex = 0; // User is focused on first input which has \"A\"\n const newLetter = \"D\"; // User types \"D\"\n \n // Simulate the replacement logic\n const encodedLetter = encodedLettersOnly[letterIndex]; // \"X\"\n const newAttempt = [...decryptionAttempt];\n \n // Clear all instances of the encoded letter\n encodedLettersOnly.split(\"\").forEach((letter, idx) => {\n if (letter === encodedLetter) {\n newAttempt[idx] = \"\";\n }\n });\n \n // Set all instances to the new letter\n encodedLettersOnly.split(\"\").forEach((letter, idx) => {\n if (letter === encodedLetter) {\n newAttempt[idx] = newLetter;\n }\n });\n \n // Verify the replacement worked correctly\n assertEquals(newAttempt[0], \"D\", \"First position (X) should now be D\");\n assertEquals(newAttempt[5], \"D\", \"Sixth position (also X) should now be D\");\n assertEquals(newAttempt[1], \"B\", \"Second position (Y) should remain B\");\n assertEquals(newAttempt[2], \"C\", \"Third position (Z) should remain C\");\n assertEquals(newAttempt[7], \"B\", \"Eighth position (Y) should remain B\");\n});\n\nDeno.test(\"Letter replacement - handles empty fields correctly\", () => {\n // When field is empty, normal input should work\n const decryptionAttempt = [\"\", \"B\", \"C\", \"\", \"\", \"\", \"\", \"B\"];\n const encodedLettersOnly = \"XYZWQXRY\";\n const letterIndex = 0; // User is focused on first input which is empty\n const newLetter = \"A\";\n \n const encodedLetter = encodedLettersOnly[letterIndex]; // \"X\"\n const newAttempt = [...decryptionAttempt];\n \n // Since the regex test /^[a-zA-Z]$/.test(event.key) && decryptionAttempt[letterIndex]\n // would be false (field is empty), this path wouldn't execute\n // But let's test that the normal handleLetterChange would work\n \n // Set all instances to the new letter\n encodedLettersOnly.split(\"\").forEach((letter, idx) => {\n if (letter === encodedLetter) {\n newAttempt[idx] = newLetter;\n }\n });\n \n assertEquals(newAttempt[0], \"A\", \"First position should be A\");\n assertEquals(newAttempt[5], \"A\", \"Sixth position should also be A (same encoded letter)\");\n});\n\nDeno.test(\"Letter replacement - replaces multiple instances\", () => {\n // When replacing a letter that appears multiple times\n const decryptionAttempt = [\"T\", \"E\", \"S\", \"T\", \"\", \"T\", \"E\", \"\"];\n const encodedLettersOnly = \"XYZXQXYQ\"; // X appears at indices 0, 3, 5\n const letterIndex = 0; // Replacing \"T\" (encoded as X)\n const newLetter = \"R\";\n \n const encodedLetter = encodedLettersOnly[letterIndex]; // \"X\"\n const newAttempt = [...decryptionAttempt];\n \n // Clear all X positions\n encodedLettersOnly.split(\"\").forEach((letter, idx) => {\n if (letter === encodedLetter) {\n newAttempt[idx] = \"\";\n }\n });\n \n // Set all X positions to new letter\n encodedLettersOnly.split(\"\").forEach((letter, idx) => {\n if (letter === encodedLetter) {\n newAttempt[idx] = newLetter;\n }\n });\n \n assertEquals(newAttempt[0], \"R\", \"Position 0 should be R\");\n assertEquals(newAttempt[3], \"R\", \"Position 3 should be R\");\n assertEquals(newAttempt[5], \"R\", \"Position 5 should be R\");\n assertEquals(newAttempt[1], \"E\", \"Position 1 should remain E\");\n assertEquals(newAttempt[2], \"S\", \"Position 2 should remain S\");\n assertEquals(newAttempt[6], \"E\", \"Position 6 should remain E\");\n});\n\n",[286],"c7daf664-e3b8-11f0-9c20-42dde27851f2","hardModeAristocrat.test.ts","b1eacb8c-e3b2-11f0-9b4c-42dde27851f2",["D",1766904321471],"import { assertEquals } from \"https://deno.land/std@0.208.0/assert/mod.ts\";\nimport { substitutionEncode } from \"./substitutionCipher.ts\";\nimport { misspellSentence } from \"./misspellHelpers.ts\";\n\n/**\n * Test for hard mode aristocrat misspelling bug\n * \n * Bug: When hard mode aristocrat is played with type=\"random\", creating a misspelled\n * cipher would generate a NEW random substitution map, causing the same cipher letter\n * to map to different plaintext letters, making the puzzle unsolvable.\n * \n * Fix: When creating the misspelled cipher, we reuse the original cipher's substitution\n * map to ensure consistency.\n */\n\nDeno.test(\"Hard mode aristocrat - reuses substitution map for misspelled text\", () => {\n // Create original cipher with random type\n const originalText = \"I KNOW YOUR LIFE\";\n const originalCipher = substitutionEncode({\n plainText: originalText,\n keyword: \"test\",\n positionLetter: \"A\",\n type: \"random\",\n groupingType: \"aristocrat\",\n });\n \n // Misspell the text (simulating hard mode)\n const misspelledText = misspellSentence(originalText);\n \n // Create misspelled cipher WITHOUT reusing map (this is the bug)\n const misspelledCipherWithBug = substitutionEncode({\n plainText: misspelledText,\n keyword: \"test\",\n positionLetter: \"A\",\n type: \"random\",\n groupingType: \"aristocrat\",\n });\n \n // Create misspelled cipher WITH reusing map (this is the fix)\n const misspelledCipherFixed = substitutionEncode({\n plainText: misspelledText,\n keyword: \"test\",\n positionLetter: \"A\",\n type: \"random\",\n groupingType: \"aristocrat\",\n existingSubstitutionMap: originalCipher.substitutionMap,\n existingReverseSubstitutionMap: originalCipher.reverseSubstitutionMap,\n });\n \n // Verify the bug: different maps for same letter\n // For example, if original has A->X, the buggy version might have A->Y\n const letterA_original = originalCipher.substitutionMap[\"A\"];\n const letterA_buggy = misspelledCipherWithBug.substitutionMap[\"A\"];\n const letterA_fixed = misspelledCipherFixed.substitutionMap[\"A\"];\n \n console.log(\"Original A maps to:\", letterA_original);\n console.log(\"Buggy A maps to:\", letterA_buggy);\n console.log(\"Fixed A maps to:\", letterA_fixed);\n \n // The buggy version will likely have different mapping (random)\n // The fixed version should have the same mapping as original\n assertEquals(\n letterA_fixed,\n letterA_original,\n \"Fixed version should use the same substitution map as original\"\n );\n \n // Check all 26 letters\n for (let i = 0; i < 26; i++) {\n const letter = String.fromCharCode(65 + i); // A-Z\n assertEquals(\n misspelledCipherFixed.substitutionMap[letter],\n originalCipher.substitutionMap[letter],\n `Letter ${letter} should map to the same cipher letter in both original and misspelled versions`\n );\n }\n});\n\nDeno.test(\"Hard mode aristocrat - consistency check with K1 cipher\", () => {\n // Test with K1 to ensure the fix works for non-random types too\n const originalText = \"HELLO WORLD\";\n const originalCipher = substitutionEncode({\n plainText: originalText,\n keyword: \"SECRET\",\n positionLetter: \"D\",\n type: \"k1\",\n groupingType: \"aristocrat\",\n });\n \n const misspelledText = \"HELO WRLD\"; // Manually misspelled\n const misspelledCipher = substitutionEncode({\n plainText: misspelledText,\n keyword: \"SECRET\",\n positionLetter: \"D\",\n type: \"k1\",\n groupingType: \"aristocrat\",\n existingSubstitutionMap: originalCipher.substitutionMap,\n existingReverseSubstitutionMap: originalCipher.reverseSubstitutionMap,\n });\n \n // K1 with same keyword should generate same map anyway, but let's verify\n assertEquals(\n misspelledCipher.substitutionMap,\n originalCipher.substitutionMap,\n \"K1 cipher should have consistent substitution map\"\n );\n});\n\nDeno.test(\"Hard mode aristocrat - encoded text uses correct mapping\", () => {\n // Create a simple example to verify encoding is correct\n const originalText = \"AAA BBB\";\n const originalCipher = substitutionEncode({\n plainText: originalText,\n keyword: \"test\",\n positionLetter: \"A\",\n type: \"random\",\n groupingType: \"aristocrat\",\n });\n \n // Get what A and B map to\n const cipherA = originalCipher.substitutionMap[\"A\"];\n const cipherB = originalCipher.substitutionMap[\"B\"];\n \n // Create misspelled version with different letters\n const misspelledText = \"AAB BBA\";\n const misspelledCipher = substitutionEncode({\n plainText: misspelledText,\n keyword: \"test\",\n positionLetter: \"A\",\n type: \"random\",\n groupingType: \"aristocrat\",\n existingSubstitutionMap: originalCipher.substitutionMap,\n existingReverseSubstitutionMap: originalCipher.reverseSubstitutionMap,\n });\n \n // Expected encoded text: AAB BBA -> cipherA cipherA cipherB space cipherB cipherB cipherA\n const expectedEncoded = `${cipherA}${cipherA}${cipherB} ${cipherB}${cipherB}${cipherA}`;\n assertEquals(\n misspelledCipher.encoded,\n expectedEncoded,\n \"Misspelled text should encode correctly using the original substitution map\"\n );\n});\n\nDeno.test(\"Pre-generated misspelled text - consistency across game loads\", () => {\n // Test that pre-generating misspelled text ensures consistency\n const originalText = \"I KNOW YOUR LIFE\";\n const preGeneratedMisspelled = \"I NO UR LYFE\"; // Simulated pre-generated misspelling\n \n // Create cipher with pre-generated misspelled version\n const cipher = substitutionEncode({\n plainText: originalText,\n keyword: \"test\",\n positionLetter: \"A\",\n type: \"random\",\n groupingType: \"aristocrat\",\n misspelledOriginal: preGeneratedMisspelled,\n });\n \n // Verify misspelled version is stored\n assertEquals(\n cipher.misspelledOriginal,\n preGeneratedMisspelled,\n \"Pre-generated misspelled text should be stored in cipher\"\n );\n \n // Simulate loading the same game (with misspelled version available)\n const misspelledCipher = substitutionEncode({\n plainText: preGeneratedMisspelled,\n keyword: \"test\",\n positionLetter: \"A\",\n type: \"random\",\n groupingType: \"aristocrat\",\n existingSubstitutionMap: cipher.substitutionMap,\n existingReverseSubstitutionMap: cipher.reverseSubstitutionMap,\n misspelledOriginal: preGeneratedMisspelled,\n });\n \n // Verify consistency: same substitution map and same misspelled text\n assertEquals(\n misspelledCipher.substitutionMap,\n cipher.substitutionMap,\n \"Substitution map should be identical across game loads\"\n );\n assertEquals(\n misspelledCipher.original,\n preGeneratedMisspelled,\n \"Misspelled text should be used as the plaintext\"\n );\n});\n\n",[293],"b69ec79c-2fe2-11f1-8b64-42dde27851f2","gameHelpers.ts","d41a3b5a-4422-11f0-89d5-76b3cceeab13",540,["D",1775278619795],"import { isMobileNative, sendBridgeMessage } from \"./bridge.ts\";\n\nconst RECENT_GAMES_KEY = \"recent_game_ids\";\nconst MAX_RECENT_GAMES = 10;\n\nexport function getRecentGameIds(): string[] {\n try {\n const stored = localStorage.getItem(RECENT_GAMES_KEY);\n return stored ? JSON.parse(stored) : [];\n } catch {\n return [];\n }\n}\n\nexport function addRecentGameId(gameId: string): void {\n const recent = getRecentGameIds();\n if (!recent.includes(gameId)) {\n recent.push(gameId);\n if (recent.length > MAX_RECENT_GAMES) {\n recent.splice(0, recent.length - MAX_RECENT_GAMES);\n }\n localStorage.setItem(RECENT_GAMES_KEY, JSON.stringify(recent));\n }\n}\n\nexport function startNewGame(input: string) {\n const newNumber = Math.round(Math.random() * 1000000);\n\n // Propagate next-game link to all recent games so other players can follow\n const playerName = localStorage.getItem(\"name\");\n if (playerName) {\n const recentGames = getRecentGameIds();\n for (const oldGameId of recentGames) {\n navigator.sendBeacon(\n \"https://simplevalueapi.val.run/addLog\",\n JSON.stringify({\n id: oldGameId,\n log: `🔗 ${playerName} created a new game: ${newNumber}`,\n })\n );\n }\n }\n\n // Register current game before navigating away\n addRecentGameId(input);\n\n window.location.href = `${window.location.origin}/${newNumber}`;\n}\n\nexport function present(text: string) {\n alert(text);\n void sendBridgeMessage({ action: \"present\", data: { message: text } });\n}\n\nexport function appendToLocalStorage(text: string, author: string | null): void {\n const newValue = `${text} - ${author ?? \"\"}`;\n if (isMobileNative()) {\n void sendBridgeMessage({ action: \"appendKnownQuote\", data: { quote: newValue } });\n return;\n }\n\n const key = \"known_texts\";\n // Get the existing data from local storage\n const storedData = localStorage.getItem(key);\n\n // If it exists, parse it; otherwise, use an empty array\n let arr: string[] = storedData ? JSON.parse(storedData) : [];\n\n // Push the new value onto the array if it is not already in it\n if (!arr.includes(newValue)) {\n arr.push(newValue);\n }\n\n // Save the updated array back to local storage\n localStorage.setItem(key, JSON.stringify(arr));\n}\n\nexport function isTextKnown(text: string, author: string | null, texts: string[]): boolean {\n const set = new Set(texts);\n return set.has(`${text} - ${author ?? \"\"}`);\n}\n\nexport async function getKnownTexts(): Promise {\n if (isMobileNative()) {\n const result = await sendBridgeMessage({ action: \"requestKnownQuotes\", data: {} });\n return result?.[\"quotes\"] ?? [];\n }\n const key = \"known_texts\";\n const storedData = localStorage.getItem(key);\n return storedData ? JSON.parse(storedData) : [];\n}",[299],"5f9bf334-40f9-11f1-b55e-42b51c65c3df","constants.ts","d41a38e4-4422-11f0-89d5-76b3cceeab13",["D",1777157521973],26,"export const quoteCount = 6839;\n\nexport const tutorialUrl = \"https://baolei.notion.site/ciphertutorial\";\nexport const strategyUrl = \"https://baolei.notion.site/cipherstrategy\";\n",[306],"6386d184-a721-11f0-a70d-0224a6c84d84","cipherHelpers.ts","2975a900-a6e7-11f0-a077-0224a6c84d84",504,["D",1760242229389],"export function getCipherName(\n type: string,\n keyword: string,\n groupingType: string\n): string {\n // Caesar cipher is a special case of K1 aristocrat with empty keyword\n if (type === \"k1\" && keyword === \"\" && groupingType === \"aristocrat\") {\n return \"Caesar Cipher\";\n }\n\n // Capitalize first letter of type and groupingType\n const capitalizedType = type.charAt(0).toUpperCase() + type.slice(1);\n const capitalizedGrouping =\n groupingType.charAt(0).toUpperCase() + groupingType.slice(1);\n\n return `${capitalizedType} ${capitalizedGrouping}`;\n}\n",[313],"229d8704-a798-11f0-8271-0224a6c84d84","bridge.ts","d41a35f6-4422-11f0-89d5-76b3cceeab13",["D",1760293230598],"export function isMobileNative(): boolean {\n return Boolean((globalThis as any).window?.WebNativeBridge);\n}\n\nexport async function sendBridgeMessage(message: {\n action: string;\n data: any;\n}): Promise {\n return await (globalThis as any).window?.WebNativeBridge?.webToNative?.(\n message\n );\n}\n",[320],"02f23eb6-e28c-11f0-a32d-42dde27851f2","appSiteAssociation.test.ts","f3c14a04-c805-11f0-8990-42dde27851f2",["D",1766775142106],"import { assertEquals } from \"https://deno.land/std@0.208.0/assert/mod.ts\";\nimport { appSiteAssociation } from \"./api.ts\";\nimport server from \"./main.tsx\";\n\nDeno.test(\"appSiteAssociation - function exists and returns correct response\", async () => {\n const response = appSiteAssociation();\n \n // Check that response is returned\n assertEquals(response instanceof Response, true, \"appSiteAssociation should return a Response object\");\n \n // Check headers\n assertEquals(\n response.headers.get(\"Content-Type\"),\n \"application/json\",\n \"Response should have Content-Type: application/json\"\n );\n \n // Check response body\n const body = await response.json();\n assertEquals(\n body.applinks !== undefined,\n true,\n \"Response should contain applinks object\"\n );\n assertEquals(\n body.applinks.details !== undefined,\n true,\n \"applinks should contain details array\"\n );\n assertEquals(\n body.applinks.details.length > 0,\n true,\n \"details array should not be empty\"\n );\n assertEquals(\n body.applinks.details[0].appIDs.includes(\"869W3P5ZRS.fyi.lei.cipher\"),\n true,\n \"appIDs should contain the correct app ID\"\n );\n});\n\nDeno.test(\"server - routes .well-known/apple-app-site-association correctly\", async () => {\n const request = new Request(\"https://example.com/.well-known/apple-app-site-association\");\n const response = await server(request);\n \n // Check that response is returned\n assertEquals(response instanceof Response, true, \"Server should return a Response object\");\n \n // Check headers\n assertEquals(\n response.headers.get(\"Content-Type\"),\n \"application/json\",\n \"Response should have Content-Type: application/json\"\n );\n \n // Check response body\n const body = await response.json();\n assertEquals(\n body.applinks !== undefined,\n true,\n \"Response should contain applinks object\"\n );\n});\n\nDeno.test(\"server - HTML includes apple-itunes-app meta tag\", async () => {\n const request = new Request(\"https://example.com/123\");\n const response = await server(request);\n \n // Check that response is HTML\n assertEquals(\n response.headers.get(\"content-type\"),\n \"text/html\",\n \"Response should have content-type: text/html\"\n );\n \n // Check response body contains the meta tag\n const html = await response.text();\n assertEquals(\n html.includes('name=\"apple-itunes-app\"'),\n true,\n \"HTML should contain apple-itunes-app meta tag\"\n );\n assertEquals(\n html.includes('app-id=6742675455'),\n true,\n \"Meta tag should contain correct app-id\"\n );\n assertEquals(\n html.includes('app-argument=https://cipher.lei.fyi/123'),\n true,\n \"Meta tag should contain correct app-argument with the game ID\"\n );\n});\n\nDeno.test(\"server - HTML includes correct numberId in apple-itunes-app meta tag for random games\", async () => {\n const request = new Request(\"https://example.com/\");\n const response = await server(request);\n \n // Check that response is HTML\n const html = await response.text();\n \n // Extract the numberId from the meta tag\n const metaTagMatch = html.match(/app-argument=https:\\/\\/cipher\\.lei\\.fyi\\/(\\d+)/);\n assertEquals(\n metaTagMatch !== null,\n true,\n \"HTML should contain apple-itunes-app meta tag with a numeric game ID\"\n );\n \n if (metaTagMatch) {\n const numberId = metaTagMatch[1];\n // Check that the same numberId is in the data-uuid attribute\n assertEquals(\n html.includes(`data-uuid=\"cipher-${numberId}\"`),\n true,\n \"The numberId in apple-itunes-app should match the one in data-uuid\"\n );\n }\n});\n\n\n",[326],"b0b954ee-abeb-11f0-8ee2-0224a6c84d84","api.ts","d419ff96-4422-11f0-89d5-76b3cceeab13",508,["D",1760768921885],8,"import { quoteCount } from \"./constants.ts\";\nimport { randomWordFromSentence } from \"./wordHelpers.ts\";\n\n// Deno runtime type declaration\ndeclare const Deno: {\n env: {\n get(key: string): string | undefined;\n };\n};\n\n/**\n * API Specification for getQuote endpoint\n *\n * Path:\n * /quote\n *\n * Query Parameters:\n * - pageId (optional): The starting quote ID. If not provided, a random ID is selected.\n * - count (optional): The number of quotes to return. Must be used with pageId.\n *\n * Response Formats:\n *\n * 1. Single Quote Mode (when count is NOT provided):\n * Returns a single quote object:\n * {\n * quote: string, // The quote text\n * author: string, // The author name\n * keyword: string, // A random word from a previous quote\n * quoteId: number // The quote's unique ID\n * }\n *\n * 2. Multiple Quotes Mode (when both count AND pageId are provided):\n * Returns an array of quote objects:\n * [\n * {\n * quote: string,\n * author: string,\n * quoteId: number\n * },\n * ...\n * ]\n * Returns exactly 'count' quotes starting from 'pageId'.\n * Note: keyword is not included in multi-quote mode.\n */\nexport async function getQuote(request: Request): Promise {\n const url = new URL(request.url);\n const pageId =\n url.searchParams.get(\"pageId\") ??\n Math.floor(Math.random() * quoteCount + 1).toString();\n const pageIdInt = parseInt(pageId);\n const countParam = url.searchParams.get(\"count\");\n const count = countParam ? parseInt(countParam) : null;\n\n console.log(\"Page ID:\", pageIdInt);\n if (count !== null) {\n console.log(\"Count:\", count);\n }\n\n try {\n const notionToken = Deno.env.get(\"Notion_ready_only_api_token\");\n if (!notionToken) {\n throw new Error(\"Notion API token not found\");\n }\n const databaseId = \"16e2c190bff080fd9ea8d2a8c21548b0\";\n\n // Determine the range to fetch based on count parameter\n const maxId =\n count !== null && url.searchParams.has(\"pageId\")\n ? pageIdInt + count - 1\n : pageIdInt + 10; // load a few more to make sure we have one that's long enough\n const minId =\n count !== null && url.searchParams.has(\"pageId\")\n ? pageIdInt\n : Math.max(1, pageIdInt - 1); // load a few more to make sure we have one that's long enough\n\n // Use database query with filter instead of direct page fetch\n const response = await fetch(\n `https://api.notion.com/v1/databases/${databaseId}/query`,\n {\n method: \"POST\",\n headers: {\n Authorization: `Bearer ${notionToken}`,\n \"Notion-Version\": \"2022-06-28\",\n \"Content-Type\": \"application/json\",\n },\n body: JSON.stringify({\n filter: {\n and: [\n {\n property: \"ID\", // Uppercase ID property\n unique_id: {\n less_than_or_equal_to: maxId,\n },\n },\n {\n property: \"ID\", // Uppercase ID property\n unique_id: {\n greater_than_or_equal_to: minId,\n },\n },\n ],\n },\n sorts: [\n {\n property: \"ID\",\n direction: \"ascending\",\n },\n ],\n }),\n }\n );\n // console.log(response);\n\n if (!response.ok) {\n throw new Error(\n `Failed to query Notion database: ${response.statusText}`\n );\n }\n\n const data = await response.json();\n console.log(`Fetched ${data.results.length} pages from Notion API`);\n\n // Multi-quote mode: return list of quotes when count and pageId are both provided\n if (count !== null && url.searchParams.has(\"pageId\")) {\n const quotes: Array<{ quote: string; author: string; quoteId: number }> =\n [];\n for (const page of data.results) {\n const quote = page.properties.quote?.rich_text?.[0]?.plain_text || \"\";\n const author = page.properties.author?.rich_text?.[0]?.plain_text || \"\";\n const quoteId = page.properties.ID.unique_id?.number ?? 0;\n\n if (quote.length >= 1) {\n quotes.push({ quote, author, quoteId });\n }\n\n if (quotes.length >= count) {\n break;\n }\n }\n\n if (quotes.length === 0) {\n throw new Error(`No quotes found starting from ID ${pageId}`);\n }\n\n return new Response(JSON.stringify(quotes), {\n headers: { \"Content-Type\": \"application/json\" },\n });\n }\n\n // Single quote mode: original behavior with keyword\n let keyword = \"\";\n for (const page of data.results) {\n // console.log(\"Checking page\", page.properties.ID);\n // Extract plain text from rich text properties\n const quote = page.properties.quote?.rich_text?.[0]?.plain_text || \"\";\n const author = page.properties.author?.rich_text?.[0]?.plain_text || \"\";\n const quoteId = page.properties.ID.unique_id?.number ?? 0;\n if (!keyword) {\n keyword = randomWordFromSentence(quote);\n // console.log(\"Found a keyword\", keyword);\n continue;\n }\n if (quote.length >= 1) {\n // console.log(\"Found a quote long enough\", quote);\n return new Response(\n JSON.stringify({ quote, author, keyword, quoteId }),\n {\n headers: { \"Content-Type\": \"application/json\" },\n }\n );\n }\n }\n\n throw new Error(`No page found with ID ${pageId}`);\n } catch (error) {\n return new Response(JSON.stringify({ error: error.message }), {\n status: 500,\n headers: { \"Content-Type\": \"application/json\" },\n });\n }\n}\n\nexport function appSiteAssociation(): Response {\n return new Response(\n JSON.stringify({\n applinks: {\n details: [\n {\n appIDs: [\"869W3P5ZRS.fyi.lei.cipher\"],\n components: [\n {\n \"/\": \"/*\",\n comment: \"matches all\",\n },\n ],\n },\n ],\n },\n }),\n {\n headers: { \"Content-Type\": \"application/json\" },\n }\n );\n}\n",[332],"ce826916-0ac3-11f1-a72d-42dde27851f2","analyze_quotes.js","ce8269de-0ac3-11f1-a72d-42dde27851f2",["D",1771197152424],"#!/usr/bin/env node\n\n/**\n * Script to fetch all quotes from the Cipher API and analyze authors and words\n *\n * This script:\n * 1. Fetches quotes in batches of 100 starting from pageId 1\n * 2. Continues until no more quotes are found\n * 3. Analyzes and displays the top 25 authors by quote count\n * 4. Analyzes and displays the most frequent words (4+ letters)\n */\n\nconst API_ENDPOINT = \"https://cipher.lei.fyi/quote\";\nconst BATCH_SIZE = 100;\n\n// ANSI escape codes for terminal control\nconst CLEAR_LINE = \"\\x1b[2K\";\nconst CURSOR_UP = \"\\x1b[1A\";\nconst CURSOR_HOME = \"\\x1b[H\";\nconst CLEAR_SCREEN = \"\\x1b[2J\";\nconst HIDE_CURSOR = \"\\x1b[?25l\";\nconst SHOW_CURSOR = \"\\x1b[?25h\";\n\nasync function fetchQuotes(pageId, count) {\n const url = `${API_ENDPOINT}?pageId=${pageId}&count=${count}`;\n\n try {\n const response = await fetch(url);\n const data = await response.json();\n\n // Check if we got an error\n if (data.error) {\n return null;\n }\n\n // Check if data is an array (multi-quote mode)\n if (Array.isArray(data)) {\n return data;\n }\n\n return null;\n } catch (error) {\n return null;\n }\n}\n\nfunction updateDisplay(stats) {\n // Clear screen and move cursor to home\n process.stdout.write(CLEAR_SCREEN + CURSOR_HOME);\n\n // Header\n\n // Progress stats\n console.log(` Total quotes fetched: ${stats.totalQuotes}`);\n console.log(` Unique authors: ${stats.uniqueAuthors}`);\n console.log();\n\n // Top authors section\n\n if (stats.topAuthors.length === 0) {\n console.log(\" (Loading...)\");\n } else {\n stats.topAuthors.forEach((item, index) => {\n const rank = (index + 1).toString().padStart(3);\n const count = item.count.toString().padStart(5);\n const bar = \"█\".repeat(Math.min(50, Math.floor(item.count / 10)));\n console.log(` ${rank}. ${item.author.padEnd(35)} ${count} ${bar}`);\n });\n }\n\n // Top words section\n console.log(\"-\".repeat(70));\n\n if (!stats.topWords || stats.topWords.length === 0) {\n console.log(\" (Loading...)\");\n } else {\n // Display in 3 columns\n const wordsPerColumn = 66 / 3;\n for (let i = 0; i < wordsPerColumn; i++) {\n const col1 = stats.topWords[i];\n const col2 = stats.topWords[i + wordsPerColumn];\n const col3 = stats.topWords[i + wordsPerColumn * 2];\n\n let line = \"\";\n if (col1) {\n const rank = (i + 1).toString().padStart(3);\n const count = col1.count.toString().padStart(5);\n line += ` ${rank}. ${col1.word.padEnd(12)} ${count}`;\n }\n\n if (col2) {\n const padding = col1 ? \" \" : \" \".repeat(25);\n const rank = (i + wordsPerColumn + 1).toString().padStart(3);\n const count = col2.count.toString().padStart(5);\n line += `${padding}${rank}. ${col2.word.padEnd(12)} ${count}`;\n }\n\n if (col3) {\n const padding = col2 ? \" \" : \" \".repeat(25);\n const rank = (i + wordsPerColumn * 2 + 1).toString().padStart(3);\n const count = col3.count.toString().padStart(5);\n line += `${padding}${rank}. ${col3.word.padEnd(12)} ${count}`;\n }\n\n console.log(line);\n }\n }\n\n console.log(\"=\".repeat(70));\n\n if (stats.isComplete) {\n console.log(\"✅ FETCH COMPLETE!\");\n } else {\n console.log(\"⏳ Fetching...\");\n }\n}\n\nfunction sanitizeAuthorName(author) {\n if (!author) return \"Unknown\";\n\n // Remove content in parentheses\n let sanitized = author.replace(/\$[^)]*\$/g, \"\");\n\n // Remove common suffixes (Jr., Jr, Sr., Sr, III, etc.)\n sanitized = sanitized.replace(/\\b(Jr\\.?|Sr\\.?|III|II|IV)\\b\\.?/gi, \"\");\n\n // Remove standalone periods and extra whitespace\n sanitized = sanitized.replace(/\\s+\\./g, \"\").replace(/\\.\\s+/g, \" \");\n\n // Trim whitespace\n sanitized = sanitized.trim();\n\n // Split into words (filter out periods and empty strings)\n const words = sanitized.split(/\\s+/).filter((w) => w.length > 0 && w !== \".\");\n\n // If 2 or more words, use first + last only\n if (words.length >= 2) {\n sanitized = `${words[0]} ${words[words.length - 1]}`;\n } else if (words.length === 1) {\n sanitized = words[0];\n } else {\n return \"Unknown\";\n }\n\n return sanitized || \"Unknown\";\n}\n\nfunction analyzeWordsLive(quotes) {\n const wordCounts = {};\n\n // Extract words from all quotes\n for (const quote of quotes) {\n if (!quote.quote) continue;\n\n // Extract words (letters only, at least 4 chars)\n const words = quote.quote.toLowerCase().match(/[a-z]{4,}/g) || [];\n\n for (const word of words) {\n wordCounts[word] = (wordCounts[word] || 0) + 1;\n }\n }\n\n // Get top words by frequency\n const topWords = Object.entries(wordCounts)\n .map(([word, count]) => ({ word, count }))\n .sort((a, b) => b.count - a.count)\n .slice(0, 66);\n\n return {\n wordCounts,\n topWords,\n totalWords: Object.keys(wordCounts).length,\n };\n}\n\nfunction analyzeAuthorsLive(quotes) {\n const authorCounts = {};\n\n // Count quotes per author with sanitized names\n for (const quote of quotes) {\n const author = sanitizeAuthorName(quote.author);\n authorCounts[author] = (authorCounts[author] || 0) + 1;\n }\n\n // Get top 25 authors by quote count\n const topAuthors = Object.entries(authorCounts)\n .map(([author, count]) => ({ author, count }))\n .sort((a, b) => b.count - a.count)\n .slice(0, 25);\n\n return {\n authorCounts,\n topAuthors,\n uniqueAuthors: Object.keys(authorCounts).length,\n };\n}\n\nasync function fetchAllQuotes() {\n const allQuotes = [];\n let pageId = 1;\n let continueLooping = true;\n const startTime = Date.now();\n\n // Hide cursor for cleaner display\n process.stdout.write(HIDE_CURSOR);\n\n while (continueLooping) {\n const quotes = await fetchQuotes(pageId, BATCH_SIZE);\n\n if (quotes === null || quotes.length === 0) {\n continueLooping = false;\n } else {\n allQuotes.push(...quotes);\n\n // Analyze and display current state\n const authorAnalysis = analyzeAuthorsLive(allQuotes);\n const wordAnalysis = analyzeWordsLive(allQuotes);\n const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(1);\n\n updateDisplay({\n totalQuotes: allQuotes.length,\n currentPageId: pageId,\n uniqueAuthors: authorAnalysis.uniqueAuthors,\n topAuthors: authorAnalysis.topAuthors,\n uniqueWords: wordAnalysis.totalWords,\n topWords: wordAnalysis.topWords,\n elapsedTime,\n isComplete: false,\n });\n\n pageId += BATCH_SIZE;\n\n // Add a small delay to be nice to the API\n await new Promise((resolve) => setTimeout(resolve, 100));\n }\n }\n\n // Final update\n const authorAnalysis = analyzeAuthorsLive(allQuotes);\n const wordAnalysis = analyzeWordsLive(allQuotes);\n const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(1);\n\n updateDisplay({\n totalQuotes: allQuotes.length,\n currentPageId: pageId,\n uniqueAuthors: authorAnalysis.uniqueAuthors,\n topAuthors: authorAnalysis.topAuthors,\n uniqueWords: wordAnalysis.totalWords,\n topWords: wordAnalysis.topWords,\n elapsedTime,\n isComplete: true,\n });\n\n // Show cursor again\n process.stdout.write(SHOW_CURSOR);\n\n return allQuotes;\n}\n\nasync function main() {\n try {\n // Clear screen at start\n process.stdout.write(CLEAR_SCREEN + CURSOR_HOME);\n console.log(\"Starting quote analysis...\\n\");\n await new Promise((resolve) => setTimeout(resolve, 1000));\n\n const quotes = await fetchAllQuotes();\n\n if (quotes.length === 0) {\n console.log(\"\\n❌ No quotes were fetched. Exiting.\");\n return;\n }\n\n console.log(\"\\n✨ Analysis complete! Press Ctrl+C to exit.\");\n } catch (error) {\n // Make sure cursor is visible on error\n process.stdout.write(SHOW_CURSOR);\n throw error;\n }\n}\n\n// Handle Ctrl+C gracefully\nprocess.on(\"SIGINT\", () => {\n process.stdout.write(SHOW_CURSOR);\n console.log(\"\\n\\n👋 Exiting...\");\n process.exit(0);\n});\n\nmain().catch((error) => {\n console.error(\"Fatal error:\", error);\n process.exit(1);\n});",[340],"8901727e-2793-11f0-9d52-569c3dd06744","README.md","8901731e-2793-11f0-9d52-569c3dd06744",["D",1735608699289],"A web app to practice aristocrat and patristocrat cipher decoding.",[346],"2975aaa4-a6e7-11f0-a077-0224a6c84d84","PUNCTUATION_FEATURE.md","2975ab12-a6e7-11f0-a077-0224a6c84d84",["D",1760217221145],"# Punctuation Preservation Feature\n\n## Summary\n\nSuccessfully implemented punctuation preservation for Aristocrat ciphers while maintaining punctuation stripping for Patristocrat ciphers.\n\n## Changes Made\n\n### 1. `substitutionCipher.ts`\n\n- **Line 148-158**: Updated aristocrat encoding to preserve all punctuation and spacing\n- **Line 174**: Fixed TypeScript type annotation for `encodedLetterCounts`\n\n**Key Logic:**\n\n- Aristocrat: Encode only letters (`/[A-Z]/`), preserve everything else (spaces, punctuation)\n- Patristocrat: Strip all non-letters, group into 5-letter blocks (no change from before)\n\n### 2. `App.tsx`\n\nUpdated to handle letter-only indexing while displaying punctuation:\n\n#### New Helper Functions (Lines 503-534):\n\n- `visualIndexFor()`: Maps group/char position to visual position in encoded string\n- `letterIndexFromVisual()`: Converts visual position to letter-only array index\n- `isLetterAtVisual()`: Checks if character at position is a letter\n\n#### Updated Functions:\n\n- `handleLetterChange()`: Works with letter-only indices, finds matching encoded letters\n- `handleKeyDown()`: Backspace handling with letter-only indices\n- `handleClear()`: Clears only letter positions\n- `isDuplicated()`: Checks duplicates using letter-only indices\n- `attemptedOriginalFor()`: Maps encoded letters to attempted decryption\n- `attemptedEncodedFor()`: Maps attempted letters to encoded letters\n\n#### Initialization (Lines 92-98, 169-175):\n\n- `decryptionAttempt` now only tracks letters: `cipher.encoded.replace(/[^A-Z]/g, '')`\n- Input refs array sized for letters only\n\n#### Rendering (Lines 609-682):\n\n- Display layer: Shows all characters including punctuation\n- Input layer: Only creates input boxes for letters, displays punctuation as text\n\n### 3. `substitutionCipher.test.ts` (New File)\n\nComprehensive test suite with 8 tests:\n\n1. **Aristocrat - preserves punctuation and spacing**: Verifies commas, periods, exclamation marks, etc. are preserved\n2. **Aristocrat - letters are properly substituted**: Validates correct substitution with apostrophes\n3. **Patristocrat - strips punctuation and groups into 5-letter blocks**: Ensures no punctuation in output\n4. **Patristocrat - same substitution but different formatting**: Confirms both use same cipher\n5. **Caesar cipher - aristocrat preserves punctuation**: Tests Caesar as K1 with empty keyword\n6. **Letter counts - only counts letters**: Verifies punctuation doesn't affect frequency analysis\n7. **cleanOriginal - only contains letters**: Ensures answer checking works correctly\n8. **Various punctuation marks**: Tests hyphens, ellipses, parentheses, etc.\n\n**All tests pass! ✅**\n\n## How It Works\n\n### Data Structure\n\n- `cipher.encoded`: Full string with letters, spaces, and punctuation (aristocrat) or letters + spaces only (patristocrat)\n- `decryptionAttempt[]`: Array of only letters (no punctuation or spaces)\n- Mapping: Helper functions convert between visual positions and letter-only array indices\n\n### Example Flow\n\n**Input:** `\"Hello, World!\"`\n\n**Aristocrat Mode:**\n\n- `cipher.encoded`: `\"KHOOR, ZRUOG!\"` (letters encoded, punctuation preserved)\n- `decryptionAttempt`: `[\"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\"]` (10 letters only)\n- User sees: `K H O O R , W R U O G !` with inputs only under letters\n\n**Patristocrat Mode:**\n\n- `cipher.encoded`: `\"KHOOR ZRUOG\"` (punctuation stripped, grouped)\n- `decryptionAttempt`: `[\"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\"]` (same 10 letters)\n- User sees: `KHOOR ZRUOG` with inputs under all characters\n\n## Benefits\n\n1. **More authentic**: Real cryptograms preserve punctuation\n2. **Better hints**: Punctuation provides clues about sentence structure\n3. **Cleaner code**: Separation between display (with punctuation) and state (letters only)\n4. **Backward compatible**: Patristocrat unchanged, existing games work\n5. **Well tested**: Comprehensive test coverage ensures correctness\n\n## Testing\n\nRun tests:\n\n```bash\ndeno test substitutionCipher.test.ts\n```\n\nAll 8 tests pass with type checking enabled.\n",[352],"49467468-1045-11f1-97d3-42dde27851f2","Notice.tsx","0d04bde6-4428-11f0-a96c-76b3cceeab13",530,["D",1771802519305],18,"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { sendBridgeMessage } from \"./bridge.ts\";\nimport { getCipherName } from \"./cipherHelpers.ts\";\nimport { tutorialUrl, strategyUrl } from \"./constants.ts\";\n\nexport function Notice({\n type,\n groupingType,\n keyword,\n}: {\n type?: string;\n groupingType?: string;\n keyword?: string;\n}) {\n return (\n \n

\n URGENT NOTICE\n

\n
\n We’ve intercepted an enemy telegraph with top-secret plans. Your\n mission is to crack the cipher before the enemy strikes. Lives depend on\n your speed and precision!\n
\n
\n {type && groupingType && keyword !== undefined && (\n

\n The message is encrypted with{\" \"}\n {getCipherName(type, keyword, groupingType)}. Learn the{\" \"}\n \n void sendBridgeMessage({\n action: \"openLink\",\n data: { url: tutorialUrl },\n })\n }\n >\n rules\n {\" \"}\n and{\" \"}\n \n void sendBridgeMessage({\n action: \"openLink\",\n data: { url: strategyUrl },\n })\n }\n >\n strategies\n \n .\n

\n )}\n \n );\n}\n",[358],"f8d203a0-a71f-11f0-bd90-0224a6c84d84","Loading.tsx","0d04bb8e-4428-11f0-a96c-76b3cceeab13",501,["D",1760241620865],16,"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { isMobileNative, sendBridgeMessage } from \"./bridge.ts\";\nimport { tutorialUrl } from \"./constants.ts\";\n\nexport function Loading() {\n return (\n \n {!isMobileNative() && (\n

Cipher Challenge 🕵️

\n )}\n \n Our agents are still busy at work retrieving intel. Due to the nature of\n this work, no further details can be provided.\n
\n
\n Just hang on for a for a few more seconds...\n
\n
\n In the meantime you can study the{\" \"}\n \n void sendBridgeMessage({\n action: \"openLink\",\n data: { url: tutorialUrl },\n })\n }\n >\n rulebook\n {\" \"}\n and the{\" \"}\n \n void sendBridgeMessage({\n action: \"openLink\",\n data: { url: strategyUrl },\n })\n }\n >\n strategies\n \n .\n \n \n );\n}\n",[366],"4862820c-44d6-11f0-9fd0-76b3cceeab13","KnownTextWarning.tsx","0d04b0da-4428-11f0-a96c-76b3cceeab13",399,["D",1749434757648],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { useState } from \"https://esm.sh/react@18.2.0\";\nimport { isMobileNative } from \"./bridge.ts\";\nimport { startNewGame } from \"./gameHelpers.ts\";\n\nexport function KnownTextWarning(\n { cipherText, knownTexts, uuid }: { cipherText: string; knownTexts: string[]; uuid: string },\n) {\n const [knownTextsShown, setKnownTextsShown] = useState(false);\n\n return (\n

\n You have decoded this one before.\n

\n {!isMobileNative()\n ? (\n {\n setKnownTextsShown(!knownTextsShown);\n }}\n style={{\n marginTop: \"5pt\",\n padding: \"10pt\",\n backgroundColor: \"#4CAF50\",\n color: \"white\",\n border: \"none\",\n flex: 1,\n }}\n >\n {knownTextsShown ? \"Hide solved texts\" : \"Show solved texts\"}\n \n )\n : (\n {\n startNewGame(uuid);\n }}\n style={{\n marginTop: \"5pt\",\n padding: \"10pt\",\n backgroundColor: \"#4CAF50\",\n color: \"white\",\n border: \"none\",\n flex: 1,\n }}\n >\n Try another one\n \n )}\n {knownTextsShown && (\n

= 0 ? \"bold\" : \"regular\" }}>\n {text}\n

\n )}\n

\n );\n}",[374],"4f346a50-44d6-11f0-bc1a-76b3cceeab13","GameResult.tsx","7e3cb3f2-442c-11f0-8338-76b3cceeab13",400,["D",1749434769089],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { isMobileNative, sendBridgeMessage } from \"./bridge.ts\";\n\nexport function GameResult({ uuid }: { uuid: string }) {\n const resultUrl = `https://cipherresult.val.run/?id=${uuid}`;\n return (\n \n See{\" \"}\n {\n void sendBridgeMessage({ action: \"openLink\", data: { url: resultUrl } });\n }}\n >\n Game Result\n \n \n );\n}",[381],"46409426-1043-11f1-9c5b-42dde27851f2","GameLink.tsx","7e3cb1a4-442c-11f0-8338-76b3cceeab13",529,["D",1771801655240],5,"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { useState } from \"https://esm.sh/react@18.2.0\";\nimport { isMobileNative } from \"./bridge.ts\";\n\nexport function GameLink({\n uuid,\n currentUrl,\n}: {\n uuid: string;\n currentUrl: string;\n}) {\n const [copied, setCopied] = useState(false);\n\n const id = uuid.replace(\"cipher-\", \"\");\n const handleCopy = () => {\n navigator.clipboard.writeText(currentUrl).then(() => {\n setCopied(true);\n setTimeout(() => setCopied(false), 2000);\n });\n };\n\n return (\n <>\n \n \n Game ID: {id}\n window.location.reload()}\n title=\"Reload to get the latest cipher encoding\"\n style={{\n background: \"none\",\n border: \"1px solid #aaa\",\n borderRadius: \"4px\",\n cursor: \"pointer\",\n fontSize: \"1em\",\n lineHeight: \"1\",\n padding: \"1px 5px\",\n color: \"#555\",\n }}\n >\n ↻\n \n \n {!isMobileNative() && (\n <>\n

\n Competing against friends? Send them this link to solve the same\n problem:\n

\n \n \n \n {copied ? \"✓ Copied!\" : \"📋 Copy\"}\n \n \n \n )}\n \n );\n}\n",[388],"b69eb766-2fe2-11f1-8b64-42dde27851f2","GameActivity.tsx","fdd2853a-2fde-11f1-aa06-42dde27851f2",["D",1775278619795],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { useEffect, useState } from \"https://esm.sh/react@18.2.0\";\n\ninterface GameLog {\n log: string;\n createdAt: string;\n}\n\ninterface NextGame {\n gameId: string;\n playerName: string;\n}\n\ninterface ParsedLogs {\n players: string[];\n completed: string[];\n nextGames: NextGame[];\n}\n\nfunction parseLogs(logs: GameLog[]): ParsedLogs {\n const players: string[] = [];\n const completed: string[] = [];\n const nextGames: NextGame[] = [];\n const seenPlayers = new Set();\n const seenNextGameIds = new Set();\n\n for (const entry of logs) {\n const log = typeof entry.log === \"string\" ? entry.log : \"\";\n if (!log) continue;\n\n // Players who started the game\n const playerMatch = log.match(/🎮 (.+) started the game/);\n if (playerMatch && !seenPlayers.has(playerMatch[1])) {\n seenPlayers.add(playerMatch[1]);\n players.push(playerMatch[1]);\n }\n\n if (log.includes(\"⭐️\") || log.includes(\"💀\")) {\n completed.push(log);\n }\n\n const nextMatch = log.match(/🔗 (.+) created a new game: (\\d+)/);\n if (nextMatch && !seenNextGameIds.has(nextMatch[2])) {\n seenNextGameIds.add(nextMatch[2]);\n nextGames.push({ playerName: nextMatch[1], gameId: nextMatch[2] });\n }\n }\n\n return { players, completed, nextGames };\n}\n\nexport function GameActivity({ uuid }: { uuid: string }) {\n const [players, setPlayers] = useState([]);\n const [completed, setCompleted] = useState([]);\n const [nextGames, setNextGames] = useState([]);\n\n useEffect(() => {\n const fetchLogs = async () => {\n try {\n const response = await fetch(\n `https://simplevalueapi.val.run/getLogs?id=${uuid}`\n );\n const data = await response.json();\n if (data.logs && Array.isArray(data.logs)) {\n const parsed = parseLogs(data.logs);\n setPlayers(parsed.players);\n setCompleted(parsed.completed);\n setNextGames(parsed.nextGames);\n }\n } catch {\n // silently fail\n }\n };\n\n fetchLogs();\n const interval = setInterval(fetchLogs, 5000);\n return () => clearInterval(interval);\n }, [uuid]);\n\n if (players.length === 0 && completed.length === 0 && nextGames.length === 0) return null;\n\n return (\n \n {players.length > 0 && (\n

\n 🎮 {players.join(\", \")} started the game\n

\n )}\n {completed.map((text, i) => (\n

\n {text}\n

\n ))}\n {nextGames.length > 0 && (\n

0 || players.length > 0 ? \"8px\" : \"0\" }}>\n {nextGames.map((ng, i) => (\n

\n 🔗 {ng.playerName} created{\" \"}\n \n Game {ng.gameId}\n \n

\n ))}\n

\n )}\n \n );\n}\n",[396],"49464b82-1045-11f1-97d3-42dde27851f2","CipherModeSelector.tsx","463fbdee-1043-11f1-9c5b-42dde27851f2",["D",1771802519305],"/** @jsxImportSource https://esm.sh/react@18.2.0 */\n\nexport const CIPHER_MODES = [\n { id: \"random\", label: \"Random Encryption\" },\n { id: \"caesar\", label: \"Caesar\" },\n { id: \"random_aristocrat\", label: \"Random Aristocrat\" },\n { id: \"k1_aristocrat\", label: \"K1 Aristocrat\" },\n { id: \"k2_aristocrat\", label: \"K2 Aristocrat\" },\n { id: \"k1_patristocrat\", label: \"K1 Patristocrat\" },\n { id: \"k2_patristocrat\", label: \"K2 Patristocrat\" },\n] as const;\n\nexport type CipherModeId = (typeof CIPHER_MODES)[number][\"id\"];\n\nexport function CipherModeSelector({\n selectedMode,\n onModeChange,\n}: {\n selectedMode: CipherModeId;\n onModeChange: (mode: CipherModeId) => void;\n}) {\n return (\n

\n \n {CIPHER_MODES.map((mode, index) => {\n const cipherLoaded = selectedMode !== \"random\";\n const isHeader = mode.id === \"random\" && cipherLoaded;\n const label = isHeader ? \"Change Encryption\" : mode.label;\n return (\n onModeChange(mode.id)}\n style={{\n padding: \"11px 10px\",\n backgroundColor: \"white\",\n cursor: isHeader ? \"default\" : \"pointer\",\n whiteSpace: \"nowrap\",\n borderBottom:\n index < CIPHER_MODES.length - 1 ? \"1px solid #e0e0e0\" : \"none\",\n color: isHeader\n ? \"#888\"\n : selectedMode === mode.id\n ? \"#1C50FF\"\n : \"#000\",\n fontWeight: !isHeader && selectedMode === mode.id ? \"bold\" : \"normal\",\n }}\n >\n {label}\n

\n );\n })}\n \n \n );\n}\n",[402],"b69dead4-2fe2-11f1-8b64-42dde27851f2","App.tsx","d41a0f68-4422-11f0-89d5-76b3cceeab13",["D",1775278619795],81,"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport React, {\n createRef,\n useEffect,\n useRef,\n useState,\n} from \"https://esm.sh/react@18.2.0\";\nimport { AnotherRound } from \"./AnotherRound.tsx\";\nimport { isMobileNative, sendBridgeMessage } from \"./bridge.ts\";\nimport { getCipherName } from \"./cipherHelpers.ts\";\nimport { CipherModeSelector, type CipherModeId } from \"./CipherModeSelector.tsx\";\nimport { GameActivity } from \"./GameActivity.tsx\";\nimport {\n addRecentGameId,\n appendToLocalStorage,\n getRecentGameIds,\n isTextKnown,\n present,\n startNewGame,\n} from \"./gameHelpers.ts\";\nimport { GameLink } from \"./GameLink.tsx\";\nimport { KnownTextWarning } from \"./KnownTextWarning.tsx\";\nimport { Loading } from \"./Loading.tsx\";\nimport { misspellSentence } from \"./misspellHelpers.ts\";\nimport { post } from \"./networkHelpers.ts\";\nimport { Notice } from \"./Notice.tsx\";\nimport { fetchQuote } from \"./quoteService.ts\";\nimport {\n randomSubstitutionMap,\n substitutionAndReverseMaps,\n substitutionEncode,\n} from \"./substitutionCipher.ts\";\nimport { generateHint, randomLetter } from \"./wordHelpers.ts\";\n\n// ── Cipher mode helpers ──────────────────────────────────────────────────────\n\nfunction getSelectedModeFromCipher(\n cipher: ReturnType\n): CipherModeId {\n if (\n cipher.type === \"k1\" &&\n cipher.keyword === \"\" &&\n cipher.groupingType === \"aristocrat\"\n )\n return \"caesar\";\n if (cipher.type === \"random\" && cipher.groupingType === \"aristocrat\")\n return \"random_aristocrat\";\n if (cipher.type === \"k1\" && cipher.groupingType === \"aristocrat\")\n return \"k1_aristocrat\";\n if (cipher.type === \"k2\" && cipher.groupingType === \"aristocrat\")\n return \"k2_aristocrat\";\n if (cipher.type === \"k1\" && cipher.groupingType === \"patristocrat\")\n return \"k1_patristocrat\";\n if (cipher.type === \"k2\" && cipher.groupingType === \"patristocrat\")\n return \"k2_patristocrat\";\n return \"random\";\n}\n\nfunction extractKeywordFromText(text: string): string {\n const words = text\n .toUpperCase()\n .replace(/[^A-Z ]/g, \" \")\n .split(/\\s+/)\n .filter(Boolean);\n const longWords = words.filter((w) => w.length >= 4);\n if (longWords.length > 0)\n return longWords[Math.floor(Math.random() * longWords.length)];\n return words[0] || \"WORD\";\n}\n\nfunction getModeParamsForMode(\n mode: CipherModeId,\n cipher: ReturnType\n): { type: \"k1\" | \"k2\" | \"random\"; groupingType: \"aristocrat\" | \"patristocrat\"; keyword: string } {\n const keyword =\n cipher.keyword && cipher.keyword.length >= 4\n ? cipher.keyword\n : extractKeywordFromText(cipher.original);\n switch (mode) {\n case \"caesar\":\n return { type: \"k1\", groupingType: \"aristocrat\", keyword: \"\" };\n case \"random_aristocrat\":\n return { type: \"random\", groupingType: \"aristocrat\", keyword: \"\" };\n case \"k1_aristocrat\":\n return { type: \"k1\", groupingType: \"aristocrat\", keyword };\n case \"k2_aristocrat\":\n return { type: \"k2\", groupingType: \"aristocrat\", keyword };\n case \"k1_patristocrat\":\n return { type: \"k1\", groupingType: \"patristocrat\", keyword };\n case \"k2_patristocrat\":\n return { type: \"k2\", groupingType: \"patristocrat\", keyword };\n default:\n return {\n type: cipher.type,\n groupingType: cipher.groupingType,\n keyword: cipher.keyword,\n };\n }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport function App({ uuid }: { uuid: string }) {\n const [name, setName] = useState(localStorage.getItem(\"name\"));\n const [hardMode, setHardMode] = useState(\n localStorage.getItem(\"hardMode\") === \"true\"\n );\n const [cipher, setCipher] = useState | null>(null);\n const [originalQuote, setOriginalQuote] = useState(null);\n const [decryptionAttempt, setDecryptionAttempt] = useState([]);\n const [startTime, setStartTime] = useState(null);\n const [solveTime, setSolveTime] = useState(null);\n const [isCorrect, setIsCorrect] = useState(null);\n const [hintCount, setHintCount] = useState(0);\n const [keywordRevealed, setKeywordRevealed] = useState(false);\n const [quoteAuthor, setQuoteAuthor] = useState(null);\n const [isLoading, setIsLoading] = useState(true);\n const [loadingError, setLoadingError] = useState(\"\");\n const [isRevealed, setIsRevealed] = useState(false);\n const [currentFocusIndex, setCurrentFocusIndex] = useState(\n null\n );\n const inputRefs = useRef[]>([]);\n const [knownTexts, setKnownTexts] = useState([]);\n const [selectedCipherMode, setSelectedCipherMode] = useState(\"random\");\n // Ref so the loadGame closure can read the latest selection without a re-render dependency\n const selectedCipherModeRef = useRef(\"random\");\n\n const currentUrl = `${window.location.origin}/${uuid.replace(\"cipher-\", \"\")}`;\n // present(`uuid: ${uuid}, currentUrl: ${currentUrl} window.location.origin: ${window.location.origin}`);\n window.history.pushState({}, \"\", currentUrl);\n\n if (window.WebNativeBridge) {\n window.WebNativeBridge.nativeToWeb = (data: any) => {\n if (data.action === \"startNewGame\") {\n startNewGame(uuid);\n }\n };\n }\n\n useEffect(() => {\n async function loadGame() {\n const result = await fetchQuote(uuid);\n\n setKnownTexts(result.knownTexts);\n\n if (result.error) {\n setLoadingError(result.error);\n setIsLoading(false);\n return;\n }\n\n if (result.cipher) {\n // Loading is done — now check if the user pre-selected a specific mode\n // while waiting. Apply it immediately (fast, client-side re-encode only).\n let finalCipher = result.cipher;\n const pendingMode = selectedCipherModeRef.current;\n if (pendingMode !== \"random\") {\n const loadedMode = getSelectedModeFromCipher(result.cipher);\n if (pendingMode !== loadedMode) {\n const { type, groupingType, keyword } = getModeParamsForMode(\n pendingMode,\n result.cipher\n );\n finalCipher = substitutionEncode({\n plainText: result.cipher.original,\n keyword,\n positionLetter: randomLetter(),\n type,\n groupingType,\n });\n if (groupingType === \"aristocrat\") {\n finalCipher.misspelledOriginal = misspellSentence(\n result.cipher.original\n );\n }\n // Background-save the new encoding so other users get the same mode\n if (uuid) {\n post(\"https://simplevalueapi.val.run/setValue\", {\n id: uuid,\n value: { cipher: finalCipher, author: result.author },\n });\n }\n }\n }\n\n // Reflect the actual cipher mode in the selector\n const actualMode = getSelectedModeFromCipher(finalCipher);\n setSelectedCipherMode(actualMode);\n selectedCipherModeRef.current = actualMode;\n\n setCipher(finalCipher);\n setQuoteAuthor(result.author);\n // Store the original quote before any misspelling is applied\n setOriginalQuote(finalCipher.original);\n\n // Initialize decryption attempt with empty strings (only for letters)\n const lettersOnly = finalCipher.encoded.replace(/[^A-Z]/g, \"\");\n const initialAttempt = lettersOnly.split(\"\").map(() => \"\");\n setDecryptionAttempt(initialAttempt);\n\n // Create refs for each input (only for letters)\n inputRefs.current = initialAttempt.map(() => createRef());\n }\n\n // If this is a new game for the user, propagate to all previous games\n const playerName = localStorage.getItem(\"name\");\n const recentGames = getRecentGameIds();\n if (playerName && !recentGames.includes(uuid)) {\n const gameNumber = uuid.replace(\"cipher-\", \"\");\n for (const oldGameId of recentGames) {\n post(\"https://simplevalueapi.val.run/addLog\", {\n id: oldGameId,\n log: `🔗 ${playerName} created a new game: ${gameNumber}`,\n });\n }\n }\n addRecentGameId(uuid);\n\n setIsLoading(false);\n }\n\n loadGame();\n }, []); // Only load once on mount\n\n // Add Enter key listener for submitting the game\n useEffect(() => {\n const handleKeyPress = (event: KeyboardEvent) => {\n // Only allow Enter to submit when game is active and not yet completed\n if (\n event.key === \"Enter\" &&\n startTime !== null &&\n !isRevealed &&\n !isCorrect\n ) {\n // Blur the active element to dismiss keyboard\n if (document.activeElement instanceof HTMLElement) {\n document.activeElement.blur();\n }\n handleSubmit();\n }\n };\n\n window.addEventListener(\"keydown\", handleKeyPress);\n return () => {\n window.removeEventListener(\"keydown\", handleKeyPress);\n };\n }, [startTime, isRevealed, isCorrect, decryptionAttempt]);\n\n const handleStartGame = () => {\n if (!name || !name.trim()) {\n return;\n }\n localStorage.setItem(\"name\", name ?? \"\");\n\n // Log that this player started the game\n if (uuid) {\n post(\"https://simplevalueapi.val.run/addLog\", {\n id: uuid,\n log: `🎮 ${name.trim()} started the game`,\n });\n }\n\n // Apply hard mode modifications\n if (hardMode && cipher) {\n if (cipher.groupingType === \"aristocrat\") {\n // For aristocrat: apply misspelling\n // Use pre-generated misspelled version if available (for consistency)\n // Otherwise generate on-the-fly (for backwards compatibility with old saved games)\n const misspelledText = cipher.misspelledOriginal || misspellSentence(cipher.original);\n const misspelledCipher = substitutionEncode({\n plainText: misspelledText,\n keyword: cipher.keyword,\n positionLetter: cipher.positionLetter,\n type: cipher.type,\n groupingType: cipher.groupingType,\n // IMPORTANT: Reuse the existing substitution map to ensure consistency\n // This prevents the bug where random type generates a new map\n existingSubstitutionMap: cipher.substitutionMap,\n existingReverseSubstitutionMap: cipher.reverseSubstitutionMap,\n // Pass through the misspelled version\n misspelledOriginal: cipher.misspelledOriginal,\n });\n setCipher(misspelledCipher);\n\n // Re-initialize decryption attempt with the misspelled cipher\n const lettersOnly = misspelledCipher.encoded.replace(/[^A-Z]/g, \"\");\n const initialAttempt = lettersOnly.split(\"\").map(() => \"\");\n setDecryptionAttempt(initialAttempt);\n inputRefs.current = initialAttempt.map(() => createRef());\n } else if (cipher.groupingType === \"patristocrat\") {\n // For patristocrat: reduce hint from 4 letters to 2 letters\n const hintInfo = generateHint(cipher.original, 2);\n setCipher({\n ...cipher,\n hint: hintInfo.hint,\n hintSource: hintInfo.source,\n });\n }\n }\n\n setStartTime(Date.now());\n };\n\n const handleModeChange = (mode: CipherModeId) => {\n selectedCipherModeRef.current = mode;\n setSelectedCipherMode(mode);\n\n // If cipher isn't loaded yet, the loadGame effect will apply the mode\n // once it finishes — no need to do anything here.\n if (!cipher || mode === \"random\") return;\n\n const currentMode = getSelectedModeFromCipher(cipher);\n if (mode === currentMode) return; // Already the requested mode\n\n // Re-encode client-side (fast — no network wait)\n const { type, groupingType, keyword } = getModeParamsForMode(mode, cipher);\n const newCipher = substitutionEncode({\n plainText: cipher.original,\n keyword,\n positionLetter: randomLetter(),\n type,\n groupingType,\n });\n if (groupingType === \"aristocrat\") {\n newCipher.misspelledOriginal = misspellSentence(cipher.original);\n }\n\n // Reset decryption attempt for the new encoding\n const lettersOnly = newCipher.encoded.replace(/[^A-Z]/g, \"\");\n const initialAttempt = lettersOnly.split(\"\").map(() => \"\");\n setDecryptionAttempt(initialAttempt);\n inputRefs.current = initialAttempt.map(() => createRef());\n\n setCipher(newCipher);\n\n // Background-save so other users on the same link get the new mode too\n if (uuid) {\n post(\"https://simplevalueapi.val.run/setValue\", {\n id: uuid,\n value: { cipher: newCipher, author: quoteAuthor },\n });\n }\n };\n\n const handleLetterChange = (letterIndex: number, value: string) => {\n if (!cipher) return;\n\n const newAttempt = [...decryptionAttempt];\n const uppercaseValue = value.toUpperCase();\n\n // If the value is a letter, autofill all matching encoded letters\n if (/^[A-Z]$/.test(uppercaseValue)) {\n newAttempt[letterIndex] = uppercaseValue;\n\n // Get the encoded letter at this letter-only index\n const encodedLettersOnly = cipher.encoded.replace(/[^A-Z]/g, \"\");\n const encodedLetter = encodedLettersOnly[letterIndex];\n\n // Find all indices of the same encoded letter and fill them\n encodedLettersOnly.split(\"\").forEach((letter, idx) => {\n if (letter === encodedLetter) {\n newAttempt[idx] = uppercaseValue;\n }\n });\n\n // Find the next unfilled input and focus it\n const nextUnfilledIndex = newAttempt.findIndex(\n (letter, i) => letter === \"\" && i > letterIndex\n );\n if (\n nextUnfilledIndex !== -1 &&\n inputRefs.current[nextUnfilledIndex]?.current\n ) {\n inputRefs.current[nextUnfilledIndex].current?.focus();\n } else {\n // find the first unfilled input and focus it\n const firstUnfilledIndex = newAttempt.findIndex(\n (letter) => letter === \"\"\n );\n if (\n firstUnfilledIndex !== -1 &&\n inputRefs.current[firstUnfilledIndex]?.current\n ) {\n inputRefs.current[firstUnfilledIndex].current?.focus();\n }\n }\n }\n\n setDecryptionAttempt(newAttempt);\n };\n\n const handleKeyDown = (\n letterIndex: number,\n event: React.KeyboardEvent\n ) => {\n if (!cipher) return;\n\n // Handle letter key press - if field is already filled, clear it first to allow replacement\n if (/^[a-zA-Z]$/.test(event.key) && decryptionAttempt[letterIndex]) {\n event.preventDefault(); // Prevent default to handle manually\n \n const encodedLettersOnly = cipher.encoded.replace(/[^A-Z]/g, \"\");\n const encodedLetter = encodedLettersOnly[letterIndex];\n const newAttempt = [...decryptionAttempt];\n const uppercaseValue = event.key.toUpperCase();\n \n // Clear all instances of the old letter first\n encodedLettersOnly.split(\"\").forEach((letter, idx) => {\n if (letter === encodedLetter) {\n newAttempt[idx] = \"\";\n }\n });\n \n // Now set all instances to the new letter\n encodedLettersOnly.split(\"\").forEach((letter, idx) => {\n if (letter === encodedLetter) {\n newAttempt[idx] = uppercaseValue;\n }\n });\n \n setDecryptionAttempt(newAttempt);\n \n // Find the next unfilled input and focus it\n const nextUnfilledIndex = newAttempt.findIndex(\n (letter, i) => letter === \"\" && i > letterIndex\n );\n if (\n nextUnfilledIndex !== -1 &&\n inputRefs.current[nextUnfilledIndex]?.current\n ) {\n inputRefs.current[nextUnfilledIndex].current?.focus();\n } else {\n // find the first unfilled input and focus it\n const firstUnfilledIndex = newAttempt.findIndex(\n (letter) => letter === \"\"\n );\n if (\n firstUnfilledIndex !== -1 &&\n inputRefs.current[firstUnfilledIndex]?.current\n ) {\n inputRefs.current[firstUnfilledIndex].current?.focus();\n }\n }\n \n return; // Exit early since we handled the key press\n }\n\n // Handle backspace to clear all instances of the letter or move to previous input\n if (event.key === \"Backspace\") {\n const encodedLettersOnly = cipher.encoded.replace(/[^A-Z]/g, \"\");\n // If current input is empty, move to previous input and delete its letter\n if (!decryptionAttempt[letterIndex]) {\n if (letterIndex > 0) {\n const prevIndex = letterIndex - 1;\n const newAttempt = [...decryptionAttempt];\n\n // Remove the letter from the previous input\n const encodedLetterToRemove = encodedLettersOnly[prevIndex];\n newAttempt[prevIndex] = \"\";\n\n // Remove the same letter from all other inputs\n const updatedAttempt = newAttempt.map((letter, idx) =>\n encodedLettersOnly[idx] === encodedLetterToRemove ? \"\" : letter\n );\n\n setDecryptionAttempt(updatedAttempt);\n\n // Focus the previous input\n inputRefs.current[prevIndex].current?.focus();\n }\n } else {\n // If current input is not empty, clear all instances of its letter\n const encodedLetterToRemove = encodedLettersOnly[letterIndex];\n const newAttempt = decryptionAttempt.map((letter, idx) =>\n encodedLettersOnly[idx] === encodedLetterToRemove ? \"\" : letter\n );\n\n setDecryptionAttempt(newAttempt);\n\n // Focus the current input after clearing\n inputRefs.current[letterIndex].current?.focus();\n }\n }\n };\n\n const handleClear = async () => {\n if (cipher) {\n // Only create entries for letters (not punctuation)\n const lettersOnly = cipher.encoded.replace(/[^A-Z]/g, \"\");\n const initialAttempt = lettersOnly.split(\"\").map(() => \"\");\n setDecryptionAttempt(initialAttempt);\n }\n };\n const handleSubmit = async () => {\n if (isRevealed || isCorrect) {\n return;\n }\n\n // if there is empty letter in decryptionAttempt, return\n if (decryptionAttempt.some((letter) => letter === \"\")) {\n present(\"😾 Not completed yet\");\n return;\n }\n if (cipher) {\n // Remove spaces from the encoded message to match decryption attempt\n const cleanEncoded = cipher.encoded.replace(/\\s/g, \"\");\n\n // Translate the decryption attempt back to original letters\n const translatedAttempt = decryptionAttempt.join(\"\");\n const isMatch = translatedAttempt === cipher.cleanOriginal;\n\n setIsCorrect(isMatch);\n\n if (isMatch && startTime) {\n const timeTaken = Math.round((Date.now() - startTime) / 1000);\n setSolveTime(timeTaken);\n\n // Use the original quote (before misspelling) for saving\n appendToLocalStorage(originalQuote || cipher.original, quoteAuthor);\n\n if (uuid && name) {\n await post(\"https://simplevalueapi.val.run/addLog\", {\n id: uuid,\n log: `⭐️ ${name} completed the mission. Time: ${timeTaken} seconds. Hints: ${hintCount}. Keyword needed: ${\n keywordRevealed ? \"yes\" : \"no\"\n }${hardMode ? \". ⚔️ Hard Mode ✔️ ⚔️\" : \"\"}`,\n });\n void sendBridgeMessage({\n action: \"finish\",\n data: {\n uuid,\n success: true,\n timeTaken,\n hintCount,\n keywordRevealed,\n hardMode,\n },\n });\n }\n }\n if (!isMatch && uuid && name) {\n await post(\"https://simplevalueapi.val.run/addLog\", {\n id: uuid,\n log: `❌ ${name} submitted an incorrect answer. Hints so far: ${hintCount}. Keyword used: ${\n keywordRevealed ? \"yes\" : \"no\"\n }${hardMode ? \". ⚔️ Hard Mode ✔️ ⚔️\" : \"\"}`,\n });\n }\n }\n };\n\n const handleRevealAnswer = async () => {\n if (isCorrect) {\n return;\n }\n if (cipher && startTime) {\n const revealedAttempt = cipher.cleanOriginal.split(\"\");\n const timeTaken = Math.round((Date.now() - startTime) / 1000);\n setDecryptionAttempt(revealedAttempt);\n setIsRevealed(true);\n // Use the original quote (before misspelling) for saving\n appendToLocalStorage(originalQuote || cipher.original, quoteAuthor);\n if (uuid && name) {\n const writeResult = await post(\n \"https://simplevalueapi.val.run/addLog\",\n {\n id: uuid,\n log: `💀 ${name} abandoned the mission. Time: ${timeTaken} seconds. Hints: ${hintCount}. Keyword needed: ${\n keywordRevealed ? \"yes\" : \"no\"\n }${hardMode ? \". ⚔️ Hard Mode ✔️ ⚔️\" : \"\"}`,\n }\n );\n void sendBridgeMessage({\n action: \"finish\",\n data: {\n uuid,\n success: false,\n timeTaken,\n hintCount,\n keywordRevealed,\n hardMode,\n },\n });\n }\n }\n };\n\n const handleRevealKeyword = () => {\n if (cipher) {\n if (cipher.type === \"random\") {\n present(\"It's a random substitution cipher. There is no keyword.\");\n } else if (\n cipher.type === \"k1\" &&\n cipher.keyword === \"\" &&\n cipher.groupingType === \"aristocrat\"\n ) {\n const shift = cipher.positionLetter.charCodeAt(0) - 65;\n present(`It's a Caesar cipher with shift ${shift}`);\n setKeywordRevealed(true);\n } else {\n present(`The keyword is ${cipher.keyword}`);\n setKeywordRevealed(true);\n }\n }\n };\n\n const handleRevealAuthor = () => {\n if (quoteAuthor) {\n present(`The author is ${quoteAuthor}`);\n } else {\n present(`No author for this`);\n }\n };\n\n const handleHintType = () => {\n if (isCorrect || isRevealed) {\n return;\n }\n if (cipher && currentFocusIndex !== null) {\n // Get the original letter for the current encoded letter\n const encodedLettersOnly = cipher.encoded.replace(/[^A-Z]/g, \"\");\n const encodedLetter = encodedLettersOnly[currentFocusIndex];\n const originalLetter =\n Object.entries(cipher.reverseSubstitutionMap).find(\n ([encoded]) => encoded === encodedLetter\n )?.[1] || \"\";\n\n if (originalLetter) {\n const newAttempt = [...decryptionAttempt];\n newAttempt[currentFocusIndex] = originalLetter;\n\n // Fill all matching encoded letters\n decryptionAttempt.forEach((letter, idx) => {\n if (encodedLettersOnly[idx] === encodedLetter) {\n newAttempt[idx] = originalLetter;\n }\n });\n\n setDecryptionAttempt(newAttempt);\n setHintCount(hintCount + 1);\n // Find the next unfilled input and focus it\n const nextUnfilledIndex = newAttempt.findIndex(\n (letter, i) => letter === \"\" && i > currentFocusIndex\n );\n if (\n nextUnfilledIndex !== -1 &&\n inputRefs.current[nextUnfilledIndex]?.current\n ) {\n inputRefs.current[nextUnfilledIndex].current?.focus();\n }\n }\n }\n };\n\n const isDuplicated = (encodedLetter: string) => {\n if (!cipher) return false;\n const encodedLettersOnly = cipher.encoded.replace(/[^A-Z]/g, \"\");\n let attemptForLetter = \"\";\n for (const index in decryptionAttempt) {\n if (\n encodedLettersOnly[index] === encodedLetter &&\n decryptionAttempt[index] !== \"\"\n ) {\n attemptForLetter = decryptionAttempt[index];\n break;\n }\n }\n for (const index in decryptionAttempt) {\n // if another encoded letter also uses attemptForLetter\n if (\n decryptionAttempt[index] !== \"\" &&\n encodedLettersOnly[index] !== encodedLetter &&\n decryptionAttempt[index] === attemptForLetter\n ) {\n return true;\n }\n }\n return false;\n };\n\n const attemptedOriginalFor = (encodedLetter: string) => {\n if (!cipher) return \"\";\n const encodedLettersOnly = cipher.encoded.replace(/[^A-Z]/g, \"\");\n for (const index in decryptionAttempt) {\n if (\n encodedLettersOnly[index] === encodedLetter &&\n decryptionAttempt[index] !== \"\"\n ) {\n return decryptionAttempt[index];\n }\n }\n return \"?\";\n };\n\n const attemptedEncodedFor = (originalLetter: string) => {\n if (!cipher) return \"\";\n const encodedLettersOnly = cipher.encoded.replace(/[^A-Z]/g, \"\");\n for (const index in decryptionAttempt) {\n if (decryptionAttempt[index] === originalLetter) {\n return encodedLettersOnly[index];\n }\n }\n return \"?\";\n };\n\n // Helper: Get the visual position (including punctuation) in the encoded string\n const visualIndexFor = (groupIndex: number, indexInGroup: number): number => {\n if (!cipher) return 0;\n let index = 0;\n let words = cipher.encoded.split(/\\s+/); // Split by all whitespace (spaces, newlines, tabs)\n for (let i = 0; i < groupIndex; i += 1) {\n index += words[i].length;\n }\n return index + indexInGroup;\n };\n\n // Helper: Convert visual position to letter-only index in decryptionAttempt\n const letterIndexFromVisual = (visualIndex: number): number => {\n if (!cipher) return 0;\n const encodedWithoutSpaces = cipher.encoded.replace(/\\s/g, \"\");\n let letterCount = 0;\n for (let i = 0; i < visualIndex && i < encodedWithoutSpaces.length; i++) {\n if (/[A-Z]/.test(encodedWithoutSpaces[i])) {\n letterCount++;\n }\n }\n return letterCount;\n };\n\n // Helper: Check if a character at visual position is a letter\n const isLetterAtVisual = (\n groupIndex: number,\n indexInGroup: number\n ): boolean => {\n if (!cipher) return false;\n const words = cipher.encoded.split(/\\s+/); // Split by all whitespace (spaces, newlines, tabs)\n if (groupIndex >= words.length) return false;\n const char = words[groupIndex][indexInGroup];\n return /[A-Z]/.test(char);\n };\n\n return (\n <>\n \n {isLoading ? (\n <>\n \n \n \n \n \n ) : !cipher ? (\n

\n {`Something unexpected happened: ${loadingError}`}\n

\n ) : (\n \n {!isMobileNative() && (\n

\n Cipher Challenge 🕵️\n

\n )}\n\n {cipher &&\n startTime === null &&\n isTextKnown(cipher.original, quoteAuthor, knownTexts) && (\n \n )}\n\n {startTime !== null && (\n

\n \n \n \n {cipher.encoded.split(/\\s+/).map((group, groupIndex) => (\n \n \n {group.split(\"\").map((char, charIndex) => {\n const isLetter = /[A-Z]/.test(char);\n return (\n \n {char}\n {isLetter && (\n \n {cipher?.encodedLetterCounts[\n char\n ].toString() ?? \"\"}\n \n )}\n

\n );\n })}\n \n \n {group.split(\"\").map((char, charIndex) => {\n const isLetter = isLetterAtVisual(\n groupIndex,\n charIndex\n );\n const visualIdx = visualIndexFor(\n groupIndex,\n charIndex\n );\n const letterIdx = letterIndexFromVisual(visualIdx);\n\n if (!isLetter) {\n // Render punctuation/non-letter as plain text\n return (\n \n {char}\n \n );\n }\n\n // Render input for letters\n return (\n \n handleLetterChange(letterIdx, e.target.value)\n }\n onKeyDown={(e) => handleKeyDown(letterIdx, e)}\n onFocus={() => setCurrentFocusIndex(letterIdx)}\n style={{\n width: \"var(--char-width)\",\n height: \"var(--char-height)\",\n textAlign: \"center\",\n textTransform: \"uppercase\",\n backgroundColor: \"#e0e0e0\",\n fontSize: \"var(--font-size-base)\",\n padding: \"0\",\n border: \"1px solid #ccc\",\n boxSizing: \"border-box\",\n lineHeight: \"normal\",\n verticalAlign: \"middle\",\n }}\n />\n );\n })}\n \n \n ))}\n \n \n \n\n {cipher.hint && (\n \n {cipher.hintSource === \"first\"\n ? \"Beginning of the quote\"\n : \"End of the quote\"}\n : {cipher.hint}\n \n )}\n\n

\n \n {getCipherName(\n cipher.type,\n cipher.keyword,\n cipher.groupingType\n )}\n {\" \"}\n → original:\n
\n {cipher.type !== \"k2\"\n ? \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n .split(\"\")\n .map((letter, index) => (\n \n {letter}\n \n {cipher.encodedLetterCounts[letter] ?? 0}\n \n {\"→\"}\n \n {attemptedOriginalFor(letter)}\n \n \n \n ))\n : \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n .split(\"\")\n .map((letter, index) => (\n \n \n {attemptedEncodedFor(letter)}\n \n {\"→\"}\n {letter}\n \n \n ))}\n

\n\n {cipher.type === \"k2\" && (\n

\n Cipher letter frequency:\n
\n {\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n .split(\"\")\n .map((letter, index) => (\n \n {letter}\n {\":\"}\n \n {cipher?.encodedLetterCounts[letter] ?? 0}\n \n \n \n ))}\n

\n )}\n\n {!isMobileNative() && (\n

\n Codebreaker: {name ?? \"\"}\n

\n )}\n \n \n Submit Decryption\n \n \n Clear\n \n \n\n {isCorrect !== null && !isRevealed && (\n \n {isCorrect ? (\n <>\n 🎉 Correct! You solved the cipher in {solveTime} seconds\n with {hintCount} hints and{\" \"}\n {keywordRevealed\n ? \"with the help of the keyword\"\n : \"without peeking the keyword\"}\n .\n
\n Original Quote: \"{originalQuote || cipher.original}\"\n {quoteAuthor && (\n \n Quote by: {quoteAuthor}\n \n )}\n \n ) : (\n \"Incorrect. Try again! 🤔\"\n )}\n \n )}\n \n )}\n\n {startTime === null && (\n

\n \n \n \n setName(e.target.value)}\n type=\"text\"\n />\n \n START\n \n

\n \n \n {\n const newHardMode = e.target.checked;\n setHardMode(newHardMode);\n localStorage.setItem(\"hardMode\", String(newHardMode));\n }}\n style={{\n width: \"20px\",\n height: \"20px\",\n cursor: \"pointer\",\n }}\n />\n Hard Mode\n \n (\n present(\n \"Hard Mode:\\nIf it's an Aristocrat, some misspellings will be introduced.\\nIf it's a Patristocrat, the hint is reduced.\"\n )\n }\n style={{\n color: \"gray\",\n textDecoration: \"none\",\n cursor: \"pointer\",\n }}\n >\n What is it?\n )\n \n \n )}\n\n \n \n \n\n {startTime !== null && (\n \n \n Reveal Author\n \n \n Reveal Current Letter\n \n \n Reveal Keyword\n \n \n Reveal Entire Answer\n \n \n )}\n\n {isRevealed && (\n \n 🚨 Answer Revealed! Better luck next time. 🚨\n \n )}\n \n )}\n \n );\n}\n",[408],"56e3acc2-ad3e-11f0-a058-0224a6c84d84","App.test.ts","56e3ad8a-ad3e-11f0-a058-0224a6c84d84",510,["D",1760914370552],"import { assertEquals } from \"https://deno.land/std@0.208.0/assert/mod.ts\";\n\n/**\n * Test for the letter filling bug fix in App.tsx\n *\n * Bug Description:\n * When cipher.encoded contains newlines, splitting by space only (\" \")\n * causes newlines to remain in words, leading to misalignment between\n * visual indices and letter indices. This caused incorrect letter filling.\n *\n * Fix:\n * Changed all instances of .split(\" \") to .split(/\\s+/) to properly\n * split by all whitespace characters (spaces, newlines, tabs).\n */\n\nDeno.test(\n \"visualIndexFor handles newlines correctly (bug from game 794496)\",\n () => {\n // Real scenario from the bug report\n const encoded = \"DBEQ,\\nNXP LD WECD\";\n\n // Fixed implementation\n const visualIndexFor = (\n groupIndex: number,\n indexInGroup: number\n ): number => {\n let index = 0;\n let words = encoded.split(/\\s+/); // Split by all whitespace\n for (let i = 0; i < groupIndex; i += 1) {\n index += words[i].length;\n }\n return index + indexInGroup;\n };\n\n const letterIndexFromVisual = (visualIndex: number): number => {\n const encodedWithoutSpaces = encoded.replace(/\\s/g, \"\");\n let letterCount = 0;\n for (let i = 0; i < visualIndex && i < encodedWithoutSpaces.length; i++) {\n if (/[A-Z]/.test(encodedWithoutSpaces[i])) {\n letterCount++;\n }\n }\n return letterCount;\n };\n\n const isLetterAtVisual = (\n groupIndex: number,\n indexInGroup: number\n ): boolean => {\n const words = encoded.split(/\\s+/); // Split by all whitespace\n if (groupIndex >= words.length) return false;\n const char = words[groupIndex][indexInGroup];\n return /[A-Z]/.test(char);\n };\n\n const encodedLettersOnly = encoded.replace(/[^A-Z]/g, \"\");\n const words = encoded.split(/\\s+/);\n\n // Test all letter positions\n let allCorrect = true;\n words.forEach((group, groupIndex) => {\n group.split(\"\").forEach((char, charIndex) => {\n const isLetter = isLetterAtVisual(groupIndex, charIndex);\n if (isLetter) {\n const visualIdx = visualIndexFor(groupIndex, charIndex);\n const letterIdx = letterIndexFromVisual(visualIdx);\n const actualLetter = encodedLettersOnly[letterIdx];\n\n if (char !== actualLetter) {\n console.error(\n `Mismatch at group ${groupIndex}, char ${charIndex}: ` +\n `expected '${char}', got '${actualLetter}'`\n );\n allCorrect = false;\n }\n }\n });\n });\n\n assertEquals(allCorrect, true, \"All letters should match their indices\");\n }\n);\n\nDeno.test(\"letter filling works correctly across newlines\", () => {\n const encoded = \"ABC,\\nDEF GHI\";\n const encodedLettersOnly = encoded.replace(/[^A-Z]/g, \"\"); // \"ABCDEFGHI\"\n\n // Simulate filling letter 'D' (index 3) with 'X'\n const decryptionAttempt = encodedLettersOnly.split(\"\").map(() => \"\");\n const letterToFill = 3; // Position of 'D' in \"ABCDEFGHI\"\n const valueToFill = \"X\";\n const encodedLetter = encodedLettersOnly[letterToFill]; // 'D'\n\n // Fill all positions where the encoded letter matches\n encodedLettersOnly.split(\"\").forEach((letter, idx) => {\n if (letter === encodedLetter) {\n decryptionAttempt[idx] = valueToFill;\n }\n });\n\n // Only position 3 should be filled (only one 'D' in the string)\n assertEquals(decryptionAttempt[3], \"X\");\n assertEquals(decryptionAttempt[0], \"\"); // 'A' should not be filled\n assertEquals(decryptionAttempt[4], \"\"); // 'E' should not be filled\n});\n\nDeno.test(\n \"whitespace splitting works for various whitespace characters\",\n () => {\n const testCases = [\n { input: \"ABC DEF\", expected: [\"ABC\", \"DEF\"] },\n { input: \"ABC\\nDEF\", expected: [\"ABC\", \"DEF\"] },\n { input: \"ABC\\tDEF\", expected: [\"ABC\", \"DEF\"] },\n { input: \"ABC \\n\\n DEF\", expected: [\"ABC\", \"DEF\"] },\n { input: \"ABC,\\nDEF GHI\", expected: [\"ABC,\", \"DEF\", \"GHI\"] },\n ];\n\n testCases.forEach(({ input, expected }) => {\n const result = input.split(/\\s+/);\n assertEquals(\n result,\n expected,\n `Failed for input: ${JSON.stringify(input)}`\n );\n });\n }\n);\n",[415],"fdd2a164-2fde-11f1-aa06-42dde27851f2","AnotherRound.tsx","7e3ca574-442c-11f0-8338-76b3cceeab13",538,["D",1775277021265],9,"/** @jsxImportSource https://esm.sh/react@18.2.0 */\nimport { isMobileNative } from \"./bridge.ts\";\nimport { startNewGame } from \"./gameHelpers.ts\";\n\nexport function AnotherRound({ uuid }: { uuid: string }) {\n return (\n !isMobileNative() && (\n <>\n \n \n {\n startNewGame(uuid);\n }}\n style={{\n padding: \"10pt\",\n backgroundColor: \"#3572fa\",\n color: \"white\",\n border: \"none\",\n flex: 1,\n fontSize: \"var(--font-size-button)\",\n }}\n >\n New Game\n \n \n \n )\n );\n}\n",[422],"ce832b6c-0ac3-11f1-a72d-42dde27851f2",".vtignore","2975a784-a6e7-11f0-a077-0224a6c84d84",["D",1771197152424],"# don't ignore anything",[430],"2975f0b8-a6e7-11f0-a077-0224a6c84d84",".vscode","0199d51f-481c-713b-a192-42ecc85f9123",["D",1760217221145],[436],"d7161b26-1050-11f1-8238-42dde27851f2",".claude","019c87f4-9f5d-70e6-9200-d0860d53c739",532,["D",1771807481696],[441],"pulls","branches","forks","envVars",{"_453":26,"_455":26},"connections",{"_453":26,"_454":26},"count","unfilledCount","emptyCount",{"_34":440,"_13":441,"_70":442,"_44":-5,"_36":37,"_201":443,"_203":24,"_38":610,"_40":26,"_73":74,"_207":-5,"_75":30,"_209":-5,"_494":611,"_17":612},{"_34":603,"_13":604,"_70":605,"_44":442,"_36":37,"_201":443,"_203":24,"_38":606,"_40":26,"_73":21,"_207":607,"_75":30,"_209":-5,"_494":608,"_17":609},{"_34":435,"_13":436,"_70":437,"_44":-5,"_36":37,"_201":41,"_203":24,"_38":600,"_40":26,"_73":74,"_207":-5,"_75":30,"_209":-5,"_494":601,"_17":602},{"_34":593,"_13":594,"_70":595,"_44":437,"_36":37,"_201":41,"_203":24,"_38":596,"_40":26,"_73":21,"_207":597,"_75":30,"_209":-5,"_494":598,"_17":599},{"_34":429,"_13":430,"_70":431,"_44":-5,"_36":37,"_201":81,"_203":24,"_38":590,"_40":267,"_73":21,"_207":433,"_75":30,"_209":-5,"_494":591,"_17":592},{"_34":421,"_13":422,"_70":423,"_44":-5,"_36":37,"_201":424,"_203":24,"_38":587,"_40":426,"_73":206,"_207":427,"_75":30,"_209":-5,"_494":588,"_17":589},{"_34":414,"_13":415,"_70":416,"_44":-5,"_36":37,"_201":417,"_203":24,"_38":584,"_40":26,"_73":206,"_207":419,"_75":30,"_209":-5,"_494":585,"_17":586},{"_34":407,"_13":408,"_70":409,"_44":-5,"_36":37,"_201":301,"_203":24,"_38":581,"_40":411,"_73":206,"_207":412,"_75":30,"_209":-5,"_494":582,"_17":583},{"_34":401,"_13":402,"_70":403,"_44":-5,"_36":37,"_201":360,"_203":24,"_38":578,"_40":252,"_73":206,"_207":405,"_75":30,"_209":-5,"_494":579,"_17":580},{"_34":395,"_13":396,"_70":397,"_44":-5,"_36":37,"_201":301,"_203":24,"_38":575,"_40":252,"_73":206,"_207":399,"_75":30,"_209":-5,"_494":576,"_17":577},{"_34":387,"_13":388,"_70":389,"_44":-5,"_36":37,"_201":390,"_203":24,"_38":572,"_40":392,"_73":206,"_207":393,"_75":30,"_209":-5,"_494":573,"_17":574},{"_34":380,"_13":381,"_70":382,"_44":-5,"_36":37,"_201":383,"_203":24,"_38":569,"_40":252,"_73":206,"_207":385,"_75":30,"_209":-5,"_494":570,"_17":571},{"_34":373,"_13":374,"_70":375,"_44":-5,"_36":37,"_201":376,"_203":24,"_38":566,"_40":244,"_73":206,"_207":378,"_75":30,"_209":-5,"_494":567,"_17":568},{"_34":365,"_13":366,"_70":367,"_44":-5,"_36":37,"_201":368,"_203":24,"_38":563,"_40":370,"_73":206,"_207":371,"_75":30,"_209":-5,"_494":564,"_17":565},{"_34":357,"_13":358,"_70":359,"_44":-5,"_36":37,"_201":360,"_203":24,"_38":560,"_40":362,"_73":206,"_207":363,"_75":30,"_209":-5,"_494":561,"_17":562},{"_34":351,"_13":352,"_70":353,"_44":-5,"_36":37,"_201":41,"_203":24,"_38":557,"_40":26,"_73":21,"_207":355,"_75":30,"_209":-5,"_494":558,"_17":559},{"_34":345,"_13":346,"_70":347,"_44":-5,"_36":37,"_201":252,"_203":24,"_38":554,"_40":26,"_73":21,"_207":349,"_75":30,"_209":-5,"_494":555,"_17":556},{"_34":339,"_13":340,"_70":341,"_44":-5,"_36":37,"_201":81,"_203":24,"_38":551,"_40":26,"_73":206,"_207":343,"_75":30,"_209":-5,"_494":552,"_17":553},{"_34":331,"_13":332,"_70":333,"_44":-5,"_36":37,"_201":334,"_203":24,"_38":548,"_40":336,"_73":206,"_207":337,"_75":30,"_209":-5,"_494":549,"_17":550},{"_34":325,"_13":326,"_70":327,"_44":-5,"_36":37,"_201":288,"_203":24,"_38":545,"_40":252,"_73":206,"_207":329,"_75":30,"_209":-5,"_494":546,"_17":547},{"_34":319,"_13":320,"_70":321,"_44":-5,"_36":37,"_201":235,"_203":24,"_38":542,"_40":252,"_73":206,"_207":323,"_75":30,"_209":-5,"_494":543,"_17":544},{"_34":312,"_13":313,"_70":314,"_44":-5,"_36":37,"_201":315,"_203":24,"_38":539,"_40":252,"_73":206,"_207":317,"_75":30,"_209":-5,"_494":540,"_17":541},{"_34":305,"_13":306,"_70":307,"_44":-5,"_36":37,"_201":129,"_203":24,"_38":536,"_40":309,"_73":206,"_207":310,"_75":30,"_209":-5,"_494":537,"_17":538},{"_34":298,"_13":299,"_70":300,"_44":-5,"_36":37,"_201":301,"_203":24,"_38":533,"_40":205,"_73":206,"_207":303,"_75":30,"_209":-5,"_494":534,"_17":535},{"_34":292,"_13":293,"_70":294,"_44":-5,"_36":37,"_201":242,"_203":24,"_38":530,"_40":252,"_73":206,"_207":296,"_75":30,"_209":-5,"_494":531,"_17":532},{"_34":285,"_13":286,"_70":287,"_44":-5,"_36":37,"_201":288,"_203":24,"_38":527,"_40":26,"_73":206,"_207":290,"_75":30,"_209":-5,"_494":528,"_17":529},{"_34":276,"_13":277,"_70":104,"_44":-5,"_36":37,"_201":278,"_203":24,"_38":524,"_40":280,"_73":281,"_207":282,"_75":30,"_209":283,"_494":525,"_17":526},{"_34":270,"_13":271,"_70":272,"_44":-5,"_36":37,"_201":202,"_203":24,"_38":521,"_40":244,"_73":206,"_207":274,"_75":30,"_209":-5,"_494":522,"_17":523},{"_34":262,"_13":263,"_70":264,"_44":-5,"_36":37,"_201":265,"_203":24,"_38":518,"_40":267,"_73":206,"_207":268,"_75":30,"_209":-5,"_494":519,"_17":520},{"_34":255,"_13":256,"_70":257,"_44":-5,"_36":37,"_201":258,"_203":24,"_38":515,"_40":26,"_73":206,"_207":260,"_75":30,"_209":-5,"_494":516,"_17":517},{"_34":247,"_13":248,"_70":249,"_44":-5,"_36":37,"_201":250,"_203":24,"_38":512,"_40":252,"_73":206,"_207":253,"_75":30,"_209":-5,"_494":513,"_17":514},{"_34":239,"_13":240,"_70":241,"_44":-5,"_36":37,"_201":242,"_203":24,"_38":509,"_40":244,"_73":206,"_207":245,"_75":30,"_209":-5,"_494":510,"_17":511},{"_34":232,"_13":233,"_70":234,"_44":-5,"_36":37,"_201":235,"_203":24,"_38":506,"_40":26,"_73":21,"_207":237,"_75":30,"_209":-5,"_494":507,"_17":508},{"_34":226,"_13":227,"_70":228,"_44":-5,"_36":37,"_201":41,"_203":24,"_38":503,"_40":26,"_73":206,"_207":230,"_75":30,"_209":-5,"_494":504,"_17":505},{"_34":218,"_13":219,"_70":220,"_44":-5,"_36":37,"_201":221,"_203":24,"_38":500,"_40":223,"_73":206,"_207":224,"_75":30,"_209":-5,"_494":501,"_17":502},{"_34":211,"_13":212,"_70":213,"_44":-5,"_36":37,"_201":214,"_203":24,"_38":497,"_40":26,"_73":206,"_207":216,"_75":30,"_209":-5,"_494":498,"_17":499},{"_34":198,"_13":199,"_70":200,"_44":-5,"_36":37,"_201":202,"_203":24,"_38":493,"_40":205,"_73":206,"_207":208,"_75":30,"_209":-5,"_494":495,"_17":496},["D",1763229308190],"children",[],[199],["D",1763001991791],[],[212],["D",1774143132812],[],[219],["D",1760217221145],[],[227],["D",1760293230598],[],[233],["D",1766904321471],[],[240],["D",1762016258186],[],[248],["D",1749418805397],[],[256],["D",1750634621433],[],[263],["D",1763229308190],[],[271],["D",1763858833829],[],[277],["D",1766775142106],[],[286],["D",1766904321471],[],[293],["D",1775278619795],[],[299],["D",1777157521973],[],[306],["D",1760242229389],[],[313],["D",1760293230598],[],[320],["D",1766775142106],[],[326],["D",1760768921885],[],[332],["D",1771197152424],[],[340],["D",1735608699289],[],[346],["D",1760217221145],[],[352],["D",1771802519305],[],[358],["D",1760241620865],[],[366],["D",1749434757648],[],[374],["D",1749434769089],[],[381],["D",1771801655240],[],[388],["D",1775278619795],[],[396],["D",1771802519305],[],[402],["D",1775278619795],[],[408],["D",1760914370552],[],[415],["D",1775277021265],[],[422],["D",1771197152424],[],[430],"2975a590-a6e7-11f0-a077-0224a6c84d84","extensions.json","2975a5f4-a6e7-11f0-a077-0224a6c84d84",["D",1760217221145],"{\n \"recommendations\": [\n \"denoland.vscode-deno\"\n ]\n}",[],[436,594],["D",1760217221145],[459],[436],"d7161266-1050-11f1-8238-42dde27851f2","settings.json","d716131a-1050-11f1-8238-42dde27851f2",["D",1771807481696],"{\n \"permissions\": {\n \"allow\": [\n \"Bash(node ./analyze_quote.js:*)\",\n \"Bash(node:*)\",\n \"Bash(python3:*)\"\n ]\n }\n}\n",[],[441,604],["D",1771807481696],[457],[441],["D",1746217506027],{"_11":12,"_142":78},{"_11":12,"_138":-5,"_77":78,"_31":76,"_139":140,"_141":30},{"_40":129,"_13":16,"_34":37,"_130":95,"_131":-5,"_132":-5,"_133":-5,"_134":-5,"_135":-5,"_136":14,"_137":12},"ctx",{"_54":-5,"_160":650,"_651":652,"_653":654,"_655":30,"_656":30,"_657":30,"_658":24,"_659":-5,"_660":-7,"_661":-7,"_662":26,"_663":30,"_664":30,"_665":-5,"_666":30,"_667":30,"_668":30,"_669":-5},"ENV",{"_621":622,"_623":624,"_625":16,"_626":627,"_628":629,"_630":631,"_632":633,"_634":635,"_636":637,"_638":639,"_640":641,"_642":643,"_644":645,"_646":647,"_648":649},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","fdb67791413f4386b4dbf18f354029a617f6160f","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]

History · refs