puzzle-lib 2.0.0-alpha.2 → 2.0.0-beta.2

package/src/{Conversion → conversion}/conversion.ts

@@ -1,7 +1,8 @@
-import {CharacterEncoding} from './CharacterEncoding';
+import {CharacterEncoding} from './character-encoding.js';
 
 const BINARY_REGEX = /^[01]+$/;
 const TERNARY_REGEX = /^[0-2]{3}$/;
+const HEX_REGEX = /^[0-9a-f]{2}$/i;
 
 function appearsBinary(str: string): boolean {
   return BINARY_REGEX.test(str);
@@ -18,10 +19,26 @@ function asciiPrintable(index: number): string {
   return String.fromCharCode(index);
 }
 
+/**
+ * Checks if a token could be valid printable hex.
+ */
+function appearsHexPrintable(input: string): boolean {
+  if (!HEX_REGEX.test(input)) {
+    return false;
+  }
+  const hex = Number.parseInt(input, 16);
+  return hex >= 32 && hex <= 126;
+}
+
 /**
  * Determines the character encoding of a single input token.
  */
 export function determineCharacterEncoding(input: string): CharacterEncoding {
+  // Unambiguous hex: 2 hex chars with at least one a-f letter and at least one digit
+  if (HEX_REGEX.test(input) && /[a-f]/i.test(input) && /[0-9]/.test(input)) {
+    return CharacterEncoding.Hexadecimal;
+  }
+
   if (input.match(/[a-z]/i)) {
     return CharacterEncoding.Latin;
   }
@@ -51,6 +68,11 @@ export function determineCharacterEncoding(input: string): CharacterEncoding {
     return CharacterEncoding.Ascii;
   }
 
+  // All-digit 2-char tokens that aren't decimal but are valid printable hex
+  if (appearsHexPrintable(input)) {
+    return CharacterEncoding.Hexadecimal;
+  }
+
   return CharacterEncoding.None;
 }
 
@@ -77,6 +99,14 @@ export function convertCharacter(
     return asciiPrintable(baseTen);
   }
 
+  if (encoding === CharacterEncoding.Hexadecimal) {
+    const hex = Number.parseInt(input, 16);
+    if (Number.isNaN(hex)) {
+      return '';
+    }
+    return asciiPrintable(hex);
+  }
+
   const asciiOffset = 64;
   if (encoding === CharacterEncoding.Ordinal) {
     return asciiPrintable(baseTen + asciiOffset);
@@ -98,12 +128,33 @@ export function convertCharacter(
   return '';
 }
 
+// Auto-chunk a continuous binary string into 8-bit, 7-bit, or 5-bit groups.
+function chunkBinary(token: string): string[] {
+  if (!appearsBinary(token) || token.length <= 8) {
+    return [token];
+  }
+  const chunkSize =
+    token.length % 8 === 0
+      ? 8
+      : token.length % 7 === 0
+        ? 7
+        : token.length % 5 === 0
+          ? 5
+          : 8;
+  return token.match(new RegExp(`.{1,${chunkSize}}`, 'g'))!;
+}
+
 function splitString(input: string): string[] {
-  return input.split(' ').filter(item => item !== '');
+  return input
+    .split(' ')
+    .filter(item => item !== '')
+    .flatMap(chunkBinary);
 }
 
 /**
  * Determines the most common encoding across all tokens in a string.
+ * When hex and decimal encodings are mixed, tries hex for all tokens
+ * and picks whichever produces more printable results.
  */
 export function determineStringEncoding(input: string): CharacterEncoding {
   const encodingCount: {[index: number]: number} = {};
@@ -130,6 +181,30 @@ export function determineStringEncoding(input: string): CharacterEncoding {
       maxEncoding = encoding;
     }
   }
+
+  // Tiebreaker: if we have a mix of hex and decimal (Ascii/Ordinal) and the
+  // most common encoding is a decimal type, check if interpreting everything
+  // as hex produces more printable results.
+  const hasHex = encodingCount[CharacterEncoding.Hexadecimal] > 0;
+  const maxIsDecimal =
+    maxEncoding === CharacterEncoding.Ascii ||
+    maxEncoding === CharacterEncoding.Ordinal;
+
+  if (hasHex && maxIsDecimal) {
+    const hexPrintable = parsed.filter(
+      t =>
+        appearsHexPrintable(t) &&
+        convertCharacter(t, CharacterEncoding.Hexadecimal) !== '',
+    ).length;
+    const decPrintable = parsed.filter(
+      t => convertCharacter(t, maxEncoding) !== '',
+    ).length;
+
+    if (hexPrintable > decPrintable) {
+      return CharacterEncoding.Hexadecimal;
+    }
+  }
+
   return maxEncoding;
 }
 

package/src/conversion/index.ts

@@ -0,0 +1,15 @@
+export {
+  convertCharacter,
+  convertString,
+  determineCharacterEncoding,
+  determineStringEncoding,
+} from './conversion.js';
+export {
+  getAsciiTable,
+  getOrdinalTable,
+  toAscii,
+  toOrdinal,
+} from './character-conversion.js';
+export {CharacterEncoding} from './character-encoding.js';
+export {CharacterTableEntry} from './character-table-entry.js';
+export {sigFigCeil, sigFigFloor, sigFigRound} from './significant-figures.js';

package/src/morse/index.ts

@@ -0,0 +1,14 @@
+export {
+  decodeMorse,
+  invertAndReverseMorse,
+  invertMorse,
+  lookupMorseEncoding,
+  morseEncodingToString,
+  MORSE_CHARACTER_DIVIDER,
+  MORSE_DASH,
+  MORSE_DOT,
+  MORSE_WORD_DIVIDER,
+  parseMorseString,
+  reverseMorse,
+} from './morse.js';
+export {MorseEncoding} from './encoding.js';

package/src/{Morse → morse}/morse.ts

@@ -1,12 +1,12 @@
-import {EncodingCategory} from '../Common/EncodingCategory';
-import {EncodingEntry} from '../Common/EncodingEntry';
-import {EncodingLookupResult} from '../Common/EncodingLookupResult';
-import {MorseEncoding} from './MorseEncoding';
+import {EncodingCategory} from '../common/encoding-category.js';
+import {EncodingEntry} from '../common/encoding-entry.js';
+import {EncodingLookupResult} from '../common/encoding-lookup-result.js';
+import {MorseEncoding} from './encoding.js';
 
 export const MORSE_DOT = '.';
 export const MORSE_DASH = '-';
-export const MORSE_CHARACTER_DIVIDER = '/';
-export const MORSE_WORD_DIVIDER = ' ';
+export const MORSE_CHARACTER_DIVIDER = ' ';
+export const MORSE_WORD_DIVIDER = '/';
 
 // Reserved character used internally for dot/dash swap
 const RESERVED_DIVIDER = 'A';

package/src/nato/index.ts

@@ -0,0 +1,2 @@
+export {lookupNatoPhonetic, NATO_ALPHABET} from './nato.js';
+export {NatoCharacter} from './character.js';

package/src/{Nato → nato}/nato.ts

@@ -1,4 +1,4 @@
-import {NatoCharacter} from './NatoCharacter';
+import {NatoCharacter} from './character.js';
 
 export const NATO_ALPHABET: readonly NatoCharacter[] = [
   new NatoCharacter('A', 'Alfa'),

package/src/naval-flags/index.ts

@@ -0,0 +1 @@
+export {getNavalFlag, NAVAL_FLAGS} from './naval-flags.js';

package/src/{NavalFlags/navalFlags.ts → naval-flags/naval-flags.ts}

@@ -1,5 +1,5 @@
-import {CharacterImage} from '../Common/CharacterImage';
-import {InlineSvg} from '../Common/InlineSvg';
+import {CharacterImage} from '../common/character-image.js';
+import {InlineSvg} from '../common/inline-svg.js';
 
 export const NAVAL_FLAGS: readonly CharacterImage[] = [
   new CharacterImage(