ciorent 1.0.5 → 1.0.7

package/deferred.d.ts

@@ -0,0 +1,22 @@
+export interface Deferred<T> {
+	get: Promise<T>;
+	set: T extends undefined ? (value?: T) => void : (value: T) => void;
+}
+/**
+* Create a deferred value.
+*
+* @example
+* const result = deferred.init();
+*
+* // Set result value, unblock all
+* // coroutines waiting for the results
+* result.set(10);
+*
+* // Get result value
+* await result.get;
+*/
+export declare const init: <T>() => Deferred<T>;
+/**
+* Reset a deferred value.
+*/
+export declare const reset: (value: Deferred<any>) => void;

package/deferred.js

@@ -0,0 +1 @@
+import{loadedResolve,loadResolve}from"./utils.js";export let init=()=>({get:new Promise(loadResolve),set:loadedResolve});export let reset=value=>{value.get=new Promise(loadResolve);value.set=loadedResolve};

package/index.d.ts

@@ -0,0 +1,46 @@
+/**
+* Continue the execution on next event loop cycle.
+*
+* You can `await` this **occasionally** in an expensive synchronous operation to avoid
+* blocking the main thread and let other asynchronous task to run.
+*/
+export declare const nextTick: Promise<void>;
+/**
+* Get the state of a promise on next tick:
+* - `0`: Input promise rejected
+* - `1`: Input promise resolves
+* - `2`: Input promise pending
+*/
+export declare const state: (p: Promise<any>) => Promise<0 | 1 | 2>;
+/**
+* Check whether a value is awaitable.
+* @param p
+* @returns
+*/
+export declare const isThenable: <T>(p: unknown) => p is PromiseLike<T>;
+/**
+* Timeout a promise.
+* @param p
+* @param ms
+*/
+export declare const timeout: <T>(p: Promise<T>, ms: number) => Promise<T | void>;
+/**
+* Sleep for a duration.
+* @param ms - Sleep duration in milliseconds
+*/
+export declare const sleep: (ms: number) => Promise<void>;
+/**
+* Sleep for a duration synchronously.
+*
+* This method blocks the current thread.
+*
+* On the browser it only works in workers.
+* @param ms - Sleep duration in milliseconds
+*/
+export declare const sleepSync: (ms: number) => void;
+export * as deferred from "./deferred.js";
+export * as mutex from "./mutex.js";
+export * as limit from "./rate-limit.js";
+export * as semaphore from "./semaphore.js";
+export * as signal from "./signal.js";
+export * as iters from "./iterators.js";

package/index.js

@@ -0,0 +1 @@
+import{loadedReject,loadedResolve,loadResolve,loadResolvers}from"./utils.js";export let nextTick=Promise.resolve();let getFinishedState=async(s,p)=>{try{await p;s[0]=1}catch(e){s[0]=0;return p}};export let state=async p=>{let res=[2];getFinishedState(res,p);await nextTick;return res[0]};export let isThenable=p=>p!==null&&typeof p===`object`&&!Array.isArray(p)&&typeof p.then===`function`;export let timeout=(p,ms)=>{let promise=new Promise(loadResolvers);setTimeout(loadedResolve,ms);p.then(loadedResolve,loadedReject);return promise};export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.(`timers/promises`).setTimeout??(ms=>{let promise=new Promise(loadResolve);setTimeout(loadedResolve,ms);return promise});let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??(ms=>{Atomics.wait(sharedBuf,0,0,ms)});export*as deferred from"./deferred.js";export*as mutex from"./mutex.js";export*as limit from"./rate-limit.js";export*as semaphore from"./semaphore.js";export*as signal from"./signal.js";export*as iters from"./iterators.js";

package/iterators.d.ts

