pi-dev-team 0.2.0

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/fast-check/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "fast-check",
+  "version": "4.10.2",
+  "description": "Property based testing framework for JavaScript (like QuickCheck)",
+  "type": "module",
+  "main": "lib/fast-check.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "require": {
+        "types@<5.7": "./lib/cjs/types57/fast-check.d.ts",
+        "types": "./lib/cjs/fast-check.d.ts",
+        "default": "./lib/cjs/fast-check.js"
+      },
+      "import": {
+        "types@<5.7": "./lib/types57/fast-check.d.ts",
+        "types": "./lib/fast-check.d.ts",
+        "default": "./lib/fast-check.js"
+      }
+    }
+  },
+  "module": "lib/fast-check.js",
+  "types": "lib/fast-check.d.ts",
+  "typesVersions": {
+    "<5.7": {
+      "lib/fast-check.d.ts": [
+        "lib/types57/fast-check.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "lib"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dubzzz/fast-check.git",
+    "directory": "packages/fast-check"
+  },
+  "author": "Nicolas DUBIEN <github@dubien.org>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/dubzzz/fast-check/issues"
+  },
+  "homepage": "https://fast-check.dev/",
+  "engines": {
+    "node": ">=12.17.0"
+  },
+  "dependencies": {
+    "pure-rand": "^8.0.0"
+  },
+  "devDependencies": {
+    "@microsoft/api-extractor": "^7.59.1",
+    "@types/node": "^24.13.4",
+    "not-node-buffer": "npm:buffer@^6.0.3",
+    "regexp-tree": "^0.1.27",
+    "typescript": "~6.0.3",
+    "vitest": "^4.1.10",
+    "@fast-check/poisoning": "0.3.1",
+    "fast-check": "4.10.2"
+  },
+  "keywords": [
+    "property-based testing",
+    "end-to-end testing",
+    "unit testing",
+    "testing",
+    "quickcheck",
+    "faker",
+    "fuzzer",
+    "fuzz",
+    "jest",
+    "vitest",
+    "random"
+  ],
+  "funding": [
+    {
+      "type": "individual",
+      "url": "https://github.com/sponsors/dubzzz"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/fast-check"
+    }
+  ],
+  "scripts": {
+    "build:post-build": "sed -i 's/^declare namespace fast_check_default_d_exports {/\\/\\*\\* @public \\*\\/ declare namespace fast_check_default_d_exports {/' lib/fast-check.d.ts && sed -i 's/fast_check_default_d_exports/fc/' lib/fast-check.d.ts && mkdir -p lib/types57 && cp lib/*.d.ts lib/types57/ && for f in lib/types57/*.d.ts; do [ -f \"$f\" ] && sed -i 's/Array<ArrayBuffer>>/Array>/g' \"$f\"; done && cp lib/*.d.ts lib/cjs/ && cp -r lib/types57 lib/cjs/ && cp package.cjs-template.json lib/cjs/package.json",
+    "build": "rolldown -c && pnpm run build:post-build",
+    "build-ci": "rolldown -c && pnpm run build:post-build",
+    "typecheck": "tsc --noEmit",
+    "test-bundle": "for f in test-bundle/*.mjs test-bundle/*.cjs; do [ -f \"$f\" ] && echo \"Running ${f##*/}\" && node \"$f\" || exit 1; done",
+    "test-legacy-bundle": "nvs add 12.17.0 && for f in test-bundle/*.cjs; do [ -f \"$f\" ] && echo \"Running ${f##*/}\" && $(nvs which 12.17.0) \"$f\" || exit 1; done",
+    "api-extractor": "api-extractor run --local"
+  }
+}

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Nicolas DUBIEN
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/README.md

