swc/crates/swc_bundler/tests/.cache/deno/59dd8cbfbbe24842699fe79947a23c6a7c9c3aa4.ts
2021-11-09 20:42:49 +09:00

162 lines
3.9 KiB
TypeScript

// Loaded from https://deno.land/std@0.101.0/bytes/bytes_list.ts
/**
* An abstraction of multiple Uint8Arrays
*/
export class BytesList {
private len = 0;
private chunks: {
value: Uint8Array;
start: number; // start offset from head of chunk
end: number; // end offset from head of chunk
offset: number; // offset of head in all bytes
}[] = [];
constructor() {}
/**
* Total size of bytes
*/
size() {
return this.len;
}
/**
* Push bytes with given offset infos
*/
add(value: Uint8Array, start = 0, end = value.byteLength) {
if (value.byteLength === 0 || end - start === 0) {
return;
}
checkRange(start, end, value.byteLength);
this.chunks.push({
value,
end,
start,
offset: this.len,
});
this.len += end - start;
}
/**
* Drop head `n` bytes.
*/
shift(n: number) {
if (n === 0) {
return;
}
if (this.len <= n) {
this.chunks = [];
this.len = 0;
return;
}
const idx = this.getChunkIndex(n);
this.chunks.splice(0, idx);
const [chunk] = this.chunks;
if (chunk) {
const diff = n - chunk.offset;
chunk.start += diff;
}
let offset = 0;
for (const chunk of this.chunks) {
chunk.offset = offset;
offset += chunk.end - chunk.start;
}
this.len = offset;
}
/**
* Find chunk index in which `pos` locates by binary-search
* returns -1 if out of range
*/
getChunkIndex(pos: number): number {
let max = this.chunks.length;
let min = 0;
while (true) {
const i = min + Math.floor((max - min) / 2);
if (i < 0 || this.chunks.length <= i) {
return -1;
}
const { offset, start, end } = this.chunks[i];
const len = end - start;
if (offset <= pos && pos < offset + len) {
return i;
} else if (offset + len <= pos) {
min = i + 1;
} else {
max = i - 1;
}
}
}
/**
* Get indexed byte from chunks
*/
get(i: number): number {
if (i < 0 || this.len <= i) {
throw new Error("out of range");
}
const idx = this.getChunkIndex(i);
const { value, offset, start } = this.chunks[idx];
return value[start + i - offset];
}
/**
* Iterafor of bytes from given position
*/
*iterator(start = 0): IterableIterator<number> {
const startIdx = this.getChunkIndex(start);
if (startIdx < 0) return;
const first = this.chunks[startIdx];
let firstOffset = start - first.offset;
for (let i = startIdx; i < this.chunks.length; i++) {
const chunk = this.chunks[i];
for (let j = chunk.start + firstOffset; j < chunk.end; j++) {
yield chunk.value[j];
}
firstOffset = 0;
}
}
/**
* Returns subset of bytes copied
*/
slice(start: number, end: number = this.len): Uint8Array {
if (end === start) {
return new Uint8Array();
}
checkRange(start, end, this.len);
const result = new Uint8Array(end - start);
const startIdx = this.getChunkIndex(start);
const endIdx = this.getChunkIndex(end - 1);
let written = 0;
for (let i = startIdx; i < endIdx; i++) {
const chunk = this.chunks[i];
const len = chunk.end - chunk.start;
result.set(chunk.value.subarray(chunk.start, chunk.end), written);
written += len;
}
const last = this.chunks[endIdx];
const rest = end - start - written;
result.set(last.value.subarray(last.start, last.start + rest), written);
return result;
}
/**
* Concatenate chunks into single Uint8Array copied.
*/
concat(): Uint8Array {
const result = new Uint8Array(this.len);
let sum = 0;
for (const { value, start, end } of this.chunks) {
result.set(value.subarray(start, end), sum);
sum += end - start;
}
return result;
}
}
function checkRange(start: number, end: number, len: number) {
if (start < 0 || len < start || end < 0 || len < end || end < start) {
throw new Error("invalid range");
}
}