pi-dev-team 0.2.0

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/distribution/uniformFloat32.js

@@ -0,0 +1,17 @@
+//#region src/distribution/uniformFloat32.ts
+const scale = 5.960464477539063e-8;
+const mask = 16777215;
+/**
+* Uniformly generate random 32-bit floating point values between 0 (included) and 1 (excluded)
+*
+* @remarks Generated values are multiples of 2**-24, providing 24 bits of randomness.
+*
+* @param rng - Instance of RandomGenerator to extract random values from
+*
+* @public
+*/
+function uniformFloat32(rng) {
+	return (rng.next() & mask) * scale;
+}
+//#endregion
+export { uniformFloat32 };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/distribution/uniformFloat64.d.ts

@@ -0,0 +1,15 @@
+import { t as RandomGenerator } from "../RandomGenerator-DcXj09Ch.js";
+
+//#region src/distribution/uniformFloat64.d.ts
+/**
+* Uniformly generate random 64-bit floating point values between 0 (included) and 1 (excluded)
+*
+* @remarks Generated values are multiples of 2**-53, providing 53 bits of randomness.
+*
+* @param rng - Instance of RandomGenerator to extract random values from
+*
+* @public
+*/
+declare function uniformFloat64(rng: RandomGenerator): number;
+//#endregion
+export { uniformFloat64 };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/distribution/uniformFloat64.js

@@ -0,0 +1,21 @@
+//#region src/distribution/uniformFloat64.ts
+const scale26 = 1.4901161193847656e-8;
+const scale53 = 11102230246251565e-32;
+const mask1 = 67108863;
+const mask2 = 134217727;
+/**
+* Uniformly generate random 64-bit floating point values between 0 (included) and 1 (excluded)
+*
+* @remarks Generated values are multiples of 2**-53, providing 53 bits of randomness.
+*
+* @param rng - Instance of RandomGenerator to extract random values from
+*
+* @public
+*/
+function uniformFloat64(rng) {
+	const value1 = rng.next() & mask1;
+	const value2 = rng.next() & mask2;
+	return value1 * scale26 + value2 * scale53;
+}
+//#endregion
+export { uniformFloat64 };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/distribution/uniformInt.d.ts

@@ -0,0 +1,15 @@
+import { t as RandomGenerator } from "../RandomGenerator-DcXj09Ch.js";
+
+//#region src/distribution/uniformInt.d.ts
+/**
+* Uniformly generate random integer values between `from` (included) and `to` (included)
+*
+* @param rng - Instance of RandomGenerator to extract random values from
+* @param from - Lower bound of the range (included)
+* @param to - Upper bound of the range (included)
+*
+* @public
+*/
+declare function uniformInt(rng: RandomGenerator, from: number, to: number): number;
+//#endregion
+export { uniformInt };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/distribution/uniformInt.js