@@ -0,0 +1,168 @@
+<h1>
+  <img src="https://raw.githubusercontent.com/dubzzz/pure-rand/main/assets/logo.svg" alt="pure-rand logo" />
+</h1>
+
+Fast Pseudorandom number generators (aka PRNG) with purity in mind!
+
+[![Build Status](https://github.com/dubzzz/pure-rand/actions/workflows/build-status.yml/badge.svg?branch=main)](https://github.com/dubzzz/pure-rand/actions)
+[![NPM Version](https://badge.fury.io/js/pure-rand.svg)](https://badge.fury.io/js/pure-rand)
+[![Monthly Downloads](https://img.shields.io/npm/dm/pure-rand)](https://www.npmjs.com/package/pure-rand)
+
+[![Codecov](https://codecov.io/gh/dubzzz/pure-rand/branch/main/graph/badge.svg)](https://codecov.io/gh/dubzzz/pure-rand)
+[![Package Quality](https://packagequality.com/shield/pure-rand.svg)](https://packagequality.com/#?package=pure-rand)
+[![Tested with fast-check](https://img.shields.io/badge/tested%20with-fast%E2%80%91check%20%F0%9F%90%92-%23282ea9?style=flat&logoSize=auto&labelColor=%231b1b1d)](https://fast-check.dev/)
+
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/dubzzz/pure-rand/labels/good%20first%20issue)
+[![License](https://img.shields.io/npm/l/pure-rand.svg)](https://github.com/dubzzz/pure-rand/blob/main/LICENSE)
+[![Share on Bluesky](https://img.shields.io/badge/share%20on-Bluesky-0285FF?logo=bluesky&logoColor=white)](https://bsky.app/intent/compose?text=pure-rand%20%E2%80%94%20fast%20and%20pure%20pseudorandom%20number%20generators%20for%20JS%2FTS.%20Perfect%20for%20reproducible%20randomness!%20%F0%9F%8E%B2%0A%0Ahttps%3A%2F%2Fgithub.com%2Fdubzzz%2Fpure-rand%0A%0Aby%20%40nicolas.dubien.me)
+
+## Getting started
+
+**Install it in node via:**
+
+`npm install pure-rand` or `yarn add pure-rand`
+
+## Usage
+
+**Simple usage**
+
+```javascript
+import { uniformInt } from 'pure-rand/distribution/uniformInt';
+import { xoroshiro128plus } from 'pure-rand/generator/xoroshiro128plus';
+
+const seed = 42;
+const rng = xoroshiro128plus(seed);
+const firstDiceValue = uniformInt(rng, 1, 6); // value in {1..6}, here: 2
+const secondDiceValue = uniformInt(rng, 1, 6); // value in {1..6}, here: 4
+const thirdDiceValue = uniformInt(rng, 1, 6); // value in {1..6}, here: 6
+```
+
+**Pure usage**
+
+Pure means that the instance `rng` will never be altered in-place. It can be called again and again and it will always return the same value. But it will also return the next `rng`. Here is an example showing how the code above can be translated into its pure version:
+
+```javascript
+import { uniformIntDistribution } from 'pure-rand/distribution/UniformIntDistribution';
+import { xoroshiro128plus } from 'pure-rand/generator/xoroshiro128plus';
+import { purify } from 'pure-rand/utils/purify';
+
+const uniformIntDistributionPure = purify(uniformIntDistribution);
+
+const seed = 42;
+const rng1 = xoroshiro128plus(seed);
+const [firstDiceValue, rng2] = uniformIntDistributionPure(rng1, 1, 6); // value in {1..6}, here: 2
+const [secondDiceValue, rng3] = uniformIntDistributionPure(rng2, 1, 6); // value in {1..6}, here: 4
+const [thirdDiceValue, rng4] = uniformIntDistributionPure(rng3, 1, 6); // value in {1..6}, here: 6
+
+// You can call: uniformIntDistributionPure(rng1, 1, 6);
+// over and over it will always give you back the same value along with a new rng (always producing the same values too).
+```
+
+**Independent simulations**
+
+In order to produce independent simulations it can be tempting to instanciate several PRNG based on totally different seeds. While it would produce distinct set of values, the best way to ensure fully unrelated sequences is rather to use jumps. Jump just consists into moving far away from the current position in the generator (eg.: jumping in Xoroshiro 128+ will move you 2<sup>64</sup> generations away from the current one on a generator having a sequence of 2<sup>128</sup> elements).
+
+```javascript
+import { uniformInt } from 'pure-rand/distribution/uniformInt';
+import { xoroshiro128plus } from 'pure-rand/generator/xoroshiro128plus';
+import { purify } from 'pure-rand/utils/purify';
+
+const pureJump = purify((rng) => rng.jump());
+const createAnotherSimulation = (rng) => pureJump(rng)[1];
+
+const seed = 42;
+const rngSimulation1 = xoroshiro128plus(seed);
+const rngSimulation2 = createAnotherSimulation(rngSimulation1); // not in-place, creates a new instance
+const rngSimulation3 = createAnotherSimulation(rngSimulation2); // not in-place, creates a new instance
+
+const diceSim1Value = uniformInt(rngSimulation1, 1, 6); // value in {1..6}, here: 2
+const diceSim2Value = uniformInt(rngSimulation2, 1, 6); // value in {1..6}, here: 5
+const diceSim3Value = uniformInt(rngSimulation3, 1, 6); // value in {1..6}, here: 6
+```
+
+**Non-uniform usage**
+
+While not recommended as non-uniform distribution implies that one or several values from the range will be more likely than others, it might be tempting for people wanting to maximize the throughput.
+
+```javascript
+import { xoroshiro128plus } from 'pure-rand/generator/xoroshiro128plus';
+
+const seed = 42;
+const rng = xoroshiro128plus(seed);
+const rand = (min, max) => {
+  const out = (rng.next() >>> 0) / 0x100000000;
+  return min + Math.floor(out * (max - min + 1));
+};
+const firstDiceValue = rand(1, 6); // value in {1..6}, here: 6
+```
+
+**Select your seed**
+
+While not perfect, here is a rather simple way to generate a seed for your PNRG.
+
+```javascript
+const seed = Date.now() ^ (Math.random() * 0x100000000);
+```
+
+## Documentation
+
+### Pseudorandom number generators
+
+In computer science most random number generators<sup>(1)</sup> are [pseudorandom number generators](https://en.wikipedia.org/wiki/Pseudorandom_number_generator) (abbreviated: PRNG). In other words, they are fully deterministic and given the original seed one can rebuild the whole sequence.
+
+Each PRNG algorithm has to deal with tradeoffs in terms of randomness quality, speed, length of the sequence<sup>(2)</sup>... In other words, it's important to compare relative speed of libraries with that in mind. Indeed, a Mersenne Twister PRNG will not have the same strenghts and weaknesses as a Xoroshiro PRNG, so depending on what you need exactly you might prefer one PRNG over another even if it will be slower.
+
+4 PRNGs come with pure-rand:
+
+- `congruential32`: Linear Congruential generator — \[[more](https://en.wikipedia.org/wiki/Linear_congruential_generator)\]
+- `mersenne`: Mersenne Twister generator — \[[more](https://en.wikipedia.org/wiki/Mersenne_Twister)\]
+- `xorshift128plus`: Xorshift 128+ generator — \[[more](https://en.wikipedia.org/wiki/Xorshift)\]
+- `xoroshiro128plus`: Xoroshiro 128+ generator — \[[more](https://en.wikipedia.org/wiki/Xorshift)\]
+
+Our recommendation is `xoroshiro128plus`. But if you want to use another one, you can replace it by any other PRNG provided by pure-rand in the examples above.
+
+Each of these generators come with its own import: `pure-rand/generator/<name>`.
+
+### Distributions
+
+Once you are able to generate random values, next step is to scale them into the range you want. Indeed, you probably don't want a floating point value between 0 (included) and 1 (excluded) but rather an integer value between 1 and 6 if you emulate a dice or any other range based on your needs.
+
+At this point, simple way would be to do `min + floor(random() * (max - min + 1))` but actually it will not generate the values with equal probabilities even if you use the best PRNG in the world to back `random()`. In order to have equal probabilities you need to rely on uniform distributions<sup>(3)</sup> which comes built-in in some PNRG libraries.
+
+pure-rand provides 4 built-in functions for uniform distributions of values:
+
+- `uniformInt(rng, min, max)`
+- `uniformBigInt(rng, min, max)` - with `min` and `max` being `bigint`
+- `uniformFloat32(rng)` - to generate value between 0 (included) and 1 (excluded)
+- `uniformFloat64(rng)` - to generate value between 0 (included) and 1 (excluded)
+
+Each of these distributions come with its own import: `pure-rand/distribution/<name>`.
+
+### Extra helpers
+
+Some helpers are also provided in order to ease the use of `RandomGenerator` instances:
+
+- `generateN(rng: RandomGenerator, num: number): number[]`: generates `num` random values using `rng` and return them
+- `skipN(rng: RandomGenerator, num: number): void`: skips `num` random values
+
+And one last helper responsible to change any function accepting an instance of `RandomGenerator` as a first argument into a pure version of it:
+
+- `purify<TArgs extends unknown[], TReturn>(action: (rng: RandomGenerator, ...args: TArgs) => TReturn): (rng: RandomGenerator, ...args: TArgs) => [TReturn, RandomGenerator]`: purifies the action
+
+Each of these helpers come with its own import: `pure-rand/utils/<name>`.
+
+## Comparison
+
+pure-rand offers competitive performance compared to other PRNG libraries, with built-in support for uniform distributions — ensuring unbiased results out of the box.
+
+<img src="https://raw.githubusercontent.com/dubzzz/pure-rand/main/assets/comparison.svg" alt="Comparison against other libraries" />
+
+For detailed benchmark results and methodology, see the [full comparison](./COMPARISON.md).
+
+---
+
+(1) — Not all as there are also [hardware-based random number generator](https://en.wikipedia.org/wiki/Hardware_random_number_generator).
+
+(2) — How long it takes to reapeat itself?
+
+(3) — While most users don't really think of it, uniform distribution is key! Without it entries might be biased towards some values and make some others less probable. The naive `rand() % numValues` is a good example of biased version as if `rand()` is uniform in `0, 1, 2` and `numValues` is `2`, the probabilities are: `P(0) = 67%`, `P(1) = 33%` causing `1` to be less probable than `0`

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

@@ -0,0 +1,14 @@
+//#region src/types/RandomGenerator.d.ts
+interface RandomGenerator {
+  /** Produce a fully independent clone of the current instance */
+  clone(): RandomGenerator;
+  /**
+  * Generate next value BUT alters current generator.
+  * Values uniform in range -0x8000_0000 (included) to 0x7fff_ffff (included)
+  */
+  next(): number;
+  /** Access to the internal state of a RandomGenerator in a read-only fashion */
+  getState(): readonly number[];
+}
+//#endregion
+export { RandomGenerator as t };

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

@@ -0,0 +1,15 @@
+import { t as RandomGenerator } from "../RandomGenerator-DcXj09Ch.js";
+
+//#region src/distribution/uniformBigInt.d.ts
+/**
+* Uniformly generate random bigint 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 uniformBigInt(rng: RandomGenerator, from: bigint, to: bigint): bigint;
+//#endregion
+export { uniformBigInt };

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

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/distribution/uniformBigInt.ts
+const SBigInt = BigInt;
+const NumValues = 4294967296n;
+/**
+* Uniformly generate random bigint 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 uniformBigInt(rng, from, to) {
+	const diff = to - from + 1n;
+	let FinalNumValues = NumValues;
+	let NumIterations = 1;
+	while (FinalNumValues < diff) {
+		FinalNumValues <<= 32n;
+		++NumIterations;
+	}
+	let value = generateNext(NumIterations, rng);
+	if (value < diff) return value + from;
+	if (value + diff < FinalNumValues) return value % diff + from;
+	const MaxAcceptedRandom = FinalNumValues - FinalNumValues % diff;
+	while (value >= MaxAcceptedRandom) value = generateNext(NumIterations, rng);
+	return value % diff + from;
+}
+function generateNext(NumIterations, rng) {
+	let value = SBigInt(rng.next() + 2147483648);
+	for (let num = 1; num < NumIterations; ++num) {
+		const out = rng.next();
+		value = (value << 32n) + SBigInt(out + 2147483648);
+	}
+	return value;
+}
+//#endregion
+exports.uniformBigInt = uniformBigInt;

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

@@ -0,0 +1,15 @@
+import { t as RandomGenerator } from "../RandomGenerator-DcXj09Ch.js";
+
+//#region src/distribution/uniformFloat32.d.ts
+/**
+* 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
+*/
+declare function uniformFloat32(rng: RandomGenerator): number;
+//#endregion
+export { uniformFloat32 };

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

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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
+exports.uniformFloat32 = uniformFloat32;

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/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/distribution/uniformFloat64.js

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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
+exports.uniformFloat64 = uniformFloat64;

package/skills/property-based-testing/fixtures/js-roundtrip/node_modules/pure-rand/lib/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/distribution/uniformInt.js

@@ -0,0 +1,134 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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
+exports.uniformInt = uniformInt;

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

@@ -0,0 +1,14 @@
+//#region src/types/RandomGenerator.d.ts
+interface RandomGenerator {
+  /** Produce a fully independent clone of the current instance */
+  clone(): RandomGenerator;
+  /**
+  * Generate next value BUT alters current generator.
+  * Values uniform in range -0x8000_0000 (included) to 0x7fff_ffff (included)
+  */
+  next(): number;
+  /** Access to the internal state of a RandomGenerator in a read-only fashion */
+  getState(): readonly number[];
+}
+//#endregion
+export { RandomGenerator as t };

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

@@ -0,0 +1,15 @@
+import { t as RandomGenerator } from "../RandomGenerator-DcXj09Ch.js";
+
+//#region src/distribution/uniformBigInt.d.ts
+/**
+* Uniformly generate random bigint 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 uniformBigInt(rng: RandomGenerator, from: bigint, to: bigint): bigint;
+//#endregion
+export { uniformBigInt };

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

@@ -0,0 +1,37 @@
+//#region src/distribution/uniformBigInt.ts
+const SBigInt = BigInt;
+const NumValues = 4294967296n;
+/**
+* Uniformly generate random bigint 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 uniformBigInt(rng, from, to) {
+	const diff = to - from + 1n;
+	let FinalNumValues = NumValues;
+	let NumIterations = 1;
+	while (FinalNumValues < diff) {
+		FinalNumValues <<= 32n;
+		++NumIterations;
+	}
+	let value = generateNext(NumIterations, rng);
+	if (value < diff) return value + from;
+	if (value + diff < FinalNumValues) return value % diff + from;
+	const MaxAcceptedRandom = FinalNumValues - FinalNumValues % diff;
+	while (value >= MaxAcceptedRandom) value = generateNext(NumIterations, rng);
+	return value % diff + from;
+}
+function generateNext(NumIterations, rng) {
+	let value = SBigInt(rng.next() + 2147483648);
+	for (let num = 1; num < NumIterations; ++num) {
+		const out = rng.next();
+		value = (value << 32n) + SBigInt(out + 2147483648);
+	}
+	return value;
+}
+//#endregion
+export { uniformBigInt };

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

@@ -0,0 +1,15 @@
+import { t as RandomGenerator } from "../RandomGenerator-DcXj09Ch.js";
+
+//#region src/distribution/uniformFloat32.d.ts
+/**
+* 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
+*/
+declare function uniformFloat32(rng: RandomGenerator): number;
+//#endregion
+export { uniformFloat32 };