@mytld/engine 0.0.0-stage → 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +116 -2
- package/dist/cache/result-cache.d.ts +26 -0
- package/dist/cache/result-cache.js +66 -0
- package/dist/cache/safe-store.d.ts +17 -0
- package/dist/cache/safe-store.js +83 -0
- package/dist/cache/store.d.ts +43 -0
- package/dist/cache/store.js +100 -0
- package/dist/core/domain.d.ts +27 -0
- package/dist/core/domain.js +60 -0
- package/dist/core/tlds.d.ts +5 -0
- package/dist/core/tlds.js +69 -0
- package/dist/engine/create-engine.d.ts +17 -0
- package/dist/engine/create-engine.js +147 -0
- package/dist/engine/options.d.ts +65 -0
- package/dist/engine/options.js +13 -0
- package/dist/index.d.ts +16 -0
- package/dist/index.js +14 -0
- package/dist/lookup/dns.d.ts +21 -0
- package/dist/lookup/dns.js +57 -0
- package/dist/lookup/rdap-bootstrap.d.ts +18 -0
- package/dist/lookup/rdap-bootstrap.js +56 -0
- package/dist/lookup/rdap.d.ts +22 -0
- package/dist/lookup/rdap.js +107 -0
- package/dist/lookup/whois-parser.d.ts +9 -0
- package/dist/lookup/whois-parser.js +64 -0
- package/dist/lookup/whois.d.ts +17 -0
- package/dist/lookup/whois.js +89 -0
- package/dist/throttle/host-throttle.d.ts +44 -0
- package/dist/throttle/host-throttle.js +98 -0
- package/dist/throttle/semaphore.d.ts +21 -0
- package/dist/throttle/semaphore.js +45 -0
- package/dist/util/async-iterable.d.ts +7 -0
- package/dist/util/async-iterable.js +37 -0
- package/package.json +73 -4
|
@@ -0,0 +1,89 @@
|
|
|
1
|
+
import net from "node:net";
|
|
2
|
+
import { keyedSemaphore } from "../throttle/semaphore.js";
|
|
3
|
+
import { formatQuery, parseWhois } from "./whois-parser.js";
|
|
4
|
+
/** Well-known servers. Everything else is discovered via whois.iana.org. */
|
|
5
|
+
export const DEFAULT_WHOIS_SERVERS = {
|
|
6
|
+
de: "whois.denic.de",
|
|
7
|
+
eu: "whois.eu",
|
|
8
|
+
at: "whois.nic.at",
|
|
9
|
+
io: "whois.nic.io",
|
|
10
|
+
sh: "whois.nic.sh",
|
|
11
|
+
co: "whois.registry.co",
|
|
12
|
+
me: "whois.nic.me",
|
|
13
|
+
};
|
|
14
|
+
const IANA_WHOIS = "whois.iana.org";
|
|
15
|
+
const SERVER_CACHE_TTL_SEC = 7 * 86_400;
|
|
16
|
+
const MAX_RESPONSE_BYTES = 64 * 1024;
|
|
17
|
+
export function createWhois(options) {
|
|
18
|
+
const serverLookups = new Map();
|
|
19
|
+
// WHOIS servers are much stricter than RDAP, so concurrency stays low.
|
|
20
|
+
const hostSlots = keyedSemaphore(options.perHost);
|
|
21
|
+
/** Sends one query over TCP port 43. Resolves with whatever arrived before close or timeout. */
|
|
22
|
+
function query(host, text) {
|
|
23
|
+
return new Promise((resolve, reject) => {
|
|
24
|
+
const chunks = [];
|
|
25
|
+
let received = 0;
|
|
26
|
+
const collected = () => Buffer.concat(chunks).toString("utf8");
|
|
27
|
+
const socket = net.connect({ host, port: 43 });
|
|
28
|
+
socket.setTimeout(options.timeoutMs);
|
|
29
|
+
socket.on("connect", () => {
|
|
30
|
+
socket.write(`${text}\r\n`);
|
|
31
|
+
});
|
|
32
|
+
socket.on("data", (chunk) => {
|
|
33
|
+
chunks.push(chunk);
|
|
34
|
+
received += chunk.length;
|
|
35
|
+
if (received > MAX_RESPONSE_BYTES) {
|
|
36
|
+
socket.destroy();
|
|
37
|
+
}
|
|
38
|
+
});
|
|
39
|
+
socket.on("timeout", () => {
|
|
40
|
+
socket.destroy(new Error("timeout"));
|
|
41
|
+
});
|
|
42
|
+
// A reset after a complete answer is common, so keep partial data if there is any.
|
|
43
|
+
socket.on("error", (err) => {
|
|
44
|
+
if (received)
|
|
45
|
+
resolve(collected());
|
|
46
|
+
else
|
|
47
|
+
reject(err);
|
|
48
|
+
});
|
|
49
|
+
socket.on("close", () => {
|
|
50
|
+
resolve(collected());
|
|
51
|
+
});
|
|
52
|
+
});
|
|
53
|
+
}
|
|
54
|
+
/** WHOIS server for a TLD: built-in table, else discovered via IANA (cached for a week). */
|
|
55
|
+
function serverFor(tld) {
|
|
56
|
+
if (options.servers[tld]) {
|
|
57
|
+
return Promise.resolve(options.servers[tld]);
|
|
58
|
+
}
|
|
59
|
+
const known = serverLookups.get(tld);
|
|
60
|
+
if (known) {
|
|
61
|
+
return known;
|
|
62
|
+
}
|
|
63
|
+
const lookup = options.store
|
|
64
|
+
.json(`whois:server:v1:${tld}`, SERVER_CACHE_TTL_SEC, () => discoverServer(tld))
|
|
65
|
+
.catch(() => null);
|
|
66
|
+
serverLookups.set(tld, lookup);
|
|
67
|
+
return lookup;
|
|
68
|
+
}
|
|
69
|
+
async function discoverServer(tld) {
|
|
70
|
+
const reply = await query(IANA_WHOIS, tld);
|
|
71
|
+
return reply.match(/^whois:\s*(\S+)/im)?.[1]?.toLowerCase() ?? null;
|
|
72
|
+
}
|
|
73
|
+
async function check(tld, domain) {
|
|
74
|
+
const host = await serverFor(tld);
|
|
75
|
+
if (!host) {
|
|
76
|
+
return "unknown";
|
|
77
|
+
}
|
|
78
|
+
return hostSlots(host).run(async () => {
|
|
79
|
+
try {
|
|
80
|
+
const reply = await query(host, formatQuery(tld, domain));
|
|
81
|
+
return parseWhois(reply);
|
|
82
|
+
}
|
|
83
|
+
catch {
|
|
84
|
+
return "unknown";
|
|
85
|
+
}
|
|
86
|
+
});
|
|
87
|
+
}
|
|
88
|
+
return { check, serverFor };
|
|
89
|
+
}
|
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
import type { SafeStore } from "../cache/safe-store.js";
|
|
2
|
+
/** Store key for a host cooldown (also read by my.tld's admin stats). */
|
|
3
|
+
export declare const cooldownKey: (host: string) => string;
|
|
4
|
+
/**
|
|
5
|
+
* Per-host request pacing for registries.
|
|
6
|
+
*
|
|
7
|
+
* Registry back-ends serve many TLDs from one host (Identity Digital runs hundreds,
|
|
8
|
+
* Google ~40), so limits apply per host, not per TLD:
|
|
9
|
+
*
|
|
10
|
+
* - **Pacing:** requests are spaced 1/rate seconds apart. The rate starts at `maxRate`,
|
|
11
|
+
* halves on every 429 and recovers slowly on success.
|
|
12
|
+
*
|
|
13
|
+
* - **Bounded waiting:** if the next free slot is too far out, the request is skipped
|
|
14
|
+
* instead of queued. The caller falls back to WHOIS or reports "unknown".
|
|
15
|
+
*
|
|
16
|
+
* - **Cooldowns:** a long `Retry-After` blocks the host until it expires. Cooldowns are
|
|
17
|
+
* written to the shared store, so other instances respect them too.
|
|
18
|
+
*/
|
|
19
|
+
export declare class HostThrottle {
|
|
20
|
+
private readonly store;
|
|
21
|
+
private readonly maxRate;
|
|
22
|
+
private readonly rate;
|
|
23
|
+
private readonly nextSlotAt;
|
|
24
|
+
private readonly cooldownUntil;
|
|
25
|
+
private readonly cooldownCheckedAt;
|
|
26
|
+
constructor(store: SafeStore, maxRate: number);
|
|
27
|
+
/**
|
|
28
|
+
* Reserves the next request slot for `host`.
|
|
29
|
+
*
|
|
30
|
+
* @returns milliseconds to wait before sending, or `null` if the queue is too long.
|
|
31
|
+
*/
|
|
32
|
+
reserveSlot(host: string): number | null;
|
|
33
|
+
/** True while the host is in a cooldown: checked locally first, then in the shared store. */
|
|
34
|
+
isCoolingDown(host: string): Promise<boolean>;
|
|
35
|
+
/** Synchronous check, used right before sending after a wait. */
|
|
36
|
+
isCoolingDownLocally(host: string): boolean;
|
|
37
|
+
/** A request succeeded: let the rate creep back towards the maximum. */
|
|
38
|
+
recordSuccess(host: string): void;
|
|
39
|
+
/** A request got HTTP 429: halve the rate and push the queue back. */
|
|
40
|
+
recordRateLimited(host: string): void;
|
|
41
|
+
/** Blocks the host for `seconds` (capped at a day), here and for other instances. */
|
|
42
|
+
coolDown(host: string, seconds: number): void;
|
|
43
|
+
private currentRate;
|
|
44
|
+
}
|
|
@@ -0,0 +1,98 @@
|
|
|
1
|
+
/** How far ahead a request may be scheduled before we give up on that host for now. */
|
|
2
|
+
const MAX_QUEUE_DELAY_MS = 4000;
|
|
3
|
+
/** Pause added after a 429, so requests already in flight don't hit the limit again. */
|
|
4
|
+
const BACKOFF_AFTER_429_MS = 1000;
|
|
5
|
+
/** How often a host's cooldown is re-read from the shared store. */
|
|
6
|
+
const COOLDOWN_RECHECK_MS = 60_000;
|
|
7
|
+
/** Rate recovery per successful request, in requests per second. */
|
|
8
|
+
const RATE_RECOVERY_STEP = 0.25;
|
|
9
|
+
const MIN_RATE = 1;
|
|
10
|
+
const MAX_COOLDOWN_SEC = 86_400;
|
|
11
|
+
/** Store key for a host cooldown (also read by my.tld's admin stats). */
|
|
12
|
+
export const cooldownKey = (host) => `rdap:cool:${host}`;
|
|
13
|
+
/**
|
|
14
|
+
* Per-host request pacing for registries.
|
|
15
|
+
*
|
|
16
|
+
* Registry back-ends serve many TLDs from one host (Identity Digital runs hundreds,
|
|
17
|
+
* Google ~40), so limits apply per host, not per TLD:
|
|
18
|
+
*
|
|
19
|
+
* - **Pacing:** requests are spaced 1/rate seconds apart. The rate starts at `maxRate`,
|
|
20
|
+
* halves on every 429 and recovers slowly on success.
|
|
21
|
+
*
|
|
22
|
+
* - **Bounded waiting:** if the next free slot is too far out, the request is skipped
|
|
23
|
+
* instead of queued. The caller falls back to WHOIS or reports "unknown".
|
|
24
|
+
*
|
|
25
|
+
* - **Cooldowns:** a long `Retry-After` blocks the host until it expires. Cooldowns are
|
|
26
|
+
* written to the shared store, so other instances respect them too.
|
|
27
|
+
*/
|
|
28
|
+
export class HostThrottle {
|
|
29
|
+
store;
|
|
30
|
+
maxRate;
|
|
31
|
+
rate = new Map();
|
|
32
|
+
nextSlotAt = new Map();
|
|
33
|
+
cooldownUntil = new Map();
|
|
34
|
+
cooldownCheckedAt = new Map();
|
|
35
|
+
constructor(store, maxRate) {
|
|
36
|
+
this.store = store;
|
|
37
|
+
this.maxRate = maxRate;
|
|
38
|
+
}
|
|
39
|
+
/**
|
|
40
|
+
* Reserves the next request slot for `host`.
|
|
41
|
+
*
|
|
42
|
+
* @returns milliseconds to wait before sending, or `null` if the queue is too long.
|
|
43
|
+
*/
|
|
44
|
+
reserveSlot(host) {
|
|
45
|
+
const now = Date.now();
|
|
46
|
+
const slot = Math.max(now, this.nextSlotAt.get(host) ?? 0);
|
|
47
|
+
if (slot - now > MAX_QUEUE_DELAY_MS) {
|
|
48
|
+
return null;
|
|
49
|
+
}
|
|
50
|
+
this.nextSlotAt.set(host, slot + 1000 / this.currentRate(host));
|
|
51
|
+
return slot - now;
|
|
52
|
+
}
|
|
53
|
+
/** True while the host is in a cooldown: checked locally first, then in the shared store. */
|
|
54
|
+
async isCoolingDown(host) {
|
|
55
|
+
if (this.isCoolingDownLocally(host)) {
|
|
56
|
+
return true;
|
|
57
|
+
}
|
|
58
|
+
const now = Date.now();
|
|
59
|
+
const checkedAt = this.cooldownCheckedAt.get(host) ?? 0;
|
|
60
|
+
if (checkedAt >= now - COOLDOWN_RECHECK_MS) {
|
|
61
|
+
return false;
|
|
62
|
+
}
|
|
63
|
+
this.cooldownCheckedAt.set(host, now);
|
|
64
|
+
const remainingMs = await this.store.pttl(cooldownKey(host));
|
|
65
|
+
if (remainingMs <= 0) {
|
|
66
|
+
return false;
|
|
67
|
+
}
|
|
68
|
+
this.cooldownUntil.set(host, now + remainingMs);
|
|
69
|
+
return true;
|
|
70
|
+
}
|
|
71
|
+
/** Synchronous check, used right before sending after a wait. */
|
|
72
|
+
isCoolingDownLocally(host) {
|
|
73
|
+
return (this.cooldownUntil.get(host) ?? 0) > Date.now();
|
|
74
|
+
}
|
|
75
|
+
/** A request succeeded: let the rate creep back towards the maximum. */
|
|
76
|
+
recordSuccess(host) {
|
|
77
|
+
const rate = this.rate.get(host);
|
|
78
|
+
if (rate === undefined || rate >= this.maxRate) {
|
|
79
|
+
return;
|
|
80
|
+
}
|
|
81
|
+
this.rate.set(host, Math.min(this.maxRate, rate + RATE_RECOVERY_STEP));
|
|
82
|
+
}
|
|
83
|
+
/** A request got HTTP 429: halve the rate and push the queue back. */
|
|
84
|
+
recordRateLimited(host) {
|
|
85
|
+
this.rate.set(host, Math.max(MIN_RATE, this.currentRate(host) / 2));
|
|
86
|
+
const pushedBack = Date.now() + BACKOFF_AFTER_429_MS;
|
|
87
|
+
this.nextSlotAt.set(host, Math.max(this.nextSlotAt.get(host) ?? 0, pushedBack));
|
|
88
|
+
}
|
|
89
|
+
/** Blocks the host for `seconds` (capped at a day), here and for other instances. */
|
|
90
|
+
coolDown(host, seconds) {
|
|
91
|
+
const sec = Math.min(seconds, MAX_COOLDOWN_SEC);
|
|
92
|
+
this.cooldownUntil.set(host, Date.now() + sec * 1000);
|
|
93
|
+
void this.store.set(cooldownKey(host), "1", sec);
|
|
94
|
+
}
|
|
95
|
+
currentRate(host) {
|
|
96
|
+
return this.rate.get(host) ?? this.maxRate;
|
|
97
|
+
}
|
|
98
|
+
}
|
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Tiny FIFO semaphore.
|
|
3
|
+
*
|
|
4
|
+
* Bounds how many tasks run at once (e.g. per upstream host) without blocking
|
|
5
|
+
* the event loop. Waiting tasks are released in arrival order.
|
|
6
|
+
*/
|
|
7
|
+
export declare class Semaphore {
|
|
8
|
+
private readonly max;
|
|
9
|
+
private active;
|
|
10
|
+
private readonly waiting;
|
|
11
|
+
constructor(max: number);
|
|
12
|
+
run<T>(task: () => Promise<T>): Promise<T>;
|
|
13
|
+
}
|
|
14
|
+
/**
|
|
15
|
+
* Lazily creates one semaphore per key, e.g. one per RDAP or WHOIS host.
|
|
16
|
+
*
|
|
17
|
+
* @example
|
|
18
|
+
* const slots = keyedSemaphore(3);
|
|
19
|
+
* await slots("whois.denic.de").run(() => query(...));
|
|
20
|
+
*/
|
|
21
|
+
export declare function keyedSemaphore(max: number): (key: string) => Semaphore;
|
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Tiny FIFO semaphore.
|
|
3
|
+
*
|
|
4
|
+
* Bounds how many tasks run at once (e.g. per upstream host) without blocking
|
|
5
|
+
* the event loop. Waiting tasks are released in arrival order.
|
|
6
|
+
*/
|
|
7
|
+
export class Semaphore {
|
|
8
|
+
max;
|
|
9
|
+
active = 0;
|
|
10
|
+
waiting = [];
|
|
11
|
+
constructor(max) {
|
|
12
|
+
this.max = max;
|
|
13
|
+
}
|
|
14
|
+
async run(task) {
|
|
15
|
+
if (this.active >= this.max) {
|
|
16
|
+
await new Promise((resolve) => this.waiting.push(resolve));
|
|
17
|
+
}
|
|
18
|
+
this.active++;
|
|
19
|
+
try {
|
|
20
|
+
return await task();
|
|
21
|
+
}
|
|
22
|
+
finally {
|
|
23
|
+
this.active--;
|
|
24
|
+
this.waiting.shift()?.();
|
|
25
|
+
}
|
|
26
|
+
}
|
|
27
|
+
}
|
|
28
|
+
/**
|
|
29
|
+
* Lazily creates one semaphore per key, e.g. one per RDAP or WHOIS host.
|
|
30
|
+
*
|
|
31
|
+
* @example
|
|
32
|
+
* const slots = keyedSemaphore(3);
|
|
33
|
+
* await slots("whois.denic.de").run(() => query(...));
|
|
34
|
+
*/
|
|
35
|
+
export function keyedSemaphore(max) {
|
|
36
|
+
const semaphores = new Map();
|
|
37
|
+
return (key) => {
|
|
38
|
+
let semaphore = semaphores.get(key);
|
|
39
|
+
if (!semaphore) {
|
|
40
|
+
semaphore = new Semaphore(max);
|
|
41
|
+
semaphores.set(key, semaphore);
|
|
42
|
+
}
|
|
43
|
+
return semaphore;
|
|
44
|
+
};
|
|
45
|
+
}
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Adapts a "call me back for every item, resolve when done" producer to an async
|
|
3
|
+
* iterator. Items are buffered, so a slow consumer never loses results.
|
|
4
|
+
*
|
|
5
|
+
* Errors from the producer are re-thrown after all buffered items were yielded.
|
|
6
|
+
*/
|
|
7
|
+
export declare function callbackToAsyncIterable<T>(produce: (push: (item: T) => void) => Promise<void>): AsyncIterable<T>;
|
|
@@ -0,0 +1,37 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Adapts a "call me back for every item, resolve when done" producer to an async
|
|
3
|
+
* iterator. Items are buffered, so a slow consumer never loses results.
|
|
4
|
+
*
|
|
5
|
+
* Errors from the producer are re-thrown after all buffered items were yielded.
|
|
6
|
+
*/
|
|
7
|
+
export async function* callbackToAsyncIterable(produce) {
|
|
8
|
+
const buffer = [];
|
|
9
|
+
let notify = null;
|
|
10
|
+
let finished = false;
|
|
11
|
+
let failure;
|
|
12
|
+
produce((item) => {
|
|
13
|
+
buffer.push(item);
|
|
14
|
+
notify?.();
|
|
15
|
+
})
|
|
16
|
+
.catch((err) => {
|
|
17
|
+
failure = err;
|
|
18
|
+
})
|
|
19
|
+
.finally(() => {
|
|
20
|
+
finished = true;
|
|
21
|
+
notify?.();
|
|
22
|
+
});
|
|
23
|
+
while (true) {
|
|
24
|
+
if (buffer.length) {
|
|
25
|
+
yield buffer.shift();
|
|
26
|
+
continue;
|
|
27
|
+
}
|
|
28
|
+
if (finished) {
|
|
29
|
+
break;
|
|
30
|
+
}
|
|
31
|
+
await new Promise((resolve) => (notify = resolve));
|
|
32
|
+
notify = null;
|
|
33
|
+
}
|
|
34
|
+
if (failure) {
|
|
35
|
+
throw failure;
|
|
36
|
+
}
|
|
37
|
+
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,75 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@mytld/engine",
|
|
3
|
-
"version": "
|
|
4
|
-
"
|
|
5
|
-
"
|
|
6
|
-
|
|
3
|
+
"version": "1.0.0",
|
|
4
|
+
"description": "Fast, honest domain availability checks for Node.js: parallel DNS, then RDAP and WHOIS. Only reports \"available\" when a registry confirms it.",
|
|
5
|
+
"keywords": [
|
|
6
|
+
"domain",
|
|
7
|
+
"availability",
|
|
8
|
+
"whois",
|
|
9
|
+
"rdap",
|
|
10
|
+
"dns",
|
|
11
|
+
"tld",
|
|
12
|
+
"domain-checker",
|
|
13
|
+
"registrar",
|
|
14
|
+
"rdap-client",
|
|
15
|
+
"whois-client",
|
|
16
|
+
"domain-availability"
|
|
17
|
+
],
|
|
18
|
+
"homepage": "https://mytld.dev",
|
|
19
|
+
"bugs": {
|
|
20
|
+
"url": "https://github.com/my-tld/mytld-engine/issues"
|
|
21
|
+
},
|
|
22
|
+
"repository": {
|
|
23
|
+
"type": "git",
|
|
24
|
+
"url": "git+https://github.com/my-tld/mytld-engine.git"
|
|
25
|
+
},
|
|
26
|
+
"license": "MIT",
|
|
27
|
+
"author": {
|
|
28
|
+
"name": "slxca",
|
|
29
|
+
"url": "https://github.com/slxca"
|
|
30
|
+
},
|
|
31
|
+
"type": "module",
|
|
32
|
+
"sideEffects": false,
|
|
33
|
+
"engines": {
|
|
34
|
+
"node": ">=20.3"
|
|
35
|
+
},
|
|
36
|
+
"exports": {
|
|
37
|
+
".": {
|
|
38
|
+
"types": "./dist/index.d.ts",
|
|
39
|
+
"import": "./dist/index.js"
|
|
40
|
+
},
|
|
41
|
+
"./domain": {
|
|
42
|
+
"types": "./dist/core/domain.d.ts",
|
|
43
|
+
"import": "./dist/core/domain.js"
|
|
44
|
+
},
|
|
45
|
+
"./tlds": {
|
|
46
|
+
"types": "./dist/core/tlds.d.ts",
|
|
47
|
+
"import": "./dist/core/tlds.js"
|
|
48
|
+
},
|
|
49
|
+
"./package.json": "./package.json"
|
|
50
|
+
},
|
|
51
|
+
"main": "./dist/index.js",
|
|
52
|
+
"types": "./dist/index.d.ts",
|
|
53
|
+
"files": [
|
|
54
|
+
"dist",
|
|
55
|
+
"!dist/**/*.map",
|
|
56
|
+
"README.md",
|
|
57
|
+
"LICENSE"
|
|
58
|
+
],
|
|
59
|
+
"scripts": {
|
|
60
|
+
"build": "rm -rf dist && tsc -p tsconfig.build.json",
|
|
61
|
+
"typecheck": "tsc --noEmit",
|
|
62
|
+
"test": "pnpm build && node --test test/",
|
|
63
|
+
"smoke": "pnpm build && node scripts/smoke.mjs",
|
|
64
|
+
"prepack": "pnpm build",
|
|
65
|
+
"prepublishOnly": "pnpm typecheck && node --test test/"
|
|
66
|
+
},
|
|
67
|
+
"devDependencies": {
|
|
68
|
+
"@types/node": "^20",
|
|
69
|
+
"typescript": "^5"
|
|
70
|
+
},
|
|
71
|
+
"packageManager": "pnpm@12.18.0",
|
|
72
|
+
"publishConfig": {
|
|
73
|
+
"access": "public"
|
|
74
|
+
}
|
|
75
|
+
}
|