Meet JSON's functional half-brother.

// @JSOL v0.2.97

/**
 @description
 
 # Rosetta Code: Anagrams
 
 This script solves the Anagrams task from Rosetta Code: 
 https://rosettacode.org/wiki/Anagrams
 
 ## Task
 
 Using a provided word list (e.g., unixdict.txt), find the sets of words that 
 share the same characters that contain the most words in them.
 
 ## JSOL Implementation Details
 
 JSOL's domain is pure business logic: it has no filesystem, DOM, or DB access. 
 Therefore, the word list is passed as a raw string argument to the entry 
 function `$aParseAndFindAnagrams`. This function normalizes any whitespace 
 (spaces, tabs, newlines) into single spaces, trims the string, and splits it 
 into an array of clean words. It then delegates the grouping logic to 
 `$aFindAnagramGroups`.
 
 Groups of size 1 (a word with no anagram partner) are never returned. JSOL's 
 Map has no way to increment an existing key's value, so grouping is done 
 with two parallel arrays: `$aSignatures` (each unique signature seen so far) 
 and `$aGroups` (the matching array of words for that signature).
 
 ### Entry Point API (`$aParseAndFindAnagrams`)
 - `$sDictionaryContent` (`string`): The raw content of unixdict.txt
 - **Returns** (`array<array<string>>`): The anagram group(s) with the most members. Empty if no word has an anagram partner.
 
 ## Output
 
 Pasting the content of `unixdict.txt` as an argument into [this JSOL code running in the REPL](http://jsol.bustelo.com.ar/?file=rosetta-code%2Fanagrams.jsol.js#repl) returns:
 ```js
 [
    ["abel","able","bale","bela","elba"],
    ["alger","glare","lager","large","regal"],
    ["angel","angle","galen","glean","lange"],
    ["caret","carte","cater","crate","trace"],
    ["elan","lane","lean","lena","neal"],
    ["evil","levi","live","veil","vile"]
 ]
```	
*/

/**
 @contract
 {
   "cases": [
     { "$sDictionaryContent": "listen silent enlist  banana cat act tac dog" }
   ]
 }
*/


/**
 * @param {string} $sDictionaryContent - The raw content of unixdict.txt
 * @returns {array<array<string>>} - The anagram group(s) with the most members. Empty if no word has an anagram partner.
 */


const $aParseAndFindAnagrams = function($sDictionaryContent) {
    // JSOL engine requires requiere regex como strings:
    const $xWhitespace = "\\s+";
    
    // JSOL's Regex.replace: (pattern, replacement, subject, flags)
    const $sNormalized = Regex.replace($xWhitespace, " ", $sDictionaryContent, "g");
    const $sTrimmed = Str.trim($sNormalized);
    
    const $aLines = Str.split($sTrimmed, " ");
    const $aCleanWords = [];
    const $qLineCount = Arr.len($aLines);

    for (let $i = 0; $i < $qLineCount; $i = $i + 1) {
        const $sWord = $aLines[$i];
        
        if (Str.len($sWord) > 0) {
            Arr.push($aCleanWords, $sWord);
        }
    }

    return $aFindAnagramGroups($aCleanWords);
};


/**
 * @param {array} $aWords - The dictionary / word list to search.
 * @returns {array<array>} - The anagram group(s) with the most members. Empty if no word in $aWords has an anagram partner.
 */

const $aFindAnagramGroups = function($aWords) {
    const $aSignatures = [];
    const $aGroups = [];

    const $qWordCount = Arr.len($aWords);
    for (let $i = 0; $i < $qWordCount; $i = $i + 1) {
        const $sWord = $aWords[$i];
        const $sSignature = $sSortLetters($sWord);

        const $qSigCount = Arr.len($aSignatures);
        let $qFoundAt = -1;
        for (let $qJ = 0; $qJ < $qSigCount; $qJ = $qJ + 1) {
            if ($aSignatures[$qJ] === $sSignature) {
                $qFoundAt = $qJ;
            }
        }

        if ($qFoundAt === -1) {
            Arr.push($aSignatures, $sSignature);
            Arr.push($aGroups, [$sWord]);
        } else {
            Arr.push($aGroups[$qFoundAt], $sWord);
        }
    }

    // Find the largest group size, then keep every group tied for it
    // (ties are common: "cat"/"act"/"tac" and "listen"/"silent"/"enlist"
    // are both size-3 groups).
    let $qMaxSize = 0;
    const $qGroupCount = Arr.len($aGroups);
    for (let $i = 0; $i < $qGroupCount; $i = $i + 1) {
        if (Arr.len($aGroups[$i]) > $qMaxSize) {
            $qMaxSize = Arr.len($aGroups[$i]);
        }
    }

    const $aLargestGroups = [];
    if ($qMaxSize > 1) {
        for (let $i = 0; $i < $qGroupCount; $i = $i + 1) {
            if (Arr.len($aGroups[$i]) === $qMaxSize) {
                Arr.push($aLargestGroups, $aGroups[$i]);
            }
        }
    }

    return $aLargestGroups;
};


