(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Rabin = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i>> 2] >>> 1; var offset = ptr >>> 1; if (length <= CHUNKSIZE) return String.fromCharCode.apply(String, U16.subarray(offset, offset + length)); const parts = []; do { const last = U16[offset + CHUNKSIZE - 1]; const size = last >= 0xD800 && last < 0xDC00 ? CHUNKSIZE - 1 : CHUNKSIZE; parts.push(String.fromCharCode.apply(String, U16.subarray(offset, offset += size))); length -= size; } while (length > CHUNKSIZE); return parts.join("") + String.fromCharCode.apply(String, U16.subarray(offset, offset + length)); } /** Prepares the base module prior to instantiation. */ function preInstantiate(imports) { const baseModule = {}; function getString(memory, ptr) { if (!memory) return ""; return getStringImpl(memory.buffer, ptr); } // add common imports used by stdlib for convenience const env = (imports.env = imports.env || {}); env.abort = env.abort || function abort(mesg, file, line, colm) { const memory = baseModule.memory || env.memory; // prefer exported, otherwise try imported throw Error("abort: " + getString(memory, mesg) + " at " + getString(memory, file) + ":" + line + ":" + colm); } env.trace = env.trace || function trace(mesg, n) { const memory = baseModule.memory || env.memory; console.log("trace: " + getString(memory, mesg) + (n ? " " : "") + Array.prototype.slice.call(arguments, 2, 2 + n).join(", ")); } imports.Math = imports.Math || Math; imports.Date = imports.Date || Date; return baseModule; } /** Prepares the final module once instantiation is complete. */ function postInstantiate(baseModule, instance) { const rawExports = instance.exports; const memory = rawExports.memory; const table = rawExports.table; const alloc = rawExports["__alloc"]; const retain = rawExports["__retain"]; const rttiBase = rawExports["__rtti_base"] || ~0; // oob if not present /** Gets the runtime type info for the given id. */ function getInfo(id) { const U32 = new Uint32Array(memory.buffer); const count = U32[rttiBase >>> 2]; if ((id >>>= 0) >= count) throw Error("invalid id: " + id); return U32[(rttiBase + 4 >>> 2) + id * 2]; } /** Gets the runtime base id for the given id. */ function getBase(id) { const U32 = new Uint32Array(memory.buffer); const count = U32[rttiBase >>> 2]; if ((id >>>= 0) >= count) throw Error("invalid id: " + id); return U32[(rttiBase + 4 >>> 2) + id * 2 + 1]; } /** Gets the runtime alignment of a collection's values. */ function getValueAlign(info) { return 31 - Math.clz32((info >>> VAL_ALIGN_OFFSET) & 31); // -1 if none } /** Gets the runtime alignment of a collection's keys. */ function getKeyAlign(info) { return 31 - Math.clz32((info >>> KEY_ALIGN_OFFSET) & 31); // -1 if none } /** Allocates a new string in the module's memory and returns its retained pointer. */ function __allocString(str) { const length = str.length; const ptr = alloc(length << 1, STRING_ID); const U16 = new Uint16Array(memory.buffer); for (var i = 0, p = ptr >>> 1; i < length; ++i) U16[p + i] = str.charCodeAt(i); return ptr; } baseModule.__allocString = __allocString; /** Reads a string from the module's memory by its pointer. */ function __getString(ptr) { const buffer = memory.buffer; const id = new Uint32Array(buffer)[ptr + ID_OFFSET >>> 2]; if (id !== STRING_ID) throw Error("not a string: " + ptr); return getStringImpl(buffer, ptr); } baseModule.__getString = __getString; /** Gets the view matching the specified alignment, signedness and floatness. */ function getView(alignLog2, signed, float) { const buffer = memory.buffer; if (float) { switch (alignLog2) { case 2: return new Float32Array(buffer); case 3: return new Float64Array(buffer); } } else { switch (alignLog2) { case 0: return new (signed ? Int8Array : Uint8Array)(buffer); case 1: return new (signed ? Int16Array : Uint16Array)(buffer); case 2: return new (signed ? Int32Array : Uint32Array)(buffer); case 3: return new (signed ? BigInt64Array : BigUint64Array)(buffer); } } throw Error("unsupported align: " + alignLog2); } /** Allocates a new array in the module's memory and returns its retained pointer. */ function __allocArray(id, values) { const info = getInfo(id); if (!(info & (ARRAYBUFFERVIEW | ARRAY))) throw Error("not an array: " + id + " @ " + info); const align = getValueAlign(info); const length = values.length; const buf = alloc(length << align, ARRAYBUFFER_ID); const arr = alloc(info & ARRAY ? ARRAY_SIZE : ARRAYBUFFERVIEW_SIZE, id); const U32 = new Uint32Array(memory.buffer); U32[arr + ARRAYBUFFERVIEW_BUFFER_OFFSET >>> 2] = retain(buf); U32[arr + ARRAYBUFFERVIEW_DATASTART_OFFSET >>> 2] = buf; U32[arr + ARRAYBUFFERVIEW_DATALENGTH_OFFSET >>> 2] = length << align; if (info & ARRAY) U32[arr + ARRAY_LENGTH_OFFSET >>> 2] = length; const view = getView(align, info & VAL_SIGNED, info & VAL_FLOAT); if (info & VAL_MANAGED) { for (let i = 0; i < length; ++i) view[(buf >>> align) + i] = retain(values[i]); } else { view.set(values, buf >>> align); } return arr; } baseModule.__allocArray = __allocArray; /** Gets a live view on an array's values in the module's memory. Infers the array type from RTTI. */ function __getArrayView(arr) { const U32 = new Uint32Array(memory.buffer); const id = U32[arr + ID_OFFSET >>> 2]; const info = getInfo(id); if (!(info & ARRAYBUFFERVIEW)) throw Error("not an array: " + id); const align = getValueAlign(info); var buf = U32[arr + ARRAYBUFFERVIEW_DATASTART_OFFSET >>> 2]; const length = info & ARRAY ? U32[arr + ARRAY_LENGTH_OFFSET >>> 2] : U32[buf + SIZE_OFFSET >>> 2] >>> align; return getView(align, info & VAL_SIGNED, info & VAL_FLOAT) .subarray(buf >>>= align, buf + length); } baseModule.__getArrayView = __getArrayView; /** Copies an array's values from the module's memory. Infers the array type from RTTI. */ function __getArray(arr) { const input = __getArrayView(arr); const len = input.length; const out = new Array(len); for (let i = 0; i < len; i++) out[i] = input[i]; return out; } baseModule.__getArray = __getArray; /** Copies an ArrayBuffer's value from the module's memory. */ function __getArrayBuffer(ptr) { const buffer = memory.buffer; const length = new Uint32Array(buffer)[ptr + SIZE_OFFSET >>> 2]; return buffer.slice(ptr, ptr + length); } baseModule.__getArrayBuffer = __getArrayBuffer; /** Copies a typed array's values from the module's memory. */ function getTypedArray(Type, alignLog2, ptr) { return new Type(getTypedArrayView(Type, alignLog2, ptr)); } /** Gets a live view on a typed array's values in the module's memory. */ function getTypedArrayView(Type, alignLog2, ptr) { const buffer = memory.buffer; const U32 = new Uint32Array(buffer); const bufPtr = U32[ptr + ARRAYBUFFERVIEW_DATASTART_OFFSET >>> 2]; return new Type(buffer, bufPtr, U32[bufPtr + SIZE_OFFSET >>> 2] >>> alignLog2); } baseModule.__getInt8Array = getTypedArray.bind(null, Int8Array, 0); baseModule.__getInt8ArrayView = getTypedArrayView.bind(null, Int8Array, 0); baseModule.__getUint8Array = getTypedArray.bind(null, Uint8Array, 0); baseModule.__getUint8ArrayView = getTypedArrayView.bind(null, Uint8Array, 0); baseModule.__getUint8ClampedArray = getTypedArray.bind(null, Uint8ClampedArray, 0); baseModule.__getUint8ClampedArrayView = getTypedArrayView.bind(null, Uint8ClampedArray, 0); baseModule.__getInt16Array = getTypedArray.bind(null, Int16Array, 1); baseModule.__getInt16ArrayView = getTypedArrayView.bind(null, Int16Array, 1); baseModule.__getUint16Array = getTypedArray.bind(null, Uint16Array, 1); baseModule.__getUint16ArrayView = getTypedArrayView.bind(null, Uint16Array, 1); baseModule.__getInt32Array = getTypedArray.bind(null, Int32Array, 2); baseModule.__getInt32ArrayView = getTypedArrayView.bind(null, Int32Array, 2); baseModule.__getUint32Array = getTypedArray.bind(null, Uint32Array, 2); baseModule.__getUint32ArrayView = getTypedArrayView.bind(null, Uint32Array, 2); if (BIGINT) { baseModule.__getInt64Array = getTypedArray.bind(null, BigInt64Array, 3); baseModule.__getInt64ArrayView = getTypedArrayView.bind(null, BigInt64Array, 3); baseModule.__getUint64Array = getTypedArray.bind(null, BigUint64Array, 3); baseModule.__getUint64ArrayView = getTypedArrayView.bind(null, BigUint64Array, 3); } baseModule.__getFloat32Array = getTypedArray.bind(null, Float32Array, 2); baseModule.__getFloat32ArrayView = getTypedArrayView.bind(null, Float32Array, 2); baseModule.__getFloat64Array = getTypedArray.bind(null, Float64Array, 3); baseModule.__getFloat64ArrayView = getTypedArrayView.bind(null, Float64Array, 3); /** Tests whether an object is an instance of the class represented by the specified base id. */ function __instanceof(ptr, baseId) { const U32 = new Uint32Array(memory.buffer); var id = U32[(ptr + ID_OFFSET) >>> 2]; if (id <= U32[rttiBase >>> 2]) { do if (id == baseId) return true; while (id = getBase(id)); } return false; } baseModule.__instanceof = __instanceof; // Pull basic exports to baseModule so code in preInstantiate can use them baseModule.memory = baseModule.memory || memory; baseModule.table = baseModule.table || table; // Demangle exports and provide the usual utility on the prototype return demangle(rawExports, baseModule); } function isResponse(o) { return typeof Response !== "undefined" && o instanceof Response; } /** Asynchronously instantiates an AssemblyScript module from anything that can be instantiated. */ async function instantiate(source, imports) { if (isResponse(source = await source)) return instantiateStreaming(source, imports); return postInstantiate( preInstantiate(imports || (imports = {})), await WebAssembly.instantiate( source instanceof WebAssembly.Module ? source : await WebAssembly.compile(source), imports ) ); } exports.instantiate = instantiate; /** Synchronously instantiates an AssemblyScript module from a WebAssembly.Module or binary buffer. */ function instantiateSync(source, imports) { return postInstantiate( preInstantiate(imports || (imports = {})), new WebAssembly.Instance( source instanceof WebAssembly.Module ? source : new WebAssembly.Module(source), imports ) ) } exports.instantiateSync = instantiateSync; /** Asynchronously instantiates an AssemblyScript module from a response, i.e. as obtained by `fetch`. */ async function instantiateStreaming(source, imports) { if (!WebAssembly.instantiateStreaming) { return instantiate( isResponse(source = await source) ? source.arrayBuffer() : source, imports ); } return postInstantiate( preInstantiate(imports || (imports = {})), (await WebAssembly.instantiateStreaming(source, imports)).instance ); } exports.instantiateStreaming = instantiateStreaming; /** Demangles an AssemblyScript module's exports to a friendly object structure. */ function demangle(exports, baseModule) { var module = baseModule ? Object.create(baseModule) : {}; var setArgumentsLength = exports["__argumentsLength"] ? function(length) { exports["__argumentsLength"].value = length; } : exports["__setArgumentsLength"] || exports["__setargc"] || function() {}; for (let internalName in exports) { if (!Object.prototype.hasOwnProperty.call(exports, internalName)) continue; const elem = exports[internalName]; let parts = internalName.split("."); let curr = module; while (parts.length > 1) { let part = parts.shift(); if (!Object.prototype.hasOwnProperty.call(curr, part)) curr[part] = {}; curr = curr[part]; } let name = parts[0]; let hash = name.indexOf("#"); if (hash >= 0) { let className = name.substring(0, hash); let classElem = curr[className]; if (typeof classElem === "undefined" || !classElem.prototype) { let ctor = function(...args) { return ctor.wrap(ctor.prototype.constructor(0, ...args)); }; ctor.prototype = { valueOf: function valueOf() { return this[THIS]; } }; ctor.wrap = function(thisValue) { return Object.create(ctor.prototype, { [THIS]: { value: thisValue, writable: false } }); }; if (classElem) Object.getOwnPropertyNames(classElem).forEach(name => Object.defineProperty(ctor, name, Object.getOwnPropertyDescriptor(classElem, name)) ); curr[className] = ctor; } name = name.substring(hash + 1); curr = curr[className].prototype; if (/^(get|set):/.test(name)) { if (!Object.prototype.hasOwnProperty.call(curr, name = name.substring(4))) { let getter = exports[internalName.replace("set:", "get:")]; let setter = exports[internalName.replace("get:", "set:")]; Object.defineProperty(curr, name, { get: function() { return getter(this[THIS]); }, set: function(value) { setter(this[THIS], value); }, enumerable: true }); } } else { if (name === 'constructor') { (curr[name] = (...args) => { setArgumentsLength(args.length); return elem(...args); }).original = elem; } else { // instance method (curr[name] = function(...args) { // ! setArgumentsLength(args.length); return elem(this[THIS], ...args); }).original = elem; } } } else { if (/^(get|set):/.test(name)) { if (!Object.prototype.hasOwnProperty.call(curr, name = name.substring(4))) { Object.defineProperty(curr, name, { get: exports[internalName.replace("set:", "get:")], set: exports[internalName.replace("get:", "set:")], enumerable: true }); } } else if (typeof elem === "function" && elem !== setArgumentsLength) { (curr[name] = (...args) => { setArgumentsLength(args.length); return elem(...args); }).original = elem; } else { curr[name] = elem; } } } return module; } exports.demangle = demangle; },{}],3:[function(require,module,exports){ const Rabin = require('./rabin') const getRabin = require('../dist/rabin-wasm.node.js') const create = async (avg, min, max, windowSize, polynomial) => { const compiled = await getRabin() return new Rabin(compiled, avg, min, max, windowSize, polynomial) } module.exports = { Rabin, create } },{"../dist/rabin-wasm.node.js":1,"./rabin":4}],4:[function(require,module,exports){ /** * Rabin fingerprinting * * @class Rabin */ class Rabin { /** * Creates an instance of Rabin. * @param { import("./../dist/rabin-wasm") } asModule * @param {number} [bits=12] * @param {number} [min=8 * 1024] * @param {number} [max=32 * 1024] * @param {number} polynomial * @memberof Rabin */ constructor(asModule, bits = 12, min = 8 * 1024, max = 32 * 1024, windowSize = 64, polynomial) { this.bits = bits this.min = min this.max = max this.asModule = asModule this.rabin = new asModule.Rabin(bits, min, max, windowSize, polynomial) this.polynomial = polynomial } /** * Fingerprints the buffer * * @param {Uint8Array} buf * @returns {Array} * @memberof Rabin */ fingerprint(buf) { const { __retain, __release, __allocArray, __getInt32Array, Int32Array_ID, Uint8Array_ID } = this.asModule const lengths = new Int32Array(Math.ceil(buf.length/this.min)) const lengthsPtr = __retain(__allocArray(Int32Array_ID, lengths)) const pointer = __retain(__allocArray(Uint8Array_ID, buf)) const out = this.rabin.fingerprint(pointer, lengthsPtr) const processed = __getInt32Array(out) __release(pointer) __release(lengthsPtr) const end = processed.indexOf(0); return end >= 0 ? processed.subarray(0, end) : processed; } } module.exports = Rabin },{}]},{},[3])(3) });