@datawrapper/jschardet 3.0.1-0

package/src/big5prober.js

@@ -0,0 +1,54 @@
+/*
+ * The Original Code is Mozilla Universal charset detector code.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 2001
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   António Afonso (antonio.afonso gmail.com) - port to JavaScript
+ *   Mark Pilgrim - port to Python
+ *   Shy Shalom - original C code
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301  USA
+ */
+
+var CodingStateMachine = require('./codingstatemachine')
+var MultiByteCharSetProber = require('./mbcharsetprober')
+var Big5SMModel = require('./mbcssm/big5')
+var Big5DistributionAnalysis = require('./chardistribution').Big5DistributionAnalysis
+
+function Big5Prober() {
+    MultiByteCharSetProber.apply(this);
+
+    var self = this;
+
+    function init() {
+        self._mCodingSM = new CodingStateMachine(Big5SMModel);
+        self._mDistributionAnalyzer = new Big5DistributionAnalysis();
+        self.reset();
+    }
+
+    this.getCharsetName = function() {
+        return "Big5";
+    }
+
+    init();
+}
+Big5Prober.prototype = new MultiByteCharSetProber();
+
+module.exports = Big5Prober

package/src/chardistribution.js

@@ -0,0 +1,301 @@
+/*
+ * The Original Code is Mozilla Universal charset detector code.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 2001
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   António Afonso (antonio.afonso gmail.com) - port to JavaScript
+ *   Mark Pilgrim - port to Python
+ *   Shy Shalom - original C code
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301  USA
+ */
+
+var jisfreq = require('./jisfreq');
+var euctwfreq = require('./euctwfreq');
+var euckrfreq = require('./euckrfreq');
+var gb2312freq = require('./gb2312freq');
+var big5freq = require('./big5freq');
+
+function CharDistributionAnalysis() {
+    var ENOUGH_DATA_THRESHOLD = 1024;
+    var SURE_YES = 0.99;
+    var SURE_NO = 0.01;
+    var MINIMUM_DATA_THRESHOLD = 3;
+
+    var self = this;
+
+    function init() {
+        self._mCharToFreqOrder = null; // Mapping table to get frequency order from char order (get from GetOrder())
+        self._mTableSize = null; // Size of above table
+        self._mTypicalDistributionRatio = null; // This is a constant value which varies from language to language, used in calculating confidence.  See http://www.mozilla.org/projects/intl/UniversalCharsetDetection.html for further detail.
+        self.reset();
+    }
+
+    /**
+     * reset analyser, clear any state
+     */
+    this.reset = function() {
+        this._mDone = false; // If this flag is set to constants.True, detection is done and conclusion has been made
+        this._mTotalChars = 0; // Total characters encountered
+        this._mFreqChars = 0; // The number of characters whose frequency order is less than 512
+    }
+
+    /**
+     * feed a character with known length
+     */
+    this.feed = function(aStr, aCharLen) {
+        if( aCharLen == 2 ) {
+            // we only care about 2-bytes character in our distribution analysis
+            var order = this.getOrder(aStr);
+        } else {
+            order = -1;
+        }
+        if( order >= 0 ) {
+            this._mTotalChars++;
+            // order is valid
+            if( order < this._mTableSize ) {
+                if( 512 > this._mCharToFreqOrder[order] ) {
+                    this._mFreqChars++;
+                }
+            }
+        }
+    }
+
+    /**
+     * return confidence based on existing data
+     */
+    this.getConfidence = function() {
+        // if we didn't receive any character in our consideration range, return negative answer
+        if( this._mTotalChars <= 0 || this._mFreqChars <= MINIMUM_DATA_THRESHOLD) {
+            return SURE_NO;
+        }
+        if( this._mTotalChars != this._mFreqChars ) {
+            var r = this._mFreqChars / ((this._mTotalChars - this._mFreqChars) * this._mTypicalDistributionRatio);
+            if( r < SURE_YES ) {
+                return r;
+            }
+        }
+
+        // normalize confidence (we don't want to be 100% sure)
+        return SURE_YES;
+    }
+
+    this.gotEnoughData = function() {
+        // It is not necessary to receive all data to draw conclusion. For charset detection,
+        // certain amount of data is enough
+        return this._mTotalChars > ENOUGH_DATA_THRESHOLD;
+    }
+
+    this.getOrder = function(aStr) {
+        // We do not handle characters based on the original encoding string, but
+        // convert this encoding string to a number, here called order.
+        // This allows multiple encodings of a language to share one frequency table.
+        return -1;
+    }
+
+    init();
+}
+
+exports.CharDistributionAnalysis = CharDistributionAnalysis
+
+function EUCTWDistributionAnalysis() {
+    CharDistributionAnalysis.apply(this);
+
+    var self = this;
+
+    function init() {
+        self._mCharToFreqOrder = euctwfreq.EUCTWCharToFreqOrder;
+        self._mTableSize = euctwfreq.EUCTW_TABLE_SIZE;
+        self._mTypicalDistributionRatio = euctwfreq.EUCTW_TYPICAL_DISTRIBUTION_RATIO;
+    }
+
+    this.getOrder = function(aStr) {
+        // for euc-TW encoding, we are interested
+        //   first  byte range: 0xc4 -- 0xfe
+        //   second byte range: 0xa1 -- 0xfe
+        // no validation needed here. State machine has done that
+        if( aStr.charCodeAt(0) >= 0xC4 ) {
+            return 94 * (aStr.charCodeAt(0) - 0xC4) + aStr.charCodeAt(1) - 0xA1;
+        } else {
+            return -1;
+        }
+    }
+
+    init();
+}
+EUCTWDistributionAnalysis.prototype = new CharDistributionAnalysis();
+
+exports.EUCTWDistributionAnalysis = EUCTWDistributionAnalysis
+
+function EUCKRDistributionAnalysis() {
+    CharDistributionAnalysis.apply(this);
+
+    var self = this;
+
+    function init() {
+        self._mCharToFreqOrder = euckrfreq.EUCKRCharToFreqOrder;
+        self._mTableSize = euckrfreq.EUCKR_TABLE_SIZE;
+        self._mTypicalDistributionRatio = euckrfreq.EUCKR_TYPICAL_DISTRIBUTION_RATIO;
+    }
+
+    this.getOrder = function(aStr) {
+        // for euc-KR encoding, we are interested
+        //   first  byte range: 0xb0 -- 0xfe
+        //   second byte range: 0xa1 -- 0xfe
+        // no validation needed here. State machine has done that
+        if( aStr.charCodeAt(0) >= 0xB0 ) {
+            return 94 * (aStr.charCodeAt(0) - 0xB0) + aStr.charCodeAt(1) - 0xA1;
+        } else {
+            return -1;
+        }
+    }
+
+    init();
+}
+EUCKRDistributionAnalysis.prototype = new CharDistributionAnalysis();
+
+exports.EUCKRDistributionAnalysis = EUCKRDistributionAnalysis
+
+function GB2312DistributionAnalysis() {
+    CharDistributionAnalysis.apply(this);
+
+    var self = this;
+
+    function init() {
+        self._mCharToFreqOrder = gb2312freq.GB2312CharToFreqOrder;
+        self._mTableSize = gb2312freq.GB2312_TABLE_SIZE;
+        self._mTypicalDistributionRatio = gb2312freq.GB2312_TYPICAL_DISTRIBUTION_RATIO;
+    }
+
+    this.getOrder = function(aStr) {
+        // for GB2312 encoding, we are interested
+        //  first  byte range: 0xb0 -- 0xfe
+        //  second byte range: 0xa1 -- 0xfe
+        // no validation needed here. State machine has done that
+        if( aStr.charCodeAt(0) >= 0xB0 && aStr.charCodeAt(1) >= 0xA1 ) {
+            return 94 * (aStr.charCodeAt(0) - 0xB0) + aStr.charCodeAt(1) - 0xA1;
+        } else {
+            return -1;
+        }
+    }
+
+    init();
+}
+GB2312DistributionAnalysis.prototype = new CharDistributionAnalysis();
+
+exports.GB2312DistributionAnalysis = GB2312DistributionAnalysis
+
+function Big5DistributionAnalysis() {
+    CharDistributionAnalysis.apply(this);
+
+    var self = this;
+
+    function init() {
+        self._mCharToFreqOrder = big5freq.Big5CharToFreqOrder;
+        self._mTableSize = big5freq.BIG5_TABLE_SIZE;
+        self._mTypicalDistributionRatio = big5freq.BIG5_TYPICAL_DISTRIBUTION_RATIO;
+    }
+
+    this.getOrder = function(aStr) {
+        // for big5 encoding, we are interested
+        //   first  byte range: 0xa4 -- 0xfe
+        //   second byte range: 0x40 -- 0x7e , 0xa1 -- 0xfe
+        // no validation needed here. State machine has done that
+        if( aStr.charCodeAt(0) >= 0xA4 ) {
+            if( aStr.charCodeAt(1) >= 0xA1 ) {
+                return 157 * (aStr.charCodeAt(0) - 0xA4) + aStr.charCodeAt(1) - 0xA1 + 63;
+            } else {
+                return 157 * (aStr.charCodeAt(0) - 0xA4) + aStr.charCodeAt(1) - 0x40;
+            }
+        } else {
+            return -1;
+        }
+    }
+
+    init();
+}
+Big5DistributionAnalysis.prototype = new CharDistributionAnalysis();
+
+exports.Big5DistributionAnalysis = Big5DistributionAnalysis
+
+function SJISDistributionAnalysis() {
+    CharDistributionAnalysis.apply(this);
+
+    var self = this;
+
+    function init() {
+        self._mCharToFreqOrder = jisfreq.JISCharToFreqOrder;
+        self._mTableSize = jisfreq.JIS_TABLE_SIZE;
+        self._mTypicalDistributionRatio = jisfreq.JIS_TYPICAL_DISTRIBUTION_RATIO;
+    }
+
+    this.getOrder = function(aStr) {
+        // for sjis encoding, we are interested
+        //   first  byte range: 0x81 -- 0x9f , 0xe0 -- 0xef
+        //   second byte range: 0x40 -- 0x7e,  0x80 -- 0xfc
+        // no validation needed here. State machine has done that
+        if( aStr.charCodeAt(0) >= 0x81 && aStr.charCodeAt(0) <= 0x9F ) {
+            var order = 188 * (aStr.charCodeAt(0) - 0x81);
+        } else if( aStr.charCodeAt(0) >= 0xE0 && aStr.charCodeAt(0) <= 0xEF ) {
+            order = 188 * (aStr.charCodeAt(0) - 0xE0 + 31);
+        } else {
+            return -1;
+        }
+        order += aStr.charCodeAt(1) - 0x40;
+        if( aStr.charCodeAt(1) < 0x40 || aStr.charCodeAt(1) === 0x7F || aStr.charCodeAt(1) > 0xFC) {
+            order = -1;
+        }
+        return order;
+    }
+
+    init();
+}
+SJISDistributionAnalysis.prototype = new CharDistributionAnalysis();
+
+exports.SJISDistributionAnalysis = SJISDistributionAnalysis
+
+function EUCJPDistributionAnalysis() {
+    CharDistributionAnalysis.apply(this);
+
+    var self = this;
+
+    function init() {
+        self._mCharToFreqOrder = jisfreq.JISCharToFreqOrder;
+        self._mTableSize = jisfreq.JIS_TABLE_SIZE;
+        self._mTypicalDistributionRatio = jisfreq.JIS_TYPICAL_DISTRIBUTION_RATIO;
+    }
+
+    this.getOrder = function(aStr) {
+        // for euc-JP encoding, we are interested
+        //   first  byte range: 0xa0 -- 0xfe
+        //   second byte range: 0xa1 -- 0xfe
+        // no validation needed here. State machine has done that
+        if( aStr[0] >= "\xA0" ) {
+            return 94 * (aStr.charCodeAt(0) - 0xA1) + aStr.charCodeAt(1) - 0xA1;
+        } else {
+            return -1;
+        }
+    }
+
+    init();
+}
+EUCJPDistributionAnalysis.prototype = new CharDistributionAnalysis();
+
+exports.EUCJPDistributionAnalysis = EUCJPDistributionAnalysis

