puzzle-lib 1.3.0 → 1.6.0

package/src/Conversion/CharacterTableEntry.ts

@@ -0,0 +1,23 @@
+export class CharacterTableEntry {
+  private static getValue(value: number, base: number, maxValue: number) {
+    return value
+      .toString(base)
+      .padStart(Math.ceil(Math.log(maxValue) / Math.log(base)), '0');
+  }
+
+  readonly character: string;
+  readonly binary: string;
+  readonly ternary: string;
+  readonly octal: string;
+  readonly decimal: string;
+  readonly hexadecimal: string;
+
+  constructor(character: string, value: number, maxValue: number) {
+    this.character = character;
+    this.binary = CharacterTableEntry.getValue(value, 2, maxValue);
+    this.ternary = CharacterTableEntry.getValue(value, 3, maxValue);
+    this.octal = CharacterTableEntry.getValue(value, 8, maxValue);
+    this.decimal = CharacterTableEntry.getValue(value, 10, maxValue);
+    this.hexadecimal = CharacterTableEntry.getValue(value, 16, maxValue);
+  }
+}

package/src/Conversion/SignificantFigures.ts

@@ -0,0 +1,55 @@
+export class SignificantFigures {
+  static ceil(num: number, sigFigs: number) {
+    return this.roundInternal(Math.ceil, num, sigFigs);
+  }
+
+  static floor(num: number, sigFigs: number) {
+    return this.roundInternal(Math.floor, num, sigFigs);
+  }
+
+  static round(num: number, sigFigs: number) {
+    return this.roundInternal(Math.round, num, sigFigs);
+  }
+
+  private static roundInternal(
+    func: (num: number) => number,
+    num: number,
+    sigFigs: number
+  ) {
+    if (num === 0) {
+      return num;
+    }
+
+    if (sigFigs <= 0) {
+      throw new RangeError('sigFigs value must be positive');
+    }
+
+    const factor = this.getFactor(num, sigFigs);
+
+    if (factor > 0) {
+      return func(num / factor) * factor;
+    } else if (factor < 0) {
+      const absFactor = Math.abs(factor);
+      return func(num * absFactor) / absFactor;
+    } else {
+      return num;
+    }
+  }
+
+  private static getFactor(num: number, sigFigs: number) {
+    const absNum = Math.abs(num);
+    let digits = 0;
+
+    if (absNum < 1) {
+      digits = -sigFigs;
+    } else {
+      digits = Math.ceil(Math.log(absNum) / Math.log(10)) - sigFigs;
+    }
+
+    if (digits < 0) {
+      return -Math.pow(10, Math.abs(digits));
+    } else {
+      return Math.pow(10, digits);
+    }
+  }
+}

package/src/Conversion/StringAutoConvert.ts

@@ -0,0 +1,56 @@
+import {CharacterAutoConvert} from './CharacterAutoConvert';
+import {CharacterEncoding} from './CharacterEncoding';
+
+export class StringAutoConvert {
+  static convertString(input: string, homogeneous: boolean) {
+    const split = this.splitString(input);
+
+    if (homogeneous) {
+      const encoding = this.determineStringEncoding(input);
+      return split.reduce(
+        (result, letter) =>
+          result + CharacterAutoConvert.convertCharacter(letter, encoding),
+        ''
+      );
+    } else {
+      return split.reduce(
+        (result, letter) =>
+          result + CharacterAutoConvert.convertCharacter(letter),
+        ''
+      );
+    }
+  }
+
+  static determineStringEncoding(input: string): CharacterEncoding {
+    const encodingCount: {[index: number]: number} = {};
+    const parsed = this.splitString(input);
+    const encodingKeys: number[] = [];
+
+    for (const letter of parsed) {
+      const charEncoding =
+        CharacterAutoConvert.determineCharacterEncoding(letter);
+      if (!encodingCount[charEncoding]) {
+        encodingCount[charEncoding] = 1;
+        encodingKeys.push(charEncoding);
+      } else {
+        encodingCount[charEncoding] = encodingCount[charEncoding] + 1;
+      }
+    }
+
+    let maxCount = 0;
+    let maxEncoding: number;
+    maxEncoding = CharacterEncoding.None;
+
+    for (const encoding of encodingKeys) {
+      if (encodingCount[encoding] > maxCount) {
+        maxCount = encodingCount[encoding];
+        maxEncoding = encoding;
+      }
+    }
+    return maxEncoding;
+  }
+
+  static splitString(input: string): string[] {
+    return input.split(' ').filter(item => item !== '');
+  }
+}

