bridges-cli 0.0.1 → 0.1.0

package/src/utils/usePuzzleInput.ts

@@ -1,32 +1,404 @@
 import { useApp, useInput } from 'ink'
-import { useRef } from 'react'
+import { useCallback, useRef, useState } from 'react'
 
-export default function usePuzzleInput(
-    puzzleIndex: number,
-    puzzlesLength: number,
-    onPrev: () => void,
-    onNext: () => void,
+import type { Direction, PlacedBridge, SelectionState } from '../types.ts'
+
+type UsePuzzleInputProps = {
+    puzzleIndex: number
+    puzzlesLength: number
+    rows: { value: number | '-' | '=' | '#' | ' ' | '|' }[][]
+    showSolution: boolean
+    onPrev: () => void
+    onNext: () => void
     onToggleSolution: () => void
+    onBridgePlaced?: (bridge: PlacedBridge) => boolean
+}
+
+function findMatchingNodes(
+    rows: { value: number | '-' | '=' | '#' | ' ' | '|' }[][],
+    number: number
 ) {
+    const matches: { row: number; col: number }[] = []
+    for (let row = 0; row < rows.length; row++) {
+        const currentRow = rows[row]
+        if (!currentRow) continue
+        for (let col = 0; col < currentRow.length; col++) {
+            const cell = currentRow[col]
+            if (cell && cell.value === number) {
+                matches.push({ row, col })
+            }
+        }
+    }
+    return matches
+}
+
+function generateLabels(count: number): string[] {
+    const labels: string[] = []
+    for (let i = 0; i < count; i++) {
+        labels.push(String.fromCharCode(97 + i)) // a, b, c, ...
+    }
+    return labels
+}
+
+export function findNodeInDirection(
+    rows: { value: number | '-' | '=' | '#' | ' ' | '|' }[][],
+    fromRow: number,
+    fromCol: number,
+    direction: Direction
+): { row: number; col: number } | null {
+    const rowCount = rows.length
+    const firstRow = rows[0]
+    if (!firstRow) return null
+    const colCount = firstRow.length
+
+    let checkRow = fromRow
+    let checkCol = fromCol
+
+    if (direction === 'h') {
+        // left
+        checkCol = fromCol - 1
+        while (checkCol >= 0) {
+            const row = rows[fromRow]
+            if (!row) return null
+            const cell = row[checkCol]
+            if (cell) {
+                if (cell.value === '|' || cell.value === '#') {
+                    // Bridge in the way - invalid
+                    return null
+                }
+                if (typeof cell.value === 'number') {
+                    return { row: fromRow, col: checkCol }
+                }
+            }
+            checkCol--
+        }
+    } else if (direction === 'l') {
+        // right
+        checkCol = fromCol + 1
+        while (checkCol < colCount) {
+            const row = rows[fromRow]
+            if (!row) return null
+            const cell = row[checkCol]
+            if (cell) {
+                if (cell.value === '|' || cell.value === '#') {
+                    // Bridge in the way - invalid
+                    return null
+                }
+                if (typeof cell.value === 'number') {
+                    return { row: fromRow, col: checkCol }
+                }
+            }
+            checkCol++
+        }
+    } else if (direction === 'j') {
+        // down
+        checkRow = fromRow + 1
+        while (checkRow < rowCount) {
+            const row = rows[checkRow]
+            if (!row) return null
+            const cell = row[fromCol]
+            if (cell) {
+                if (cell.value === '-' || cell.value === '=') {
+                    // Bridge in the way - invalid
+                    return null
+                }
+                if (typeof cell.value === 'number') {
+                    return { row: checkRow, col: fromCol }
+                }
+            }
+            checkRow++
+        }
+    } else if (direction === 'k') {
+        // up
+        checkRow = fromRow - 1
+        while (checkRow >= 0) {
+            const row = rows[checkRow]
+            if (!row) return null
+            const cell = row[fromCol]
+            if (cell) {
+                if (cell.value === '-' || cell.value === '=') {
+                    // Bridge in the way - invalid
+                    return null
+                }
+                if (typeof cell.value === 'number') {
+                    return { row: checkRow, col: fromCol }
+                }
+            }
+            checkRow--
+        }
+    }
+
+    return null
+}
+
+export default function usePuzzleInput({
+    puzzleIndex,
+    puzzlesLength,
+    rows,
+    showSolution,
+    onPrev,
+    onNext,
+    onToggleSolution,
+    onBridgePlaced,
+}: UsePuzzleInputProps) {
     const { exit } = useApp()
     const puzzleIndexRef = useRef(puzzleIndex)
     puzzleIndexRef.current = puzzleIndex
 
-    useInput(input => {
+    const showSolutionRef = useRef(showSolution)
+    showSolutionRef.current = showSolution
+
+    const [selectionState, setSelectionState] = useState<SelectionState>({
+        mode: 'idle',
+        selectedNumber: null,
+        direction: null,
+        matchingNodes: [],
+        disambiguationLabels: [],
+        selectedNode: null,
+    })
+
+    // Use a ref to track mode for synchronous access in input handler
+    const selectionStateRef = useRef(selectionState)
+    selectionStateRef.current = selectionState
+
+    // Store timeout ID so we can cancel it when user provides input
+    const resetTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+
+    const resetSelection = useCallback(() => {
+        if (resetTimeoutRef.current) {
+            clearTimeout(resetTimeoutRef.current)
+            resetTimeoutRef.current = null
+        }
+        setSelectionState({
+            mode: 'idle',
+            selectedNumber: null,
+            direction: null,
+            matchingNodes: [],
+            disambiguationLabels: [],
+            selectedNode: null,
+        })
+    }, [])
+
+    // Clear the reset timeout when user changes mode (e.g., starts a new selection)
+    const clearResetTimeout = useCallback(() => {
+        if (resetTimeoutRef.current) {
+            clearTimeout(resetTimeoutRef.current)
+            resetTimeoutRef.current = null
+        }
+    }, [])
+
+    useInput((input, key) => {
+        // q always quits
         if (input === 'q') {
             exit()
+            return
         }
 
-        if (input === 'n' && puzzleIndexRef.current + 1 < puzzlesLength) {
-            onNext()
-        }
+        const currentMode = selectionStateRef.current.mode
 
-        if (input === 'p' && puzzleIndexRef.current - 1 >= 0) {
-            onPrev()
+        // If not idle, handle selection keys
+        if (currentMode !== 'idle') {
+            // Esc resets to idle
+            if (key.escape) {
+                resetSelection()
+                return
+            }
+
+            // In disambiguation mode, handle a-z
+            if (currentMode === 'disambiguation') {
+                const labelIndex = input.charCodeAt(0) - 97 // a=0, b=1, ...
+                const matches = selectionStateRef.current.matchingNodes
+                if (labelIndex >= 0 && labelIndex < matches.length) {
+                    // Selected! Now enter selecting-node mode to choose direction
+                    setSelectionState({
+                        ...selectionStateRef.current,
+                        mode: 'selecting-node',
+                        disambiguationLabels: [],
+                        selectedNode: matches[labelIndex] ?? null,
+                    })
+                }
+                return
+            }
+
+            // In selecting-node mode, handle direction keys
+            if (
+                currentMode === 'selecting-node' &&
+                selectionStateRef.current.selectedNumber !== null
+            ) {
+                if (
+                    input === 'h' ||
+                    input === 'j' ||
+                    input === 'k' ||
+                    input === 'l' ||
+                    input === 'H' ||
+                    input === 'J' ||
+                    input === 'K' ||
+                    input === 'L'
+                ) {
+                    const isDouble = input === input.toUpperCase()
+                    const direction = input.toLowerCase() as Direction
+                    const selectedNode = selectionStateRef.current.selectedNode
+                    const targetNode = selectedNode
+                        ? findNodeInDirection(rows, selectedNode.row, selectedNode.col, direction)
+                        : null
+
+                    let erased = false
+                    if (targetNode && selectedNode && onBridgePlaced) {
+                        // Toggle the bridge (add if not exists, remove if exists)
+                        // The callback returns true if a bridge was erased
+                        erased = onBridgePlaced({
+                            from: selectedNode,
+                            to: targetNode,
+                            count: isDouble ? 2 : 1,
+                        })
+                    }
+
+                    // Show selected/invalid state, then reset after 1.5s
+                    setSelectionState({
+                        ...selectionStateRef.current,
+                        mode: targetNode ? 'selected' : 'invalid',
+                        direction,
+                        bridgeErased: erased,
+                        isDoubleBridge: isDouble,
+                    })
+                    resetTimeoutRef.current = setTimeout(resetSelection, 1_500)
+                }
+                return
+            }
+
+            // In selected/invalid mode, allow immediate input for next action
+            if (currentMode === 'selected' || currentMode === 'invalid') {
+                // Clear any pending timeout since user is providing input
+                clearResetTimeout()
+
+                // Allow n/p/s navigation
+                if (input === 'n' && puzzleIndexRef.current + 1 < puzzlesLength) {
+                    onNext()
+                    resetSelection()
+                    return
+                } else if (input === 'p' && puzzleIndexRef.current - 1 >= 0) {
+                    onPrev()
+                    resetSelection()
+                    return
+                } else if (input === 's') {
+                    onToggleSolution()
+                    resetSelection()
+                    return
+                }
+
+                // Allow number keys to start a new selection
+                if (input >= '1' && input <= '8') {
+                    if (showSolutionRef.current) return
+
+                    const num = parseInt(input, 10)
+                    const matches = findMatchingNodes(rows, num)
+                    if (matches.length > 0) {
+                        if (matches.length === 1) {
+                            setSelectionState({
+                                mode: 'selecting-node',
+                                selectedNumber: num,
+                                direction: null,
+                                matchingNodes: matches,
+                                disambiguationLabels: [],
+                                selectedNode: matches[0] ?? null,
+                            })
+                        } else {
+                            setSelectionState({
+                                mode: 'disambiguation',
+                                selectedNumber: num,
+                                direction: null,
+                                matchingNodes: matches,
+                                disambiguationLabels: generateLabels(matches.length),
+                                selectedNode: null,
+                            })
+                        }
+                    }
+                    return
+                }
+
+                // Allow direction keys to draw another bridge immediately
+                if (
+                    input === 'h' ||
+                    input === 'j' ||
+                    input === 'k' ||
+                    input === 'l' ||
+                    input === 'H' ||
+                    input === 'J' ||
+                    input === 'K' ||
+                    input === 'L'
+                ) {
+                    // Get the previously selected node to use as starting point
+                    const prevNode = selectionStateRef.current.selectedNode
+                    if (prevNode) {
+                        const isDouble = input === input.toUpperCase()
+                        const direction = input.toLowerCase() as Direction
+                        const targetNode = findNodeInDirection(
+                            rows,
+                            prevNode.row,
+                            prevNode.col,
+                            direction
+                        )
+
+                        let erased = false
+                        if (targetNode && onBridgePlaced) {
+                            erased = onBridgePlaced({
+                                from: prevNode,
+                                to: targetNode,
+                                count: isDouble ? 2 : 1,
+                            })
+                        }
+
+                        setSelectionState({
+                            ...selectionStateRef.current,
+                            mode: targetNode ? 'selected' : 'invalid',
+                            direction,
+                            bridgeErased: erased,
+                            isDoubleBridge: isDouble,
+                        })
+                    }
+                    return
+                }
+            }
         }
 
-        if (input === 's') {
+        // Normal mode key handling
+        if (input === 'n' && puzzleIndexRef.current + 1 < puzzlesLength) {
+            onNext()
+        } else if (input === 'p' && puzzleIndexRef.current - 1 >= 0) {
+            onPrev()
+        } else if (input === 's') {
             onToggleSolution()
+        } else if (input >= '1' && input <= '8') {
+            if (showSolutionRef.current) return
+
+            // Number pressed - enter selecting-node or disambiguation mode
+            const num = parseInt(input, 10)
+            const matches = findMatchingNodes(rows, num)
+            if (matches.length > 0) {
+                if (matches.length === 1) {
+                    // Single match - go directly to selecting-node mode
+                    setSelectionState({
+                        mode: 'selecting-node',
+                        selectedNumber: num,
+                        direction: null,
+                        matchingNodes: matches,
+                        disambiguationLabels: [],
+                        selectedNode: matches[0] ?? null,
+                    })
+                } else {
+                    // Multiple matches - enter disambiguation mode
+                    setSelectionState({
+                        mode: 'disambiguation',
+                        selectedNumber: num,
+                        direction: null,
+                        matchingNodes: matches,
+                        disambiguationLabels: generateLabels(matches.length),
+                        selectedNode: null,
+                    })
+                }
+            }
         }
     })
+
+    return { selectionState, resetSelection }
 }

package/src/utils/parsePuzzle.ts

@@ -1,178 +0,0 @@
-import type { HashiNodeData } from '../types.ts'
-
-function letterToNumber(char: string): number {
-    return char.charCodeAt(0) - 96
-}
-
-/**
- * Parses a puzzle encoding string into a 2D array of HashiNodeData.
- *
- * Encoding format: "WIDTHxHEIGHT:row1.row2.row3..."
- * - Digits (0-9): explicit node values
- * - Letters (a-z): skip positions (a=1, b=2, c=3, etc.)
- * - "-": single horizontal line (connects to adjacent nodes)
- * - "=": double horizontal line (connects to adjacent nodes)
- * - "|": single vertical line (connects to node in row below)
- * - "#": double vertical line (connects to node in row below)
- *
- * The letter repeat rule applies to lines: "-c" means 3 single horizontal lines
- *
- * Example: "3x3:1-1.1a|" creates a 3x3 grid with horizontal and vertical bridges
- */
-export function parsePuzzle(encoding: string): HashiNodeData[][] {
-    const parts = encoding.split(':')
-    const dimensions = parts[0] || ''
-    const rest = parts[1] || ''
-
-    // Parse string for row width
-    const match: RegExpMatchArray | null = dimensions.match(/(\d+)x(\d+)/)
-    let numNodes = 0
-    if (match !== null && match[1] !== undefined) {
-        numNodes = parseInt(match[1], 10)
-    }
-
-    // Split grid data into rows
-    const rowStrings = rest.split('.')
-    const rows: HashiNodeData[][] = []
-
-    for (const rowStr of rowStrings) {
-        const nodes: HashiNodeData[] = Array(numNodes)
-            .fill(null)
-            .map(() => ({ value: ' ' }))
-        let position = 0
-        let i = 0
-
-        // Parse each character in the encoding
-        while (i < rowStr.length && position < numNodes) {
-            const char = rowStr[i] ?? ''
-            const charCode = char.charCodeAt(0)
-
-            // Digit: create a node with the numeric value
-            if (charCode >= 48 && charCode <= 57) {
-                const value = Number(char)
-                // Check if previous position has a line node and set lineLeft
-                if (
-                    position > 0 &&
-                    (nodes[position - 1]!.value === '-' || nodes[position - 1]!.value === '=')
-                ) {
-                    const lineCount: 1 | 2 = nodes[position - 1]!.value === '=' ? 2 : 1
-                    nodes[position] = { value, lineLeft: lineCount }
-                } else {
-                    nodes[position] = { value }
-                }
-                position++
-                i++
-            } else if (char === '-' || char === '=') {
-                // Horizontal line: single (-) or double (=)
-                const lineCount: 1 | 2 = char === '=' ? 2 : 1
-
-                // Set lineRight on current position if it's a number node
-                if (position > 0 && typeof nodes[position - 1]!.value === 'number') {
-                    nodes[position - 1] = { ...nodes[position - 1]!, lineRight: lineCount }
-                }
-
-                // Create the line node
-                nodes[position] = { value: char as '-' | '=' }
-
-                // Set lineRight on the line node and lineLeft on next position if it's a number node
-                if (position < numNodes - 1 && typeof nodes[position + 1]!.value === 'number') {
-                    nodes[position + 1] = { ...nodes[position + 1]!, lineLeft: lineCount }
-                }
-
-                // Check if next char is a letter (repeat count)
-                const nextChar = rowStr[i + 1]
-                if (nextChar && nextChar >= 'a' && nextChar <= 'z') {
-                    const repeat = letterToNumber(nextChar)
-                    // Create repeated line nodes (the first is already at 'position')
-                    // We need to create 'repeat' more nodes starting at position+1
-                    for (let r = 1; r <= repeat && position + r < numNodes; r++) {
-                        nodes[position + r] = { value: char as '-' | '=' }
-                        // Set lineLeft/lineRight on adjacent number nodes
-                        if (
-                            position + r > 0 &&
-                            typeof nodes[position + r - 1]!.value === 'number'
-                        ) {
-                            nodes[position + r - 1] = {
-                                ...nodes[position + r - 1]!,
-                                lineRight: lineCount,
-                            }
-                        }
-                        if (
-                            position + r < numNodes - 1 &&
-                            typeof nodes[position + r + 1]!.value === 'number'
-                        ) {
-                            nodes[position + r + 1] = {
-                                ...nodes[position + r + 1]!,
-                                lineLeft: lineCount,
-                            }
-                        }
-                    }
-                    // Set lineLeft on the last line node if next position has a number
-                    const lastLinePos = position + repeat
-                    if (
-                        lastLinePos < numNodes - 1 &&
-                        typeof nodes[lastLinePos + 1]!.value === 'number'
-                    ) {
-                        nodes[lastLinePos + 1] = { ...nodes[lastLinePos + 1]!, lineLeft: lineCount }
-                    }
-                    position += repeat + 1
-                    i += 2
-                } else {
-                    position++
-                    i++
-                }
-            } else if (char === '|' || char === '#') {
-                // Vertical line: single (|) or double (#)
-                // Create the line node (connections handled in second pass)
-                // Note: vertical lines do not support letter repeat
-                nodes[position] = { value: char as '|' | '#' }
-                position++
-                i++
-            } else {
-                // Letter: skip positions based on letter-to-number mapping
-                position += letterToNumber(char)
-                i++
-            }
-        }
-
-        // Fill any remaining undefined positions with empty nodes
-        for (let j = 0; j < numNodes; j++) {
-            if (nodes[j] === undefined || nodes[j] === null) {
-                nodes[j] = { value: ' ' }
-            }
-        }
-
-        rows.push(nodes)
-    }
-
-    // Second pass: handle vertical line connections
-    // For each vertical line, connect to the number nodes above and below
-    for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
-        const currentRow = rows[rowIdx]!
-
-        for (let colIdx = 0; colIdx < currentRow.length; colIdx++) {
-            const node = currentRow[colIdx]!
-            if (node.value === '|' || node.value === '#') {
-                const lineCount: 1 | 2 = node.value === '#' ? 2 : 1
-
-                // Set lineDown on the number node in the row above (if exists)
-                if (rowIdx > 0) {
-                    const nodeAbove = rows[rowIdx - 1]![colIdx]!
-                    if (typeof nodeAbove.value === 'number') {
-                        rows[rowIdx - 1]![colIdx] = { ...nodeAbove, lineDown: lineCount }
-                    }
-                }
-
-                // Set lineUp on the number node in the row below (if exists)
-                if (rowIdx < rows.length - 1) {
-                    const nodeBelow = rows[rowIdx + 1]![colIdx]!
-                    if (typeof nodeBelow.value === 'number') {
-                        rows[rowIdx + 1]![colIdx] = { ...nodeBelow, lineUp: lineCount }
-                    }
-                }
-            }
-        }
-    }
-
-    return rows
-}

package/src/utils/samplePuzzles.ts

@@ -1,59 +0,0 @@
-export interface PuzzleData {
-    encoding: string
-    solution?: string
-}
-
-export const samplePuzzles: PuzzleData[] = [
-    {
-        encoding: '7x7:4a3a3a3.a2c4a.3b3b3.g.2b8a4a.d1a3.a1a4a1a',
-        solution: '7x7:4=3-3=3.#2=b4|.3-a3a#3.c#a##.2=a8=4#.c#1-3.a1-4-1a',
-    },
-    {
-        encoding: '9x9:3c1a3a3.b2b3c.3c2a2b.e4b6.3a4a8b3a.a1a3a2c.3a3a2b1a.c4a5b3.3a5a3b2a',
-        solution: '9x9:3-b1a3-3.#a2-a3#a#.3a|a2#2a#.|a|a#4=a6.3-4=8=a3#.|1-3#2a|#.3-3#2#a1#.|a#4=5-a3.3=5-3=a2a'
-    },
-    { encoding: '9x9:2a5a6b2a.a1d1a2.3a2b1a2a.a4b8a4b.3g3.b3a3b2a.a2a1b3a3.1a3d2a.a3b4a3a2' },
-    { encoding: '9x9:4b4a5b3.a2b3a1b.2h.a2a1a4c.4a4a3a2a3.c2a8a4a.h2.b2a1b2a.3b2a4b2' },
-    { encoding: '9x9:a3d3a3.1a2a4b1a.a4a4a1b4.d4b3a.3b3b2b.a1f3.6a2a2a3b.c2c2a.3a2b2b3' },
-    { encoding: '9x9:a2a3b6a2.b2a3d.a1g.b1c3a3.4c8b3a.e1c.3a3a2d.g1a.b3b4b4' },
-    { encoding: '9x9:4b6b2a2.i.3a2a2c6.c3b2b.b5a4c4.f2b.2a8a4c3.c1b2b.b4e3' },
-    { encoding: '9x9:a3b5b1a.1b2a2b3.i.2c2a2a6.a3a8a4a1a.5a2a4c5.i.4b4a2b3.a1b4b1a' },
-    { encoding: '9x9:3c1a3a3.b2b3c.3c2a2b.e4b6.3a4a8b3a.a1a3a2c.3a3a2b1a.c4a5b3.3a5a3b2a' },
-    { encoding: '9x9:4a3b3a1a.a3b4a1a3.4h.b3a3a4a6.a1a1a2a2a.5a8a5a3b.h3.1a2a4b4a.a1a2b3a3' },
-    { encoding: '9x9:a1b4b3a.3b4d1.d2a1b.a3a8a3a4a.2c1c3.a4a3a3a4a.b1a3d.1d3b4.a4b4b1a' },
-    { encoding: '9x9:2a5a6b2a.a1d1a2.3a2b1a2a.a4b8a4b.3g3.b3a3b2a.a2a1b3a3.1a3d2a.a3b4a3a2' },
-    { encoding: '9x9:3a3a2c1.a3d3b.b2b1c.4b2b8a4.a2e2a.4a5b1b2.c1b3b.b3b2a3a.2c2a3a3' },
-    { encoding: '9x9:4a2b1b3.a2b3a3b.5a4b1c.h3.b5a4a5b.1h.c1b3a4.b2a3b2a.1b3b2a3' },
-    { encoding: '9x9:1a2a3a4a3.a2a4a4a2a.1c2d.a5a4a2b3.b3a8b3a.3b1d3.b1b3a3a.a2b2d.4b4a3b3' },
-    { encoding: '9x9:a2b3a4a4.3a4b2a2a.a2a5b4b.5a4d3a.c2a3c.a2d2a4.b3b3a2a.a4a3b2a2.3a2a2b2a' },
-    { encoding: '9x9:1a1a4a3a2.a3a2a2a3a.2g3.a2b3b3a.3b4a3b6.a3b4b3a.2g3.a4a2a1a2a.3a2a3a3a3' },
-    { encoding: '9x9:2a3a4a3a2.a2a2a2a1a.b1a3d.2d1b2.a3b8b4a.4b4d2.d3a2b.a1a4a1a1a.1a1a2a3a2' },
-    { encoding: '9x9:3a4a3a2a2.a2c3a3a.2a1e2.a3b2a1b.4a2b2a1a.a1b2a5a4.b2b3c.3c1a2b.a2a3a3b3' },
-    { encoding: '9x9:2b4b5a4.b3b4a2a.f1b.1a2a3c4.a4a3a3a3a.2c4a5a4.b1f.a2a2b3b.3a5b4b3' },
-    { encoding: '9x9:4a3a3b3a.a1a3b3a2.4a2a2b2a.a1a1e.2a5a8a4a4.e2a2a.a3b3a2a6.1a2b2a1a.a4b4a2a3' },
-    { encoding: '9x9:2b5b4a2.a1e1a.d1a3b.a4a8a2a3a.3a1a3a3a3.a2a2a2a6a.b2a2d.a2e3a.4a3b1b2' },
-    { encoding: '9x9:3a1a1a3a3.a2a1e.b2a7a4b.3d2b5.a2b4a3b.h3.3a2a3a4b.a2a3a3b4.2a3d2a' },
-    { encoding: '9x9:1a3b3b3.a2g.2a3a1a2a6.a4a1a3a3a.b1a2c4.3d3a6a.a4b6a1a3.e1a2a.3a3a5a5a3' },
-    {
-        encoding:
-            '9x16:a3a2a5a2a.2a3a2a2a2.e3c.a2b1a1b.4a4b4b4.a3b1a1b.2a2b5c.a4a4b2a4.d2d.3b5a3a2a.b1e3.d4b2a.3a3c2a4.a1a2e.1a2a3a3b.a2c2b3',
-    },
-    {
-        encoding:
-            '9x16:a2a2a3a3a.2a2a4a1a2.e2a3a.a3b5a3a5.5a3b2a3a.a2f2.b3a4b3a.a3a1e.2a1a4a3a2.a4a2e.3a1a2b3a.a5a2b3a3.3a3b1c.a2a2c3a.2a3a2a3a2.a2a6a3a2a',
-    },
-    {
-        encoding:
-            '9x16:2a3b2b2.a1b2d.2e1a3.b4a8b2a.2b1b2a4.e1c.1a1a4b2a.a3a2d2.2d3a3a.a5b5a2a4.c1e.3a2b2b3.a2b3a1b.4a4e3.d2b1a.3b4b2a3.',
-    },
-    {
-        encoding:
-            '13x22:1a2b2b3a2a2.i1a2a.3b3b3a3a1b.a3c1f2.b3c4b1c.3g2b4a.b5b2f3.i2a3a.3a4a1a1a1a1a5.e3c4c.a3a3c1d3.2d2c4a1a.c5c2e.2a1a3a3a3a5a4.a4a2i.3f3b4b.a4b3g2.3b3b3c2b.g4c2a.b1a1a2b3b4.a1a1i.2a2a3b3b2a3',
-    },
-    { encoding: '9x9:3b3b4a2.a2c1c.b1a4a2b.3d2b3.a2b5b1a.4b2a2b2.b1a3b2a.a1c2b1.2a3d3a' },
-    { encoding: '9x9:4b4b4a4.b1a1d.2b1d3.d2a2b.4a4b3b4.a4b4b2a.2a1c2a2.a2e1a.2a4a3a4a2' },
-    {
-        encoding:
-            '21x35:a1a3b4a2a2a4b3a2b2.3c2b1e4b6a2b.b4c3a2c3d2a2a.a2a4a5a3b2b4a2d2.3a2a2a4a3c2c2d.a4a3a3a2b5b4a4a3a1a.3c4f4b3a3a2b.a2a2b3a4a3a2b5a4b5.4a2b4a1a3a7b2a1a1b.a2a3b5a4d1a3a3b4.3c4f2i.a2a2b4b5b5a3a3a4a4.e5b3a4f2a2a.4a3a5i1a2a2a3.a3a2a3a3a4b6b3a3a4a.3a2a3a2a2a4b2b4a3a3.a2a3e4k.4a4a2c2a3a5a3b5b3.a1a3b3b6c2b3d.1a3b3a3b1g2a2.a3a4b2b4b6b2a4c.2g2b2b2a2a3a2.a2a6a4a6d2b1a4c.5a4a4a2a2b4b8a3a1a2.a1a4a2a7b4b4a2a5a3a.b4e2b3b4c2b.3c6b7a3c2a2a1b3.a3a2o2a.3a5a5a3b3a4b5b2b3.e2a3e1d4b.3b2b3b2d2b2a',
-    },
-]