@@ -0,0 +1,33 @@
+/**
+* Describe an async iterator created by `race()`
+*/
+export interface RaceIterator<T> extends AsyncIterator<T> {
+	_: Promise<T>[];
+}
+/**
+* Race promises and return them in order
+*/
+export declare const race: <T>(promises: Promise<T>[]) => RaceIterator<T>;
+/**
+* Describe an async iterator created by `map()`
+*/
+export interface MapIterator<
+	I,
+	O
+> extends AsyncIterator<O> {
+	_: AsyncIterator<I>;
+	f: (value: I) => Promise<Awaited<O>>;
+}
+export declare const map: <
+	I,
+	O
+>(iterator: AsyncIterator<I>, mapFn: MapIterator<I, O>["f"]) => MapIterator<I, O>;
+/**
+* Describe an async iterator created by `filter()`
+*/
+export interface FilterIterator<T> extends AsyncIterator<T> {
+	_: AsyncIterator<T>;
+	f: (value: T) => Promise<boolean> | boolean;
+}
+export declare const filter: <T>(iterator: AsyncIterator<T>, filterFn: FilterIterator<T>["f"]) => FilterIterator<T>;
+export declare const find: <T>(iterator: AsyncIterator<T>, findFn: (value: T) => Promise<boolean> | boolean) => Promise<T | undefined>;

package/iterators.js

@@ -0,0 +1 @@
+import{loadedResolve,loadResolve}from"./utils.ts";let iteratorDoneResult={done:true,value:undefined};let promiseIteratorDoneResult=Promise.resolve(iteratorDoneResult);let toIteratorResult=value=>({done:false,value});let resolveNext=async(p,resolvers)=>{try{let res=await p;resolvers.pop()(res)}catch{resolvers.pop()(p)}};function raceNext(){return this._.pop()?.then(toIteratorResult)??promiseIteratorDoneResult}export let race=promises=>{let last=promises.length-1;let waitingPromises=new Array(last+1);for(let i=0,resolvers=new Array(last+1);i<=last;i++){waitingPromises[last-i]=new Promise(loadResolve);resolvers[last-i]=loadedResolve;resolveNext(promises[i],resolvers)}return{next:raceNext,_:waitingPromises}};async function mapNext(){let p=await this._.next();if(p.done)return iteratorDoneResult;let res=this.f(p.value);return toIteratorResult(res instanceof Promise?await res:res)}export let map=(iterator,mapFn)=>({next:mapNext,_:iterator,f:mapFn});async function filterNext(){let p=await this._.next();while(!p.done){let res=this.f(p.value);if(res instanceof Promise?await res:res)return p;p=await this._.next()}return iteratorDoneResult}export let filter=(iterator,filterFn)=>({next:filterNext,_:iterator,f:filterFn});export let find=async(iterator,findFn)=>{let p=await iterator.next();while(!p.done){let res=findFn(p.value);if(res instanceof Promise?await res:res)return p.value;p=await iterator.next()}};

package/mutex.d.ts

@@ -0,0 +1,17 @@
+import { type Extend } from "./utils.js";
+/**
+* Describe a mutex.
+*/
+export type Mutex = [Promise<void>];
+/**
+* Create a mutex.
+*/
+export declare const init: () => Mutex;
+/**
+* Acquire a mutex.
+*/
+export declare const acquire: (mu: Extend<Mutex>) => Promise<() => void>;
+/**
+* Automatically acquire and run a task.
+*/
+export declare const run: <const T extends (...args: any[]) => Promise<any>>(mu: Extend<Mutex>, fn: T, ...args: Parameters<T>) => ReturnType<T>;

package/mutex.js

@@ -0,0 +1 @@
+import{nextTick}from"./index.js";import{loadedResolve,loadResolve}from"./utils.js";export let init=()=>[nextTick];export let acquire=async mu=>{let currentLock=mu[0];mu[0]=new Promise(loadResolve);let release=loadedResolve;await currentLock;return release};let chainLock=async(lock,fn,...args)=>{try{await lock}finally{return fn(...args)}};export let run=(mu,fn,...args)=>mu[0]=chainLock(mu[0],fn,...args);

package/package.json

