28796963159

Committed 06 Jul 2026 01:56PM UTC coverage: 77.44% (-0.9%) from 78.303%

Build # 28796963159

Build Type

Pull #216

github

Committed by

web-flow

Commit Message

Merge 9296e7726 into 1ad22655a

Pull Request Pull Request #216: Add a native Pynter/SVML pathway to the standalone repl

Coverage Stats

2469 of 3473 branches covered (71.09%)

Branch coverage included in aggregate %.

166 of 230 new or added lines in 10 files covered. (72.17%)

53 existing lines in 2 files now uncovered.

5965 of 7418 relevant lines covered (80.41%)

13502.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.1

/src/utils/buffer.ts

declare global {
  interface ArrayBufferConstructor {
    transfer(source: ArrayBuffer, length: number): ArrayBuffer;
  }
}

if (!ArrayBuffer.transfer) {
  ArrayBuffer.transfer = (source, length) => {
    if (!(source instanceof ArrayBuffer))
      throw new TypeError("Source must be an instance of ArrayBuffer");
    if (length <= source.byteLength) return source.slice(0, length);
    const sourceView = new Uint8Array(source);
    const destView = new Uint8Array(new ArrayBuffer(length));
    destView.set(sourceView);
    return destView.buffer;
  };
}

/**
 * A little-endian byte buffer class.
 */
export default class Buffer {
  private _capacity: number;
  public cursor: number;
  private _written: number;
  private _buffer: ArrayBuffer;
  private _view: DataView;

  constructor() {
    this._capacity = 32;
    this.cursor = 0;
    this._written = 0;
    this._buffer = new ArrayBuffer(this._capacity);
    this._view = new DataView(this._buffer);
  }

  private maybeExpand(n: number) {
    if (this.cursor + n <= this._capacity) {
      return;
    }

    while (this.cursor + n > this._capacity) {
      this._capacity *= 2;
    }
    this._buffer = ArrayBuffer.transfer(this._buffer, this._capacity);
    this._view = new DataView(this._buffer);
  }

  private updateWritten() {
    this._written = Math.max(this._written, this.cursor);
  }

  get(signed: boolean, s: 8 | 16 | 32): number {
    const r = this._view[`get${signed ? "I" : "Ui"}nt${s}`](this.cursor, true);
    this.cursor += s / 8;
    return r;
  }

  getI(s: 8 | 16 | 32): number {
    return this.get(true, s);
  }

  getU(s: 8 | 16 | 32): number {
    return this.get(false, s);
  }

  getF(s: 32 | 64): number {
    const r = this._view[`getFloat${s}`](this.cursor, true);
    this.cursor += s / 8;
    return r;
  }

  put(n: number, signed: boolean, s: 8 | 16 | 32) {
    this.maybeExpand(s / 8);
    this._view[`set${signed ? "I" : "Ui"}nt${s}`](this.cursor, n, true);
    this.cursor += s / 8;
    this.updateWritten();
  }

  putI(s: 8 | 16 | 32, n: number) {
    this.put(n, true, s);
  }

  putU(s: 8 | 16 | 32, n: number) {
    this.put(n, false, s);
  }

  putF(s: 32 | 64, n: number) {
    this.maybeExpand(s / 8);
    this._view[`setFloat${s}`](this.cursor, n, true);
    this.cursor += s / 8;
    this.updateWritten();
  }

  putA(a: Uint8Array) {
    this.maybeExpand(a.byteLength);
    new Uint8Array(this._buffer, this.cursor, a.byteLength).set(a);
    this.cursor += a.byteLength;
    this.updateWritten();
  }

  align(n: number) {
    const rem = this.cursor % n;
    if (rem === 0) {
      return;
    }
    this.cursor += n - rem;
  }

  asArray(): Uint8Array {
    return new Uint8Array(this._buffer.slice(0, this._written));
  }

  get written(): number {
    return this._written;
  }
}

