type Skip = null;

interface Token<Type extends string, Value extends unknown> {
  type: Type;
  value: Value;
}

type Tokens = Token<string, unknown>[];

interface Lexer<
  TTokens extends Tokens,
  State extends Record<string, unknown>,
  Methods extends Record<string, Function>,
> {
  enter: (
    char: string,
    internal: {
      token: <const TToken extends Token<string, unknown>>(
        token: TToken,
      ) => [TToken];
      skip: Skip;
      state: State;
      methods: Methods;
    },
  ) => TTokens | Skip;
  state?: State;
  methods?: Methods;
}

const empty = Object.create(null);

const lexer = <
  const TTokens extends Tokens,
  State extends Record<string, unknown>,
  Methods extends Record<string, Function>,
>(
  lexer: Lexer<TTokens, State, Methods>,
) => {
  return {
    lexer: (source: string) =>
      source.split("").map((char) =>
        lexer.enter(char, {
          token: (token) => [token],
          skip: null,
          state: lexer.state || empty,
          methods: lexer.methods || empty,
        }),
      ).filter(t => !!t).flat(),
  };
};

const customLexer = lexer({
  state: {
    alreadyReadChars: [] as string[],
  },
  methods: {
    isNumbericChar: (char: String) => !isNaN(Number(char)),
  },
  enter: (char, internal) => {
    if (
      internal.state.alreadyReadChars.includes(char) ||
      internal.methods.isNumbericChar(char)
    ) {
      return internal.skip;
    }

    internal.state.alreadyReadChars.push(char);

    return internal.token({
      type: "char",
      value: {
        char,
      },
    });
  },
});

console.log(customLexer.lexer("abcdefg1234hijkkkk"));