package/src/charsetgroupprober.js

@@ -0,0 +1,120 @@
+/*
+ * The Original Code is Mozilla Universal charset detector code.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 2001
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   António Afonso (antonio.afonso gmail.com) - port to JavaScript
+ *   Mark Pilgrim - port to Python
+ *   Shy Shalom - original C code
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301  USA
+ */
+
+var constants = require('./constants');
+var CharSetProber = require('./charsetprober');
+var logger = require('./logger');
+
+function CharSetGroupProber() {
+    CharSetProber.apply(this);
+
+    var self = this;
+
+    function init() {
+        self._mActiveNum = 0;
+        self._mProbers = [];
+        self._mBestGuessProber = null;
+    }
+
+    this.reset = function() {
+        CharSetGroupProber.prototype.reset.apply(this);
+        this._mActiveNum = 0;
+        for( var i = 0, prober; prober = this._mProbers[i]; i++ ) {
+            if( prober ) {
+                prober.reset();
+                prober.active = true;
+                this._mActiveNum++;
+            }
+        }
+        this._mBestGuessProber = null;
+    }
+
+    this.getCharsetName = function() {
+        if( !this._mBestGuessProber ) {
+            this.getConfidence();
+            if( !this._mBestGuessProber ) return null;
+        }
+        return this._mBestGuessProber.getCharsetName();
+    }
+
+    this.getSupportedCharsetNames = function() {
+        throw new Error("Unimplemented method getSupportedCharsetNames()");
+    }
+
+    this.feed = function(aBuf) {
+        for( var i = 0, prober; prober = this._mProbers[i]; i++ ) {
+            if( !prober || !prober.active ) continue;
+            var st = prober.feed(aBuf);
+            if( !st ) continue;
+            if( st == constants.foundIt ) {
+                this._mBestGuessProber = prober;
+                return this.getState();
+            } else if( st == constants.notMe ) {
+                prober.active = false;
+                this._mActiveNum--;
+                if( this._mActiveNum <= 0 ) {
+                    this._mState = constants.notMe;
+                    return this.getState();
+                }
+            }
+        }
+        return this.getState();
+    }
+
+    this.getConfidence = function() {
+        var st = this.getState();
+        if( st == constants.foundIt ) {
+            return 0.99;
+        } else if( st == constants.notMe ) {
+            return 0.01;
+        }
+        var bestConf = 0.0;
+        this._mBestGuessProber = null;
+        for( var i = 0, prober; prober = this._mProbers[i]; i++ ) {
+            if( !prober ) continue;
+            if( !prober.active ) {
+                logger.log(prober.getCharsetName() + " not active\n");
+                continue;
+            }
+            var cf = prober.getConfidence();
+            logger.log(prober.getCharsetName() + " confidence = " + cf + "\n");
+            if( bestConf < cf ) {
+                bestConf = cf;
+                this._mBestGuessProber = prober;
+            }
+        }
+        if( !this._mBestGuessProber ) return 0.0;
+        return bestConf;
+    }
+
+    init();
+}
+CharSetGroupProber.prototype = new CharSetProber();
+
+module.exports = CharSetGroupProber