/**
 * @param {string} $sWord - The word to be sorted.
 * @returns {string} - A string containing the same characters, sorted ascending by character code.
 */

const $sSortLetters = function($sWord) {
    const $sLower = Str.lower($sWord);
    const $qLen = Str.len($sLower);

    // Collect char codes, then insertion-sort them ascending: two words
    // are anagrams iff their sorted char codes are identical.
    const $aCodes = [];
    for (let $i = 0; $i < $qLen; $i = $i + 1) {
        Arr.push($aCodes, Str.char($sLower, $i));
    }

    for (let $i = 1; $i < $qLen; $i = $i + 1) {
        const $qKey = $aCodes[$i];
        let $qJ = $i - 1;
        while ($qJ >= 0 && $aCodes[$qJ] > $qKey) {
            $aCodes[$qJ + 1] = $aCodes[$qJ];
            $qJ = $qJ - 1;
        }
        $aCodes[$qJ + 1] = $qKey;
    }

    let $sSorted = "";
    for (let $i = 0; $i < $qLen; $i = $i + 1) {
        $sSorted = $sSorted + Str.fromChar($aCodes[$i]);
    }
    return $sSorted;
};

// @JSOL v0.2.97

/**
 @description
 
 # Rosetta Code: Anagrams
 
 This script solves the Anagrams task from Rosetta Code: 
 https://rosettacode.org/wiki/Anagrams
 
 ## Task
 
 Using a provided word list (e.g., unixdict.txt), find the sets of words that 
 share the same characters that contain the most words in them.
 
 ## JSOL Implementation Details
 
 JSOL's domain is pure business logic: it has no filesystem, DOM, or DB access. 
 Therefore, the word list is passed as a raw string argument to the entry 
 function `$aParseAndFindAnagrams`. This function normalizes any whitespace 
 (spaces, tabs, newlines) into single spaces, trims the string, and splits it 
 into an array of clean words. It then delegates the grouping logic to 
 `$aFindAnagramGroups`.
 
 Groups of size 1 (a word with no anagram partner) are never returned. JSOL's 
 Map has no way to increment an existing key's value, so grouping is done 
 with two parallel arrays: `$aSignatures` (each unique signature seen so far) 
 and `$aGroups` (the matching array of words for that signature).
 
 ### Entry Point API (`$aParseAndFindAnagrams`)
 - `$sDictionaryContent` (`string`): The raw content of unixdict.txt
 - **Returns** (`array<array<string>>`): The anagram group(s) with the most members. Empty if no word has an anagram partner.
 
 ## Output
 
 Pasting the content of `unixdict.txt` as an argument into [this JSOL code running in the REPL](http://jsol.bustelo.com.ar/?file=rosetta-code%2Fanagrams.jsol.js#repl) returns:
 ```js
 [
    ["abel","able","bale","bela","elba"],
    ["alger","glare","lager","large","regal"],
    ["angel","angle","galen","glean","lange"],
    ["caret","carte","cater","crate","trace"],
    ["elan","lane","lean","lena","neal"],
    ["evil","levi","live","veil","vile"]
 ]
```	
*/

/**
 @contract
 {
   "cases": [
     { "$sDictionaryContent": "listen silent enlist  banana cat act tac dog" }
   ]
 }
*/


/**
 * @param {string} $sDictionaryContent - The raw content of unixdict.txt
 * @returns {array<array<string>>} - The anagram group(s) with the most members. Empty if no word has an anagram partner.
 */


const $aParseAndFindAnagrams = function($sDictionaryContent) {
  // JSOL engine requires requiere regex como strings:
    const $xWhitespace = "\\s+";
    
    // JSOL's Regex.replace: (pattern, replacement, subject, flags)
    const $sNormalized = Rgx.replace($xWhitespace,  " ",  $sDictionaryContent,  "g");
    const $sTrimmed = $sNormalized.trim();
    
    const $aLines = Str["split"]($sTrimmed,  " ");
    const $aCleanWords = [];
    const $qLineCount = $aLines.length;

    for (let $i = 0; $i < $qLineCount; $i = $i + 1) {
    const $sWord = $aLines[$i];
        
        if (Str["len"]($sWord) > 0) {
      $aCleanWords.push( $sWord);
    }
  }
  return $aFindAnagramGroups($aCleanWords);
};
/**
 * @param {array} $aWords - The dictionary / word list to search.
 * @returns {array<array>} - The anagram group(s) with the most members. Empty if no word in $aWords has an anagram partner.
 */

const $aFindAnagramGroups = function($aWords) {
  const $aSignatures = [];
    const $aGroups = [];

    const $qWordCount = $aWords.length;
    for (let $i = 0; $i < $qWordCount; $i = $i + 1) {
    const $sWord = $aWords[$i];
        const $sSignature = $sSortLetters($sWord);

        const $qSigCount = $aSignatures.length;
        let $qFoundAt = -1;
        for (let $qJ = 0; $qJ < $qSigCount; $qJ = $qJ + 1) {
      if ($aSignatures[$qJ] === $sSignature) {
        $qFoundAt = $qJ;
      }
    }
    if ($qFoundAt === -1) {
      $aSignatures.push( $sSignature);
            $aGroups.push( [$sWord]);
    }
    else {
      $aGroups[$qFoundAt].push( $sWord);
    }
  }
  // Find the largest group size, then keep every group tied for it
    // (ties are common: "cat"/"act"/"tac" and "listen"/"silent"/"enlist"
    // are both size-3 groups).
    let $qMaxSize = 0;
    const $qGroupCount = $aGroups.length;
    for (let $i = 0; $i < $qGroupCount; $i = $i + 1) {
    if ($aGroups[$i].length > $qMaxSize) {
      $qMaxSize = $aGroups[$i].length;
    }
  }
  const $aLargestGroups = [];
    if ($qMaxSize > 1) {
    for (let $i = 0; $i < $qGroupCount; $i = $i + 1) {
      if ($aGroups[$i].length === $qMaxSize) {
        $aLargestGroups.push( $aGroups[$i]);
      }
    }
  }
  return $aLargestGroups;
};
/**
 * @param {string} $sWord - The word to be sorted.
 * @returns {string} - A string containing the same characters, sorted ascending by character code.
 */

const $sSortLetters = function($sWord) {
  const $sLower = $sWord.toLowerCase();
    const $qLen = Str["len"]($sLower);

    // Collect char codes, then insertion-sort them ascending: two words
    // are anagrams iff their sorted char codes are identical.
    const $aCodes = [];
    for (let $i = 0; $i < $qLen; $i = $i + 1) {
    $aCodes.push( Str["char"]($sLower,  $i));
  }
  for (let $i = 1; $i < $qLen; $i = $i + 1) {
    const $qKey = $aCodes[$i];
        let $qJ = $i - 1;
        while ($qJ >= 0 && $aCodes[$qJ] > $qKey) {
      $aCodes[$qJ + 1] = $aCodes[$qJ];
            $qJ = $qJ - 1;
    }
    $aCodes[$qJ + 1] = $qKey;
  }
  let $sSorted = "";
    for (let $i = 0; $i < $qLen; $i = $i + 1) {
    $sSorted = $sSorted + Str["fromChar"]($aCodes[$i]);
  }
  return $sSorted;
};
window['$aParseAndFindAnagrams'] = $aParseAndFindAnagrams;

<?php
// @JSOL v0.2.97

/**
 @description
 
 # Rosetta Code: Anagrams
 
 This script solves the Anagrams task from Rosetta Code: 
 https://rosettacode.org/wiki/Anagrams
 
 ## Task
 
 Using a provided word list (e.g., unixdict.txt), find the sets of words that 
 share the same characters that contain the most words in them.
 
 ## JSOL Implementation Details
 
 JSOL's domain is pure business logic: it has no filesystem, DOM, or DB access. 
 Therefore, the word list is passed as a raw string argument to the entry 
 function `$aParseAndFindAnagrams`. This function normalizes any whitespace 
 (spaces, tabs, newlines) into single spaces, trims the string, and splits it 
 into an array of clean words. It then delegates the grouping logic to 
 `$aFindAnagramGroups`.
 
 Groups of size 1 (a word with no anagram partner) are never returned. JSOL's 
 Map has no way to increment an existing key's value, so grouping is done 
 with two parallel arrays: `$aSignatures` (each unique signature seen so far) 
 and `$aGroups` (the matching array of words for that signature).
 
 ### Entry Point API (`$aParseAndFindAnagrams`)
 - `$sDictionaryContent` (`string`): The raw content of unixdict.txt
 - **Returns** (`array<array<string>>`): The anagram group(s) with the most members. Empty if no word has an anagram partner.
 
 ## Output
 
 Pasting the content of `unixdict.txt` as an argument into [this JSOL code running in the REPL](http://jsol.bustelo.com.ar/?file=rosetta-code%2Fanagrams.jsol.js#repl) returns:
 ```js
 [
    ["abel","able","bale","bela","elba"],
    ["alger","glare","lager","large","regal"],
    ["angel","angle","galen","glean","lange"],
    ["caret","carte","cater","crate","trace"],
    ["elan","lane","lean","lena","neal"],
    ["evil","levi","live","veil","vile"]
 ]
```	
*/

/**
 @contract
 {
   "cases": [
     { "$sDictionaryContent": "listen silent enlist  banana cat act tac dog" }
   ]
 }
*/


/**
 * @param {string} $sDictionaryContent - The raw content of unixdict.txt
 * @returns {array<array<string>>} - The anagram group(s) with the most members. Empty if no word has an anagram partner.
 */


$aParseAndFindAnagrams = function($sDictionaryContent) use (&$aFindAnagramGroups) {
  // JSOL engine requires requiere regex como strings:
    $xWhitespace = "\\s+";
    
    // JSOL's Regex.replace: (pattern, replacement, subject, flags)
    $sNormalized = Rgx::replace($xWhitespace,  " ",  $sDictionaryContent,  "g");
    $sTrimmed = trim($sNormalized);
    
    $aLines = Str::split($sTrimmed,  " ");
    $aCleanWords = [];
    $qLineCount = count($aLines);

    for ($i = 0; $i < $qLineCount; $i = $i + 1) {
    $sWord = $aLines[$i];
        
        if (mb_strlen($sWord, "UTF-8") > 0) {
      $aCleanWords[] =  $sWord;
    }
  }
  return $aFindAnagramGroups($aCleanWords);
};
/**
 * @param {array} $aWords - The dictionary / word list to search.
 * @returns {array<array>} - The anagram group(s) with the most members. Empty if no word in $aWords has an anagram partner.
 */

$aFindAnagramGroups = function($aWords) use (&$sSortLetters) {
  $aSignatures = [];
    $aGroups = [];

    $qWordCount = count($aWords);
    for ($i = 0; $i < $qWordCount; $i = $i + 1) {
    $sWord = $aWords[$i];
        $sSignature = $sSortLetters($sWord);

        $qSigCount = count($aSignatures);
        $qFoundAt = -1;
        for ($qJ = 0; $qJ < $qSigCount; $qJ = $qJ + 1) {
      if ($aSignatures[$qJ] === $sSignature) {
        $qFoundAt = $qJ;
      }
    }
    if ($qFoundAt === -1) {
      $aSignatures[] =  $sSignature;
            $aGroups[] =  [$sWord];
    }
    else {
      $aGroups[$qFoundAt][] =  $sWord;
    }
  }
  // Find the largest group size, then keep every group tied for it
    // (ties are common: "cat"/"act"/"tac" and "listen"/"silent"/"enlist"
    // are both size-3 groups).
    $qMaxSize = 0;
    $qGroupCount = count($aGroups);
    for ($i = 0; $i < $qGroupCount; $i = $i + 1) {
    if (count($aGroups[$i]) > $qMaxSize) {
      $qMaxSize = count($aGroups[$i]);
    }
  }
  $aLargestGroups = [];
    if ($qMaxSize > 1) {
    for ($i = 0; $i < $qGroupCount; $i = $i + 1) {
      if (count($aGroups[$i]) === $qMaxSize) {
        $aLargestGroups[] =  $aGroups[$i];
      }
    }
  }
  return $aLargestGroups;
};
/**
 * @param {string} $sWord - The word to be sorted.
 * @returns {string} - A string containing the same characters, sorted ascending by character code.
 */

$sSortLetters = function($sWord) {
  $sLower = mb_strtolower($sWord, "UTF-8");
    $qLen = mb_strlen($sLower, "UTF-8");

    // Collect char codes, then insertion-sort them ascending: two words
    // are anagrams iff their sorted char codes are identical.
    $aCodes = [];
    for ($i = 0; $i < $qLen; $i = $i + 1) {
    $aCodes[] =  mb_ord(mb_substr($sLower,  $i, 1, "UTF-8"), "UTF-8");
  }
  for ($i = 1; $i < $qLen; $i = $i + 1) {
    $qKey = $aCodes[$i];
        $qJ = $i - 1;
        while ($qJ >= 0 && $aCodes[$qJ] > $qKey) {
      $aCodes[$qJ + 1] = $aCodes[$qJ];
            $qJ = $qJ - 1;
    }
    $aCodes[$qJ + 1] = $qKey;
  }
  $sSorted = "";
    for ($i = 0; $i < $qLen; $i = $i + 1) {
    $sSorted = $sSorted . mb_chr($aCodes[$i], "UTF-8");
  }
  return $sSorted;
};

declare var JSOL: any;
declare var Rgx: any;
declare var Str: any;
declare var Arr: any;
declare var Bool: any;
declare var Cast: any;

// @JSOL v0.2.97

/**
 @description
 
 # Rosetta Code: Anagrams
 
 This script solves the Anagrams task from Rosetta Code: 
 https://rosettacode.org/wiki/Anagrams
 
 ## Task
 
 Using a provided word list (e.g., unixdict.txt), find the sets of words that 
 share the same characters that contain the most words in them.
 
 ## JSOL Implementation Details
 
 JSOL's domain is pure business logic: it has no filesystem, DOM, or DB access. 
 Therefore, the word list is passed as a raw string argument to the entry 
 function `$aParseAndFindAnagrams`. This function normalizes any whitespace 
 (spaces, tabs, newlines) into single spaces, trims the string, and splits it 
 into an array of clean words. It then delegates the grouping logic to 
 `$aFindAnagramGroups`.
 
 Groups of size 1 (a word with no anagram partner) are never returned. JSOL's 
 Map has no way to increment an existing key's value, so grouping is done 
 with two parallel arrays: `$aSignatures` (each unique signature seen so far) 
 and `$aGroups` (the matching array of words for that signature).
 
 ### Entry Point API (`$aParseAndFindAnagrams`)
 - `$sDictionaryContent` (`string`): The raw content of unixdict.txt
 - **Returns** (`array<array<string>>`): The anagram group(s) with the most members. Empty if no word has an anagram partner.
 
 ## Output
 
 Pasting the content of `unixdict.txt` as an argument into [this JSOL code running in the REPL](http://jsol.bustelo.com.ar/?file=rosetta-code%2Fanagrams.jsol.js#repl) returns:
 ```js
 [
    ["abel","able","bale","bela","elba"],
    ["alger","glare","lager","large","regal"],
    ["angel","angle","galen","glean","lange"],
    ["caret","carte","cater","crate","trace"],
    ["elan","lane","lean","lena","neal"],
    ["evil","levi","live","veil","vile"]
 ]
```	
*/

/**
 @contract
 {
   "cases": [
     { "$sDictionaryContent": "listen silent enlist  banana cat act tac dog" }
   ]
 }
*/


/**
 * @param {string} $sDictionaryContent - The raw content of unixdict.txt
 * @returns {array<array<string>>} - The anagram group(s) with the most members. Empty if no word has an anagram partner.
 */


const $aParseAndFindAnagrams = function($sDictionaryContent: any): any[] {
  // JSOL engine requires requiere regex como strings:
    const $xWhitespace = "\\s+";
    
    // JSOL's Regex.replace: (pattern, replacement, subject, flags)
    const $sNormalized: string = Rgx.replace($xWhitespace,  " ",  $sDictionaryContent,  "g");
    const $sTrimmed: string = $sNormalized.trim();
    
    const $aLines: any[] = Str["split"]($sTrimmed,  " ");
    const $aCleanWords: any[] = [];
    const $qLineCount: number = $aLines.length;

    for (let $i = 0; $i < $qLineCount; $i = $i + 1) {
    const $sWord: string = $aLines[$i];
        
        if (Str["len"]($sWord) > 0) {
      $aCleanWords.push( $sWord);
    }
  }
  return $aFindAnagramGroups($aCleanWords);
};
/**
 * @param {array} $aWords - The dictionary / word list to search.
 * @returns {array<array>} - The anagram group(s) with the most members. Empty if no word in $aWords has an anagram partner.
 */

const $aFindAnagramGroups = function($aWords: any): any[] {
  const $aSignatures: any[] = [];
    const $aGroups: any[] = [];

    const $qWordCount: number = $aWords.length;
    for (let $i = 0; $i < $qWordCount; $i = $i + 1) {
    const $sWord: string = $aWords[$i];
        const $sSignature: string = $sSortLetters($sWord);

        const $qSigCount: number = $aSignatures.length;
        let $qFoundAt: number = -1;
        for (let $qJ = 0; $qJ < $qSigCount; $qJ = $qJ + 1) {
      if ($aSignatures[$qJ] === $sSignature) {
        $qFoundAt = $qJ;
      }
    }
    if ($qFoundAt === -1) {
      $aSignatures.push( $sSignature);
            $aGroups.push( [$sWord]);
    }
    else {
      $aGroups[$qFoundAt].push( $sWord);
    }
  }
  // Find the largest group size, then keep every group tied for it
    // (ties are common: "cat"/"act"/"tac" and "listen"/"silent"/"enlist"
    // are both size-3 groups).
    let $qMaxSize: number = 0;
    const $qGroupCount: number = $aGroups.length;
    for (let $i = 0; $i < $qGroupCount; $i = $i + 1) {
    if ($aGroups[$i].length > $qMaxSize) {
      $qMaxSize = $aGroups[$i].length;
    }
  }
  const $aLargestGroups: any[] = [];
    if ($qMaxSize > 1) {
    for (let $i = 0; $i < $qGroupCount; $i = $i + 1) {
      if ($aGroups[$i].length === $qMaxSize) {
        $aLargestGroups.push( $aGroups[$i]);
      }
    }
  }
  return $aLargestGroups;
};
/**
 * @param {string} $sWord - The word to be sorted.
 * @returns {string} - A string containing the same characters, sorted ascending by character code.
 */

const $sSortLetters = function($sWord: any): string {
  const $sLower: string = $sWord.toLowerCase();
    const $qLen: number = Str["len"]($sLower);

    // Collect char codes, then insertion-sort them ascending: two words
    // are anagrams iff their sorted char codes are identical.
    const $aCodes: any[] = [];
    for (let $i = 0; $i < $qLen; $i = $i + 1) {
    $aCodes.push( Str["char"]($sLower,  $i));
  }
  for (let $i = 1; $i < $qLen; $i = $i + 1) {
    const $qKey: number = $aCodes[$i];
        let $qJ: number = $i - 1;
        while ($qJ >= 0 && $aCodes[$qJ] > $qKey) {
      $aCodes[$qJ + 1] = $aCodes[$qJ];
            $qJ = $qJ - 1;
    }
    $aCodes[$qJ + 1] = $qKey;
  }
  let $sSorted: string = "";
    for (let $i = 0; $i < $qLen; $i = $i + 1) {
    $sSorted = $sSorted + Str["fromChar"]($aCodes[$i]);
  }
  return $sSorted;
};

import math
import functools
from jsol_core import JSOL

# @JSOL v0.2.97

#*
# @description
# 
# # Rosetta Code: Anagrams
# 
# This script solves the Anagrams task from Rosetta Code: 
# https://rosettacode.org/wiki/Anagrams
# 
# ## Task
# 
# Using a provided word list (e.g., unixdict.txt), find the sets of words that 
# share the same characters that contain the most words in them.
# 
# ## JSOL Implementation Details
# 
# JSOL's domain is pure business logic: it has no filesystem, DOM, or DB access. 
# Therefore, the word list is passed as a raw string argument to the entry 
# function `$aParseAndFindAnagrams`. This function normalizes any whitespace 
# (spaces, tabs, newlines) into single spaces, trims the string, and splits it 
# into an array of clean words. It then delegates the grouping logic to 
# `$aFindAnagramGroups`.
# 
# Groups of size 1 (a word with no anagram partner) are never returned. JSOL's 
# Map has no way to increment an existing key's value, so grouping is done 
# with two parallel arrays: `$aSignatures` (each unique signature seen so far) 
# and `$aGroups` (the matching array of words for that signature).
# 
# ### Entry Point API (`$aParseAndFindAnagrams`)
# - `$sDictionaryContent` (`string`): The raw content of unixdict.txt
# - **Returns** (`array<array<string>>`): The anagram group(s) with the most members. Empty if no word has an anagram partner.
# 
# ## Output
# 
# Pasting the content of `unixdict.txt` as an argument into [this JSOL code running in the REPL](http://jsol.bustelo.com.ar/?file=rosetta-code%2Fanagrams.jsol.js#repl) returns:
# ```js
# [
#    ["abel","able","bale","bela","elba"],
#    ["alger","glare","lager","large","regal"],
#    ["angel","angle","galen","glean","lange"],
#    ["caret","carte","cater","crate","trace"],
#    ["elan","lane","lean","lena","neal"],
#    ["evil","levi","live","veil","vile"]
# ]
#```	
#