@@ -1,38 +1 @@
-{
-  "name": "ciorent",
-  "version": "1.0.5",
-  "description": "A lightweight, low-overhead concurrency library",
-  "homepage": "https://re-utils.pages.dev/concurrency",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/re-utils/ciorent.git"
-  },
-  "keywords": [
-    "low-overhead",
-    "lightweight",
-    "concurrency",
-    "cross-runtime"
-  ],
-  "license": "MIT",
-  "type": "module",
-  "scripts": {
-    "task": "bun scripts/task.ts",
-    "fmt": "biome format .",
-    "lint": "biome check",
-    "build:test": "bun task build && bun test",
-    "build:publish": "bun task build && bun task report-size && bun task publish"
-  },
-  "devDependencies": {
-    "@biomejs/biome": "^2.1.3",
-    "@types/bun": "^1.2.19",
-    "mitata": "^1.0.34",
-    "oxc-minify": "^0.64.0",
-    "oxc-transform": "^0.65.0",
-    "typescript": "^5.9.2",
-    "jiti": "^2.5.1",
-    "ciorent": "./lib"
-  },
-  "trustedDependencies": [
-    "@biomejs/biome"
-  ]
-}
+{"name":"ciorent","version":"1.0.7","description":"A lightweight, low-overhead concurrency library","homepage":"https://re-utils.pages.dev/concurrency","repository":{"type":"git","url":"git+https://github.com/re-utils/ciorent.git"},"keywords":["low-overhead","lightweight","concurrency","cross-runtime"],"license":"MIT","type":"module","exports":{"./iterators":"./iterators.js",".":"./index.js","./utils":"./utils.js","./semaphore":"./semaphore.js","./rate-limit":"./rate-limit.js","./deferred":"./deferred.js","./mutex":"./mutex.js","./signal":"./signal.js"}}

package/rate-limit.d.ts

@@ -0,0 +1,22 @@
+/**
+* Describe a rate limiter.
+*/
+export type Limiter = (limit: number, ms: number) => () => boolean;
+/**
+* Fixed window strategy.
+* @param limit
+* @param ms
+*/
+export declare const fixedWindow: Limiter;
+/**
+* Sliding window strategy.
+* @param limit
+* @param ms
+*/
+export declare const slidingWindow: Limiter;
+/**
+* Token bucket strategy.
+* @param limit
+* @param ms
+*/
+export declare const tokenBucket: Limiter;

package/rate-limit.js

@@ -0,0 +1 @@
+export let fixedWindow=(limit,ms)=>{let cur=limit;let unlock=()=>{cur=limit};return()=>{if(cur===0)return false;if(cur--===limit)setTimeout(unlock,ms);return true}};export let slidingWindow=(limit,ms)=>{let cur=limit;let unlock=()=>{cur++};return()=>{if(cur===0)return false;cur--;setTimeout(unlock,ms);return true}};export let tokenBucket=(limit,ms)=>{let cur=limit;ms/=limit;let unlock=()=>{if(cur++<limit)setTimeout(unlock,ms)};return()=>{if(cur===0)return false;if(cur--===limit)setTimeout(unlock,ms);return true}};

package/semaphore.d.ts

@@ -0,0 +1,46 @@
+import { type Extend } from "./utils.js";
+type QueueItem = () => void;
+type Queue = [(QueueItem | null)[], len: number, head: number, tail: number];
+export type Semaphore = [...Queue, remain: number];
+/**
+* Check whether the semaphore queue is full.
+*/
+export declare const full: (qu: Extend<Semaphore>) => boolean;
+/**
+* Create a semaphore.
+*
+* @example
+* // maximum of 10 concurrent tasks and 200 waiting tasks.
+* const sem = semaphore.init(10, 200);
+*/
+export declare const init: (permits: number, capacity: number) => Semaphore;
+/**
+* Acquire a permit.
+*
+* @example
+*
+* if (semaphore.full(sem)) {
+*   // Internal queue is full
+* }
+*
+* await semaphore.acquire(sem);
+*
+* // Do something and then release the permit.
+* semaphore.release(sem);
+*/
+export declare const acquire: (sem: Extend<Semaphore>) => Promise<void> | void;
+/**
+* Release a permit.
+*
+* @example
+* semaphore.release(sem);
+*/
+export declare const release: (sem: Extend<Semaphore>) => void;
+/**
+* @param task Task to limit
+* @param sem Target semaphore
+* @throws {Error} when `sem` internal queue is full
+* @returns The limited function
+*/
+export declare const limit: <Fn extends (...args: any[]) => Promise<any>>(task: Fn, sem: Extend<Semaphore>) => Fn;
+export {};