package/src/charsetprober.js

@@ -0,0 +1,104 @@
+/*
+ * The Original Code is Mozilla Universal charset detector code.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 2001
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   António Afonso (antonio.afonso gmail.com) - port to JavaScript
+ *   Mark Pilgrim - port to Python
+ *   Shy Shalom - original C code
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301  USA
+ */
+
+var constants = require('./constants')
+
+function CharSetProber() {
+    this.reset = function() {
+        this._mState = constants.detecting;
+    }
+
+    this.getCharsetName = function() {
+        return null;
+    }
+
+    this.getSupportedCharsetNames = function() {
+      throw new Error("Unimplemented method getSupportedCharsetNames()");
+    }
+
+    this.feed = function(aBuf) {
+    }
+
+    this.getState = function() {
+        return this._mState;
+    }
+
+    this.getConfidence = function() {
+        return 0.0;
+    }
+
+    this.filterHighBitOnly = function(aBuf) {
+        aBuf = aBuf.replace(/[\x00-\x7F]+/g, " ");
+        return aBuf;
+    }
+
+    this.filterWithoutEnglishLetters = function(aBuf) {
+        aBuf = aBuf.replace(/[A-Za-z]+/g, " ");
+        return aBuf;
+    }
+
+    // Input: aBuf is a string containing all different types of characters
+    // Output: a string that contains all alphabetic letters, high-byte characters, and word immediately preceding `>`, but nothing else within `<>`
+    // Ex: input - '¡£º <div blah blah> abcdef</div> apples! * and oranges 9jd93jd>'
+    //     output - '¡£º blah div apples and oranges jd jd '
+    this.filterWithEnglishLetters = function(aBuf) {
+        var result = '';
+        var inTag = false;
+        var prev = 0;
+
+        for (var curr = 0; curr < aBuf.length; curr++) {
+          var c = aBuf[curr];
+
+          if (c == '>') {
+            inTag = false;
+          } else if (c == '<') {
+            inTag = true;
+          }
+
+          var isAlpha = /[a-zA-Z]/.test(c);
+          var isASCII = /^[\x00-\x7F]*$/.test(c);
+
+          if (isASCII && !isAlpha) {
+            if (curr > prev && !inTag) {
+              result = result + aBuf.substring(prev, curr) + ' ';
+            }
+
+            prev = curr + 1;
+          }
+        }
+
+        if (!inTag) {
+          result = result + aBuf.substring(prev);
+        }
+
+        return result;
+    }
+}
+
+module.exports = CharSetProber

