feat: add orChar/from chain for charIn/charNotIn

src/core/inputs.ts

@@ -1,4 +1,4 @@
-import type { Input } from './internal'
+import type { CharInput, Input } from './internal'
 import { createInput } from './internal'
 import type { EscapeChar } from './types/escape'
 import type { Join } from './types/join'
@@ -10,16 +10,27 @@ export type { Input }
 
 const ESCAPE_REPLACE_RE = /[.*+?^${}()|[\]\\/]/g
 
-/** This matches any character in the string provided */
-export function charIn<T extends string>(chars: T) {
-  return createInput(`[${chars.replace(/[-\\^\]]/g, '\\$&')}]`) as Input<`[${EscapeChar<T>}]`>
+function createCharInput <T extends string>(raw: T) {
+  const input = createInput(`[${raw}]`)
+  const from = <From extends string, To extends string>(charFrom: From, charTo: To) => createCharInput(`${raw}${escapeCharInput(charFrom)}-${escapeCharInput(charTo)}`)
+  const orChar = Object.assign((<T extends string>(chars: T) => createCharInput(`${raw}${escapeCharInput(chars)}`)), { from })
+  return Object.assign(input, { orChar, from }) as CharInput<T>
 }
 
-/** This matches any character that is not in the string provided */
-export function charNotIn<T extends string>(chars: T) {
-  return createInput(`[^${chars.replace(/[-\\^\]]/g, '\\$&')}]`) as Input<`[^${EscapeChar<T>}]`>
+function escapeCharInput <T extends string>(raw: T) {
+  return raw.replace(/[-\\^\]]/g, '\\$&') as EscapeChar<T>
 }
 
+/** This matches any character in the string provided */
+export const charIn = Object.assign(<T extends string>(chars: T) => {
+  return createCharInput(escapeCharInput(chars))
+}, createCharInput(''))
+
+/** This matches any character that is not in the string provided */
+export const charNotIn = Object.assign(<T extends string>(chars: T) => {
+  return createCharInput(`^${escapeCharInput(chars)}`)
+}, createCharInput('^'))
+
 /**
  * This takes a variable number of inputs and matches any of them
  * @example

src/core/internal.ts

@@ -1,4 +1,5 @@
 import { exactly } from './inputs'
+import type { EscapeChar } from './types/escape'
 import type { Join } from './types/join'
 import type { InputSource, MapToCapturedGroupsArr, MapToGroups, MapToValues } from './types/sources'
 import type { IfUnwrapped } from './wrap'
@@ -134,6 +135,11 @@ export interface Input<
   toString: () => string
 }
 
+export interface CharInput<T extends string> extends Input<`[${T}]`> {
+  orChar: (<Or extends string>(chars: Or) => CharInput<`${T}${EscapeChar<Or>}`>) & CharInput<T>
+  from: <From extends string, To extends string>(charFrom: From, charTo: To) => CharInput<`${T}${EscapeChar<From>}-${EscapeChar<To>}`>
+}
+
 export function createInput<
   Value extends string,
   Groups extends string = never,

test/inputs.test.ts

@@ -30,11 +30,41 @@ describe('inputs', () => {
     expect(new RegExp(input as any)).toMatchInlineSnapshot('/\\[fo\\\\\\]\\\\\\^\\]/')
     expectTypeOf(extractRegExp(input)).toEqualTypeOf<'[fo\\]\\^]'>()
   })
+  it('charIn.orChar', () => {
+    const input = charIn('a').orChar('b')
+    expect(new RegExp(input as any)).toMatchInlineSnapshot('/\\[ab\\]/')
+    expectTypeOf(extractRegExp(input)).toEqualTypeOf<'[ab]'>()
+  })
+  it('charIn.orChar.from', () => {
+    const input = charIn('a').orChar.from('a', 'b')
+    expect(new RegExp(input as any)).toMatchInlineSnapshot('/\\[aa-b\\]/')
+    expectTypeOf(extractRegExp(input)).toEqualTypeOf<'[aa-b]'>()
+  })
+  it('charIn.from', () => {
+    const input = charIn.from('a', 'b')
+    expect(new RegExp(input as any)).toMatchInlineSnapshot('/\\[a-b\\]/')
+    expectTypeOf(extractRegExp(input)).toEqualTypeOf<'[a-b]'>()
+  })
   it('charNotIn', () => {
     const input = charNotIn('fo^-')
     expect(new RegExp(input as any)).toMatchInlineSnapshot('/\\[\\^fo\\\\\\^\\\\-\\]/')
     expectTypeOf(extractRegExp(input)).toEqualTypeOf<'[^fo\\^\\-]'>()
   })
+  it('charNotIn.orChar', () => {
+    const input = charNotIn('a').orChar('b')
+    expect(new RegExp(input as any)).toMatchInlineSnapshot('/\\[\\^ab\\]/')
+    expectTypeOf(extractRegExp(input)).toEqualTypeOf<'[^ab]'>()
+  })
+  it('charNotIn.orChar.from', () => {
+    const input = charNotIn('a').orChar.from('a', 'b')
+    expect(new RegExp(input as any)).toMatchInlineSnapshot('/\\[\\^aa-b\\]/')
+    expectTypeOf(extractRegExp(input)).toEqualTypeOf<'[^aa-b]'>()
+  })
+  it('charNotIn.from', () => {
+    const input = charNotIn.from('a', 'b')
+    expect(new RegExp(input as any)).toMatchInlineSnapshot('/\\[\\^a-b\\]/')
+    expectTypeOf(extractRegExp(input)).toEqualTypeOf<'[^a-b]'>()
+  })
   it('anyOf', () => {
     const values = ['fo/o', 'bar', 'baz', oneOrMore('this')] as const
     const input = anyOf(...values)