package/semaphore.js

@@ -0,0 +1 @@
+import{loadedResolve,loadResolve}from"./utils.js";let push=(qu,item)=>{let tail=qu[3];qu[3]=tail+1===qu[1]?0:tail+1;qu[0][tail]=item};let pop=qu=>{let head=qu[2];qu[2]=head+1===qu[1]?0:head+1;let val=qu[0][head];qu[0][head]=null;return val};export let full=qu=>qu[0].length+qu[4]<=0;export let init=(permits,capacity)=>[new Array(capacity).fill(null),capacity,0,0,permits];export let acquire=sem=>{if(--sem[4]<0){let promise=new Promise(loadResolve);push(sem,loadedResolve);return promise}};export let release=sem=>{sem[4]++<0&&pop(sem)()};export let limit=(task,sem)=>async(...args)=>{if(full(sem))throw new Error(`Semaphore internal queue is full`);if(--sem[4]<0){let promise=new Promise(loadResolve);push(sem,loadedResolve);await promise}try{return await task(...args)}finally{release(sem)}};

package/signal.d.ts

@@ -0,0 +1,41 @@
+/**
+* Describe a signal.
+*/
+export type Signal = [interrupted: boolean, ...parents: Signal[]];
+/**
+* Create a signal.
+*/
+export declare const init: () => Signal;
+/**
+* Create a signal that aborts when any of the input signals abort.
+* @param sigs
+*/
+export declare const any: (signals: Signal[]) => Signal;
+/**
+* Create a signal that when interrupted will interrupt a group of other signals.
+*/
+export declare const group: (signals: Signal[]) => Signal;
+/**
+* Check whether the signal has been aborted.
+* @param t
+*/
+export declare const aborted: (t: Signal) => boolean;
+/**
+* Abort a signal.
+* @param t
+*/
+export declare const abort: (t: Signal) => void;
+/**
+* Abort a signal after a duration.
+* @param t
+*/
+export declare const abortAfter: (ms: number, t: Signal) => void;
+/**
+* Create a signal that aborts after ms.
+* @param ms
+*/
+export declare const timeout: (ms: number) => Signal;
+/**
+* Attach a signal to a `DisposableStack` or `AsyncDisposableStack`
+*/
+export declare const adopt: (t: Signal, stack: DisposableStack | AsyncDisposableStack) => void;

package/signal.js

@@ -0,0 +1 @@
+export let init=()=>[false];export let any=signals=>{let sig=[false];for(let i=0;i<signals.length;i++)signals[i].push(sig);return sig};let _=[false];export let group=signals=>_.concat(signals);export let aborted=t=>t[0];export let abort=t=>{if(!t[0]){t[0]=true;if(t.length>1)for(let i=1;i<t.length;i++)abort(t[i])}};export let abortAfter=(ms,t)=>{setTimeout(()=>abort(t),ms)};export let timeout=ms=>{let sig=[false];abortAfter(ms,sig);return sig};export let adopt=(t,stack)=>{stack.adopt(t,abort)};

package/utils.d.ts

@@ -0,0 +1,5 @@
+export type Extend<T extends any[]> = [...T, ...any[]];
+export declare let loadedResolve: (res?: any) => void;
+export declare let loadedReject: (reason?: any) => void;
+export declare const loadResolvers: (res: (value?: any) => void, rej: (reason?: any) => void) => void;
+export declare const loadResolve: (res: (value?: any) => void) => void;

package/utils.js

@@ -0,0 +1 @@
+export let loadedResolve;export let loadedReject;export let loadResolvers=(res,rej)=>{loadedResolve=res;loadedReject=rej};export let loadResolve=res=>{loadedResolve=res};

package/bench/await.bench.ts