1	declare global {
2	interface ArrayBufferConstructor {
3	transfer(source: ArrayBuffer, length: number): ArrayBuffer;
4	}
5	}
6
7	if (!ArrayBuffer.transfer) {	13✔
8	ArrayBuffer.transfer = (source, length) => {	3✔
UNCOV 9	if (!(source instanceof ArrayBuffer))	×
10	throw new TypeError("Source must be an instance of ArrayBuffer");	×
UNCOV 11	if (length <= source.byteLength) return source.slice(0, length);	×
UNCOV 12	const sourceView = new Uint8Array(source);	×
UNCOV 13	const destView = new Uint8Array(new ArrayBuffer(length));	×
UNCOV 14	destView.set(sourceView);	×
UNCOV 15	return destView.buffer;	×
16	};
17	}
18
19	/**
20	* A little-endian byte buffer class.
21	*/
22	export default class Buffer {	13✔
23	private _capacity: number;
24	public cursor: number;
25	private _written: number;
26	private _buffer: ArrayBuffer;
27	private _view: DataView;
28
29	constructor() {
30	this._capacity = 32;	48✔
31	this.cursor = 0;	48✔
32	this._written = 0;	48✔
33	this._buffer = new ArrayBuffer(this._capacity);	48✔
34	this._view = new DataView(this._buffer);	48✔
35	}
36
37	private maybeExpand(n: number) {
38	if (this.cursor + n <= this._capacity) {	603✔
39	return;	582✔
40	}
41
42	while (this.cursor + n > this._capacity) {	21✔
43	this._capacity *= 2;	25✔
44	}
45	this._buffer = ArrayBuffer.transfer(this._buffer, this._capacity);	21✔
46	this._view = new DataView(this._buffer);	21✔
47	}
48
49	private updateWritten() {
50	this._written = Math.max(this._written, this.cursor);	603✔
51	}
52
53	get(signed: boolean, s: 8 \| 16 \| 32): number {
54	const r = this._view[`get${signed ? "I" : "Ui"}nt${s}`](this.cursor, true);	×
55	this.cursor += s / 8;	×
56	return r;	×
57	}
58
59	getI(s: 8 \| 16 \| 32): number {
60	return this.get(true, s);	×
61	}
62
63	getU(s: 8 \| 16 \| 32): number {
64	return this.get(false, s);	×
65	}
66
67	getF(s: 32 \| 64): number {
68	const r = this._view[`getFloat${s}`](this.cursor, true);	×
69	this.cursor += s / 8;	×
70	return r;	×
71	}
72
73	put(n: number, signed: boolean, s: 8 \| 16 \| 32) {
74	this.maybeExpand(s / 8);	570✔
75	this._view[`set${signed ? "I" : "Ui"}nt${s}`](this.cursor, n, true);	570✔
76	this.cursor += s / 8;	570✔
77	this.updateWritten();	570✔
78	}
79
80	putI(s: 8 \| 16 \| 32, n: number) {
81	this.put(n, true, s);	55✔
82	}
83
84	putU(s: 8 \| 16 \| 32, n: number) {
85	this.put(n, false, s);	515✔
86	}
87
88	putF(s: 32 \| 64, n: number) {
89	this.maybeExpand(s / 8);	1✔
90	this._view[`setFloat${s}`](this.cursor, n, true);	1✔
91	this.cursor += s / 8;	1✔
92	this.updateWritten();	1✔
93	}
94
95	putA(a: Uint8Array) {
96	this.maybeExpand(a.byteLength);	32✔
97	new Uint8Array(this._buffer, this.cursor, a.byteLength).set(a);	32✔
98	this.cursor += a.byteLength;	32✔
99	this.updateWritten();	32✔
100	}
101
102	align(n: number) {
103	const rem = this.cursor % n;	64✔
104	if (rem === 0) {	64✔
105	return;	58✔
106	}
107	this.cursor += n - rem;	6✔
108	}
109
110	asArray(): Uint8Array {
111	return new Uint8Array(this._buffer.slice(0, this._written));	73✔
112	}
113
114	get written(): number {
115	return this._written;	×
116	}
117	}

source-academy / py-slang / 28796963159

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous