Microsoft JScript runtime error Object doesn't support this property or method
<p>So i am trying to call this function in my javascript but it gives me the error of "Microsoft JScript runtime error Object doesn't support this property or method" and i cant figure out why. It is occuring when trying to call hmacObj.getHMAC.  This is from the jsSHA website: <a href="http://jssha.sourceforge.net/" rel="nofollow">http://jssha.sourceforge.net/</a> to use the hmac-sha1 algorithm encryption.  Thank you!</p>

<pre><code>hmacObj = new jsSHA(signature_base_string,"HEX");

signature = hmacObj.getHMAC(signature_key,"HEX","SHA-1","HEX");
</code></pre>

<p>Above this i have copied the code from sha.js </p>

<p>snippet: </p>

<pre><code>function jsSHA(srcString, inputFormat) {

 /*
  * Configurable variables. Defaults typically work
  */
 jsSHA.charSize = 8; // Number of Bits Per character (8 for ASCII, 16 for Unicode)
 jsSHA.b64pad  = ""; // base-64 pad character. "=" for strict RFC compliance
 jsSHA.hexCase = 0; // hex output format. 0 - lowercase; 1 - uppercase

 var sha1 = null;
 var sha224 = null;
</code></pre>

<p>The function it is calling (inside of the jsSHA function)</p>

<pre><code>this.getHMAC = function (key, inputFormat, variant, outputFormat) {
        var formatFunc = null;
        var keyToUse = null;
        var blockByteSize = null;
        var blockBitSize = null;
        var keyWithIPad = [];
        var keyWithOPad = [];
        var lastArrayIndex = null;
        var retVal = null;
        var keyBinLen = null;
        var hashBitSize = null;

        // Validate the output format selection
        switch (outputFormat) {
        case "HEX":
            formatFunc = binb2hex;
            break;
        case "B64":
            formatFunc = binb2b64;
            break;
        default:
            return "FORMAT NOT RECOGNIZED";
        }

        // Validate the hash variant selection and set needed variables
        switch (variant) {
        case "SHA-1":
            blockByteSize = 64;
            hashBitSize = 160;
            break;
        case "SHA-224":
            blockByteSize = 64;
            hashBitSize = 224;
            break;
        case "SHA-256":
            blockByteSize = 64;
            hashBitSize = 256;
            break;
        case "SHA-384":
            blockByteSize = 128;
            hashBitSize = 384;
            break;
        case "SHA-512":
            blockByteSize = 128;
            hashBitSize = 512;
            break;
        default:
            return "HASH NOT RECOGNIZED";
        }

        // Validate input format selection
        if ("HEX" === inputFormat) {
            // Nibbles must come in pairs
            if (0 !== (key.length % 2)) {
                return "KEY MUST BE IN BYTE INCREMENTS";
            }
            keyToUse = hex2binb(key);
            keyBinLen = key.length * 4;
        } else if ("ASCII" === inputFormat) {
            keyToUse = str2binb(key);
            keyBinLen = key.length * jsSHA.charSize;
        } else {
            return "UNKNOWN KEY INPUT TYPE";
        }

        // These are used multiple times, calculate and store them
        blockBitSize = blockByteSize * 8;
        lastArrayIndex = (blockByteSize / 4) - 1;

        // Figure out what to do with the key based on its size relative to
        // the hash's block size
        if (blockByteSize &lt; (keyBinLen / 8)) {
            if ("SHA-1" === variant) {
                keyToUse = coreSHA1(keyToUse, keyBinLen);
            } else {
                keyToUse = coreSHA2(keyToUse, keyBinLen, variant);
            }
            // For all variants, the block size is bigger than the output size
            // so there will never be a useful byte at the end of the string
            keyToUse[lastArrayIndex] &amp;= 0xFFFFFF00;
        } else if (blockByteSize &gt; (keyBinLen / 8)) {
            // If the blockByteSize is greater than the key length, there will
            // always be at LEAST one "useless" byte at the end of the string
            keyToUse[lastArrayIndex] &amp;= 0xFFFFFF00;
        }

        // Create ipad and opad
        for (var i = 0; i &lt;= lastArrayIndex; i++) {
            keyWithIPad[i] = keyToUse[i] ^ 0x36363636;
            keyWithOPad[i] = keyToUse[i] ^ 0x5C5C5C5C;
        }

        // Calculate the HMAC
        if ("SHA-1" === variant) {
            retVal = coreSHA1(keyWithIPad.concat(strToHash), blockBitSize + strBinLen);
            retVal = coreSHA1(keyWithOPad.concat(retVal), blockBitSize + hashBitSize);
        } else {
            retVal = coreSHA2(keyWithIPad.concat(strToHash), blockBitSize + strBinLen, variant);
            retVal = coreSHA2(keyWithOPad.concat(retVal), blockBitSize + hashBitSize, variant);
        }

        return (formatFunc(retVal));
    };
</code></pre>
