Properly encode strings to UTF8 bytes, see #4

Author: dcodeIO

bcrypt.js

@@ -157,6 +157,141 @@
         }
         return res;
     };    
+    // ref: http://mths.be/fromcodepoint v0.1.0 by @mathias
+    /* if (!String.fromCodePoint) {
+        (function () {
+            var defineProperty = (function () {
+                // IE 8 only supports `Object.defineProperty` on DOM elements
+                try {
+                    var object = {};
+                    var $defineProperty = Object.defineProperty;
+                    var result = $defineProperty(object, object, object) && $defineProperty;
+                } catch (error) {
+                }
+                return result;
+            }());
+            var stringFromCharCode = String.fromCharCode;
+            var floor = Math.floor;
+            var fromCodePoint = function () {
+                var MAX_SIZE = 0x4000;
+                var codeUnits = [];
+                var highSurrogate;
+                var lowSurrogate;
+                var index = -1;
+                var length = arguments.length;
+                if (!length)
+                    return '';
+                var result = '';
+                while (++index < length) {
+                    var codePoint = Number(arguments[index]);
+                    if (
+                        !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
+                            codePoint < 0 || // not a valid Unicode code point
+                            codePoint > 0x10FFFF || // not a valid Unicode code point
+                            floor(codePoint) != codePoint // not an integer
+                        ) {
+                        throw RangeError('Invalid code point: ' + codePoint);
+                    }
+                    if (codePoint <= 0xFFFF) { // BMP code point
+                        codeUnits.push(codePoint);
+                    } else { // Astral code point; split in surrogate halves
+                        // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+                        codePoint -= 0x10000;
+                        highSurrogate = (codePoint >> 10) + 0xD800;
+                        lowSurrogate = (codePoint % 0x400) + 0xDC00;
+                        codeUnits.push(highSurrogate, lowSurrogate);
+                    }
+                    if (index + 1 == length || codeUnits.length > MAX_SIZE) {
+                        result += stringFromCharCode.apply(null, codeUnits);
+                        codeUnits.length = 0;
+                    }
+                }
+                return result;
+            };
+            if (defineProperty) {
+                defineProperty(String, 'fromCodePoint', {
+                    'value': fromCodePoint,
+                    'configurable': true,
+                    'writable': true
+                });
+            } else {
+                String["fromCodePoint"] = fromCodePoint;
+            }
+        }());
+    } */
+    
+    // ref: http://mths.be/codepointat v0.1.0 by @mathias
+    if (!String.prototype.codePointAt) {
+        (function() {
+            'use strict'; // needed to support `apply`/`call` with `undefined`/`null`
+            var codePointAt = function(position) {
+                if (this == null) {
+                    throw TypeError();
+                }
+                var string = String(this);
+                var size = string.length;
+                // `ToInteger`
+                var index = position ? Number(position) : 0;
+                if (index != index) { // better `isNaN`
+                    index = 0;
+                }
+                // Account for out-of-bounds indices:
+                if (index < 0 || index >= size) {
+                    return undefined;
+                }
+                // Get the first code unit
+                var first = string.charCodeAt(index);
+                var second;
+                if ( // check if it’s the start of a surrogate pair
+                    first >= 0xD800 && first <= 0xDBFF && // high surrogate
+                        size > index + 1 // there is a next code unit
+                    ) {
+                    second = string.charCodeAt(index + 1);
+                    if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate
+                        // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+                        return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
+                    }
+                }
+                return first;
+            };
+            if (Object.defineProperty) {
+                Object.defineProperty(String.prototype, 'codePointAt', {
+                    'value': codePointAt,
+                    'configurable': true,
+                    'writable': true
+                });
+            } else {
+                String.prototype["codePointAt"] = codePointAt;
+            }
+        }());
+    }
+        
+    /**
+     * Encodes a unicode code point to bytes.
+     * @param {number} codePoint Code point to encode
+     * @param {Array.<number>} out Output array
+     */
+    function utf8_encode_char(codePoint, out) {
+        if (codePoint < 0)
+            throw RangeError("Illegal code point: "+codePoint);
+        if (codePoint < 0x80) {
+            out.push(  codePoint     &0x7F);
+        } else if (codePoint < 0x800) {
+            out.push(((codePoint>>6 )&0x1F)|0xC0);
+            out.push(( codePoint     &0x3F)|0x80);
+        } else if (codePoint < 0x10000) {
+            out.push(((codePoint>>12)&0x0F)|0xE0);
+            out.push(((codePoint>>6 )&0x3F)|0x80);
+            out.push(( codePoint     &0x3F)|0x80);
+        } else if (codePoint < 0x110000) {
+            out.push(((codePoint>>18)&0x07)|0xF0);
+            out.push(((codePoint>>12)&0x3F)|0x80);
+            out.push(((codePoint>>6 )&0x3F)|0x80);
+            out.push(( codePoint     &0x3F)|0x80);
+        } else
+            throw RangeError("Illegal code point: "+codePoint);
+    }
+        
     /**
      * bcrypt namespace.
      * @type {Object.<string,*>}
@@ -656,18 +791,17 @@
         }
     }
 
-    function _stringToBytes ( str ) {
-        var ch, st, re = [];
-        for (var i = 0; i < str.length; i++ ) {
-            ch = str.charCodeAt(i);
-            st = [];
-            do {
-                st.push( ch & 0xFF );
-                ch = ch >> 8;
-            } while (ch);
-            re = re.concat( st.reverse() );
-        }
-        return re;
+    function _stringToBytes(str) {
+        var cp, out = [];
+        for (var i=0; i<str.length; i++) {
+            cp = str.charCodeAt(i);
+            if (cp >= 0xD800 && cp <= 0xDFFF) {
+                cp = str.codePointAt(i);
+                if (cp > 0xFFFF) i++;
+            }
+            utf8_encode_char(cp, out);
+        }
+        return out;
     }
 
     /**