package/src/Morse/MorseCharacter.ts

@@ -0,0 +1,112 @@
+import {EncodingCategory} from '../Common/EncodingCategory';
+import {EncodingCharacterBase} from '../Common/EncodingCharacterBase';
+import {Helpers} from '../Common/Helpers';
+import {MorseData} from './MorseData';
+import {MorseEncoding} from './MorseEncoding';
+
+const MORSE_BITMASK = MorseEncoding.Dot | MorseEncoding.Dash;
+
+export class MorseCharacter extends EncodingCharacterBase<MorseEncoding> {
+  static readonly DOT: string = '.';
+  static readonly DASH: string = '-';
+  // Character which may not appear in morse and is reserved for use by this class
+  static readonly RESERVED_DIVIDER: string = 'A';
+
+  static toMorseString(encoding: MorseEncoding) {
+    let morseChars = '';
+
+    while (encoding !== MorseEncoding.None) {
+      if ((encoding & MORSE_BITMASK) === MorseEncoding.Dot) {
+        morseChars += MorseCharacter.DOT;
+      } else if ((encoding & MORSE_BITMASK) === MorseEncoding.Dash) {
+        morseChars += MorseCharacter.DASH;
+      } else {
+        throw new Error('Invalid morse bits');
+      }
+
+      encoding >>>= 2;
+    }
+
+    return morseChars;
+  }
+
+  static parseMorseString(morse: string): MorseEncoding {
+    let bits = MorseEncoding.None;
+
+    for (let i = morse.length - 1; i >= 0; i--) {
+      const ch = morse[i];
+      if (ch === MorseCharacter.DOT) {
+        bits |= MorseEncoding.Dot;
+      } else if (ch === MorseCharacter.DASH) {
+        bits |= MorseEncoding.Dash;
+      } else {
+        throw new Error('Invalid morse character');
+      }
+
+      bits <<= 2;
+    }
+
+    bits >>>= 2;
+    return bits;
+  }
+
+  private _morse: string;
+
+  constructor(str = '', category: EncodingCategory = EncodingCategory.All) {
+    super(MorseData.instance, category);
+
+    this._morse = str;
+  }
+
+  get morseString() {
+    return this._morse;
+  }
+
+  set morseString(value: string) {
+    this._morse = value;
+    this.invalidateLookup();
+  }
+
+  backspace() {
+    if (this._morse.length > 0) {
+      this._morse = this._morse.substring(0, this._morse.length - 1);
+      this.invalidateLookup();
+    }
+  }
+
+  dot() {
+    this._morse += MorseCharacter.DOT;
+    this.invalidateLookup();
+  }
+
+  dash() {
+    this._morse += MorseCharacter.DASH;
+    this.invalidateLookup();
+  }
+
+  invertDotsAndDashes() {
+    // Replace dots with a placeholder, dashes with dots, then placeholders with dashes
+    Helpers.assert(this._morse.indexOf(MorseCharacter.RESERVED_DIVIDER) < 0);
+    this._morse = this._morse
+      .replace(/\./g, 'A')
+      .replace(/-/g, MorseCharacter.DOT)
+      .replace(/A/g, MorseCharacter.DASH);
+  }
+
+  reverse() {
+    this._morse = this._morse.split('').reverse().join('');
+  }
+
+  protected onClear() {
+    this._morse = '';
+    this.invalidateLookup();
+  }
+
+  protected onEmpty() {
+    return this._morse.length === 0;
+  }
+
+  protected getEncoding() {
+    return MorseCharacter.parseMorseString(this._morse);
+  }
+}

package/src/Morse/MorseData.ts

