declare namespace braces { type Transform = (str: string) => string; interface Options { /** * Limit the length of the input string. Useful when the input string is generated or your application allows * users to pass a string, et cetera. * * @default 65536 * @example * console.log(braces('a/{b,c}/d', { maxLength: 3 })); * //=> throws an error */ maxLength?: number | undefined; /** * Generate an "expanded" brace pattern (alternatively you can use the `braces.expand()` method). * * @default undefined * @example * console.log(braces('a/{b,c}/d', { expand: true })); * //=> [ 'a/b/d', 'a/c/d' ] */ expand?: boolean | undefined; /** * Remove duplicates from the returned array. * * @default undefined */ nodupes?: boolean | undefined; /** * To prevent malicious patterns from being passed by users, an error is thrown when `braces.expand()` * is used or `options.expand` is true and the generated range will exceed the `rangeLimit`. * * You can customize `options.rangeLimit` or set it to `Infinity` to disable this altogether. * * @default 1000 * @example * // pattern exceeds the "rangeLimit", so it's optimized automatically * console.log(braces.expand('{1..1000}')); * //=> ['([1-9]|[1-9][0-9]{1,2}|1000)'] * * // pattern does not exceed "rangeLimit", so it's NOT optimized * console.log(braces.expand('{1..100}')); * //=> ['1', '2', '3', '4', '5', …, '100'] */ rangeLimit?: number | undefined; /** * Customize range expansion. * * @default undefined * @example * const range = braces.expand('x{a..e}y', { * transform: (str) => `foo/${str}` * }); * * console.log(range); * //=> [ 'xfooay', 'xfooby', 'xfoocy', 'xfoody', 'xfooey' ] */ transform?: Transform | undefined; /** * In regular expressions, quanitifiers can be used to specify how many times a token can be repeated. * For example, `a{1,3}` will match the letter `a` one to three times. * * Unfortunately, regex quantifiers happen to share the same syntax as [Bash lists](#lists) * * The `quantifiers` option tells braces to detect when [regex quantifiers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#quantifiers) * are defined in the given pattern, and not to try to expand them as lists. * * @default undefined * @example * const braces = require('braces'); * console.log(braces('a/b{1,3}/{x,y,z}')); * //=> [ 'a/b(1|3)/(x|y|z)' ] * console.log(braces('a/b{1,3}/{x,y,z}', {quantifiers: true})); * //=> [ 'a/b{1,3}/(x|y|z)' ] * console.log(braces('a/b{1,3}/{x,y,z}', {quantifiers: true, expand: true})); * //=> [ 'a/b{1,3}/x', 'a/b{1,3}/y', 'a/b{1,3}/z' ] */ quantifiers?: boolean | undefined; /** * Do not strip backslashes that were used for escaping from the result. * * @default undefined */ keepEscaping?: boolean | undefined; } } interface Braces { (pattern: string, options?: braces.Options): string[]; expand(pattern: string): string[]; } declare const braces: Braces; export as namespace braces; export = braces;