@@ -1,29 +0,0 @@
-import { bench, do_not_optimize, run, summary } from 'mitata';
-
-// Example benchmark
-summary(() => {
-  bench('Await', function* () {
-    yield {
-      [0]() {
-        return Promise.resolve(1);
-      },
-      async bench(data: any) {
-        do_not_optimize(await data);
-      },
-    };
-  });
-
-  bench('Await non-promise', function* () {
-    yield {
-      [0]() {
-        return 1;
-      },
-      async bench(data: any) {
-        do_not_optimize(await data);
-      },
-    };
-  });
-});
-
-// Start the benchmark
-run();

package/bench/bun.lock

@@ -1,38 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 0,
-  "workspaces": {
-    "": {
-      "dependencies": {
-        "@types/mutexify": "^1.2.4",
-        "async-mutex": "^0.5.0",
-        "async-sema": "^3.1.1",
-        "bottleneck": "^2.19.5",
-        "limit-concur": "^4.0.0",
-        "mutexify": "^1.4.0",
-        "p-limit": "^6.2.0",
-      },
-    },
-  },
-  "packages": {
-    "@types/mutexify": ["@types/mutexify@1.2.4", "", {}, "sha512-mKNLg7IdppIDCNXiC1hNkNhdEdYnd5ErNnoNgEOERwU3DwD/S1/TBseob0Uq/QXWADBz7OWaWUoHa6IEUtrOEQ=="],
-
-    "async-mutex": ["async-mutex@0.5.0", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-1A94B18jkJ3DYq284ohPxoXbfTA5HsQ7/Mf4DEhcyLx3Bz27Rh59iScbB6EPiP+B+joue6YCxcMXSbFC1tZKwA=="],
-
-    "async-sema": ["async-sema@3.1.1", "", {}, "sha512-tLRNUXati5MFePdAk8dw7Qt7DpxPB60ofAgn8WRhW6a2rcimZnYBP9oxHiv0OHy+Wz7kPMG+t4LGdt31+4EmGg=="],
-
-    "bottleneck": ["bottleneck@2.19.5", "", {}, "sha512-VHiNCbI1lKdl44tGrhNfU3lup0Tj/ZBMJB5/2ZbNXRCPuRCO7ed2mgcK4r17y+KB2EfuYuRaVlwNbAeaWGSpbw=="],
-
-    "limit-concur": ["limit-concur@4.0.0", "", {}, "sha512-BXUCP52gLz8JA8/cRKkXswOV6FnA2gl8hL8DbgQuo8XA9NKcwU3Oq/Cg1JyAZ+gyNmFEZXI+ZYLes0BrZkl+7g=="],
-
-    "mutexify": ["mutexify@1.4.0", "", { "dependencies": { "queue-tick": "^1.0.0" } }, "sha512-pbYSsOrSB/AKN5h/WzzLRMFgZhClWccf2XIB4RSMC8JbquiB0e0/SH5AIfdQMdyHmYtv4seU7yV/TvAwPLJ1Yg=="],
-
-    "p-limit": ["p-limit@6.2.0", "", { "dependencies": { "yocto-queue": "^1.1.1" } }, "sha512-kuUqqHNUqoIWp/c467RI4X6mmyuojY5jGutNU0wVTmEOOfcuwLqyMVoAi9MKi2Ak+5i9+nhmrK4ufZE8069kHA=="],
-
-    "queue-tick": ["queue-tick@1.0.1", "", {}, "sha512-kJt5qhMxoszgU/62PLP1CJytzd2NKetjSRnyuj31fDd3Rlcz3fzlFdFLD1SItunPwyqEOkca6GbV612BWfaBag=="],
-
-    "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
-
-    "yocto-queue": ["yocto-queue@1.2.1", "", {}, "sha512-AyeEbWOu/TAXdxlV9wmGcR0+yh2j3vYPGOECcIj2S7MkrLyC7ne+oye2BKTItt0ii2PHk4cDy+95+LshzbXnGg=="],
-  }
-}

package/bench/package.json