@@ -0,0 +1,143 @@
+import {EncodingCategory} from '../Common/EncodingCategory';
+import {EncodingDataBase} from '../Common/EncodingDataBase';
+import {MorseEncoding} from './MorseEncoding';
+
+export class MorseData extends EncodingDataBase<MorseEncoding> {
+  static readonly instance: MorseData = new MorseData();
+
+  constructor() {
+    super();
+
+    // Letters
+    this.addToList(MorseEncoding.LetterA, EncodingCategory.Letter, 'A');
+    this.addToList(MorseEncoding.LetterB, EncodingCategory.Letter, 'B');
+    this.addToList(MorseEncoding.LetterC, EncodingCategory.Letter, 'C');
+    this.addToList(MorseEncoding.LetterD, EncodingCategory.Letter, 'D');
+    this.addToList(MorseEncoding.LetterE, EncodingCategory.Letter, 'E');
+    this.addToList(MorseEncoding.LetterF, EncodingCategory.Letter, 'F');
+    this.addToList(MorseEncoding.LetterG, EncodingCategory.Letter, 'G');
+    this.addToList(MorseEncoding.LetterH, EncodingCategory.Letter, 'H');
+    this.addToList(MorseEncoding.LetterI, EncodingCategory.Letter, 'I');
+    this.addToList(MorseEncoding.LetterJ, EncodingCategory.Letter, 'J');
+    this.addToList(MorseEncoding.LetterK, EncodingCategory.Letter, 'K');
+    this.addToList(MorseEncoding.LetterL, EncodingCategory.Letter, 'L');
+    this.addToList(MorseEncoding.LetterM, EncodingCategory.Letter, 'M');
+    this.addToList(MorseEncoding.LetterN, EncodingCategory.Letter, 'N');
+    this.addToList(MorseEncoding.LetterO, EncodingCategory.Letter, 'O');
+    this.addToList(MorseEncoding.LetterP, EncodingCategory.Letter, 'P');
+    this.addToList(MorseEncoding.LetterQ, EncodingCategory.Letter, 'Q');
+    this.addToList(MorseEncoding.LetterR, EncodingCategory.Letter, 'R');
+    this.addToList(MorseEncoding.LetterS, EncodingCategory.Letter, 'S');
+    this.addToList(MorseEncoding.LetterT, EncodingCategory.Letter, 'T');
+    this.addToList(MorseEncoding.LetterU, EncodingCategory.Letter, 'U');
+    this.addToList(MorseEncoding.LetterV, EncodingCategory.Letter, 'V');
+    this.addToList(MorseEncoding.LetterW, EncodingCategory.Letter, 'W');
+    this.addToList(MorseEncoding.LetterX, EncodingCategory.Letter, 'X');
+    this.addToList(MorseEncoding.LetterY, EncodingCategory.Letter, 'Y');
+    this.addToList(MorseEncoding.LetterZ, EncodingCategory.Letter, 'Z');
+
+    // Numbers
+    this.addToList(MorseEncoding.Number0, EncodingCategory.Number, '0');
+    this.addToList(MorseEncoding.Number1, EncodingCategory.Number, '1');
+    this.addToList(MorseEncoding.Number2, EncodingCategory.Number, '2');
+    this.addToList(MorseEncoding.Number3, EncodingCategory.Number, '3');
+    this.addToList(MorseEncoding.Number4, EncodingCategory.Number, '4');
+    this.addToList(MorseEncoding.Number5, EncodingCategory.Number, '5');
+    this.addToList(MorseEncoding.Number6, EncodingCategory.Number, '6');
+    this.addToList(MorseEncoding.Number7, EncodingCategory.Number, '7');
+    this.addToList(MorseEncoding.Number8, EncodingCategory.Number, '8');
+    this.addToList(MorseEncoding.Number9, EncodingCategory.Number, '9');
+
+    // Punctuation
+    this.addToList(
+      MorseEncoding.PunctuationPeriod,
+      EncodingCategory.Punctuation,
+      '.'
+    );
+    this.addToList(
+      MorseEncoding.PunctuationComma,
+      EncodingCategory.Punctuation,
+      ','
+    );
+    this.addToList(
+      MorseEncoding.PunctuationQuestionMark,
+      EncodingCategory.Punctuation,
+      '?'
+    );
+    this.addToList(
+      MorseEncoding.PunctuationApostrophe,
+      EncodingCategory.Punctuation,
+      "'"
+    );
+    this.addToList(
+      MorseEncoding.PunctuationExclamationPoint,
+      EncodingCategory.Punctuation,
+      '!'
+    );
+    this.addToList(
+      MorseEncoding.PunctuationForwardSlash,
+      EncodingCategory.Punctuation,
+      '/'
+    );
+    this.addToList(
+      MorseEncoding.PunctuationOpenParenthesis,
+      EncodingCategory.Punctuation,
+      '('
+    );
+    this.addToList(
+      MorseEncoding.PunctuationCloseParenthesis,
+      EncodingCategory.Punctuation,
+      ')'
+    );
+    this.addToList(
+      MorseEncoding.PunctuationAmpersand,
+      EncodingCategory.Punctuation,
+      '&'
+    );
+    this.addToList(
+      MorseEncoding.PunctuationColon,
+      EncodingCategory.Punctuation,
+      ':'
+    );
+    this.addToList(
+      MorseEncoding.PunctuationSemicolon,
+      EncodingCategory.Punctuation,
+      ';'
+    );
+    this.addToList(
+      MorseEncoding.PunctuationDoubleDash,
+      EncodingCategory.Punctuation,
+      '='
+    );
+    this.addToList(
+      MorseEncoding.PunctuationPlusSign,
+      EncodingCategory.Punctuation,
+      '+'
+    );
+    this.addToList(
+      MorseEncoding.PunctuationHyphen,
+      EncodingCategory.Punctuation,
+      '-'
+    );
+    this.addToList(
+      MorseEncoding.PunctuationUnderscore,
+      EncodingCategory.Punctuation,
+      '_'
+    );
+    this.addToList(
+      MorseEncoding.PunctuationQuotationMark,
+      EncodingCategory.Punctuation,
+      '"'
+    );
+    this.addToList(
+      MorseEncoding.PunctuationDollarSign,
+      EncodingCategory.Punctuation,
+      '$'
+    );
+    this.addToList(
+      MorseEncoding.PunctuationAtSign,
+      EncodingCategory.Punctuation,
+      '@'
+    );
+  }
+}

