Mercurial > repos > fubar > jbrowse2

comparison x/static/js/5099.14f82444.chunk.js.map @ 125:49f3d3878413 draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
planemo upload for repository https://github.com/galaxyproject/tools-iuc/tree/master/tools/jbrowse2 commit 5ea1f9c1eef1de76232e69aa6d34cda77d90d566
author fubar
date Sat, 05 Oct 2024 23:58:05 +0000
parents
children
comparison
equal deleted inserted replaced
124:137e08517410 125:49f3d3878413
1 {"version":3,"file":"static/js/5099.14f82444.chunk.js","mappings":"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","sources":["../../../node_modules/@gmod/cram/src/cramFile/constants.ts","../../../node_modules/@gmod/cram/src/cramFile/record.ts","../../../node_modules/@gmod/cram/src/errors.ts","../../../node_modules/@gmod/cram/src/unzip-pako.ts","../../../node_modules/@gmod/cram/src/rans/constants.ts","../../../node_modules/@gmod/cram/src/rans/decoding.ts","../../../node_modules/@gmod/cram/src/rans/frequencies.ts","../../../node_modules/@gmod/cram/src/rans/index.ts","../../../node_modules/@gmod/cram/src/cramFile/codecs/getBits.ts","../../../node_modules/@gmod/cram/src/cramFile/util.ts","../../../node_modules/@gmod/cram/src/cramFile/sectionParsers.ts","../../../node_modules/@gmod/cram/src/cramFile/slice/decodeRecord.ts","../../../node_modules/@gmod/cram/src/cramFile/slice/index.ts","../../../node_modules/@gmod/cram/src/cramFile/codecs/_base.ts","../../../node_modules/@gmod/cram/src/cramFile/codecs/byteArrayLength.ts","../../../node_modules/@gmod/cram/src/cramFile/codecs/index.ts","../../../node_modules/@gmod/cram/src/cramFile/codecs/external.ts","../../../node_modules/@gmod/cram/src/cramFile/codecs/huffman.ts","../../../node_modules/@gmod/cram/src/cramFile/codecs/byteArrayStop.ts","../../../node_modules/@gmod/cram/src/cramFile/codecs/beta.ts","../../../node_modules/@gmod/cram/src/cramFile/codecs/subexp.ts","../../../node_modules/@gmod/cram/src/cramFile/codecs/gamma.ts","../../../node_modules/@gmod/cram/src/cramFile/container/compressionScheme.ts","../../../node_modules/@gmod/cram/src/cramFile/container/index.ts","../../../node_modules/@gmod/cram/src/io/index.ts","../../../node_modules/@gmod/cram/src/sam.ts","../../../node_modules/@gmod/cram/src/cramFile/file.ts","../../../node_modules/@gmod/cram/src/rans/d04.ts","../../../node_modules/@gmod/cram/src/rans/d14.ts","../../../node_modules/@gmod/cram/src/craiIndex.ts","../../../node_modules/@gmod/cram/src/indexedCramFile.ts","../../../node_modules/@jkbonfield/htscodecs/arith_gen.js","../../../node_modules/@jkbonfield/htscodecs/arith_sh.js","../../../node_modules/@jkbonfield/htscodecs/byte_model.js","../../../node_modules/@jkbonfield/htscodecs/fqzcomp.js","../../../node_modules/@jkbonfield/htscodecs/index.js","../../../node_modules/@jkbonfield/htscodecs/iostream.js","../../../node_modules/@jkbonfield/htscodecs/rans.js","../../../node_modules/@jkbonfield/htscodecs/rans4x16.js","../../../node_modules/@jkbonfield/htscodecs/tok3.js","../../../node_modules/bzip2/bzip2.js","../../../node_modules/charenc/charenc.js","../../../node_modules/crypt/crypt.js","../../../node_modules/is-buffer/index.js","../../../node_modules/md5/md5.js","../../../node_modules/xz-decompress/dist/package/xz-decompress.js","../../../node_modules/crc/mjs/calculators/crc32.js","../../../node_modules/crc/mjs/create_buffer.js","../../../node_modules/crc/mjs/crc32.js","../../../node_modules/crc/mjs/define_crc.js"],"sourcesContent":["const Constants = {\n CRAM_FLAG_PRESERVE_QUAL_SCORES: 1 << 0,\n CRAM_FLAG_DETACHED: 1 << 1,\n CRAM_FLAG_MATE_DOWNSTREAM: 1 << 2,\n CRAM_FLAG_NO_SEQ: 1 << 3,\n CRAM_FLAG_MASK: (1 << 4) - 1,\n\n // mate read is reversed\n CRAM_M_REVERSE: 1,\n // mated read is unmapped\n CRAM_M_UNMAP: 2,\n\n // the read is paired in sequencing, no matter whether it is mapped in a pair\n BAM_FPAIRED: 1,\n // the read is mapped in a proper pair\n BAM_FPROPER_PAIR: 2,\n // the read itself is unmapped; conflictive with BAM_FPROPER_PAIR\n BAM_FUNMAP: 4,\n // the mate is unmapped\n BAM_FMUNMAP: 8,\n // the read is mapped to the reverse strand\n BAM_FREVERSE: 16,\n // the mate is mapped to the reverse strand\n BAM_FMREVERSE: 32,\n // this is read1\n BAM_FREAD1: 64,\n // this is read2\n BAM_FREAD2: 128,\n // not primary alignment\n BAM_FSECONDARY: 256,\n // QC failure\n BAM_FQCFAIL: 512,\n // optical or PCR duplicate\n BAM_FDUP: 1024,\n // supplementary alignment\n BAM_FSUPPLEMENTARY: 2048,\n\n BAM_CMATCH: 0,\n BAM_CINS: 1,\n BAM_CDEL: 2,\n BAM_CREF_SKIP: 3,\n BAM_CSOFT_CLIP: 4,\n BAM_CHARD_CLIP: 5,\n BAM_CPAD: 6,\n BAM_CEQUAL: 7,\n BAM_CDIFF: 8,\n BAM_CBACK: 9,\n\n BAM_CIGAR_STR: 'MIDNSHP:XB',\n BAM_CIGAR_SHIFT: 4,\n BAM_CIGAR_MASK: 0xf,\n BAM_CIGAR_TYPE: 0x3c1a7,\n}\n\nexport default Constants\n","import Constants from './constants'\nimport CramContainerCompressionScheme from './container/compressionScheme'\nimport type decodeRecord from './slice/decodeRecord'\n\nexport interface RefRegion {\n start: number\n end: number\n seq: string\n}\n\nexport interface ReadFeature {\n code: string\n pos: number\n refPos: number\n data: any\n\n ref?: string\n sub?: string\n}\n\nfunction decodeReadSequence(cramRecord: CramRecord, refRegion: RefRegion) {\n // if it has no length, it has no sequence\n if (!cramRecord.lengthOnRef && !cramRecord.readLength) {\n return null\n }\n\n if (cramRecord.isUnknownBases()) {\n return null\n }\n\n // remember: all coordinates are 1-based closed\n const regionSeqOffset = cramRecord.alignmentStart - refRegion.start\n\n if (!cramRecord.readFeatures) {\n return refRegion.seq\n .slice(regionSeqOffset, regionSeqOffset + (cramRecord.lengthOnRef || 0))\n .toUpperCase()\n }\n\n let bases = ''\n let regionPos = regionSeqOffset\n let currentReadFeature = 0\n while (bases.length < cramRecord.readLength) {\n if (currentReadFeature < cramRecord.readFeatures.length) {\n const feature = cramRecord.readFeatures[currentReadFeature]!\n if (feature.code === 'Q' || feature.code === 'q') {\n currentReadFeature += 1\n } else if (feature.pos === bases.length + 1) {\n // process the read feature\n currentReadFeature += 1\n\n if (feature.code === 'b') {\n // specify a base pair for some reason\n const added = feature.data\n bases += added\n regionPos += added.length\n } else if (feature.code === 'B') {\n // base pair and associated quality\n // TODO: do we need to set the quality in the qual scores?\n bases += feature.data[0]\n regionPos += 1\n } else if (feature.code === 'X') {\n // base substitution\n bases += feature.sub\n regionPos += 1\n } else if (feature.code === 'I') {\n // insertion\n bases += feature.data\n } else if (feature.code === 'D') {\n // deletion\n regionPos += feature.data\n } else if (feature.code === 'i') {\n // insert single base\n bases += feature.data\n } else if (feature.code === 'N') {\n // reference skip. delete some bases\n // do nothing\n // seqBases.splice(feature.pos - 1, feature.data)\n regionPos += feature.data\n } else if (feature.code === 'S') {\n // soft clipped bases that should be present in the read seq\n // seqBases.splice(feature.pos - 1, 0, ...feature.data.split(''))\n bases += feature.data\n } else if (feature.code === 'P') {\n // padding, do nothing\n } else if (feature.code === 'H') {\n // hard clip, do nothing\n }\n } else if (currentReadFeature < cramRecord.readFeatures.length) {\n // put down a chunk of sequence up to the next read feature\n const chunk = refRegion.seq.slice(\n regionPos,\n regionPos + feature.pos - bases.length - 1,\n )\n bases += chunk\n regionPos += chunk.length\n }\n } else {\n // put down a chunk of reference up to the full read length\n const chunk = refRegion.seq.slice(\n regionPos,\n regionPos + cramRecord.readLength - bases.length,\n )\n bases += chunk\n regionPos += chunk.length\n }\n }\n\n return bases.toUpperCase()\n}\n\nconst baseNumbers = {\n a: 0,\n A: 0,\n c: 1,\n C: 1,\n g: 2,\n G: 2,\n t: 3,\n T: 3,\n n: 4,\n N: 4,\n}\n\nfunction decodeBaseSubstitution(\n cramRecord: CramRecord,\n refRegion: RefRegion,\n compressionScheme: CramContainerCompressionScheme,\n readFeature: ReadFeature,\n) {\n // decode base substitution code using the substitution matrix\n const refCoord = readFeature.refPos - refRegion.start\n const refBase = refRegion.seq.charAt(refCoord)\n if (refBase) {\n readFeature.ref = refBase\n }\n let baseNumber = (baseNumbers as any)[refBase]\n if (baseNumber === undefined) {\n baseNumber = 4\n }\n const substitutionScheme = compressionScheme.substitutionMatrix[baseNumber]!\n const base = substitutionScheme[readFeature.data]\n if (base) {\n readFeature.sub = base\n }\n}\n\nexport interface MateRecord {\n readName?: string\n sequenceId: number\n alignmentStart: number\n flags?: number\n\n uniqueId?: number\n}\n\nexport const BamFlags = [\n [0x1, 'Paired'],\n [0x2, 'ProperlyPaired'],\n [0x4, 'SegmentUnmapped'],\n [0x8, 'MateUnmapped'],\n [0x10, 'ReverseComplemented'],\n // the mate is mapped to the reverse strand\n [0x20, 'MateReverseComplemented'],\n // this is read1\n [0x40, 'Read1'],\n // this is read2\n [0x80, 'Read2'],\n // not primary alignment\n [0x100, 'Secondary'],\n // QC failure\n [0x200, 'FailedQc'],\n // optical or PCR duplicate\n [0x400, 'Duplicate'],\n // supplementary alignment\n [0x800, 'Supplementary'],\n] as const\n\nexport const CramFlags = [\n [0x1, 'PreservingQualityScores'],\n [0x2, 'Detached'],\n [0x4, 'WithMateDownstream'],\n [0x8, 'DecodeSequenceAsStar'],\n] as const\n\nexport const MateFlags = [\n [0x1, 'OnNegativeStrand'],\n [0x2, 'Unmapped'],\n] as const\n\ntype FlagsDecoder<Type> = {\n [Property in Type as `is${Capitalize<string & Property>}`]: (\n flags: number,\n ) => boolean\n}\n\ntype FlagsEncoder<Type> = {\n [Property in Type as `set${Capitalize<string & Property>}`]: (\n flags: number,\n ) => number\n}\n\nfunction makeFlagsHelper<T>(\n x: readonly (readonly [number, T])[],\n): FlagsDecoder<T> & FlagsEncoder<T> {\n const r: any = {}\n for (const [code, name] of x) {\n r[`is${name}`] = (flags: number) => !!(flags & code)\n r[`set${name}`] = (flags: number) => flags | code\n }\n\n return r\n}\n\nexport const BamFlagsDecoder = makeFlagsHelper(BamFlags)\nexport const CramFlagsDecoder = makeFlagsHelper(CramFlags)\nexport const MateFlagsDecoder = makeFlagsHelper(MateFlags)\n\n/**\n * Class of each CRAM record returned by this API.\n */\nexport default class CramRecord {\n public tags: Record<string, string>\n public flags: number\n public cramFlags: number\n public readBases?: string | null\n public _refRegion?: RefRegion\n public readFeatures?: ReadFeature[]\n public alignmentStart: number\n public lengthOnRef: number | undefined\n public readLength: number\n public templateLength?: number\n public templateSize?: number\n public readName?: string\n public mateRecordNumber?: number\n public mate?: MateRecord\n public uniqueId: number\n public sequenceId: number\n public readGroupId: number\n public mappingQuality: number | undefined\n public qualityScores: number[] | null | undefined\n\n constructor({\n flags,\n cramFlags,\n readLength,\n mappingQuality,\n lengthOnRef,\n qualityScores,\n mateRecordNumber,\n readBases,\n readFeatures,\n mateToUse,\n readGroupId,\n readName,\n sequenceId,\n uniqueId,\n templateSize,\n alignmentStart,\n tags,\n }: ReturnType<typeof decodeRecord> & { uniqueId: number }) {\n this.flags = flags\n this.cramFlags = cramFlags\n this.readLength = readLength\n this.mappingQuality = mappingQuality\n this.lengthOnRef = lengthOnRef\n this.qualityScores = qualityScores\n if (readBases) {\n this.readBases = readBases\n }\n\n this.readGroupId = readGroupId\n this.readName = readName\n this.sequenceId = sequenceId\n this.uniqueId = uniqueId\n this.templateSize = templateSize\n this.alignmentStart = alignmentStart\n this.tags = tags\n\n // backwards compatibility\n if (readFeatures) {\n this.readFeatures = readFeatures\n }\n if (mateToUse) {\n this.mate = {\n flags: mateToUse.mateFlags,\n readName: mateToUse.mateReadName,\n sequenceId: mateToUse.mateSequenceId,\n alignmentStart: mateToUse.mateAlignmentStart,\n }\n }\n if (mateRecordNumber) {\n this.mateRecordNumber = mateRecordNumber\n }\n }\n\n /**\n * @returns {boolean} true if the read is paired, regardless of whether both segments are mapped\n */\n isPaired() {\n return !!(this.flags & Constants.BAM_FPAIRED)\n }\n\n /** @returns {boolean} true if the read is paired, and both segments are mapped */\n isProperlyPaired() {\n return !!(this.flags & Constants.BAM_FPROPER_PAIR)\n }\n\n /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */\n isSegmentUnmapped() {\n return !!(this.flags & Constants.BAM_FUNMAP)\n }\n\n /** @returns {boolean} true if the read itself is unmapped; conflictive with isProperlyPaired */\n isMateUnmapped() {\n return !!(this.flags & Constants.BAM_FMUNMAP)\n }\n\n /** @returns {boolean} true if the read is mapped to the reverse strand */\n isReverseComplemented() {\n return !!(this.flags & Constants.BAM_FREVERSE)\n }\n\n /** @returns {boolean} true if the mate is mapped to the reverse strand */\n isMateReverseComplemented() {\n return !!(this.flags & Constants.BAM_FMREVERSE)\n }\n\n /** @returns {boolean} true if this is read number 1 in a pair */\n isRead1() {\n return !!(this.flags & Constants.BAM_FREAD1)\n }\n\n /** @returns {boolean} true if this is read number 2 in a pair */\n isRead2() {\n return !!(this.flags & Constants.BAM_FREAD2)\n }\n\n /** @returns {boolean} true if this is a secondary alignment */\n isSecondary() {\n return !!(this.flags & Constants.BAM_FSECONDARY)\n }\n\n /** @returns {boolean} true if this read has failed QC checks */\n isFailedQc() {\n return !!(this.flags & Constants.BAM_FQCFAIL)\n }\n\n /** @returns {boolean} true if the read is an optical or PCR duplicate */\n isDuplicate() {\n return !!(this.flags & Constants.BAM_FDUP)\n }\n\n /** @returns {boolean} true if this is a supplementary alignment */\n isSupplementary() {\n return !!(this.flags & Constants.BAM_FSUPPLEMENTARY)\n }\n\n /**\n * @returns {boolean} true if the read is detached\n */\n isDetached() {\n return !!(this.cramFlags & Constants.CRAM_FLAG_DETACHED)\n }\n\n /** @returns {boolean} true if the read has a mate in this same CRAM segment */\n hasMateDownStream() {\n return !!(this.cramFlags & Constants.CRAM_FLAG_MATE_DOWNSTREAM)\n }\n\n /** @returns {boolean} true if the read contains qual scores */\n isPreservingQualityScores() {\n return !!(this.cramFlags & Constants.CRAM_FLAG_PRESERVE_QUAL_SCORES)\n }\n\n /** @returns {boolean} true if the read has no sequence bases */\n isUnknownBases() {\n return !!(this.cramFlags & Constants.CRAM_FLAG_NO_SEQ)\n }\n\n /**\n * Get the original sequence of this read.\n * @returns {String} sequence basepairs\n */\n getReadBases() {\n if (!this.readBases && this._refRegion) {\n const decoded = decodeReadSequence(this, this._refRegion)\n if (decoded) {\n this.readBases = decoded\n }\n }\n return this.readBases\n }\n\n /**\n * Get the pair orientation of a paired read. Adapted from igv.js\n * @returns {String} of paired orientatin\n */\n getPairOrientation() {\n if (\n !this.isSegmentUnmapped() &&\n this.isPaired() &&\n !this.isMateUnmapped() &&\n this.mate &&\n this.sequenceId === this.mate.sequenceId\n ) {\n const s1 = this.isReverseComplemented() ? 'R' : 'F'\n const s2 = this.isMateReverseComplemented() ? 'R' : 'F'\n let o1 = ' '\n let o2 = ' '\n if (this.isRead1()) {\n o1 = '1'\n o2 = '2'\n } else if (this.isRead2()) {\n o1 = '2'\n o2 = '1'\n }\n\n const tmp = []\n let isize = this.templateLength || this.templateSize\n if (isize === undefined) {\n throw new Error('One of templateSize and templateLength must be set')\n }\n if (this.alignmentStart > this.mate.alignmentStart && isize > 0) {\n isize = -isize\n }\n if (isize > 0) {\n tmp[0] = s1\n tmp[1] = o1\n tmp[2] = s2\n tmp[3] = o2\n } else {\n tmp[2] = s1\n tmp[3] = o1\n tmp[0] = s2\n tmp[1] = o2\n }\n return tmp.join('')\n }\n return null\n }\n\n /**\n * Annotates this feature with the given reference sequence basepair\n * information. This will add a `sub` and a `ref` item to base\n * substitution read features given the actual substituted and reference\n * base pairs, and will make the `getReadSequence()` method work.\n *\n * @param {object} refRegion\n * @param {number} refRegion.start\n * @param {number} refRegion.end\n * @param {string} refRegion.seq\n * @param {CramContainerCompressionScheme} compressionScheme\n * @returns {undefined} nothing\n */\n addReferenceSequence(\n refRegion: RefRegion,\n compressionScheme: CramContainerCompressionScheme,\n ) {\n if (this.readFeatures) {\n // use the reference bases to decode the bases\n // substituted in each base substitution\n this.readFeatures.forEach(readFeature => {\n if (readFeature.code === 'X') {\n decodeBaseSubstitution(\n this,\n refRegion,\n compressionScheme,\n readFeature,\n )\n }\n })\n }\n\n // if this region completely covers this read,\n // keep a reference to it\n if (\n !this.readBases &&\n refRegion.start <= this.alignmentStart &&\n refRegion.end >=\n this.alignmentStart + (this.lengthOnRef || this.readLength) - 1\n ) {\n this._refRegion = refRegion\n }\n }\n\n toJSON() {\n const data: any = {}\n Object.keys(this).forEach(k => {\n if (k.startsWith('_')) {\n return\n }\n data[k] = (this as any)[k]\n })\n\n data.readBases = this.getReadBases()\n\n return data\n }\n}\n","export class CramError extends Error {}\n\n/** Error caused by encountering a part of the CRAM spec that has not yet been implemented */\nexport class CramUnimplementedError extends Error {}\n\n/** An error caused by malformed data. */\nexport class CramMalformedError extends CramError {}\n\n/**\n * An error caused by data being too big, exceeding a size limit.\n */\nexport class CramSizeLimitError extends CramError {}\n\n/**\n * An invalid argument was supplied to a cram-js method or object.\n */\nexport class CramArgumentError extends CramError {}\n","import { inflate } from 'pako'\nimport { Buffer } from 'buffer'\n\nexport function unzip(input: Buffer) {\n return Buffer.from(inflate(input))\n}\n","const TF_SHIFT = 12\nconst TOTFREQ = 1 << TF_SHIFT\nconst RANS_BYTE_L = 1 << 23\n\nexport { TF_SHIFT, TOTFREQ, RANS_BYTE_L }\n","// @ts-nocheck\nimport { CramMalformedError } from '../errors'\n\nimport { RANS_BYTE_L } from './constants'\n\nclass FC {\n // int F, C;\n constructor() {\n this.F = undefined\n this.C = undefined\n }\n}\n\nclass AriDecoder {\n // final FC[] fc = new FC[256];\n // byte[] R;\n\n constructor() {\n this.fc = new Array(256)\n for (let i = 0; i < this.fc.length; i += 1) {\n this.fc[i] = new FC()\n }\n this.R = null\n }\n}\n\nclass DecodingSymbol {\n // int start; // Start of range.\n // int freq; // Symbol frequency.\n constructor() {\n this.start = undefined\n this.freq = undefined\n }\n}\n\n// Initialize a decoder symbol to start \"start\" and frequency \"freq\"\nfunction symbolInit(sym, start, freq) {\n if (!(start <= 1 << 16)) {\n throw new CramMalformedError('assertion failed: start <= 1<<16')\n }\n if (!(freq <= (1 << 16) - start)) {\n throw new CramMalformedError('assertion failed: freq <= 1<<16')\n }\n sym.start = start\n sym.freq = freq\n}\n\n// Advances in the bit stream by \"popping\" a single symbol with range start\n// \"start\" and frequency \"freq\". All frequencies are assumed to sum to\n// \"1 << scaleBits\".\n// No renormalization or output happens.\n/* private static int */ function advanceStep(\n /* final int */ r,\n /* final int */ start,\n /* final int */ freq,\n /* final int */ scaleBits,\n) {\n /* final int */ const mask = (1 << scaleBits) - 1\n\n // s, x = D(x)\n return freq * (r >> scaleBits) + (r & mask) - start\n}\n\n// Equivalent to RansDecAdvanceStep that takes a symbol.\n/* static int */ function advanceSymbolStep(\n /* final int */ r,\n /* final RansDecSymbol */ sym,\n /* final int */ scaleBits,\n) {\n return advanceStep(r, sym.start, sym.freq, scaleBits)\n}\n\n// Returns the current cumulative frequency (map it to a symbol yourself!)\n/* static int */ function get(/* final int */ r, /* final int */ scaleBits) {\n return r & ((1 << scaleBits) - 1)\n}\n\n// Advances in the bit stream by \"popping\" a single symbol with range start\n// \"start\" and frequency \"freq\". All frequencies are assumed to sum to\n// \"1 << scaleBits\",\n// and the resulting bytes get written to ptr (which is updated).\n/* private static int */ function advance(\n /* int */ r,\n /* final ByteBuffer */ pptr,\n /* final int */ start,\n /* final int */ freq,\n /* final int */ scaleBits,\n) {\n /* final int */ const mask = (1 << scaleBits) - 1\n\n // s, x = D(x)\n r = freq * (r >> scaleBits) + (r & mask) - start\n\n // re-normalize\n if (r < RANS_BYTE_L) {\n do {\n /* final int */ const b = 0xff & pptr.get()\n r = (r << 8) | b\n } while (r < RANS_BYTE_L)\n }\n\n return r\n}\n\n// Equivalent to RansDecAdvance that takes a symbol.\n/* static int */ function advanceSymbol(\n /* final int */ r,\n /* final ByteBuffer */ pptr,\n /* final RansDecSymbol */ sym,\n /* final int */ scaleBits,\n) {\n return advance(r, pptr, sym.start, sym.freq, scaleBits)\n}\n\n// Re-normalize.\n/* static int */ function renormalize(\n /* int */ r,\n /* final ByteBuffer */ pptr,\n) {\n // re-normalize\n if (r < RANS_BYTE_L) {\n do {\n r = (r << 8) | (0xff & pptr.get())\n } while (r < RANS_BYTE_L)\n }\n\n return r\n}\n\nexport default {\n FC,\n AriDecoder,\n DecodingSymbol,\n symbolInit,\n advanceStep,\n advanceSymbolStep,\n get,\n advanceSymbol,\n renormalize,\n}\n","// @ts-nocheck\nimport { CramMalformedError } from '../errors'\n\nimport { TOTFREQ } from './constants'\nimport Decoding from './decoding'\n\nfunction assert(result) {\n if (!result) {\n throw new CramMalformedError('assertion failed')\n }\n}\n\nexport function readStatsO0(\n /* ByteBuffer */ cp,\n /* Decoding.AriDecoder */ decoder,\n /* Decoding.RansDecSymbol[] */ syms,\n) {\n // Pre-compute reverse lookup of frequency.\n let rle = 0\n let x = 0\n let j = cp.get() & 0xff\n do {\n if (decoder.fc[j] == null) {\n decoder.fc[j] = new Decoding.FC()\n }\n decoder.fc[j].F = cp.get() & 0xff\n if (decoder.fc[j].F >= 128) {\n decoder.fc[j].F &= ~128\n decoder.fc[j].F = ((decoder.fc[j].F & 127) << 8) | (cp.get() & 0xff)\n }\n decoder.fc[j].C = x\n\n Decoding.symbolInit(syms[j], decoder.fc[j].C, decoder.fc[j].F)\n\n /* Build reverse lookup table */\n if (!decoder.R) {\n decoder.R = new Array(TOTFREQ)\n }\n decoder.R.fill(j, x, x + decoder.fc[j].F)\n\n x += decoder.fc[j].F\n\n if (rle === 0 && j + 1 === (0xff & cp.getByteAt(cp.position()))) {\n j = cp.get() & 0xff\n rle = cp.get() & 0xff\n } else if (rle !== 0) {\n rle -= 1\n j += 1\n } else {\n j = cp.get() & 0xff\n }\n } while (j !== 0)\n\n assert(x < TOTFREQ)\n}\n\nexport function readStatsO1(\n /* ByteBuffer */ cp,\n /* Decoding.AriDecoder[] */ D,\n /* Decoding.RansDecSymbol[][] */ syms,\n) {\n let rlei = 0\n let i = 0xff & cp.get()\n do {\n let rlej = 0\n let x = 0\n let j = 0xff & cp.get()\n if (D[i] == null) {\n D[i] = new Decoding.AriDecoder()\n }\n do {\n if (D[i].fc[j] == null) {\n D[i].fc[j] = new Decoding.FC()\n }\n D[i].fc[j].F = 0xff & cp.get()\n if (D[i].fc[j].F >= 128) {\n D[i].fc[j].F &= ~128\n D[i].fc[j].F = ((D[i].fc[j].F & 127) << 8) | (0xff & cp.get())\n }\n D[i].fc[j].C = x\n\n if (D[i].fc[j].F === 0) {\n D[i].fc[j].F = TOTFREQ\n }\n\n if (syms[i][j] == null) {\n syms[i][j] = new Decoding.RansDecSymbol()\n }\n\n Decoding.symbolInit(syms[i][j], D[i].fc[j].C, D[i].fc[j].F)\n\n /* Build reverse lookup table */\n if (D[i].R == null) {\n D[i].R = new Array(TOTFREQ)\n }\n D[i].R.fill(j, x, x + D[i].fc[j].F)\n\n x += D[i].fc[j].F\n assert(x <= TOTFREQ)\n\n if (rlej === 0 && j + 1 === (0xff & cp.getByteAt(cp.position()))) {\n j = 0xff & cp.get()\n rlej = 0xff & cp.get()\n } else if (rlej !== 0) {\n rlej -= 1\n j += 1\n } else {\n j = 0xff & cp.get()\n }\n } while (j !== 0)\n\n if (rlei === 0 && i + 1 === (0xff & cp.getByteAt(cp.position()))) {\n i = 0xff & cp.get()\n rlei = 0xff & cp.get()\n } else if (rlei !== 0) {\n rlei -= 1\n i += 1\n } else {\n i = 0xff & cp.get()\n }\n } while (i !== 0)\n}\n","// @ts-nocheck\nimport { Buffer } from 'buffer'\nimport { CramMalformedError } from '../errors'\n\nimport Decoding from './decoding'\nimport { readStatsO0, readStatsO1 } from './frequencies'\n\nimport D04 from './d04'\nimport D14 from './d14'\n\n// const /* int */ ORDER_BYTE_LENGTH = 1\n// const /* int */ COMPRESSED_BYTE_LENGTH = 4\nconst /* int */ RAW_BYTE_LENGTH = 4\n// const /* int */ PREFIX_BYTE_LENGTH =\n// ORDER_BYTE_LENGTH + COMPRESSED_BYTE_LENGTH + RAW_BYTE_LENGTH\n\n// enum ORDER {\n// ZERO, ONE;\n\n// static ORDER fromInt(const /* int */ value) {\n// try {\n// return ORDER.values()[value];\n// } catch (const ArrayIndexOutOfBoundsException e) {\n// throw new RuntimeException(\"Unknown rANS order: \" + value);\n// }\n// }\n// }\n\n// static ByteBuffer compress(const ByteBuffer input, const ORDER order, const ByteBuffer out) {\n// if (input.remaining() == 0)\n// return EMPTY_BUFFER;\n\n// if (input.remaining() < 4)\n// return encode_order0_way4(input, out);\n\n// switch (order) {\n// case ZERO:\n// return encode_order0_way4(input, out);\n// case ONE:\n// return encode_order1_way4(input, out);\n\n// default:\n// throw new RuntimeException(\"Unknown rANS order: \" + order);\n// }\n// }\n\n// static /* ByteBuffer */ allocateIfNeeded(/* const int */ in_size,\n// /* const ByteBuffer */ out_buf) {\n// const /* int */ compressedSize = (/* int */) (1.05 * in_size + 257 * 257 * 3 + 4);\n// if (out_buf == null)\n// return ByteBuffer.allocate(compressedSize);\n// if (out_buf.remaining() < compressedSize)\n// throw new RuntimeException(\"Insufficient buffer size.\");\n// out_buf.order(ByteOrder.LITTLE_ENDIAN);\n// return out_buf;\n// }\n\n// static ByteBuffer encode_order0_way4(const ByteBuffer input,\n// ByteBuffer out_buf) {\n// const /* int */ in_size = input.remaining();\n// out_buf = allocateIfNeeded(in_size, out_buf);\n// const /* int */ freqTableStart = PREFIX_BYTE_LENGTH;\n// out_buf.position(freqTableStart);\n\n// const /* int */[] F = Frequencies.calcFrequencies_o0(in);\n// const RansEncSymbol[] syms = Frequencies.buildSyms_o0(F);\n\n// const ByteBuffer cp = out_buf.slice();\n// const /* int */ frequencyTable_size = Frequencies.writeFrequencies_o0(cp, F);\n\n// input.rewind();\n// const /* int */ compressedBlob_size = E04.compress(input, syms, cp);\n\n// finalizeCompressed(0, out_buf, in_size, frequencyTable_size,\n// compressedBlob_size);\n// return out_buf;\n// }\n\n// static ByteBuffer encode_order1_way4(const ByteBuffer input,\n// ByteBuffer out_buf) {\n// const /* int */ in_size = input.remaining();\n// out_buf = allocateIfNeeded(in_size, out_buf);\n// const /* int */ freqTableStart = PREFIX_BYTE_LENGTH;\n// out_buf.position(freqTableStart);\n\n// const /* int */[][] F = Frequencies.calcFrequencies_o1(in);\n// const RansEncSymbol[][] syms = Frequencies.buildSyms_o1(F);\n\n// const ByteBuffer cp = out_buf.slice();\n// const /* int */ frequencyTable_size = Frequencies.writeFrequencies_o1(cp, F);\n\n// input.rewind();\n// const /* int */ compressedBlob_size = E14.compress(input, syms, cp);\n\n// finalizeCompressed(1, out_buf, in_size, frequencyTable_size,\n// compressedBlob_size);\n// return out_buf;\n// }\n\n// static void finalizeCompressed(const /* int */ order, const ByteBuffer out_buf,\n// const /* int */ in_size, const /* int */ frequencyTable_size, const /* int */ compressedBlob_size) {\n// out_buf.limit(PREFIX_BYTE_LENGTH + frequencyTable_size\n// + compressedBlob_size);\n// out_buf.put(0, (byte) order);\n// out_buf.order(ByteOrder.LITTLE_ENDIAN);\n// const /* int */ compressedSizeOffset = ORDER_BYTE_LENGTH;\n// out_buf.putInt(compressedSizeOffset, frequencyTable_size\n// + compressedBlob_size);\n// const /* int */ rawSizeOffset = ORDER_BYTE_LENGTH + COMPRESSED_BYTE_LENGTH;\n// out_buf.putInt(rawSizeOffset, in_size);\n// out_buf.rewind();\n// }\n\nfunction /* static ByteBuffer */ uncompressOrder0Way4(\n /* const ByteBuffer */ input,\n /* const ByteBuffer */ out,\n) {\n // input.order(ByteOrder.LITTLE_ENDIAN);\n const D = new Decoding.AriDecoder()\n const syms = new Array(256)\n for (let i = 0; i < syms.length; i += 1) {\n syms[i] = new Decoding.DecodingSymbol()\n }\n\n readStatsO0(input, D, syms)\n\n D04(input, D, syms, out)\n\n return out\n}\n\nfunction /* static ByteBuffer */ uncompressOrder1Way4(\n /* const ByteBuffer */ input,\n /* const ByteBuffer */ output,\n) {\n const D = new Array(256)\n for (let i = 0; i < D.length; i += 1) {\n D[i] = new Decoding.AriDecoder()\n }\n const /* Decoding.RansDecSymbol[][] */ syms = new Array(256)\n for (let i = 0; i < syms.length; i += 1) {\n syms[i] = new Array(256)\n for (let j = 0; j < syms[i].length; j += 1) {\n syms[i][j] = new Decoding.DecodingSymbol()\n }\n }\n readStatsO1(input, D, syms)\n\n D14(input, output, D, syms)\n\n return output\n}\n\n/* compat layer to make a node buffer act like a java ByteBuffer */\nclass ByteBuffer {\n constructor(nodeBuffer, initialInputPosition = 0) {\n this._buffer = nodeBuffer\n this._position = initialInputPosition\n this.length = nodeBuffer.length\n }\n\n get() {\n const b = this._buffer[this._position]\n this._position += 1\n return b\n }\n\n getByte() {\n return this.get()\n }\n\n getByteAt(position) {\n return this._buffer[position]\n }\n\n position() {\n return this._position\n }\n\n put(val) {\n this._buffer[this._position] = val\n this._position += 1\n return val\n }\n\n putAt(position, val) {\n this._buffer[position] = val\n return val\n }\n\n setPosition(pos) {\n this._position = pos\n return pos\n }\n\n getInt() {\n const i = this._buffer.readInt32LE(this._position)\n this._position += 4\n return i\n }\n\n remaining() {\n return this._buffer.length - this._position\n }\n}\n\n// static /* const */ ByteBuffer EMPTY_BUFFER = ByteBuffer.allocate(0);\nexport default function uncompress(\n inputBuffer,\n outputBuffer,\n initialInputPosition = 0,\n) {\n if (inputBuffer.length === 0) {\n outputBuffer.fill(0)\n return outputBuffer\n }\n\n const input = new ByteBuffer(inputBuffer, initialInputPosition)\n // input.order(ByteOrder.LITTLE_ENDIAN);\n\n const order = input.get()\n if (order !== 0 && order !== 1) {\n throw new CramMalformedError(`Invalid rANS order ${order}`)\n }\n\n const /* int */ inputSize = input.getInt()\n if (inputSize !== input.remaining() - RAW_BYTE_LENGTH) {\n throw new CramMalformedError('Incorrect input length.')\n }\n\n const /* int */ outputSize = input.getInt()\n const output = new ByteBuffer(outputBuffer || Buffer.allocUnsafe(outputSize))\n // TODO output.limit(outputSize)\n\n if (output.length < outputSize) {\n throw new CramMalformedError(\n `Output buffer too small to fit ${outputSize} bytes.`,\n )\n }\n\n switch (order) {\n case 0:\n return uncompressOrder0Way4(input, output)\n\n case 1:\n return uncompressOrder1Way4(input, output)\n\n default:\n throw new CramMalformedError(`Invalid rANS order: ${order}`)\n }\n}\n","export class CramBufferOverrunError extends Error {}\n\nexport function getBits(\n data: Buffer,\n cursor: { bytePosition: number; bitPosition: number },\n numBits: number,\n) {\n let val = 0\n if (\n cursor.bytePosition + (7 - cursor.bitPosition + numBits) / 8 >\n data.length\n ) {\n throw new CramBufferOverrunError(\n 'read error during decoding. the file seems to be truncated.',\n )\n }\n for (let dlen = numBits; dlen; dlen--) {\n // get the next `dlen` bits in the input, put them in val\n val <<= 1\n val |= (data[cursor.bytePosition]! >> cursor.bitPosition) & 1\n cursor.bitPosition -= 1\n if (cursor.bitPosition < 0) {\n cursor.bytePosition += 1\n }\n cursor.bitPosition &= 7\n }\n return val\n}\n","import md5 from 'md5'\nimport Long from 'long'\nimport { CramBufferOverrunError } from './codecs/getBits'\n\nexport function itf8Size(v: number) {\n if (!(v & ~0x7f)) {\n return 1\n }\n if (!(v & ~0x3fff)) {\n return 2\n }\n if (!(v & ~0x1fffff)) {\n return 3\n }\n if (!(v & ~0xfffffff)) {\n return 4\n }\n return 5\n}\n\nexport function parseItf8(buffer: Uint8Array, initialOffset: number) {\n let offset = initialOffset\n const countFlags = buffer[offset]!\n let result: number\n if (countFlags < 0x80) {\n result = countFlags\n offset = offset + 1\n } else if (countFlags < 0xc0) {\n result = ((countFlags << 8) | buffer[offset + 1]!) & 0x3fff\n offset = offset + 2\n } else if (countFlags < 0xe0) {\n result =\n ((countFlags << 16) | (buffer[offset + 1]! << 8) | buffer[offset + 2]!) &\n 0x1fffff\n offset = offset + 3\n } else if (countFlags < 0xf0) {\n result =\n ((countFlags << 24) |\n (buffer[offset + 1]! << 16) |\n (buffer[offset + 2]! << 8) |\n buffer[offset + 3]!) &\n 0x0fffffff\n offset = offset + 4\n } else {\n result =\n ((countFlags & 0x0f) << 28) |\n (buffer[offset + 1]! << 20) |\n (buffer[offset + 2]! << 12) |\n (buffer[offset + 3]! << 4) |\n (buffer[offset + 4]! & 0x0f)\n // x=((0xff & 0x0f)<<28) | (0xff<<20) | (0xff<<12) | (0xff<<4) | (0x0f & 0x0f);\n // TODO *val_p = uv < 0x80000000UL ? uv : -((int32_t) (0xffffffffUL - uv)) - 1;\n offset = offset + 5\n }\n if (offset > buffer.length) {\n throw new CramBufferOverrunError(\n 'Attempted to read beyond end of buffer; this file seems truncated.',\n )\n }\n return [result, offset - initialOffset] as const\n}\n\nexport function parseLtf8(buffer: Buffer, initialOffset: number) {\n let offset = initialOffset\n const countFlags = buffer[offset]!\n let n: number | Long\n if (countFlags < 0x80) {\n n = countFlags\n offset += 1\n } else if (countFlags < 0xc0) {\n n = ((buffer[offset]! << 8) | buffer[offset + 1]!) & 0x3fff\n offset += 2\n } else if (countFlags < 0xe0) {\n n =\n ((buffer[offset]! << 16) |\n (buffer[offset + 1]! << 8) |\n buffer[offset + 2]!) &\n 0x1fffff\n n = ((countFlags & 63) << 16) | buffer.readUInt16LE(offset + 1)\n offset += 3\n } else if (countFlags < 0xf0) {\n n =\n ((buffer[offset]! << 24) |\n (buffer[offset + 1]! << 16) |\n (buffer[offset + 2]! << 8) |\n buffer[offset + 3]!) &\n 0x0fffffff\n offset += 4\n } else if (countFlags < 0xf8) {\n n =\n ((buffer[offset]! & 15) * 2 ** 32 + (buffer[offset + 1]! << 24)) |\n ((buffer[offset + 2]! << 16) |\n (buffer[offset + 3]! << 8) |\n buffer[offset + 4]!)\n // TODO *val_p = uv < 0x80000000UL ? uv : -((int32_t) (0xffffffffUL - uv)) - 1;\n offset += 5\n } else if (countFlags < 0xfc) {\n n =\n ((((buffer[offset]! & 7) << 8) | buffer[offset + 1]!) * 2 ** 32 +\n (buffer[offset + 2]! << 24)) |\n ((buffer[offset + 3]! << 16) |\n (buffer[offset + 4]! << 8) |\n buffer[offset + 5]!)\n offset += 6\n } else if (countFlags < 0xfe) {\n n =\n ((((buffer[offset]! & 3) << 16) |\n (buffer[offset + 1]! << 8) |\n buffer[offset + 2]!) *\n 2 ** 32 +\n (buffer[offset + 3]! << 24)) |\n ((buffer[offset + 4]! << 16) |\n (buffer[offset + 5]! << 8) |\n buffer[offset + 6]!)\n offset += 7\n } else if (countFlags < 0xff) {\n n = Long.fromBytesBE(\n buffer.slice(offset + 1, offset + 8) as unknown as number[],\n )\n if (\n n.greaterThan(Number.MAX_SAFE_INTEGER) ||\n n.lessThan(Number.MIN_SAFE_INTEGER)\n ) {\n throw new Error('integer overflow')\n }\n n = n.toNumber()\n offset += 8\n } else {\n n = Long.fromBytesBE(\n buffer.slice(offset + 1, offset + 9) as unknown as number[],\n )\n if (\n n.greaterThan(Number.MAX_SAFE_INTEGER) ||\n n.lessThan(Number.MIN_SAFE_INTEGER)\n ) {\n throw new Error('integer overflow')\n }\n n = n.toNumber()\n offset += 9\n }\n return [n, offset - initialOffset] as const\n}\n\nexport function parseItem<T>(\n buffer: Buffer,\n parser: (buffer: Buffer, offset: number) => { offset: number; value: T },\n startBufferPosition = 0,\n startFilePosition = 0,\n) {\n const { offset, value } = parser(buffer, startBufferPosition)\n return {\n ...value,\n _endPosition: offset + startFilePosition,\n _size: offset - startBufferPosition,\n }\n}\n\n// this would be nice as a decorator, but i'm a little worried about babel\n// support for it going away or changing. memoizes a method in the stupidest\n// possible way, with no regard for the arguments. actually, this only works\n// on methods that take no arguments\nexport function tinyMemoize(_class: any, methodName: any) {\n const method = _class.prototype[methodName]\n const memoAttrName = `_memo_${methodName}`\n _class.prototype[methodName] = function _tinyMemoized() {\n if (!(memoAttrName in this)) {\n const res = method.call(this)\n this[memoAttrName] = res\n Promise.resolve(res).catch(() => {\n \n delete this[memoAttrName]\n })\n }\n return this[memoAttrName]\n }\n}\n\nexport function sequenceMD5(seq: string) {\n return md5(seq.toUpperCase().replaceAll(/[^\\u0021-\\u007e]/g, ''))\n}\n","import { TupleOf } from '../typescript'\nimport { parseItf8, parseLtf8 } from './util'\nimport { DataSeriesEncodingMap } from './codecs/dataSeriesTypes'\nimport { CramEncoding } from './encoding'\n\nexport function cramFileDefinition() {\n return {\n parser: (buffer: Buffer, _startOffset = 0) => {\n const b = buffer\n const dataView = new DataView(b.buffer, b.byteOffset, b.length)\n let offset = 0\n const magic = buffer.subarray(offset, offset + 4).toString()\n offset += 4\n const majorVersion = dataView.getUint8(offset)\n offset += 1\n const minorVersion = dataView.getUint8(offset)\n offset += 1\n const fileId = b\n .subarray(offset, offset + 20)\n .toString()\n .replaceAll('\\0', '')\n offset += 20\n return {\n value: {\n magic,\n majorVersion,\n minorVersion,\n fileId,\n },\n offset,\n }\n },\n maxLength: 26,\n }\n}\nexport function cramBlockHeader() {\n const parser = (buffer: Buffer, _startOffset = 0) => {\n const b = buffer\n const dataView = new DataView(b.buffer, b.byteOffset, b.length)\n let offset = 0\n const d = dataView.getUint8(offset)\n const compressionMethod = [\n 'raw',\n 'gzip',\n 'bzip2',\n 'lzma',\n 'rans',\n 'rans4x16',\n 'arith',\n 'fqzcomp',\n 'tok3',\n ][d]\n if (!compressionMethod) {\n throw new Error(`compression method number ${d} not implemented`)\n }\n offset += 1\n\n const c = dataView.getUint8(offset)\n const contentType = [\n 'FILE_HEADER',\n 'COMPRESSION_HEADER',\n 'MAPPED_SLICE_HEADER',\n 'UNMAPPED_SLICE_HEADER', // < only used in cram v1\n 'EXTERNAL_DATA',\n 'CORE_DATA',\n ][c]\n if (!contentType) {\n throw new Error(`invalid block content type id ${c}`)\n }\n offset += 1\n\n const [contentId, newOffset1] = parseItf8(buffer, offset)\n offset += newOffset1\n const [compressedSize, newOffset2] = parseItf8(buffer, offset)\n offset += newOffset2\n const [uncompressedSize, newOffset3] = parseItf8(buffer, offset)\n offset += newOffset3\n return {\n offset,\n value: {\n uncompressedSize,\n compressedSize,\n contentId,\n contentType: contentType as\n | 'FILE_HEADER'\n | 'COMPRESSION_HEADER'\n | 'MAPPED_SLICE_HEADER'\n | 'UNMAPPED_SLICE_HEADER' // < only used in cram v1\n | 'EXTERNAL_DATA'\n | 'CORE_DATA',\n compressionMethod: compressionMethod as CompressionMethod,\n },\n }\n }\n return { parser, maxLength: 17 }\n}\n\nexport function cramBlockCrc32() {\n return {\n parser: (buffer: Buffer, offset: number) => {\n const b = buffer\n const dataView = new DataView(b.buffer, b.byteOffset, b.length)\n const crc32 = dataView.getUint32(offset, true)\n offset += 4\n return {\n offset,\n value: {\n crc32,\n },\n }\n },\n maxLength: 4,\n }\n}\n\nexport type CramTagDictionary = string[][]\n\nfunction makeTagSet(buffer: Buffer, stringStart: number, stringEnd: number) {\n const str = buffer.toString('utf8', stringStart, stringEnd)\n const tags = []\n for (let i = 0; i < str.length; i += 3) {\n tags.push(str.slice(i, i + 3))\n }\n return tags\n}\n\nexport function cramTagDictionary() {\n return {\n parser: (buffer: Buffer, offset: number) => {\n const [size, newOffset1] = parseItf8(buffer, offset)\n offset += newOffset1\n const subbuf = buffer.subarray(offset, offset + size)\n offset += size\n\n const tagSets = []\n let stringStart = 0\n let i = 0\n for (; i < subbuf.length; i++) {\n if (!subbuf[i]) {\n tagSets.push(makeTagSet(subbuf, stringStart, i))\n stringStart = i + 1\n }\n }\n if (i > stringStart) {\n tagSets.push(makeTagSet(subbuf, stringStart, i))\n }\n\n return {\n value: {\n size,\n ents: tagSets,\n },\n offset,\n }\n },\n }\n}\n\nexport interface CramPreservationMap {\n MI: boolean\n UI: boolean\n PI: boolean\n RN: boolean\n AP: boolean\n RR: boolean\n SM: [number, number, number, number, number]\n TD: CramTagDictionary\n}\n\nexport function cramPreservationMap() {\n return {\n parser: (buffer: Buffer, offset: number) => {\n const b = buffer\n const dataView = new DataView(b.buffer, b.byteOffset, b.length)\n const [mapSize, newOffset1] = parseItf8(buffer, offset)\n offset += newOffset1\n const [mapCount, newOffset2] = parseItf8(buffer, offset)\n offset += newOffset2\n const ents = []\n for (let i = 0; i < mapCount; i++) {\n const key =\n String.fromCharCode(buffer[offset]!) +\n String.fromCharCode(buffer[offset + 1]!)\n offset += 2\n\n if (\n key === 'MI' ||\n key === 'UI' ||\n key === 'PI' ||\n key === 'RN' ||\n key === 'AP' ||\n key === 'RR'\n ) {\n ents.push({\n key,\n value: !!dataView.getUint8(offset),\n })\n offset += 1\n } else if (key === 'SM') {\n ents.push({\n key,\n value: [\n dataView.getUint8(offset),\n dataView.getUint8(offset + 1),\n dataView.getUint8(offset + 2),\n dataView.getUint8(offset + 3),\n dataView.getUint8(offset + 4),\n ],\n })\n offset += 5\n } else if (key === 'TD') {\n const { offset: offsetRet, value } = cramTagDictionary().parser(\n buffer,\n offset,\n )\n ents.push({ key, value: value.ents })\n offset = offsetRet\n } else {\n throw new Error(`unknown key ${key}`)\n }\n }\n return {\n value: {\n mapSize,\n mapCount,\n ents,\n },\n offset,\n }\n },\n }\n}\n\nfunction formatMap(data: { ents: { key: string; value: unknown }[] }) {\n const map: Record<string, unknown> = {}\n for (const { key, value } of data.ents) {\n if (map[key]) {\n console.warn(`duplicate key ${key} in map`)\n }\n map[key] = value\n }\n return map\n}\n\nexport interface MappedSliceHeader {\n refSeqId: number\n refSeqStart: number\n refSeqSpan: number\n numRecords: number\n recordCounter: number\n numBlocks: number\n numContentIds: number\n contentIds: number[]\n refBaseBlockId: number\n md5?: TupleOf<number, 16>\n}\n\nexport interface UnmappedSliceHeader {\n numRecords: number\n recordCounter: number\n numBlocks: number\n numContentIds: number\n contentIds: number[]\n md5?: TupleOf<number, 16>\n}\n\nexport function isMappedSliceHeader(\n header: unknown,\n): header is MappedSliceHeader {\n return typeof (header as any).refSeqId === 'number'\n}\n\ninterface Value {\n codecId: number\n parametersBytes: number\n parameters: Record<string, unknown>\n}\n// assemble a section parser for the unmapped slice header, with slight\n// variations depending on the major version of the cram file\nfunction cramUnmappedSliceHeader(majorVersion: number) {\n let maxLength = 0\n maxLength += 5\n maxLength += 9\n maxLength += 5 * 2\n maxLength += 16\n\n const parser = (buffer: Buffer, offset: number) => {\n const [numRecords, newOffset1] = parseItf8(buffer, offset)\n offset += newOffset1\n let recordCounter = 0\n\n // recordCounter is itf8 in a CRAM v2 file, absent in CRAM v1\n if (majorVersion >= 3) {\n const [rc, newOffset2] = parseLtf8(buffer, offset)\n offset += newOffset2\n recordCounter = rc\n } else if (majorVersion === 2) {\n const [rc, newOffset2] = parseItf8(buffer, offset)\n offset += newOffset2\n recordCounter = rc\n } else {\n console.warn('recordCounter=0')\n }\n\n const [numBlocks, newOffset3] = parseItf8(buffer, offset)\n offset += newOffset3\n const [numContentIds, newOffset4] = parseItf8(buffer, offset)\n offset += newOffset4\n const contentIds = []\n for (let i = 0; i < numContentIds; i++) {\n const [id, newOffset5] = parseItf8(buffer, offset)\n offset += newOffset5\n contentIds.push(id)\n }\n\n // the md5 sum is missing in cram v1\n let md5: TupleOf<number, 16> | undefined\n if (majorVersion >= 2) {\n md5 = [...buffer.subarray(offset, offset + 16)] as TupleOf<number, 16>\n offset += 16\n }\n\n return {\n value: {\n recordCounter,\n md5,\n contentIds,\n numContentIds,\n numBlocks,\n numRecords,\n },\n offset,\n }\n }\n return {\n parser,\n maxLength: (numContentIds: number) => maxLength + numContentIds * 5,\n }\n}\n\n// assembles a section parser for the unmapped slice header, with slight\n// variations depending on the major version of the cram file\nfunction cramMappedSliceHeader(majorVersion: number) {\n let maxLength = 0\n maxLength += 5 * 4 // EL0\n maxLength += 9 // EL1\n maxLength += 5 * 3 // EL2 ITF8s\n maxLength += 16 // MD5\n\n return {\n parser: (buffer: Buffer, offset: number) => {\n // L0\n const [refSeqId, newOffset1] = parseItf8(buffer, offset)\n offset += newOffset1\n const [refSeqStart, newOffset2] = parseItf8(buffer, offset)\n offset += newOffset2\n const [refSeqSpan, newOffset3] = parseItf8(buffer, offset)\n offset += newOffset3\n const [numRecords, newOffset4] = parseItf8(buffer, offset)\n offset += newOffset4\n // EL0\n\n // L1\n let recordCounter = 0\n if (majorVersion >= 3) {\n const [rc, newOffset5] = parseLtf8(buffer, offset)\n offset += newOffset5\n recordCounter = rc\n } else if (majorVersion === 2) {\n const [rc, newOffset5] = parseItf8(buffer, offset)\n offset += newOffset5\n recordCounter = rc\n } else {\n console.warn('majorVersion is <2, recordCounter set to 0')\n }\n // EL1\n\n // L2\n const [numBlocks, newOffset6] = parseItf8(buffer, offset)\n offset += newOffset6\n const [numContentIds, newOffset7] = parseItf8(buffer, offset)\n offset += newOffset7\n const contentIds = []\n for (let i = 0; i < numContentIds; i++) {\n const [id, newOffset5] = parseItf8(buffer, offset)\n offset += newOffset5\n contentIds.push(id)\n }\n const [refBaseBlockId, newOffset8] = parseItf8(buffer, offset)\n offset += newOffset8\n // EL2\n\n // the md5 sum is missing in cram v1\n let md5: TupleOf<number, 16> | undefined\n if (majorVersion >= 2) {\n md5 = [...buffer.subarray(offset, offset + 16)] as TupleOf<number, 16>\n offset += 16\n }\n\n return {\n value: {\n md5,\n numBlocks,\n numRecords,\n numContentIds,\n refSeqSpan,\n refSeqId,\n refSeqStart,\n recordCounter,\n refBaseBlockId,\n contentIds,\n },\n offset,\n }\n },\n maxLength: (numContentIds: number) => maxLength + numContentIds * 5,\n }\n}\n\nfunction cramEncoding() {\n return {\n parser: (buffer: Buffer, offset: number) => cramEncodingSub(buffer, offset),\n }\n}\n\nfunction cramEncodingSub(\n buffer: Buffer,\n offset: number,\n): { value: Value; offset: number } {\n const b = buffer\n const dataView = new DataView(b.buffer, b.byteOffset, b.length)\n const [codecId, newOffset1] = parseItf8(buffer, offset)\n offset += newOffset1\n const [parametersBytes, newOffset2] = parseItf8(buffer, offset)\n offset += newOffset2\n\n const parameters = {} as Record<string, unknown>\n\n if (codecId === 0) {\n // NULL\n } else if (codecId === 1) {\n // EXTERNAL\n const [bc, newOffset3] = parseItf8(buffer, offset)\n parameters.blockContentId = bc\n offset += newOffset3\n } else if (codecId === 2) {\n // GOLUMB\n const [off, newOffset3] = parseItf8(buffer, offset)\n parameters.offset = off\n offset += newOffset3\n const [M2, newOffset4] = parseItf8(buffer, offset)\n parameters.M = M2\n offset += newOffset4\n } else if (codecId === 3) {\n // HUFFMAN_INT\n const val = parseItf8(buffer, offset)\n const numCodes = val[0]\n offset += val[1]\n const symbols = [] as number[]\n for (let i = 0; i < numCodes; i++) {\n const code = parseItf8(buffer, offset)\n symbols.push(code[0])\n offset += code[1]\n }\n parameters.symbols = symbols\n const val2 = parseItf8(buffer, offset)\n const numLengths = val[0]\n parameters.numLengths = numLengths\n parameters.numCodes = numCodes\n parameters.numLengths = numLengths\n offset += val2[1]\n const bitLengths = [] as number[]\n for (let i = 0; i < numLengths; i++) {\n const len = parseItf8(buffer, offset)\n offset += len[1]\n bitLengths.push(len[0])\n }\n parameters.bitLengths = bitLengths\n } else if (codecId === 4) {\n // BYTE_ARRAY_LEN\n const { value: lengthsEncoding, offset: newOffset1 } = cramEncodingSub(\n buffer,\n offset,\n )\n parameters.lengthsEncoding = lengthsEncoding\n offset = newOffset1\n const { value: valuesEncoding, offset: newOffset2 } = cramEncodingSub(\n buffer,\n offset,\n )\n parameters.valuesEncoding = valuesEncoding\n offset = newOffset2\n } else if (codecId === 5) {\n // BYTE_ARRAY_STOP\n parameters.stopByte = dataView.getUint8(offset)\n offset += 1\n const [blockContentId, newOffset1] = parseItf8(buffer, offset)\n parameters.blockContentId = blockContentId\n offset += newOffset1\n } else if (codecId === 6) {\n // BETA\n const [off, newOffset1] = parseItf8(buffer, offset)\n parameters.offset = off\n offset += newOffset1\n const [len, newOffset2] = parseItf8(buffer, offset)\n parameters.length = len\n offset += newOffset2\n } else if (codecId === 7) {\n // SUBEXP\n const [off, newOffset1] = parseItf8(buffer, offset)\n parameters.offset = off\n offset += newOffset1\n const [K, newOffset2] = parseItf8(buffer, offset)\n parameters.K = K\n offset += newOffset2\n } else if (codecId === 8) {\n // GOLOMB_RICE\n const [off, newOffset1] = parseItf8(buffer, offset)\n parameters.offset = off\n offset += newOffset1\n const [l2m, newOffset2] = parseItf8(buffer, offset)\n parameters.log2m = l2m\n offset += newOffset2\n } else if (codecId === 9) {\n // GAMMA\n const [off, newOffset1] = parseItf8(buffer, offset)\n parameters.offset = off\n offset += newOffset1\n } else {\n throw new Error(`unknown codecId ${codecId}`)\n }\n\n return {\n value: {\n codecId,\n parametersBytes,\n parameters,\n },\n offset,\n }\n}\n\nfunction cramDataSeriesEncodingMap() {\n return {\n parser: (buffer: Buffer, offset: number) => {\n const [mapSize, newOffset1] = parseItf8(buffer, offset)\n offset += newOffset1\n const [mapCount, newOffset2] = parseItf8(buffer, offset)\n offset += newOffset2\n const ents = []\n for (let i = 0; i < mapCount; i++) {\n const key =\n String.fromCharCode(buffer[offset]!) +\n String.fromCharCode(buffer[offset + 1]!)\n offset += 2\n\n const { value, offset: newOffset4 } = cramEncodingSub(buffer, offset)\n offset = newOffset4\n ents.push({ key, value })\n }\n return {\n value: {\n mapSize,\n ents,\n mapCount,\n },\n offset,\n }\n },\n }\n}\n\nfunction cramTagEncodingMap() {\n return {\n parser: (buffer: Buffer, offset: number) => {\n const [mapSize, newOffset1] = parseItf8(buffer, offset)\n offset += newOffset1\n const [mapCount, newOffset2] = parseItf8(buffer, offset)\n offset += newOffset2\n const ents = []\n for (let i = 0; i < mapCount; i++) {\n const [k0, newOffset3] = parseItf8(buffer, offset)\n offset += newOffset3\n const key =\n String.fromCharCode((k0 >> 16) & 0xff) +\n String.fromCharCode((k0 >> 8) & 0xff) +\n String.fromCharCode(k0 & 0xff)\n\n const { value, offset: newOffset4 } = cramEncodingSub(buffer, offset)\n offset = newOffset4\n ents.push({ key, value })\n }\n return {\n value: {\n mapSize,\n ents,\n mapCount,\n },\n offset,\n }\n },\n }\n}\n\nfunction cramCompressionHeader() {\n return {\n parser: (buffer: Buffer, offset: number) => {\n // TODO: if we want to support CRAM v1, we will need to refactor\n // compression header into 2 parts to parse the landmarks, like the\n // container header\n const { value: preservation, offset: newOffset1 } =\n cramPreservationMap().parser(buffer, offset)\n offset = newOffset1\n\n const { value: dataSeriesEncoding, offset: newOffset2 } =\n cramDataSeriesEncodingMap().parser(buffer, offset)\n offset = newOffset2\n\n const { value: tagEncoding, offset: newOffset3 } =\n cramTagEncodingMap().parser(buffer, offset)\n offset = newOffset3\n\n return {\n value: {\n dataSeriesEncoding: formatMap(\n dataSeriesEncoding,\n ) as DataSeriesEncodingMap,\n preservation: formatMap(\n preservation,\n ) as unknown as CramPreservationMap,\n tagEncoding: formatMap(tagEncoding) as Record<string, CramEncoding>,\n },\n offset,\n }\n },\n }\n}\n\nfunction cramContainerHeader1(majorVersion: number) {\n let maxLength = 4\n maxLength += 5 * 4\n maxLength += 9\n maxLength += 9\n maxLength += 5 + 5\n return {\n maxLength,\n parser: (buffer: Buffer, offset: number) => {\n const b = buffer\n const dataView = new DataView(b.buffer, b.byteOffset, b.length)\n // byte size of the container data (blocks)\n const length = dataView.getInt32(offset, true)\n offset += 4\n // reference sequence identifier, -1 for unmapped reads, -2 for multiple\n // reference sequences\n const [refSeqId, newOffset1] = parseItf8(buffer, offset)\n offset += newOffset1\n const [refSeqStart, newOffset2] = parseItf8(buffer, offset)\n offset += newOffset2\n const [alignmentSpan, newOffset3] = parseItf8(buffer, offset)\n offset += newOffset3\n const [numRecords, newOffset4] = parseItf8(buffer, offset)\n offset += newOffset4\n\n let recordCounter = 0\n if (majorVersion >= 3) {\n const [rc, newOffset5] = parseLtf8(buffer, offset)\n recordCounter = rc\n offset += newOffset5\n } else if (majorVersion === 2) {\n const [rc, newOffset5] = parseItf8(buffer, offset)\n recordCounter = rc\n offset += newOffset5\n } else {\n console.warn('setting recordCounter=0')\n }\n\n let numBases: number | undefined\n if (majorVersion > 1) {\n const [n, newOffset5] = parseLtf8(buffer, offset)\n numBases = n\n offset += newOffset5\n }\n const [numBlocks, newOffset6] = parseItf8(buffer, offset)\n offset += newOffset6\n const [numLandmarks, newOffset7] = parseItf8(buffer, offset)\n offset += newOffset7\n return {\n value: {\n length,\n refSeqId,\n refSeqStart,\n alignmentSpan,\n numBlocks,\n numLandmarks,\n numBases,\n recordCounter,\n numRecords,\n },\n offset,\n }\n },\n }\n}\n\nfunction cramContainerHeader2(majorVersion: number) {\n return {\n parser: (buffer: Buffer, offset: number) => {\n const b = buffer\n const dataView = new DataView(b.buffer, b.byteOffset, b.length)\n const [numLandmarks, newOffset1] = parseItf8(buffer, offset)\n offset += newOffset1\n const landmarks = []\n for (let i = 0; i < numLandmarks; i++) {\n const [landmark, newOffset2] = parseItf8(buffer, offset)\n offset += newOffset2\n landmarks.push(landmark)\n }\n\n let crc32: number | undefined\n if (majorVersion >= 3) {\n crc32 = dataView.getUint32(offset, true)\n offset += 4\n }\n return {\n value: {\n ...(crc32 === undefined ? {} : { crc32 }),\n numLandmarks,\n landmarks,\n },\n offset,\n }\n },\n maxLength: (numLandmarks: number) => 5 + 5 * numLandmarks + 4,\n }\n}\n\nexport type CompressionMethod =\n | 'raw'\n | 'gzip'\n | 'bzip2'\n | 'lzma'\n | 'rans'\n | 'rans4x16'\n | 'arith'\n | 'fqzcomp'\n | 'tok3'\n\nexport interface BlockHeader {\n compressionMethod: CompressionMethod\n contentType:\n | 'FILE_HEADER'\n | 'COMPRESSION_HEADER'\n | 'MAPPED_SLICE_HEADER'\n | 'UNMAPPED_SLICE_HEADER' // < only used in cram v1\n | 'EXTERNAL_DATA'\n | 'CORE_DATA'\n contentId: number\n compressedSize: number\n uncompressedSize: number\n}\n\nexport interface CramCompressionHeader {\n preservation: CramPreservationMap\n dataSeriesEncoding: DataSeriesEncodingMap\n tagEncoding: Record<string, CramEncoding>\n _size: number\n _endPosition: number\n}\n\nexport function getSectionParsers(majorVersion: number) {\n return {\n cramFileDefinition: cramFileDefinition(),\n cramBlockHeader: cramBlockHeader(),\n cramBlockCrc32: cramBlockCrc32(),\n cramDataSeriesEncodingMap: cramDataSeriesEncodingMap(),\n cramTagEncodingMap: cramTagEncodingMap(),\n cramCompressionHeader: cramCompressionHeader(),\n cramEncoding: cramEncoding(),\n cramUnmappedSliceHeader: cramUnmappedSliceHeader(majorVersion),\n cramMappedSliceHeader: cramMappedSliceHeader(majorVersion),\n cramContainerHeader1: cramContainerHeader1(majorVersion),\n cramContainerHeader2: cramContainerHeader2(majorVersion),\n }\n}\n","import { CramMalformedError } from '../../errors'\nimport {\n BamFlagsDecoder,\n CramFlagsDecoder,\n MateFlagsDecoder,\n ReadFeature,\n} from '../record'\nimport CramSlice, { SliceHeader } from './index'\nimport { isMappedSliceHeader } from '../sectionParsers'\nimport CramContainerCompressionScheme, {\n DataSeriesTypes,\n} from '../container/compressionScheme'\nimport { CramFileBlock } from '../file'\nimport { Cursors, DataTypeMapping } from '../codecs/_base'\nimport { DataSeriesEncodingKey } from '../codecs/dataSeriesTypes'\n\n/**\n * given a Buffer, read a string up to the first null character\n * @private\n */\nfunction readNullTerminatedString(buffer: Uint8Array) {\n let r = ''\n for (let i = 0; i < buffer.length && buffer[i] !== 0; i++) {\n r += String.fromCharCode(buffer[i]!)\n }\n return r\n}\n\n/**\n * parse a BAM tag's array value from a binary buffer\n * @private\n */\nfunction parseTagValueArray(buffer: Uint8Array) {\n const arrayType = String.fromCharCode(buffer[0]!)\n const length = Int32Array.from(buffer.slice(1))[0]!\n\n const array: number[] = new Array(length)\n buffer = buffer.slice(5)\n\n if (arrayType === 'c') {\n const arr = new Int8Array(buffer.buffer)\n for (let i = 0; i < length; i += 1) {\n array[i] = arr[i]!\n }\n } else if (arrayType === 'C') {\n const arr = new Uint8Array(buffer.buffer)\n for (let i = 0; i < length; i += 1) {\n array[i] = arr[i]!\n }\n } else if (arrayType === 's') {\n const arr = new Int16Array(buffer.buffer)\n for (let i = 0; i < length; i += 1) {\n array[i] = arr[i]!\n }\n } else if (arrayType === 'S') {\n const arr = new Uint16Array(buffer.buffer)\n for (let i = 0; i < length; i += 1) {\n array[i] = arr[i]!\n }\n } else if (arrayType === 'i') {\n const arr = new Int32Array(buffer.buffer)\n for (let i = 0; i < length; i += 1) {\n array[i] = arr[i]!\n }\n } else if (arrayType === 'I') {\n const arr = new Uint32Array(buffer.buffer)\n for (let i = 0; i < length; i += 1) {\n array[i] = arr[i]!\n }\n } else if (arrayType === 'f') {\n const arr = new Float32Array(buffer.buffer)\n for (let i = 0; i < length; i += 1) {\n array[i] = arr[i]!\n }\n } else {\n throw new Error(`unknown type: ${arrayType}`)\n }\n\n return array\n}\n\nfunction parseTagData(tagType: string, buffer: Uint8Array) {\n if (tagType === 'Z') {\n return readNullTerminatedString(buffer)\n }\n if (tagType === 'A') {\n return String.fromCharCode(buffer[0]!)\n }\n if (tagType === 'I') {\n return new Uint32Array(buffer.buffer)[0]\n }\n if (tagType === 'i') {\n return new Int32Array(buffer.buffer)[0]\n }\n if (tagType === 's') {\n return new Int16Array(buffer.buffer)[0]\n }\n if (tagType === 'S') {\n return new Uint16Array(buffer.buffer)[0]\n }\n if (tagType === 'c') {\n return new Int8Array(buffer.buffer)[0]\n }\n if (tagType === 'C') {\n return buffer[0]!\n }\n if (tagType === 'f') {\n return new Float32Array(buffer.buffer)[0]\n }\n if (tagType === 'H') {\n return Number.parseInt(\n readNullTerminatedString(buffer).replace(/^0x/, ''),\n 16,\n )\n }\n if (tagType === 'B') {\n return parseTagValueArray(buffer)\n }\n\n throw new CramMalformedError(`Unrecognized tag type ${tagType}`)\n}\n\nfunction decodeReadFeatures(\n alignmentStart: number,\n readFeatureCount: number,\n decodeDataSeries: any,\n compressionScheme: CramContainerCompressionScheme,\n majorVersion: number,\n) {\n let currentReadPos = 0\n let currentRefPos = alignmentStart - 1\n const readFeatures: ReadFeature[] = new Array(readFeatureCount)\n\n function decodeRFData([type, dataSeriesName]: readonly [\n type: string,\n dataSeriesName: string,\n ]) {\n const data = decodeDataSeries(dataSeriesName)\n if (type === 'character') {\n return String.fromCharCode(data)\n }\n if (type === 'string') {\n let r = ''\n for (let i = 0; i < data.byteLength; i++) {\n r += String.fromCharCode(data[i])\n }\n return r\n }\n if (type === 'numArray') {\n return data.toArray()\n }\n // else if (type === 'number') {\n // return data[0]\n // }\n return data\n }\n\n for (let i = 0; i < readFeatureCount; i += 1) {\n const code = String.fromCharCode(decodeDataSeries('FC'))\n\n const readPosDelta = decodeDataSeries('FP')\n\n // map of operator name -> data series name\n const data1Schema = {\n B: ['character', 'BA'] as const,\n S: ['string', majorVersion > 1 ? 'SC' : 'IN'] as const, // IN if cram v1, SC otherwise\n X: ['number', 'BS'] as const,\n D: ['number', 'DL'] as const,\n I: ['string', 'IN'] as const,\n i: ['character', 'BA'] as const,\n b: ['string', 'BB'] as const,\n q: ['numArray', 'QQ'] as const,\n Q: ['number', 'QS'] as const,\n H: ['number', 'HC'] as const,\n P: ['number', 'PD'] as const,\n N: ['number', 'RS'] as const,\n }[code]\n\n if (!data1Schema) {\n throw new CramMalformedError(`invalid read feature code \"${code}\"`)\n }\n\n let data = decodeRFData(data1Schema)\n\n // if this is a tag with two data items, make the data an array and add the second item\n const data2Schema = { B: ['number', 'QS'] as const }[code]\n if (data2Schema) {\n data = [data, decodeRFData(data2Schema)]\n }\n\n currentReadPos += readPosDelta\n const pos = currentReadPos\n\n currentRefPos += readPosDelta\n const refPos = currentRefPos\n\n // for gapping features, adjust the reference position for read features that follow\n if (code === 'D' || code === 'N') {\n currentRefPos += data\n } else if (code === 'I' || code === 'S') {\n currentRefPos -= data.length\n } else if (code === 'i') {\n currentRefPos -= 1\n }\n\n readFeatures[i] = { code, pos, refPos, data }\n }\n return readFeatures\n}\n\nexport type DataSeriesDecoder = <T extends DataSeriesEncodingKey>(\n dataSeriesName: T,\n) => DataTypeMapping[DataSeriesTypes[T]]\n\nexport default function decodeRecord(\n slice: CramSlice,\n decodeDataSeries: DataSeriesDecoder,\n compressionScheme: CramContainerCompressionScheme,\n sliceHeader: SliceHeader,\n coreDataBlock: CramFileBlock,\n blocksByContentId: Record<number, CramFileBlock>,\n cursors: Cursors,\n majorVersion: number,\n recordNumber: number,\n) {\n let flags = decodeDataSeries('BF')\n\n // note: the C data type of compressionFlags is byte in cram v1\n // and int32 in cram v2+, but that does not matter for us here\n // in javascript land.\n const cramFlags = decodeDataSeries('CF')\n\n if (!isMappedSliceHeader(sliceHeader.parsedContent)) {\n throw new Error('slice header not mapped')\n }\n\n const sequenceId =\n majorVersion > 1 && sliceHeader.parsedContent.refSeqId === -2\n ? decodeDataSeries('RI')\n : sliceHeader.parsedContent.refSeqId\n\n const readLength = decodeDataSeries('RL')\n // if APDelta, will calculate the true start in a second pass\n let alignmentStart = decodeDataSeries('AP')\n if (compressionScheme.APdelta) {\n alignmentStart = alignmentStart + cursors.lastAlignmentStart\n }\n cursors.lastAlignmentStart = alignmentStart\n const readGroupId = decodeDataSeries('RG')\n\n let readName: string | undefined\n if (compressionScheme.readNamesIncluded) {\n readName = readNullTerminatedString(decodeDataSeries('RN'))\n }\n\n let mateToUse:\n | {\n mateFlags: number\n mateSequenceId: number\n mateAlignmentStart: number\n mateReadName: string | undefined\n }\n | undefined\n let templateSize: number | undefined\n let mateRecordNumber: number | undefined\n // mate record\n if (CramFlagsDecoder.isDetached(cramFlags)) {\n // note: the MF is a byte in 1.0, int32 in 2+, but once again this doesn't\n // matter for javascript\n const mateFlags = decodeDataSeries('MF')\n let mateReadName: string | undefined\n if (!compressionScheme.readNamesIncluded) {\n mateReadName = readNullTerminatedString(decodeDataSeries('RN'))\n readName = mateReadName\n }\n const mateSequenceId = decodeDataSeries('NS')\n const mateAlignmentStart = decodeDataSeries('NP')\n if (mateFlags || mateSequenceId > -1) {\n mateToUse = {\n mateFlags,\n mateSequenceId,\n mateAlignmentStart,\n mateReadName,\n }\n }\n\n templateSize = decodeDataSeries('TS')\n\n // set mate unmapped if needed\n if (MateFlagsDecoder.isUnmapped(mateFlags)) {\n flags = BamFlagsDecoder.setMateUnmapped(flags)\n }\n // set mate reversed if needed\n if (MateFlagsDecoder.isOnNegativeStrand(mateFlags)) {\n flags = BamFlagsDecoder.setMateReverseComplemented(flags)\n }\n\n // detachedCount++\n } else if (CramFlagsDecoder.isWithMateDownstream(cramFlags)) {\n mateRecordNumber = decodeDataSeries('NF') + recordNumber + 1\n }\n\n // TODO: the aux tag parsing will have to be refactored if we want to support\n // cram v1\n const TLindex = decodeDataSeries('TL')\n if (TLindex < 0) {\n /* TODO: check nTL: TLindex >= compressionHeader.tagEncoding.size */\n throw new CramMalformedError('invalid TL index')\n }\n\n const tags: Record<string, any> = {}\n // TN = tag names\n const TN = compressionScheme.getTagNames(TLindex)!\n const ntags = TN.length\n for (let i = 0; i < ntags; i += 1) {\n const tagId = TN[i]!\n const tagName = tagId.slice(0, 2)\n const tagType = tagId.slice(2, 3)\n\n const tagData = compressionScheme\n .getCodecForTag(tagId)\n .decode(slice, coreDataBlock, blocksByContentId, cursors)\n tags[tagName] =\n typeof tagData === 'number' ? tagData : parseTagData(tagType, tagData)\n }\n\n let readFeatures: ReadFeature[] | undefined\n let lengthOnRef: number | undefined\n let mappingQuality: number | undefined\n let qualityScores: number[] | undefined | null\n let readBases = undefined\n if (!BamFlagsDecoder.isSegmentUnmapped(flags)) {\n // reading read features\n const readFeatureCount = decodeDataSeries('FN')\n if (readFeatureCount) {\n readFeatures = decodeReadFeatures(\n alignmentStart,\n readFeatureCount,\n decodeDataSeries,\n compressionScheme,\n majorVersion,\n )\n }\n\n // compute the read's true span on the reference sequence, and the end\n // coordinate of the alignment on the reference\n lengthOnRef = readLength\n if (readFeatures) {\n for (const { code, data } of readFeatures) {\n if (code === 'D' || code === 'N') {\n lengthOnRef += data\n } else if (code === 'I' || code === 'S') {\n lengthOnRef = lengthOnRef - data.length\n } else if (code === 'i') {\n lengthOnRef = lengthOnRef - 1\n }\n }\n }\n if (Number.isNaN(lengthOnRef)) {\n console.warn(\n `${\n readName || `${sequenceId}:${alignmentStart}`\n } record has invalid read features`,\n )\n lengthOnRef = readLength\n }\n\n // mapping quality\n mappingQuality = decodeDataSeries('MQ')\n if (CramFlagsDecoder.isPreservingQualityScores(cramFlags)) {\n qualityScores = new Array(readLength)\n for (let i = 0; i < qualityScores.length; i++) {\n qualityScores[i] = decodeDataSeries('QS')\n }\n }\n } else if (CramFlagsDecoder.isDecodeSequenceAsStar(cramFlags)) {\n readBases = null\n qualityScores = null\n } else {\n const bases = new Array(readLength) as number[]\n for (let i = 0; i < bases.length; i += 1) {\n bases[i] = decodeDataSeries('BA')\n }\n readBases = String.fromCharCode(...bases)\n\n if (CramFlagsDecoder.isPreservingQualityScores(cramFlags)) {\n qualityScores = new Array(readLength)\n for (let i = 0; i < bases.length; i += 1) {\n qualityScores[i] = decodeDataSeries('QS')\n }\n }\n }\n\n return {\n readLength,\n sequenceId,\n cramFlags,\n flags,\n alignmentStart,\n readGroupId,\n readName,\n mateToUse,\n templateSize,\n mateRecordNumber,\n readFeatures,\n lengthOnRef,\n mappingQuality,\n qualityScores,\n readBases,\n tags,\n }\n}\n","import { CramArgumentError, CramMalformedError } from '../../errors'\nimport { parseItem, sequenceMD5, tinyMemoize } from '../util'\n\nimport Constants from '../constants'\nimport decodeRecord, { DataSeriesDecoder } from './decodeRecord'\nimport CramRecord from '../record'\nimport CramContainer from '../container'\nimport CramFile, { CramFileBlock } from '../file'\nimport {\n getSectionParsers,\n isMappedSliceHeader,\n MappedSliceHeader,\n UnmappedSliceHeader,\n} from '../sectionParsers'\nimport { CramBufferOverrunError } from '../codecs/getBits'\nimport { Cursors, DataTypeMapping } from '../codecs/_base'\nimport { DataSeriesEncodingKey } from '../codecs/dataSeriesTypes'\nimport { DataSeriesTypes } from '../container/compressionScheme'\n\nexport type SliceHeader = CramFileBlock & {\n parsedContent: MappedSliceHeader | UnmappedSliceHeader\n}\n\n/**\n * @private\n * Try to estimate the template length from a bunch of interrelated multi-segment reads.\n * @param {Array[CramRecord]} allRecords\n * @param {number} currentRecordNumber\n * @param {CramRecord} thisRecord\n */\nfunction calculateMultiSegmentMatedTemplateLength(\n allRecords: CramRecord[],\n currentRecordNumber: number,\n thisRecord: CramRecord,\n) {\n function getAllMatedRecords(startRecord: CramRecord) {\n const records = [startRecord]\n if (\n startRecord.mateRecordNumber !== undefined &&\n startRecord.mateRecordNumber >= 0\n ) {\n const mateRecord = allRecords[startRecord.mateRecordNumber]\n if (!mateRecord) {\n throw new CramMalformedError(\n 'intra-slice mate record not found, this file seems malformed',\n )\n }\n records.push(...getAllMatedRecords(mateRecord))\n }\n return records\n }\n\n const matedRecords = getAllMatedRecords(thisRecord)\n const starts = matedRecords.map(r => r.alignmentStart)\n const ends = matedRecords.map(r => r.alignmentStart + r.readLength - 1)\n const estimatedTemplateLength = Math.max(...ends) - Math.min(...starts) + 1\n if (estimatedTemplateLength >= 0) {\n matedRecords.forEach(r => {\n if (r.templateLength !== undefined) {\n throw new CramMalformedError(\n 'mate pair group has some members that have template lengths already, this file seems malformed',\n )\n }\n r.templateLength = estimatedTemplateLength\n })\n }\n}\n\n/**\n * @private\n * Attempt to calculate the `templateLength` for a pair of intra-slice paired reads.\n * Ported from htslib. Algorithm is imperfect.\n * @param {CramRecord} thisRecord\n * @param {CramRecord} mateRecord\n */\nfunction calculateIntraSliceMatePairTemplateLength(\n thisRecord: CramRecord,\n mateRecord: CramRecord,\n) {\n // this just estimates the template length by using the simple (non-gapped) end coordinate of each\n // read, because gapping in the alignment doesn't mean the template is longer or shorter\n const start = Math.min(thisRecord.alignmentStart, mateRecord.alignmentStart)\n const end = Math.max(\n thisRecord.alignmentStart + thisRecord.readLength - 1,\n mateRecord.alignmentStart + mateRecord.readLength - 1,\n )\n const lengthEstimate = end - start + 1\n thisRecord.templateLength = lengthEstimate\n mateRecord.templateLength = lengthEstimate\n}\n\n/**\n * @private establishes a mate-pair relationship between two records in the\n * same slice. CRAM compresses mate-pair relationships between records in the\n * same slice down into just one record having the index in the slice of its\n * mate\n */\nfunction associateIntraSliceMate(\n allRecords: CramRecord[],\n currentRecordNumber: number,\n thisRecord: CramRecord,\n mateRecord: CramRecord,\n) {\n const complicatedMultiSegment = !!(\n mateRecord.mate ||\n (mateRecord.mateRecordNumber !== undefined &&\n mateRecord.mateRecordNumber !== currentRecordNumber)\n )\n\n // Deal with lossy read names\n if (!thisRecord.readName) {\n thisRecord.readName = String(thisRecord.uniqueId)\n mateRecord.readName = thisRecord.readName\n }\n\n thisRecord.mate = {\n sequenceId: mateRecord.sequenceId,\n alignmentStart: mateRecord.alignmentStart,\n uniqueId: mateRecord.uniqueId,\n }\n if (mateRecord.readName) {\n thisRecord.mate.readName = mateRecord.readName\n }\n\n // the mate record might have its own mate pointer, if this is some kind of\n // multi-segment (more than paired) scheme, so only relate that one back to this one\n // if it does not have any other relationship\n if (!mateRecord.mate && mateRecord.mateRecordNumber === undefined) {\n mateRecord.mate = {\n sequenceId: thisRecord.sequenceId,\n alignmentStart: thisRecord.alignmentStart,\n uniqueId: thisRecord.uniqueId,\n }\n if (thisRecord.readName) {\n mateRecord.mate.readName = thisRecord.readName\n }\n }\n\n // make sure the proper flags and cramFlags are set on both records\n // paired\n thisRecord.flags |= Constants.BAM_FPAIRED\n\n // set mate unmapped if needed\n if (mateRecord.flags & Constants.BAM_FUNMAP) {\n thisRecord.flags |= Constants.BAM_FMUNMAP\n // thisRecord.templateLength = 0\n }\n if (thisRecord.flags & Constants.BAM_FUNMAP) {\n // thisRecord.templateLength = 0\n mateRecord.flags |= Constants.BAM_FMUNMAP\n }\n\n // set mate reversed if needed\n if (mateRecord.flags & Constants.BAM_FREVERSE) {\n thisRecord.flags |= Constants.BAM_FMREVERSE\n }\n if (thisRecord.flags & Constants.BAM_FREVERSE) {\n mateRecord.flags |= Constants.BAM_FMREVERSE\n }\n\n if (thisRecord.templateLength === undefined) {\n if (complicatedMultiSegment) {\n calculateMultiSegmentMatedTemplateLength(\n allRecords,\n currentRecordNumber,\n thisRecord,\n )\n } else {\n calculateIntraSliceMatePairTemplateLength(thisRecord, mateRecord)\n }\n }\n\n // delete this last because it's used by the\n // complicated template length estimation\n thisRecord.mateRecordNumber = undefined\n}\n\nexport default class CramSlice {\n private file: CramFile\n\n constructor(\n public container: CramContainer,\n public containerPosition: number,\n public sliceSize: number,\n ) {\n this.file = container.file\n }\n\n // memoize\n async getHeader() {\n // fetch and parse the slice header\n const { majorVersion } = await this.file.getDefinition()\n const sectionParsers = getSectionParsers(majorVersion)\n const containerHeader = await this.container.getHeader()\n if (!containerHeader) {\n throw new Error('no container header detected')\n }\n\n const header = await this.file.readBlock(\n containerHeader._endPosition + this.containerPosition,\n )\n if (header === undefined) {\n throw new Error('block header undefined')\n }\n if (header.contentType === 'MAPPED_SLICE_HEADER') {\n const content = parseItem(\n header.content,\n sectionParsers.cramMappedSliceHeader.parser,\n 0,\n containerHeader._endPosition,\n )\n return { ...header, parsedContent: content }\n } else if (header.contentType === 'UNMAPPED_SLICE_HEADER') {\n const content = parseItem(\n header.content,\n sectionParsers.cramUnmappedSliceHeader.parser,\n 0,\n containerHeader._endPosition,\n )\n return { ...header, parsedContent: content }\n } else {\n throw new CramMalformedError(\n `error reading slice header block, invalid content type ${header.contentType}`,\n )\n }\n }\n\n // memoize\n async getBlocks() {\n const header = await this.getHeader()\n // read all the blocks into memory and store them\n let blockPosition = header._endPosition\n const blocks: CramFileBlock[] = new Array(header.parsedContent.numBlocks)\n for (let i = 0; i < blocks.length; i++) {\n const block = await this.file.readBlock(blockPosition)\n if (block === undefined) {\n throw new Error('block undefined')\n }\n blocks[i] = block\n blockPosition = blocks[i]!._endPosition\n }\n\n return blocks\n }\n\n // no memoize\n async getCoreDataBlock() {\n const blocks = await this.getBlocks()\n return blocks[0]!\n }\n\n // memoize\n async _getBlocksContentIdIndex(): Promise<Record<number, CramFileBlock>> {\n const blocks = await this.getBlocks()\n const blocksByContentId: Record<number, CramFileBlock> = {}\n blocks.forEach(block => {\n if (block.contentType === 'EXTERNAL_DATA') {\n blocksByContentId[block.contentId] = block\n }\n })\n return blocksByContentId\n }\n\n async getBlockByContentId(id: number) {\n const blocksByContentId = await this._getBlocksContentIdIndex()\n return blocksByContentId[id]\n }\n\n async getReferenceRegion() {\n // read the slice header\n const sliceHeader = (await this.getHeader()).parsedContent\n if (!isMappedSliceHeader(sliceHeader)) {\n throw new Error('slice header not mapped')\n }\n\n if (sliceHeader.refSeqId < 0) {\n return undefined\n }\n\n const compressionScheme = await this.container.getCompressionScheme()\n if (compressionScheme === undefined) {\n throw new Error('compression scheme undefined')\n }\n\n if (sliceHeader.refBaseBlockId >= 0) {\n const refBlock = await this.getBlockByContentId(\n sliceHeader.refBaseBlockId,\n )\n if (!refBlock) {\n throw new CramMalformedError(\n 'embedded reference specified, but reference block does not exist',\n )\n }\n\n // TODO: we do not read anything named 'span'\n // if (sliceHeader.span > refBlock.uncompressedSize) {\n // throw new CramMalformedError('Embedded reference is too small')\n // }\n\n // TODO verify\n return {\n seq: (refBlock as any).data.toString('utf8'),\n start: sliceHeader.refSeqStart,\n end: sliceHeader.refSeqStart + sliceHeader.refSeqSpan - 1,\n span: sliceHeader.refSeqSpan,\n }\n }\n if (\n compressionScheme.referenceRequired ||\n this.file.fetchReferenceSequenceCallback\n ) {\n if (!this.file.fetchReferenceSequenceCallback) {\n throw new Error(\n 'reference sequence not embedded, and seqFetch callback not provided, cannot fetch reference sequence',\n )\n }\n\n const seq = await this.file.fetchReferenceSequenceCallback(\n sliceHeader.refSeqId,\n sliceHeader.refSeqStart,\n sliceHeader.refSeqStart + sliceHeader.refSeqSpan - 1,\n )\n\n if (seq.length !== sliceHeader.refSeqSpan) {\n throw new CramArgumentError(\n 'seqFetch callback returned a reference sequence of the wrong length',\n )\n }\n\n return {\n seq,\n start: sliceHeader.refSeqStart,\n end: sliceHeader.refSeqStart + sliceHeader.refSeqSpan - 1,\n span: sliceHeader.refSeqSpan,\n }\n }\n\n return undefined\n }\n\n getAllRecords() {\n return this.getRecords(() => true)\n }\n\n async _fetchRecords() {\n const { majorVersion } = await this.file.getDefinition()\n\n const compressionScheme = await this.container.getCompressionScheme()\n if (compressionScheme === undefined) {\n throw new Error('compression scheme undefined')\n }\n\n const sliceHeader = await this.getHeader()\n const blocksByContentId = await this._getBlocksContentIdIndex()\n\n // check MD5 of reference if available\n if (\n majorVersion > 1 &&\n this.file.options.checkSequenceMD5 &&\n isMappedSliceHeader(sliceHeader.parsedContent) &&\n sliceHeader.parsedContent.refSeqId >= 0 &&\n sliceHeader.parsedContent.md5?.join('') !== '0000000000000000'\n ) {\n const refRegion = await this.getReferenceRegion()\n if (refRegion) {\n const { seq, start, end } = refRegion\n const seqMd5 = sequenceMD5(seq)\n const storedMd5 = sliceHeader.parsedContent.md5\n ?.map(byte => (byte < 16 ? '0' : '') + byte.toString(16))\n .join('')\n if (seqMd5 !== storedMd5) {\n throw new CramMalformedError(\n `MD5 checksum reference mismatch for ref ${sliceHeader.parsedContent.refSeqId} pos ${start}..${end}. recorded MD5: ${storedMd5}, calculated MD5: ${seqMd5}`,\n )\n }\n }\n }\n\n // tracks the read position within the block. codec.decode() methods\n // advance the byte and bit positions in the cursor as they decode\n // data note that we are only decoding a single block here, the core\n // data block\n const coreDataBlock = await this.getCoreDataBlock()\n const cursors: Cursors = {\n lastAlignmentStart: isMappedSliceHeader(sliceHeader.parsedContent)\n ? sliceHeader.parsedContent.refSeqStart\n : 0,\n coreBlock: { bitPosition: 7, bytePosition: 0 },\n externalBlocks: {\n map: new Map(),\n getCursor(contentId: number) {\n let r = this.map.get(contentId)\n if (r === undefined) {\n r = { bitPosition: 7, bytePosition: 0 }\n this.map.set(contentId, r)\n }\n return r\n },\n },\n }\n\n const decodeDataSeries: DataSeriesDecoder = <\n T extends DataSeriesEncodingKey,\n >(\n dataSeriesName: T,\n ): DataTypeMapping[DataSeriesTypes[T]] => {\n const codec = compressionScheme.getCodecForDataSeries(dataSeriesName)\n if (!codec) {\n throw new CramMalformedError(\n `no codec defined for ${dataSeriesName} data series`,\n )\n }\n // console.log(dataSeriesName, Object.getPrototypeOf(codec))\n const decoded = codec.decode(\n this,\n coreDataBlock,\n blocksByContentId,\n cursors,\n )\n return decoded\n }\n const records: CramRecord[] = new Array(\n sliceHeader.parsedContent.numRecords,\n )\n for (let i = 0; i < records.length; i += 1) {\n try {\n const init = decodeRecord(\n this,\n decodeDataSeries,\n compressionScheme,\n sliceHeader,\n coreDataBlock,\n blocksByContentId,\n cursors,\n majorVersion,\n i,\n )\n records[i] = new CramRecord({\n ...init,\n uniqueId:\n sliceHeader.contentPosition +\n sliceHeader.parsedContent.recordCounter +\n i +\n 1,\n })\n } catch (e) {\n if (e instanceof CramBufferOverrunError) {\n console.warn(\n 'read attempted beyond end of buffer, file seems truncated.',\n )\n break\n } else {\n throw e\n }\n }\n }\n\n // interpret `recordsToNextFragment` attributes to make standard `mate`\n // objects Resolve mate pair cross-references between records in this slice\n for (let i = 0; i < records.length; i += 1) {\n const { mateRecordNumber } = records[i]!\n if (mateRecordNumber !== undefined && mateRecordNumber >= 0) {\n associateIntraSliceMate(\n records,\n i,\n records[i]!,\n records[mateRecordNumber]!,\n )\n }\n }\n\n return records\n }\n\n async getRecords(filterFunction: (r: CramRecord) => boolean) {\n // fetch the features if necessary, using the file-level feature cache\n const cacheKey = this.container.filePosition + this.containerPosition\n let recordsPromise = this.file.featureCache.get(cacheKey.toString())\n if (!recordsPromise) {\n recordsPromise = this._fetchRecords()\n this.file.featureCache.set(cacheKey.toString(), recordsPromise)\n }\n\n const unfiltered = await recordsPromise\n const records = unfiltered.filter(filterFunction)\n\n // if we can fetch reference sequence, add the reference sequence to the records\n if (records.length && this.file.fetchReferenceSequenceCallback) {\n const sliceHeader = await this.getHeader()\n if (\n isMappedSliceHeader(sliceHeader.parsedContent) &&\n (sliceHeader.parsedContent.refSeqId >= 0 || // single-ref slice\n sliceHeader.parsedContent.refSeqId === -2) // multi-ref slice\n ) {\n const singleRefId =\n sliceHeader.parsedContent.refSeqId >= 0\n ? sliceHeader.parsedContent.refSeqId\n : undefined\n const compressionScheme = await this.container.getCompressionScheme()\n if (compressionScheme === undefined) {\n throw new Error('compression scheme undefined')\n }\n const refRegions: Record<\n string,\n { id: number; start: number; end: number; seq: string | null }\n > = {}\n\n // iterate over the records to find the spans of the reference\n // sequences we need to fetch\n for (const record of records) {\n const seqId =\n singleRefId !== undefined ? singleRefId : record.sequenceId\n let refRegion = refRegions[seqId]\n if (!refRegion) {\n refRegion = {\n id: seqId,\n start: record.alignmentStart,\n end: Number.NEGATIVE_INFINITY,\n seq: null,\n }\n refRegions[seqId] = refRegion\n }\n\n const end =\n record.alignmentStart +\n (record.lengthOnRef || record.readLength) -\n 1\n if (end > refRegion.end) {\n refRegion.end = end\n }\n if (record.alignmentStart < refRegion.start) {\n refRegion.start = record.alignmentStart\n }\n }\n\n // fetch the `seq` for all of the ref regions\n await Promise.all(\n Object.values(refRegions).map(async refRegion => {\n if (\n refRegion.id !== -1 &&\n refRegion.start <= refRegion.end &&\n this.file.fetchReferenceSequenceCallback\n ) {\n refRegion.seq = await this.file.fetchReferenceSequenceCallback(\n refRegion.id,\n refRegion.start,\n refRegion.end,\n )\n }\n }),\n )\n\n // now decorate all the records with them\n for (const record of records) {\n const seqId =\n singleRefId !== undefined ? singleRefId : record.sequenceId\n const refRegion = refRegions[seqId]\n if (refRegion?.seq) {\n const seq = refRegion.seq\n record.addReferenceSequence(\n { ...refRegion, seq },\n compressionScheme,\n )\n }\n }\n }\n }\n\n return records\n }\n}\n\n// memoize several methods in the class for performance\n'getHeader getBlocks _getBlocksContentIdIndex'.split(' ').forEach(method => {\n tinyMemoize(CramSlice, method)\n})\n","import CramSlice from '../slice'\nimport { CramFileBlock } from '../file'\nimport { DataType } from './dataSeriesTypes'\n\nexport interface DataTypeMapping {\n byte: number\n int: number\n long: number\n byteArray: Uint8Array\n}\n\nexport interface Cursor {\n bitPosition: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7\n bytePosition: number\n}\n\nexport interface Cursors {\n lastAlignmentStart: number\n coreBlock: Cursor\n externalBlocks: {\n map: Map<any, any>\n getCursor: (contentId: number) => Cursor\n }\n}\n\n// codec base class\nexport default abstract class CramCodec<\n TResult extends DataType = DataType,\n TParameters = unknown,\n> {\n public parameters: TParameters\n public dataType: DataType\n\n constructor(parameters: TParameters, dataType: TResult) {\n this.parameters = parameters\n this.dataType = dataType\n }\n\n abstract decode(\n slice: CramSlice,\n coreDataBlock: CramFileBlock,\n blocksByContentId: Record<number, CramFileBlock>,\n cursors: Cursors,\n ): DataTypeMapping[TResult]\n}\n","import CramCodec, { Cursors } from './_base'\nimport { ByteArrayLengthEncoding, CramEncoding } from '../encoding'\nimport CramSlice from '../slice'\nimport { CramFileBlock } from '../file'\nimport { DataType } from './dataSeriesTypes'\nimport { tinyMemoize } from '../util'\n\ntype CramCodecFactory = <TData extends DataType = DataType>(\n encodingData: CramEncoding,\n dataType: TData | 'ignore',\n) => CramCodec<TData>\n\nexport default class ByteArrayStopCodec extends CramCodec<\n 'byteArray',\n ByteArrayLengthEncoding['parameters']\n> {\n private instantiateCodec: CramCodecFactory\n\n constructor(\n parameters: ByteArrayLengthEncoding['parameters'],\n dataType: 'byteArray',\n instantiateCodec: CramCodecFactory,\n ) {\n super(parameters, dataType)\n this.instantiateCodec = instantiateCodec\n }\n\n decode(\n slice: CramSlice,\n coreDataBlock: CramFileBlock,\n blocksByContentId: Record<number, CramFileBlock>,\n cursors: Cursors,\n ) {\n const lengthCodec = this._getLengthCodec()\n const arrayLength = lengthCodec.decode(\n slice,\n coreDataBlock,\n blocksByContentId,\n cursors,\n )\n\n const dataCodec = this._getDataCodec()\n const data = new Uint8Array(arrayLength)\n for (let i = 0; i < arrayLength; i += 1) {\n data[i] = dataCodec.decode(\n slice,\n coreDataBlock,\n blocksByContentId,\n cursors,\n )\n }\n\n return data\n }\n\n // memoize\n _getLengthCodec() {\n const encodingParams = this.parameters.lengthsEncoding\n return this.instantiateCodec(encodingParams, 'int')\n }\n\n // memoize\n _getDataCodec() {\n const encodingParams = this.parameters.valuesEncoding\n return this.instantiateCodec(encodingParams, 'byte')\n }\n}\n\n'_getLengthCodec _getDataCodec'.split(' ').forEach(method => {\n tinyMemoize(ByteArrayStopCodec, method)\n})\n","import { CramUnimplementedError } from '../../errors'\n\nimport HuffmanIntCodec from './huffman'\nimport ExternalCodec from './external'\nimport ByteArrayStopCodec from './byteArrayStop'\nimport ByteArrayLengthCodec from './byteArrayLength'\nimport BetaCodec from './beta'\nimport GammaCodec from './gamma'\nimport SubexpCodec from './subexp'\nimport CramCodec from './_base'\nimport { CramEncoding } from '../encoding'\nimport { DataType } from './dataSeriesTypes'\n\nconst codecClasses = {\n 1: ExternalCodec,\n // 2: GolombCodec,\n 3: HuffmanIntCodec,\n 4: ByteArrayLengthCodec,\n 5: ByteArrayStopCodec,\n 6: BetaCodec,\n 7: SubexpCodec,\n // 8: GolombRiceCodec,\n 9: GammaCodec,\n}\n\nfunction getCodecClassWithId(id: number) {\n return (codecClasses as any)[id]\n}\n\nexport function instantiateCodec<TResult extends DataType = DataType>(\n encodingData: CramEncoding,\n dataType: DataType | 'ignore',\n): CramCodec<TResult> {\n const CodecClass = getCodecClassWithId(\n dataType === 'ignore' ? 0 : encodingData.codecId,\n )\n if (!CodecClass) {\n throw new CramUnimplementedError(\n `no codec implemented for codec ID ${encodingData.codecId}`,\n )\n }\n\n return new CodecClass(encodingData.parameters, dataType, instantiateCodec)\n}\n","import { CramMalformedError, CramUnimplementedError } from '../../errors'\nimport CramCodec, { Cursor, Cursors } from './_base'\nimport { parseItf8 } from '../util'\nimport CramSlice from '../slice'\nimport { CramFileBlock } from '../file'\nimport { CramBufferOverrunError } from './getBits'\nimport { ExternalCramEncoding } from '../encoding'\n\nexport default class ExternalCodec extends CramCodec<\n 'int' | 'byte',\n ExternalCramEncoding['parameters']\n> {\n private readonly _decodeData: (\n contentBlock: CramFileBlock,\n cursor: Cursor,\n ) => number\n\n constructor(\n parameters: ExternalCramEncoding['parameters'],\n dataType: 'int' | 'byte',\n ) {\n super(parameters, dataType)\n if (this.dataType === 'int') {\n this._decodeData = this._decodeInt\n } else if (this.dataType === 'byte') {\n this._decodeData = this._decodeByte\n } else {\n throw new CramUnimplementedError(\n `${this.dataType} decoding not yet implemented by EXTERNAL codec`,\n )\n }\n }\n\n decode(\n slice: CramSlice,\n coreDataBlock: CramFileBlock,\n blocksByContentId: Record<number, CramFileBlock>,\n cursors: Cursors,\n ) {\n const { blockContentId } = this.parameters\n const contentBlock = blocksByContentId[blockContentId]\n if (!contentBlock) {\n throw new CramMalformedError(\n `no block found with content ID ${blockContentId}}`,\n )\n }\n const cursor = cursors.externalBlocks.getCursor(blockContentId)\n return this._decodeData(contentBlock, cursor)\n }\n\n _decodeInt(contentBlock: CramFileBlock, cursor: Cursor) {\n const [result, bytesRead] = parseItf8(\n contentBlock.content,\n cursor.bytePosition,\n )\n cursor.bytePosition = cursor.bytePosition + bytesRead\n return result\n }\n\n _decodeByte(contentBlock: CramFileBlock, cursor: Cursor) {\n if (cursor.bytePosition >= contentBlock.content.length) {\n throw new CramBufferOverrunError(\n 'attempted to read beyond end of block. this file seems truncated.',\n )\n }\n return contentBlock.content[cursor.bytePosition++]!\n }\n}\n","import { CramMalformedError } from '../../errors'\nimport CramCodec, { Cursor, Cursors } from './_base'\nimport { getBits } from './getBits'\nimport { HuffmanEncoding } from '../encoding'\n\nimport CramSlice from '../slice'\nimport { CramFileBlock } from '../file'\n\nfunction numberOfSetBits(ii: number) {\n let i = (ii - (ii >> 1)) & 0x55555555\n i = (i & 0x33333333) + ((i >> 2) & 0x33333333)\n return (((i + (i >> 4)) & 0x0f0f0f0f) * 0x01010101) >> 24\n}\n\ninterface Code {\n bitLength: number\n value: number\n bitCode: number\n}\n\nexport default class HuffmanIntCodec extends CramCodec<\n 'byte' | 'int',\n HuffmanEncoding['parameters']\n> {\n private codes: Record<number, Code> = {}\n private codeBook: Record<number, number[]> = {}\n private sortedCodes: Code[] = []\n private sortedValuesByBitCode: number[] = []\n private sortedBitCodes: number[] = []\n private sortedBitLengthsByBitCode: number[] = []\n private bitCodeToValue: number[] = []\n\n constructor(\n parameters: HuffmanEncoding['parameters'],\n dataType: 'byte' | 'int',\n ) {\n super(parameters, dataType)\n if (!['byte', 'int'].includes(this.dataType)) {\n throw new TypeError(\n `${this.dataType} decoding not yet implemented by HUFFMAN_INT codec`,\n )\n }\n\n this.buildCodeBook()\n this.buildCodes()\n this.buildCaches()\n\n // if this is a degenerate zero-length huffman code, special-case the\n // decoding\n if (this.sortedCodes[0]!.bitLength === 0) {\n this._decode = this._decodeZeroLengthCode\n }\n }\n\n buildCodeBook() {\n // parse the parameters together into a `codes` data structure\n let codes = new Array<{ symbol: number; bitLength: number }>(\n this.parameters.numCodes,\n )\n for (let i = 0; i < this.parameters.numCodes; i++) {\n codes[i] = {\n symbol: this.parameters.symbols[i]!,\n bitLength: this.parameters.bitLengths[i]!,\n }\n }\n // sort the codes by bit length and symbol value\n codes = codes.sort(\n (a, b) => a.bitLength - b.bitLength || a.symbol - b.symbol,\n )\n\n this.codeBook = {}\n codes.forEach(code => {\n if (!this.codeBook[code.bitLength]) {\n this.codeBook[code.bitLength] = []\n }\n this.codeBook[code.bitLength]!.push(code.symbol)\n })\n }\n\n buildCodes() {\n this.codes = {} /* new TreeMap<Integer, HuffmanBitCode>(); */\n let codeLength = 0\n let codeValue = -1\n Object.entries(this.codeBook).forEach(([bitLength, symbols]) => {\n const bitLengthInt = Number.parseInt(bitLength, 10)\n symbols.forEach(symbol => {\n const code = {\n bitLength: bitLengthInt,\n value: symbol,\n bitCode: 0,\n }\n codeValue = codeValue + 1\n const delta = bitLengthInt - codeLength // new length?\n codeValue = codeValue << delta // pad with 0's\n code.bitCode = codeValue // calculated: huffman code\n codeLength = codeLength + delta // adjust current code length\n\n if (numberOfSetBits(codeValue) > bitLengthInt) {\n throw new CramMalformedError('Symbol out of range')\n }\n\n this.codes[symbol] = code\n })\n })\n }\n\n buildCaches() {\n this.sortedCodes = Object.values(this.codes).sort(\n (a, b) => a.bitLength - b.bitLength || a.bitCode - b.bitCode,\n )\n\n this.sortedValuesByBitCode = this.sortedCodes.map(c => c.value)\n this.sortedBitCodes = this.sortedCodes.map(c => c.bitCode)\n this.sortedBitLengthsByBitCode = this.sortedCodes.map(c => c.bitLength)\n const maxBitCode = Math.max(...this.sortedBitCodes)\n\n this.bitCodeToValue = new Array(maxBitCode + 1).fill(-1)\n for (let i = 0; i < this.sortedBitCodes.length; i += 1) {\n this.bitCodeToValue[this.sortedCodes[i]!.bitCode] = i\n }\n }\n\n decode(\n slice: CramSlice,\n coreDataBlock: CramFileBlock,\n blocksByContentId: Record<number, CramFileBlock>,\n cursors: Cursors,\n ) {\n return this._decode(slice, coreDataBlock, cursors.coreBlock)\n }\n\n // _decodeNull() {\n // return -1\n // }\n\n // the special case for zero-length codes\n _decodeZeroLengthCode() {\n return this.sortedCodes[0]!.value\n }\n\n _decode(slice: CramSlice, coreDataBlock: CramFileBlock, coreCursor: Cursor) {\n const input = coreDataBlock.content\n\n let prevLen = 0\n let bits = 0\n for (let i = 0; i < this.sortedCodes.length; i += 1) {\n const length = this.sortedCodes[i]!.bitLength\n bits <<= length - prevLen\n bits |= getBits(input, coreCursor, length - prevLen)\n prevLen = length\n {\n const index = this.bitCodeToValue[bits]!\n if (index > -1 && this.sortedBitLengthsByBitCode[index] === length) {\n return this.sortedValuesByBitCode[index]!\n }\n\n for (\n let j = i;\n this.sortedCodes[j + 1]!.bitLength === length &&\n j < this.sortedCodes.length;\n j += 1\n ) {\n i += 1\n }\n }\n }\n throw new CramMalformedError('Huffman symbol not found.')\n }\n}\n","import { CramMalformedError } from '../../errors'\n\nimport CramCodec, { Cursor, Cursors } from './_base'\nimport CramSlice from '../slice'\nimport { CramFileBlock } from '../file'\nimport { ByteArrayStopCramEncoding } from '../encoding'\nimport { CramBufferOverrunError } from './getBits'\n\nexport default class ByteArrayStopCodec extends CramCodec<\n 'byteArray',\n ByteArrayStopCramEncoding['parameters']\n> {\n decode(\n slice: CramSlice,\n coreDataBlock: CramFileBlock,\n blocksByContentId: Record<number, CramFileBlock>,\n cursors: Cursors,\n ) {\n const { blockContentId } = this.parameters\n const contentBlock = blocksByContentId[blockContentId]\n if (!contentBlock) {\n throw new CramMalformedError(\n `no block found with content ID ${blockContentId}`,\n )\n }\n const cursor = cursors.externalBlocks.getCursor(blockContentId)\n return this._decodeByteArray(contentBlock, cursor)\n }\n\n _decodeByteArray(contentBlock: CramFileBlock, cursor: Cursor) {\n const dataBuffer = contentBlock.content\n const { stopByte } = this.parameters\n // scan to the next stop byte\n const startPosition = cursor.bytePosition\n let stopPosition = cursor.bytePosition\n while (\n dataBuffer[stopPosition] !== stopByte &&\n stopPosition < dataBuffer.length\n ) {\n if (stopPosition === dataBuffer.length) {\n throw new CramBufferOverrunError(\n 'byteArrayStop reading beyond length of data buffer?',\n )\n }\n stopPosition = stopPosition + 1\n }\n cursor.bytePosition = stopPosition + 1\n return dataBuffer.subarray(startPosition, stopPosition)\n }\n}\n","import { CramUnimplementedError } from '../../errors'\nimport CramCodec, { Cursors } from './_base'\nimport { getBits } from './getBits'\nimport CramSlice from '../slice'\nimport { CramFileBlock } from '../file'\nimport { BetaEncoding } from '../encoding'\n\nexport default class BetaCodec extends CramCodec<\n 'int',\n BetaEncoding['parameters']\n> {\n constructor(parameters: BetaEncoding['parameters'], dataType: 'int') {\n super(parameters, dataType)\n if (this.dataType !== 'int') {\n throw new CramUnimplementedError(\n `${this.dataType} decoding not yet implemented by BETA codec`,\n )\n }\n }\n\n decode(\n slice: CramSlice,\n coreDataBlock: CramFileBlock,\n blocksByContentId: Record<number, CramFileBlock>,\n cursors: Cursors,\n ) {\n const fromBits = getBits(\n coreDataBlock.content,\n cursors.coreBlock,\n this.parameters.length,\n )\n return fromBits - this.parameters.offset\n }\n}\n","import { CramUnimplementedError } from '../../errors'\nimport CramCodec, { Cursors } from './_base'\nimport { getBits } from './getBits'\nimport CramSlice from '../slice'\nimport { CramFileBlock } from '../file'\nimport { SubexpEncoding } from '../encoding'\n\nexport default class SubexpCodec extends CramCodec<\n 'int',\n SubexpEncoding['parameters']\n> {\n constructor(parameters: SubexpEncoding['parameters'], dataType: 'int') {\n super(parameters, dataType)\n if (this.dataType !== 'int') {\n throw new CramUnimplementedError(\n `${this.dataType} decoding not yet implemented by SUBEXP codec`,\n )\n }\n }\n\n decode(\n slice: CramSlice,\n coreDataBlock: CramFileBlock,\n blocksByContentId: Record<number, CramFileBlock>,\n cursors: Cursors,\n ) {\n let numLeadingOnes = 0\n while (getBits(coreDataBlock.content, cursors.coreBlock, 1)) {\n numLeadingOnes = numLeadingOnes + 1\n }\n\n let b: number\n let n: number\n if (numLeadingOnes === 0) {\n b = this.parameters.K\n n = getBits(coreDataBlock.content, cursors.coreBlock, b)\n } else {\n b = numLeadingOnes + this.parameters.K - 1\n const bits = getBits(coreDataBlock.content, cursors.coreBlock, b)\n n = (1 << b) | bits\n }\n\n return n - this.parameters.offset\n }\n}\n","import { CramUnimplementedError } from '../../errors'\nimport CramCodec, { Cursors } from './_base'\nimport { getBits } from './getBits'\nimport { GammaEncoding } from '../encoding'\nimport CramSlice from '../slice'\nimport { CramFileBlock } from '../file'\n\nexport default class GammaCodec extends CramCodec<\n 'int',\n GammaEncoding['parameters']\n> {\n constructor(parameters: GammaEncoding['parameters'], dataType: 'int') {\n super(parameters, dataType)\n if (this.dataType !== 'int') {\n throw new CramUnimplementedError(\n `${this.dataType} decoding not yet implemented by GAMMA codec`,\n )\n }\n }\n\n decode(\n slice: CramSlice,\n coreDataBlock: CramFileBlock,\n blocksByContentId: Record<number, CramFileBlock>,\n cursors: Cursors,\n ) {\n let length = 1\n\n while (getBits(coreDataBlock.content, cursors.coreBlock, 1) === 0) {\n length = length + 1\n }\n\n const readBits = getBits(\n coreDataBlock.content,\n cursors.coreBlock,\n length - 1,\n )\n\n const value = readBits | (1 << (length - 1))\n return value - this.parameters.offset\n }\n}\n","import { instantiateCodec } from '../codecs'\nimport CramCodec from '../codecs/_base'\nimport { CramCompressionHeader } from '../sectionParsers'\nimport { CramEncoding } from '../encoding'\nimport { CramMalformedError } from '../../errors'\nimport {\n DataSeriesEncodingKey,\n DataSeriesEncodingMap,\n} from '../codecs/dataSeriesTypes'\n\n// the hardcoded data type to be decoded for each core\n// data field\nconst dataSeriesTypes = {\n BF: 'int',\n CF: 'int',\n RI: 'int',\n RL: 'int',\n AP: 'int',\n RG: 'int',\n MF: 'int',\n NS: 'int',\n NP: 'int',\n TS: 'int',\n NF: 'int',\n TC: 'byte',\n TN: 'int',\n FN: 'int',\n FC: 'byte',\n FP: 'int',\n BS: 'byte',\n IN: 'byteArray',\n SC: 'byteArray',\n DL: 'int',\n BA: 'byte',\n BB: 'byteArray',\n RS: 'int',\n PD: 'int',\n HC: 'int',\n MQ: 'int',\n RN: 'byteArray',\n QS: 'byte',\n QQ: 'byteArray',\n TL: 'int',\n // TM: 'ignore',\n // TV: 'ignore',\n} as const\n\nexport type DataSeriesTypes = typeof dataSeriesTypes\n\nfunction parseSubstitutionMatrix(byteArray: number[]) {\n const matrix: string[][] = new Array(5)\n for (let i = 0; i < 5; i += 1) {\n matrix[i] = new Array(4)\n }\n\n matrix[0]![(byteArray[0]! >> 6) & 3] = 'C'\n matrix[0]![(byteArray[0]! >> 4) & 3] = 'G'\n matrix[0]![(byteArray[0]! >> 2) & 3] = 'T'\n matrix[0]![(byteArray[0]! >> 0) & 3] = 'N'\n\n matrix[1]![(byteArray[1]! >> 6) & 3] = 'A'\n matrix[1]![(byteArray[1]! >> 4) & 3] = 'G'\n matrix[1]![(byteArray[1]! >> 2) & 3] = 'T'\n matrix[1]![(byteArray[1]! >> 0) & 3] = 'N'\n\n matrix[2]![(byteArray[2]! >> 6) & 3] = 'A'\n matrix[2]![(byteArray[2]! >> 4) & 3] = 'C'\n matrix[2]![(byteArray[2]! >> 2) & 3] = 'T'\n matrix[2]![(byteArray[2]! >> 0) & 3] = 'N'\n\n matrix[3]![(byteArray[3]! >> 6) & 3] = 'A'\n matrix[3]![(byteArray[3]! >> 4) & 3] = 'C'\n matrix[3]![(byteArray[3]! >> 2) & 3] = 'G'\n matrix[3]![(byteArray[3]! >> 0) & 3] = 'N'\n\n matrix[4]![(byteArray[4]! >> 6) & 3] = 'A'\n matrix[4]![(byteArray[4]! >> 4) & 3] = 'C'\n matrix[4]![(byteArray[4]! >> 2) & 3] = 'G'\n matrix[4]![(byteArray[4]! >> 0) & 3] = 'T'\n\n return matrix\n}\n\ntype DataSeriesCache = {\n [K in DataSeriesEncodingKey]?: CramCodec<DataSeriesTypes[K]>\n}\n\nexport default class CramContainerCompressionScheme {\n public readNamesIncluded: boolean\n public APdelta: boolean\n public referenceRequired: boolean\n public tagIdsDictionary: Record<number, string[]>\n public substitutionMatrix: string[][]\n public dataSeriesCodecCache: DataSeriesCache = {}\n public tagCodecCache: Record<string, CramCodec> = {}\n public tagEncoding: Record<string, CramEncoding> = {}\n public dataSeriesEncoding: DataSeriesEncodingMap\n\n constructor(content: CramCompressionHeader) {\n // interpret some of the preservation map tags for convenient use\n this.readNamesIncluded = content.preservation.RN\n this.APdelta = content.preservation.AP\n this.referenceRequired = !!content.preservation.RR\n this.tagIdsDictionary = content.preservation.TD\n this.substitutionMatrix = parseSubstitutionMatrix(content.preservation.SM)\n this.dataSeriesEncoding = content.dataSeriesEncoding\n this.tagEncoding = content.tagEncoding\n }\n\n /**\n * @param {string} tagName three-character tag name\n * @private\n */\n getCodecForTag(tagName: string): CramCodec {\n const test = this.tagCodecCache[tagName]\n if (!test) {\n const encodingData = this.tagEncoding[tagName]\n if (!encodingData) {\n throw new Error('Error, no tag encoding')\n }\n const ret = instantiateCodec(\n encodingData,\n 'byteArray', // all tags are byte array data\n )\n this.tagCodecCache[tagName] = ret\n return ret\n } else {\n return test\n }\n }\n\n /**\n *\n * @param {number} tagListId ID of the tag list to fetch from the tag dictionary\n * @private\n */\n getTagNames(tagListId: number) {\n return this.tagIdsDictionary[tagListId]\n }\n\n getCodecForDataSeries<TDataSeries extends DataSeriesEncodingKey>(\n dataSeriesName: TDataSeries,\n ): CramCodec<DataSeriesTypes[TDataSeries]> | undefined {\n let r: CramCodec<DataSeriesTypes[TDataSeries]> | undefined =\n this.dataSeriesCodecCache[dataSeriesName]\n if (r === undefined) {\n const encodingData = this.dataSeriesEncoding[dataSeriesName]\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n if (encodingData) {\n const dataType = dataSeriesTypes[dataSeriesName]\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n if (!dataType) {\n throw new CramMalformedError(\n `data series name ${dataSeriesName} not defined in file compression header`,\n )\n }\n r = instantiateCodec(encodingData, dataType)\n // didn't find a way to make TS understand this\n this.dataSeriesCodecCache[dataSeriesName] = r as CramCodec<any>\n }\n }\n return r\n }\n\n toJSON() {\n const data: any = {}\n Object.keys(this).forEach(k => {\n if (k.endsWith('Cache')) {\n return\n }\n data[k] = (this as any)[k]\n })\n return data\n }\n}\n","import { Buffer } from 'buffer'\nimport { CramMalformedError } from '../../errors'\n// locals\nimport { itf8Size, parseItem, tinyMemoize } from '../util'\nimport CramSlice from '../slice'\nimport CramContainerCompressionScheme from './compressionScheme'\nimport CramFile from '../file'\nimport { getSectionParsers } from '../sectionParsers'\n\nexport default class CramContainer {\n constructor(\n public file: CramFile,\n public filePosition: number,\n ) {}\n\n getHeader() {\n return this._readContainerHeader(this.filePosition)\n }\n\n async getCompressionHeaderBlock() {\n const containerHeader = await this.getHeader()\n\n // if there are no records in the container, there will be no compression\n // header\n if (!containerHeader?.numRecords) {\n return null\n }\n const { majorVersion } = await this.file.getDefinition()\n const sectionParsers = getSectionParsers(majorVersion)\n\n const block = await this.getFirstBlock()\n if (block === undefined) {\n return undefined\n }\n if (block.contentType !== 'COMPRESSION_HEADER') {\n throw new CramMalformedError(\n `invalid content type ${block.contentType} in compression header block`,\n )\n }\n\n const content = parseItem(\n block.content,\n sectionParsers.cramCompressionHeader.parser,\n 0,\n block.contentPosition,\n )\n return {\n ...block,\n parsedContent: content,\n }\n }\n\n async getFirstBlock() {\n const containerHeader = await this.getHeader()\n if (!containerHeader) {\n return undefined\n }\n return this.file.readBlock(containerHeader._endPosition)\n }\n\n // parses the compression header data into a CramContainerCompressionScheme\n // object\n async getCompressionScheme() {\n const header = await this.getCompressionHeaderBlock()\n if (!header) {\n return undefined\n }\n\n return new CramContainerCompressionScheme(header.parsedContent)\n }\n\n getSlice(slicePosition: number, sliceSize: number) {\n // note: slicePosition is relative to the end of the container header\n // TODO: perhaps we should cache slices?\n return new CramSlice(this, slicePosition, sliceSize)\n }\n\n async _readContainerHeader(position: number) {\n const { majorVersion } = await this.file.getDefinition()\n const sectionParsers = getSectionParsers(majorVersion)\n const { cramContainerHeader1, cramContainerHeader2 } = sectionParsers\n const { size: fileSize } = await this.file.stat()\n\n if (position >= fileSize) {\n console.warn(`pos:${position}>=fileSize:${fileSize} in cram container`)\n return undefined\n }\n\n // parse the container header. do it in 2 pieces because you cannot tell\n // how much to buffer until you read numLandmarks\n const bytes1 = Buffer.allocUnsafe(cramContainerHeader1.maxLength)\n await this.file.read(bytes1, 0, cramContainerHeader1.maxLength, position)\n const header1 = parseItem(bytes1, cramContainerHeader1.parser)\n const numLandmarksSize = itf8Size(header1.numLandmarks)\n if (position + header1.length >= fileSize) {\n // header indicates container goes beyond fileSize\n console.warn(\n `container at ${position} is beyond fileSize:${fileSize}, skipping`,\n )\n return undefined\n }\n const bytes2 = Buffer.allocUnsafe(\n cramContainerHeader2.maxLength(header1.numLandmarks),\n )\n await this.file.read(\n bytes2,\n 0,\n cramContainerHeader2.maxLength(header1.numLandmarks),\n position + header1._size - numLandmarksSize,\n )\n const header2 = parseItem(bytes2, cramContainerHeader2.parser)\n\n if (this.file.validateChecksums && header2.crc32 !== undefined) {\n await this.file.checkCrc32(\n position,\n header1._size + header2._size - numLandmarksSize - 4,\n header2.crc32,\n `container header beginning at position ${position}`,\n )\n }\n\n const completeHeader = Object.assign(header1, header2, {\n _size: header1._size + header2._size - numLandmarksSize,\n _endPosition: header1._size + header2._size - numLandmarksSize + position,\n })\n\n return completeHeader\n }\n}\n\n'getHeader getCompressionHeaderBlock getCompressionScheme'\n .split(' ')\n .forEach(method => {\n tinyMemoize(CramContainer, method)\n })\n","import { Filehandle } from '../cramFile/filehandle'\nimport { LocalFile, RemoteFile } from 'generic-filehandle'\n\nfunction open(\n maybeUrl?: string,\n maybePath?: string,\n maybeFilehandle?: Filehandle,\n): Filehandle {\n if (maybeFilehandle) {\n return maybeFilehandle\n }\n if (maybeUrl) {\n return new RemoteFile(maybeUrl)\n }\n if (maybePath) {\n return new LocalFile(maybePath)\n }\n throw new Error('no url, path, or filehandle provided, cannot open')\n}\n\nexport { open }\n\nexport { LocalFile, RemoteFile } from 'generic-filehandle'\n","export function parseHeaderText(text: string) {\n const lines = text.split(/\\r?\\n/)\n const data: {\n tag: string\n data: {\n tag: string\n value: string\n }[]\n }[] = []\n for (const line of lines) {\n const [tag, ...fields] = line.split(/\\t/)\n if (tag) {\n data.push({\n tag: tag.slice(1),\n data: fields.map(f => {\n const r = f.indexOf(':')\n return r !== -1\n ? {\n tag: f.slice(0, r),\n value: f.slice(r + 1),\n }\n : // @CO lines are not comma separated.\n // See \"samtools view -H c2\\#pad.3.0.cram\"\n // so, just store value tag and value itself\n {\n tag: f,\n value: '',\n }\n }),\n })\n }\n }\n return data\n}\n","import { Buffer } from 'buffer'\nimport crc32 from 'crc/crc32'\nimport QuickLRU from 'quick-lru'\nimport htscodecs from '@jkbonfield/htscodecs'\nimport bzip2 from 'bzip2'\nimport { XzReadableStream } from 'xz-decompress'\nimport { CramMalformedError, CramUnimplementedError } from '../errors'\n// locals\nimport { unzip } from '../unzip'\nimport ransuncompress from '../rans'\nimport {\n BlockHeader,\n CompressionMethod,\n cramFileDefinition,\n getSectionParsers,\n} from './sectionParsers'\nimport CramContainer from './container'\nimport CramRecord from './record'\nimport { open } from '../io'\nimport { parseItem, tinyMemoize } from './util'\nimport { parseHeaderText } from '../sam'\nimport { Filehandle } from './filehandle'\n\nfunction bufferToStream(buf: Buffer) {\n return new ReadableStream({\n start(controller) {\n controller.enqueue(buf)\n controller.close()\n },\n })\n}\n\n// source: https://abdulapopoola.com/2019/01/20/check-endianness-with-javascript/\nfunction getEndianness() {\n const uInt32 = new Uint32Array([0x11223344])\n const uInt8 = new Uint8Array(uInt32.buffer)\n\n if (uInt8[0] === 0x44) {\n return 0 // little-endian\n } else if (uInt8[0] === 0x11) {\n return 1 // big-endian\n } else {\n return 2 // mixed-endian?\n }\n}\n\nexport interface CramFileSource {\n filehandle?: Filehandle\n url?: string\n path?: string\n}\n\nexport type SeqFetch = (\n seqId: number,\n start: number,\n end: number,\n) => Promise<string>\n\nexport type CramFileArgs = CramFileSource & {\n checkSequenceMD5?: boolean\n cacheSize?: number\n seqFetch?: SeqFetch\n}\n\nexport type CramFileBlock = BlockHeader & {\n _endPosition: number\n contentPosition: number\n _size: number\n content: Buffer\n crc32?: number\n}\n\nexport default class CramFile {\n private file: Filehandle\n public validateChecksums: boolean\n public fetchReferenceSequenceCallback?: SeqFetch\n public options: {\n checkSequenceMD5?: boolean\n cacheSize: number\n }\n public featureCache: QuickLRU<string, Promise<CramRecord[]>>\n private header: string | undefined\n\n constructor(args: CramFileArgs) {\n this.file = open(args.url, args.path, args.filehandle)\n this.validateChecksums = true\n this.fetchReferenceSequenceCallback = args.seqFetch\n this.options = {\n checkSequenceMD5: args.checkSequenceMD5,\n cacheSize: args.cacheSize ?? 20000,\n }\n\n // cache of features in a slice, keyed by the slice offset. caches all of\n // the features in a slice, or none. the cache is actually used by the\n // slice object, it's just kept here at the level of the file\n this.featureCache = new QuickLRU({\n maxSize: this.options.cacheSize,\n })\n if (getEndianness() > 0) {\n throw new Error('Detected big-endian machine, may be unable to run')\n }\n }\n\n // can just read this object like a filehandle\n read(buffer: Buffer, offset: number, length: number, position: number) {\n return this.file.read(buffer, offset, length, position)\n }\n\n // can just stat this object like a filehandle\n stat() {\n return this.file.stat()\n }\n\n // memoized\n async getDefinition() {\n const { maxLength, parser } = cramFileDefinition()\n const headbytes = Buffer.allocUnsafe(maxLength)\n await this.file.read(headbytes, 0, maxLength, 0)\n const definition = parser(headbytes).value\n if (definition.majorVersion !== 2 && definition.majorVersion !== 3) {\n throw new CramUnimplementedError(\n `CRAM version ${definition.majorVersion} not supported`,\n )\n }\n return definition\n }\n\n // memoize\n async getSamHeader() {\n const firstContainer = await this.getContainerById(0)\n if (!firstContainer) {\n throw new CramMalformedError('file contains no containers')\n }\n\n const firstBlock = await firstContainer.getFirstBlock()\n if (firstBlock === undefined) {\n return parseHeaderText('')\n }\n const content = firstBlock.content\n // find the end of the trailing zeros in the header text\n const headerLength = content.readInt32LE(0)\n const textStart = 4\n // let textEnd = content.length - 1\n // while (textEnd >= textStart && !content[textEnd]) textEnd -= 1\n // trim off the trailing zeros\n const text = content.toString('utf8', textStart, textStart + headerLength)\n this.header = text\n return parseHeaderText(text)\n }\n\n async getHeaderText() {\n await this.getSamHeader()\n return this.header\n }\n\n async getContainerById(containerNumber: number) {\n const { majorVersion } = await this.getDefinition()\n const sectionParsers = getSectionParsers(majorVersion)\n let position = sectionParsers.cramFileDefinition.maxLength\n const { size: fileSize } = await this.file.stat()\n const { cramContainerHeader1 } = sectionParsers\n\n // skip with a series of reads to the proper container\n let currentContainer: CramContainer | undefined\n for (let i = 0; i <= containerNumber; i++) {\n // if we are about to go off the end of the file\n // and have not found that container, it does not exist\n if (position + cramContainerHeader1.maxLength + 8 >= fileSize) {\n return undefined\n }\n\n currentContainer = this.getContainerAtPosition(position)\n const currentHeader = await currentContainer.getHeader()\n if (!currentHeader) {\n throw new CramMalformedError(\n `container ${containerNumber} not found in file`,\n )\n }\n // if this is the first container, read all the blocks in the container\n // to determine its length, because we cannot trust the container\n // header's given length due to a bug somewhere in htslib\n if (i === 0) {\n position = currentHeader._endPosition\n for (let j = 0; j < currentHeader.numBlocks; j++) {\n const block = await this.readBlock(position)\n if (block === undefined) {\n return undefined\n }\n position = block._endPosition\n }\n } else {\n // otherwise, just traverse to the next container using the container's length\n position += currentHeader._size + currentHeader.length\n }\n }\n\n return currentContainer\n }\n\n async checkCrc32(\n position: number,\n length: number,\n recordedCrc32: number,\n description: string,\n ) {\n const b = Buffer.allocUnsafe(length)\n await this.file.read(b, 0, length, position)\n const calculatedCrc32 = crc32.unsigned(b)\n if (calculatedCrc32 !== recordedCrc32) {\n throw new CramMalformedError(\n `crc mismatch in ${description}: recorded CRC32 = ${recordedCrc32}, but calculated CRC32 = ${calculatedCrc32}`,\n )\n }\n }\n\n /**\n * @returns {Promise[number]} the number of containers in the file\n */\n async containerCount(): Promise<number | undefined> {\n const { majorVersion } = await this.getDefinition()\n const sectionParsers = getSectionParsers(majorVersion)\n const { size: fileSize } = await this.file.stat()\n const { cramContainerHeader1 } = sectionParsers\n\n let containerCount = 0\n let position = sectionParsers.cramFileDefinition.maxLength\n while (position + cramContainerHeader1.maxLength + 8 < fileSize) {\n const currentHeader =\n await this.getContainerAtPosition(position).getHeader()\n if (!currentHeader) {\n break\n }\n // if this is the first container, read all the blocks in the\n // container, because we cannot trust the container\n // header's given length due to a bug somewhere in htslib\n if (containerCount === 0) {\n position = currentHeader._endPosition\n for (let j = 0; j < currentHeader.numBlocks; j++) {\n const block = await this.readBlock(position)\n if (block === undefined) {\n return undefined\n }\n position = block._endPosition\n }\n } else {\n // otherwise, just traverse to the next container using the container's length\n position += currentHeader._size + currentHeader.length\n }\n containerCount += 1\n }\n\n return containerCount\n }\n\n getContainerAtPosition(position: number) {\n return new CramContainer(this, position)\n }\n\n async readBlockHeader(position: number) {\n const { majorVersion } = await this.getDefinition()\n const sectionParsers = getSectionParsers(majorVersion)\n const { cramBlockHeader } = sectionParsers\n const { size: fileSize } = await this.file.stat()\n\n if (position + cramBlockHeader.maxLength >= fileSize) {\n return undefined\n }\n\n const buffer = Buffer.allocUnsafe(cramBlockHeader.maxLength)\n await this.file.read(buffer, 0, cramBlockHeader.maxLength, position)\n return parseItem(buffer, cramBlockHeader.parser, 0, position)\n }\n\n async _parseSection<T>(\n section: {\n maxLength: number\n parser: (buffer: Buffer, offset: number) => { offset: number; value: T }\n },\n position: number,\n size = section.maxLength,\n preReadBuffer?: Buffer,\n ) {\n let buffer: Buffer\n if (preReadBuffer) {\n buffer = preReadBuffer\n } else {\n const { size: fileSize } = await this.file.stat()\n if (position + size >= fileSize) {\n return undefined\n }\n buffer = Buffer.allocUnsafe(size)\n await this.file.read(buffer, 0, size, position)\n }\n const data = parseItem(buffer, section.parser, 0, position)\n if (data._size !== size) {\n throw new CramMalformedError(\n `section read error: requested size ${size} does not equal parsed size ${data._size}`,\n )\n }\n return data\n }\n\n async _uncompress(\n compressionMethod: CompressionMethod,\n inputBuffer: Buffer,\n outputBuffer: Buffer,\n ) {\n if (compressionMethod === 'gzip') {\n const result = unzip(inputBuffer)\n result.copy(outputBuffer)\n } else if (compressionMethod === 'bzip2') {\n const bits = bzip2.array(inputBuffer)\n let size = bzip2.header(bits)\n let j = 0\n let chunk: Uint8Array | -1\n do {\n chunk = bzip2.decompress(bits, size)\n if (chunk !== -1) {\n Buffer.from(chunk).copy(outputBuffer, j)\n j += chunk.length\n size -= chunk.length\n }\n } while (chunk !== -1)\n } else if (compressionMethod === 'lzma') {\n const decompressedResponse = new Response(\n new XzReadableStream(bufferToStream(inputBuffer)),\n )\n const ret = Buffer.from(await decompressedResponse.arrayBuffer())\n ret.copy(outputBuffer)\n } else if (compressionMethod === 'rans') {\n ransuncompress(inputBuffer, outputBuffer)\n // htscodecs r4x8 is slower, but compatible.\n // htscodecs.r4x8_uncompress(inputBuffer, outputBuffer);\n } else if (compressionMethod === 'rans4x16') {\n htscodecs.r4x16_uncompress(inputBuffer, outputBuffer)\n } else if (compressionMethod === 'arith') {\n htscodecs.arith_uncompress(inputBuffer, outputBuffer)\n } else if (compressionMethod === 'fqzcomp') {\n htscodecs.fqzcomp_uncompress(inputBuffer, outputBuffer)\n } else if (compressionMethod === 'tok3') {\n htscodecs.tok3_uncompress(inputBuffer, outputBuffer)\n } else {\n throw new CramUnimplementedError(\n `${compressionMethod} decompression not yet implemented`,\n )\n }\n }\n\n async readBlock(position: number) {\n const { majorVersion } = await this.getDefinition()\n const sectionParsers = getSectionParsers(majorVersion)\n const blockHeader = await this.readBlockHeader(position)\n if (blockHeader === undefined) {\n return undefined\n }\n const blockContentPosition = blockHeader._endPosition\n\n const uncompressedData = Buffer.allocUnsafe(blockHeader.uncompressedSize)\n\n const block: CramFileBlock = {\n ...blockHeader,\n _endPosition: blockContentPosition,\n contentPosition: blockContentPosition,\n content: uncompressedData,\n }\n\n if (blockHeader.compressionMethod !== 'raw') {\n const compressedData = Buffer.allocUnsafe(blockHeader.compressedSize)\n await this.read(\n compressedData,\n 0,\n blockHeader.compressedSize,\n blockContentPosition,\n )\n\n await this._uncompress(\n blockHeader.compressionMethod,\n compressedData,\n uncompressedData,\n )\n } else {\n await this.read(\n uncompressedData,\n 0,\n blockHeader.uncompressedSize,\n blockContentPosition,\n )\n }\n\n if (majorVersion >= 3) {\n // parse the crc32\n const crc = await this._parseSection(\n sectionParsers.cramBlockCrc32,\n blockContentPosition + blockHeader.compressedSize,\n )\n if (crc === undefined) {\n return undefined\n }\n block.crc32 = crc.crc32\n\n // check the block data crc32\n if (this.validateChecksums) {\n await this.checkCrc32(\n position,\n blockHeader._size + blockHeader.compressedSize,\n crc.crc32,\n 'block data',\n )\n }\n\n // make the endposition and size reflect the whole block\n block._endPosition = crc._endPosition\n block._size =\n block.compressedSize + sectionParsers.cramBlockCrc32.maxLength\n } else {\n block._endPosition = blockContentPosition + block.compressedSize\n block._size = block.compressedSize\n }\n\n return block\n }\n}\n\n'getDefinition getSectionParsers getSamHeader'.split(' ').forEach(method => {\n tinyMemoize(CramFile, method)\n})\n","// @ts-nocheck\nimport { CramMalformedError } from '../errors'\n\nimport { TF_SHIFT } from './constants'\nimport Decoding from './decoding'\n\nexport default function uncompress(\n /* ByteBuffer */ input,\n /* Decoding.AriDecoder */ D,\n /* Decoding.Symbol[] */ syms,\n /* ByteBuffer */ out,\n) {\n let rans0 = input.getInt()\n let rans1 = input.getInt()\n let rans2 = input.getInt()\n let rans3 = input.getInt()\n\n const /* int */ outputSize = out.remaining()\n const /* int */ outputEnd = outputSize & ~3\n for (let i = 0; i < outputEnd; i += 4) {\n const /* byte */ c0 = D.R[Decoding.get(rans0, TF_SHIFT)]\n const /* byte */ c1 = D.R[Decoding.get(rans1, TF_SHIFT)]\n const /* byte */ c2 = D.R[Decoding.get(rans2, TF_SHIFT)]\n const /* byte */ c3 = D.R[Decoding.get(rans3, TF_SHIFT)]\n\n out.putAt(i, c0)\n out.putAt(i + 1, c1)\n out.putAt(i + 2, c2)\n out.putAt(i + 3, c3)\n\n rans0 = Decoding.advanceSymbolStep(rans0, syms[0xff & c0], TF_SHIFT)\n rans1 = Decoding.advanceSymbolStep(rans1, syms[0xff & c1], TF_SHIFT)\n rans2 = Decoding.advanceSymbolStep(rans2, syms[0xff & c2], TF_SHIFT)\n rans3 = Decoding.advanceSymbolStep(rans3, syms[0xff & c3], TF_SHIFT)\n\n rans0 = Decoding.renormalize(rans0, input)\n rans1 = Decoding.renormalize(rans1, input)\n rans2 = Decoding.renormalize(rans2, input)\n rans3 = Decoding.renormalize(rans3, input)\n }\n\n out.setPosition(outputEnd)\n let /* byte */ c: number\n switch (outputSize & 3) {\n case 0:\n break\n case 1:\n c = D.R[Decoding.get(rans0, TF_SHIFT)]\n Decoding.advanceSymbol(rans0, input, syms[0xff & c], TF_SHIFT)\n out.put(c)\n break\n\n case 2:\n c = D.R[Decoding.get(rans0, TF_SHIFT)]\n Decoding.advanceSymbol(rans0, input, syms[0xff & c], TF_SHIFT)\n out.put(c)\n\n c = D.R[Decoding.get(rans1, TF_SHIFT)]\n Decoding.advanceSymbol(rans1, input, syms[0xff & c], TF_SHIFT)\n out.put(c)\n break\n\n case 3:\n c = D.R[Decoding.get(rans0, TF_SHIFT)]\n Decoding.advanceSymbol(rans0, input, syms[0xff & c], TF_SHIFT)\n out.put(c)\n\n c = D.R[Decoding.get(rans1, TF_SHIFT)]\n Decoding.advanceSymbol(rans1, input, syms[0xff & c], TF_SHIFT)\n out.put(c)\n\n c = D.R[Decoding.get(rans2, TF_SHIFT)]\n Decoding.advanceSymbol(rans2, input, syms[0xff & c], TF_SHIFT)\n out.put(c)\n break\n\n default:\n throw new CramMalformedError(\n 'invalid output size encountered during rANS decoding',\n )\n }\n\n out.setPosition(0)\n}\n","// @ts-nocheck\nimport { TF_SHIFT } from './constants'\nimport Decoding from './decoding'\n\nexport default function uncompress(\n /* ByteBuffer */ input,\n /* ByteBuffer */ output,\n /* Decoding.AriDecoder[] */ D,\n /* Decoding.Symbol[][] */ syms,\n) {\n const /* int */ outputSize = output.remaining()\n let rans0 = input.getInt()\n let rans1 = input.getInt()\n let rans2 = input.getInt()\n let rans7 = input.getInt()\n\n const /* int */ isz4 = outputSize >> 2\n let /* int */ i0 = 0\n let /* int */ i1 = isz4\n let /* int */ i2 = 2 * isz4\n let /* int */ i7 = 3 * isz4\n let /* int */ l0 = 0\n let /* int */ l1 = 0\n let /* int */ l2 = 0\n let /* int */ l7 = 0\n for (; i0 < isz4; i0 += 1, i1 += 1, i2 += 1, i7 += 1) {\n const /* int */ c0 = 0xff & D[l0].R[Decoding.get(rans0, TF_SHIFT)]\n const /* int */ c1 = 0xff & D[l1].R[Decoding.get(rans1, TF_SHIFT)]\n const /* int */ c2 = 0xff & D[l2].R[Decoding.get(rans2, TF_SHIFT)]\n const /* int */ c7 = 0xff & D[l7].R[Decoding.get(rans7, TF_SHIFT)]\n\n output.putAt(i0, c0)\n output.putAt(i1, c1)\n output.putAt(i2, c2)\n output.putAt(i7, c7)\n\n rans0 = Decoding.advanceSymbolStep(rans0, syms[l0][c0], TF_SHIFT)\n rans1 = Decoding.advanceSymbolStep(rans1, syms[l1][c1], TF_SHIFT)\n rans2 = Decoding.advanceSymbolStep(rans2, syms[l2][c2], TF_SHIFT)\n rans7 = Decoding.advanceSymbolStep(rans7, syms[l7][c7], TF_SHIFT)\n\n rans0 = Decoding.renormalize(rans0, input)\n rans1 = Decoding.renormalize(rans1, input)\n rans2 = Decoding.renormalize(rans2, input)\n rans7 = Decoding.renormalize(rans7, input)\n\n l0 = c0\n l1 = c1\n l2 = c2\n l7 = c7\n }\n\n // Remainder\n for (; i7 < outputSize; i7 += 1) {\n const /* int */ c7 = 0xff & D[l7].R[Decoding.get(rans7, TF_SHIFT)]\n output.putAt(i7, c7)\n rans7 = Decoding.advanceSymbol(rans7, input, syms[l7][c7], TF_SHIFT)\n l7 = c7\n }\n}\n","import { unzip } from './unzip'\nimport { open } from './io'\nimport { CramMalformedError } from './errors'\nimport { CramFileSource } from './cramFile/file'\nimport { Filehandle } from './cramFile/filehandle'\n\nconst BAI_MAGIC = 21_578_050 // BAI\\1\n\nexport interface Slice {\n start: number\n span: number\n containerStart: number\n sliceStart: number\n sliceBytes: number\n}\n\ntype ParsedIndex = Record<string, Slice[] | undefined>\n\nfunction addRecordToIndex(index: ParsedIndex, record: number[]) {\n const [seqId, start, span, containerStart, sliceStart, sliceBytes] = record\n\n const s = seqId!\n if (!index[s]) {\n index[s] = []\n }\n\n index[s].push({\n start: start!,\n span: span!,\n containerStart: containerStart!,\n sliceStart: sliceStart!,\n sliceBytes: sliceBytes!,\n })\n}\n\nfunction maybeUnzip(data: Buffer) {\n if (data[0] === 31 && data[1] === 139) {\n return unzip(data)\n }\n return data\n}\n\nexport default class CraiIndex {\n // A CRAM index (.crai) is a gzipped tab delimited file containing the\n // following columns:\n //\n // 1. Sequence id\n // 2. Alignment start\n // 3. Alignment span\n // 4. Container start byte position in the file\n // 5. Slice start byte position in the container data (‘blocks’)\n // 6. Slice size in bytes\n // Each line represents a slice in the CRAM file. Please note that all slices must be listed in index file.\n private parseIndexP?: Promise<ParsedIndex>\n\n private filehandle: Filehandle\n\n /**\n *\n * @param {object} args\n * @param {string} [args.path]\n * @param {string} [args.url]\n * @param {FileHandle} [args.filehandle]\n */\n constructor(args: CramFileSource) {\n this.filehandle = open(args.url, args.path, args.filehandle)\n }\n\n async parseIndex() {\n const index: ParsedIndex = {}\n const uncompressedBuffer = maybeUnzip(await this.filehandle.readFile())\n if (\n uncompressedBuffer.length > 4 &&\n uncompressedBuffer.readUInt32LE(0) === BAI_MAGIC\n ) {\n throw new CramMalformedError(\n 'invalid .crai index file. note: file appears to be a .bai index. this is technically legal but please open a github issue if you need support',\n )\n }\n // interpret the text as regular ascii, since it is\n // supposed to be only digits and whitespace characters\n // this is written in a deliberately low-level fashion for performance,\n // because some .crai files can be pretty large.\n let currentRecord: number[] = []\n let currentString = ''\n for (const charCode of uncompressedBuffer) {\n if (\n (charCode >= 48 && charCode <= 57) /* 0-9 */ ||\n (!currentString && charCode === 45) /* leading - */\n ) {\n currentString += String.fromCharCode(charCode)\n } else if (charCode === 9 /* \\t */) {\n currentRecord.push(Number.parseInt(currentString, 10))\n currentString = ''\n } else if (charCode === 10 /* \\n */) {\n currentRecord.push(Number.parseInt(currentString, 10))\n currentString = ''\n addRecordToIndex(index, currentRecord)\n currentRecord = []\n } else if (charCode !== 13 /* \\r */ && charCode !== 32 /* space */) {\n // if there are other characters in the file besides\n // space and \\r, something is wrong.\n throw new CramMalformedError('invalid .crai index file')\n }\n }\n\n // if the file ends without a \\n, we need to flush our buffers\n if (currentString) {\n currentRecord.push(Number.parseInt(currentString, 10))\n }\n if (currentRecord.length === 6) {\n addRecordToIndex(index, currentRecord)\n }\n\n // sort each of them by start\n Object.entries(index).forEach(([seqId, ent]) => {\n const e2 = ent!\n index[seqId] = e2.sort((a, b) => a.start - b.start || a.span - b.span)\n })\n return index\n }\n\n getIndex() {\n if (!this.parseIndexP) {\n this.parseIndexP = this.parseIndex().catch((e: unknown) => {\n this.parseIndexP = undefined\n throw e\n })\n }\n return this.parseIndexP\n }\n\n /**\n * @param {number} seqId\n * @returns {Promise} true if the index contains entries for\n * the given reference sequence ID, false otherwise\n */\n async hasDataForReferenceSequence(seqId: number) {\n return !!(await this.getIndex())[seqId]\n }\n\n /**\n * fetch index entries for the given range\n *\n * @param {number} seqId\n * @param {number} queryStart\n * @param {number} queryEnd\n *\n * @returns {Promise} promise for\n * an array of objects of the form\n * `{start, span, containerStart, sliceStart, sliceBytes }`\n */\n async getEntriesForRange(\n seqId: number,\n queryStart: number,\n queryEnd: number,\n ): Promise<Slice[]> {\n const seqEntries = (await this.getIndex())[seqId]\n if (!seqEntries) {\n return []\n }\n\n const compare = (entry: Slice) => {\n const entryStart = entry.start\n const entryEnd = entry.start + entry.span\n if (entryStart > queryEnd) {\n return -1\n } // entry is ahead of query\n if (entryEnd <= queryStart) {\n return 1\n } // entry is behind query\n return 0 // entry overlaps query\n }\n const bins = [] as Slice[]\n for (const entry of seqEntries) {\n if (compare(entry) === 0) {\n bins.push(entry)\n }\n }\n return bins\n }\n}\n","import { CramUnimplementedError } from './errors'\nimport CramFile from './cramFile'\nimport CramRecord from './cramFile/record'\nimport { SeqFetch } from './cramFile/file'\nimport { Filehandle } from './cramFile/filehandle'\nimport { Slice } from './craiIndex'\n\nexport interface CramFileSource {\n cramFilehandle?: Filehandle\n cramUrl?: string\n cramPath?: string\n}\n\nexport interface CramIndexLike {\n getEntriesForRange: (\n seqId: number,\n start: number,\n end: number,\n ) => Promise<Slice[]>\n hasDataForReferenceSequence: (seqId: number) => Promise<boolean>\n}\n\nexport default class IndexedCramFile {\n public cram: CramFile\n public index: CramIndexLike\n\n /**\n *\n * @param {object} args\n * @param {CramFile} args.cram\n * @param {Index-like} args.index object that supports getEntriesForRange(seqId,start,end) -> Promise[Array[index entries]]\n * @param {number} [args.cacheSize] optional maximum number of CRAM records to cache. default 20,000\n * @param {boolean} [args.checkSequenceMD5] - default true. if false, disables verifying the MD5\n * checksum of the reference sequence underlying a slice. In some applications, this check can cause an inconvenient amount (many megabases) of sequences to be fetched.\n */\n constructor(\n args: {\n index: CramIndexLike\n } & (\n | { cram: CramFile }\n | ({\n cram?: undefined\n seqFetch?: SeqFetch\n checkSequenceMD5?: boolean\n cacheSize?: number\n } & CramFileSource)\n ),\n ) {\n // { cram, index, seqFetch /* fasta, fastaIndex */ }) {\n this.cram =\n args.cram ??\n new CramFile({\n url: args.cramUrl,\n path: args.cramPath,\n filehandle: args.cramFilehandle,\n seqFetch: args.seqFetch,\n checkSequenceMD5: args.checkSequenceMD5,\n cacheSize: args.cacheSize,\n })\n\n if (!(this.cram instanceof CramFile)) {\n throw new Error('invalid arguments: no cramfile')\n }\n\n this.index = args.index\n }\n\n /**\n *\n * @param {number} seq numeric ID of the reference sequence\n * @param {number} start start of the range of interest. 1-based closed coordinates.\n * @param {number} end end of the range of interest. 1-based closed coordinates.\n * @returns {Promise[Array[CramRecord]]}\n */\n async getRecordsForRange(\n seq: number,\n start: number,\n end: number,\n opts: {\n viewAsPairs?: boolean\n pairAcrossChr?: boolean\n maxInsertSize?: number\n } = {},\n ) {\n opts.viewAsPairs = opts.viewAsPairs || false\n opts.pairAcrossChr = opts.pairAcrossChr || false\n opts.maxInsertSize = opts.maxInsertSize || 200000\n\n if (typeof seq === 'string') {\n // TODO: support string reference sequence names somehow\n throw new CramUnimplementedError(\n 'string sequence names not yet supported',\n )\n }\n const seqId = seq\n const slices = await this.index.getEntriesForRange(seqId, start, end)\n\n // TODO: do we need to merge or de-duplicate the blocks?\n\n // fetch all the slices and parse the feature data\n const filter = (feature: CramRecord) =>\n feature.sequenceId === seq &&\n feature.alignmentStart <= end &&\n feature.lengthOnRef !== undefined &&\n feature.alignmentStart + feature.lengthOnRef - 1 >= start\n const sliceResults = await Promise.all(\n slices.map(slice => this.getRecordsInSlice(slice, filter)),\n )\n\n let ret: CramRecord[] = Array.prototype.concat(...sliceResults)\n if (opts.viewAsPairs) {\n const readNames: Record<string, number> = {}\n const readIds: Record<string, number> = {}\n for (const read of ret) {\n const name = read.readName\n if (name === undefined) {\n throw new Error('readName undefined')\n }\n const id = read.uniqueId\n if (!readNames[name]) {\n readNames[name] = 0\n }\n readNames[name] += 1\n readIds[id] = 1\n }\n const unmatedPairs: Record<string, boolean> = {}\n Object.entries(readNames).forEach(([k, v]) => {\n if (v === 1) {\n unmatedPairs[k] = true\n }\n })\n const matePromises = []\n for (const cramRecord of ret) {\n const name = cramRecord.readName\n if (name === undefined) {\n throw new Error('readName undefined')\n }\n if (\n unmatedPairs[name] &&\n cramRecord.mate &&\n (cramRecord.mate.sequenceId === seqId || opts.pairAcrossChr) &&\n Math.abs(cramRecord.alignmentStart - cramRecord.mate.alignmentStart) <\n opts.maxInsertSize\n ) {\n const mateSlices = this.index.getEntriesForRange(\n cramRecord.mate.sequenceId,\n cramRecord.mate.alignmentStart,\n cramRecord.mate.alignmentStart + 1,\n )\n matePromises.push(mateSlices)\n }\n }\n const mateBlocks = await Promise.all(matePromises)\n let mateChunks = [] as Slice[]\n for (const block of mateBlocks) {\n mateChunks.push(...block)\n }\n // filter out duplicates\n mateChunks = mateChunks\n .sort((a, b) => a.toString().localeCompare(b.toString()))\n .filter(\n (item, pos, ary) =>\n !pos || item.toString() !== ary[pos - 1]!.toString(),\n )\n\n const mateRecordPromises = []\n const mateFeatPromises: Promise<CramRecord[]>[] = []\n for (const c of mateChunks) {\n let recordPromise = this.cram.featureCache.get(c.toString())\n if (!recordPromise) {\n recordPromise = this.getRecordsInSlice(c, () => true)\n this.cram.featureCache.set(c.toString(), recordPromise)\n }\n mateRecordPromises.push(recordPromise)\n const featPromise = recordPromise.then(feats => {\n const mateRecs = []\n for (const feature of feats) {\n if (feature.readName === undefined) {\n throw new Error('readName undefined')\n }\n if (unmatedPairs[feature.readName] && !readIds[feature.uniqueId]) {\n mateRecs.push(feature)\n }\n }\n return mateRecs\n })\n mateFeatPromises.push(featPromise)\n }\n const newMateFeats = await Promise.all(mateFeatPromises)\n if (newMateFeats.length) {\n const newMates = newMateFeats.reduce((result, current) =>\n result.concat(current),\n )\n ret = ret.concat(newMates)\n }\n }\n return ret\n }\n\n getRecordsInSlice(\n {\n containerStart,\n sliceStart,\n sliceBytes,\n }: { containerStart: number; sliceStart: number; sliceBytes: number },\n filterFunction: (r: CramRecord) => boolean,\n ) {\n const container = this.cram.getContainerAtPosition(containerStart)\n const slice = container.getSlice(sliceStart, sliceBytes)\n return slice.getRecords(filterFunction)\n }\n\n /**\n *\n * @param {number} seqId\n * @returns {Promise} true if the CRAM file contains data for the given\n * reference sequence numerical ID\n */\n hasDataForReferenceSequence(seqId: number) {\n return this.index.hasDataForReferenceSequence(seqId)\n }\n}\n","/*\n * Copyright (c) 2019 Genome Research Ltd.\n * Author(s): James Bonfield\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * 1. Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n *\n * 3. Neither the names Genome Research Ltd and Wellcome Trust Sanger\n * Institute nor the names of its contributors may be used to endorse\n * or promote products derived from this software without specific\n * prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS \"AS\n * IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\n * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH\n * LTD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nconst RangeCoder = require(\"./arith_sh\");\nconst IOStream = require(\"./iostream\");\nconst ByteModel = require(\"./byte_model\");\nconst bzip2 = require(\"bzip2\");\n\nconst ARITH_ORDER = 1\nconst ARITH_EXT = 4\nconst ARITH_STRIPE = 8\nconst ARITH_NOSIZE = 16\nconst ARITH_CAT = 32\nconst ARITH_RLE = 64\nconst ARITH_PACK = 128\n\nmodule.exports = class RangeCoderGen {\n decode(src) {\n\tthis.stream = new IOStream(src);\n\treturn this.decodeStream(this.stream)\n }\n\n decodeStream(stream, n_out=0) {\n\tvar flags = this.stream.ReadByte();\n\tif (!(flags & ARITH_NOSIZE))\n\t n_out = this.stream.ReadUint7();\n\tvar e_len = n_out;\n\n\tvar order = flags & ARITH_ORDER;\n\n\t// 4-way recursion\n\tif (flags & ARITH_STRIPE)\n\t return this.decodeStripe(this.stream, n_out)\n\n\t// Meta data\n\tif (flags & ARITH_PACK) {\n\t var P\n\t [P, e_len] = this.decodePackMeta(this.stream)\n\t}\n\n\t// NOP, useful for tiny blocks\n\tif (flags & ARITH_CAT)\n\t var data = this.decodeCat(this.stream, e_len)\n\n\t// Entropy decode\n\telse if (flags & ARITH_EXT) {\n\t var data = this.decodeExt(this.stream, e_len)\n\t} else if (flags & ARITH_RLE) {\n\t var data = order\n\t\t? this.decodeRLE1(this.stream, e_len)\n\t\t: this.decodeRLE0(this.stream, e_len)\n\t} else {\n\t var data = order\n\t\t? this.decode1(this.stream, e_len)\n\t\t: this.decode0(this.stream, e_len)\n\t}\n\n\t// Transforms\n\tif (flags & ARITH_PACK)\n\t data = this.decodePack(data, P, n_out)\n\n\treturn data\n }\n\n encode(src, flags) {\n\tthis.stream = new IOStream(\"\", 0, src.length*1.1 + 100); // guestimate worst case!\n\n\tthis.stream.WriteByte(flags);\n\tif (!(flags & ARITH_NOSIZE))\n\t this.stream.WriteUint7(src.length);\n\n\tif (flags & ARITH_STRIPE)\n\t return Buffer.concat([this.stream.buf.slice(0, this.stream.pos),\n\t\t\t\t this.encodeStripe(this.stream, src, flags>>8)])\n\n\tvar order = flags & ARITH_ORDER;\n\tvar e_len = src.length;\n\n\t// step 1: Encode meta-data\n\tvar pack_meta\n\tif (flags & ARITH_PACK)\n\t [pack_meta, src, e_len] = this.encodePack(src)\n\n\t// step 2: Write any meta data\n\tif (flags & ARITH_PACK)\n\t this.stream.WriteStream(pack_meta)\n\n\t// step 3: arith encoding below\n\tif (flags & ARITH_RLE) {\n\t return order\n\t\t? this.encodeRLE1(src, e_len, this.stream)\n\t\t: this.encodeRLE0(src, e_len, this.stream);\n\t} else {\n\t return order\n\t\t? this.encode1(src, e_len, this.stream)\n\t\t: this.encode0(src, e_len, this.stream);\n\t}\n }\n\n //----------------------------------------------------------------------\n // Order-0 codec\n decode0(stream, n_out) {\n\tvar output = new Buffer.allocUnsafe(n_out);\n\n\tvar max_sym = stream.ReadByte()\n\tif (max_sym == 0)\n\t max_sym = 256\n\n\tvar byte_model = new ByteModel(max_sym);\n\n\tvar rc = new RangeCoder(stream);\n\trc.RangeStartDecode(stream);\n\n\tfor (var i = 0; i < n_out; i++)\n\t output[i] = byte_model.ModelDecode(stream, rc);\n\n\treturn output;\n }\n\n encode0(src, n_in, out) {\n\t// Count the maximum symbol present\n\tvar max_sym = 0;\n\tfor (var i = 0; i < n_in; i++)\n\t if (max_sym < src[i])\n\t\tmax_sym = src[i]\n\tmax_sym++; // FIXME not what spec states!?\n\n\tvar byte_model = new ByteModel(max_sym);\n\tout.WriteByte(max_sym);\n\tvar rc = new RangeCoder(out);\n\n\tfor (var i = 0; i < n_in; i++)\n\t byte_model.ModelEncode(out, rc, src[i])\n\trc.RangeFinishEncode(out)\n\n\treturn out.buf.slice(0, out.pos);\n }\n\n //----------------------------------------------------------------------\n // Order-1 codec\n\n decode1(stream, n_out) {\n\tvar output = new Buffer.allocUnsafe(n_out);\n\n\tvar max_sym = stream.ReadByte()\n\tif (max_sym == 0)\n\t max_sym = 256\n\n\tvar byte_model = new Array(max_sym);\n\tfor (var i = 0; i < max_sym; i++)\n\t byte_model[i] = new ByteModel(max_sym);\n\n\tvar rc = new RangeCoder(stream);\n\trc.RangeStartDecode(stream);\n\n\tvar last = 0;\n\tfor (var i = 0; i < n_out; i++) {\n\t output[i] = byte_model[last].ModelDecode(stream, rc);\n\t last = output[i];\n\t}\n\n\treturn output;\n }\n\n encode1(src, n_in, out) {\n\t// Count the maximum symbol present\n\tvar max_sym = 0;\n\tfor (var i = 0; i < n_in; i++)\n\t if (max_sym < src[i])\n\t\tmax_sym = src[i]\n\tmax_sym++; // FIXME not what spec states!\n\n\tvar byte_model = new Array(max_sym);\n\tfor (var i = 0; i < max_sym; i++)\n\t byte_model[i] = new ByteModel(max_sym);\n\tout.WriteByte(max_sym);\n\tvar rc = new RangeCoder(out);\n\n\tvar last = 0;\n\tfor (var i = 0; i < n_in; i++) {\n\t byte_model[last].ModelEncode(out, rc, src[i])\n\t last = src[i]\n\t}\n\trc.RangeFinishEncode(out)\n\n\treturn out.buf.slice(0, out.pos);\n }\n\n //----------------------------------------------------------------------\n // External codec\n decodeExt(stream, n_out) {\n\t// Bzip2 only for now\n\tvar output = new Buffer.allocUnsafe(n_out)\n\tvar bits = bzip2.array(stream.buf.slice(stream.pos))\n\tvar size = bzip2.header(bits)\n\tvar j = 0\n\tdo {\n\t var chunk = bzip2.decompress(bits, size);\n\t if (chunk != -1) {\n\t Buffer.from(chunk).copy(output, j)\n\t j += chunk.length\n\t\tsize -= chunk.length\n\t }\n\t} while(chunk != -1);\n\n\treturn output\n }\n\n encodeExt(stream, n_out) {\n\t// We cannot compress using Bzip2 now as it's\n\t// absent from bzip2.js, but consider using\n\t// https://github.com/cscott/compressjs\n }\n\n //----------------------------------------------------------------------\n // Order-0 RLE codec\n decodeRLE0(stream, n_out) {\n\tvar output = new Buffer.allocUnsafe(n_out);\n\n\tvar max_sym = stream.ReadByte()\n\tif (max_sym == 0)\n\t max_sym = 256\n\n\tvar model_lit = new ByteModel(max_sym);\n\tvar model_run = new Array(258);\n\tfor (var i = 0; i <= 257; i++)\n\t model_run[i] = new ByteModel(4)\n\n\tvar rc = new RangeCoder(stream);\n\trc.RangeStartDecode(stream);\n\n\tvar i = 0;\n\twhile (i < n_out) {\n\t output[i] = model_lit.ModelDecode(stream, rc)\n\t var part = model_run[output[i]].ModelDecode(stream, rc)\n\t var run = part\n\t var rctx = 256\n\t while (part == 3) {\n\t\tpart = model_run[rctx].ModelDecode(stream, rc)\n\t\trctx = 257\n\t\trun += part\n\t }\n\t for (var j = 1; j <= run; j++)\n\t\toutput[i+j] = output[i]\n\t i += run+1\n\t}\n\n\treturn output;\n }\n\n encodeRLE0(src, n_in, out) {\n\t// Count the maximum symbol present\n\tvar max_sym = 0;\n\tfor (var i = 0; i < n_in; i++)\n\t if (max_sym < src[i])\n\t\tmax_sym = src[i]\n\tmax_sym++; // FIXME not what spec states!\n\n\tvar model_lit = new ByteModel(max_sym);\n\tvar model_run = new Array(258);\n\tfor (var i = 0; i <= 257; i++)\n\t model_run[i] = new ByteModel(4)\n\n\tout.WriteByte(max_sym);\n\tvar rc = new RangeCoder(out);\n\n\tvar i = 0\n\twhile (i < n_in) {\n\t model_lit.ModelEncode(out, rc, src[i])\n\t var run = 1\n\t while (i+run < n_in && src[i+run] == src[i])\n\t\trun++\n\t run--\n\n\t var rctx = src[i]\n\t var last = src[i]\n\t i += run+1\n\n\t var part = run >= 3 ? 3 : run\n\t model_run[rctx].ModelEncode(out, rc, part)\n\t run -= part\n\t rctx = 256\n\t while (part == 3) {\n\t\tpart = run >= 3 ? 3 : run\n\t\tmodel_run[rctx].ModelEncode(out, rc, part)\n\t\trctx = 257\n\t\trun -= part\n\t }\n\t}\n\trc.RangeFinishEncode(out)\n\n\treturn out.buf.slice(0, out.pos);\n }\n\n //----------------------------------------------------------------------\n // Order-1 RLE codec\n\n decodeRLE1(stream, n_out) {\n\tvar output = new Buffer.allocUnsafe(n_out);\n\n\tvar max_sym = stream.ReadByte()\n\tif (max_sym == 0)\n\t max_sym = 256\n\n\tvar model_lit = new Array(max_sym);\n\tfor (var i = 0; i < max_sym; i++)\n\t model_lit[i] = new ByteModel(max_sym);\n\n\tvar model_run = new Array(258);\n\tfor (var i = 0; i <= 257; i++)\n\t model_run[i] = new ByteModel(4)\n\n\tvar rc = new RangeCoder(stream);\n\trc.RangeStartDecode(stream);\n\n\tvar last = 0;\n\tvar i = 0;\n\twhile (i < n_out) {\n\t output[i] = model_lit[last].ModelDecode(stream, rc)\n\t last = output[i]\n\t var part = model_run[output[i]].ModelDecode(stream, rc)\n\t var run = part\n\t var rctx = 256\n\t while (part == 3) {\n\t\tpart = model_run[rctx].ModelDecode(stream, rc)\n\t\trctx = 257\n\t\trun += part\n\t }\n\t for (var j = 1; j <= run; j++)\n\t\toutput[i+j] = output[i]\n\t i += run+1\n\t}\n\n\treturn output;\n }\n\n encodeRLE1(src, n_in, out) {\n\t// Count the maximum symbol present\n\tvar max_sym = 0;\n\tfor (var i = 0; i < n_in; i++)\n\t if (max_sym < src[i])\n\t\tmax_sym = src[i]\n\tmax_sym++; // FIXME not what spec states!\n\n\tvar model_lit = new Array(max_sym)\n\tfor (var i = 0; i < max_sym; i++)\n\t model_lit[i] = new ByteModel(max_sym);\n\tvar model_run = new Array(258);\n\tfor (var i = 0; i <= 257; i++)\n\t model_run[i] = new ByteModel(4)\n\n\tout.WriteByte(max_sym);\n\tvar rc = new RangeCoder(out);\n\n\tvar i = 0\n\tvar last = 0\n\twhile (i < n_in) {\n\t model_lit[last].ModelEncode(out, rc, src[i])\n\t var run = 1\n\t while (i+run < n_in && src[i+run] == src[i])\n\t\trun++\n\t run--\n\n\t var rctx = src[i]\n\t last = src[i]\n\t i += run+1\n\n\t var part = run >= 3 ? 3 : run\n\t model_run[rctx].ModelEncode(out, rc, part)\n\t run -= part\n\t rctx = 256\n\t while (part == 3) {\n\t\tpart = run >= 3 ? 3 : run\n\t\tmodel_run[rctx].ModelEncode(out, rc, part)\n\t\trctx = 257\n\t\trun -= part\n\t }\n\t}\n\trc.RangeFinishEncode(out)\n\n\treturn out.buf.slice(0, out.pos);\n }\n\n //----------------------------------------------------------------------\n // Pack method\n decodePackMeta(stream) {\n\tthis.nsym = stream.ReadByte()\n\n\tvar M = new Array(this.nsym);\n\tfor (var i = 0; i < this.nsym; i++)\n\t M[i] = stream.ReadByte()\n\n\tvar e_len = stream.ReadUint7(); // Could be derived data from nsym and n_out\n\n\treturn [M, e_len]\n }\n\n decodePack(data, M, len) {\n\tvar out = new Buffer.allocUnsafe(len);\n\n\tif (this.nsym <= 1) {\n\t // Constant value\n\t for (var i = 0; i < len; i++)\n\t\tout[i] = M[0]\n\n\t} else if (this.nsym <= 2) {\n\t // 1 bit per value\n\t for (var i = 0, j = 0; i < len; i++) {\n\t\tif (i % 8 == 0)\n\t\t var v = data[j++]\n\t\tout[i] = M[v & 1]\n\t\tv >>= 1\n\t }\n\n\t} else if (this.nsym <= 4) {\n\t // 2 bits per value\n\t for (var i = 0, j = 0; i < len; i++) {\n\t\tif (i % 4 == 0)\n\t\t var v = data[j++]\n\t\tout[i] = M[v & 3]\n\t\tv >>= 2\n\t }\n\n\t} else if (this.nsym <= 16) {\n\t // 4 bits per value\n\t for (var i = 0, j = 0; i < len; i++) {\n\t\tif (i % 2 == 0)\n\t\t var v = data[j++]\n\t\tout[i] = M[v & 15]\n\t\tv >>= 4\n\t }\n\n\t} else {\n\t // 8 bits per value: NOP\n\t return data\n\t}\n\n\treturn out\n }\n\n // Compute M array and return meta-data stream\n packMeta(src) {\n\tvar stream = new IOStream(\"\", 0, 1024)\n\n\t// Count symbols\n\tvar M = new Array(256)\n\tfor (var i = 0; i < src.length; i++)\n\t M[src[i]] = 1\n\n\t// Write Map\n\tfor (var nsym = 0, i = 0; i < 256; i++)\n\t if (M[i])\n\t\tM[i] = ++nsym; // map to 1..N\n\tstream.WriteByte(nsym);\n\n\t// FIXME: add check for nsym > 16?\n\t// Or just accept it as an inefficient waste of time.\n\tfor (var i = 0; i < 256; i++) {\n\t if (M[i]) {\n\t\tstream.WriteByte(i) // adjust to 0..N-1\n\t\tM[i]--;\n\t }\n\t}\n\n\treturn [stream, M, nsym]\n }\n\n encodePack(data) {\n\tvar meta, M, nsym\n\t[meta, M, nsym] = this.packMeta(data)\n\n\tvar len = data.length\n\tvar i = 0;\n\tif (nsym <= 1) {\n\t // Constant values\n\t meta.WriteUint7(0)\n\t return [meta, new Buffer.allocUnsafe(0), 0];\n\t}\n\n\tif (nsym <= 2) {\n\t // 1 bit per value\n\t var out = new Buffer.allocUnsafe(Math.floor((len+7)/8));\n\t for (var i = 0, j = 0; i < (len & ~7); i+=8, j++)\n\t\tout[j] = (M[data[i+0]]<<0)\n\t\t + (M[data[i+1]]<<1)\n\t\t + (M[data[i+2]]<<2)\n\t\t + (M[data[i+3]]<<3)\n\t\t + (M[data[i+4]]<<4)\n\t\t + (M[data[i+5]]<<5)\n\t\t + (M[data[i+6]]<<6)\n\t\t + (M[data[i+7]]<<7)\n\t if (i < len) {\n\t\tout[j] = 0;\n\t\tvar v = 0;\n\t\twhile (i < len) {\n\t\t out[j] |= M[data[i++]]<<v;\n\t\t v++;\n\t\t}\n\t\tj++;\n\t }\n\n\t meta.WriteUint7(j)\n\t return [meta, out, out.length]\n\t}\n\n\tif (nsym <= 4) {\n\t // 2 bits per value\n\t var out = new Buffer.allocUnsafe(Math.floor((len+3)/4));\n\t for (var i = 0, j = 0; i < (len & ~3); i+=4, j++)\n\t\tout[j] = (M[data[i+0]]<<0)\n\t\t + (M[data[i+1]]<<2)\n\t\t + (M[data[i+2]]<<4)\n\t\t + (M[data[i+3]]<<6)\n\n\t if (i < len) {\n\t\tout[j] = 0;\n\t\tvar v = 0;\n\t\twhile (i < len) {\n\t\t out[j] |= M[data[i++]]<<v;\n\t\t v+=2;\n\t\t}\n\t\tj++;\n\t }\n\n\t meta.WriteUint7(j)\n\t return [meta, out, out.length]\n\t}\n\n\tif (nsym <= 16) {\n\t // 4 bits per value\n\t var out = new Buffer.allocUnsafe(Math.floor((len+1)/2));\n\t for (var i = 0, j = 0; i < (len & ~1); i+=2, j++)\n\t\tout[j] = (M[data[i+0]]<<0)\n\t\t + (M[data[i+1]]<<4)\n\t if (i < len)\n\t\tout[j++] = M[data[i++]];\n\n\t meta.WriteUint7(j)\n\t return [meta, out, out.length]\n\t}\n\n\t// Otherwise an expensive NOP\n\tmeta.WriteUint7(data.length)\n\treturn [meta, data, data.length]\n }\n\n //----------------------------------------------------------------------\n // STRIPE method\n encodeStripe(hdr, src, N) {\n if (N == 0)\n\tN = 4; // old default\n\n\t// Split into multiple streams\n\tvar part = new Array(N)\n\tvar ulen = new Array(N)\n\tfor (var s = 0; s < N; s++) {\n\t ulen[s] = Math.floor(src.length / N) + ((src.length % N) > s);\n\t part[s] = new Array(ulen[s])\n\t}\n\n\tfor (var x = 0, i = 0; i < src.length; i+=N, x++) {\n\t for (var j = 0; j < N; j++)\n\t\tif (x < part[j].length)\n\t\t part[j][x] = src[i+j]\n\t}\n\n\t// Compress each part\n\tvar comp = new Array(N)\n\tvar total = 0\n\tfor (var s = 0; s < N; s++) {\n\t // Example: try O0 and O1 and choose best\n\t var comp0 = this.encode(part[s], 0)\n\t var comp1 = this.encode(part[s], 1)\n\t comp[s] = (comp1.length < comp0.length) ? comp1 : comp0\n\t total += comp[s].length\n\t}\n\n\t// Serialise\n\tvar out = new IOStream(\"\", 0, total+5*N + 1)\n\tout.WriteByte(N)\n\tfor (var s = 0; s < N; s++)\n\t out.WriteUint7(comp[s].length)\n\n\tfor (var s = 0; s < N; s++)\n\t out.WriteData(comp[s], comp[s].length)\n\n\treturn out.buf.slice(0, out.buf.pos)\n }\n\n decodeStripe(stream, len) {\n\tvar N = stream.ReadByte()\n\t\n\t// Retrieve lengths\n\tvar clen = new Array(N)\n\tvar ulen = new Array(N)\n\tfor (var j = 0; j < N; j++)\n\t clen[j] = stream.ReadUint7()\n\n\t// Decode streams\n\tvar T = new Array(N);\n\tfor (var j = 0; j < N; j++) {\n\t ulen[j] = Math.floor(len / N) + ((len % N) > j)\n\t T[j] = this.decodeStream(stream, ulen[j])\n\t}\n\n\t// Transpose\n\tvar out = new Buffer.allocUnsafe(len)\n\tfor (var j = 0; j < N; j++) {\n\t for (var i = 0; i < ulen[j]; i++) {\n\t\tout[i*N + j] = T[j][i];\n\t }\n\t}\n\n\treturn out\n }\n\n //----------------------------------------------------------------------\n // Cat method\n decodeCat(stream, len) {\n\tvar out = new Buffer.allocUnsafe(len);\n\tfor (var i = 0; i < len; i++)\n\t out[i] = stream.ReadByte()\n\n\treturn out\n }\n}\n","/*\n * Copyright (c) 2019 Genome Research Ltd.\n * Author(s): James Bonfield\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * 1. Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n *\n * 3. Neither the names Genome Research Ltd and Wellcome Trust Sanger\n * Institute nor the names of its contributors may be used to endorse\n * or promote products derived from this software without specific\n * prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS \"AS\n * IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\n * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH\n * LTD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n// An arithmetic coder, based on Eugene Shelwien's reimplementation of\n// Michael Schindler range coder.\n//\n// Order-0 byte stream of ~/scratch/data/q40b\n// C: 3.1s decode (approx same vs 32-bit and 64-bit)\n// Arith_sh.js 6.7s decode (32-bit with carries)\n// Arith.js 317.0s decode (64-bit no carries); int64 crippling it.\n\n//----------------------------------------------------------------------\n// Arithmetic (range) coder\nmodule.exports = class RangeCoder {\n constructor(src) {\n\tthis.low = 0;\n\tthis.range = 0xffffffff;\n\tthis.code = 0;\n\tthis.FFnum = 0;\n\tthis.carry = 0;\n\tthis.cache = 0;\n }\n\n RangeStartDecode(src) {\n\tfor (var i = 0; i < 5; i++)\n\t this.code = (this.code << 8) + src.ReadByte();\n\tthis.code &= 0xffffffff;\n\tthis.code >>>= 0; // force to be +ve int\n }\n\n RangeGetFrequency(tot_freq) {\n\tthis.range = Math.floor(this.range / tot_freq);\n\t//return this.code / this.range;\n\treturn Math.floor(this.code / this.range);\n\n\t// Conceptual scenario; return freq only and don't modify range yet\n\t//return Math.floor(this.code / (Math.floor(this.range / tot_freq)));\n }\n\n RangeDecode(src, sym_low, sym_freq, tot_freq) {\n\t// Conceptually we divide range here, but in practice we cached it earlier\n\t//this.range = Math.floor(this.range / tot_freq);\n\n\tthis.code -= sym_low * this.range;\n\tthis.range *= sym_freq;\n\n\twhile (this.range < (1<<24)) {\n\t this.range *= 256;\n\t this.code = (this.code*256 + src.ReadByte());\n\t}\n }\n\n RangeShiftLow(dst) {\n\t// We know range is < (1<<24) as we got here. We already have a\n\t// cached copy of 8 bits from low. Is this correct, or does it need\n\t// fixing? Possible scenarios.\n\t// 1. Low < 0xff000000 thus low+range < 0xffffffff and cache\n\t// cannot possibly change. Output cache and as many ffs as needed.\n\t// 2. We already detected an overflow in RangeEncode, setting carry.\n\t// In this case output cached byte + 1 and any 00s needed.\n\t// 3. Neither case - range is low but we haven't yet detected if we're\n\t// XXffffff or XY000000 scenario. Increase counter for ff/00s.\n\n\tif (this.low < 0xff000000 | this.carry) {\n\t // cached byte if no overflow, byte+1 otherwise\n\t dst.WriteByte(this.cache + this.carry);\n\n\t // Flush any tracked FFs (no carry) or 00s (carry).\n\t while (this.FFnum) {\n\t\tdst.WriteByte(this.carry-1);\n\t\tthis.FFnum--;\n\t }\n\n\t // Take a copy of top byte ready for next flush\n\t this.cache = this.low >>> 24;\n\t this.carry = 0;\n\t} else {\n\t this.FFnum++; // keep track of number of trailing ff/00 bytes to write\n\t}\n\tthis.low <<= 8;\n\tthis.low >>>= 0; // force to be +ve int\n }\n\n RangeEncode(dst, sym_low, sym_freq, tot_freq) {\n\tvar old_low = this.low\n\tthis.range = Math.floor(this.range / tot_freq)\n\tthis.low += sym_low * this.range;\n\tthis.low >>>= 0; // Truncate to +ve int so we can spot overflow\n\tthis.range *= sym_freq;\n\n\t// \"low + sym*range < old_low\" means we overflow; set carry.\n\t// NB: can this.low < old_low occur twice before range < (1<<24)?\n\t// We claim not, but prove it!\n\tif (this.low < old_low) {\n\t if (this.carry != 0) console.log(\"ERROR: Multiple carry\")\n\t this.carry = 1\n\t}\n\n\t// Renormalise if range gets too small\n\twhile (this.range < (1<<24)) {\n\t this.range *= 256;\n\t this.RangeShiftLow(dst);\n\t}\n }\n\n RangeFinishEncode(dst) {\n\tfor (var i = 0; i < 5; i++)\n\t this.RangeShiftLow(dst)\n }\n};\n","/*\n * Copyright (c) 2019 Genome Research Ltd.\n * Author(s): James Bonfield\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * 1. Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n *\n * 3. Neither the names Genome Research Ltd and Wellcome Trust Sanger\n * Institute nor the names of its contributors may be used to endorse\n * or promote products derived from this software without specific\n * prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS \"AS\n * IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\n * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH\n * LTD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n// An adaptive probability model for encoding and decoding of symbols\n// within a given alphabet, using the range coder to get/put the\n// compressed data.\n\nconst MAX_FREQ = ((1<<16)-17)\nconst STEP = 16\n\nmodule.exports = class ByteModel {\n constructor(max_sym = 256) {\n\tthis.total_freq = max_sym;\n\tthis.max_sym = max_sym-1;\n\tthis.S = new Array\n\tthis.F = new Array\n\n\tfor (var i = 0; i <= this.max_sym; i++) {\n\t this.S[i] = i;\n\t this.F[i] = 1;\n\t}\n }\n\n ModelDecode(src, rc) {\n\t// Find symbol\n\tvar freq = rc.RangeGetFrequency(this.total_freq);\n\n\t// Linear scan to find cumulative frequency 'freq'\n\tvar acc = 0;\n\tvar x = 0;\n\twhile (acc + this.F[x] <= freq)\n\t acc += this.F[x++];\n\n//\tfor (var acc = 0; (acc += this.F[x]) <= freq; x++)\n//\t ;\n//\tacc -= this.F[x];\n\n\t// Update range coder\n\trc.RangeDecode(src, acc, this.F[x], this.total_freq);\n\n\t// Update model\n\tthis.F[x] += STEP;\n\tthis.total_freq += STEP;\n\tif (this.total_freq > MAX_FREQ)\n\t this.ModelRenormalise();\n\t\n\n\t// Keep symbols approximately frequency sorted\n\tvar sym = this.S[x];\n\tif (x > 0 && this.F[x] > this.F[x-1]) {\n\t var tmp = this.F[x];\n\t this.F[x] = this.F[x-1];\n\t this.F[x-1] = tmp;\n\n\t tmp = this.S[x];\n\t this.S[x] = this.S[x-1];\n\t this.S[x-1] = tmp;\n\t}\n\n\treturn sym;\n }\n\n ModelRenormalise() {\n\t// Halve all the frequencies, being careful not to hit zero\n\tthis.total_freq = 0;\n\tfor (var i = 0; i <= this.max_sym; i++) {\n\t this.F[i] -= Math.floor(this.F[i] / 2);\n\t this.total_freq += this.F[i];\n\t}\n }\n\n ModelEncode(dst, rc, sym) {\n\t// Find cumulative frequency\n\tvar acc = 0;\n\tfor (var x = 0; this.S[x] != sym; x++)\n\t acc += this.F[x];\n\n\t// Encode\n\trc.RangeEncode(dst, acc, this.F[x], this.total_freq);\n\n\t// Update model\n\tthis.F[x] += STEP;\n\tthis.total_freq += STEP;\n\tif (this.total_freq > MAX_FREQ) // FIXME x2\n\t this.ModelRenormalise();\n\n\t// Keep symbols approximately frequency sorted\n\tvar sym = this.S[x];\n\tif (x > 0 && this.F[x] > this.F[x-1]) {\n\t var tmp = this.F[x];\n\t this.F[x] = this.F[x-1];\n\t this.F[x-1] = tmp;\n\n\t tmp = this.S[x];\n\t this.S[x] = this.S[x-1];\n\t this.S[x-1] = tmp;\n\t}\n }\n};\n","/*\n * Copyright (c) 2019 Genome Research Ltd.\n * Author(s): James Bonfield\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * 1. Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n *\n * 3. Neither the names Genome Research Ltd and Wellcome Trust Sanger\n * Institute nor the names of its contributors may be used to endorse\n * or promote products derived from this software without specific\n * prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS \"AS\n * IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\n * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH\n * LTD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nconst IOStream = require(\"./iostream\");\nconst ByteModel = require(\"./byte_model\");\nconst RangeCoder = require(\"./arith_sh\");\n\n\n//----------------------------------------------------------------------\n// Main arithmetic entry function: decodes a compressed src and\n// returns the uncompressed buffer.\n\nfunction read_array(src, tab, size) {\n var j = 0; // array value\n var z = 0; // array index: tab[j]\n var last = -1;\n\n // Remove first level of run-length encoding\n var R = new Array(1024) // runs\n while (z < size) {\n\tvar run = src.ReadByte()\n\tR[j++] = run\n\tz += run\n\n\tif (run == last) {\n\t var copy = src.ReadByte()\n\t z += run * copy\n\t while (copy--)\n\t\tR[j++] = run\n\t}\n\tlast = run\n }\n\n // Now expand runs in R to tab, noting 255 is max run\n var i = 0\n j = 0\n z = 0\n while (z < size) {\n\tvar run_len = 0\n\tdo {\n\t var part = R[j++]\n\t run_len += part\n\t} while (part == 255)\n\t\n\twhile (run_len--)\n\t tab[z++] = i;\n\ti++\n }\n}\n\nconst QMAX = 256\n\nconst FLAG_DEDUP = 2\nconst FLAG_FLEN = 4\nconst FLAG_SEL = 8 // whether selector is used in context\nconst FLAG_QMAP = 16\nconst FLAG_PTAB = 32\nconst FLAG_DTAB = 64\nconst FLAG_QTAB = 128\n\nconst GFLAG_MULTI_PARAM = 1\nconst GFLAG_HAVE_STAB = 2\nconst GFLAG_DO_REV = 4\n\n// Compute a new context from our current state and qual q\nfunction fqz_update_ctx(params, state, q) {\n var last = params.context\n state.qctx = ((state.qctx << params.qshift) + params.qtab[q]); // >>> 0\n last += ((state.qctx & ((1<<params.qbits)-1)) << params.qloc); // >>> 0\n\n if (params.do_pos)\n\tlast += params.ptab[Math.min(state.p, 1023)] << params.ploc\n\n if (params.do_delta) {\n\tlast += params.dtab[Math.min(state.delta, 255)] << params.dloc\n\t// Is it better to use q here or qtab[q]?\n\t// If qtab[q] we can map eg [a-z0-9A-Z]->0 ,->1 and have\n\t// delta being a token number count into comma separated lists?\n\tstate.delta += (state.prevq != q) ? 1 : 0\n\tstate.prevq = q\n }\n\n if (params.do_sel)\n\tlast += state.s << params.sloc\n\n state.p--\n\n return last & 0xffff\n}\n\nfunction decode_fqz_single_param(src) {\n var p = {} // params\n \n // Load FQZ parameters\n p.context = src.ReadUint16()\n p.pflags = src.ReadByte()\n\n p.do_dedup = p.pflags & FLAG_DEDUP\n p.fixed_len = p.pflags & FLAG_FLEN\n p.do_sel = p.pflags & FLAG_SEL\n p.do_qmap = p.pflags & FLAG_QMAP\n p.do_pos = p.pflags & FLAG_PTAB\n p.do_delta = p.pflags & FLAG_DTAB\n p.do_qtab = p.pflags & FLAG_QTAB\n\n p.max_sym = src.ReadByte()\n\n var x = src.ReadByte()\n p.qbits = x>>4\n p.qshift = x&15\n x = src.ReadByte()\n p.qloc = x>>4\n p.sloc = x&15\n x = src.ReadByte()\n p.ploc = x>>4\n p.dloc = x&15\n\n // Qual map, eg to \"unbin\" Illumina qualities\n p.qmap = new Array(256);\n if (p.pflags & FLAG_QMAP) {\n\tfor (var i = 0; i < p.max_sym; i++)\n\t p.qmap[i] = src.ReadByte()\n } else {\n\t// Useful optimisation to speed up main loop\n\tfor (var i = 0; i < 256; i++)\n\t p.qmap[i] = i; // NOP\n }\n\n // Read tables\n p.qtab = new Array(1024);\n if (p.qbits > 0 && (p.pflags & FLAG_QTAB)) {\n\tread_array(src, p.qtab, 256)\n } else {\n\t// Useful optimisation to speed up main loop\n\tfor (var i = 0; i < 256; i++)\n\t p.qtab[i] = i; // NOP\n }\n\n p.ptab = new Array(1024);\n if (p.pflags & FLAG_PTAB)\n\tread_array(src, p.ptab, 1024);\n\n p.dtab = new Array(256);\n if (p.pflags & FLAG_DTAB)\n\tread_array(src, p.dtab, 256);\n\n return p\n}\n\nfunction decode_fqz_params(src) {\n var gparams = {\n\tmax_sym: 0\n }\n\n // Check fqz format version\n var vers = src.ReadByte()\n if (vers != 5) {\n\tconsole.error(\"Invalid FQZComp version number\");\n\treturn;\n }\n\n var gflags = src.ReadByte()\n var nparam = (gflags & GFLAG_MULTI_PARAM) ? src.ReadByte() : 1\n var max_sel = gflags.nparam > 1 ? gflags.nparam-1 : 0 // Note max_sel, not num_sel\n\n var stab = new Array(256);\n if (gflags & GFLAG_HAVE_STAB) {\n\tmax_sel = src.ReadByte()\n\tread_array(src, stab, 256);\n } else {\n\tfor (var i = 0; i < nparam; i++)\n\t stab[i] = i;\n\tfor (; i < 256; i++)\n\t stab[i] = nparam-1;\n }\n gparams.do_rev = (gflags & GFLAG_DO_REV)\n gparams.stab = stab\n gparams.max_sel = max_sel\n\n gparams.params = new Array(gparams.nparam)\n for (var p = 0; p < nparam; p++) {\n\tgparams.params[p] = decode_fqz_single_param(src)\n\tif (gparams.max_sym < gparams.params[p].max_sym)\n\t gparams.max_sym = gparams.params[p].max_sym\n }\n\n return gparams\n}\n\nfunction fqz_create_models(gparams) {\n var model = {}\n\n model.qual = new Array(1<<16)\n for (var i = 0; i < (1<<16); i++)\n\tmodel.qual[i] = new ByteModel(gparams.max_sym+1) // +1 as max value not num. values\n\n model.len = new Array(4)\n for (var i = 0; i < 4; i++)\n\tmodel.len[i] = new ByteModel(256)\n\n model.rev = new ByteModel(2)\n model.dup = new ByteModel(2)\n\n if (gparams.max_sel > 0)\n\tmodel.sel = new ByteModel(gparams.max_sel+1) // +1 as max value not num. values\n\n return model\n}\n\n// Initialise a new record, updating state.\n// Returns 1 if dup, otherwise 0\nfunction decode_fqz_new_record(src, rc, gparams, model, state, rev) {\n // Parameter selector\n if (gparams.max_sel > 0) {\n\tstate.s = model.sel.ModelDecode(src, rc)\n } else {\n\tstate.s = 0;\n }\n state.x = gparams.stab[state.s]\n\n var params = gparams.params[state.x]\n\n // Reset contexts at the start of each new record\n if (params.fixed_len >= 0) {\n\t// Not fixed or fixed but first record\n\tvar len = model.len[0].ModelDecode(src, rc)\n\tlen |= model.len[1].ModelDecode(src, rc) << 8\n\tlen |= model.len[2].ModelDecode(src, rc) << 16\n\tlen |= model.len[3].ModelDecode(src, rc) << 24\n\tif (params.fixed_len > 0)\n\t params.fixed_len = -len\n } else {\n\tlen = -params.fixed_len\n }\n state.len = len\n\n if (gparams.do_rev)\n\trev[state.rec] = model.rev.ModelDecode(src, rc)\n\n state.is_dup = 0\n if (params.pflags & FLAG_DEDUP) {\n\tif (model.dup.ModelDecode(src, rc))\n\t state.is_dup = 1\n }\n\n state.p = len; // number of remaining bytes in this record\n state.delta = 0\n state.qctx = 0\n state.prevq = 0\n state.rec++\n}\n\nfunction decode_fqz(src, q_lens) {\n // Decode parameter block\n var n_out = src.ReadUint7()\n var gparams = decode_fqz_params(src)\n if (!gparams) return\n var params = gparams.params\n var rev = new Array(q_lens.length)\n\n // Create initial models\n var model = fqz_create_models(gparams)\n\n // Create our entropy encoder and output buffers\n var rc = new RangeCoder(src)\n rc.RangeStartDecode(src)\n var output = new Buffer.allocUnsafe(n_out)\n\n // Internal FQZ state\n var state = {\n\tqctx:0, // Qual-only sub-context\n\tprevq:0, // Previous quality value\n\tdelta:0, // Running delta (q vs prevq)\n\tp:0, // Number of bases left in current record\n\ts:0, // Current parameter selector value (0 if unused)\n\tx:0, // \"stab\" tabulated copy of s\n\tlen:0, // Length of current string\n\tis_dup:0, // This string is a duplicate of last\n\trec:0 // Record number\n }\n\n // The main decode loop itself\n var i = 0 // position in output buffer\n while (i < n_out) {\n\tif (state.p == 0) {\n\t decode_fqz_new_record(src, rc, gparams, model, state, rev)\n\t if (state.is_dup > 0) {\n\t\tif (model.dup.ModelDecode(src, rc)) {\n\t\t // Duplicate of last line\n\t\t for (var x = 0; x < len; x++)\n\t\t\toutput[i+x] = output[i+x-state.len]\n\t\t i += state.len\n\t\t state.p = 0\n\t\t continue\n\t\t}\n\t }\n\t q_lens.push(state.len)\n\n\t var params = gparams.params[state.x]\n\t var last = params.context\n\t}\n\n\t// Decode the current quality (possibly mapped via qmap)\n\tvar Q = model.qual[last].ModelDecode(src, rc)\n\n\t//if (params.do_qmap)\n\t// output[i++] = params.qmap[Q];\n\t//else\n\t// output[i++] = Q\n\toutput[i++] = params.qmap[Q]; // optimised version of above\n\tlast = fqz_update_ctx(params, state, Q)\n }\n\n if (gparams.do_rev)\n\treverse_qualities(output, n_out, rev, q_lens)\n\n return output;\n}\n\nfunction reverse_qualities(qual, qual_len, rev, len) {\n var rec = 0\n var i = 0\n while (i < qual_len) {\n\tif (rev[rec]) {\n\t var j = 0\n\t var k = len[rec]-1\n\t while (j < k) {\n\t\tvar tmp = qual[i+j]\n\t\tqual[i+j] = qual[i+k]\n\t\tqual[i+k] = tmp\n\t\tj++\n\t\tk--\n\t }\n\t}\n\n\ti += len[rec++];\n }\n}\n\nfunction decode(src, q_lens) {\n var stream = new IOStream(src);\n\n //var n_out = stream.ReadUint32(); stream.ReadUint32(); // move to main\n\n return decode_fqz(stream, q_lens);\n}\n \n//----------------------------------------------------------------------\n// FQZComp encoder.\n\nfunction pick_fqz_params(src, q_lens, q_dirs, qhist) {\n // Find cardinality of q_dirs\n var qd_last = q_dirs[0];\n for (var i = 0; i < q_dirs.length; i++)\n\tif (q_dirs[i] != qd_last)\n\t break;\n var qd_fixed = (i == q_dirs.length) ? 1 : 0\n\n // Scan input to find number of symbols and max symbol\n var nsym = 0\n var max_sym = 0\n\n // selector == 0: Assume one single input dataset\n for (var i = 0; i < 256; i++)\n\tqhist[0][i] = 0;\n\n var rec = 0;\n var len = 0\n for (var i = 0; i < src.length; i++) {\n\tif (len == 0) {\n\t len = q_lens[rec < q_lens.length-1 ? rec++ : rec]\n\t}\n\tqhist[0][src[i]]++;\n\tlen--;\n }\n for (var i = 0; i < 256; i++) {\n\tif (!qhist[0][i])\n\t continue;\n\tif (max_sym < i)\n\t max_sym = i;\n\tnsym++;\n }\n\n var qshift = 5\n var do_qmap = 0\n // Reduced symbol frequencies implies lower qshift and\n // a lookup table to go from qual to Q\n if (nsym <= 16) {\n\tdo_qmap = 1 // based on qhist\n\tif (nsym <= 2)\n\t qshift = 1\n\telse if (nsym <= 4)\n\t qshift = 2\n\telse if (nsym <= 8)\n\t qshift = 3\n\telse\n\t qshift = 4\n }\n\n// // Two params and a 1-bit selector.\n// // This is 1% overhead vs two data sets compressed independently.\n// // It's 6.9% smaller than compressing both together with 1 param.\n// if (0) return [{\n//\t// q4\n//\tqbits: 8,\n//\tqshift: 2,\n//\tqloc: 7,\n//\n//\tpbits: 7,\n//\tpshift: 1,\n//\tploc: 0,\n//\n//\tdbits: 0,\n//\tdshift: 0,\n//\tdloc: 0,\n//\n// sbits: 0,\n// sloc: 0,\n//\n//\t//sbits: 2,\n//\t//do_stab: 1,\n//\tsbits: 1,\n//\tdo_stab: 0,\n//\tcontext: (0<<15),\n//\n//\tmax_sym: 36,\n//\tnsym: 4,\n//\n//\tdo_qmap: 1,\n//\tdo_dedup: 0,\n//\tfixed_len: 1,\n//\tdo_sel: 0,\n//\tdo_rev: 0,\n//\tdo_pos: 1,\n//\tdo_delta: 0,\n//\tdo_qtab: 0\n// }, {\n//\t//q40\n//\tqbits: 9,\n//\tqshift: 5,\n//\tqloc: 7,\n//\n//\tpbits: 7,\n//\tpshift: 0,\n//\tploc: 0,\n//\n//\tdbits: 0,\n//\tdshift: 0,\n//\tdloc: 0,\n//\n// sbits: 0,\n// sloc: 0,\n//\n//\t//sbits: 2,\n//\t//do_stab: 1,\n//\tsbits: 1,\n//\tdo_stab: 0,\n//\tcontext: (1<<15),\n//\n//\tmax_sym: 44,\n//\tnsym: 45,\n//\n//\tdo_qmap: 0,\n//\tdo_dedup: 0,\n//\tfixed_len: 1,\n//\tdo_sel: 0,\n//\tdo_rev: 0,\n//\tdo_pos: 1,\n//\tdo_delta: 0,\n//\tdo_qtab: 0\n// }]\n\n return [{qbits: 8+(qshift>4),\n\t qshift: qshift,\n\t qloc: 7,\n\n\t pbits: 7,\n\t pshift: q_lens[0] > 128 ? 1 : 0,\n\t ploc: 0,\n\n\t dbits: qshift>4 ? 0 : 1,\n\t dshift: 3,\n\t dloc: 15,\n\n\n\t // NB: Also useful as a way of embedding sel and doing sel\n\t // specific contexts. Identical bar context. Eg 0<<15 or 1<<15.\n\t sbits: 0,\n\t sloc: 15,\n\t do_stab: 0,\n\t context: (0<<15),\n\n\t max_sym: max_sym,\n\t nsym: nsym,\n\n\t do_qmap: do_qmap,\n\t do_dedup: 0,\n\t fixed_len: (q_lens.length == 1) ? 1 : 0,\n\t do_sel: 0,\n\t do_rev: 0,\n\t do_pos: 1,\n\t do_delta: (qshift <= 4) ? 1 : 0,\n\t do_qtab: 0,\n\n\t // Override above with some attempt at using selectors\n\t // when the q_dirs are specific and non-fixed.\n\t qbits: 8+(qshift>4)-(qd_fixed==0),\n\t sbits: 1,\n\t sloc: 15-(qshift<=4), // read1 vs read2\n\t do_stab: 1,\n\t do_sel: 1,\n\t \n//\t // q4+dir: 7245769 with, 7353962 without. 1.5% saving\n//\t qbits: 6,\n//\t dbits: 2,\n//\t dshift: 2,\n//\t dloc: 13,\n//\t sbits: 1,\n//\t sloc: 15,\n//\t do_stab: 1,\n//\t do_sel: 1,\n\n\t // with 20 bits of context, q40 = 31741545\n\t // qbits 10, dbits 2, pbits 7, sbits 1\n\t }]\n}\n\nfunction store_array(out, tab, size) {\n var i = 0; // index into tab\n var j = 0; // current value in tab[i]\n\n var tmp1 = new Array(size*2);\n var sz1 = 0;\n\n // First level of RLE. Replace all runs of 'j' values\n // with run-lengths, including zeros for missing values.\n // Eg 0 1 2 2 2 3 3 3 4 4 4 5 5 5 5 7 7\n // to 1 1 3 3 3 4 0 2\n while (i < size) {\n\t// Length of j^{th} element\n\tvar i_start = i\n\twhile (i < size && tab[i] == j)\n\t i++;\n\tvar run_len = i - i_start\n\n\t// Encode run length to tmp array\n\tdo {\n\t var r = Math.min(255, run_len)\n\t tmp1[sz1++] = r\n\t run_len -= r\n\t} while (r == 255)\n\tj++;\n }\n\n // Second round of RLE on our tmp array, using a different\n // RLE algorithm.\n // Eg 1 1 3 3 3 4 0 2\n // to 1 1 +0 3 3 +1 4 0 2\n var last = -1\n var tmp2 = new Array(size*2)\n var sz2 = 0\n i = 0 // index into tmp1]\n // k is used size of tmp1[]\n while (i < sz1) {\n\tvar curr = tmp1[i++];\n\ttmp2[sz2++] = curr\n\tif (curr == last) {\n\t var i_start = i;\n\t while (i < sz1 && tmp1[i] == last && i - i_start < 255)\n\t\ti++;\n\t tmp2[sz2++] = i - i_start;\n\t} else {\n\t last = curr\n\t}\n }\n\n // Append 2nd RLE, tmp2, to out.\n out.WriteData(tmp2, sz2)\n}\n\n\t\t\t\t \n\n// q_lens is an array of quality lengths per record.\n// (If they're all the same, just set one value.)\nfunction encode_fqz_params(out, params, qhist, qtab, ptab, dtab, stab) {\n var dsqr = [\n 0, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3,\n 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5,\n 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7\n ]\n\n for (var i = 0; i < params.length; i++)\n\tstab[i] = i; // 1 parameter set per selector value\n for (; i < 256; i++)\n\tstab[i] = params.length-1;\n\n // Store global meta-data\n out.WriteByte(5); // FQZ format number\n var gflags = ((params.length > 1) ? GFLAG_MULTI_PARAM : 0)\n\t | ((params[0].do_stab) ? GFLAG_HAVE_STAB : 0)\n out.WriteByte(gflags)\n\n if (gflags & GFLAG_MULTI_PARAM)\n\tout.WriteByte(params.length) // Number of parameter blocks.\n\n if (gflags & GFLAG_HAVE_STAB) {\n\tvar max_sel = 1<<params[0].sbits;\n\tif (max_sel > 0) max_sel--;\n\tout.WriteByte(max_sel)\n\tstore_array(out, stab, 256)\n }\n\n // Store per-param meta-data\n for (var p = 0; p < params.length; p++) {\n\tout.WriteUint16(params[p].context)\n\tout.WriteByte((params[p].do_qtab ? FLAG_QTAB : 0) | // FLAG\n\t\t (params[p].do_delta ? FLAG_DTAB : 0) |\n\t\t (params[p].do_pos ? FLAG_PTAB : 0) |\n\t\t (params[p].do_qmap ? FLAG_QMAP : 0) |\n\t\t (params[p].do_sel ? FLAG_SEL : 0) |\n\t\t (params[p].fixed_len? FLAG_FLEN : 0) |\n\t\t (params[p].do_dedup ? FLAG_DEDUP : 0))\n\tif (params[p].do_qmap)\n\t out.WriteByte(params[p].nsym)\n\telse\n\t out.WriteByte(params[p].max_sym)\n\tout.WriteByte((params[p].qbits << 4) | (params[p].qshift))\n\tout.WriteByte((params[p].qloc << 4) | (params[p].sloc))\n\tout.WriteByte((params[p].ploc << 4) | (params[p].dloc))\n\n\tif (params[p].do_qmap) {\n\t params[p].max_sym = params[p].nsym\n\t var n = 0;\n\t for (var i = 0; i < 256; i++) {\n\t\tif (qhist[p][i]) {\n\t\t out.WriteByte(i)\n\t\t qhist[p][i] = n++;\n\t\t}\n\t }\n\t // Ensure we have all matched input params\n\t for (; n < params[p].nsym; n++)\n\t\tout.WriteByte(0)\n\t} else {\n\t //params[p].nsym = 255;\n\t for (var i = 0; i < 256; i++)\n\t\tqhist[p][i] = i; // NOP\n\t}\n\n\tif (params[p].qbits > 0) {\n\t //\t// Eg map 0-44 to a smaller range, to improve context usage.\n\t //\t// Makes q40 test set go from 33596471 to 33450075 (-0.4%)\n\t //\tparams[p].do_qtab = 1;\n\t //\tfor (var j = i = 0; i < params[p].max_sym; i++) {\n\t //\t qtab[i]=j;\n\t //\t if ((i%3)!=0 | i >= 28) j++\n\t //\t console.log(\"qtab[\",i,\"]=\",qtab[i]);\n\t //\t}\n\t //\tfor (; i < 256; i++)\n\t //\t qtab[i] = qtab[params[p].max_sym-1]\n\n\t for (var i = 0; i < 256; i++)\n\t\tqtab[p][i] = i; // NOP for now\n\n\t if (params[p].do_qtab)\n\t\tstore_array(out, qtab[p], 256)\n\t}\n\n\tif (params[p].pbits > 0) {\n\t for (var i = 0; i < 1024; i++)\n\t\tptab[p][i] = Math.min((1<<params[p].pbits)-1, i >> params[p].pshift)\n\n\t store_array(out, ptab[p], 1024)\n\t}\n\n\tif (params[p].dbits > 0) {\n\t for (var i = 0; i < 256; i++)\n\t\tif (dsqr[i] > (1<<params[p].dbits) - 1)\n\t\t dsqr[i] = (1<<params[p].dbits) - 1\n\t for (var i = 0; i < 256; i++)\n\t\tdtab[p][i] = dsqr[Math.min(dsqr.length-1, i >> params[p].dshift)]\n\n\t store_array(out, dtab[p], 256)\n\t}\n }\n\n return out\n}\n\nfunction encode_fqz(out, src, q_lens, q_dirs, params, qhist, qtab, ptab, dtab, stab) {\n //console.error(\"0:\",params[0])\n //console.error(\"1:\",params[1])\n\n var max_sel = 1<<params[0].sbits\n if (max_sel > 0) max_sel--\n var n_in = src.length\n\n // Create the models\n var max_sym = 0;\n for (var p = 0; p < params.length; p++)\n\tif (max_sym < params[p].max_sym)\n\t max_sym = params[p].max_sym;\n\n var model_qual = new Array(1<<16)\n for (var i = 0; i < (1<<16); i++)\n\tmodel_qual[i] = new ByteModel(max_sym+1)\n\n var model_len = new Array(4)\n for (var i = 0; i < 4; i++)\n\tmodel_len[i] = new ByteModel(256)\n\n var model_rev = new ByteModel(2)\n var model_dup = new ByteModel(2)\n var model_sel = new ByteModel(max_sel+1)\n\n // Note: our JavaScript encoder doesn't have a way for reversing\n // some quality strings, so we ignore do_rev for now.\n var rc = new RangeCoder(src)\n\n // The main encoding loop\n var p = 0; // remaining position along current record\n var i = 0; // index in src data\n var rec = 0;\n\n while (i < n_in) {\n\tif (p == 0) {\n\t //var s = 0 // single non-mixed sample\n\t var s = q_dirs[rec]\n\t if (params[0].sbits > 0) {// FIXME: check All params[].do_stab / sbits must be identical\n\t\t//console.log(\"Ssel\", s)\n\t model_sel.ModelEncode(out, rc, s)\n\t }\n\t var x = stab[s]\n\n\t // Reset contexts at the statr of each new record\n\t var len = q_lens[Math.min(q_lens.length-1, rec++)]\n\t if (params[x].fixed_len) {\n\t\tif (params[x].fixed_len > 0) { // First length\n\t\t //console.log(\"Len\", len)\n\t\t model_len[0].ModelEncode(out, rc, len & 0xff)\n\t\t model_len[1].ModelEncode(out, rc, (len>>8) & 0xff)\n\t\t model_len[2].ModelEncode(out, rc, (len>>16) & 0xff)\n\t\t model_len[3].ModelEncode(out, rc, (len>>24) & 0xff)\n\t\t params[x].fixed_len = -1; // indicate we've stored it once\n\t\t}\n\t } else {\n\t\t//console.log(\"len\", len)\n\t\tmodel_len[0].ModelEncode(out, rc, len & 0xff)\n\t\tmodel_len[1].ModelEncode(out, rc, (len>>8) & 0xff)\n\t\tmodel_len[2].ModelEncode(out, rc, (len>>16) & 0xff)\n\t\tmodel_len[3].ModelEncode(out, rc, (len>>24) & 0xff)\n\t }\n\n\t if (params[x].do_dedup)\n\t\tprocess.exit(1) // FIXME\n\n\t p = len\n\t var delta = 0\n\t //var last = 0\n\t var last = params[x].context\n\t var qlast = 0\n\t var q1 = 0\n\t}\n\n\t// Encode current quality\n\tvar q = src[i++]\n\tvar Q = qhist[x][q]\n\tmodel_qual[last].ModelEncode(out, rc, Q)\n\t//console.log(\"Ctx\",last,qhist[x][q])\n\n\t// Update contexts for next quality\n\tqlast = (qlast << params[x].qshift) + qtab[x][Q]\n\tlast = params[x].context\n\tlast += (qlast & ((1<<params[x].qbits)-1)) << params[x].qloc\n\n\t// 46.6-48.6 billion cycles with ifs + \"<< params[x].?loc\" shifts\n\t// 47.3-47.3 billion cycles with ifs\n\t// 47.1-47.9 billion cycles without ifs\n\tif (params[x].pbits > 0)\n\t last += ptab[x][Math.min(p, 1023)] << params[x].ploc\n\n\tif (params[x].dbits > 0) {\n\t last += dtab[x][Math.min(delta, 255)] << params[x].dloc\n\t delta += (q1 != Q) ? 1 : 0\n\t q1 = Q\n\t}\n\n\tif (params[x].do_sel)\n\t last += s << params[x].sloc\n\n\tlast = (last & 0xffff)\n\tp--\n }\n\n rc.RangeFinishEncode(out)\n return out.buf.slice(0, out.pos)\n}\n\nfunction encode(src, q_lens, q_dirs) {\n var qhist = new Array(2)\n var qtab = new Array(2)\n var ptab = new Array(2)\n var dtab = new Array(2)\n var stab = new Array(256)\n\n for (var s = 0; s < 2; s++) {\n qhist[s] = new Array(256)\n qtab[s] = new Array(256)\n ptab[s] = new Array(1024) \n dtab[s] = new Array(256)\n }\n\n var out = new IOStream(\"\", 0, src.length*1.1 + 100); // FIXME: guestimate worst case\n\n out.WriteUint7(src.length);\n var params = pick_fqz_params(src, q_lens, q_dirs, qhist)\n var out = encode_fqz_params(out, params, qhist, qtab, ptab, dtab, stab)\n return encode_fqz(out, src, q_lens, q_dirs, params, qhist, qtab, ptab, dtab, stab)\n}\n\nmodule.exports = { decode, encode }\n","/*\n * Copyright (c) 2020 Genome Research Ltd.\n * Author(s): James Bonfield\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * 1. Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n *\n * 3. Neither the names Genome Research Ltd and Wellcome Trust Sanger\n * Institute nor the names of its contributors may be used to endorse\n * or promote products derived from this software without specific\n * prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS \"AS\n * IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\n * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH\n * LTD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n// This is an interface to the htscodecs reference implementation of\n// the CRAM 3.1 codecs.\n\n// This JavaScript file is not part of the reference implementation\n// and is simply and interface to get a consistent interface for cram-js.\n\n\"use strict\";\n\nvar r4x8 = require('./rans');\nvar r4x16 = require('./rans4x16');\nvar arith = require('./arith_gen');\nvar fqzcomp = require('./fqzcomp');\nvar tok3 = require('./tok3');\n\nfunction r4x8_uncompress(inputBuffer, outputBuffer) {\n r4x8.decode(inputBuffer).copy(outputBuffer, 0, 0);\n}\n\nfunction r4x16_uncompress(inputBuffer, outputBuffer) {\n r4x16.decode(inputBuffer).copy(outputBuffer, 0, 0);\n}\n\nfunction arith_uncompress(inputBuffer, outputBuffer) {\n arith.decode(inputBuffer).copy(outputBuffer, 0, 0);\n}\n\nfunction fqzcomp_uncompress(inputBuffer, outputBuffer) {\n var q_lens = new Array\n fqzcomp.decode(inputBuffer, q_lens).copy(outputBuffer, 0, 0);\n}\n\nfunction tok3_uncompress(inputBuffer, outputBuffer) {\n // Returns in string form instead of buffer\n var out = tok3.decode(inputBuffer, 0, '\\0');\n Buffer.from(out, 'binary').copy(outputBuffer, 0, 0);\n}\n\nmodule.exports = {\n r4x8_uncompress: r4x8_uncompress,\n r4x16_uncompress: r4x16_uncompress,\n arith_uncompress: arith_uncompress,\n fqzcomp_uncompress: fqzcomp_uncompress,\n tok3_uncompress: tok3_uncompress,\n};\n","/*\n * Copyright (c) 2019 Genome Research Ltd.\n * Author(s): James Bonfield\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * 1. Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n *\n * 3. Neither the names Genome Research Ltd and Wellcome Trust Sanger\n * Institute nor the names of its contributors may be used to endorse\n * or promote products derived from this software without specific\n * prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS \"AS\n * IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\n * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH\n * LTD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n// Turn a buffer into a fake stream with get / put commands.\n// This enables up to closely match the published pseudocode.\nmodule.exports = class IOStream {\n constructor(buf, start_pos = 0, size = 0) {\n\tif (size != 0) {\n\t this.buf = Buffer.allocUnsafe(size)\n\t this.length = size\n\t} else {\n\t this.buf = buf\n\t this.length = buf.length\n\t}\n\tthis.pos = start_pos\n }\n\n // ----------\n // Reading\n EOF() {\n\treturn this.pos >= this.length\n }\n\n ReadData(len) {\n\tvar A = this.buf.slice(this.pos, this.pos+len)\n\tthis.pos += len;\n\treturn A\n }\n\n ReadByte() {\n\tconst b = this.buf[this.pos]\n\tthis.pos++\n\treturn b\n }\n\n ReadChar() {\n\tconst b = this.buf[this.pos]\n\tthis.pos++\n\treturn String.fromCharCode(b)\n }\n\n ReadUint16() {\n\tvar i = this.ReadByte()\n\ti |= this.ReadByte()<<8\n\treturn i\n }\n\n ReadUint32() {\n\tconst i = this.buf.readInt32LE(this.pos)\n\tthis.pos += 4\n\treturn i\n }\n\n // nul terminated string\n ReadString() {\n\tvar s = \"\"\n\tdo {\n\t var b = this.buf[this.pos++]\n\t if (b)\n\t\ts += String.fromCharCode(b)\n\t} while (b)\n\treturn s\n }\n\n// ReadUint7() {\n//\t// Variable sized unsigned integers\n//\tvar i = 0;\n//\tvar s = 0;\n//\tdo {\n//\t var c = this.ReadByte();\n//\t i = i | ((c & 0x7f)<<s);\n//\t s += 7;\n//\t} while ((c & 0x80))\n//\n//\treturn i;\n// }\n\n ReadUint7() {\n\t// Variable sized unsigned integers\n\tvar i = 0;\n\tdo {\n\t var c = this.ReadByte();\n\t i = (i<<7) | (c & 0x7f)\n\t} while ((c & 0x80))\n\n\treturn i;\n }\n\n ReadITF8() {\n\tvar i = this.buf[this.pos];\n\tthis.pos++;\n\n\t//process.stderr.write(\"i=\"+i+\"\\n\");\n\n\tif (i >= 0xf0) {\n\t // 1111xxxx => +4 bytes\n\t i = (i & 0x0f) << 28;\n\t i += (this.buf[this.pos+0] << 20)\n\t + (this.buf[this.pos+1] << 12)\n\t + (this.buf[this.pos+2] << 4)\n\t + (this.buf[this.pos+3] >> 4);\n\t this.pos += 4;\n\t //process.stderr.write(\" 4i=\"+i+\"\\n\");\n\t} else if (i >= 0xe0) {\n\t // 1110xxxx => +3 bytes\n\t i = (i & 0x0f) << 24;\n\t i += (this.buf[this.pos+0] << 16)\n\t + (this.buf[this.pos+1] << 8)\n\t + (this.buf[this.pos+2] << 0);\n\t this.pos += 3;\n\t //process.stderr.write(\" 3i=\"+i+\"\\n\");\n\t} else if (i >= 0xc0) {\n\t // 110xxxxx => +2 bytes\n\t i = (i & 0x1f) << 16;\n\t i += (this.buf[this.pos+0] << 8)\n\t + (this.buf[this.pos+1] << 0);\n\t this.pos += 2;\n\t //process.stderr.write(\" 2i=\"+i+\"\\n\");\n\t} else if (i >= 0x80) {\n\t // 10xxxxxx => +1 bytes\n\t i = (i & 0x3f) << 8;\n\t i += this.buf[this.pos];\n\t this.pos++;;\n\t //process.stderr.write(\" 1i=\"+i+\"\\n\");\n\t} else {\n\t // 0xxxxxxx => +0 bytes\n\t}\n\n\treturn i;\n }\n\n // ----------\n // Writing\n WriteByte(b) {\n\tthis.buf[this.pos++] = b\n }\n\n WriteChar(b) {\n\tthis.buf[this.pos++] = b.charCodeAt(0)\n }\n\n WriteString(str) {\n\tfor (var i = 0; i < str.length; i++)\n\t this.buf[this.pos++] = str.charCodeAt(i)\n\tthis.buf[this.pos++] = 0\n }\n\n WriteData(buf, len) {\n\tfor (var i = 0; i < len; i++)\n\t this.buf[this.pos++] = buf[i]\n }\n\n WriteStream(stream) {\n\tthis.WriteData(stream.buf, stream.pos)\n }\n\n WriteUint16(u) {\n\t//this.buf.writeInt16LE(u, this.pos);\n\tthis.WriteByte(u&0xff)\n\tthis.WriteByte((u>>8)&0xff)\n }\n\n WriteUint32(u) {\n\tthis.buf.writeInt32LE(u, this.pos);\n\tthis.pos += 4;\n }\n\n// WriteUint7(i) {\n//\tdo {\n//\t this.WriteByte((i & 0x7f) | ((i > 0x80) << 7));\n//\t i >>= 7;\n//\t} while (i > 0);\n// }\n\n WriteUint7(i) {\n\tvar s = 0;\n\tvar X = i;\n\tdo {\n\t s += 7;\n\t X >>= 7;\n\t} while (X > 0);\n\n\tdo {\n\t s -= 7;\n\t this.WriteByte(((i >> s) & 0x7f) + ((s > 0) << 7))\n\t} while (s > 0);\n }\n\n WriteITF8(i) {\n\t// Horrid, ITF8 is unsigned, but we still write signed into it\n\tif (i < 0)\n\t i = (1<<32) + i\n\n\tif (i <= 0x0000007f) {\n\t // 1 byte\n\t this.buf[this.pos++] = i\n\t} else if (i <= 0x00003fff) {\n\t // 2 bytes\n\t this.buf[this.pos++] = 0x80 | Math.floor(i / 256)\n\t this.buf[this.pos++] = i & 0xff;\n\t} else if (i < 0x0001ffff) {\n\t // 3 bytes\n\t this.buf[this.pos++] = 0xc0 | Math.floor(i / 65536)\n\t this.buf[this.pos++] = Math.floor(i / 256) & 0xff\n\t this.buf[this.pos++] = i & 0xff;\n\t} else if (i < 0x0fffffff) {\n\t // 4 bytes\n\t this.buf[this.pos++] = 0xe0 | Math.floor(i / 16777216)\n\t this.buf[this.pos++] = Math.floor(i / 65536) & 0xff\n\t this.buf[this.pos++] = Math.floor(i / 256) & 0xff\n\t this.buf[this.pos++] = i & 0xff;\n\t} else {\n\t // 5 bytes; oddly using 4.5 bytes\n\t this.buf[this.pos++] = 0xf0 | Math.floor(i / 268435456)\n\t this.buf[this.pos++] = Math.floor(i / 1048576) & 0xff\n\t this.buf[this.pos++] = Math.floor(i / 4096) & 0xff\n\t this.buf[this.pos++] = Math.floor(i / 4) & 0xff\n\t this.buf[this.pos++] = i & 0x0f;\n\t}\n }\n\n // ----------\n // Writing from end of buffer going backwards.\n // Needed by rANS codec.\n WriteByteNeg(b) {\n\tthis.buf[--this.pos] = b;\n }\n};\n","/*\n * Copyright (c) 2019-2020 Genome Research Ltd.\n * Author(s): James Bonfield\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * 1. Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n *\n * 3. Neither the names Genome Research Ltd and Wellcome Trust Sanger\n * Institute nor the names of its contributors may be used to endorse\n * or promote products derived from this software without specific\n * prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS \"AS\n * IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\n * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH\n * LTD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nconst IOStream = require(\"./iostream\");\n\n//----------------------------------------------------------------------\n// rANS primitives itself\n//\n// RansGet* is decoder side\n\nfunction RansGetCumulativeFreq(R) {\n return R & 0xfff;\n}\n\nfunction RansGetSymbolFromFreq(C, f) {\n // NOTE: Inefficient.\n // In practice we would implement this via a precomputed\n // lookup table C2S[f]; see RansBuildC2S below.\n var s = 0;\n while (f >= C[s+1])\n\ts++;\n\n return s;\n}\n\nfunction RansBuildC2S(C) {\n var C2S = new Array(0x1000);\n var s = 0;\n for (var f = 0; f < 0x1000; f++) {\n\twhile (f >= C[s+1])\n\t s++;\n\tC2S[f] = s;\n }\n return C2S;\n}\n\nfunction RansAdvanceStep(R, c, f) {\n return f * (R >> 12) + (R & 0xfff) - c;\n}\n\nfunction RansRenorm(src, R) {\n while (R < (1<<23))\n\tR = (R << 8) + src.ReadByte();\n\n return R;\n}\n\n\n// RanEnc* is for encoder\nfunction RansEncInit() {\n return 1<<23;\n}\n\nfunction RansEncFlush(R, dst) {\n dst.WriteByteNeg((R >> 24) & 0xff);\n dst.WriteByteNeg((R >> 16) & 0xff);\n dst.WriteByteNeg((R >> 8) & 0xff);\n dst.WriteByteNeg((R >> 0) & 0xff);\n}\n\nfunction RansEncRenorm(R, dst, freq, scale_bits) {\n var R_max = (((1 << 23) >> scale_bits) << 8) * freq;\n\n while (R >= R_max) {\n\tdst.WriteByteNeg(R & 0xff);\n\tR >>= 8;\n }\n return R;\n}\n\n// Puts a symbol with frequency freq, cumulative freq start\n// and total freq 1<<scale_bits.\n//\n// Note with static probabilities, /freq and %freq could be\n// precomputed via multiplies and shifts.\nfunction RansEncPut(R, dst, start, freq, scale_bits) {\n var scale = 1<<scale_bits;\n R = RansEncRenorm(R, dst, freq, scale_bits);\n R = (Math.floor(R / freq) << scale_bits) + (R % freq) + start;\n return R;\n}\n\n//----------------------------------------------------------------------\n// Main rANS entry function: decodes a compressed src and\n// returns the uncompressed buffer.\nfunction decode(src) {\n var stream = new IOStream(src);\n var order = stream.ReadByte();\n var n_in = stream.ReadUint32();\n var n_out = stream.ReadUint32();\n\n if (order == 0) {\n\treturn RansDecode0(stream, n_out)\n } else {\n\treturn RansDecode1(stream, n_out)\n }\n}\n\nfunction encode(src, order) {\n //var stream = new IOStream(src);\n //var n_in = stream.ReadUint32();\n //var n_out = stream.ReadUint32();\n\n if (order == 0) {\n\treturn RansEncode0(src)\n } else {\n\treturn RansEncode1(src)\n }\n}\n\n//----------------------------------------------------------------------\n// Order-0 decoder\n\n// Decode a single table of order-0 frequences,\n// filling out the F and C arrays.\nfunction ReadFrequencies0(src, F, C) {\n // Initialise; not in the specification - implicit?\n for (var i = 0; i < 256; i++)\n\tF[i] = 0;\n\n var sym = src.ReadByte();\n var last_sym = sym;\n var rle = 0;\n\n // Read F[]\n do {\n\tvar f = src.ReadITF8();\n\tF[sym] = f;\n\tif (rle > 0) {\n\t rle--;\n\t sym++;\n\t} else {\n\t sym = src.ReadByte();\n\t if (sym == last_sym+1)\n\t\trle = src.ReadByte();\n\t}\n\tlast_sym = sym;\n } while (sym != 0);\n\n // Compute C[] from F[]\n C[0] = 0;\n for (var i = 0; i <= 255; i++)\n\tC[i+1] = C[i] + F[i];\n}\n\nfunction RansDecode0(src, nbytes) {\n // Decode frequencies\n var F = new Array(256);\n var C = new Array(256);\n ReadFrequencies0(src, F, C);\n\n // Fast lookup to avoid slow RansGetSymbolFromFreq\n var C2S = RansBuildC2S(C);\n\n // Initialise rANS state\n var R = new Array(4);\n for (var i = 0; i < 4; i++)\n\tR[i] = src.ReadUint32();\n\n // Main decode loop\n var output = new Buffer.allocUnsafe(nbytes);\n for (var i = 0; i < nbytes; i++) {\n\tvar i4 = i%4;\n\tvar f = RansGetCumulativeFreq(R[i4]);\n\tvar s = C2S[f]; // Equiv to RansGetSymbolFromFreq(C, f);\n\n\toutput[i] = s;\n\tR[i4] = RansAdvanceStep(R[i4], C[s], F[s]);\n\tR[i4] = RansRenorm(src, R[i4]);\n }\n\n return output;\n}\n\n//----------------------------------------------------------------------\n// Order-0 encoder\n\nfunction BuildFrequencies0(src, F) {\n for (var i = 0; i < 256; i++)\n\tF[i] = 0;\n\n for (var i = 0; i < src.length; i++)\n\tF[src[i]]++;\n}\n\nfunction NormaliseFrequencies0(F) {\n // Compute total\n var tot = 0;\n for (var i = 0; i < 256; i++)\n\ttot += F[i];\n\n // Scale total of frequencies to max\n const max = (1<<12);\n var scale = max / tot;\n do {\n\tvar max_val = 0;\n\tvar max_idx = 0;\n\tvar renorm = 0;\n\ttot = 0;\n\tfor (var i = 0; i < 256; i++) {\n\t if (F[i] == 0)\n\t\tcontinue\n\n\t if (max_val < F[i]) {\n\t\tmax_val = F[i]\n\t\tmax_idx = i\n\t }\n\n\t F[i] = Math.floor(F[i] * scale);\n\t if (F[i] == 0)\n\t\tF[i] = 1;\n\n\t tot += F[i];\n\t}\n\n\t// Adjust new tot to ensure it matches.\n\tif (tot < max) {\n\t // Too low, boost the most common symbol\n\t F[max_idx] += max-tot;\n\t} else if (tot-max < F[max_idx]/2 && F[max_idx] > 2) {\n\t // Too high, reduce the common symbol\n\t F[max_idx] -= tot-max;\n\t} else if (tot != max) {\n\t // Much too high, fudge scale and try again.\n\t scale = scale * 0.99\n\t renorm = 1;\n\t}\n } while (renorm)\n}\n\nfunction WriteFrequencies0(out, F) {\n var rle = 0;\n for (var i = 0; i < 256; i++) {\n\tif (!F[i])\n\t continue\n\n\t// Output Symbol if needed and Frequency\n\tif (rle > 0)\n\t rle--\n\telse {\n\t out.WriteByte(i)\n\n\t if (i > 0 && F[i-1] > 0) {\n\t\t// We've encoded two symbol frequencies in a row.\n\t\t// How many more are there? Store that count so\n\t\t// we can avoid writing consecutive symbols.\n\t\tfor (rle = i+1; rle<256 && F[rle]; rle++)\n\t\t ;\n\t\trle -= i+1;\n\n\t\tout.WriteByte(rle);\n\t }\n\t}\n\n\tout.WriteITF8(F[i])\n }\n out.WriteByte(0);\n}\n\nfunction RansEncode0(src) {\n const nbytes = src.length\n var output = new IOStream(\"\", 0, 257*3+9);\n\n output.WriteByte(0); // Order 0\n output.WriteUint32(0); // compressed size: correct later\n output.WriteUint32(0); // uncompressed size: correct later\n\n // Compute frequencies\n var F = new Array(256)\n BuildFrequencies0(src, F)\n NormaliseFrequencies0(F);\n WriteFrequencies0(output, F);\n\n // Compute cumulative frequencies\n var C = new Array(256)\n C[0] = 0;\n for (var i = 1; i < 256; i++)\n\tC[i] = C[i-1] + F[i-1];\n\n // Initialise rANS state\n var R = new Array(4);\n for (var i = 0; i < 4; i++)\n\tR[i] = RansEncInit();\n\n var alloc = Math.floor(nbytes*1.05+100)\n var rans_out = new IOStream(\"\", alloc, alloc)\n\n // Main encode loop\n for (var i = nbytes-1; i >= 0; i--)\n\tR[i%4] = RansEncPut(R[i%4], rans_out, C[src[i]], F[src[i]], 12);\n\n for (var i = 3; i >= 0; i--)\n\tRansEncFlush(R[i], rans_out);\n\n // Stitch blocks together into final output buffer\n var freq_tab = output.pos\n output.buf.writeInt32LE(freq_tab-9 + (rans_out.length - rans_out.pos), 1);\n output.buf.writeInt32LE(nbytes, 5);\n\n return Buffer.concat([output.buf.slice(0, output.pos),\n\t\t\t rans_out.buf.slice(rans_out.pos, rans_out.length)],\n\t\t\t output.pos + rans_out.length - rans_out.pos);\n}\n\n//----------------------------------------------------------------------\n// Order-1 decoder\n\n// Decode a table of order-1 frequences,\n// filling out the F and C arrays.\nfunction ReadFrequencies1(src, F, C) {\n // Initialise; not in the specification - implicit?\n for (var i = 0; i < 256; i++) {\n\tF[i] = new Array(256);\n\tC[i] = new Array(256);\n\tfor (var j = 0; j < 256; j++)\n\t F[i][j] = 0;\n }\n\n var sym = src.ReadByte();\n var last_sym = sym;\n var rle = 0;\n\n // Read F[]\n do {\n\tReadFrequencies0(src, F[sym], C[sym]);\n\n\tif (rle > 0) {\n\t rle--;\n\t sym++;\n\t} else {\n\t sym = src.ReadByte();\n\t if (sym == last_sym+1)\n\t\trle = src.ReadByte();\n\t}\n\tlast_sym = sym;\n } while (sym != 0);\n}\n\nfunction RansDecode1(src, nbytes) {\n // Decode frequencies\n var F = new Array(256);\n var C = new Array(256);\n ReadFrequencies1(src, F, C);\n\n // Fast lookup to avoid slow RansGetSymbolFromFreq\n var C2S = new Array(256);\n for (var i = 0; i < 256; i++)\n\tC2S[i] = RansBuildC2S(C[i]);\n\n // Initialise rANS state\n var R = new Array(4);\n var L = new Array(4);\n for (var j = 0; j < 4; j++) {\n\tR[j] = src.ReadUint32();\n\tL[j] = 0;\n }\n\n // Main decode loop\n var output = new Buffer.allocUnsafe(nbytes);\n var nbytes4 = Math.floor(nbytes/4);\n for (var i = 0; i < nbytes4; i++) {\n\tfor (var j = 0; j < 4; j++) {\n\t var f = RansGetCumulativeFreq(R[j]);\n\n\t //var s = RansGetSymbolFromFreq(C[L[j]], f);\n\t var s = C2S[L[j]][f]; // Precomputed version of above\n\n\t output[i+j*nbytes4] = s;\n\t R[j] = RansAdvanceStep(R[j], C[L[j]][s], F[L[j]][s]);\n\t R[j] = RansRenorm(src, R[j]);\n\t L[j] = s;\n\t}\n }\n\n // Now deal with the remainder if buffer size is not a multiple of 4,\n // using rANS state 3 exclusively. (It'd have been nice to have\n // designed this to just act as if we kept going with a bail out.)\n i = 4*i;\n while (i < nbytes) {\n\tvar f = RansGetCumulativeFreq(R[3]);\n\tvar s = RansGetSymbolFromFreq(C[L[3]], f);\n\toutput[i++] = s;\n\tR[3] = RansAdvanceStep(R[3], C[L[3]][s], F[L[3]][s]);\n\tR[3] = RansRenorm(src, R[3]);\n\tL[3] = s;\n }\n\n return output;\n}\n\n//----------------------------------------------------------------------\n// Order-1 encoder\n\nfunction BuildFrequencies1(src, F, F0) {\n for (var i = 0; i < 256; i++) {\n\tF0[i] = 0;\n\tfor (var j = 0; j < 256; j++)\n\t F[i][j] = 0;\n }\n\n var last = 0;\n for (var i = 0; i < src.length; i++) {\n\tF0[src[i]]++;\n\tF[last][src[i]]++;\n\t//F[last][src[i]]++;\n\tlast = src[i];\n }\n\n // Also accept we'll be starting at 4 points, not just byte 0\n F[0][src[1*(src.length >> 2)]]++;\n F[0][src[2*(src.length >> 2)]]++;\n F[0][src[3*(src.length >> 2)]]++;\n F0[0] += 3;\n}\n\nfunction NormaliseFrequencies1(F, F0) {\n for (var i = 0; i < 256; i++)\n\tif (F0[i])\n\t NormaliseFrequencies0(F[i])\n}\n\nfunction WriteFrequencies1(out, F, F0) {\n var rle = 0;\n var last_sym = 0;\n\n for (var i = 0; i < 256; i++) {\n\tif (!F0[i])\n\t continue\n\n\t// Output Symbol if needed and Frequency\n\tif (rle > 0)\n\t rle--\n\telse {\n\t out.WriteByte(i)\n\n\t if (i > 0 && F0[i-1] > 0) {\n\t\tfor (rle = i+1; rle<256 && F0[rle]; rle++)\n\t\t ;\n\t\trle -= i+1;\n\t\tout.WriteByte(rle);\n\t }\n\t}\n\n\tWriteFrequencies0(out, F[i]);\n }\n out.WriteByte(0);\n}\n\nfunction RansEncode1(src) {\n const nbytes = src.length;\n var output = new IOStream(\"\", 0, 257*257*3+9);\n\n output.WriteByte(1); // Order 0\n output.WriteUint32(0); // compressed size: correct later\n output.WriteUint32(0); // uncompressed size: correct later\n\n // Compute frequencies\n var F0 = new Array(256)\n var F = new Array(256)\n var C = new Array(256)\n for (var i = 0; i < 256; i++) {\n\tF[i] = new Array(256);\n\tC[i] = new Array(256);\n }\n\n BuildFrequencies1(src, F, F0)\n NormaliseFrequencies1(F, F0);\n WriteFrequencies1(output, F, F0);\n\n // Compute cumulative frequencies\n for (var i = 0; i < 256; i++) {\n\tif (!F0[i])\n\t continue;\n\n\tC[i][0] = 0;\n\tfor (var j = 1; j < 256; j++)\n\t C[i][j] = C[i][j-1] + F[i][j-1];\n }\n\n // Initialise rANS state\n var R = new Array(4);\n var L = new Array(4);\n for (var j = 0; j < 4; j++) {\n\tR[j] = RansEncInit();\n\tL[j] = 0;\n }\n var rans_out = new IOStream(\"\", nbytes, nbytes);\n\n // We have 4 rans codecs running in parallel on its own 1/4tr of buffer\n var nbytes4 = Math.floor(nbytes/4);\n var idx = new Array(4);\n var last = new Array(4)\n for (var j = 0; j < 4; j++) {\n\tidx[j] = (j+1)*nbytes4 - 2;\n\tlast[j] = src[idx[j]+1]\n }\n\n // Deal with the remainder if not a multiple of 4\n last[3] = src[nbytes-1];\n for (var i = nbytes-2; i > 4*nbytes4-2; i--) {\n\tR[3] = RansEncPut(R[3], rans_out, C[src[i]][last[3]], F[src[i]][last[3]], 12);\n\tlast[3] = src[i];\n }\n\n // Main encode loop\n while (idx[0] >= 0) {\n\tfor (var j = 3; j >= 0; j--) {\n\t var s = src[idx[j]]\n\t R[j] = RansEncPut(R[j], rans_out, C[s][last[j]], F[s][last[j]], 12);\n\t last[j] = s;\n\t idx[j]--;\n\t}\n }\n\n for (var j = 3; j >= 0; j--) {\n R[j] = RansEncPut(R[j], rans_out, C[0][last[j]], F[0][last[j]], 12)\n }\n\n for (var i = 3; i >= 0; i--)\n\tRansEncFlush(R[i], rans_out);\n\n // Stitch blocks together into final output buffer\n var freq_tab = output.pos;\n output.buf.writeInt32LE(freq_tab-9 + (rans_out.length - rans_out.pos), 1);\n output.buf.writeInt32LE(nbytes, 5);\n\n return Buffer.concat([output.buf.slice(0, output.pos),\n\t\t\t rans_out.buf.slice(rans_out.pos, rans_out.length)],\n\t\t\t output.pos + rans_out.length - rans_out.pos);\n}\n\nmodule.exports = { decode, encode }\n","/*\n * Copyright (c) 2019 Genome Research Ltd.\n * Author(s): James Bonfield\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * 1. Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n *\n * 3. Neither the names Genome Research Ltd and Wellcome Trust Sanger\n * Institute nor the names of its contributors may be used to endorse\n * or promote products derived from this software without specific\n * prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS \"AS\n * IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\n * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH\n * LTD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nconst IOStream = require(\"./iostream\");\n\n//----------------------------------------------------------------------\n// rANS primitives itself\n//\n// RansGet* is decoder side\n\nfunction RansGetCumulativeFreq(R, bits) {\n return R & ((1<<bits)-1)\n}\n\nfunction RansGetSymbolFromFreq(C, f) {\n // NOTE: Inefficient.\n // In practice we would implement this via a precomputed\n // lookup table C2S[f]; see RansBuildC2S below.\n var s = 0;\n while (f >= C[s+1])\n\ts++;\n\n //console.error(f, C, s)\n\n return s;\n}\n\nfunction RansBuildC2S(C, bits) {\n var max = 1<<bits\n var C2S = new Array(max);\n var s = 0;\n for (var f = 0; f < max; f++) {\n\twhile (f >= C[s+1])\n\t s++;\n\tC2S[f] = s;\n }\n return C2S;\n}\n\nfunction RansAdvanceStep(R, c, f, bits) {\n return f * (R >> bits) + (R & ((1<<bits)-1)) - c;\n}\n\nfunction RansRenorm(src, R) {\n if (R < (1<<15))\n\tR = (R << 16) + src.ReadUint16();\n\n return R;\n}\n\n\n// RanEnc* is for encoder\nfunction RansEncInit() {\n return 1<<15;\n}\n\nfunction RansEncFlush(R, dst) {\n dst.WriteByteNeg((R >> 24) & 0xff);\n dst.WriteByteNeg((R >> 16) & 0xff);\n dst.WriteByteNeg((R >> 8) & 0xff);\n dst.WriteByteNeg((R >> 0) & 0xff);\n}\n\nfunction RansEncRenorm(R, dst, freq, scale_bits) {\n //var R_max = (((1 << 15) >> scale_bits) << 16) * freq;\n var R_max = (1 << (31-scale_bits)) * freq\n\n while (R >= R_max) {\n\tdst.WriteByteNeg((R>>8) & 0xff);\n\tdst.WriteByteNeg(R & 0xff);\n\tR >>= 16;\n }\n return R;\n}\n\n// Puts a symbol with frequency freq, cumulative freq start\n// and total freq 1<<scale_bits.\n//\n// Note with static probabilities, /freq and %freq could be\n// precomputed via multiplies and shifts.\nfunction RansEncPut(R, dst, start, freq, scale_bits) {\n var scale = 1<<scale_bits;\n R = RansEncRenorm(R, dst, freq, scale_bits);\n R = (Math.floor(R / freq) << scale_bits) + (R % freq) + start;\n return R;\n}\n\n\n//----------------------------------------------------------------------\n// Run length encoding\nfunction EncodeRLE(src) {\n // Step 1: find which symbols benefit from RLE\n var L = new Array(256)\n for (var i = 0; i < 256; i++)\n\tL[i] = 0\n\n var last = -1\n for (var i = 0; i < src.length; i++) {\n\tL[src[i]] += src[i] == last ? 1 : -1\n\tlast = src[i]\n }\n\n var nrle = 0;\n for (var i = 0; i < 256; i++)\n\tif (L[i] > 0)\n\t nrle++\n\n if (!nrle) {\n\t// Format cannot cope with zero RLE symbols, so pick one!\n\tnrle = 1;\n\tL[0] = 1;\n }\n\n // Start meta-data as list of symbols to RLE\n var meta = new IOStream(\"\", 0, nrle+1 + src.length)\n meta.WriteByte(nrle)\n for (var i = 0; i < 256; i++)\n\tif (L[i] > 0)\n\t meta.WriteByte(i)\n\n // Step 2: Now apply RLE itself\n var data = new Buffer.allocUnsafe(src.length)\n var dpos = 0\n for (var i = 0; i < src.length; i++) {\n\tdata[dpos++] = src[i]\n\tif (L[src[i]] > 0) {\n\t last = src[i];\n\t var run = 0;\n\t while (i+run+1 < src.length && src[i+run+1] == last)\n\t\trun++;\n\t meta.WriteUint7(run)\n\t i += run\n\t}\n }\n\n // Compress the meta-data\n var cmeta = RansEncode0(meta.buf.slice(0, meta.pos))\n var hdr = new IOStream(\"\", 0, 16)\n hdr.WriteUint7(meta.pos*2) // Uncompressed meta-data length + compressed-bit-flag(0)\n hdr.WriteUint7(dpos) // Length of RLE encoded data\n hdr.WriteUint7(cmeta.length) // Compressed meta-data length\n var meta = Buffer.concat([hdr.buf.slice(0,hdr.pos), cmeta])\n\n return [meta, data.slice(0, dpos)]\n}\n\nfunction DecodeRLEMeta(src) {\n var u_meta_len = src.ReadUint7()\n var rle_len = src.ReadUint7()\n\n // Decode RLE lengths\n if (u_meta_len & 1) {\n\tvar rle_meta = src.ReadData((u_meta_len-1)/2)\n } else {\n\tvar comp_meta_len = src.ReadUint7()\n\tvar rle_meta = src.ReadData(comp_meta_len)\n\trle_meta = RansDecode0(new IOStream(rle_meta), u_meta_len/2)\n }\n\n // Decode list of symbols for which RLE lengths are applied\n var rle_meta = new IOStream(rle_meta)\n var L = new Array(256)\n var n = rle_meta.ReadByte()\n if (n == 0)\n\tn = 256;\n for (var i = 0; i < n; i++)\n\tL[rle_meta.ReadByte()] = 1\n\n return [L, rle_meta, rle_len]\n}\n\nfunction DecodeRLE(buf, L, rle_meta, len) {\n var src = new IOStream(buf);\n\n var out = new Buffer.allocUnsafe(len)\n\n // Expand up buf+meta to out; i = buf index, j = out index\n var j = 0;\n for (var i = 0; j < len; i++) {\n\tvar sym = buf[i];\n\tif (L[sym]) {\n\t var run = rle_meta.ReadUint7()\n\t for (var r = 0; r <= run; r++)\n\t\tout[j++] = sym\n\t} else {\n\t out[j++] = sym\n\t}\n }\n\n return out\n}\n\n//----------------------------------------------------------------------\n// Bit packing\n\nfunction EncodePack(src) {\n // Step 1: identify number of distinct symbols\n var F = new Array(256)\n for (var i = 0; i < 256; i++)\n\tF[i] = 0\n\n for (var i = 0; i < src.length; i++)\n\tF[src[i]]++\n\n var P = new Array(256)\n var nsym = 0;\n for (var i = 0; i < 256; i++)\n\tif (F[i] > 0)\n\t P[i] = nsym++\n\n if (nsym > 16) {\n\t//console.error(\"Too many symbols to pack:\",nsym)\n\treturn\n }\n\n\n // Pack data\n if (nsym <= 1) {\n\t// Constant\n\tvar data = new Buffer.allocUnsafe(0)\n }\n\n else if (nsym <= 2) {\n\t// 1 bit per value\n\tvar data = new Buffer.allocUnsafe(Math.ceil(src.length/8))\n\tvar j = -1\n\tfor (i = 0; i < src.length; i++) {\n\t if (i % 8 == 0)\n\t\tdata[++j] = 0\n\t data[j] += P[src[i]] << (i % 8)\n\t}\n }\n\n else if (nsym <= 4) {\n\t// 2 bits per value\n\tvar data = new Buffer.allocUnsafe(Math.ceil(src.length/4))\n\tvar j = -1\n\tfor (i = 0; i < src.length; i++) {\n\t if (i % 4 == 0)\n\t\tdata[++j] = 0\n\t data[j] += P[src[i]] << ((i % 4) * 2)\n\t}\n }\n\n else {\n\t// 4 bits per value\n\tvar data = new Buffer.allocUnsafe(Math.ceil(src.length/2))\n\tvar j = -1\n\tfor (i = 0; i < src.length; i++) {\n\t if (i % 2 == 0)\n\t\tdata[++j] = 0\n\t data[j] += P[src[i]] << ((i % 2) * 4)\n\t}\n }\n\n\n // Produce pack meta-data\n var meta = new IOStream(\"\", 0, nsym+5)\n meta.WriteByte(nsym)\n var j = 0\n for (var i = 0; i < 256; i++) {\n\tif (F[i] > 0) {\n\t F[i] = j++;\n\t meta.WriteByte(i)\n\t}\n }\n meta.WriteUint7(data.length)\n\n return [meta.buf.slice(0, meta.pos), data]\n}\n\n\n// Pack meta data is the number and value of distinct symbols plus\n// the length of the packed byte stream.\nfunction DecodePackMeta(src) {\n var nsym = src.ReadByte()\n var P = new Array(nsym)\n\n for (var i = 0; i < nsym; i++)\n\tP[i] = src.ReadByte()\n\n var len = src.ReadUint7()\n\n return [P, nsym, len]\n}\n\n// Extract bits from src producing output of length len.\n// Nsym is number of distinct symbols used.\nfunction DecodePack(data, P, nsym, len) {\n var out = new Buffer.allocUnsafe(len)\n var j = 0;\n\n // Constant value\n if (nsym <= 1) {\n\tfor (var i = 0; i < len; i++)\n\t out[i] = P[0]\n }\n\n // 1 bit per value\n else if (nsym <= 2) {\n\tfor (i = 0; i < len; i++) {\n\t if (i % 8 == 0)\n\t\tvar v = data[j++];\n\n\t out[i] = P[v & 1]\n\t v >>= 1\n\t}\n }\n\n // 2 bits per value\n else if (nsym <= 4) {\n\tfor (i = 0; i < len; i++) {\n\t if (i % 4 == 0)\n\t\tvar v = data[j++];\n\n\t out[i] = P[v & 3]\n\t v >>= 2\n\t}\n }\n\n // 4 bits per value\n else if (nsym <= 16) {\n\tfor (i = 0; i < len; i++) {\n\t if (i % 2 == 0)\n\t\tvar v = data[j++];\n\n\t out[i] = P[v & 15]\n\t v >>= 4\n\t}\n }\n\n return out\n}\n\n\n//----------------------------------------------------------------------\n// 4 way interleaving.\n// This is simply 4 rANS streams interleaved to form bytes 0,4,8...,\n// 1,5,9..., 2,6,10... and 3,7,11...\n//\n// It works well when the distributions differ for each of the 4 bytes,\n// for example when compressing a series of 32-bit integers.\n//\n// Maybe make this more general purpose of X* where we specify the stripe\n// size instead of fixing it at 4?\nfunction RansEncodeStripe(hdr, src, N) {\n if (N == 0)\n\tN = 4; // old default\n\n // Split into multiple streams\n var part = new Array(N)\n var ulen = new Array(N)\n for (var s = 0; s < N; s++) {\n\tulen[s] = Math.floor(src.length / N) + ((src.length % N) > s);\n\tpart[s] = new Array(ulen[s])\n }\n\n for (var x = 0, i = 0; i < src.length; i+=N, x++) {\n\tfor (var j = 0; j < N; j++)\n\t if (x < part[j].length)\n\t\tpart[j][x] = src[i+j]\n }\n\n // Compress each part\n var comp = new Array(N)\n var total = 0\n for (var s = 0; s < N; s++) {\n\t// Example: try O0 and O1 and choose best\n\tvar comp0 = encode(part[s], 0)\n\tvar comp1 = encode(part[s], 1)\n\tcomp[s] = (comp1.length < comp0.length) ? comp1 : comp0\n\ttotal += comp[s].length\n }\n\n // Serialise\n var out = new IOStream(\"\", 0, total+5*N+1)\n out.WriteByte(N)\n for (var s = 0; s < N; s++)\n\tout.WriteUint7(comp[s].length)\n\n for (var s = 0; s < N; s++)\n\tout.WriteData(comp[s], comp[s].length)\n\n return out.buf.slice(0, out.buf.pos)\n}\n\nfunction RansDecodeStripe(src, len) {\n var N = src.ReadByte()\n\n // Retrieve lengths\n var clen = new Array(N)\n var ulen = new Array(N)\n for (var j = 0; j < N; j++)\n\tclen[j] = src.ReadUint7()\n\n // Decode streams\n var T = new Array(N);\n for (var j = 0; j < N; j++) {\n\tulen[j] = Math.floor(len / N) + ((len % N) > j)\n\tT[j] = RansDecodeStream(src, ulen[j])\n }\n\n // Transpose\n var out = new Buffer.allocUnsafe(len)\n for (var j = 0; j < N; j++) {\n\tfor (var i = 0; i < ulen[j]; i++) {\n\t out[i*N + j] = T[j][i];\n\t}\n }\n\n return out;\n}\n\n\n//----------------------------------------------------------------------\n// Main rANS entry function: decodes a compressed src and\n// returns the uncompressed buffer.\nfunction decode(src) {\n var stream = new IOStream(src)\n return RansDecodeStream(stream, 0)\n}\n\nfunction RansDecodeStream(stream, n_out) {\n var format = stream.ReadByte();\n var order = format & 1\n var stripe = format & 8\n var nosz = format & 16\n var cat = format & 32\n var rle = format & 64\n var pack = format & 128\n\n if (!nosz)\n\tn_out = stream.ReadUint7();\n\n // N-way interleaving\n if (stripe)\n\treturn RansDecodeStripe(stream, n_out)\n\n // Bit packing\n if (pack) {\n\tvar pack_len = n_out\n\tvar [P, nsym, n_out] = DecodePackMeta(stream)\n }\n\n // Run length encoding\n if (rle) {\n\tvar rle_len = n_out\n\tvar [L, rle_meta, n_out] = DecodeRLEMeta(stream)\n }\n\n // Uncompress data (all, packed or run literals)\n if (cat)\n\tvar buf = stream.ReadData(n_out)\n else if (order == 0)\n\tvar buf = RansDecode0(stream, n_out)\n else\n\tvar buf = RansDecode1(stream, n_out)\n\n // Apply expansion transforms\n if (rle)\n\tbuf = DecodeRLE(buf, L, rle_meta, rle_len)\n\n if (pack)\n\tbuf = DecodePack(buf, P, nsym, pack_len)\n\n return buf\n}\n\nfunction encode(src, format) {\n var hdr = new IOStream(\"\", 0, 10);\n hdr.WriteByte(format);\n\n var order = format & 1\n var stripe= format & 8\n var nosz = format & 16\n var cat = format & 32\n var rle = format & 64\n var pack = format & 128\n\n var N = format>>8\n\n if (!nosz)\n\thdr.WriteUint7(src.length);\n\n if (stripe)\n\treturn Buffer.concat([hdr.buf.slice(0, hdr.pos), RansEncodeStripe(hdr, src, N)])\n\n var pack_meta = new Buffer.alloc(0)\n if (pack)\n\t[pack_meta, src] = EncodePack(src)\n\n var rle_meta = new Buffer.alloc(0)\n if (rle)\n\t[rle_meta, src] = EncodeRLE(src)\n\n if (src.length < 4 && order == 1) {\n\t// Protect against short order-1 data due to RLE/Pack\n\torder = 0\n\thdr.buf[0] &= ~1\n }\n\n if (cat)\n\tvar comp = src\n else if (order == 0)\n\tvar comp = RansEncode0(src)\n else\n\tvar comp = RansEncode1(src)\n\n return Buffer.concat([hdr.buf.slice(0,hdr.pos), pack_meta, rle_meta, comp])\n}\n\n//----------------------------------------------------------------------\n// Order-0 decoder\n\nfunction ReadAlphabet(src) {\n var A = new Array(256)\n for (var i = 0; i < 256; i++)\n\tA[i] = 0;\n\n var rle = 0\n var sym = src.ReadByte()\n var last_sym = sym\n\n do {\n\tA[sym] = 1;\n\tif (rle > 0) {\n\t rle--\n\t sym++\n\t} else {\n\t sym = src.ReadByte()\n\t if (sym == last_sym+1)\n\t\trle = src.ReadByte()\n\t}\n\tlast_sym = sym\n } while (sym != 0)\n\n return A\n}\n\n// Decode a single table of order-0 frequences,\n// filling out the F and C arrays.\nfunction ReadFrequencies0(src, F, C) {\n // Initialise; not in the specification - implicit?\n for (var i = 0; i < 256; i++)\n\tF[i] = 0;\n\n // Fetch alphabet\n var A = ReadAlphabet(src);\n\n // Fetch frequencies for the symbols listed in our alphabet\n for (var i = 0; i < 256; i++) {\n\tif (A[i] > 0)\n\t F[i] = src.ReadUint7()\n }\n\n NormaliseFrequencies0_Shift(F, 12)\n\n // Compute C[] from F[]\n C[0] = 0;\n for (var i = 0; i <= 255; i++)\n\tC[i+1] = C[i] + F[i];\n}\n\nfunction RansDecode0(src, nbytes) {\n // Decode frequencies\n var F = new Array(256);\n var C = new Array(256);\n ReadFrequencies0(src, F, C);\n\n // Fast lookup to avoid slow RansGetSymbolFromFreq\n var C2S = RansBuildC2S(C, 12);\n\n // Initialise rANS state\n var R = new Array(4);\n for (var i = 0; i < 4; i++)\n\tR[i] = src.ReadUint32();\n\n // Main decode loop\n var output = new Buffer.allocUnsafe(nbytes);\n for (var i = 0; i < nbytes; i++) {\n\tvar i4 = i%4;\n\tvar f = RansGetCumulativeFreq(R[i4], 12);\n\tvar s = C2S[f]; // Equiv to RansGetSymbolFromFreq(C, f);\n\n\toutput[i] = s;\n\tR[i4] = RansAdvanceStep(R[i4], C[s], F[s], 12);\n\tR[i4] = RansRenorm(src, R[i4]);\n }\n\n return output;\n}\n\n//----------------------------------------------------------------------\n// Order-0 encoder\n\nfunction BuildFrequencies0(src, F) {\n for (var i = 0; i < 256; i++)\n\tF[i] = 0;\n\n for (var i = 0; i < src.length; i++)\n\tF[src[i]]++;\n}\n\nfunction NormaliseFrequencies0(F, bits) {\n // Compute total\n var tot = 0;\n for (var i = 0; i < 256; i++)\n\ttot += F[i];\n\n // Scale total of frequencies to max\n const max = (1<<bits);\n var scale = max / tot;\n do {\n\tvar max_val = 0;\n\tvar max_idx = 0;\n\tvar renorm = 0;\n\ttot = 0;\n\tfor (var i = 0; i < 256; i++) {\n\t if (F[i] == 0)\n\t\tcontinue\n\n\t if (max_val < F[i]) {\n\t\tmax_val = F[i]\n\t\tmax_idx = i\n\t }\n\n\t F[i] = Math.floor(F[i] * scale);\n\t if (F[i] == 0)\n\t\tF[i] = 1;\n\n\t tot += F[i];\n\t}\n\n\t// Adjust new tot to ensure it matches.\n\tif (tot < max) {\n\t // Too low, boost the most common symbol\n\t F[max_idx] += max-tot;\n\t} else if (tot-max < F[max_idx]/2 && F[max_idx] > 2) {\n\t // Too high, reduce the common symbol\n\t F[max_idx] -= tot-max;\n\t} else if (tot != max) {\n\t // Much too high, fudge scale and try again.\n\t scale = max / tot;\n\t renorm = 1;\n\t}\n } while (renorm)\n}\n\nfunction NormaliseFrequencies0_Shift(F, bits) {\n // Compute total and number of bits to shift by\n var tot = 0;\n for (var i = 0; i < 256; i++)\n\ttot += F[i];\n\n if (tot == 0 || tot == (1<<bits))\n\treturn\n\n var shift = 0;\n while (tot < (1<<bits)) {\n\ttot *= 2;\n\tshift++;\n }\n\n // Scale total of frequencies to (1<<bits)\n for (var i = 0; i < 256; i++)\n\tF[i] <<= shift;\n}\n\nfunction WriteAlphabet(out, F) {\n var rle = 0;\n for (var i = 0; i < 256; i++) {\n\tif (!F[i])\n\t continue\n\n\tif (rle > 0)\n\t rle--\n\telse {\n\t out.WriteByte(i)\n\n\t if (i > 0 && F[i-1] > 0) {\n\t\t// We've encoded two symbol frequencies in a row.\n\t\t// How many more are there? Store that count so\n\t\t// we can avoid writing consecutive symbols.\n\t\tfor (rle = i+1; rle<256 && F[rle]; rle++)\n\t\t ;\n\t\trle -= i+1;\n\n\t\tout.WriteByte(rle);\n\t }\n\t}\n }\n out.WriteByte(0)\n}\n\nfunction WriteFrequencies0(out, F) {\n WriteAlphabet(out, F)\n\n for (var i = 0; i < 256; i++) {\n\tif (F[i])\n\t out.WriteUint7(F[i])\n }\n}\n\nfunction RansEncode0(src) {\n const nbytes = src.length;\n var output = new IOStream(\"\", 0, 257*3+9);\n\n // Compute frequencies\n var F = new Array(256)\n BuildFrequencies0(src, F)\n var bit_size = Math.ceil(Math.log2(nbytes));\n if (bit_size > 12)\n\tbit_size = 12;\n NormaliseFrequencies0(F, bit_size);\n WriteFrequencies0(output, F);\n NormaliseFrequencies0(F, 12);\n\n // Compute cumulative frequencies\n var C = new Array(256)\n C[0] = 0;\n for (var i = 1; i < 256; i++)\n\tC[i] = C[i-1] + F[i-1];\n\n // Initialise rANS state\n var R = new Array(4);\n for (var i = 0; i < 4; i++)\n\tR[i] = RansEncInit();\n\n // Allow expansion room if trying to compress random data.\n var rans_out = new IOStream(\"\", (nbytes*1.05+100)>>0, (nbytes*1.05+100)>>0);\n\n // Main encode loop\n for (var i = nbytes-1; i >= 0; i--)\n\tR[i%4] = RansEncPut(R[i%4], rans_out, C[src[i]], F[src[i]], 12);\n\n for (var i = 3; i >= 0; i--)\n\tRansEncFlush(R[i], rans_out);\n\n // Stitch blocks together into final output buffer\n //console.error(\"pos=\",rans_out.pos, \" len=\",rans_out.length)\n //console.error(rans_out.buf.slice(rans_out.pos, rans_out.length))\n return Buffer.concat([output.buf.slice(0, output.pos),\n\t\t\t rans_out.buf.slice(rans_out.pos, rans_out.length)],\n\t\t\t output.pos + rans_out.length - rans_out.pos);\n}\n\n//----------------------------------------------------------------------\n// Order-1 decoder\n\n// Decode a table of order-1 frequences,\n// filling out the F and C arrays.\nfunction ReadFrequencies1(src, F, C, shift) {\n // Initialise; not in the specification - implicit?\n for (var i = 0; i < 256; i++) {\n\tF[i] = new Array(256);\n\tC[i] = new Array(256);\n\tfor (var j = 0; j < 256; j++)\n\t F[i][j] = 0;\n }\n\n // Fetch alphabet\n var A = ReadAlphabet(src);\n\n // Read F[]\n for (var i = 0; i < 256; i++) {\n\tif (!A[i])\n\t continue\n\n\tvar run = 0;\n\tfor (var j = 0; j < 256; j++) {\n\t if (!A[j])\n\t\tcontinue\n\n\t if (run > 0) {\n\t\trun--\n\t } else {\n\t\tF[i][j] = src.ReadUint7();\n\t\tif (F[i][j] == 0)\n\t\t run = src.ReadByte();\n\t }\n\t}\n\n\tNormaliseFrequencies0_Shift(F[i], shift)\n\n\t// Compute C[] from F[]\n\tC[i][0] = 0;\n\tfor (var j = 0; j < 256; j++)\n\t C[i][j+1] = C[i][j] + F[i][j];\n }\n}\n\nfunction RansDecode1(src, nbytes) {\n // FIXME: this bit is missing from the RansDecode0 pseudocode.\n\n var comp = src.ReadByte();\n var shift = comp >> 4;\n\n var freq_src = src\n if (comp & 1) {\n\tvar ulen = src.ReadUint7()\n\tvar clen = src.ReadUint7()\n\tvar comp = new IOStream(src.ReadData(clen))\n\tvar freq_src = new IOStream(RansDecode0(comp, ulen));\n }\n\n // Decode frequencies\n var F = new Array(256);\n var C = new Array(256);\n ReadFrequencies1(freq_src, F, C, shift);\n\n // Fast lookup to avoid slow RansGetSymbolFromFreq\n var C2S = new Array(256);\n for (var i = 0; i < 256; i++)\n\t// Could do only for symbols in alphabet?\n\tC2S[i] = RansBuildC2S(C[i], shift);\n\n // Initialise rANS state\n var R = new Array(4);\n var L = new Array(4);\n for (var j = 0; j < 4; j++) {\n\tR[j] = src.ReadUint32();\n\tL[j] = 0;\n }\n\n // Main decode loop\n var output = new Buffer.allocUnsafe(nbytes);\n var nbytes4 = Math.floor(nbytes/4);\n for (var i = 0; i < nbytes4; i++) {\n\tfor (var j = 0; j < 4; j++) {\n\t var f = RansGetCumulativeFreq(R[j], shift);\n\n\t //var s = RansGetSymbolFromFreq(C[L[j]], f);\n\t var s = C2S[L[j]][f]; // Precomputed version of above\n\n\t output[i+j*nbytes4] = s;\n\t R[j] = RansAdvanceStep(R[j], C[L[j]][s], F[L[j]][s], shift);\n\t R[j] = RansRenorm(src, R[j]);\n\t L[j] = s;\n\t}\n }\n\n // Now deal with the remainder if buffer size is not a multiple of 4,\n // using rANS state 3 exclusively. (It'd have been nice to have\n // designed this to just act as if we kept going with a bail out.)\n i = 4*i;\n while (i < nbytes) {\n\tvar f = RansGetCumulativeFreq(R[3], shift);\n\tvar s = RansGetSymbolFromFreq(C[L[3]], f);\n\toutput[i++] = s;\n\tR[3] = RansAdvanceStep(R[3], C[L[3]][s], F[L[3]][s], shift);\n\tR[3] = RansRenorm(src, R[3]);\n\tL[3] = s;\n }\n\n return output;\n}\n\n//----------------------------------------------------------------------\n// Order-1 encoder\n\nfunction BuildFrequencies1(src, F, F0) {\n for (var i = 0; i < 256; i++) {\n\tF0[i] = 0;\n\tfor (var j = 0; j < 256; j++)\n\t F[i][j] = 0;\n }\n\n var last = 0;\n for (var i = 0; i < src.length; i++) {\n\tF0[last]++;\n\tF[last][src[i]]++;\n\tlast = src[i];\n }\n F0[last]++;\n\n // Also accept we'll be starting at 4 points, not just byte 0\n F[0][src[1*(src.length >> 2)]]++;\n F[0][src[2*(src.length >> 2)]]++;\n F[0][src[3*(src.length >> 2)]]++;\n F0[0] += 3;\n}\n\nfunction NormaliseFrequencies1(F, F0, shift) {\n\n for (var i = 0; i < 256; i++) {\n\tif (!F0[i])\n\t continue;\n\n\tvar bit_size = Math.ceil(Math.log2(F0[i]));\n\tif (bit_size > shift)\n\t bit_size = shift;\n\n\tNormaliseFrequencies0(F[i], bit_size)\n }\n}\n\nfunction NormaliseFrequencies1_Shift(F, F0, shift) {\n for (var i = 0; i < 256; i++)\n\tif (F0[i])\n\t NormaliseFrequencies0_Shift(F[i], shift)\n}\n\nfunction WriteFrequencies1(out, F, F0) {\n WriteAlphabet(out, F0)\n\n for (var i = 0; i < 256; i++) {\n\tif (!F0[i])\n\t continue\n\n\tvar run = 0\n\tfor (var j = 0; j < 256; j++) {\n\t if (!F0[j])\n\t\tcontinue\n\n\t if (run) {\n\t\trun--\n\t } else {\n\t\tout.WriteUint7(F[i][j])\n\n\t\tif (!F[i][j]) {\n\t\t // Count how many more zero-freqs we have\n\t\t for (var k = j+1; k < 256; k++) {\n\t\t\tif (!F0[k])\n\t\t\t continue\n\n\t\t\tif (F[i][k] == 0)\n\t\t\t run++\n\t\t\telse\n\t\t\t break\n\t\t }\n\t\t out.WriteByte(run)\n\t\t}\n\t }\n\t}\n }\n}\n\nfunction RansEncode1(src) {\n const nbytes = src.length;\n var output = new IOStream(\"\", 0, 257*257*3+9);\n\n // Compute frequencies\n var F0 = new Array(256)\n var F = new Array(256)\n var C = new Array(256)\n for (var i = 0; i < 256; i++) {\n\tF[i] = new Array(256);\n\tC[i] = new Array(256);\n }\n\n // Frequency precision\n var shift = 12;\n\n BuildFrequencies1(src, F, F0)\n NormaliseFrequencies1(F, F0, shift);\n\n // Store frequencies, possibly compressed\n var freq = new IOStream(\"\", 0, 257*257*3+9);\n\n WriteFrequencies1(freq, F, F0);\n\n var cfreq = RansEncode0(freq.buf.slice(0, freq.pos))\n if (cfreq.length < freq.pos) {\n\toutput.WriteByte(1 | (shift<<4));\n\toutput.WriteUint7(freq.pos)\n\toutput.WriteUint7(cfreq.length)\n\toutput.WriteData(cfreq, cfreq.length);\n } else {\n\toutput.WriteByte(0 | (shift<<4));\n\toutput.WriteData(freq.buf, freq.pos);\n }\n\n // Normalise and compute cumulative frequencies\n NormaliseFrequencies1_Shift(F, F0, shift);\n for (var i = 0; i < 256; i++) {\n\tif (!F0[i])\n\t continue;\n\n\tC[i][0] = 0;\n\tfor (var j = 1; j < 256; j++)\n\t C[i][j] = C[i][j-1] + F[i][j-1];\n }\n\n // Initialise rANS state\n var R = new Array(4);\n var L = new Array(4);\n for (var j = 0; j < 4; j++) {\n\tR[j] = RansEncInit();\n\tL[j] = 0;\n }\n var rans_out = new IOStream(\"\", (nbytes*1.05+100)>>0, (nbytes*1.05+100)>>0);\n\n // We have 4 rans codecs running in parallel on its own 1/4tr of buffer\n var nbytes4 = Math.floor(nbytes/4);\n var idx = new Array(4);\n var last = new Array(4)\n for (var j = 0; j < 4; j++) {\n\tidx[j] = (j+1)*nbytes4 - 2;\n\tlast[j] = src[idx[j]+1]\n }\n\n // Deal with the remainder if not a multiple of 4\n last[3] = src[nbytes-1];\n for (var i = nbytes-2; i > 4*nbytes4-2; i--) {\n\tR[3] = RansEncPut(R[3], rans_out, C[src[i]][last[3]], F[src[i]][last[3]], shift);\n\tlast[3] = src[i];\n }\n\n // Main encode loop\n while (idx[0] >= 0) {\n\tfor (var j = 3; j >= 0; j--) {\n\t var s = src[idx[j]]\n\t R[j] = RansEncPut(R[j], rans_out, C[s][last[j]], F[s][last[j]], shift);\n\t last[j] = s;\n\t idx[j]--;\n\t}\n }\n\n for (var j = 3; j >= 0; j--) {\n R[j] = RansEncPut(R[j], rans_out, C[0][last[j]], F[0][last[j]], shift)\n }\n\n for (var i = 3; i >= 0; i--)\n\tRansEncFlush(R[i], rans_out);\n\n // Stitch blocks together into final output buffer\n return Buffer.concat([output.buf.slice(0, output.pos),\n\t\t\t rans_out.buf.slice(rans_out.pos, rans_out.length)],\n\t\t\t output.pos + rans_out.length - rans_out.pos);\n}\n\nmodule.exports = { decode, encode }\n","/*\n * Copyright (c) 2019 Genome Research Ltd.\n * Author(s): James Bonfield\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * 1. Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n *\n * 3. Neither the names Genome Research Ltd and Wellcome Trust Sanger\n * Institute nor the names of its contributors may be used to endorse\n * or promote products derived from this software without specific\n * prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS \"AS\n * IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\n * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH\n * LTD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n// Name tokeniser\n//\n// This is a reference implementation designed to match the\n// written specification as closely as possible. It is *NOT*\n// an efficient implementation, but see comments below.\n\nconst IOStream = require(\"./iostream\");\nconst rans = require(\"./rans4x16\");\nconst arith_gen = require(\"./arith_gen\");\n\nvar arith = new arith_gen()\n\nconst TOK_TYPE = 0\nconst TOK_STRING = 1\nconst TOK_CHAR = 2\nconst TOK_DIGITS0 = 3\nconst TOK_DZLEN = 4\nconst TOK_DUP = 5\nconst TOK_DIFF = 6\nconst TOK_DIGITS = 7\nconst TOK_DELTA = 8\nconst TOK_DELTA0 = 9\nconst TOK_MATCH = 10\nconst TOK_NOP = 11\nconst TOK_END = 12\n\n//----------------------------------------------------------------------\n// Token byte streams\nfunction DecodeTokenByteStreams(src, in_size, use_arith, nnames) {\n var t = -1\n\n var B = new Array(256)\n\n while (!src.EOF()) {\n\tvar ttype = src.ReadByte()\n\tvar tok_new = ttype & 128\n\tvar tok_dup = ttype & 64\n\tvar type = ttype & 63\n\n\tif (tok_new) {\n\t t++\n\t B[t] = new Array(13)\n\t}\n\n\tif (type != TOK_TYPE && tok_new) {\n\t var M = new Array(nnames-1).fill(TOK_MATCH)\n\t B[t][TOK_TYPE] = new IOStream(Buffer.from([type].concat(M)))\n }\n\n\tif (tok_dup) {\n\t var dup_pos = src.ReadByte()\n\t var dup_type = src.ReadByte()\n\t B[t][type] = new IOStream(B[dup_pos][dup_type].buf)\n\t} else {\n\t var clen = src.ReadUint7()\n\t var data = src.ReadData(clen)\n\n\t if (use_arith)\n\t\tB[t][type] = arith.decode(data)\n\t else\n\t\tB[t][type] = rans.decode(data)\n\t B[t][type] = new IOStream(B[t][type])\n\t}\n }\n\n return B\n}\n\n//----------------------------------------------------------------------\n// Token decode\nfunction LeftPadNumber(val, len) {\n var str = val+\"\"\n while (str.length < len)\n\tstr = \"0\" + str\n\n return str\n}\n\nfunction DecodeSingleName(B, N, T, n) {\n var type = B[0][TOK_TYPE].ReadByte()\n var dist = B[0][type].ReadUint32()\n var m = n - dist\n\n if (type == TOK_DUP) {\n\tN[n] = N[m]\n\tT[n] = T[m]\n\treturn N[n]\n }\n \n var t = 1\n N[n] = \"\"\n T[n] = new Array(256)\n do {\n\ttype = B[t][TOK_TYPE].ReadByte()\n\n\tswitch(type) {\n\tcase TOK_CHAR:\n\t T[n][t] = B[t][TOK_CHAR].ReadChar()\n\t break\n\n\tcase TOK_STRING:\n\t T[n][t] = B[t][TOK_STRING].ReadString()\n\t break\n\t\n\tcase TOK_DIGITS:\n\t T[n][t] = B[t][TOK_DIGITS].ReadUint32()\n\t break\n\n\tcase TOK_DIGITS0:\n\t var d = B[t][TOK_DIGITS0].ReadUint32()\n\t var l = B[t][TOK_DZLEN].ReadByte()\n\t T[n][t] = LeftPadNumber(d, l)\n\t break\n\n\tcase TOK_DELTA:\n\t T[n][t] = (T[m][t]>>0) + B[t][TOK_DELTA].ReadByte()\n\t break\n\n\tcase TOK_DELTA0:\n\t var d = (T[m][t]>>0) + B[t][TOK_DELTA0].ReadByte()\n\t var l = T[m][t].length\n\t T[n][t] = LeftPadNumber(d, l)\n\t break\n\n\tcase TOK_MATCH:\n\t T[n][t] = T[m][t]\n\t break\n\n\tdefault:\n\t T[n][t] = \"\"\n\t break\n\t}\n\n\tN[n] += T[n][t++]\n } while (type != TOK_END)\n\n return N[n]\n}\n\n//----------------------------------------------------------------------\n// Main tokeniser decode entry function: decodes a compressed src and\n// returns the uncompressed buffer.\nfunction decode(src, len, separator) {\n var src = new IOStream(src)\n var ulen = src.ReadUint32()\n var nnames = src.ReadUint32()\n var use_arith = src.ReadByte()\n\n var B = DecodeTokenByteStreams(src, len, use_arith, nnames)\n var N = new Array(nnames)\n var T = new Array(nnames)\n\n var str = \"\"\n if (typeof separator === 'undefined')\n\tseparator = '\\n'\n for (var i = 0; i < nnames; i++)\n\tstr += DecodeSingleName(B, N, T, i) + separator\n\n return str\n}\n\n//----------------------------------------------------------------------\n// Main tokeniser encode function\n\n// Encoder is trickier than decode as we have a lot of decisions to make.\n// However here we just make a simple guess without anything complex,\n// to demonstrate the basic idea. See the C implementation for further\n// expansion on this.\nfunction encode(src, use_arith) {\n // Convert buffer to array of names\n var str = src.toString()\n if (str[str.length-1] == '\\n')\n\tstr = str.substring(0,str.length-1)\n var names = str.split(\"\\n\")\n\n var out = new IOStream(\"\", 0, str.length*2 + 10000) // guess max size\n out.WriteUint32(str.length)\n out.WriteUint32(names.length)\n out.WriteByte(use_arith)\n\n // Tokenise names\n var T = new Array(names.length)\n var H = {}\n var F = new Array(256).fill(0) // DELTA vs DIGIT frequency\n var max_tok = 0\n var max_len = 0\n for (var i = 0; i < names.length; i++) {\n\tvar [ntok,len] = TokeniseName(T, H, F, names[i], i)\n\tif (max_tok < ntok)\n\t max_tok = ntok\n\tif (max_len < len)\n\t max_len = len\n }\n\n // Convert tokens to byte streams and serialise\n for (var tnum = 0; tnum < max_tok; tnum++) {\n\tvar B = new Array(TOK_END+1)\n\tfor (var type = 0; type <= TOK_END; type++)\n\t B[type] = new IOStream(\"\", 0, names.length * max_len)\n\n\tFillByteStreams(B, T, tnum, names, max_tok, max_len)\n\tSerialiseByteStreams(B, tnum, use_arith, out)\n }\n\n return out.buf.slice(0, out.pos)\n}\n\nfunction FillByteStreams(B, T, tnum, names, max_tok, max_len) {\n // Create byte streams B[]\n for (var n = 0; n < names.length; n++) {\n\tif (tnum > 0 && T[n][0].type == TOK_DUP)\n\t continue\n\n\tif (!T[n][tnum])\n\t continue\n\n\tB[TOK_TYPE].WriteByte(T[n][tnum].type)\n\n\tswitch (T[n][tnum].type) {\n\tcase TOK_DIFF:\n\t B[TOK_DIFF].WriteUint32(T[n][tnum].val)\n\t break\n\n\tcase TOK_DUP:\n\t B[TOK_DUP].WriteUint32(T[n][tnum].val)\n\t break\n\n\tcase TOK_STRING:\n\t B[TOK_STRING].WriteString(T[n][tnum].val)\n\t break\n\n\tcase TOK_CHAR:\n\t B[TOK_CHAR].WriteChar(T[n][tnum].val)\n\t break\n\n\tcase TOK_DIGITS:\n\t B[TOK_DIGITS].WriteUint32(T[n][tnum].val)\n\t break\n\n\tcase TOK_DIGITS0:\n\t B[TOK_DIGITS0].WriteUint32(T[n][tnum].val)\n\t B[TOK_DZLEN].WriteByte(T[n][tnum].val.length)\n\t break\n\n\tcase TOK_DELTA:\n\t B[T[n][tnum].type].WriteByte(T[n][tnum].val)\n\t break\n\n\tcase TOK_DELTA0:\n\t B[T[n][tnum].type].WriteByte(T[n][tnum].val)\n\t break\n\t}\n }\n}\n\nfunction SerialiseByteStreams(B, tnum, use_arith, out) {\n // Compress and serialise byte streams B[]\n for (var type = 0; type <= TOK_END; type++) {\n\tif (B[type].pos <= 0)\n\t continue\n\n\tout.WriteByte(type + ((type == 0) ? 128 : 0))\n\n\t// IOStream to sized buffer\n\tB[type] = B[type].buf.slice(0, B[type].pos)\n\tvar comp = try_compress(B[type], use_arith)\n\n\tout.WriteUint7(comp.length)\n\tout.WriteData(comp, comp.length)\n }\n}\n\nfunction try_compress(src, use_arith) {\n var best = 1<<30\n var comp\n\n var methods = [0, 1, 64, 65, 128, 129, 193+8]\n for (var i in methods) {\n\tvar lvl = methods[i]\n\tif ((lvl & 1) && src.length < 100)\n\t continue\n\n\tif ((lvl & 8) && (src.length % 4) != 0)\n\t continue\n\n\ttry {\n\t var tmp = use_arith\n\t\t? arith.encode(src, lvl)\n\t\t: rans.encode(src, lvl)\n\t} catch (e) {\n\t var tmp = 0\n\t}\n\tif (tmp && best > tmp.length) {\n\t best = tmp.length\n\t comp = tmp\n\t}\n }\n\n return comp\n}\n\nfunction TokeniseName(T, H, F, name, n) {\n var max_len = 0\n\n // Always compare against last name only\n var p = n-1\n T[n] = new Array(256)\n\n if (H[name]) {\n\t//console.error(name,H[name],n)\n\tT[n][0] = {\n\t type: TOK_DUP,\n\t val: n - H[name]\n\t}\n } else {\n\tT[n][0] = {\n\t type: TOK_DIFF,\n\t val: n == 0 ? 0 : 1\n\t}\n }\n\n H[name] = n\n\n // Splits on alphanumerics, punctuation\n var tok = name.match(/([a-zA-Z0-9]{1,9})|([^a-zA-Z0-9]+)/g)\n for (var i = 0; i < tok.length; i++) {\n\tvar t = i+1 // token 0 = DIFF vs DUP\n\tvar type = TOK_STRING\n\tvar val = tok[i]\n\tif (tok[i].match(/^0+[0-9]*$/g))\n\t type = TOK_DIGITS0\n\telse if (tok[i].match(/^[0-9]+$/g))\n\t type = TOK_DIGITS\n\telse if (tok[i].length == 1)\n\t type = TOK_CHAR\n\n\tif (p >= 0 && T[p][t]) {\n\t if (T[p][t].str == tok[i]) {\n\t\ttype = TOK_MATCH\n\t\tval = \"\"\n\t } else if (T[p][t].type == TOK_DIGITS || T[p][t].type == TOK_DELTA) {\n\t\tvar d = val - T[p][t].str;\n\t\tF[t]++\n\t\tif (d >= 0 && d < 256 && F[t] > n/2) {\n\t\t type = TOK_DELTA\n\t\t val = d\n\t\t}\n\t } else if ((T[p][t].type == TOK_DIGITS0 || T[p][t].type == TOK_DELTA0)\n\t\t && T[p][t].str.length == val.length) {\n\t\tvar d = val - T[p][t].str;\n\t\tF[t]++\n\t\tif (d >= 0 && d < 256 && F[t] > n/2) {\n\t\t type = TOK_DELTA0\n\t\t val = d\n\t\t}\n\t }\n\t}\n\n\tT[n][t] = {\n\t str: tok[i],\n\t val: val,\n\t type: type\n\t}\n\n\tif (max_len < T[n][t].val.length+3) // +3 for integers; 5 -> (Uint32)5\n\t max_len = T[n][t].val.length+3\n\n\t//console.error(t,T[n][t])\n }\n T[n][++t] = {\n\ttype: TOK_END\n }\n\n return [t+1, max_len]\n}\n\nmodule.exports = { encode, decode }\n","/*\nbzip2.js - a small bzip2 decompression implementation\n\nCopyright 2011 by antimatter15 (antimatter15@gmail.com)\n\nBased on micro-bunzip by Rob Landley (rob@landley.net).\n\nBased on bzip2 decompression code by Julian R Seward (jseward@acm.org),\nwhich also acknowledges contributions by Mike Burrows, David Wheeler,\nPeter Fenwick, Alistair Moffat, Radford Neal, Ian H. Witten,\nRobert Sedgewick, and Jon L. Bentley.\n\nI hereby release this code under the GNU Library General Public License\n(LGPL) version 2, available at http://www.gnu.org/copyleft/lgpl.html\n*/\n\nvar bzip2 = {};\n\nbzip2.array = function (bytes) {\n var bit = 0,\n byte = 0;\n var BITMASK = [0, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF];\n return function (n) {\n var result = 0;\n while (n > 0) {\n var left = 8 - bit;\n if (n >= left) {\n result <<= left;\n result |= (BITMASK[left] & bytes[byte++]);\n bit = 0;\n n -= left;\n } else {\n result <<= n;\n result |= ((bytes[byte] & (BITMASK[n] << (8 - n - bit))) >> (8 - n - bit));\n bit += n;\n n = 0;\n }\n }\n return result\n }\n}\n\nbzip2.simple = function (bits) {\n var size = bzip2.header(bits);\n var all, chunk, chunks = [];\n var index = 0;\n do {\n //all += chunk;\n chunk = bzip2.decompress(bits, size);\n //all.set(chunk, index);\n if (chunk != -1) {\n chunks.push(chunk);\n index += chunk.byteLength;\n }\n } while (chunk != -1);\n all = new Uint8Array(index);\n index = 0;\n for (var i = 0; i < chunks.length; ++i) {\n chunk = chunks[i];\n all.set(chunk, index);\n index += chunk.byteLength;\n }\n return all;\n}\n\nbzip2.header = function (bits) {\n if (bits(8 * 3) != 4348520)\n throw \"No magic number found\";\n var i = bits(8) - 48;\n if (i < 1 || i > 9)\n throw \"Not a BZIP archive\";\n return i;\n};\n\n//takes a function for reading the block data (starting with 0x314159265359)\n//a block size (0-9) (optional, defaults to 9)\n//a length at which to stop decompressing and return the output\nbzip2.decompress = function (bits, size, len) {\n var MAX_HUFCODE_BITS = 20;\n var MAX_SYMBOLS = 258;\n var SYMBOL_RUNA = 0;\n var SYMBOL_RUNB = 1;\n var GROUP_SIZE = 50;\n\n var bufsize = 100000 * 9;\n for (var h = '', i = 0; i < 6; i++)\n h += bits(8).toString(16);\n if (h == \"177245385090\")\n return -1; //last block\n if (h != \"314159265359\")\n throw \"eek not valid bzip data\";\n bits(32); //ignore CRC codes\n if (bits(1))\n throw \"unsupported obsolete version\";\n var origPtr = bits(24);\n if (origPtr > bufsize)\n throw \"Initial position larger than buffer size\";\n var t = bits(16);\n var symToByte = new Uint8Array(256),\n symTotal = 0;\n for (i = 0; i < 16; i++) {\n if (t & (1 << (15 - i))) {\n var k = bits(16);\n for (j = 0; j < 16; j++) {\n if (k & (1 << (15 - j))) {\n symToByte[symTotal++] = (16 * i) + j;\n }\n }\n }\n }\n\n var groupCount = bits(3);\n if (groupCount < 2 || groupCount > 6)\n throw \"another error\";\n var nSelectors = bits(15);\n if (nSelectors == 0)\n throw \"meh\";\n var mtfSymbol = []; //TODO: possibly replace JS array with typed arrays\n for (var i = 0; i < groupCount; i++)\n mtfSymbol[i] = i;\n var selectors = new Uint8Array(32768);\n\n for (var i = 0; i < nSelectors; i++) {\n for (var j = 0; bits(1); j++)\n if (j >= groupCount)\n throw \"whoops another error\";\n var uc = mtfSymbol[j];\n mtfSymbol.splice(j, 1); //this is a probably inefficient MTF transform\n mtfSymbol.splice(0, 0, uc);\n selectors[i] = uc;\n }\n\n var symCount = symTotal + 2;\n var groups = [];\n for (var j = 0; j < groupCount; j++) {\n var length = new Uint8Array(MAX_SYMBOLS),\n temp = new Uint8Array(MAX_HUFCODE_BITS + 1);\n t = bits(5); //lengths\n for (var i = 0; i < symCount; i++) {\n while (true) {\n if (t < 1 || t > MAX_HUFCODE_BITS)\n throw \"I gave up a while ago on writing error messages\";\n if (!bits(1))\n break;\n if (!bits(1))\n t++;\n else\n t--;\n }\n length[i] = t;\n }\n var minLen, maxLen;\n minLen = maxLen = length[0];\n for (var i = 1; i < symCount; i++) {\n if (length[i] > maxLen)\n maxLen = length[i];\n else if (length[i] < minLen)\n minLen = length[i];\n }\n var hufGroup;\n hufGroup = groups[j] = {};\n hufGroup.permute = new Uint32Array(MAX_SYMBOLS);\n hufGroup.limit = new Uint32Array(MAX_HUFCODE_BITS + 1);\n hufGroup.base = new Uint32Array(MAX_HUFCODE_BITS + 1);\n hufGroup.minLen = minLen;\n hufGroup.maxLen = maxLen;\n var base = hufGroup.base.subarray(1);\n var limit = hufGroup.limit.subarray(1);\n var pp = 0;\n for (var i = minLen; i <= maxLen; i++)\n for (var t = 0; t < symCount; t++)\n if (length[t] == i)\n hufGroup.permute[pp++] = t;\n for (i = minLen; i <= maxLen; i++)\n temp[i] = limit[i] = 0;\n for (i = 0; i < symCount; i++)\n temp[length[i]]++;\n pp = t = 0;\n for (i = minLen; i < maxLen; i++) {\n pp += temp[i];\n limit[i] = pp - 1;\n pp <<= 1;\n base[i + 1] = pp - (t += temp[i]);\n }\n limit[maxLen] = pp + temp[maxLen] - 1;\n base[minLen] = 0;\n }\n var byteCount = new Uint32Array(256);\n for (var i = 0; i < 256; i++)\n mtfSymbol[i] = i;\n var runPos, count, symCount, selector;\n runPos = count = symCount = selector = 0;\n var buf = new Uint32Array(bufsize);\n while (true) {\n if (!(symCount--)) {\n symCount = GROUP_SIZE - 1;\n if (selector >= nSelectors)\n throw \"meow i'm a kitty, that's an error\";\n hufGroup = groups[selectors[selector++]];\n base = hufGroup.base.subarray(1);\n limit = hufGroup.limit.subarray(1);\n }\n i = hufGroup.minLen;\n j = bits(i);\n while (true) {\n if (i > hufGroup.maxLen)\n throw \"rawr i'm a dinosaur\";\n if (j <= limit[i])\n break;\n i++;\n j = (j << 1) | bits(1);\n }\n j -= base[i];\n if (j < 0 || j >= MAX_SYMBOLS)\n throw \"moo i'm a cow\";\n var nextSym = hufGroup.permute[j];\n if (nextSym == SYMBOL_RUNA || nextSym == SYMBOL_RUNB) {\n if (!runPos) {\n runPos = 1;\n t = 0;\n }\n if (nextSym == SYMBOL_RUNA)\n t += runPos;\n else\n t += 2 * runPos;\n runPos <<= 1;\n continue;\n }\n if (runPos) {\n runPos = 0;\n if (count + t >= bufsize)\n throw \"Boom.\";\n uc = symToByte[mtfSymbol[0]];\n byteCount[uc] += t;\n while (t--)\n buf[count++] = uc;\n }\n if (nextSym > symTotal)\n break;\n if (count >= bufsize)\n throw \"I can't think of anything. Error\";\n i = nextSym - 1;\n uc = mtfSymbol[i];\n mtfSymbol.splice(i, 1);\n mtfSymbol.splice(0, 0, uc);\n uc = symToByte[uc];\n byteCount[uc]++;\n buf[count++] = uc;\n }\n if (origPtr < 0 || origPtr >= count)\n throw \"I'm a monkey and I'm throwing something at someone, namely you\";\n var j = 0;\n for (var i = 0; i < 256; i++) {\n k = j + byteCount[i];\n byteCount[i] = j;\n j = k;\n }\n for (var i = 0; i < count; i++) {\n uc = buf[i] & 0xff;\n buf[byteCount[uc]] |= (i << 8);\n byteCount[uc]++;\n }\n var pos = 0,\n current = 0,\n run = 0;\n if (count) {\n pos = buf[origPtr];\n current = (pos & 0xff);\n pos >>= 8;\n run = -1;\n }\n count = count;\n var output = new Uint8Array(bufsize);\n var copies, previous, outbyte;\n var index = 0;\n if (!len)\n len = Infinity;\n while (count) {\n count--;\n previous = current;\n pos = buf[pos];\n current = pos & 0xff;\n pos >>= 8;\n if (run++ == 3) {\n copies = current;\n outbyte = previous;\n current = -1;\n } else {\n copies = 1;\n outbyte = current;\n }\n while (copies--) {\n //output += (String.fromCharCode(outbyte));\n output[index++] = outbyte;\n //index++;\n if (!--len)\n return output;\n }\n if (current != previous)\n run = 0;\n }\n //return output;\n //return output.subarray(0,index-1);\n return output.subarray(0, index);\n}\n\nmodule.exports = bzip2;\n","var charenc = {\n // UTF-8 encoding\n utf8: {\n // Convert a string to a byte array\n stringToBytes: function(str) {\n return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));\n },\n\n // Convert a byte array to a string\n bytesToString: function(bytes) {\n return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));\n }\n },\n\n // Binary encoding\n bin: {\n // Convert a string to a byte array\n stringToBytes: function(str) {\n for (var bytes = [], i = 0; i < str.length; i++)\n bytes.push(str.charCodeAt(i) & 0xFF);\n return bytes;\n },\n\n // Convert a byte array to a string\n bytesToString: function(bytes) {\n for (var str = [], i = 0; i < bytes.length; i++)\n str.push(String.fromCharCode(bytes[i]));\n return str.join('');\n }\n }\n};\n\nmodule.exports = charenc;\n","(function() {\n var base64map\n = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',\n\n crypt = {\n // Bit-wise rotation left\n rotl: function(n, b) {\n return (n << b) | (n >>> (32 - b));\n },\n\n // Bit-wise rotation right\n rotr: function(n, b) {\n return (n << (32 - b)) | (n >>> b);\n },\n\n // Swap big-endian to little-endian and vice versa\n endian: function(n) {\n // If number given, swap endian\n if (n.constructor == Number) {\n return crypt.rotl(n, 8) & 0x00FF00FF | crypt.rotl(n, 24) & 0xFF00FF00;\n }\n\n // Else, assume array and swap all items\n for (var i = 0; i < n.length; i++)\n n[i] = crypt.endian(n[i]);\n return n;\n },\n\n // Generate an array of any length of random bytes\n randomBytes: function(n) {\n for (var bytes = []; n > 0; n--)\n bytes.push(Math.floor(Math.random() * 256));\n return bytes;\n },\n\n // Convert a byte array to big-endian 32-bit words\n bytesToWords: function(bytes) {\n for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8)\n words[b >>> 5] |= bytes[i] << (24 - b % 32);\n return words;\n },\n\n // Convert big-endian 32-bit words to a byte array\n wordsToBytes: function(words) {\n for (var bytes = [], b = 0; b < words.length * 32; b += 8)\n bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);\n return bytes;\n },\n\n // Convert a byte array to a hex string\n bytesToHex: function(bytes) {\n for (var hex = [], i = 0; i < bytes.length; i++) {\n hex.push((bytes[i] >>> 4).toString(16));\n hex.push((bytes[i] & 0xF).toString(16));\n }\n return hex.join('');\n },\n\n // Convert a hex string to a byte array\n hexToBytes: function(hex) {\n for (var bytes = [], c = 0; c < hex.length; c += 2)\n bytes.push(parseInt(hex.substr(c, 2), 16));\n return bytes;\n },\n\n // Convert a byte array to a base-64 string\n bytesToBase64: function(bytes) {\n for (var base64 = [], i = 0; i < bytes.length; i += 3) {\n var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];\n for (var j = 0; j < 4; j++)\n if (i * 8 + j * 6 <= bytes.length * 8)\n base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F));\n else\n base64.push('=');\n }\n return base64.join('');\n },\n\n // Convert a base-64 string to a byte array\n base64ToBytes: function(base64) {\n // Remove non-base-64 characters\n base64 = base64.replace(/[^A-Z0-9+\\/]/ig, '');\n\n for (var bytes = [], i = 0, imod4 = 0; i < base64.length;\n imod4 = ++i % 4) {\n if (imod4 == 0) continue;\n bytes.push(((base64map.indexOf(base64.charAt(i - 1))\n & (Math.pow(2, -2 * imod4 + 8) - 1)) << (imod4 * 2))\n | (base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2)));\n }\n return bytes;\n }\n };\n\n module.exports = crypt;\n})();\n","/*!\n * Determine if an object is a Buffer\n *\n * @author Feross Aboukhadijeh <https://feross.org>\n * @license MIT\n */\n\n// The _isBuffer check is for Safari 5-7 support, because it's missing\n// Object.prototype.constructor. Remove this eventually\nmodule.exports = function (obj) {\n return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)\n}\n\nfunction isBuffer (obj) {\n return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n\n// For Node v0.10 support. Remove this eventually.\nfunction isSlowBuffer (obj) {\n return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))\n}\n","(function(){\r\n var crypt = require('crypt'),\r\n utf8 = require('charenc').utf8,\r\n isBuffer = require('is-buffer'),\r\n bin = require('charenc').bin,\r\n\r\n // The core\r\n md5 = function (message, options) {\r\n // Convert to byte array\r\n if (message.constructor == String)\r\n if (options && options.encoding === 'binary')\r\n message = bin.stringToBytes(message);\r\n else\r\n message = utf8.stringToBytes(message);\r\n else if (isBuffer(message))\r\n message = Array.prototype.slice.call(message, 0);\r\n else if (!Array.isArray(message) && message.constructor !== Uint8Array)\r\n message = message.toString();\r\n // else, assume byte array already\r\n\r\n var m = crypt.bytesToWords(message),\r\n l = message.length * 8,\r\n a = 1732584193,\r\n b = -271733879,\r\n c = -1732584194,\r\n d = 271733878;\r\n\r\n // Swap endian\r\n for (var i = 0; i < m.length; i++) {\r\n m[i] = ((m[i] << 8) | (m[i] >>> 24)) & 0x00FF00FF |\r\n ((m[i] << 24) | (m[i] >>> 8)) & 0xFF00FF00;\r\n }\r\n\r\n // Padding\r\n m[l >>> 5] |= 0x80 << (l % 32);\r\n m[(((l + 64) >>> 9) << 4) + 14] = l;\r\n\r\n // Method shortcuts\r\n var FF = md5._ff,\r\n GG = md5._gg,\r\n HH = md5._hh,\r\n II = md5._ii;\r\n\r\n for (var i = 0; i < m.length; i += 16) {\r\n\r\n var aa = a,\r\n bb = b,\r\n cc = c,\r\n dd = d;\r\n\r\n a = FF(a, b, c, d, m[i+ 0], 7, -680876936);\r\n d = FF(d, a, b, c, m[i+ 1], 12, -389564586);\r\n c = FF(c, d, a, b, m[i+ 2], 17, 606105819);\r\n b = FF(b, c, d, a, m[i+ 3], 22, -1044525330);\r\n a = FF(a, b, c, d, m[i+ 4], 7, -176418897);\r\n d = FF(d, a, b, c, m[i+ 5], 12, 1200080426);\r\n c = FF(c, d, a, b, m[i+ 6], 17, -1473231341);\r\n b = FF(b, c, d, a, m[i+ 7], 22, -45705983);\r\n a = FF(a, b, c, d, m[i+ 8], 7, 1770035416);\r\n d = FF(d, a, b, c, m[i+ 9], 12, -1958414417);\r\n c = FF(c, d, a, b, m[i+10], 17, -42063);\r\n b = FF(b, c, d, a, m[i+11], 22, -1990404162);\r\n a = FF(a, b, c, d, m[i+12], 7, 1804603682);\r\n d = FF(d, a, b, c, m[i+13], 12, -40341101);\r\n c = FF(c, d, a, b, m[i+14], 17, -1502002290);\r\n b = FF(b, c, d, a, m[i+15], 22, 1236535329);\r\n\r\n a = GG(a, b, c, d, m[i+ 1], 5, -165796510);\r\n d = GG(d, a, b, c, m[i+ 6], 9, -1069501632);\r\n c = GG(c, d, a, b, m[i+11], 14, 643717713);\r\n b = GG(b, c, d, a, m[i+ 0], 20, -373897302);\r\n a = GG(a, b, c, d, m[i+ 5], 5, -701558691);\r\n d = GG(d, a, b, c, m[i+10], 9, 38016083);\r\n c = GG(c, d, a, b, m[i+15], 14, -660478335);\r\n b = GG(b, c, d, a, m[i+ 4], 20, -405537848);\r\n a = GG(a, b, c, d, m[i+ 9], 5, 568446438);\r\n d = GG(d, a, b, c, m[i+14], 9, -1019803690);\r\n c = GG(c, d, a, b, m[i+ 3], 14, -187363961);\r\n b = GG(b, c, d, a, m[i+ 8], 20, 1163531501);\r\n a = GG(a, b, c, d, m[i+13], 5, -1444681467);\r\n d = GG(d, a, b, c, m[i+ 2], 9, -51403784);\r\n c = GG(c, d, a, b, m[i+ 7], 14, 1735328473);\r\n b = GG(b, c, d, a, m[i+12], 20, -1926607734);\r\n\r\n a = HH(a, b, c, d, m[i+ 5], 4, -378558);\r\n d = HH(d, a, b, c, m[i+ 8], 11, -2022574463);\r\n c = HH(c, d, a, b, m[i+11], 16, 1839030562);\r\n b = HH(b, c, d, a, m[i+14], 23, -35309556);\r\n a = HH(a, b, c, d, m[i+ 1], 4, -1530992060);\r\n d = HH(d, a, b, c, m[i+ 4], 11, 1272893353);\r\n c = HH(c, d, a, b, m[i+ 7], 16, -155497632);\r\n b = HH(b, c, d, a, m[i+10], 23, -1094730640);\r\n a = HH(a, b, c, d, m[i+13], 4, 681279174);\r\n d = HH(d, a, b, c, m[i+ 0], 11, -358537222);\r\n c = HH(c, d, a, b, m[i+ 3], 16, -722521979);\r\n b = HH(b, c, d, a, m[i+ 6], 23, 76029189);\r\n a = HH(a, b, c, d, m[i+ 9], 4, -640364487);\r\n d = HH(d, a, b, c, m[i+12], 11, -421815835);\r\n c = HH(c, d, a, b, m[i+15], 16, 530742520);\r\n b = HH(b, c, d, a, m[i+ 2], 23, -995338651);\r\n\r\n a = II(a, b, c, d, m[i+ 0], 6, -198630844);\r\n d = II(d, a, b, c, m[i+ 7], 10, 1126891415);\r\n c = II(c, d, a, b, m[i+14], 15, -1416354905);\r\n b = II(b, c, d, a, m[i+ 5], 21, -57434055);\r\n a = II(a, b, c, d, m[i+12], 6, 1700485571);\r\n d = II(d, a, b, c, m[i+ 3], 10, -1894986606);\r\n c = II(c, d, a, b, m[i+10], 15, -1051523);\r\n b = II(b, c, d, a, m[i+ 1], 21, -2054922799);\r\n a = II(a, b, c, d, m[i+ 8], 6, 1873313359);\r\n d = II(d, a, b, c, m[i+15], 10, -30611744);\r\n c = II(c, d, a, b, m[i+ 6], 15, -1560198380);\r\n b = II(b, c, d, a, m[i+13], 21, 1309151649);\r\n a = II(a, b, c, d, m[i+ 4], 6, -145523070);\r\n d = II(d, a, b, c, m[i+11], 10, -1120210379);\r\n c = II(c, d, a, b, m[i+ 2], 15, 718787259);\r\n b = II(b, c, d, a, m[i+ 9], 21, -343485551);\r\n\r\n a = (a + aa) >>> 0;\r\n b = (b + bb) >>> 0;\r\n c = (c + cc) >>> 0;\r\n d = (d + dd) >>> 0;\r\n }\r\n\r\n return crypt.endian([a, b, c, d]);\r\n };\r\n\r\n // Auxiliary functions\r\n md5._ff = function (a, b, c, d, x, s, t) {\r\n var n = a + (b & c | ~b & d) + (x >>> 0) + t;\r\n return ((n << s) | (n >>> (32 - s))) + b;\r\n };\r\n md5._gg = function (a, b, c, d, x, s, t) {\r\n var n = a + (b & d | c & ~d) + (x >>> 0) + t;\r\n return ((n << s) | (n >>> (32 - s))) + b;\r\n };\r\n md5._hh = function (a, b, c, d, x, s, t) {\r\n var n = a + (b ^ c ^ d) + (x >>> 0) + t;\r\n return ((n << s) | (n >>> (32 - s))) + b;\r\n };\r\n md5._ii = function (a, b, c, d, x, s, t) {\r\n var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;\r\n return ((n << s) | (n >>> (32 - s))) + b;\r\n };\r\n\r\n // Package private blocksize\r\n md5._blocksize = 16;\r\n md5._digestsize = 16;\r\n\r\n module.exports = function (message, options) {\r\n if (message === undefined || message === null)\r\n throw new Error('Illegal argument ' + message);\r\n\r\n var digestbytes = crypt.wordsToBytes(md5(message, options));\r\n return options && options.asBytes ? digestbytes :\r\n options && options.asString ? bin.bytesToString(digestbytes) :\r\n crypt.bytesToHex(digestbytes);\r\n };\r\n\r\n})();\r\n","/*!\n * Based on xzwasm (c) Steve Sanderson. License: MIT - https://github.com/SteveSanderson/xzwasm\n * Contains xz-embedded by Lasse Collin and Igor Pavlov. License: Public domain - https://tukaani.org/xz/embedded.html\n * and walloc (c) 2020 Igalia, S.L. License: MIT - https://github.com/wingo/walloc\n */\n(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"stream/web\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"stream/web\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"xz-decompress\"] = factory(require(\"stream/web\"));\n\telse\n\t\troot[\"xz-decompress\"] = factory(root[\"stream/web\"]);\n})(this, (__WEBPACK_EXTERNAL_MODULE__2__) => {\nreturn /******/ (() => { // webpackBootstrap\n/******/ \t\"use strict\";\n/******/ \tvar __webpack_modules__ = ([\n/* 0 */,\n/* 1 */\n/***/ ((module) => {\n\nmodule.exports = \"data:application/wasm;base64,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\";\n\n/***/ }),\n/* 2 */\n/***/ ((module) => {\n\nmodule.exports = __WEBPACK_EXTERNAL_MODULE__2__;\n\n/***/ })\n/******/ \t]);\n/************************************************************************/\n/******/ \t// The module cache\n/******/ \tvar __webpack_module_cache__ = {};\n/******/ \t\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/ \t\t// Check if module is in cache\n/******/ \t\tvar cachedModule = __webpack_module_cache__[moduleId];\n/******/ \t\tif (cachedModule !== undefined) {\n/******/ \t\t\treturn cachedModule.exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = __webpack_module_cache__[moduleId] = {\n/******/ \t\t\t// no module.id needed\n/******/ \t\t\t// no module.loaded needed\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/ \t\n/******/ \t\t// Execute the module function\n/******/ \t\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n/******/ \t\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/ \t\n/************************************************************************/\n/******/ \t/* webpack/runtime/define property getters */\n/******/ \t(() => {\n/******/ \t\t// define getter functions for harmony exports\n/******/ \t\t__webpack_require__.d = (exports, definition) => {\n/******/ \t\t\tfor(var key in definition) {\n/******/ \t\t\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n/******/ \t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n/******/ \t\t\t\t}\n/******/ \t\t\t}\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/hasOwnProperty shorthand */\n/******/ \t(() => {\n/******/ \t\t__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/make namespace object */\n/******/ \t(() => {\n/******/ \t\t// define __esModule on exports\n/******/ \t\t__webpack_require__.r = (exports) => {\n/******/ \t\t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n/******/ \t\t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n/******/ \t\t\t}\n/******/ \t\t\tObject.defineProperty(exports, '__esModule', { value: true });\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/************************************************************************/\nvar __webpack_exports__ = {};\n// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.\n(() => {\n__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */ XzReadableStream: () => (/* binding */ XzReadableStream)\n/* harmony export */ });\n/* harmony import */ var _dist_native_xz_decompress_wasm__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);\n\n\nconst ReadableStream = globalThis.ReadableStream\n // Node < 18 support web streams, but it's not available as a global, so we need to require it.\n // This won't be reached in modern browsers, and bundlers will ignore due to 'browser' field in package.json:\n || (__webpack_require__(2).ReadableStream);\n\nconst XZ_OK = 0;\nconst XZ_STREAM_END = 1;\n\nclass XzContext {\n constructor(moduleInstance) {\n this.exports = moduleInstance.exports;\n this.memory = this.exports.memory;\n this.ptr = this.exports.create_context();\n this._refresh();\n this.bufSize = this.mem32[0];\n this.inStart = this.mem32[1] - this.ptr;\n this.inEnd = this.inStart + this.bufSize;\n this.outStart = this.mem32[4] - this.ptr;\n }\n\n supplyInput(sourceDataUint8Array) {\n this._refresh();\n const inBuffer = this.mem8.subarray(this.inStart, this.inEnd);\n inBuffer.set(sourceDataUint8Array, 0);\n this.exports.supply_input(this.ptr, sourceDataUint8Array.byteLength);\n this._refresh();\n }\n\n getNextOutput() {\n const result = this.exports.get_next_output(this.ptr);\n this._refresh();\n if (result !== XZ_OK && result !== XZ_STREAM_END) {\n throw new Error(`get_next_output failed with error code ${result}`);\n }\n const outChunk = this.mem8.slice(this.outStart, this.outStart + /* outPos */ this.mem32[5]);\n return { outChunk, finished: result === XZ_STREAM_END };\n }\n\n needsMoreInput() {\n return /* inPos */ this.mem32[2] === /* inSize */ this.mem32[3];\n }\n\n outputBufferIsFull() {\n return /* outPos */ this.mem32[5] === this.bufSize;\n }\n\n resetOutputBuffer() {\n this.outPos = this.mem32[5] = 0;\n }\n\n dispose() {\n this.exports.destroy_context(this.ptr);\n this.exports = null;\n }\n\n _refresh() {\n if (this.memory.buffer !== this.mem8?.buffer) {\n this.mem8 = new Uint8Array(this.memory.buffer, this.ptr);\n this.mem32 = new Uint32Array(this.memory.buffer, this.ptr);\n }\n }\n}\n\nclass XzReadableStream extends ReadableStream {\n static _moduleInstancePromise;\n static _moduleInstance;\n static async _getModuleInstance() {\n const base64Wasm = _dist_native_xz_decompress_wasm__WEBPACK_IMPORTED_MODULE_0__.replace('data:application/wasm;base64,', '');\n const wasmBytes = Uint8Array.from(atob(base64Wasm), c => c.charCodeAt(0)).buffer;\n const wasmOptions = {};\n const module = await WebAssembly.instantiate(wasmBytes, wasmOptions);\n XzReadableStream._moduleInstance = module.instance;\n }\n\n constructor(compressedStream) {\n let xzContext;\n let unconsumedInput = null;\n const compressedReader = compressedStream.getReader();\n\n super({\n async start(controller) {\n if (!XzReadableStream._moduleInstance) {\n await (XzReadableStream._moduleInstancePromise || (XzReadableStream._moduleInstancePromise = XzReadableStream._getModuleInstance()));\n }\n xzContext = new XzContext(XzReadableStream._moduleInstance);\n },\n\n async pull(controller) {\n if (xzContext.needsMoreInput()) {\n if (unconsumedInput === null || unconsumedInput.byteLength === 0) {\n const { done, value } = await compressedReader.read();\n if (!done) {\n unconsumedInput = value;\n }\n }\n const nextInputLength = Math.min(xzContext.bufSize, unconsumedInput.byteLength);\n xzContext.supplyInput(unconsumedInput.subarray(0, nextInputLength));\n unconsumedInput = unconsumedInput.subarray(nextInputLength);\n }\n\n const nextOutputResult = xzContext.getNextOutput();\n controller.enqueue(nextOutputResult.outChunk);\n xzContext.resetOutputBuffer();\n\n if (nextOutputResult.finished) {\n xzContext.dispose(); // Not sure if this always happens\n controller.close();\n }\n },\n cancel() {\n xzContext.dispose(); // Not sure if this always happens\n return compressedReader.cancel();\n }\n });\n }\n}\n\n})();\n\n/******/ \treturn __webpack_exports__;\n/******/ })()\n;\n});","// Generated by `./pycrc.py --algorithm=table-driven --model=crc-32 --generate=c`\nlet TABLE = [\n 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,\n 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,\n 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,\n 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,\n 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,\n 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,\n 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,\n 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,\n 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,\n 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,\n 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,\n 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,\n 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,\n 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,\n 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,\n 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,\n 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,\n 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,\n 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,\n 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,\n 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,\n 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,\n 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,\n 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,\n 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,\n 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,\n 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,\n 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,\n 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,\n 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,\n 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,\n 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,\n];\nif (typeof Int32Array !== 'undefined') {\n TABLE = new Int32Array(TABLE);\n}\nconst crc32 = (current, previous) => {\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n let crc = previous === 0 ? 0 : ~~previous ^ -1;\n for (let index = 0; index < current.length; index++) {\n crc = TABLE[(crc ^ current[index]) & 0xff] ^ (crc >>> 8);\n }\n return crc ^ -1;\n};\nexport default crc32;\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable no-prototype-builtins */\nimport { Buffer } from 'buffer';\nconst createBuffer = (value, encoding) => Buffer.from(value, encoding);\nexport default createBuffer;\n","import crc32 from './calculators/crc32.js';\nimport defineCrc from './define_crc.js';\nexport default defineCrc('crc-32', crc32);\n","import createBuffer from './create_buffer.js';\nexport default function defineCrc(model, calculator) {\n const result = (value, previous) => calculator(createBuffer(value), previous) >>> 0;\n result.signed = (value, previous) => calculator(createBuffer(value), previous);\n result.unsigned = result;\n result.model = model;\n return result;\n}\n"],"names":["baseNumbers","a","A","c","C","g","G","t","T","n","N","makeFlagsHelper","x","r","code","name","flags","BamFlagsDecoder","CramFlagsDecoder","MateFlagsDecoder","CramRecord","constructor","cramFlags","readLength","mappingQuality","lengthOnRef","qualityScores","mateRecordNumber","readBases","readFeatures","mateToUse","readGroupId","readName","sequenceId","uniqueId","templateSize","alignmentStart","tags","this","mate","mateFlags","mateReadName","mateSequenceId","mateAlignmentStart","isPaired","isProperlyPaired","isSegmentUnmapped","isMateUnmapped","isReverseComplemented","isMateReverseComplemented","isRead1","isRead2","isSecondary","isFailedQc","isDuplicate","isSupplementary","isDetached","hasMateDownStream","isPreservingQualityScores","isUnknownBases","getReadBases","_refRegion","decoded","cramRecord","refRegion","regionSeqOffset","start","seq","slice","toUpperCase","bases","regionPos","currentReadFeature","length","feature","pos","added","data","sub","chunk","decodeReadSequence","getPairOrientation","s1","s2","o1","o2","tmp","isize","templateLength","undefined","Error","join","addReferenceSequence","compressionScheme","forEach","readFeature","refCoord","refPos","refBase","charAt","ref","baseNumber","base","substitutionMatrix","decodeBaseSubstitution","end","toJSON","Object","keys","k","startsWith","CramError","CramUnimplementedError","CramMalformedError","CramArgumentError","unzip","input","from","inflate","TF_SHIFT","TOTFREQ","RANS_BYTE_L","FC","F","advanceStep","freq","scaleBits","AriDecoder","fc","Array","i","R","DecodingSymbol","symbolInit","sym","advanceSymbolStep","get","advanceSymbol","pptr","advance","renormalize","assert","result","ByteBuffer","nodeBuffer","initialInputPosition","_buffer","_position","b","getByte","getByteAt","position","put","val","putAt","setPosition","getInt","readInt32LE","remaining","CramBufferOverrunError","getBits","cursor","numBits","bytePosition","bitPosition","dlen","parseItf8","buffer","initialOffset","offset","countFlags","parseLtf8","readUInt16LE","greaterThan","Number","MAX_SAFE_INTEGER","lessThan","MIN_SAFE_INTEGER","toNumber","parseItem","parser","startBufferPosition","startFilePosition","value","_endPosition","_size","tinyMemoize","_class","methodName","method","prototype","memoAttrName","res","call","Promise","resolve","catch","cramFileDefinition","_startOffset","dataView","DataView","byteOffset","magic","subarray","toString","majorVersion","getUint8","minorVersion","fileId","replaceAll","maxLength","makeTagSet","stringStart","stringEnd","str","push","formatMap","map","key","ents","console","warn","isMappedSliceHeader","header","refSeqId","cramUnmappedSliceHeader","numRecords","newOffset1","recordCounter","rc","newOffset2","numBlocks","newOffset3","numContentIds","newOffset4","contentIds","id","newOffset5","md5","cramMappedSliceHeader","refSeqStart","refSeqSpan","newOffset6","newOffset7","refBaseBlockId","newOffset8","cramEncodingSub","codecId","parametersBytes","parameters","bc","blockContentId","off","M2","M","numCodes","symbols","val2","numLengths","bitLengths","len","lengthsEncoding","valuesEncoding","stopByte","K","l2m","log2m","cramDataSeriesEncodingMap","mapSize","mapCount","String","fromCharCode","cramTagEncodingMap","k0","cramContainerHeader1","getInt32","alignmentSpan","numBases","numLandmarks","cramContainerHeader2","landmarks","landmark","crc32","getUint32","getSectionParsers","cramBlockHeader","d","compressionMethod","contentType","contentId","compressedSize","uncompressedSize","cramBlockCrc32","cramCompressionHeader","preservation","offsetRet","size","subbuf","tagSets","cramTagDictionary","cramPreservationMap","dataSeriesEncoding","tagEncoding","cramEncoding","readNullTerminatedString","parseTagData","tagType","Uint32Array","Int32Array","Int16Array","Uint16Array","Int8Array","Float32Array","parseInt","replace","arrayType","array","arr","Uint8Array","parseTagValueArray","decodeRecord","decodeDataSeries","sliceHeader","coreDataBlock","blocksByContentId","cursors","recordNumber","parsedContent","APdelta","lastAlignmentStart","readNamesIncluded","isUnmapped","setMateUnmapped","isOnNegativeStrand","setMateReverseComplemented","isWithMateDownstream","TLindex","TN","getTagNames","ntags","tagId","tagName","tagData","getCodecForTag","decode","isDecodeSequenceAsStar","readFeatureCount","currentReadPos","currentRefPos","decodeRFData","type","dataSeriesName","byteLength","toArray","readPosDelta","data1Schema","B","S","X","D","I","q","Q","H","P","data2Schema","decodeReadFeatures","isNaN","associateIntraSliceMate","allRecords","currentRecordNumber","thisRecord","mateRecord","complicatedMultiSegment","matedRecords","getAllMatedRecords","startRecord","records","starts","ends","estimatedTemplateLength","Math","max","min","calculateMultiSegmentMatedTemplateLength","lengthEstimate","calculateIntraSliceMatePairTemplateLength","CramSlice","container","containerPosition","sliceSize","file","getHeader","getDefinition","sectionParsers","containerHeader","readBlock","content","getBlocks","blockPosition","blocks","block","getCoreDataBlock","_getBlocksContentIdIndex","getBlockByContentId","getReferenceRegion","getCompressionScheme","refBlock","span","referenceRequired","fetchReferenceSequenceCallback","getAllRecords","getRecords","_fetchRecords","options","checkSequenceMD5","seqMd5","sequenceMD5","storedMd5","byte","coreBlock","externalBlocks","Map","getCursor","set","codec","getCodecForDataSeries","init","contentPosition","e","filterFunction","cacheKey","filePosition","recordsPromise","featureCache","filter","singleRefId","refRegions","record","seqId","NEGATIVE_INFINITY","all","values","async","split","CramCodec","dataType","instantiateCodec","super","arrayLength","_getLengthCodec","dataCodec","_getDataCodec","encodingParams","codecClasses","_decodeData","_decodeInt","_decodeByte","contentBlock","bytesRead","codes","codeBook","sortedCodes","sortedValuesByBitCode","sortedBitCodes","sortedBitLengthsByBitCode","bitCodeToValue","includes","TypeError","buildCodeBook","buildCodes","buildCaches","bitLength","_decode","_decodeZeroLengthCode","symbol","sort","codeLength","codeValue","entries","bitLengthInt","bitCode","delta","ii","numberOfSetBits","maxBitCode","fill","coreCursor","prevLen","bits","index","j","_decodeByteArray","dataBuffer","startPosition","stopPosition","numLeadingOnes","encodingData","CodecClass","dataSeriesTypes","BF","CF","RI","RL","AP","RG","MF","NS","NP","TS","NF","TC","FN","FP","BS","IN","SC","DL","BA","BB","RS","PD","HC","MQ","RN","QS","QQ","TL","CramContainerCompressionScheme","dataSeriesCodecCache","tagCodecCache","RR","tagIdsDictionary","TD","byteArray","matrix","parseSubstitutionMatrix","SM","test","ret","tagListId","endsWith","CramContainer","_readContainerHeader","getCompressionHeaderBlock","getFirstBlock","getSlice","slicePosition","fileSize","stat","bytes1","allocUnsafe","read","header1","numLandmarksSize","v","bytes2","header2","validateChecksums","checkCrc32","assign","maybeUrl","maybePath","maybeFilehandle","parseHeaderText","text","lines","line","tag","fields","f","indexOf","CramFile","args","url","path","filehandle","seqFetch","cacheSize","maxSize","uInt32","uInt8","getEndianness","headbytes","definition","getSamHeader","firstContainer","getContainerById","firstBlock","headerLength","getHeaderText","containerNumber","currentContainer","getContainerAtPosition","currentHeader","recordedCrc32","description","calculatedCrc32","unsigned","containerCount","readBlockHeader","_parseSection","section","preReadBuffer","_uncompress","inputBuffer","outputBuffer","copy","decompressedResponse","Response","XzReadableStream","buf","ReadableStream","controller","enqueue","close","arrayBuffer","order","outputSize","output","out","syms","cp","decoder","rle","readStatsO0","rans0","rans1","rans2","rans3","outputEnd","c0","c1","c2","c3","uncompressOrder0Way4","rlei","rlej","RansDecSymbol","readStatsO1","rans7","isz4","i0","i1","i2","i7","l0","l1","l2","l7","c7","uncompressOrder1Way4","blockHeader","blockContentPosition","uncompressedData","compressedData","crc","addRecordToIndex","containerStart","sliceStart","sliceBytes","s","CraiIndex","parseIndex","uncompressedBuffer","readFile","readUInt32LE","currentRecord","currentString","charCode","ent","e2","getIndex","parseIndexP","hasDataForReferenceSequence","getEntriesForRange","queryStart","queryEnd","seqEntries","compare","entry","entryStart","entryEnd","bins","IndexedCramFile","cram","cramUrl","cramPath","cramFilehandle","getRecordsForRange","opts","viewAsPairs","pairAcrossChr","maxInsertSize","slices","sliceResults","getRecordsInSlice","concat","readNames","readIds","unmatedPairs","matePromises","abs","mateSlices","mateBlocks","mateChunks","localeCompare","item","ary","mateRecordPromises","mateFeatPromises","recordPromise","featPromise","then","feats","mateRecs","newMateFeats","newMates","reduce","current","RangeCoder","IOStream","ByteModel","bzip2","ARITH_PACK","module","exports","src","stream","decodeStream","n_out","ReadByte","ReadUint7","e_len","decodeStripe","decodePackMeta","decodeCat","decodeExt","decodeRLE1","decodeRLE0","decode1","decode0","decodePack","encode","WriteByte","WriteUint7","Buffer","encodeStripe","pack_meta","encodePack","WriteStream","encodeRLE1","encodeRLE0","encode1","encode0","max_sym","byte_model","RangeStartDecode","ModelDecode","n_in","ModelEncode","RangeFinishEncode","last","decompress","encodeExt","model_lit","model_run","part","run","rctx","nsym","packMeta","meta","floor","hdr","ulen","comp","total","comp0","comp1","WriteData","clen","low","range","FFnum","carry","cache","RangeGetFrequency","tot_freq","RangeDecode","sym_low","sym_freq","RangeShiftLow","dst","RangeEncode","old_low","log","total_freq","acc","ModelRenormalise","read_array","tab","z","run_len","fqz_update_ctx","params","state","context","qctx","qshift","qtab","qbits","qloc","do_pos","ptab","p","ploc","do_delta","dtab","dloc","prevq","do_sel","sloc","decode_fqz_single_param","ReadUint16","pflags","do_dedup","fixed_len","do_qmap","do_qtab","qmap","decode_fqz_new_record","gparams","model","rev","max_sel","sel","stab","do_rev","rec","is_dup","dup","store_array","tmp1","sz1","i_start","tmp2","sz2","curr","q_lens","gflags","nparam","error","decode_fqz_params","qual","fqz_create_models","qual_len","reverse_qualities","decode_fqz","q_dirs","qhist","qd_last","qd_fixed","pbits","pshift","dbits","dshift","sbits","do_stab","pick_fqz_params","dsqr","WriteUint16","encode_fqz_params","model_qual","model_len","model_sel","process","exit","qlast","q1","encode_fqz","r4x8","r4x16","arith","fqzcomp","tok3","r4x8_uncompress","r4x16_uncompress","arith_uncompress","fqzcomp_uncompress","tok3_uncompress","start_pos","EOF","ReadData","ReadChar","ReadUint32","ReadString","ReadITF8","WriteChar","charCodeAt","WriteString","u","WriteUint32","writeInt32LE","WriteITF8","WriteByteNeg","RansGetCumulativeFreq","RansGetSymbolFromFreq","RansBuildC2S","C2S","RansAdvanceStep","RansRenorm","RansEncFlush","RansEncPut","scale_bits","R_max","RansEncRenorm","ReadFrequencies0","last_sym","NormaliseFrequencies0","tot","scale","max_val","max_idx","renorm","WriteFrequencies0","nbytes","i4","RansDecode0","ReadFrequencies1","L","nbytes4","RansDecode1","BuildFrequencies0","alloc","rans_out","freq_tab","RansEncode0","F0","BuildFrequencies1","NormaliseFrequencies1","WriteFrequencies1","idx","RansEncode1","RansEncodeStripe","RansDecodeStream","format","stripe","cat","pack","RansDecodeStripe","pack_len","DecodePackMeta","rle_len","rle_meta","u_meta_len","comp_meta_len","DecodeRLEMeta","shift","freq_src","ReadAlphabet","NormaliseFrequencies0_Shift","DecodeRLE","DecodePack","ceil","EncodePack","nrle","dpos","cmeta","EncodeRLE","bit_size","log2","WriteAlphabet","cfreq","NormaliseFrequencies1_Shift","rans","LeftPadNumber","DecodeSingleName","m","l","FillByteStreams","tnum","names","max_tok","max_len","SerialiseByteStreams","use_arith","try_compress","best","methods","lvl","TokeniseName","tok","match","substring","ntok","TOK_END","separator","nnames","in_size","ttype","tok_new","tok_dup","dup_pos","dup_type","DecodeTokenByteStreams","bytes","bit","BITMASK","left","chunks","bufsize","h","origPtr","symToByte","symTotal","groupCount","nSelectors","mtfSymbol","selectors","uc","splice","symCount","groups","minLen","maxLen","hufGroup","temp","MAX_HUFCODE_BITS","permute","limit","pp","runPos","count","selector","byteCount","GROUP_SIZE","nextSym","copies","previous","outbyte","Infinity","charenc","utf8","stringToBytes","bin","unescape","encodeURIComponent","bytesToString","decodeURIComponent","escape","base64map","crypt","rotl","rotr","endian","randomBytes","random","bytesToWords","words","wordsToBytes","bytesToHex","hex","hexToBytes","substr","bytesToBase64","base64","triplet","base64ToBytes","imod4","pow","isBuffer","obj","readFloatLE","isSlowBuffer","_isBuffer","message","encoding","isArray","FF","_ff","GG","_gg","HH","_hh","II","_ii","aa","bb","cc","dd","_blocksize","_digestsize","digestbytes","asBytes","asString","factory","__WEBPACK_EXTERNAL_MODULE__2__","__webpack_modules__","__webpack_module_cache__","moduleId","cachedModule","o","defineProperty","enumerable","prop","hasOwnProperty","Symbol","toStringTag","_dist_native_xz_decompress_wasm__WEBPACK_IMPORTED_MODULE_0__","globalThis","XzContext","moduleInstance","memory","ptr","create_context","_refresh","bufSize","mem32","inStart","inEnd","outStart","supplyInput","sourceDataUint8Array","mem8","supply_input","getNextOutput","get_next_output","outChunk","finished","needsMoreInput","outputBufferIsFull","resetOutputBuffer","outPos","dispose","destroy_context","static","_getModuleInstance","base64Wasm","wasmBytes","atob","WebAssembly","instantiate","_moduleInstance","instance","compressedStream","xzContext","unconsumedInput","compressedReader","getReader","_moduleInstancePromise","pull","done","nextInputLength","nextOutputResult","cancel","TABLE","calculator","signed"],"sourceRoot":""}