@@ -0,0 +1,133 @@
+//#region src/distribution/internals/uniformIntInternal.ts
+/**
+* Uniformly generate number in range [0 ; rangeSize[
+* With rangeSize <= 0x100000000
+* @internal
+*/
+function uniformIntInternal(rng, rangeSize) {
+	const MaxAllowed = rangeSize > 2 ? ~~(4294967296 / rangeSize) * rangeSize : 4294967296;
+	let deltaV = rng.next() + 2147483648;
+	while (deltaV >= MaxAllowed) deltaV = rng.next() + 2147483648;
+	return deltaV % rangeSize;
+}
+//#endregion
+//#region src/distribution/internals/ArrayInt64.ts
+/**
+* We only accept safe integers here
+* @internal
+*/
+function fromNumberToArrayInt64(out, n) {
+	if (n < 0) {
+		const posN = -n;
+		out.sign = -1;
+		out.data[0] = ~~(posN / 4294967296);
+		out.data[1] = posN >>> 0;
+	} else {
+		out.sign = 1;
+		out.data[0] = ~~(n / 4294967296);
+		out.data[1] = n >>> 0;
+	}
+	return out;
+}
+/**
+* Substract two ArrayInt of 64 bits on 64 bits.
+* With arrayIntA - arrayIntB >= 0
+* @internal
+*/
+function substractArrayInt64(out, arrayIntA, arrayIntB) {
+	const lowA = arrayIntA.data[1];
+	const highA = arrayIntA.data[0];
+	const signA = arrayIntA.sign;
+	const lowB = arrayIntB.data[1];
+	const highB = arrayIntB.data[0];
+	const signB = arrayIntB.sign;
+	out.sign = 1;
+	if (signA === 1 && signB === -1) {
+		const low = lowA + lowB;
+		const high = highA + highB + (low > 4294967295 ? 1 : 0);
+		out.data[0] = high >>> 0;
+		out.data[1] = low >>> 0;
+		return out;
+	}
+	let lowFirst = lowA;
+	let highFirst = highA;
+	let lowSecond = lowB;
+	let highSecond = highB;
+	if (signA === -1) {
+		lowFirst = lowB;
+		highFirst = highB;
+		lowSecond = lowA;
+		highSecond = highA;
+	}
+	let reminderLow = 0;
+	let low = lowFirst - lowSecond;
+	if (low < 0) {
+		reminderLow = 1;
+		low = low >>> 0;
+	}
+	out.data[0] = highFirst - highSecond - reminderLow;
+	out.data[1] = low;
+	return out;
+}
+//#endregion
+//#region src/distribution/internals/uniformArrayIntInternal.ts
+/**
+* Uniformly generate ArrayInt64 in range [0 ; rangeSize[
+*
+* @remarks
+* In the worst case scenario it may discard half of the randomly generated value.
+* Worst case being: most significant number is 1 and remaining part evaluates to 0.
+*
+* @internal
+*/
+function uniformArrayIntInternal(rng, out, rangeSize) {
+	const maxIndex0 = rangeSize[0] + 1;
+	out[0] = uniformIntInternal(rng, maxIndex0);
+	out[1] = uniformIntInternal(rng, 4294967296);
+	while (out[0] >= rangeSize[0] && (out[0] !== rangeSize[0] || out[1] >= rangeSize[1])) {
+		out[0] = uniformIntInternal(rng, maxIndex0);
+		out[1] = uniformIntInternal(rng, 4294967296);
+	}
+	return out;
+}
+//#endregion
+//#region src/distribution/uniformInt.ts
+const safeNumberMaxSafeInteger = Number.MAX_SAFE_INTEGER;
+const sharedA = {
+	sign: 1,
+	data: [0, 0]
+};
+const sharedB = {
+	sign: 1,
+	data: [0, 0]
+};
+const sharedC = {
+	sign: 1,
+	data: [0, 0]
+};
+const sharedData = [0, 0];
+function uniformLargeIntInternal(rng, from, to, rangeSize) {
+	const rangeSizeArrayIntValue = rangeSize <= safeNumberMaxSafeInteger ? fromNumberToArrayInt64(sharedC, rangeSize) : substractArrayInt64(sharedC, fromNumberToArrayInt64(sharedA, to), fromNumberToArrayInt64(sharedB, from));
+	if (rangeSizeArrayIntValue.data[1] === 4294967295) {
+		rangeSizeArrayIntValue.data[0] += 1;
+		rangeSizeArrayIntValue.data[1] = 0;
+	} else rangeSizeArrayIntValue.data[1] += 1;
+	uniformArrayIntInternal(rng, sharedData, rangeSizeArrayIntValue.data);
+	return sharedData[0] * 4294967296 + sharedData[1] + from;
+}
+/**
+* Uniformly generate random integer values between `from` (included) and `to` (included)
+*
+* @param rng - Instance of RandomGenerator to extract random values from
+* @param from - Lower bound of the range (included)
+* @param to - Upper bound of the range (included)
+*
+* @public
+*/
+function uniformInt(rng, from, to) {
+	const rangeSize = to - from;
+	if (rangeSize <= 4294967295) return uniformIntInternal(rng, rangeSize + 1) + from;
+	return uniformLargeIntInternal(rng, from, to, rangeSize);
+}
+//#endregion
+export { uniformInt };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/generator/congruential32.d.ts

@@ -0,0 +1,7 @@
+import { JumpableRandomGenerator } from "../types/JumpableRandomGenerator.js";
+
+//#region src/generator/congruential32.d.ts
+declare function congruential32FromState(state: readonly number[]): JumpableRandomGenerator;
+declare function congruential32(seed: number): JumpableRandomGenerator;
+//#endregion
+export { congruential32, congruential32FromState };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/generator/congruential32.js

@@ -0,0 +1,44 @@
+//#region src/generator/congruential32.ts
+const MULTIPLIER = 214013;
+const INCREMENT = 2531011;
+const MASK = 4294967295;
+const MASK_2 = -2147483649;
+const MULTIPLIER_2 = -1443076087;
+const INCREMENT_2 = 505908858;
+const MULTIPLIER_3 = 1170746341;
+const INCREMENT_3 = -755606699;
+const JUMP_MULTIPLIER = 1994129409;
+const JUMP_INCREMENT = 916127744;
+var LinearCongruential32 = class LinearCongruential32 {
+	constructor(seed) {
+		this.seed = seed;
+	}
+	clone() {
+		return new LinearCongruential32(this.seed);
+	}
+	next() {
+		const s0 = this.seed;
+		const s1 = Math.imul(s0, MULTIPLIER) + INCREMENT | 0;
+		const s2 = Math.imul(s0, MULTIPLIER_2) + INCREMENT_2 | 0;
+		const s3 = Math.imul(s0, MULTIPLIER_3) + INCREMENT_3 | 0;
+		this.seed = s3;
+		const v1 = (s1 & MASK_2) >> 16;
+		const v2 = (s2 & MASK_2) >> 16;
+		return (s3 & MASK_2) >> 16 | v2 << 15 | v1 << 30;
+	}
+	jump() {
+		this.seed = Math.imul(this.seed, JUMP_MULTIPLIER) + JUMP_INCREMENT & MASK;
+	}
+	getState() {
+		return [this.seed];
+	}
+};
+function congruential32FromState(state) {
+	if (!(state.length === 1)) throw new Error("The state must have been produced by a congruential32 RandomGenerator");
+	return new LinearCongruential32(state[0]);
+}
+function congruential32(seed) {
+	return new LinearCongruential32(seed);
+}
+//#endregion
+export { congruential32, congruential32FromState };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/generator/mersenne.d.ts

@@ -0,0 +1,7 @@
+import { JumpableRandomGenerator } from "../types/JumpableRandomGenerator.js";
+
+//#region src/generator/mersenne.d.ts
+declare function mersenneFromState(state: readonly number[]): JumpableRandomGenerator;
+declare function mersenne(seed: number): JumpableRandomGenerator;
+//#endregion
+export { mersenne, mersenneFromState };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/generator/mersenne.js

@@ -0,0 +1,90 @@
+//#region src/generator/mersenne.ts
+const N = 624;
+const M = 397;
+const A = 2567483615;
+const F = 1812433253;
+const U = 11;
+const S = 7;
+const B = 2636928640;
+const T = 15;
+const C = 4022730752;
+const L = 18;
+const MASK_LOWER = 2147483647;
+const MASK_UPPER = 2147483648;
+const JUMP_COEFS = "SUSgbA\\W`E[]KN2RUSo8XVU?HKBFRl11E\\KoWOg5B]XEWG;BE;1:oVK[`B^Z9Qd23^XTnhL>]Unda4f[X;_j9H5QD=cN<5H`3bW>9bk1mjoI2fK0obmAAINOV:>Mek_V9dd<hZ\\gC3?Fm7FEk07QH_3PLm^@?^i\\QMkgP<]oLHmFnlecg5F@7U^@4jhZ?WZS0k@GHehmM36:5^9;>Hmm`co>k:KOSkSbIINb1VFf>LXgP>GUAQTD>Ci>XMGkUflLlb?_FaFUk@?5N7i70@;1o68ah@I<HFH7R2^J:G][Gf962ITWID9GWK8ElD2G5=DcHcL]cA]P2n7A=[<bInM;IHDQnJMReRXDWbVldnGEIPij`E08Xdci3@0c:IBbD4:Nk]?lEN9j^;T`0blZX7eiWE8c`<ak7j05FZi>AjUDh?M1B?^??FAXKThf<aBOXZf7jXYGK>R<;NHk3S9YhM7STJ6`:MIE`S@7298X8W>PNK=@;lLX<i\\TXLL<W@X[X54H]in8M;;n?kkQbajgAMY=Tf9b;ZKf0QUB2FHYWfnfkDoU9YkcLd95T>lK6GM1YL\\lid:J>KYS=iJ]Y>QlF>?R5_[5QeYC=66;A32Ac>OHk_ne^0g>bK:g;KFPgbGUcPR_Z=TX3H9d03bKZ2IhEPKBo>LSGWd0iFdV8C<Y:<>T[O6lC\\blaZ>GoAYP4clf^j1IfnZJ]QeDe2X<HE[LJNWnaCg[P]Co^:IRbWPY?97UePBlZNNHY6LOBM8P>=h?Ye:_f_Sb9Ki5GDYBF4dWeMfdg^ccPllNWM7G1\\UMdoYeOOD5^e@foA22G?ADYo5:FVG[bWo96;>3kc_c1Ab30>30;1@4F8g2hY?DJ4[LOL;ZLLKo2]jo>[KMDUcR279N_kF=3WL@Dd620bMTdA\\U9k``ef2iD9JgJ8CZBHS>F^Uk;<laeaeHS<15OSeS`PcSSKBRBFY]aQ=EgUXGNg=?d56`KA@2BejY0^[_DCX`L=CGMT=BW^6S1i@2ATBVk>3_ocRA>2U:4GPQ6o>5jX2HIcV3S@On6KB<[SKB?FC_AAji9agbBFkAi\\;4I\\UJ]c36Ub@[;gQACVGY<V]SDJBUU]La\\_a@JdOO8gm2T0DJMa:8Hf7>E]noQ[1Kambn??QQ]S?1i0oMGOijb\\aGY6lQ^CJ?9bFle8<eH4UUjBINX;n8@VOA5ah^URV49B[A?ONHhHAC1J5;;h0SXYlG^0W=eJdHh^K4SGe=1HZLLam;D<Q3AOdbPcdX``82\\jo0En8jRVGC73WMCF9`d:0heS?80?C188cSn7H9<daZ]MgS4Pb^1HkA:1PU^5>^h_g[RQV@PnYBRI_]`B]Bh@Uk03eXGY`I16L76H28X`R>IROMeNVUdU[:lghLhPCQZ:4a<30YBZCYnXe[?;jc8gKI2QH2MjnWBm4nGCZW`aVU2a;P<AMI25mlW_Nm][2?b6o851X@lAm]YZ`bWRF1g<Ga:T]1NXH5Veja5P9S9>:aNg:Th1Y=5o78K>LQ8hW@5S?I83Lk5Xk;j5@I3o[d:4RjE^oS30:WP9gC\\i8aSI>QRE@4lP:7lDg8g2`Ql[2I8aBU\\BQ?B4_clL9Q]S;^e1Ob5[>3JER2`c7B=o]fPOWO<DGi;Niba1PoWPPE_Q3aX0OB0mZej\\f_M[J4Y6]1`h2MkF[GiW8Q^d3^_=<I1N2Q7]2<2j[iP7V3V821FaI]A`93bC^Z\\G=WJ;^Ih?B97_iIF@\\Dl<eK1je8SNTWo_=XFMZH<<JYLZ^YQMPgYOV45K_:]kSI8^XlO0]GY=VUfe_C_F6TOcoAlVUH:o=WhhT@K`2KFhe<3\\KXQ>W:M?S_4S5d@J^`[AGA7@3]DnGSCO`\\?E8HT75^d9\\:m\\m1egIfk8cd6bD9\\eU8\\n[Pb0Cgd^S0n9kGJHb]i5XodlKHc34Fhi9K>0U5WK`>7Ff2^KL=WC6:kc?e5C^a1T1:4:^S5flXlGNIj08AfO?Dh7T7dWO>E]NI9?ob7B7P_h[4TEP[EU;GllFTnSmg9:\\[N]<SAoKP_kPlG56A:I3T6EG8Hj=XnUE`KT5U@OQ?]7[N^MFN1_NU4KO_3::Le`8IL9[1Z1H1;V3SC\\N3]S@4U[F2mhT5dYM7[4Pg_Na0_8WTH0`bgceQS8]EG;XgD4Ib4iLTP@kE79Mn>AYRJA1U5^Blhgno:aHVYc03c3J0Vc9FjEV^M75Zfd8kVC9>iJDk`AJ[6f7DK2D^DL\\AX:6b5h31XH;RQB\\N<ZSM=J;6L[`UW^eOIFc1Y]6_dfedIe4ARh72mTXC0WND_IDHVCZRDE0eODARCEETQI5TPUQE=jEH5bS?LP[ai`F5ABRYDo2o\\@=]GT?_9;hc4Lm:\\SF9k1T<0E@fX9BG[]g0nY7k[Qmi@la8`PF0j6@Q?Ii7bLkXQ<lLHf]`:DCh@9JY5>hEVLTdhL\\b1EB0lLh<=WaO@F<;8g<d:@e:LA:cFIEdmQh7hNHfSRToW?8N4:Z1K;XEDRO;OIDh<UdVln?bjgL>?VE98[B\\K<BVjkG8LiSX;fb>jf?DUK00Aih<WY6QD6cEnHBZ8iN_fd<G8Ci`11RUW2QlW]IXV:m?;J0GXXHfGNQ>:D`=fLPbO?VOTEYLj^cNj5PM>jKB5HVjJ4U7lXaTQNL9<@\\1`m\\Ug@VQHd7>jW=ca0`miF7;N0F=GjoQ`RFchKMGTmn8cF@Oh4GGCm7m2`U9j93Tb>=kSERjE_J939F01I1;`<ijk_=_Vn=7RVAI6fnQI5KlF:C44bN<<8K=Z<2TP<1]5?<dB>^LA=ebloE2Y2:9lkh0\\<YKbHD97iE`<C5oj^1>X:??`H6BXF2hG1Q[dF0Q=>W=J?7C\\k1T?<;R44oW?1hY^G8Zm]ZKnfOf0eCFYo6?=D8?<`6HU5SXh1;=:23LmV_FSi;OJfV<^?GkIDPISeHg1LaGE:V3Y3K3H<QJfbY?=;ldZRhnhQT_mGXDLFXXhSONE6Do_0iNZagB:BPGOTH;VhHUTd6LhQm^[;dO]5Hlkg<R:F<Kn\\:I:EGojgWZ2X@SYO_dlH;G8S<>oEKabY`:oU;=JW7ig?S?EYb86b7n8ce\\]IRa]koiWY<RfO;5kUI;7lVeC?[@ZaXDiF04B8R]bg@>O<mQDoUcBLcf^f>m2kMBUloD>Ze@NN^Z11TM`inXYhE_I=kA`:ZF4d\\>`L@;ZP[`ENU5cL[BV6\\Z?Di76:jg3hE6oG6jFc8kP=[GS1;WSedYQW1:U4\\OF32GgmMC<AjO]872bdBb`bKAA?8j78b>T3VfcUB2m4J^CPRU;8dScI]LU]^bBYA5_3:Y0N5i^?200000";
+var MersenneTwister = class MersenneTwister {
+	constructor(states, index) {
+		this.states = states;
+		this.index = index;
+	}
+	clone() {
+		return new MersenneTwister(this.states.slice(), this.index);
+	}
+	next() {
+		let y = this.states[this.index];
+		y ^= y >>> U;
+		y ^= y << S & B;
+		y ^= y << T & C;
+		y ^= y >>> L;
+		this.index = twistedNext(this.states, this.index);
+		return y;
+	}
+	getState() {
+		return [this.index, ...this.states];
+	}
+	jump() {
+		const originalStates = this.states.slice();
+		const originalIndex = this.index;
+		this.index = twistedNext(this.states, this.index);
+		for (let i = 19932; i > 0; --i) {
+			if (JUMP_COEFS.charCodeAt(i / 6 | 0) - 48 & 1 << i % 6) addState(this.states, this.index, originalStates, originalIndex);
+			this.index = twistedNext(this.states, this.index);
+		}
+		addState(this.states, this.index, originalStates, originalIndex);
+	}
+};
+function addState(mt, idx, originalMt, originalIdx) {
+	let i = 0;
+	if (originalIdx >= idx) {
+		for (; i < N - originalIdx; i++) mt[i + idx] ^= originalMt[i + originalIdx];
+		for (; i < N - idx; i++) mt[i + idx] ^= originalMt[i + originalIdx - N];
+		for (; i < N; i++) mt[i + idx - N] ^= originalMt[i + originalIdx - N];
+	} else {
+		for (; i < N - idx; i++) mt[i + idx] ^= originalMt[i + originalIdx];
+		for (; i < N - originalIdx; i++) mt[i + idx - N] ^= originalMt[i + originalIdx];
+		for (; i < N; i++) mt[i + idx - N] ^= originalMt[i + originalIdx - N];
+	}
+}
+function twistedNext(mt, idx) {
+	if (idx < N - M) {
+		const y = mt[idx] & MASK_UPPER | mt[idx + 1] & MASK_LOWER;
+		mt[idx] = mt[idx + M] ^ y >>> 1 ^ -(y & 1) & A;
+		return idx + 1;
+	} else if (idx < N - 1) {
+		const y = mt[idx] & MASK_UPPER | mt[idx + 1] & MASK_LOWER;
+		mt[idx] = mt[idx + M - N] ^ y >>> 1 ^ -(y & 1) & A;
+		return idx + 1;
+	} else {
+		const y = mt[idx] & MASK_UPPER | mt[0] & MASK_LOWER;
+		mt[idx] = mt[M - 1] ^ y >>> 1 ^ -(y & 1) & A;
+		return 0;
+	}
+}
+function twist(mt) {
+	for (let idx = 0; idx !== N; ++idx) twistedNext(mt, idx);
+}
+function mersenneFromState(state) {
+	if (!(state.length === 625 && state[0] >= 0 && state[0] < N)) throw new Error("The state must have been produced by a mersenne RandomGenerator");
+	return new MersenneTwister(state.slice(1), state[0]);
+}
+function mersenne(seed) {
+	const out = [seed | 0];
+	for (let idx = 1; idx !== N; ++idx) {
+		const xored = out[idx - 1] ^ out[idx - 1] >>> 30;
+		out.push(Math.imul(F, xored) + idx | 0);
+	}
+	twist(out);
+	return new MersenneTwister(out, 0);
+}
+//#endregion
+export { mersenne, mersenneFromState };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/generator/xoroshiro128plus.d.ts