package/src/Morse/MorseEncoding.ts

@@ -0,0 +1,98 @@
+// The encoding for morse is much less straightforward than the others. The dots
+// and dashes each use two bits of the integer starting with the least-
+// significant bit.
+//
+// Example:
+//
+// 'F' -> ..-.
+//
+// Which encodes as:
+//
+// 01 01 10 01
+//  .  .  -  .
+//
+// Since it's packed starting with the LSB, the resulting number is reversed:
+//
+// 01100101 -> 0x65
+//
+
+function packMorse(...args: MorseEncoding[]) {
+  let value = MorseEncoding.None;
+  let shift = 0;
+
+  for (let arg of args) {
+    arg <<= shift;
+    value |= arg;
+    shift += 2;
+  }
+
+  return value;
+}
+
+export enum MorseEncoding {
+  None = 0,
+
+  // Primitives
+  Dot = 0x1,
+  Dash = 0x2,
+
+  // Letters
+  LetterA = packMorse(Dot, Dash),
+  LetterB = packMorse(Dash, Dot, Dot, Dot),
+  LetterC = packMorse(Dash, Dot, Dash, Dot),
+  LetterD = packMorse(Dash, Dot, Dot),
+  LetterE = packMorse(Dot),
+  LetterF = packMorse(Dot, Dot, Dash, Dot),
+  LetterG = packMorse(Dash, Dash, Dot),
+  LetterH = packMorse(Dot, Dot, Dot, Dot),
+  LetterI = packMorse(Dot, Dot),
+  LetterJ = packMorse(Dot, Dash, Dash, Dash),
+  LetterK = packMorse(Dash, Dot, Dash),
+  LetterL = packMorse(Dot, Dash, Dot, Dot),
+  LetterM = packMorse(Dash, Dash),
+  LetterN = packMorse(Dash, Dot),
+  LetterO = packMorse(Dash, Dash, Dash),
+  LetterP = packMorse(Dot, Dash, Dash, Dot),
+  LetterQ = packMorse(Dash, Dash, Dot, Dash),
+  LetterR = packMorse(Dot, Dash, Dot),
+  LetterS = packMorse(Dot, Dot, Dot),
+  LetterT = packMorse(Dash),
+  LetterU = packMorse(Dot, Dot, Dash),
+  LetterV = packMorse(Dot, Dot, Dot, Dash),
+  LetterW = packMorse(Dot, Dash, Dash),
+  LetterX = packMorse(Dash, Dot, Dot, Dash),
+  LetterY = packMorse(Dash, Dot, Dash, Dash),
+  LetterZ = packMorse(Dash, Dash, Dot, Dot),
+
+  // Numbers
+  Number0 = packMorse(Dash, Dash, Dash, Dash, Dash),
+  Number1 = packMorse(Dot, Dash, Dash, Dash, Dash),
+  Number2 = packMorse(Dot, Dot, Dash, Dash, Dash),
+  Number3 = packMorse(Dot, Dot, Dot, Dash, Dash),
+  Number4 = packMorse(Dot, Dot, Dot, Dot, Dash),
+  Number5 = packMorse(Dot, Dot, Dot, Dot, Dot),
+  Number6 = packMorse(Dash, Dot, Dot, Dot, Dot),
+  Number7 = packMorse(Dash, Dash, Dot, Dot, Dot),
+  Number8 = packMorse(Dash, Dash, Dash, Dot, Dot),
+  Number9 = packMorse(Dash, Dash, Dash, Dash, Dot),
+
+  // Punctuation
+  PunctuationPeriod = packMorse(Dot, Dash, Dot, Dash, Dot, Dash),
+  PunctuationComma = packMorse(Dash, Dash, Dot, Dot, Dash, Dash),
+  PunctuationQuestionMark = packMorse(Dot, Dot, Dash, Dash, Dot, Dot),
+  PunctuationApostrophe = packMorse(Dot, Dash, Dash, Dash, Dash, Dot),
+  PunctuationExclamationPoint = packMorse(Dash, Dot, Dash, Dot, Dash, Dash),
+  PunctuationForwardSlash = packMorse(Dash, Dot, Dot, Dash, Dot),
+  PunctuationOpenParenthesis = packMorse(Dash, Dot, Dash, Dash, Dot),
+  PunctuationCloseParenthesis = packMorse(Dash, Dot, Dash, Dash, Dot, Dash),
+  PunctuationAmpersand = packMorse(Dot, Dash, Dot, Dot, Dot),
+  PunctuationColon = packMorse(Dash, Dash, Dash, Dot, Dot, Dot),
+  PunctuationSemicolon = packMorse(Dash, Dot, Dash, Dot, Dash, Dot),
+  PunctuationDoubleDash = packMorse(Dash, Dot, Dot, Dot, Dash),
+  PunctuationPlusSign = packMorse(Dot, Dash, Dot, Dash, Dot),
+  PunctuationHyphen = packMorse(Dash, Dot, Dot, Dot, Dot, Dash),
+  PunctuationUnderscore = packMorse(Dot, Dot, Dash, Dash, Dot, Dash),
+  PunctuationQuotationMark = packMorse(Dot, Dash, Dot, Dot, Dash, Dot),
+  PunctuationDollarSign = packMorse(Dot, Dot, Dot, Dash, Dot, Dot, Dash),
+  PunctuationAtSign = packMorse(Dot, Dash, Dash, Dot, Dash, Dot),
+}