@@ -1,11 +0,0 @@
-{
-  "type": "module",
-  "dependencies": {
-    "@types/mutexify": "^1.2.4",
-    "async-mutex": "^0.5.0",
-    "async-sema": "^3.1.1",
-    "limit-concur": "^4.0.0",
-    "mutexify": "^1.4.0",
-    "p-limit": "^6.2.0"
-  }
-}

package/bench/promise-all.bench.ts

@@ -1,42 +0,0 @@
-import { bench, do_not_optimize, run, summary } from 'mitata';
-
-// Example benchmark
-summary(() => {
-  bench('Fill with null', function* () {
-    const DAT = new Array(6).fill(null);
-
-    yield {
-      [0]() {
-        return [...DAT];
-      },
-      [1]() {
-        return Promise.resolve(15);
-      },
-      async bench(data: any[], p: any) {
-        data[0] = p;
-        do_not_optimize(await Promise.all(data));
-      },
-    };
-  });
-
-  bench('Fill with resolved promises', function* () {
-    const resolvedPromise = Promise.resolve();
-    const DAT = new Array(6).fill(resolvedPromise);
-
-    yield {
-      [0]() {
-        return [...DAT];
-      },
-      [1]() {
-        return Promise.resolve(15);
-      },
-      async bench(data: any[], p: any) {
-        data[0] = p;
-        do_not_optimize(await Promise.all(data));
-      },
-    };
-  });
-});
-
-// Start the benchmark
-run();

package/bench/semaphore.bench.ts

@@ -1,101 +0,0 @@
-import { semaphore, mutex } from 'ciorent';
-import limitConcur from 'limit-concur';
-import { limitFunction } from 'p-limit';
-import { Mutex, Semaphore } from 'async-mutex';
-import mutexify from 'mutexify/promise.js';
-import { Sema } from 'async-sema';
-
-import { bench, do_not_optimize, run, summary } from 'mitata';
-
-
-const task = async () => {
-  await 0;
-  do_not_optimize(Math.random());
-};
-
-const setup = (label: string, limited: () => Promise<any>) => {
-  bench(label, Function('f', `return async () => { await Promise.all([${
-    'f(),'.repeat(200)
-  }]); }`)(limited)).gc('inner');
-};
-
-const setupSemaphoreCases = (permit: number) => {
-  setup(`permit ${permit} - limit-concur`, limitConcur(permit, task));
-  setup(`permit ${permit} - p-limit`, limitFunction(task, { concurrency: permit }));
-
-  {
-    const sem = semaphore.init(permit, 200 - permit);
-    setup(`permit ${permit} - ciorent (semaphore)`, async () => {
-      await semaphore.acquire(sem);
-      try {
-        await task();
-      } finally {
-        semaphore.release(sem);
-      }
-    });
-  }
-
-  {
-    const sem = new Semaphore(permit);
-    setup(`permit ${permit} - async-mutex (semaphore)`, () => sem.runExclusive(task));
-  }
-
-  {
-    const sem = new Sema(permit);
-    setup(`permit ${permit} - async-sema`, async () => {
-      await sem.acquire();
-      try {
-        return await task();
-      } finally {
-        sem.release();
-      }
-    });
-  }
-
-  {
-    const sem = new Sema(permit, {
-      capacity: 200 - permit
-    });
-    setup(`permit ${permit} - async-sema (pre-allocated)`, async () => {
-      await sem.acquire();
-      try {
-        return await task();
-      } finally {
-        sem.release();
-      }
-    });
-  }
-}
-
-summary(() => {
-  setupSemaphoreCases(1);
-
-  {
-    const mu = mutex.init();
-    setup('permit 1 - ciorent (mutex)', () => mutex.run(mu, task));
-  }
-
-  {
-    const mu = new Mutex();
-    setup('permit 1 - async-mutex (mutex)', () => mu.runExclusive(task));
-  }
-
-  {
-    const acquire = mutexify();
-    setup('permit 1 - mutexify', async () => {
-      const release = await acquire();
-      try {
-        return await task();
-      } finally {
-        release();
-      }
-    })
-  }
-});
-
-for (let permit = 2; permit < 128; permit <<= 1)
-  summary(() => {
-    setupSemaphoreCases(permit);
-  });
-
-run();