@@ -0,0 +1,7 @@
+import { JumpableRandomGenerator } from "../types/JumpableRandomGenerator.js";
+
+//#region src/generator/xoroshiro128plus.d.ts
+declare function xoroshiro128plusFromState(state: readonly number[]): JumpableRandomGenerator;
+declare function xoroshiro128plus(seed: number): JumpableRandomGenerator;
+//#endregion
+export { xoroshiro128plus, xoroshiro128plusFromState };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/generator/xoroshiro128plus.js

@@ -0,0 +1,80 @@
+//#region src/generator/xoroshiro128plus.ts
+const jumps = [
+	3639956645,
+	3750757012,
+	1261568508,
+	386426335
+];
+var XoroShiro128Plus = class XoroShiro128Plus {
+	constructor(s01, s00, s11, s10) {
+		this.s01 = s01;
+		this.s00 = s00;
+		this.s11 = s11;
+		this.s10 = s10;
+	}
+	clone() {
+		return new XoroShiro128Plus(this.s01, this.s00, this.s11, this.s10);
+	}
+	next() {
+		const out = this.s00 + this.s10 | 0;
+		const a0 = this.s10 ^ this.s00;
+		const a1 = this.s11 ^ this.s01;
+		const s00 = this.s00;
+		const s01 = this.s01;
+		this.s00 = s00 << 24 ^ s01 >>> 8 ^ a0 ^ a0 << 16;
+		this.s01 = s01 << 24 ^ s00 >>> 8 ^ a1 ^ (a1 << 16 | a0 >>> 16);
+		this.s10 = a1 << 5 ^ a0 >>> 27;
+		this.s11 = a0 << 5 ^ a1 >>> 27;
+		return out;
+	}
+	jump() {
+		let ns01 = 0;
+		let ns00 = 0;
+		let ns11 = 0;
+		let ns10 = 0;
+		let s01 = this.s01;
+		let s00 = this.s00;
+		let s11 = this.s11;
+		let s10 = this.s10;
+		for (let i = 0; i !== 4; ++i) {
+			const ji = jumps[i];
+			for (let mask = 1; mask; mask <<= 1) {
+				if (ji & mask) {
+					ns01 ^= s01;
+					ns00 ^= s00;
+					ns11 ^= s11;
+					ns10 ^= s10;
+				}
+				const a0 = s10 ^ s00;
+				const a1 = s11 ^ s01;
+				const s00_ = s00;
+				const s01_ = s01;
+				s00 = s00_ << 24 ^ s01_ >>> 8 ^ a0 ^ a0 << 16;
+				s01 = s01_ << 24 ^ s00_ >>> 8 ^ a1 ^ (a1 << 16 | a0 >>> 16);
+				s10 = a1 << 5 ^ a0 >>> 27;
+				s11 = a0 << 5 ^ a1 >>> 27;
+			}
+		}
+		this.s01 = ns01;
+		this.s00 = ns00;
+		this.s11 = ns11;
+		this.s10 = ns10;
+	}
+	getState() {
+		return [
+			this.s01,
+			this.s00,
+			this.s11,
+			this.s10
+		];
+	}
+};
+function xoroshiro128plusFromState(state) {
+	if (!(state.length === 4)) throw new Error("The state must have been produced by a xoroshiro128plus RandomGenerator");
+	return new XoroShiro128Plus(state[0], state[1], state[2], state[3]);
+}
+function xoroshiro128plus(seed) {
+	return new XoroShiro128Plus(-1, ~seed, seed | 0, 0);
+}
+//#endregion
+export { xoroshiro128plus, xoroshiro128plusFromState };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/generator/xorshift128plus.d.ts