package/src/codingstatemachine.js

@@ -0,0 +1,71 @@
+/*
+ * The Original Code is Mozilla Universal charset detector code.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 2001
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   António Afonso (antonio.afonso gmail.com) - port to JavaScript
+ *   Mark Pilgrim - port to Python
+ *   Shy Shalom - original C code
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301  USA
+ */
+
+var constants = require('./constants')
+
+function CodingStateMachine(sm) {
+    var self = this;
+
+    function init(sm) {
+        self._mModel = sm;
+        self._mCurrentBytePos = 0;
+        self._mCurrentCharLen = 0;
+        self.reset();
+    }
+
+    this.reset = function() {
+        this._mCurrentState = constants.start;
+    }
+
+    this.nextState = function(c) {
+        // for each byte we get its class
+        // if it is first byte, we also get byte length
+        var byteCls = this._mModel.classTable[c.charCodeAt(0)];
+        if( this._mCurrentState == constants.start ) {
+            this._mCurrentBytePos = 0;
+            this._mCurrentCharLen = this._mModel.charLenTable[byteCls];
+        }
+        // from byte's class and stateTable, we get its next state
+        this._mCurrentState = this._mModel.stateTable[this._mCurrentState * this._mModel.classFactor + byteCls];
+        this._mCurrentBytePos++;
+        return this._mCurrentState;
+    }
+
+    this.getCurrentCharLen = function() {
+        return this._mCurrentCharLen;
+    }
+
+    this.getCodingStateMachine = function() {
+        return this._mModel.name;
+    }
+
+    init(sm);
+}
+
+module.exports = CodingStateMachine

package/src/constants.js

@@ -0,0 +1,40 @@
+/*
+ * The Original Code is Mozilla Universal charset detector code.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 2001
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   António Afonso (antonio.afonso gmail.com) - port to JavaScript
+ *   Mark Pilgrim - port to Python
+ *   Shy Shalom - original C code
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301  USA
+ */
+
+module.exports = {
+    detecting   : 0,
+    foundIt     : 1,
+    notMe       : 2,
+
+    start       : 0,
+    error       : 1,
+    itsMe       : 2,
+
+    SHORTCUT_THRESHOLD  : 0.95
+};