typescript - Por que a extensão do tipo string funciona e é mapeada para readonly?

Atualmente, estou trabalhando em alguns desafios de TypeScript para melhorar, um deles foi implementar um tipo DeepReadOnly. Inicialmente, não consegui e procurei as respostas. Uma dessas respostas foi:

type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends Function ? T[P] : DeepReadonly<T[P]>
}

O caso de teste foi o seguinte:

type X = {
  a: () => 22
  b: string
  c: {
    d: boolean
    e: {
      g: {
        h: {
          i: true
          j: 'string'
        }
        k: 'hello'
      }
    }
  }
}

type Expected = {
  readonly a: () => 22
  readonly b: string
  readonly c: {
    readonly d: boolean
    readonly e: {
      readonly g: {
        readonly h: {
          readonly i: true
          readonly j: 'string'
        }
        readonly k: 'hello'
      }
    }
  }
}

Minha pergunta específica é por que isso funciona em X['b'], que é do tipo string? T[P] extends Function deveria ser falso pelo que eu entendo?