Subversion-Projekte lars-tiefland.cienc

/*
 * Copyright (c) 2012 chick307 <chick307@gmail.com>
 *
 * Licensed under the MIT License.
 * http://opensource.org/licenses/mit-license
 */

void function(global, callback) {
        if (typeof module === 'object') {
                module.exports = callback();
        } else if (typeof define === 'function') {
                define(callback);
        } else {
                global.adler32cs = callback();
        }
}(this, function() {
        var _hasArrayBuffer = typeof ArrayBuffer === 'function' &&
                typeof Uint8Array === 'function';

        var _Buffer = null, _isBuffer = (function() {
                if (!_hasArrayBuffer)
                        return function _isBuffer() { return false };

                try {
                        var buffer = require('buffer');
                        if (typeof buffer.Buffer === 'function')
                                _Buffer = buffer.Buffer;
                } catch (error) {}

                return function _isBuffer(value) {
                        return value instanceof ArrayBuffer ||
                                _Buffer !== null && value instanceof _Buffer;
                };
        }());

        var _utf8ToBinary = (function() {
                if (_Buffer !== null) {
                        return function _utf8ToBinary(utf8String) {
                                return new _Buffer(utf8String, 'utf8').toString('binary');
                        };
                } else {
                        return function _utf8ToBinary(utf8String) {
                                return unescape(encodeURIComponent(utf8String));
                        };
                }
        }());

        var MOD = 65521;

        var _update = function _update(checksum, binaryString) {
                var a = checksum & 0xFFFF, b = checksum >>> 16;
                for (var i = 0, length = binaryString.length; i < length; i++) {
                        a = (a + (binaryString.charCodeAt(i) & 0xFF)) % MOD;
                        b = (b + a) % MOD;
                }
                return (b << 16 | a) >>> 0;
        };

        var _updateUint8Array = function _updateUint8Array(checksum, uint8Array) {
                var a = checksum & 0xFFFF, b = checksum >>> 16;
                for (var i = 0, length = uint8Array.length, x; i < length; i++) {
                        a = (a + uint8Array[i]) % MOD;
                        b = (b + a) % MOD;
                }
                return (b << 16 | a) >>> 0
        };

        var exports = {};

        var Adler32 = exports.Adler32 = (function() {
                var ctor = function Adler32(checksum) {
                        if (!(this instanceof ctor)) {
                                throw new TypeError(
                                        'Constructor cannot called be as a function.');
                        }
                        if (!isFinite(checksum = checksum == null ? 1 : +checksum)) {
                                throw new Error(
                                        'First arguments needs to be a finite number.');
                        }
                        this.checksum = checksum >>> 0;
                };

                var proto = ctor.prototype = {};
                proto.constructor = ctor;

                ctor.from = function(from) {
                        from.prototype = proto;
                        return from;
                }(function from(binaryString) {
                        if (!(this instanceof ctor)) {
                                throw new TypeError(
                                        'Constructor cannot called be as a function.');
                        }
                        if (binaryString == null)
                                throw new Error('First argument needs to be a string.');
                        this.checksum = _update(1, binaryString.toString());
                });

                ctor.fromUtf8 = function(fromUtf8) {
                        fromUtf8.prototype = proto;
                        return fromUtf8;
                }(function fromUtf8(utf8String) {
                        if (!(this instanceof ctor)) {
                                throw new TypeError(
                                        'Constructor cannot called be as a function.');
                        }
                        if (utf8String == null)
                                throw new Error('First argument needs to be a string.');
                        var binaryString = _utf8ToBinary(utf8String.toString());
                        this.checksum = _update(1, binaryString);
                });

                if (_hasArrayBuffer) {
                        ctor.fromBuffer = function(fromBuffer) {
                                fromBuffer.prototype = proto;
                                return fromBuffer;
                        }(function fromBuffer(buffer) {
                                if (!(this instanceof ctor)) {
                                        throw new TypeError(
                                                'Constructor cannot called be as a function.');
                                }
                                if (!_isBuffer(buffer))
                                        throw new Error('First argument needs to be ArrayBuffer.');
                                var array = new Uint8Array(buffer);
                                return this.checksum = _updateUint8Array(1, array);
                        });
                }

                proto.update = function update(binaryString) {
                        if (binaryString == null)
                                throw new Error('First argument needs to be a string.');
                        binaryString = binaryString.toString();
                        return this.checksum = _update(this.checksum, binaryString);
                };

                proto.updateUtf8 = function updateUtf8(utf8String) {
                        if (utf8String == null)
                                throw new Error('First argument needs to be a string.');
                        var binaryString = _utf8ToBinary(utf8String.toString());
                        return this.checksum = _update(this.checksum, binaryString);
                };

                if (_hasArrayBuffer) {
                        proto.updateBuffer = function updateBuffer(buffer) {
                                if (!_isBuffer(buffer))
                                        throw new Error('First argument needs to be ArrayBuffer.');
                                var array = new Uint8Array(buffer);
                                return this.checksum = _updateUint8Array(this.checksum, array);
                        };
                }

                proto.clone = function clone() {
                        return new Adler32(this.checksum);
                };

                return ctor;
        }());

        exports.from = function from(binaryString) {
                if (binaryString == null)
                        throw new Error('First argument needs to be a string.');
                return _update(1, binaryString.toString());
        };

        exports.fromUtf8 = function fromUtf8(utf8String) {
                if (utf8String == null)
                        throw new Error('First argument needs to be a string.');
                var binaryString = _utf8ToBinary(utf8String.toString());
                return _update(1, binaryString);
        };

        if (_hasArrayBuffer) {
                exports.fromBuffer = function fromBuffer(buffer) {
                        if (!_isBuffer(buffer))
                                throw new Error('First argument need to be ArrayBuffer.');
                        var array = new Uint8Array(buffer);
                        return _updateUint8Array(1, array);
                };
        }

        return exports;
});