Microsoft JScript runtime error Object doesn't support this property or method

Question

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: http://jssha.sourceforge.net/ to use the hmac-sha1 algorithm encryption. Thank you!

hmacObj = new jsSHA(signature_base_string,"HEX");

signature = hmacObj.getHMAC(signature_key,"HEX","SHA-1","HEX");

Above this i have copied the code from sha.js

snippet:

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;

The function it is calling (inside of the jsSHA function)

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 < (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] &= 0xFFFFFF00;
        } else if (blockByteSize > (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] &= 0xFFFFFF00;
        }

        // Create ipad and opad
        for (var i = 0; i <= 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));
    };

Answer 1

So i discovered that when I was instancing the object it was not creating the actual function within it. With some tweaking i was able to get it to show up and was able to call the function.

Also noticing that calling Object.getHMAC(String,string,string,string) doesn't always understand that your string is compatible with its function. Thanks all to those who helped. (John & Sean)