docs: function decodeChunkedArray( bundle, database, size, is_numeric ) {
  	var op = bundle.u8[bundle.i8++],
  		chunk, chunk_meta = [],	nans, vans=[], i=0, first = true, j=0, l=0,
  		splicefn, peekOp, ln=0, type=0, len=0, val=0;
  
  	// Process chunks till PRIM_CHUNK_END
  	while (i < size) {
  		if (is_numeric) {
  
  			//
  			// Use an optimised version of NUM_REPEATED when
  			// operating on a numeric array in order to avoid
  			// intermediate casting to Array()
  			//
  
  			if ((op & 0xF0) === 0x40) { // NUM_REPEATED
  
  				ln = op & 0x01;
  				type = (op >> 1) & 0x07;
  				len = ln ? bundle.u32[bundle.i32++] : bundle.u16[bundle.i16++];
  
  				// Collect meta
  				if (DEBUG) {
  					chunk_meta.push({
  						type: op,
  						len: len
  					});
  				}
  
  				// Init first value
  				if (first) {
  					nans = new NUMTYPE_CLASS[ type ]( size );
  					first = false;
  				}
  
  				// readTypedNum(type)
  				switch (type) {
  					case 0: val = bundle.u8[bundle.i8++]; break;
  					case 1: val = bundle.s8[bundle.i8++]; break;
  					case 2: val = bundle.u16[bundle.i16++]; break;
  					case 3: val = bundle.s16[bundle.i16++]; break;
  					case 4: val = bundle.u32[bundle.i32++]; break;
  					case 5: val = bundle.s32[bundle.i32++]; break;
  					case 6: val = bundle.f32[bundle.i32++]; break;
  					case 7: val = bundle.f64[bundle.i64++]; break;
  				}
  				nans.fill( val, i, i+len );
  				i+= len;
  
  			} else {
  
  				// Collect chunk ops
  				chunk = decodeArray( bundle, database, op );
  				if (DEBUG) {
  					chunk_meta.push({
  						type: op,
  						len: chunk.length
  					});
  				}
  
  				// Test for non-arrays
  				if (chunk.length === undefined)
  					throw new Errors.AssertError('Encountered non-array chunk as part of chunked array!');
  
  				// Init first value
  				if (first) {
  					nans = new chunk.constructor( size );
  					first = false;
  				}
  
  				// Test for type mismatch
  				if (!(chunk instanceof nans.constructor)) {
  					throw new Errors.AssertError("Got is_numeric flag, but chunks are not of the same type (op was "+op+"!");
  				}
  
  				// Merge
  				nans.set( chunk, i );
  				i += chunk.length;
  
  			}
  
  		} else {
  
  			// Collect chunk ops
  			chunk = decodeArray( bundle, database, op );
  			if (DEBUG) {
  				chunk_meta.push({
  					type: op,
  					len: chunk.length
  				});
  			}
  
  			// Test for non-arrays
  			if (chunk.length === undefined)
  				throw new Errors.AssertError('Encountered non-array chunk as part of chunked array!');
  
  			// Init first
  			if (first) {
  				vans = new Array(size);
  				first = false;
  			}
  
  			// Merge
  			for (j=0, l=chunk.length; j<l; j++, i++) {
  				vans[i] = chunk[j];
  			}
  
  		}
  
  		// Get next op-code
  		if (i < size) {
  			op = bundle.u8[bundle.i8++];
  		} else {
  			break;
  		}
  	}
  
  	// console.log("-----------");
  	// console.log(ans);
  
  	// Return chunked array
  	if (is_numeric) {
  		return DEBUG
  			? __debugMeta( nans, 'array.primitive.chunked', { 'chunks': chunk_meta, 'numeric': true } )
  			: nans;
  	} else {
  		return DEBUG
  			? __debugMeta( vans, 'array.primitive.chunked', { 'chunks': chunk_meta, 'numeric': false } )
  			: vans;
  	}
  }