@@ -0,0 +1,7 @@
+import { JumpableRandomGenerator } from "../types/JumpableRandomGenerator.js";
+
+//#region src/generator/xorshift128plus.d.ts
+declare function xorshift128plusFromState(state: readonly number[]): JumpableRandomGenerator;
+declare function xorshift128plus(seed: number): JumpableRandomGenerator;
+//#endregion
+export { xorshift128plus, xorshift128plusFromState };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/generator/xorshift128plus.js

@@ -0,0 +1,78 @@
+//#region src/generator/xorshift128plus.ts
+const jumps = [
+	1667051007,
+	2321340297,
+	1548169110,
+	304075285
+];
+var XorShift128Plus = class XorShift128Plus {
+	constructor(s01, s00, s11, s10) {
+		this.s01 = s01;
+		this.s00 = s00;
+		this.s11 = s11;
+		this.s10 = s10;
+	}
+	clone() {
+		return new XorShift128Plus(this.s01, this.s00, this.s11, this.s10);
+	}
+	next() {
+		const a0 = this.s00 ^ this.s00 << 23;
+		const a1 = this.s01 ^ (this.s01 << 23 | this.s00 >>> 9);
+		const s10 = this.s10;
+		const s11 = this.s11;
+		const out = this.s00 + s10 | 0;
+		this.s01 = s11;
+		this.s00 = s10;
+		this.s11 = a1 ^ s11 ^ a1 >>> 18 ^ s11 >>> 5;
+		this.s10 = a0 ^ s10 ^ (a0 >>> 18 | a1 << 14) ^ (s10 >>> 5 | s11 << 27);
+		return out;
+	}
+	jump() {
+		let ns01 = 0;
+		let ns00 = 0;
+		let ns11 = 0;
+		let ns10 = 0;
+		let s01 = this.s01;
+		let s00 = this.s00;
+		let s11 = this.s11;
+		let s10 = this.s10;
+		for (let i = 0; i !== 4; ++i) {
+			const ji = jumps[i];
+			for (let mask = 1; mask; mask <<= 1) {
+				if (ji & mask) {
+					ns01 ^= s01;
+					ns00 ^= s00;
+					ns11 ^= s11;
+					ns10 ^= s10;
+				}
+				const a0 = s00 ^ s00 << 23;
+				const a1 = s01 ^ (s01 << 23 | s00 >>> 9);
+				s01 = s11;
+				s00 = s10;
+				s10 = a0 ^ s10 ^ (a0 >>> 18 | a1 << 14) ^ (s10 >>> 5 | s11 << 27);
+				s11 = a1 ^ s11 ^ a1 >>> 18 ^ s11 >>> 5;
+			}
+		}
+		this.s01 = ns01;
+		this.s00 = ns00;
+		this.s11 = ns11;
+		this.s10 = ns10;
+	}
+	getState() {
+		return [
+			this.s01,
+			this.s00,
+			this.s11,
+			this.s10
+		];
+	}
+};
+function xorshift128plusFromState(state) {
+	if (!(state.length === 4)) throw new Error("The state must have been produced by a xorshift128plus RandomGenerator");
+	return new XorShift128Plus(state[0], state[1], state[2], state[3]);
+}
+function xorshift128plus(seed) {
+	return new XorShift128Plus(-1, ~seed, seed | 0, 0);
+}
+//#endregion
+export { xorshift128plus, xorshift128plusFromState };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/types/JumpableRandomGenerator.d.ts

