[READ-ONLY] Mirror of https://github.com/bombshell-dev/clack. Effortlessly build beautiful command-line apps
bomb.sh/docs/clack/basics/getting-started/
cli
command-line
command-line-app
node
prompt
prompts
feat: standard schema for validation (#543)
Co-authored-by: James Garbutt <43081j@users.noreply.github.com>
Co-authored-by: Willow (GHOST) <ghostdevbusiness@gmail.com>
authored by
Florian Lefebvre
James Garbutt
Willow (GHOST)
and committed by
GitHub
(May 28, 2026, 11:12 AM -0500)
83428ac6
adb6af9f
+365
-78
+1
examples/basic/package.json
+1
examples/basic/package.json
+31
examples/basic/standard-schema-validation.ts
+31
examples/basic/standard-schema-validation.ts
···
1
+
import { setTimeout } from 'node:timers/promises';
2
+
import { isCancel, note, text } from '@clack/prompts';
3
+
import { type } from 'arktype';
4
+
5
+
console.clear();
6
+
7
+
// Example demonstrating the issue with initial value validation
8
+
const name = await text({
9
+
message: 'Enter your email',
10
+
initialValue: 'aaa', // Invalid initial value without @
11
+
validate: type('string.email').describe('Invalid email'),
12
+
});
13
+
14
+
if (!isCancel(name)) {
15
+
note(`Valid name: ${name}`, 'Success');
16
+
}
17
+
18
+
await setTimeout(1000);
19
+
20
+
// Example with a valid initial value for comparison
21
+
const validName = await text({
22
+
message: 'Enter another email',
23
+
initialValue: 'john.doe@example.com', // Valid initial value
24
+
validate: type('string.email').describe('Invalid email'),
25
+
});
26
+
27
+
if (!isCancel(validName)) {
28
+
note(`Valid name: ${validName}`, 'Success');
29
+
}
30
+
31
+
await setTimeout(1000);
+1
packages/core/package.json
+1
packages/core/package.json
+2
packages/core/src/index.ts
+2
packages/core/src/index.ts
···
24
24
export { block, getColumns, getRows, isCancel, wrapTextWithPrefix } from './utils/index.js';
25
25
export type { ClackSettings } from './utils/settings.js';
26
26
export { settings, updateSettings } from './utils/settings.js';
27
+
export type { Validate } from './utils/validation.js';
28
+
export { runValidation } from './utils/validation.js';
+10
-2
packages/core/src/prompts/prompt.ts
+10
-2
packages/core/src/prompts/prompt.ts
···
13
13
setRawMode,
14
14
settings,
15
15
} from '../utils/index.js';
16
+
import type { Validate } from '../utils/validation.js';
17
+
import { runValidation } from '../utils/validation.js';
16
18
17
19
export interface PromptOptions<TValue, Self extends Prompt<TValue>> {
18
20
render(this: Omit<Self, 'prompt'>): string | undefined;
19
21
initialValue?: any;
20
22
initialUserInput?: string;
21
-
validate?: ((value: TValue | undefined) => string | Error | undefined) | undefined;
23
+
24
+
/**
25
+
* A function or a [Standard Schema](https://github.com/standard-schema/standard-schema)
26
+
* that validates user input. If a custom function is given, you should return a `string` or `Error`
27
+
* to show as a validation error, or `undefined` to accept the result.
28
+
*/
29
+
validate?: Validate<TValue> | undefined;
22
30
input?: Readable;
23
31
output?: Writable;
24
32
signal?: AbortSignal;
···
230
238
231
239
if (key?.name === 'return' && this._shouldSubmit(char, key)) {
232
240
if (this.opts.validate) {
233
-
const problem = this.opts.validate(this.value);
241
+
const problem = runValidation(this.opts.validate, this.value);
234
242
if (problem) {
235
243
this.error = problem instanceof Error ? problem.message : problem;
236
244
this.state = 'error';
+78
packages/core/src/utils/standard-schema.ts
+78
packages/core/src/utils/standard-schema.ts
···
1
+
// https://standardschema.dev/schema
2
+
3
+
/** The Standard Schema interface. */
4
+
export interface StandardSchemaV1<Input = unknown, Output = Input> {
5
+
/** The Standard Schema properties. */
6
+
readonly '~standard': StandardSchemaV1.Props<Input, Output>;
7
+
}
8
+
9
+
export declare namespace StandardSchemaV1 {
10
+
/** The Standard Schema properties interface. */
11
+
export interface Props<Input = unknown, Output = Input> {
12
+
/** The version number of the standard. */
13
+
readonly version: 1;
14
+
/** The vendor name of the schema library. */
15
+
readonly vendor: string;
16
+
/** Validates unknown input values. */
17
+
readonly validate: (
18
+
value: unknown,
19
+
options?: StandardSchemaV1.Options | undefined
20
+
) => Result<Output> | Promise<Result<Output>>;
21
+
/** Inferred types associated with the schema. */
22
+
readonly types?: Types<Input, Output> | undefined;
23
+
}
24
+
25
+
/** The result interface of the validate function. */
26
+
export type Result<Output> = SuccessResult<Output> | FailureResult;
27
+
28
+
/** The result interface if validation succeeds. */
29
+
export interface SuccessResult<Output> {
30
+
/** The typed output value. */
31
+
readonly value: Output;
32
+
/** A falsy value for `issues` indicates success. */
33
+
readonly issues?: undefined;
34
+
}
35
+
36
+
export interface Options {
37
+
/** Explicit support for additional vendor-specific parameters, if needed. */
38
+
readonly libraryOptions?: Record<string, unknown> | undefined;
39
+
}
40
+
41
+
/** The result interface if validation fails. */
42
+
export interface FailureResult {
43
+
/** The issues of failed validation. */
44
+
readonly issues: ReadonlyArray<Issue>;
45
+
}
46
+
47
+
/** The issue interface of the failure output. */
48
+
export interface Issue {
49
+
/** The error message of the issue. */
50
+
readonly message: string;
51
+
/** The path of the issue, if any. */
52
+
readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
53
+
}
54
+
55
+
/** The path segment interface of the issue. */
56
+
export interface PathSegment {
57
+
/** The key representing a path segment. */
58
+
readonly key: PropertyKey;
59
+
}
60
+
61
+
/** The Standard Schema types interface. */
62
+
export interface Types<Input = unknown, Output = Input> {
63
+
/** The input type of the schema. */
64
+
readonly input: Input;
65
+
/** The output type of the schema. */
66
+
readonly output: Output;
67
+
}
68
+
69
+
/** Infers the input type of a Standard Schema. */
70
+
export type InferInput<Schema extends StandardSchemaV1> = NonNullable<
71
+
Schema['~standard']['types']
72
+
>['input'];
73
+
74
+
/** Infers the output type of a Standard Schema. */
75
+
export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<
76
+
Schema['~standard']['types']
77
+
>['output'];
78
+
}
+61
packages/core/src/utils/validation.ts
+61
packages/core/src/utils/validation.ts
···
1
+
import type { StandardSchemaV1 } from './standard-schema.js';
2
+
3
+
/**
4
+
* A function or [Standard Schema](https://github.com/standard-schema/standard-schema)
5
+
* that validates user input. If a custom function is given, you should return a
6
+
* `string` or `Error` to show as a validation error, or `undefined` to accept the result.
7
+
*
8
+
* @example Using arktype
9
+
* ```ts
10
+
* import { text } from '@clack/prompts';
11
+
* import { type } from 'arktype';
12
+
*
13
+
* const name = await text({
14
+
* message: 'Enter your name (letters only)',
15
+
* validate: type('string.alpha').describe('Name can only contain letters'),
16
+
* });
17
+
* ```
18
+
*
19
+
* @example Custom validator
20
+
* ```ts
21
+
* import { text } from '@clack/prompts';
22
+
*
23
+
* const age = await text({
24
+
* message: 'Enter your age:',
25
+
* validate(value) {
26
+
* if (!value) return 'Please enter a value';
27
+
* const num = parseInt(value);
28
+
* if (isNaN(num)) return 'Please enter a valid number';
29
+
* if (num < 0 || num > 120) return 'Age must be between 0 and 120';
30
+
* return undefined;
31
+
* },
32
+
* });
33
+
* ```
34
+
*/
35
+
export type Validate<TValue> =
36
+
| ((value: TValue | undefined) => string | Error | undefined)
37
+
| StandardSchemaV1<TValue | undefined, unknown>;
38
+
39
+
/**
40
+
* Runs the `validate()` option and normalizes the result
41
+
* @param validate - The validate option
42
+
* @param value - The user input
43
+
* @returns the validation result
44
+
*/
45
+
export function runValidation<TValue>(
46
+
validate: Validate<TValue>,
47
+
value: TValue | undefined
48
+
): string | Error | undefined {
49
+
if ('~standard' in validate) {
50
+
const result = validate['~standard'].validate(value);
51
+
// https://standardschema.dev/schema#how-to-only-allow-synchronous-validation
52
+
// TODO: https://github.com/bombshell-dev/clack/issues/92
53
+
if (result instanceof Promise) {
54
+
throw new TypeError(
55
+
'Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic.'
56
+
);
57
+
}
58
+
return result.issues?.at(0)?.message;
59
+
}
60
+
return validate(value);
61
+
}
+94
-58
packages/core/test/prompts/prompt.test.ts
+94
-58
packages/core/test/prompts/prompt.test.ts
···
1
+
import { type } from 'arktype';
1
2
import { cursor } from 'sisteransi';
2
3
import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
3
4
import { default as Prompt } from '../../src/prompts/prompt.js';
···
233
234
expect(instance.state).to.equal('cancel');
234
235
});
235
236
236
-
test('accepts invalid initial value', () => {
237
-
const instance = new Prompt({
238
-
input,
239
-
output,
240
-
render: () => 'foo',
241
-
initialValue: 'invalid',
242
-
validate: (value) => (value === 'valid' ? undefined : 'must be valid'),
237
+
describe('function validation', () => {
238
+
test('accepts invalid initial value', () => {
239
+
const instance = new Prompt({
240
+
input,
241
+
output,
242
+
render: () => 'foo',
243
+
initialValue: 'invalid',
244
+
validate: (value) => (value === 'valid' ? undefined : 'must be valid'),
245
+
});
246
+
instance.prompt();
247
+
248
+
expect(instance.state).to.equal('active');
249
+
expect(instance.error).to.equal('');
243
250
});
244
-
instance.prompt();
245
251
246
-
expect(instance.state).to.equal('active');
247
-
expect(instance.error).to.equal('');
248
-
});
252
+
test('validates value on return', () => {
253
+
const instance = new Prompt({
254
+
input,
255
+
output,
256
+
render: () => 'foo',
257
+
validate: (value) => (value === 'valid' ? undefined : 'must be valid'),
258
+
});
259
+
instance.prompt();
249
260
250
-
test('validates value on return', () => {
251
-
const instance = new Prompt({
252
-
input,
253
-
output,
254
-
render: () => 'foo',
255
-
validate: (value) => (value === 'valid' ? undefined : 'must be valid'),
256
-
});
257
-
instance.prompt();
261
+
instance.value = 'invalid';
258
262
259
-
instance.value = 'invalid';
263
+
input.emit('keypress', '', { name: 'return' });
260
264
261
-
input.emit('keypress', '', { name: 'return' });
265
+
expect(instance.state).to.equal('error');
266
+
expect(instance.error).to.equal('must be valid');
267
+
});
262
268
263
-
expect(instance.state).to.equal('error');
264
-
expect(instance.error).to.equal('must be valid');
265
-
});
269
+
test('validates value with Error object', () => {
270
+
const instance = new Prompt({
271
+
input,
272
+
output,
273
+
render: () => 'foo',
274
+
validate: (value) => (value === 'valid' ? undefined : new Error('must be valid')),
275
+
});
276
+
instance.prompt();
266
277
267
-
test('validates value with Error object', () => {
268
-
const instance = new Prompt({
269
-
input,
270
-
output,
271
-
render: () => 'foo',
272
-
validate: (value) => (value === 'valid' ? undefined : new Error('must be valid')),
278
+
instance.value = 'invalid';
279
+
input.emit('keypress', '', { name: 'return' });
280
+
281
+
expect(instance.state).to.equal('error');
282
+
expect(instance.error).to.equal('must be valid');
273
283
});
274
-
instance.prompt();
275
284
276
-
instance.value = 'invalid';
277
-
input.emit('keypress', '', { name: 'return' });
285
+
test('validates value with regex validation', () => {
286
+
const instance = new Prompt<string>({
287
+
input,
288
+
output,
289
+
render: () => 'foo',
290
+
validate: (value) => (/^[A-Z]+$/.test(value ?? '') ? undefined : 'Invalid value'),
291
+
});
292
+
instance.prompt();
278
293
279
-
expect(instance.state).to.equal('error');
280
-
expect(instance.error).to.equal('must be valid');
281
-
});
294
+
instance.value = 'Invalid Value $$$';
295
+
input.emit('keypress', '', { name: 'return' });
282
296
283
-
test('validates value with regex validation', () => {
284
-
const instance = new Prompt<string>({
285
-
input,
286
-
output,
287
-
render: () => 'foo',
288
-
validate: (value) => (/^[A-Z]+$/.test(value ?? '') ? undefined : 'Invalid value'),
297
+
expect(instance.state).to.equal('error');
298
+
expect(instance.error).to.equal('Invalid value');
289
299
});
290
-
instance.prompt();
291
300
292
-
instance.value = 'Invalid Value $$$';
293
-
input.emit('keypress', '', { name: 'return' });
301
+
test('accepts valid value with regex validation', () => {
302
+
const instance = new Prompt<string>({
303
+
input,
304
+
output,
305
+
render: () => 'foo',
306
+
validate: (value) => (/^[A-Z]+$/.test(value ?? '') ? undefined : 'Invalid value'),
307
+
});
308
+
instance.prompt();
309
+
310
+
instance.value = 'VALID';
311
+
input.emit('keypress', '', { name: 'return' });
294
312
295
-
expect(instance.state).to.equal('error');
296
-
expect(instance.error).to.equal('Invalid value');
313
+
expect(instance.state).to.equal('submit');
314
+
expect(instance.error).to.equal('');
315
+
});
297
316
});
298
317
299
-
test('accepts valid value with regex validation', () => {
300
-
const instance = new Prompt<string>({
301
-
input,
302
-
output,
303
-
render: () => 'foo',
304
-
validate: (value) => (/^[A-Z]+$/.test(value ?? '') ? undefined : 'Invalid value'),
318
+
describe('standard schema', () => {
319
+
test('accepts invalid initial value', () => {
320
+
const instance = new Prompt<string>({
321
+
input,
322
+
output,
323
+
render: () => 'foo',
324
+
initialValue: 'invalid',
325
+
validate: type("'valid'"),
326
+
});
327
+
instance.prompt();
328
+
329
+
expect(instance.state).to.equal('active');
330
+
expect(instance.error).to.equal('');
305
331
});
306
-
instance.prompt();
332
+
333
+
test('validates value on return', () => {
334
+
const instance = new Prompt<string>({
335
+
input,
336
+
output,
337
+
render: () => 'foo',
338
+
validate: type("'valid'"),
339
+
});
340
+
instance.prompt();
307
341
308
-
instance.value = 'VALID';
309
-
input.emit('keypress', '', { name: 'return' });
342
+
instance.value = 'invalid';
343
+
344
+
input.emit('keypress', '', { name: 'return' });
310
345
311
-
expect(instance.state).to.equal('submit');
312
-
expect(instance.error).to.equal('');
346
+
expect(instance.state).to.equal('error');
347
+
expect(instance.error).to.equal('must be "valid" (was "invalid")');
348
+
});
313
349
});
314
350
});
+5
-3
packages/prompts/src/autocomplete.ts
+5
-3
packages/prompts/src/autocomplete.ts
···
1
1
import { styleText } from 'node:util';
2
+
import type { Validate } from '@clack/core';
2
3
import { AutocompletePrompt, settings } from '@clack/core';
3
4
import {
4
5
type CommonOptions,
···
70
71
placeholder?: string;
71
72
72
73
/**
73
-
* A function that validates user input. Return a `string` or `Error` to show as a
74
-
* validation error, or `undefined` to accept the result.
74
+
* A function or a [Standard Schema](https://github.com/standard-schema/standard-schema)
75
+
* that validates user input. If a custom function is given, you should return a `string` or `Error`
76
+
* to show as a validation error, or `undefined` to accept the result.
75
77
*/
76
-
validate?: (value: Value | Value[] | undefined) => string | Error | undefined;
78
+
validate?: Validate<Value | Value[]>;
77
79
78
80
/**
79
81
* Custom filter function to match options against the search input.
+11
-5
packages/prompts/src/date.ts
+11
-5
packages/prompts/src/date.ts
···
1
1
import { styleText } from 'node:util';
2
-
import type { DateFormat, State } from '@clack/core';
3
-
import { DatePrompt, settings } from '@clack/core';
2
+
import type { DateFormat, State, Validate } from '@clack/core';
3
+
import { DatePrompt, runValidation, settings } from '@clack/core';
4
4
import { type CommonOptions, S_BAR, S_BAR_END, symbol } from './common.js';
5
5
6
6
export type { DateFormat };
···
13
13
initialValue?: Date;
14
14
minDate?: Date;
15
15
maxDate?: Date;
16
-
validate?: (value: Date | undefined) => string | Error | undefined;
16
+
17
+
/**
18
+
* A function or a [Standard Schema](https://github.com/standard-schema/standard-schema)
19
+
* that validates user input. If a custom function is given, you should return a `string` or `Error`
20
+
* to show as a validation error, or `undefined` to accept the result.
21
+
*/
22
+
validate?: Validate<Date>;
17
23
}
18
24
19
25
export const date = (opts: DateOptions) => {
···
23
29
validate(value: Date | undefined) {
24
30
if (value === undefined) {
25
31
if (opts.defaultValue !== undefined) return undefined;
26
-
if (validate) return validate(value);
32
+
if (validate) return runValidation(validate, value);
27
33
return settings.date.messages.required;
28
34
}
29
35
const iso = (d: Date) => d.toISOString().slice(0, 10);
···
33
39
if (opts.maxDate && iso(value) > iso(opts.maxDate)) {
34
40
return settings.date.messages.beforeMax(opts.maxDate);
35
41
}
36
-
if (validate) return validate(value);
42
+
if (validate) return runValidation(validate, value);
37
43
return undefined;
38
44
},
39
45
render() {
+5
-3
packages/prompts/src/password.ts
+5
-3
packages/prompts/src/password.ts
···
1
1
import { styleText } from 'node:util';
2
+
import type { Validate } from '@clack/core';
2
3
import { PasswordPrompt, settings } from '@clack/core';
3
4
import { type CommonOptions, S_BAR, S_BAR_END, S_PASSWORD_MASK, symbol } from './common.js';
4
5
···
18
19
mask?: string;
19
20
20
21
/**
21
-
* A function that validates user input. Return a `string` or `Error` to show as a
22
-
* validation error, or `undefined` to accept the result.
22
+
* A function or a [Standard Schema](https://github.com/standard-schema/standard-schema)
23
+
* that validates user input. If a custom function is given, you should return a `string` or `Error`
24
+
* to show as a validation error, or `undefined` to accept the result.
23
25
*/
24
-
validate?: (value: string | undefined) => string | Error | undefined;
26
+
validate?: Validate<string>;
25
27
26
28
/**
27
29
* When enabled it causes the input to be cleared if/when validation fails.
+7
-4
packages/prompts/src/path.ts
+7
-4
packages/prompts/src/path.ts
···
1
1
import { existsSync, lstatSync, readdirSync } from 'node:fs';
2
2
import { dirname, join } from 'node:path';
3
+
import type { Validate } from '@clack/core';
4
+
import { runValidation } from '@clack/core';
3
5
import { autocomplete } from './autocomplete.js';
4
6
import type { CommonOptions } from './common.js';
5
7
···
33
35
initialValue?: string;
34
36
35
37
/**
36
-
* A function that validates the given path. Return a `string` or `Error` to show as a
37
-
* validation error, or `undefined` to accept the result.
38
+
* A function or a [Standard Schema](https://github.com/standard-schema/standard-schema)
39
+
* that validates user input. If a custom function is given, you should return a `string` or `Error`
40
+
* to show as a validation error, or `undefined` to accept the result.
38
41
*/
39
-
validate?: (value: string | undefined) => string | Error | undefined;
42
+
validate?: Validate<string>;
40
43
}
41
44
42
45
/**
···
71
74
return 'Please select a path';
72
75
}
73
76
if (validate) {
74
-
return validate(value);
77
+
return runValidation(validate, value);
75
78
}
76
79
return undefined;
77
80
},
+5
-3
packages/prompts/src/text.ts
+5
-3
packages/prompts/src/text.ts
···
1
1
import { styleText } from 'node:util';
2
+
import type { Validate } from '@clack/core';
2
3
import { settings, TextPrompt } from '@clack/core';
3
4
import { type CommonOptions, S_BAR, S_BAR_END, symbol } from './common.js';
4
5
···
28
29
initialValue?: string;
29
30
30
31
/**
31
-
* A function that validates user input. Return a `string` or `Error` to show as a
32
-
* validation error, or `undefined` to accept the result.
32
+
* A function or a [Standard Schema](https://github.com/standard-schema/standard-schema)
33
+
* that validates user input. If a custom function is given, you should return a `string` or `Error`
34
+
* to show as a validation error, or `undefined` to accept the result.
33
35
*/
34
-
validate?: (value: string | undefined) => string | Error | undefined;
36
+
validate?: Validate<string>;
35
37
}
36
38
37
39
/**
+34
pnpm-lock.yaml
+34
pnpm-lock.yaml
···
35
35
'@clack/prompts':
36
36
specifier: workspace:*
37
37
version: link:../../packages/prompts
38
+
arktype:
39
+
specifier: ^2.2.0
40
+
version: 2.2.0
38
41
jiti:
39
42
specifier: ^1.17.0
40
43
version: 1.21.7
···
67
70
specifier: ^1.0.5
68
71
version: 1.0.5
69
72
devDependencies:
73
+
arktype:
74
+
specifier: ^2.2.0
75
+
version: 2.2.0
70
76
vitest:
71
77
specifier: ^3.2.4
72
78
version: 3.2.4(@types/node@20.19.39)(jiti@2.5.0)
···
100
106
version: 0.1.2(vitest@3.2.4(@types/node@20.19.39)(jiti@2.5.0))
101
107
102
108
packages:
109
+
110
+
'@ark/schema@0.56.0':
111
+
resolution: {integrity: sha512-ECg3hox/6Z/nLajxXqNhgPtNdHWC9zNsDyskwO28WinoFEnWow4IsERNz9AnXRhTZJnYIlAJ4uGn3nlLk65vZA==}
112
+
113
+
'@ark/util@0.56.0':
114
+
resolution: {integrity: sha512-BghfRC8b9pNs3vBoDJhcta0/c1J1rsoS1+HgVUreMFPdhz/CRAKReAu57YEllNaSy98rWAdY1gE+gFup7OXpgA==}
103
115
104
116
'@babel/code-frame@7.26.2':
105
117
resolution: {integrity: sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==}
···
773
785
argparse@2.0.1:
774
786
resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
775
787
788
+
arkregex@0.0.5:
789
+
resolution: {integrity: sha512-ncYjBdLlh5/QnVsAA8De16Tc9EqmYM7y/WU9j+236KcyYNUXogpz3sC4ATIZYzzLxwI+0sEOaQLEmLmRleaEXw==}
790
+
791
+
arktype@2.2.0:
792
+
resolution: {integrity: sha512-t54MZ7ti5BhOEvzEkgKnWvqj+UbDfWig+DHr5I34xatymPusKLS0lQpNJd8M6DzmIto2QGszHfNKoFIT8tMCZQ==}
793
+
776
794
array-union@2.1.0:
777
795
resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
778
796
engines: {node: '>=8'}
···
1854
1872
1855
1873
snapshots:
1856
1874
1875
+
'@ark/schema@0.56.0':
1876
+
dependencies:
1877
+
'@ark/util': 0.56.0
1878
+
1879
+
'@ark/util@0.56.0': {}
1880
+
1857
1881
'@babel/code-frame@7.26.2':
1858
1882
dependencies:
1859
1883
'@babel/helper-validator-identifier': 7.25.9
···
2432
2456
sprintf-js: 1.0.3
2433
2457
2434
2458
argparse@2.0.1: {}
2459
+
2460
+
arkregex@0.0.5:
2461
+
dependencies:
2462
+
'@ark/util': 0.56.0
2463
+
2464
+
arktype@2.2.0:
2465
+
dependencies:
2466
+
'@ark/schema': 0.56.0
2467
+
'@ark/util': 0.56.0
2468
+
arkregex: 0.0.5
2435
2469
2436
2470
array-union@2.1.0: {}
2437
2471