package/bench/shallow-clone.bench.ts

@@ -1,69 +0,0 @@
-import { bench, do_not_optimize, type k_state, run, summary } from 'mitata';
-
-// Example benchmark
-summary(() => {
-  bench('Clone 2 arrays - Concat', function* (state: k_state) {
-    const DAT = new Array(state.get('len')).fill(0).map(Math.random);
-    const DAT2 = new Array(state.get('len')).map(Math.random);
-
-    yield {
-      [0]() {
-        return DAT;
-      },
-      [1]() {
-        return DAT2;
-      },
-      bench(data: any[], data1: any[]) {
-        do_not_optimize(data.concat(data1));
-      },
-    };
-  }).range('len', 2 ** 3, 2 ** 12);
-
-  bench('Clone 2 arrays - Spread', function* (state: k_state) {
-    const DAT = new Array(state.get('len')).fill(0).map(Math.random);
-    const DAT2 = new Array(state.get('len')).map(Math.random);
-
-    yield {
-      [0]() {
-        return DAT;
-      },
-      [1]() {
-        return DAT2;
-      },
-      bench(data: any[], data1: any[]) {
-        do_not_optimize([...data, ...data1]);
-      },
-    };
-  }).range('len', 2 ** 3, 2 ** 12);
-});
-
-summary(() => {
-  bench('Clone 1 array - Concat', function* (state: k_state) {
-    const DAT = new Array(state.get('len')).fill(0).map(Math.random);
-
-    yield {
-      [0]() {
-        return DAT;
-      },
-      bench(data: any[]) {
-        do_not_optimize(data.concat([]));
-      },
-    };
-  }).range('len', 2 ** 3, 2 ** 12);
-
-  bench('Clone 1 array - Spread', function* (state: k_state) {
-    const DAT = new Array(state.get('len')).fill(0).map(Math.random);
-
-    yield {
-      [0]() {
-        return DAT;
-      },
-      bench(data: any[]) {
-        do_not_optimize([...data]);
-      },
-    };
-  }).range('len', 2 ** 3, 2 ** 12);
-});
-
-// Start the benchmark
-run();

package/bench/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "../scripts/tsconfig.json"
-}

package/biome.json

@@ -1,62 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/2.1.3/schema.json",
-  "vcs": {
-    "enabled": false
-  },
-  "files": {
-    "experimentalScannerIgnores": ["node_modules"],
-    "includes": [
-      "**/*.{js,ts,jsx,tsx,json,astro,svelte,vue}",
-      "!{lib,bench}/**/*"
-    ]
-  },
-  "javascript": {
-    "formatter": {
-      "quoteStyle": "single",
-      "arrowParentheses": "always",
-      "semicolons": "always"
-    }
-  },
-  "formatter": {
-    "enabled": true,
-    "indentStyle": "space",
-    "indentWidth": 2,
-    "bracketSpacing": true
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "style": {
-        "noEnum": "error",
-        "noCommonJs": "error",
-        "useConsistentArrayType": "error",
-        "noNamespace": "error",
-        "noImplicitBoolean": "warn",
-        "noUselessElse": "error",
-        "useCollapsedElseIf": "error",
-        "useConst": "error",
-        "useNodejsImportProtocol": "error",
-        "useImportType": "error",
-        "useExponentiationOperator": "info"
-      },
-      "complexity": {
-        "noForEach": "info",
-        "noUselessCatch": "info",
-        "useArrowFunction": "warn"
-      },
-      "nursery": {
-        "noShadow": "warn",
-        "noGlobalDirnameFilename": "error",
-        "useIndexOf": "warn",
-        "noImportCycles": "error"
-      },
-      "correctness": {
-        "useYield": "warn",
-        "noUnusedImports": "warn",
-        "useImportExtensions": "error",
-        "useIsNan": "warn"
-      },
-      "recommended": false
-    }
-  }
-}