diff --git a/hxt-regex-xmlschema.cabal b/hxt-regex-xmlschema.cabal
--- a/hxt-regex-xmlschema.cabal
+++ b/hxt-regex-xmlschema.cabal
@@ -1,5 +1,5 @@
 Name:                hxt-regex-xmlschema
-Version:             9.0.1
+Version:             9.0.4
 Synopsis:            A regular expression library for W3C XML Schema regular expressions
 Description:         This library supports full W3C XML Schema regular expressions
                      inclusive all Unicode character sets and blocks.
@@ -47,6 +47,5 @@
   ghc-prof-options: -auto-all -caf-all
 
   build-depends:     base               >= 4   && < 5,
-                     haskell98          >= 1   && < 2,
                      parsec             >= 2.1 && < 4,
                      hxt-charproperties >= 9   && < 10
diff --git a/src/Text/Regex/Glob/String.hs b/src/Text/Regex/Glob/String.hs
--- a/src/Text/Regex/Glob/String.hs
+++ b/src/Text/Regex/Glob/String.hs
@@ -17,7 +17,9 @@
 module Text.Regex.Glob.String
     ( Regex
     , match
+    , matchNoCase
     , parseRegex
+    , parseRegexNoCase
     )
 where
 
@@ -28,5 +30,8 @@
 
 match           :: String -> String -> Bool
 match           = matchWithRegex . parseRegex
+
+matchNoCase     :: String -> String -> Bool
+matchNoCase     = matchWithRegex . parseRegexNoCase
 
 -- ------------------------------------------------------------
diff --git a/src/Text/Regex/Glob/String/RegexParser.hs b/src/Text/Regex/Glob/String/RegexParser.hs
--- a/src/Text/Regex/Glob/String/RegexParser.hs
+++ b/src/Text/Regex/Glob/String/RegexParser.hs
@@ -16,9 +16,16 @@
 
 module Text.Regex.Glob.String.RegexParser
     ( parseRegex
+    , parseRegexNoCase
     )
 where
 
+import Data.Char                         ( isLower
+                                         , isUpper
+                                         , toLower
+                                         , toUpper
+                                         )
+
 import Text.ParserCombinators.Parsec
 
 import Text.Regex.XMLSchema.String.Regex
@@ -30,50 +37,77 @@
 
 parseRegex :: String -> Regex
 parseRegex
+    = parseRegex' mkSymRng
+
+parseRegexNoCase :: String -> Regex
+parseRegexNoCase
+    = parseRegex' mkNoCaseSymRng
+
+parseRegex' :: (Char -> Char -> Regex) -> String -> Regex
+parseRegex' mkS
     = either (mkZero . ("syntax error: " ++) . show) id
       .
       parse ( do
-              r <- pattern
+              r <- pattern mkS
               eof
               return r
             ) ""
 
 -- ------------------------------------------------------------
 
-pattern  :: Parser Regex
-pattern
+pattern  :: (Char -> Char -> Regex) -> Parser Regex
+pattern mkS
     = many part >>= return . mkSeqs
+    where
+      part :: Parser Regex
+      part
+          = ( many1 (noneOf "\\?*[{") >>= return . mkWord' )
+            <|>
+            ( char '?' >> return mkDot )
+            <|>
+            ( char '*' >> return mkAll )
+            <|>
+            ( between (char '{') (char '}') wordList )
+            <|>
+            ( between (char '[') (char ']') charSet )
+            <|>
+            ( do c <- char '\\' >> anyChar
+                 return $ mkS c c
+            )
+      mkWord'
+          = mkSeqs . map (\ c -> mkS c c)
 
-part :: Parser Regex
-part
-    = ( many1 (noneOf "\\?*[{") >>= return . mkWord )
-      <|>
-      ( char '?' >> return mkDot )
-      <|>
-      ( char '*' >> return mkAll )
-      <|>
-      ( between (char '{') (char '}') wordList )
-      <|>
-      ( between (char '[') (char ']') charSet )
-      <|>
-      ( char '\\' >> anyChar >>= return . mkSym1 )
+      wordList :: Parser Regex
+      wordList
+          = sepBy (many1 (noneOf ",}")) (char ',') >>= return . foldr mkAlt (mkZero "") . map mkWord'
 
-wordList :: Parser Regex
-wordList
-    = sepBy (many1 (noneOf ",}")) (char ',') >>= return . foldr mkAlt (mkZero "") . map mkWord
+      charSet :: Parser Regex
+      charSet
+          = ( do p1 <- charSet' anyChar
+                 ps <- many $ charSet' (noneOf "]")
+                 return $ foldr mkAlt (mkZero "") (p1 : ps)
+            )
+          where
+            charSet' cp
+                = do c1 <- cp
+                     c2 <- rest c1
+                     return $ mkS c1 c2
+            rest c1
+                = option c1 (char '-' >> anyChar)
 
-charSet :: Parser Regex
-charSet
-    = ( do p1 <- charSet' anyChar
-           ps <- many $ charSet' (noneOf "]")
-           return $ foldr mkAlt (mkZero "") (p1 : ps)
-      )
-    where
-      charSet' cp
-          = do c1 <- cp
-               c2 <- rest c1
-               return $ mkSymRng c1 c2
-      rest c1
-          = option c1 (char '-' >> anyChar)
+-- ------------------------------------------------------------
+
+mkNoCaseSymRng :: Char -> Char -> Regex
+mkNoCaseSymRng c1 c2
+    | isLower c1
+      &&
+      isLower c2
+          = mkAlt (mkSymRng (toUpper c1) (toUpper c2)) (mkSymRng c1 c2)
+    | isUpper c1
+      &&
+      isUpper c2
+          = mkAlt (mkSymRng (toLower c1) (toLower c2)) (mkSymRng c1 c2)
+    | otherwise
+        = mkSymRng c1 c2
 
 -- ------------------------------------------------------------