@@ -0,0 +1,16 @@
+import { t as RandomGenerator } from "../RandomGenerator-DcXj09Ch.js";
+
+//#region src/types/JumpableRandomGenerator.d.ts
+interface JumpableRandomGenerator extends RandomGenerator {
+  /** Produce a fully independent clone of the current instance */
+  clone(): JumpableRandomGenerator;
+  /**
+  * Jump current generator
+  *
+  * Move the generator forward by an extremely large number of steps in its sequence.
+  * This is typically a number so large that it would be infeasible to reach by repeated `next()` calls.
+  */
+  jump(): void;
+}
+//#endregion
+export { JumpableRandomGenerator };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/types/RandomGenerator.d.ts

@@ -0,0 +1,2 @@
+import { t as RandomGenerator } from "../RandomGenerator-DcXj09Ch.js";
+export { RandomGenerator };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/utils/generateN.d.ts

@@ -0,0 +1,6 @@
+import { t as RandomGenerator } from "../RandomGenerator-DcXj09Ch.js";
+
+//#region src/utils/generateN.d.ts
+declare function generateN(rng: RandomGenerator, num: number): number[];
+//#endregion
+export { generateN };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/utils/generateN.js

@@ -0,0 +1,8 @@
+//#region src/utils/generateN.ts
+function generateN(rng, num) {
+	const out = [];
+	for (let idx = 0; idx !== num; ++idx) out.push(rng.next());
+	return out;
+}
+//#endregion
+export { generateN };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/utils/purify.d.ts

