diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,31 @@
+The Glasgow Haskell Compiler License
+
+Copyright 2004, The University Court of the University of Glasgow. 
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+ 
+- Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+ 
+- Neither name of the University nor the names of its contributors may be
+used to endorse or promote products derived from this software without
+specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
+GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,6 @@
+#!/usr/bin/env runhaskell
+
+-- I usually compile this with "ghc --make -o setup Setup.hs"
+
+import Distribution.Simple(defaultMain)
+main = defaultMain
diff --git a/Text/Regex/Base.hs b/Text/Regex/Base.hs
new file mode 100644
--- /dev/null
+++ b/Text/Regex/Base.hs
@@ -0,0 +1,51 @@
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+-----------------------------------------------------------------------------
+-- |
+--
+-- Module      :  Text.Regex.Base
+-- Copyright   :  (c) Chris Kuklewicz 2006
+-- License     :  BSD-style (see the file LICENSE)
+-- 
+-- Maintainer  :  libraries@haskell.org, textregexlazy@personal.mightyreason.com
+-- Stability   :  experimental
+-- Portability :  non-portable (MPTC+FD)
+--
+-- Classes and instances for Regex matching.
+--
+-- 
+-- This module merely imports and re-exports the common part of the new
+-- api: "Text.Regex.Base.RegexLike" and "Text.Regex.Base.Context".
+-- 
+-- To see what result types the instances of RegexContext can produce,
+-- please read the "Text.Regex.Base.Context" haddock documentation.
+-- 
+-- This does not provide any of the backends, just the common interface
+-- they all use.  The modules which provide the backends and their cabal
+-- packages are:
+-- 
+--  * @Text.Regex.Posix@ from regex-posix
+-- 
+--  * @Text.Regex@ from regex-compat (uses regex-posix)
+-- 
+--  * @Text.Regex.Parsec@ from regex-parsec
+-- 
+--  * @Text.Regex.DFA@ from regex-dfa
+-- 
+--  * @Text.Regex.PCRE@ from regex-pcre
+-- 
+--  * @Test.Regex.TRE@ from regex-tre
+-- 
+-- In fact, just importing one of the backends is adequate, you do not
+-- also need to import this module.
+-- 
+-- TODO: Copy Example*hs files into this haddock comment
+-----------------------------------------------------------------------------
+
+module Text.Regex.Base (
+  -- | RegexLike defines classes and type, and 'Extract' instances
+  module Text.Regex.Base.RegexLike
+  -- | Context only exports instances for 'RegexContext'
+  ,module Text.Regex.Base.Context) where
+
+import Text.Regex.Base.RegexLike
+import Text.Regex.Base.Context
diff --git a/Text/Regex/Base/Context.hs b/Text/Regex/Base/Context.hs
new file mode 100644
--- /dev/null
+++ b/Text/Regex/Base/Context.hs
@@ -0,0 +1,245 @@
+{-# OPTIONS_GHC -fglasgow-exts #-}
+{-|
+
+Module      :  Text.Regex.Base.Context
+Copyright   :  (c) Chris Kuklewicz 2006
+License     :  BSD-style (see the file LICENSE)
+
+Maintainer  :  libraries@haskell.org, textregexlazy@personal.mightyreason.com
+Stability   :  experimental
+Portability :  non-portable (MPTC+FD)
+
+This is a module of instances of 'RegexContext'.  Nothing else is
+exported.   These work for all the front ends and backends
+interchangably.  These instances are important because they provide
+the different results that can be gotten from a match or matchM
+operation (often via the @=~@ and @=~~@ operators).  The name is Context
+because they are context dependent: use them in a context that expects
+an Int and you get a count of matches, use them in a Bool context and
+get True if there is a match, etc.
+
+@ 
+type MatchArray = Array Int (MatchOffset, MatchLength)
+type MatchText source = Array Int (source, (MatchOffset, MatchLength))
+@
+
+These are for the first match:
+
+(@ RegexLike a b => RegexContext a b Bool @) :
+  Whether there is any match or not
+
+(@ RegexLike a b => RegexContext a b () @) :
+  Useful using @=~~@ in a monad, since failure to match is via 'fail'
+
+(@ RegexLike a b => RegexContext a b (MatchOffset,MatchLength) @) :
+  This returns the initial index and length of the whole match.
+  Starting at (-1) indicates failure to match.
+
+(@ RegexLike a b => RegexContext a b b @) :
+  This returns the text of the whole match.
+  It will return 'empty' from 'Extract' if there is no match.
+  These are defined in other modules, but documented here for convenience.
+
+(@ RegexLike a b => RegexContext a b MatchArray @) :
+  Where each sub-part the match starts and its length.
+  Starting at (-1) indicates unused.
+
+(@ RegexLike a b => RegexContext a b (Array Int b) @) :
+  The text of each sub-part of the match.
+  Unused matches are 'empty' (defined via 'Extract')
+
+(@ RegexLike a b => RegexContext a b (b, MatchText b, b) @) :
+  The text before the match, the details of the match, and the text after the match
+
+(@ RegexLike a b => RegexContext a b (b, b, b) @) :
+  The text before the match, the text of the match, the text after the match
+
+(@ RegexLike a b => RegexContext a b (b, b, b, [b]) @) :
+  The text before the match, the text of the match, the text after the match, and the text of the 1st and higher sub-parts of the match.  This is the same return value as used in Text.Regex.
+
+(@ RegexLike a b => RegexContext a b (MatchResult b) @) :
+  The 'MatchResult' structure for the match.
+
+These instances are for all the matches (non-overlapping):
+
+(@ RegexLike a b => RegexContext a b Int @) :
+  The number of matches
+
+These instances similar to the single match ones above, but in a List:
+
+(@ RegexLike a b => RegexContext a b [(MatchOffset, MatchLength)] @) :
+
+(@ RegexLike a b => RegexContext a b [b] @) :
+  As a policy, I chose [b] to be the list of whole text of each match.
+
+(@ RegexLike a b => RegexContext a b [MatchArray] @) :
+
+(@ RegexLike a b => RegexContext a b [Array Int b] @) :
+
+(@ RegexLike a b => RegexContext a b [MatchText b] @) :
+
+(@ RegexLike a b => RegexContext a b [[b]] @) :
+  This is the list of the list of the text of the sub-part of each match.
+  Unused matches are 'empty' (defined via 'Extract')
+
+-}
+
+module Text.Regex.Base.Context() where
+
+import Data.Array(Array,(!),elems,listArray)
+import Data.Maybe(maybe)
+import Text.Regex.Base.RegexLike(RegexLike(..),RegexContext(..)
+  ,MatchResult(..),Extract(empty),MatchOffset,MatchLength,MatchArray,MatchText)
+
+{-
+-- Get the ByteString type for mood/doom
+import Data.ByteString(ByteString)
+-- Get the Regex types for the mood/doom workaround
+import qualified Text.Regex.Lib.WrapPosix as R1(Regex)
+import qualified Text.Regex.Lib.WrapPCRE as R2(Regex)
+import qualified Text.Regex.Lib.WrapLazy as R3(Regex)
+import qualified Text.Regex.Lib.WrapDFAEngine as R4(Regex)
+-- Get the RegexLike instances
+import Text.Regex.Lib.StringPosix()
+import Text.Regex.Lib.StringPCRE()
+import Text.Regex.Lib.StringLazy()
+import Text.Regex.Lib.StringDFAEngine()
+import Text.Regex.Lib.ByteStringPosix()
+import Text.Regex.Lib.ByteStringPCRE()
+import Text.Regex.Lib.ByteStringLazy()
+import Text.Regex.Lib.ByteStringDFAEngine()
+-}
+{-
+
+mood :: (RegexLike a b) => a -> b -> b
+{-# INLINE mood #-}
+mood r s = case matchOnceText r s of
+    Nothing -> empty
+    Just (_,ma,_) -> fst (ma!0)
+
+doom :: (RegexLike a b,Monad m) => a -> b -> m b
+{-# INLINE doom #-}
+doom =  actOn (\(_,ma,_)->fst (ma!0))
+
+{- These run afoul of various restrictions if I say
+   "instance RegexContext a b b where"
+   so I am listing these cases explicitly
+-}
+
+instance RegexContext R1.Regex String String where match = mood; matchM = doom
+instance RegexContext R2.Regex String String where match = mood; matchM = doom
+instance RegexContext R3.Regex String String where match = mood; matchM = doom
+instance RegexContext R4.Regex String String where match = mood; matchM = doom
+instance RegexContext R1.Regex ByteString ByteString where match = mood; matchM = doom
+instance RegexContext R2.Regex ByteString ByteString where match = mood; matchM = doom
+instance RegexContext R3.Regex ByteString ByteString where match = mood; matchM = doom
+instance RegexContext R4.Regex ByteString ByteString where match = mood; matchM = doom
+-}
+
+
+nullArray :: Array Int a
+{-# INLINE nullArray #-}
+nullArray = listArray (1,0) []
+
+nullFail :: (RegexContext regex source [target],Monad m) => regex -> source -> m [target]
+{-# INLINE nullFail #-}
+nullFail r s = case match r s of
+                 [] -> regexFailed
+                 xs -> return xs
+
+regexFailed :: (Monad m) => m b
+{-# INLINE regexFailed #-}
+regexFailed =  fail $ "regex failed to match"
+
+actOn :: (RegexLike r s,Monad m) => ((s,MatchText s,s)->t) -> r -> s -> m t
+{-# INLINE actOn #-}
+actOn f r s = case matchOnceText r s of
+    Nothing -> regexFailed
+    Just preMApost -> return (f preMApost)
+
+-- ** Instances based on matchTest ()
+
+instance (RegexLike a b) => RegexContext a b Bool where 
+  match = matchTest
+  matchM r s = case match r s of
+                 False -> regexFailed
+                 True -> return True
+
+instance (RegexLike a b) => RegexContext a b () where
+  match _ _ = ()
+  matchM r s = case matchTest r s of
+                 False -> regexFailed
+                 True -> return ()
+
+-- ** Instance based on matchCount
+
+instance (RegexLike a b) => RegexContext a b Int where
+  match = matchCount
+  matchM r s = case match r s of
+                 0 -> regexFailed
+                 x -> return x
+
+-- ** Instances based on matchOnce,matchOnceText
+
+instance (RegexLike a b) => RegexContext a b (MatchOffset,MatchLength) where 
+  match r s = maybe (-1,0) (!0) (matchOnce r s)
+  matchM r s = maybe regexFailed (return.(!0)) (matchOnce r s)
+
+instance (RegexLike a b) => RegexContext a b MatchArray where 
+  match r s = maybe nullArray id (matchOnce r s)
+  matchM r s = maybe regexFailed return (matchOnce r s)
+
+instance (RegexLike a b) => RegexContext a b (b,MatchText b,b) where 
+  match r s = maybe (s,nullArray,empty) id (matchOnceText r s)
+  matchM r s = maybe regexFailed return (matchOnceText r s)
+
+instance (RegexLike a b) => RegexContext a b (Array Int b) where 
+  match r s = maybe nullArray id (matchM r s)
+  matchM = actOn (\(_,ma,_) -> fmap fst ma)
+
+instance (RegexLike a b) => RegexContext a b (b,b,b) where 
+  match r s = maybe (s,empty,empty) id (matchM r s)
+  matchM = actOn (\(pre,ma,post) -> let ((whole,_):_) = elems ma
+                                    in (pre,whole,post))
+
+instance (RegexLike a b) => RegexContext a b (b,b,b,[b]) where 
+  match r s = maybe (s,empty,empty,[]) id (matchM r s)
+  matchM = actOn (\(pre,ma,post) -> let ((whole,_):subs) = elems ma
+                                    in (pre,whole,post,map fst subs))
+
+instance (RegexLike a b) => RegexContext a b (MatchResult b) where 
+  match r s = maybe (MR {mrBefore = s,mrMatch = empty,mrAfter = empty
+                        ,mrSubs = nullArray,mrSubList = []}) id (matchM r s)
+  matchM = actOn (\(pre,ma,post) -> 
+     let ((whole,_):subs) = elems ma
+     in MR { mrBefore = pre
+           , mrMatch = whole
+           , mrAfter = post
+           , mrSubs = fmap fst ma
+           , mrSubList = tail (map fst subs) })
+
+-- ** Instances based on matchAll,matchAllText
+
+instance (RegexLike a b) => RegexContext a b [MatchArray] where
+  match = matchAll
+  matchM = nullFail
+
+instance (RegexLike a b) => RegexContext a b [MatchText b] where
+  match = matchAllText
+  matchM = nullFail
+           
+instance (RegexLike a b) => RegexContext a b [(MatchOffset,MatchLength)] where
+  match r s = [ ma!0 | ma <- matchAll r s ]
+  matchM = nullFail
+
+instance (RegexLike a b) => RegexContext a b [b] where
+  match r s = [ fst (ma!0) | ma <- matchAllText r s ]
+  matchM = nullFail
+
+instance (RegexLike a b) => RegexContext a b [Array Int b] where
+  match r s = [ fmap fst ma | ma <- matchAllText r s ]
+  matchM = nullFail
+
+instance (RegexLike a b) => RegexContext a b [[b]] where
+  match r s = [ map fst (elems ma) | ma <- matchAllText r s ]
+  matchM = nullFail
diff --git a/Text/Regex/Base/Impl.hs b/Text/Regex/Base/Impl.hs
new file mode 100644
--- /dev/null
+++ b/Text/Regex/Base/Impl.hs
@@ -0,0 +1,58 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Text.Regex.Impl
+-- Copyright   :  (c) Chris Kuklewicz 2006
+-- License     :  BSD-style (see the file LICENSE)
+-- 
+-- Maintainer  :  libraries@haskell.org, textregexlazy@personal.mightyreason.com
+-- Stability   :  experimental
+-- Portability :  non-portable (Text.Regex.Base needs MPTC+FD)
+-- 
+-- Helper functions for defining certain instances of
+-- RegexContext. These help when defining instances of RegexContext
+-- with repeated types:
+-- 
+-- @
+-- instance (RegexLike regex source) => RegexContext regex source source where
+-- @
+-- 
+-- runs into overlapping restrictions. To avoid this I have each backend
+-- define, for its own Regex type:
+-- 
+-- @
+-- instance RegexContext Regex String String where
+--   match = polymatch
+--   matchM = polymatchM
+-- @
+-- 
+-- @
+-- instance RegexContext Regex ByteString ByteString where
+--   match = polymatch
+--   matchM = polymatchM
+-- @
+-------------------------------------------------------------------------------
+
+module Text.Regex.Base.Impl(polymatch,polymatchM) where
+
+import Text.Regex.Base
+import Data.Array((!))
+
+regexFailed :: (Monad m) => m b
+{-# INLINE regexFailed #-}
+regexFailed =  fail $ "regex failed to match"
+
+actOn :: (RegexLike r s,Monad m) => ((s,MatchText s,s)->t) -> r -> s -> m t
+{-# INLINE actOn #-}
+actOn f r s = case matchOnceText r s of
+    Nothing -> regexFailed
+    Just preMApost -> return (f preMApost)
+
+polymatch :: (RegexLike a b) => a -> b -> b
+{-# INLINE polymatch #-}
+polymatch r s = case matchOnceText r s of
+    Nothing -> empty
+    Just (_,ma,_) -> fst (ma!0)
+
+polymatchM :: (RegexLike a b,Monad m) => a -> b -> m b
+{-# INLINE polymatchM #-}
+polymatchM =  actOn (\(_,ma,_)->fst (ma!0))
diff --git a/Text/Regex/Base/RegexLike.hs b/Text/Regex/Base/RegexLike.hs
new file mode 100644
--- /dev/null
+++ b/Text/Regex/Base/RegexLike.hs
@@ -0,0 +1,158 @@
+{-# OPTIONS_GHC -fglasgow-exts #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Text.Regex.Base.RegexLike
+-- Copyright   :  (c) Chris Kuklewicz 2006
+-- License     :  BSD-style (see the file LICENSE)
+-- 
+-- Maintainer  :  libraries@haskell.org, textregexlazy@personal.mightyreason.com
+-- Stability   :  experimental
+-- Portability :  non-portable (MPTC+FD)
+--
+-- Classes and instances for Regex matching.
+--
+-- 
+-- All the classes are declared here, and some common type aliases, and
+-- the MatchResult data type.
+-- 
+-- The only instances here are for Extract String and Extract ByteString.
+-- There are no data values.  The 'RegexContext' instances are in
+-- "Text.Regex.Base.Context", except for ones which run afoul of a
+-- repeated variable (RegexContext regex a a), which are defined in each
+-- modules' String and ByteString modules.
+-----------------------------------------------------------------------------
+
+module Text.Regex.Base.RegexLike (
+  -- ** Type aliases
+  MatchOffset,
+  MatchLength,
+  MatchArray,
+  MatchText,
+  -- ** Data types
+  MatchResult(..),
+  -- ** Classes
+  RegexOptions(..),
+  RegexMaker(..),
+  RegexLike(..),
+  RegexContext(..),
+  Extract(..),
+  ) where
+
+import Data.Array(Array,(!))
+import Data.Maybe(isJust)
+import Data.ByteString(ByteString)
+import qualified Data.ByteString as B (take,drop,empty)
+
+-- | 0 based index from start of source, or (-1) for unused
+type MatchOffset = Int
+-- | non-negative length of a match
+type MatchLength = Int
+-- | 0 based array, with 0th index indicating the full match.  If the
+-- full match location is not available, represent as (0,0).
+type MatchArray = Array Int (MatchOffset,MatchLength)
+type MatchText source = Array Int (source,(MatchOffset,MatchLength))
+
+
+-- | This is the same as the type from JRegex.
+data MatchResult a = MR {
+    mrBefore :: a,
+    mrMatch  :: a,
+    mrAfter  :: a,
+    mrSubList :: [a],
+    mrSubs   :: Array Int a
+}
+
+----------------
+-- | Rather than carry them around spearately, the options for how to
+-- execute a regex are kept as part of the regex.  There are two types
+-- of options.  Those that can only be specified at compilation time
+-- and never changed are CompOpt.  Those that can be changed later and
+-- affect how matching is performed are ExecOpt.  The actually types
+-- for these depend on the backend.
+class RegexOptions regex compOpt execOpt 
+  | regex->compOpt execOpt, compOpt->regex execOpt, execOpt->regex compOpt where
+  blankCompOpt :: compOpt    -- ^ no options set at all in the backend
+  blankExecOpt :: execOpt    -- ^ no options set at all in the backend
+  defaultCompOpt :: compOpt  -- ^ reasonable options (extended,caseSensitive,multiline regex)
+  defaultExecOpt :: execOpt  -- ^ reasonable options (extended,caseSensitive,multiline regex)
+  setExecOpts :: execOpt -> regex -> regex
+  -- ^ forget old flags and use new ones
+  getExecOpts :: regex -> execOpt
+  -- ^ retrieve the current flags
+
+----------------
+-- | RegexMaker captures the creation of the compiled regular
+-- expression from a source type and an option type.  The 'makeRegex'
+-- function has a default implementation that depends on makeRegexOpts
+-- and used 'defaultCompOpt' and 'defaultExecOpt'.
+class (RegexOptions regex compOpt execOpt) => RegexMaker regex compOpt execOpt source 
+  | regex -> compOpt execOpt, compOpt -> regex execOpt, execOpt -> regex compOpt where
+  -- | make using the defaultCompOpt and defaultExecOpt
+  makeRegex :: source -> regex
+  -- | Specify your own options
+  makeRegexOpts :: compOpt -> execOpt -> source -> regex
+
+  makeRegex = makeRegexOpts defaultCompOpt defaultExecOpt
+
+----------------
+-- | RegexLike is parametrized on a regular expression type and a
+-- source type to run the matching on.
+--
+-- There are default implementations: matchTest and matchOnceText
+-- using matchOnce; matchCount and matchAllText using
+-- matchAll. matchOnce uses matchOnceText and matchAll uses
+-- matchAllText. So a minimal complete instance need to provide
+-- (matchOnce or matchOnceText) and (matchAll or matchAllText).
+class (Extract source)=> RegexLike regex source where
+  matchAll   :: regex -> source-> [MatchArray]
+  -- | This can return an array of (offset,length) index pairs for the
+  -- match and captured substrings.
+  matchOnce  :: regex -> source-> Maybe MatchArray
+  matchCount :: regex -> source-> Int
+  matchTest  :: regex -> source-> Bool
+  matchAllText  :: regex -> source-> [MatchText source]
+  -- | This can return a tuple of three items: the source before the
+  -- match, an array of the match and captured substrings (with their
+  -- indices), and the source after the match.
+  matchOnceText :: regex -> source-> Maybe (source,MatchText source,source)
+
+  matchAll regex source = map (fmap snd) (matchAllText regex source)
+  matchOnce regex source = fmap (\(_,mt,_) -> fmap snd mt) (matchOnceText regex source)
+  matchTest regex source = isJust (matchOnce regex source)
+  matchCount regex source = length (matchAll regex source)
+  matchOnceText regex source = 
+    fmap (\ma -> let (o,l) = ma!0
+                 in (before o source
+                    ,fmap (\ol -> (extract ol source,ol)) ma
+                    ,after (o+l) source))
+         (matchOnce regex source)
+  matchAllText regex source =
+    map (fmap (\ol -> (extract ol source,ol)))
+        (matchAll regex source)
+
+----------------
+-- | RegexContext is the polymorphic interface to do matching
+class (RegexLike regex source) => RegexContext regex source target where
+  match :: regex -> source -> target
+  matchM :: (Monad m) => regex -> source -> m target
+
+----------------
+-- | Extract allows for indexing operations on String or ByteString.
+class Extract source where
+  -- | before is a renamed "take"
+  before :: Int -> source -> source
+  -- | after is a renamed "drop"
+  after :: Int -> source -> source
+  -- | For when there is no match, this can construct an empty data value
+  empty :: source
+  -- | extract takes an offset and length and has a default
+  -- implementation of @extract (off,len) source = before len (after
+  -- off source)@
+  extract :: (Int,Int) -> source -> source
+  extract (off,len) source = before len (after off source)
+
+instance Extract String where
+  before =  take; after = drop; empty = []
+
+instance Extract ByteString where
+  before = B.take; after = B.drop; empty = B.empty
diff --git a/regex-base.cabal b/regex-base.cabal
new file mode 100644
--- /dev/null
+++ b/regex-base.cabal
@@ -0,0 +1,45 @@
+-- ****************************************************************
+-- To fix for cabal < 1.1.4 comment out the Extra-Source-Files line
+-- ****************************************************************
+Name:                   regex-base
+Version:                0.71
+-- Cabal-Version:       >=1.1.4
+License:                BSD3
+License-File:           LICENSE
+Copyright:              Copyright (c) 2006, Christopher Kuklewicz
+Author:                 Christopher Kuklewicz
+Maintainer:             TextRegexLazy@personal.mightyreason.com
+Stability:              Seems to work, passes a few tests
+Homepage:               http://sourceforge.net/projects/lazy-regex
+-- Package-URL:
+Synopsis:               Replaces/Enhances Text.Regex
+Description:            Interface API for regex-posix,pcre,parsec,dfa
+Category:               Text
+Tested-With:            GHC
+Build-Depends:          base >= 2.0
+-- Data-Files:
+-- Extra-Source-Files:     Text/Regex/Lazy/TestCompat.hs, Text/Regex/Lazy/TestFull.hs, Text/Regex/Impl/TestContext.hs, TestTextRegexLazy.hs, Example.hs, Example2.hs, lazy.html, README, Makefile
+-- Extra-Tmp-Files:
+Exposed-Modules:        Text.Regex.Base
+                        Text.Regex.Base.RegexLike
+                        Text.Regex.Base.Context
+                        Text.Regex.Base.Impl
+Buildable:              True
+-- Other-Modules:
+-- ********* Be backward compatible until 6.4.2 is futher deployed
+-- HS-Source-Dirs:         "."
+Extensions:             MultiParamTypeClasses, FunctionalDependencies
+-- GHC-Options:            -Wall -Werror
+GHC-Options:            -Wall -Werror -O2
+-- GHC-Options:            -Wall -ddump-minimal-imports
+-- GHC-Prog-Options: 
+-- Hugs-Options:
+-- NHC-Options:
+-- Includes:
+-- Include-Dirs:
+-- C-Sources:
+-- Extra-Libraries:
+-- Extra-Lib-Dirs:
+-- CC-Options:
+-- LD-Options:
+-- Frameworks: