【JavaScript】 Punycodeの仕組みと実装

const DAMP = 700;
const BASE = 36;
const TMIN = 1;
const TMAX = 26;
const SKEW = 38;
const adapt = (delta,  stringLength,  firsttime ) => {
// 桁溢れ対策でdeltaを縮小
        delta = Math.floor( firsttime ? delta / DAMP : delta / 2 );
// 前回よりも文字列が増えてるからdeltaを増やす
        delta += Math.floor(delta / stringLength );

        let k;
// 次のデルタに必要な桁の最小数を予想
        for (k = 0;  delta > (BASE - TMIN)*TMAX/2;  k += BASE) {
            delta = Math.floor(delta / (BASE - TMIN) );
        }
// 最下位桁～最上位-3までが 閾値tmin
// 最上位桁が閾値tmaxになるように返す
        return Math.floor(k + (BASE - TMIN + 1) * delta / (delta + SKEW));
    };

const jsPunyCode = (()=>{

        // Punycodeの開始文字列
    const START_STRING = "xn--";
        // 各種パラメーター
    const BASE = 36, TMIN = 1, TMAX = 26, SKEW = 38, DAMP = 700,
        INITIAL_BIAS = 72, INITIAL_N = 0x80,
        DELIMITER_STRING = "-" , DELIMITER = DELIMITER_STRING.codePointAt(0);

        // 変数の最大値
    const MAXINT = Number.MAX_SAFE_INTEGER;
        // 基本文字(1バイト文字)かどうかの判定
    const isBasicChar = c => c < 0x80;
        // 閾値の計算
    const calculationT = (k,bias) =>  k <= bias  ? TMIN :
             (k - bias >= TMAX ? TMAX : k - bias);

        // encode_digit:数値→文字変換 decode_digit:文字→数値変換
        // 0～25:a～z 26～:0～
    const [encode_digit,decode_digit] = (()=>{
        const [NUM0_CODE,NUM25_CODE,NUM26_CODE,NUM35_CODE] =
            ["a","z","0","9"].map( e=>e.codePointAt(0) );
        const CODE_ZERO_OFFSET = NUM26_CODE - 26;
        const encode_digit = d =>
            d < 26 ? d + NUM0_CODE : d + CODE_ZERO_OFFSET;
        const decode_digit = cp =>
            cp <= NUM35_CODE ? cp - NUM26_CODE + 26: cp - NUM0_CODE;
        return [encode_digit,decode_digit];
    })();

        // biasの計算
    const adapt = (()=>{
        const PARAM1 = BASE - TMIN;
        const PARAM2 = PARAM1*TMAX/2;
        const PARAM3 = PARAM1 + 1;
        return (delta,  stringLength,  firsttime ) => {
            delta = Math.floor( firsttime ? delta / DAMP : delta / 2 );
            delta += Math.floor(delta / stringLength );

            let k;
            for (k = 0;  delta > PARAM2;  k += BASE) {
                delta = Math.floor(delta / PARAM1 );
            }
            return Math.floor(k + PARAM3 * delta / (delta + SKEW));
        };
    })();
    /**
     * 文字列からPunycodeへのエンコード
     */
    const encode = inputString =>{ /* 内容はこちら */    };

    /**
     * Punycodeから文字列へのデコード
     */
    const decode = inputString =>{ /* 内容はこちら */     };

    return {
        encode : encode,
        decode : decode
    }
})();

   /**
     * 文字列からPunycodeへのエンコード
     */
    const encode = inputString =>{

        // 入力文字列をコードポイント単位の配列に変換
        const inputArray =
            [...inputString].map( c => c.codePointAt(0) );
        const input_length = inputArray.length;

        // 基本文字を選別
        const output = inputArray.filter(isBasicChar);

        // 全ての文字が基本文字なら終了
        if( input_length === output.length ) return inputString;

        let codeNumber = INITIAL_N; // 出力対象文字コード
        let delta = 0;  // 挿入位置を指示する値
        let bias = INITIAL_BIAS;

        let outputLength = output.length; // 現在の変換済み文字数
        let firstOutputFlg = true;  // 初回出力フラグ

        if( outputLength > 0 ) output.push( DELIMITER );

        while (outputLength < input_length) {

                // 前回のcodeNumber+1より大きいものから最小のものを検索
                // (codeNumberはwhileの最後で+1されている)
            const m = inputArray.reduce(
                (a,b)=> b >= codeNumber && b < a ? b : a
                ,MAXINT);

                // 桁溢れチェック
            if (m - codeNumber > (MAXINT - delta) / (outputLength + 1))
                return null;

                // 前回出力対象コードの差分を元に挿入位置を指示する値を算出
            delta += (m - codeNumber) * (outputLength + 1);
                // 前回出力対象コードを現在の出力対象コードで更新
            codeNumber = m;

            for (let j = 0;  j < input_length;  ++j) {

                const c = inputArray[j];

                if ( c < codeNumber ) // 基本文字または処理済み文字
                    ++delta; // <n,i>のiを加算

                else if ( c === codeNumber ) { // 今回の出力対象コード

                    let q = delta, k = BASE;
                    let t = calculationT(k , bias);

                    while( q >= t ){
                        output.push( encode_digit(t + (q - t) % (BASE - t)) );
                        q = Math.floor((q - t) / (BASE - t) );

                        k += BASE;
                        t = calculationT(k , bias);

                    }

                    output.push( encode_digit(q) );
                    bias = adapt(delta, outputLength + 1, firstOutputFlg);

                    delta = 0;
                    firstOutputFlg = false;
                    ++outputLength;
                }
            }

            ++delta;
            ++codeNumber;
        }
        return `${START_STRING}${ output.map( c=>String.fromCodePoint(c) ).join("") }`;
    };

    /**
     * Punycodeから文字列へのデコード
     */
    const decode = inputString =>{

            // 基本コードと拡張文字列の分割
        const [output,inputArray] = (( )=>{
            const s1 = inputString.toLowerCase().substring(START_STRING.length);
            const delimiterPos = s1.lastIndexOf( DELIMITER_STRING );
            return (delimiterPos === 0 ? ["",s1] :
                [s1.substring(0,delimiterPos),s1.substring(delimiterPos+1)])
                    .map( string => [...string].map( c=>c.codePointAt(0) ) )

        })();
        const input_length = inputArray.length;

        let codeNumber = INITIAL_N;
        let index = 0;
        let bias = INITIAL_BIAS;

        let inPos = 0;
        let firstOutputFlg = true;  // 初回出力フラグ

        do{
            let beforeIndex = index;
            let w = 1; // 重み
            let k = BASE; // 閾値判定用の変数
            let digit,t;
            do{
                if (inPos >= input_length) return null;
                    // 文字を数値に変換
                digit = decode_digit(inputArray[inPos++]);
                index += digit * w;
                    // 閾値を計算
                t = calculationT( k , bias );
                    // 最上位桁かどうかチェック
                if (digit < t) break;

                  // 桁溢れチェック
                if (w > MAXINT / (BASE - t)) return null;
                w *= (BASE - t);
                k += BASE;

            }while( digit >= t );

            const oLength = output.length + 1;
            bias = adapt(index - beforeIndex, oLength, firstOutputFlg);
            firstOutputFlg = false;

                // 桁溢れチェック
            if (index / oLength > MAXINT - codeNumber) return null;
            codeNumber += Math.floor(index / oLength);
            index %= oLength;

                // 配列に文字を挿入
            output.splice( index , 0 , codeNumber )
            index++;
        }while( inPos < input_length );

        return output.map( c=>String.fromCodePoint(c) ).join("");

    };

const test = s =>{
    const a1 = jsPunyCode.encode(s);
    if( s === a1 ) console.log( s , "対象ではありません" );
    else console.log( `${s}\n → ${a1}\n → ${ jsPunyCode.decode( a1 ) }`);
}

test("JavaScript");
test("Punycodeは国際化ドメイン名を、数値とアルファベットおよび記号で表現したものです。");
test("Hello!こんにちは-bye!さよなら");

JavaScript 対象ではありません
Punycodeは国際化ドメイン名を、数値とアルファベットおよび記号で表現したものです。                             
 → xn--Punycode-mm3gka50fye0a7fxfcm6im7f7ple2jlnya2cx7dieva97aje2klm9ij590hmfwanohqxas20gxd2kfzofggzhxfpa903k
 → punycodeは国際化ドメイン名を、数値とアルファベットおよび記号で表現したものです。                          
Hello!こんにちは-bye!さよなら                                                                                
 → xn--Hello!-bye! -u63k7a5nzfj7e5zva2r                                                                      
 → hello!こんにちは-bye!さよなら