@@ -0,0 +1,12 @@
+import { t as RandomGenerator } from "../RandomGenerator-DcXj09Ch.js";
+import { JumpableRandomGenerator } from "../types/JumpableRandomGenerator.js";
+
+//#region src/utils/purify.d.ts
+/**
+* Transform an operation on a RandomGenerator into a pure version of it
+* @param action - The transform operation to make pure
+*/
+declare function purify<TArgs extends unknown[], TReturn>(action: (rng: RandomGenerator, ...args: TArgs) => TReturn): (rng: RandomGenerator, ...args: TArgs) => [TReturn, RandomGenerator];
+declare function purify<TArgs extends unknown[], TReturn>(action: (rng: JumpableRandomGenerator, ...args: TArgs) => TReturn): (rng: JumpableRandomGenerator, ...args: TArgs) => [TReturn, JumpableRandomGenerator];
+//#endregion
+export { purify };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/utils/purify.js

@@ -0,0 +1,9 @@
+//#region src/utils/purify.ts
+function purify(action) {
+	return (rng, ...args) => {
+		const clonedRng = rng.clone();
+		return [action(clonedRng, ...args), clonedRng];
+	};
+}
+//#endregion
+export { purify };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/utils/skipN.d.ts

@@ -0,0 +1,6 @@
+import { t as RandomGenerator } from "../RandomGenerator-DcXj09Ch.js";
+
+//#region src/utils/skipN.d.ts
+declare function skipN(rng: RandomGenerator, num: number): void;
+//#endregion
+export { skipN };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/esm/utils/skipN.js

@@ -0,0 +1,6 @@
+//#region src/utils/skipN.ts
+function skipN(rng, num) {
+	for (let idx = 0; idx !== num; ++idx) rng.next();
+}
+//#endregion
+export { skipN };

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/generator/congruential32.d.ts

@@ -0,0 +1,7 @@
+import { JumpableRandomGenerator } from "../types/JumpableRandomGenerator.js";
+
+//#region src/generator/congruential32.d.ts
+declare function congruential32FromState(state: readonly number[]): JumpableRandomGenerator;
+declare function congruential32(seed: number): JumpableRandomGenerator;
+//#endregion
+export { congruential32, congruential32FromState };