package/src/Morse/MorseString.ts

@@ -0,0 +1,106 @@
+import {Helpers} from '../Common/Helpers';
+import {MorseCharacter} from './MorseCharacter';
+
+// MorseString represents a string of multiple morse characters.  It allows for a longer representation
+// to be converted to a single string and allows for sentence-level transforms such as reversing
+// the order of tokens.
+export class MorseString {
+  static readonly CHARACTER_DIVIDER: string = '/';
+  static readonly WORD_DIVIDER = ' ';
+
+  constructor(
+    morse = '',
+    characterDivider = MorseString.CHARACTER_DIVIDER,
+    wordDivider = MorseString.WORD_DIVIDER
+  ) {
+    // The dividers should be single characters which don't clash with the other string content
+    Helpers.assertMsg(
+      characterDivider.length === 1,
+      'Divider must be a single character'
+    );
+    Helpers.assertMsg(
+      wordDivider.length === 1,
+      'Divider must be a single character'
+    );
+    Helpers.assertMsg(
+      characterDivider !== wordDivider,
+      'Dividers must be different from each other'
+    );
+    Helpers.assertMsg(
+      characterDivider !== MorseCharacter.DASH,
+      'Character divider must not be a reserved value'
+    );
+    Helpers.assertMsg(
+      characterDivider !== MorseCharacter.DOT,
+      'Character divider must not be a reserved value'
+    );
+    Helpers.assertMsg(
+      characterDivider !== MorseCharacter.RESERVED_DIVIDER,
+      'Character divider must not be a reserved value'
+    );
+    Helpers.assertMsg(
+      wordDivider !== MorseCharacter.DASH,
+      'Word divider must not be a reserved value'
+    );
+    Helpers.assertMsg(
+      wordDivider !== MorseCharacter.DOT,
+      'Word divider must not be a reserved value'
+    );
+    Helpers.assertMsg(
+      wordDivider !== MorseCharacter.RESERVED_DIVIDER,
+      'Word divider must not be a reserved value'
+    );
+
+    const words = morse.split(wordDivider).filter(w => w.length > 0);
+    // Discard any empty characters (caused by trailing separator)
+    const wordCharacters = words.map(w =>
+      w.split(characterDivider).filter(wc => wc.length > 0)
+    );
+    this._words = wordCharacters.map(subarray =>
+      subarray.map(wc => new MorseCharacter(wc))
+    );
+  }
+
+  // reverse reverses the order of all tokens in the string (including separators), such as would be
+  // the case if you were reading the data for a puzzle backwards.
+  reverse(): MorseString {
+    for (let i = 0; i < this._words.length; i++) {
+      for (const c of this._words[i]) {
+        // Reverse the dots/dashes in each letter
+        c.reverse();
+      }
+      // Reverse the letters in each word
+      this._words[i] = this._words[i].reverse();
+    }
+
+    // Reverse the order of the words
+    this._words = this._words.reverse();
+    return this;
+  }
+
+  // invertDotsAndDashes switches all dots and dashes in the input, such as would be the case if
+  // you had two ambiguous symbols for dot/dash and selected the wrong mapping.
+  invertDotsAndDashes(): MorseString {
+    for (const word of this._words) {
+      for (const c of word) {
+        c.invertDotsAndDashes();
+      }
+    }
+    return this;
+  }
+
+  toString(): string {
+    let s = '';
+    for (let i = 0; i < this._words.length; i++) {
+      if (i > 0) {
+        s += ' '; // This is a new word
+      }
+      for (const c of this._words[i]) {
+        s += c.toString() || '?';
+      }
+    }
+    return s;
+  }
+
+  protected _words: MorseCharacter[][];
+}

package/src/Nato/NatoCharacter.ts

@@ -0,0 +1,9 @@
+export class NatoCharacter {
+  readonly character: string;
+  readonly word: string;
+
+  constructor(character: string, word: string) {
+    this.character = character;
+    this.word = word;
+  }
+}

package/src/Nato/NatoData.ts

@@ -0,0 +1,49 @@
+import {NatoCharacter} from './NatoCharacter';
+
+// There's no concept of a 'partial match' for a NATO letter, so there's no
+// reason to derive from EncodingDataBase.
+export class NatoData {
+  static readonly instance: NatoData = new NatoData();
+
+  private readonly _entries: NatoCharacter[] = [
+    new NatoCharacter('A', 'Alfa'),
+    new NatoCharacter('B', 'Bravo'),
+    new NatoCharacter('C', 'Charlie'),
+    new NatoCharacter('D', 'Delta'),
+    new NatoCharacter('E', 'Echo'),
+    new NatoCharacter('F', 'Foxtrot'),
+    new NatoCharacter('G', 'Golf'),
+    new NatoCharacter('H', 'Hotel'),
+    new NatoCharacter('I', 'India'),
+    new NatoCharacter('J', 'Juliet'),
+    new NatoCharacter('K', 'Kilo'),
+    new NatoCharacter('L', 'Lima'),
+    new NatoCharacter('M', 'Mike'),
+    new NatoCharacter('N', 'November'),
+    new NatoCharacter('O', 'Oscar'),
+    new NatoCharacter('P', 'Papa'),
+    new NatoCharacter('Q', 'Quebec'),
+    new NatoCharacter('R', 'Romeo'),
+    new NatoCharacter('S', 'Sierra'),
+    new NatoCharacter('T', 'Tango'),
+    new NatoCharacter('U', 'Uniform'),
+    new NatoCharacter('V', 'Victor'),
+    new NatoCharacter('W', 'Whiskey'),
+    new NatoCharacter('X', 'X-ray'),
+    new NatoCharacter('Y', 'Yankee'),
+    new NatoCharacter('Z', 'Zulu'),
+  ];
+
+  get entries(): NatoCharacter[] {
+    return this._entries;
+  }
+
+  lookup(letter: string): NatoCharacter | null {
+    for (const ch of this._entries) {
+      if (ch.character.toUpperCase() === letter.toUpperCase()) {
+        return ch;
+      }
+    }
+    return null;
+  }
+}

package/src/NavalFlags/LICENSE

@@ -0,0 +1,7 @@
+The SVG images used in this directory are of simple geometry is ineligible for copyright 
+and therefore in the public domain, because it consists entirely of information that is 
+common property and contains no original authorship.  With the exception of the image
+for 'U'/'Uniform', they were obtained from the Wikimedia Commons project at 
+https://commons.wikimedia.org/wiki/Category:SVG_signal_flags on 2018-10-17.  The SVG
+for Uniform is also ineligible for copyright and in the public domain, but did not come
+from Wikimedia.