#*
# @contract
# {
#   "cases": [
#     { "$sDictionaryContent": "listen silent enlist  banana cat act tac dog" }
#   ]
# }
#


#*
# * @param {string} $sDictionaryContent - The raw content of unixdict.txt
# * @returns {array<array<string>>} - The anagram group(s) with the most members. Empty if no word has an anagram partner.
# 


def aParseAndFindAnagrams(sDictionaryContent): 

  # JSOL engine requires requiere regex como strings:
  xWhitespace = "\\s+";

  # JSOL's Regex.replace: (pattern, replacement, subject, flags)
  sNormalized = JSOL.regex_replace(xWhitespace,  " ",  sDictionaryContent,  "g");
  sTrimmed = sNormalized.strip();

  aLines = JSOL.str_split(sTrimmed,  " ");
  aCleanWords = [];
  qLineCount = len(aLines);

  i = 0;
  while i < qLineCount: 

    sWord = aLines[i];

    if len(sWord) > 0: 

      aCleanWords.append( sWord);


    i = i + 1;


  return aFindAnagramGroups(aCleanWords);


#*
# * @param {array} $aWords - The dictionary / word list to search.
# * @returns {array<array>} - The anagram group(s) with the most members. Empty if no word in $aWords has an anagram partner.
# 

def aFindAnagramGroups(aWords): 

  aSignatures = [];
  aGroups = [];

  qWordCount = len(aWords);
  i = 0;
  while i < qWordCount: 

    sWord = aWords[i];
    sSignature = sSortLetters(sWord);

    qSigCount = len(aSignatures);
    qFoundAt = -1;
    qJ = 0;
    while qJ < qSigCount: 

      if aSignatures[qJ] == sSignature: 

        qFoundAt = qJ;


      qJ = qJ + 1;


    if qFoundAt == -1: 

      aSignatures.append( sSignature);
      aGroups.append( [sWord]);


    else: 

      aGroups[qFoundAt].append( sWord);


    i = i + 1;


  # Find the largest group size, then keep every group tied for it
  # (ties are common: "cat"/"act"/"tac" and "listen"/"silent"/"enlist"
  # are both size-3 groups).
  qMaxSize = 0;
  qGroupCount = len(aGroups);
  i = 0;
  while i < qGroupCount: 

    if len(aGroups[i]) > qMaxSize: 

      qMaxSize = len(aGroups[i]);


    i = i + 1;


  aLargestGroups = [];
  if qMaxSize > 1: 

    i = 0;
    while i < qGroupCount: 

      if len(aGroups[i]) == qMaxSize: 

        aLargestGroups.append( aGroups[i]);


      i = i + 1;




  return aLargestGroups;


#*
# * @param {string} $sWord - The word to be sorted.
# * @returns {string} - A string containing the same characters, sorted ascending by character code.
# 

def sSortLetters(sWord): 

  sLower = sWord.lower();
  qLen = len(sLower);

  # Collect char codes, then insertion-sort them ascending: two words
  # are anagrams iff their sorted char codes are identical.
  aCodes = [];
  i = 0;
  while i < qLen: 

    aCodes.append( ord(sLower[ i]));

    i = i + 1;


  i = 1;
  while i < qLen: 

    qKey = aCodes[i];
    qJ = i - 1;
    while qJ >= 0 and aCodes[qJ] > qKey: 

      aCodes[qJ + 1] = aCodes[qJ];
      qJ = qJ - 1;


    aCodes[qJ + 1] = qKey;

    i = i + 1;


  sSorted = "";
  i = 0;
  while i < qLen: 

    sSorted = sSorted + chr(aCodes[i]);

    i = i + 1;


  return sSorted;