packages feed

jsaddle 0.4.0.5 → 0.9.9.4

raw patch · 56 files changed

Files

jsaddle.cabal view
@@ -1,82 +1,131 @@ name: jsaddle-version: 0.4.0.5+version: 0.9.9.4 cabal-version: >=1.10 build-type: Simple license: MIT license-file: LICENSE maintainer: Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com>-synopsis: High level interface for webkit-javascriptcore+synopsis: Interface for JavaScript that works with GHCJS and GHC description:-    This package provides an EDSL for calling JavaScript code using-    the JavaScriptCore engine and low level Haskell bindings-    in the webkit-javascriptcore library <https://github.com/ghcjs/webkit-javascriptcore>.+    This package provides an EDSL for calling JavaScript that+    can be used both from GHCJS and GHC.  When using GHC+    the application is run using Warp and WebSockets to+    drive a small JavaScript helper. category: Web, Javascript author: Hamish Mackenzie+tested-with: GHC==9.12.2, GHC==9.10.1, GHC==9.8.4, GHC==9.6.7, GHC==9.4.8, GHC==9.2.8, GHC==9.0.2, GHC==8.10.7, GHC==8.8.4, GHC==8.6.5, GHC==8.4.4  source-repository head     type: git     location: https://github.com/ghcjs/jsaddle+    subdir: jsaddle +flag call-stacks+  description: Include HasCallStack constraint on calls unchecked calls+  default: False++flag check-unchecked+  description: Fail unchecked calls when they are called (rather than when the result is evaluated)+  default: False+ library -    if impl(ghcjs -any)+    if impl(ghcjs -any) || arch(javascript)         build-depends:-            ghcjs-base -any,-            ghcjs-prim -any+            ghcjs-base -any+        -- GHC includes GHC.JS.Prim in base+        if impl(ghcjs -any)+            build-depends:+                ghcjs-prim -any     else         build-depends:-            haskell-gi-base >= 0.17 && < 0.19,-            gi-glib >=2.0.2 && <2.1,-            gi-gtk >=3.0.2 && <3.1,-            gi-webkit >=3.0.2 && <3.1,-            gi-javascriptcore >=3.0.2 && <3.1,-            webkitgtk3-javascriptcore >=0.14.0.0 && <0.15+            attoparsec >=0.11 && <0.15,+            containers >=0.5.6.2 && <0.9,+            deepseq >=1.3 && < 1.6,+            filepath >=1.4.0.0 && <1.6,+            ghc-prim,+            http-types >=0.8.6 && <0.13,+            process >=1.2.3.0 && <1.7,+            random >= 1.1 && < 1.4,+            ref-tf >=0.4.0.1 && <0.6,+            scientific >=0.3 && <0.4,+            stm >=2.4.4 && <2.6,+            time >=1.5.0.1 && <1.16,+            unordered-containers >=0.2 && <0.3,+            vector >=0.10 && <0.14,+            unliftio-core >=0.1 && < 0.3         exposed-modules:-            Language.Javascript.JSaddle.Test+            Data.JSString+            Data.JSString.Internal+            Data.JSString.Internal.Fusion+            Data.JSString.Internal.Fusion.CaseMapping+            Data.JSString.Internal.Fusion.Common+            Data.JSString.Internal.Fusion.Types+            Data.JSString.Internal.Search+            Data.JSString.Internal.Type+            Data.JSString.Text+            GHCJS.Prim+            GHCJS.Prim.Internal+            GHCJS.Types+            GHCJS.Concurrent+            GHCJS.Foreign+            GHCJS.Foreign.Internal+            GHCJS.Internal.Types+            GHCJS.Marshal+            GHCJS.Marshal.Internal+            GHCJS.Marshal.Pure+            GHCJS.Buffer+            GHCJS.Buffer.Types+            JavaScript.TypedArray+            JavaScript.TypedArray.ArrayBuffer+            JavaScript.TypedArray.ArrayBuffer.Internal+            JavaScript.TypedArray.ArrayBuffer.Type+            JavaScript.TypedArray.DataView.Internal+            JavaScript.TypedArray.Immutable+            JavaScript.TypedArray.Internal+            JavaScript.TypedArray.Internal.Types+            JavaScript.Array+            JavaScript.Array.Internal+            JavaScript.Object+            JavaScript.Object.Internal+            Language.Javascript.JSaddle.Debug+            Language.Javascript.JSaddle.Native+            Language.Javascript.JSaddle.Native.Internal+            Language.Javascript.JSaddle.Null+        hs-source-dirs: src-ghc     exposed-modules:         Language.Javascript.JSaddle         Language.Javascript.JSaddle.Arguments         Language.Javascript.JSaddle.Classes+        Language.Javascript.JSaddle.Classes.Internal         Language.Javascript.JSaddle.Evaluate         Language.Javascript.JSaddle.Exception+        Language.Javascript.JSaddle.Helper+        Language.Javascript.JSaddle.Marshal.String         Language.Javascript.JSaddle.Monad-        Language.Javascript.JSaddle.Native         Language.Javascript.JSaddle.Object         Language.Javascript.JSaddle.Properties+        Language.Javascript.JSaddle.Run+        Language.Javascript.JSaddle.Run.Files         Language.Javascript.JSaddle.String         Language.Javascript.JSaddle.Value         Language.Javascript.JSaddle.Types     build-depends:-        template-haskell -any,-        base <5,-        lens >=3.8.5 && <4.15,-        text >=0.11.2.3 && <1.3,-        transformers >=0.3.0.0 && <0.6+        aeson >=0.11.3.0 && <2.3,+        base >=4.9 && <5,+        base-compat >=0.9.0 && <0.16,+        base64-bytestring >=1.0.0.1 && <1.3,+        bytestring >=0.10.6.0 && <0.13,+        exceptions >=0.8 && <0.11,+        kan-extensions >= 5 && < 6,+        lens >=3.8.5 && <5.4,+        primitive >=0.6.1.0 && <0.10,+        text >=1.2.1.3 && <1.3 || >= 2.0 && < 2.2,+        transformers >=0.4.2.0 && <0.7     default-language: Haskell2010     hs-source-dirs: src-    ghc-options: -ferror-spans--test-suite test-tool--    if impl(ghcjs -any)-        buildable: False-    else-        build-depends:-            haskell-gi-base >= 0.17 && < 0.19,-            gi-glib >=2.0.2 && <2.1,-            gi-gtk >=3.0.2 && <3.1,-            gi-webkit >=3.0.2 && <3.1,-            gi-javascriptcore >=3.0.2 && <3.1,-            webkitgtk3-javascriptcore >=0.14.0.0 && <0.15-    type: exitcode-stdio-1.0-    main-is: DocTest.hs-    build-depends:-        QuickCheck -any,-        base -any,-        doctest -any,-        vector >=0.11.0.0 && <0.12,-        text >=0.11.2.3 && <1.3,-        jsaddle -any-    default-language: Haskell2010-    hs-source-dirs: tests-    ghc-options: -ferror-spans+    ghc-options: -ferror-spans -Wall+    if flag(check-unchecked)+        cpp-options: -DCHECK_UNCHECKED+    if flag(call-stacks) || flag(check-unchecked)+        cpp-options: -DJSADDLE_HAS_CALL_STACK
+ src-ghc/Data/JSString.hs view
@@ -0,0 +1,1404 @@+{-# LANGUAGE MagicHash, BangPatterns, UnboxedTuples, TypeFamilies+  #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-| Manipulation of JavaScript strings, API and fusion implementation+    based on Data.Text by Tom Harper, Duncan Coutts, Bryan O'Sullivan e.a.+ -}+module Data.JSString ( JSString++                       -- * Creation and elimination+                     , pack+                     , unpack, unpack'+                     , singleton+                     , empty++                       -- * Basic interface+                     , cons+                     , snoc+                     , append+                     , uncons+                     , head+                     , last+                     , tail+                     , init+                     , null+                     , length+                     , compareLength++                       -- * Transformations+                     , map+                     , intercalate+                     , intersperse+                     , transpose+                     , reverse+                     , replace++                       -- ** Case conversion+                     , toCaseFold+                     , toLower+                     , toUpper+                     , toTitle++                       -- ** Justification+                     , justifyLeft+                     , justifyRight+                     , center++                       -- * Folds+                     , foldl+                     , foldl'+                     , foldl1+                     , foldl1'+                     , foldr+                     , foldr1++                       -- ** Special folds+                     , concat+                     , concatMap+                     , any+                     , all+                     , maximum+                     , minimum++                       -- * Construction++                       -- ** Scans+                     , scanl+                     , scanl1+                     , scanr+                     , scanr1++                       -- ** Accumulating maps+                     , mapAccumL+                     , mapAccumR++                       -- ** Generation and unfolding+                     , replicate+                     , unfoldr+                     , unfoldrN++                       -- * Substrings++                       -- ** Breaking strings+                     , take+                     , takeEnd+                     , drop+                     , dropEnd+                     , takeWhile+                     , dropWhile+                     , dropWhileEnd+                     , dropAround+                     , strip+                     , stripStart+                     , stripEnd+                     , splitAt+                     , breakOn+                     , breakOnEnd+                     , break+                     , span+                     , group+                     , group'+                     , groupBy+                     , inits+                     , tails++                       -- ** Breaking into many substrings+                     , splitOn, splitOn'+                     , split+                     , chunksOf, chunksOf'++                       -- ** Breaking into lines and words+                     , lines, lines'+                     , words, words'+                     , unlines+                     , unwords++                       -- * Predicates+                     , isPrefixOf+                     , isSuffixOf+                     , isInfixOf++                       -- ** View patterns+                     , stripPrefix+                     , stripSuffix+                     , commonPrefixes++                       -- * Searching+                     , filter+                     , breakOnAll, breakOnAll'+                     , find+                     , partition++                       -- * Indexing+                     , index+                     , findIndex+                     , count++                       -- * Zipping+                     , zip+                     , zipWith+                     ) where++import           Prelude+  ( Char, Bool(..), Int, Maybe(..), String, Eq(..), Ord(..), Ordering(..), (++)+  , Read(..), Show(..), (&&), (||), (+), (-), (.), ($), ($!), (>>)+  , not, seq, return, otherwise, quot)+import qualified Prelude                              as P++import           Control.DeepSeq                      (NFData(..))+import           Data.Char                            (isSpace)+import           Data.Coerce                          (coerce)+import qualified Data.List                            as L+import           Data.Data+import qualified Data.Text                            as T+import qualified Data.Text.Internal.Fusion            as TF+import qualified Data.Text.Internal.Fusion.Common     as TF++import           GHC.Exts+  ( Int#, (+#), (-#), (>=#), (>#), isTrue#, chr#, Char(..)+  , Int(..), Addr#, tagToEnum#)+import qualified GHC.Exts                             as Exts+import qualified GHC.CString                          as GHC++import           Unsafe.Coerce++import           GHCJS.Prim                           (JSVal)++import           Data.JSString.Internal.Type+import           Data.JSString.Internal.Fusion        (stream, unstream)+import qualified Data.JSString.Internal.Fusion        as S+import qualified Data.JSString.Internal.Fusion.Common as S++instance Exts.IsList JSString where+  type Item JSString = Char+  fromList           = pack+  toList             = unpack++-- -----------------------------------------------------------------------------+-- * Conversion to/from 'JSString'++-- | /O(n)/ Convert a 'String' into a 'JSString'.  Subject to+-- fusion.+pack :: String -> JSString+pack = coerce T.pack+{-# INLINE [1] pack #-}++{-# RULES+"JSSTRING pack -> fused" [~1] forall x.+    pack x = unstream (S.map safe (S.streamList x))+"JSSTRING pack -> unfused" [1] forall x.+    unstream (S.map safe (S.streamList x)) = pack x+  #-}++-- | /O(n)/ Convert a 'JSString' into a 'String'.  Subject to fusion.+unpack :: JSString -> String+unpack = S.unstreamList . stream+{-# INLINE [1] unpack #-}++unpack' :: JSString -> String+unpack' = coerce T.unpack+{-# INLINE unpack' #-}++-- | /O(n)/ Convert a literal string into a JSString.  Subject to fusion.+unpackCString# :: Addr# -> JSString+unpackCString# = coerce T.unpackCString#+{-# NOINLINE unpackCString# #-}++{-# RULES "JSSTRING literal" forall a.+    unstream (S.map safe (S.streamList (GHC.unpackCString# a)))+      = unpackCString# a #-}++{-# RULES "JSSTRING literal UTF8" forall a.+    unstream (S.map safe (S.streamList (GHC.unpackCStringUtf8# a)))+      = unpackCString# a #-}++{-# RULES "JSSTRING empty literal"+    unstream (S.map safe (S.streamList []))+      = empty_ #-}++{-# RULES "JSSTRING singleton literal" forall a.+    unstream (S.map safe (S.streamList [a]))+      = singleton a #-}+++-- | /O(1)/ Convert a character into a 'JSString'.  Subject to fusion.+-- Performs replacement on invalid scalar values.+singleton :: Char -> JSString+singleton = coerce T.singleton+{-# INLINE [1] singleton #-}++{-# RULES+"JSSTRING singleton -> fused" [~1] forall a.+    singleton a = unstream (S.singleton (safe a))+"JSSTRING singleton -> unfused" [1] forall a.+    unstream (S.singleton (safe a)) = singleton a+ #-}++-- This is intended to reduce inlining bloat.+-- singleton_ :: Char -> Text+-- singleton_ c = js_singleton c++-- Text (A.run x) 0 len+--  where x :: ST s (A.MArray s)+--        x = do arr <- A.new len+--               _ <- unsafeWrite arr 0 d+--               return arr+--        len | d < '\x10000' = 1+-- x           | otherwise     = 2+--        d = safe c+-- {-# NOINLINE singleton_ #-}++-- -----------------------------------------------------------------------------+-- * Basic functions++-- | /O(n)/ Adds a character to the front of a 'JSString'.  This function+-- is more costly than its 'List' counterpart because it requires+-- copying a new array.  Subject to fusion.  Performs replacement on+-- invalid scalar values.+cons :: Char -> JSString -> JSString+cons = coerce T.cons+{-# INLINE [1] cons #-}++{-# RULES+"JSSTRING cons -> fused" [~1] forall c x.+    cons c x = unstream (S.cons (safe c) (stream x))+"JSSTRING cons -> unfused" [1] forall c x.+    unstream (S.cons (safe c) (stream x)) = cons c x+ #-}++infixr 5 `cons`++-- | /O(n)/ Adds a character to the end of a 'JSString'.  This copies the+-- entire array in the process, unless fused.  Subject to fusion.+-- Performs replacement on invalid scalar values.+snoc :: JSString -> Char -> JSString+snoc = coerce T.snoc+  -- unstream (S.snoc (stream t) (safe c))+{-# INLINE [1] snoc #-}++{-# RULES+"JSSTRING snoc -> fused" [~1] forall x c.+    snoc x c = unstream (S.snoc (stream x) (safe c))+"JSSTRING snoc -> unfused" [1] forall x c.+    unstream (S.snoc (stream x) (safe c)) = snoc x c+ #-}++-- | /O(n)/ Appends one 'JSString' to the other by copying both of them+-- into a new 'JSString'.  Subject to fusion.+append :: JSString -> JSString -> JSString+append = coerce T.append+{-# INLINE [1] append #-}++{-# RULES+"JSSTRING append -> fused" [~1] forall x1 x2.+    append x1 x2 = unstream (S.append (stream x1) (stream x2))+"JSSTRING append -> unfused" [1] forall x1 x2.+    unstream (S.append (stream x1) (stream x2)) = append x1 x2+ #-}++-- | /O(1)/ Returns the first character of a 'JSString', which must be+-- non-empty.  Subject to fusion.+head :: JSString -> Char+head = coerce T.head+{-# INLINE [1] head #-}++{-# RULES+"JSSTRING head -> fused" [~1] forall x.+    head x = S.head (stream x)+"JSSTRING head -> unfused" [1] forall x.+    S.head (stream x) = head x+ #-}+++-- | /O(1)/ Returns the first character and rest of a 'JSString', or+-- 'Nothing' if empty. Subject to fusion.+uncons :: JSString -> Maybe (Char, JSString)+uncons = coerce T.uncons+{-# INLINE [1] uncons #-}++-- | Lifted from Control.Arrow and specialized.+second :: (b -> c) -> (a,b) -> (a,c)+second f (a, b) = (a, f b)++-- | /O(1)/ Returns the last character of a 'JSString', which must be+-- non-empty.  Subject to fusion.+last :: JSString -> Char+last = coerce T.last+{-# INLINE [1] last #-}++{-# RULES+"JSSTRING last -> fused" [~1] forall x.+    last x = S.last (stream x)+"JSSTRING last -> unfused" [1] forall x.+    S.last (stream x) = last x+  #-}++-- | /O(1)/ Returns all characters after the head of a 'JSString', which+-- must be non-empty.  Subject to fusion.+tail :: JSString -> JSString+tail = coerce T.tail+{-# INLINE [1] tail #-}++{-# RULES+"JSSTRING tail -> fused" [~1] forall x.+    tail x = unstream (S.tail (stream x))+"JSSTRING tail -> unfused" [1] forall x.+    unstream (S.tail (stream x)) = tail x+ #-}++-- | /O(1)/ Returns all but the last character of a 'JSString', which must+-- be non-empty.  Subject to fusion.+init :: JSString -> JSString+init = coerce T.init+{-# INLINE [1] init #-}++{-# RULES+"JSSTRING init -> fused" [~1] forall t.+    init t = unstream (S.init (stream t))+"JSSTRING init -> unfused" [1] forall t.+    unstream (S.init (stream t)) = init t+ #-}++-- | /O(1)/ Tests whether a 'JSString' is empty or not.  Subject to+-- fusion.+null :: JSString -> Bool+null = coerce T.null+{-# INLINE [1] null #-}++{-# RULES+"JSSTRING null -> fused" [~1] forall t.+    null t = S.null (stream t)+"JSSTRING null -> unfused" [1] forall t.+    S.null (stream t) = null t+ #-}++-- | /O(n)/ Returns the number of characters in a 'JSString'.+-- Subject to fusion.+length :: JSString -> Int+length = coerce T.length+{-# INLINE [1] length #-}++{-# RULES+"JSSTRING length -> fused" [~1] forall x.+    length x = S.length (stream x)+"JSSTRING length -> unfused" [1] forall x.+    S.length (stream x) = length x+ #-}++-- | /O(n)/ Compare the count of characters in a 'JSString' to a number.+-- Subject to fusion.+--+-- This function gives the same answer as comparing against the result+-- of 'length', but can short circuit if the count of characters is+-- greater than the number, and hence be more efficient.+compareLength :: JSString -> Int -> Ordering+compareLength = coerce T.compareLength+{-# INLINE [1] compareLength #-}++{-# RULES+"JSSTRING compareN/length -> compareLength" [~1] forall t n.+    compare (length t) n = compareLength t n+  #-}++{-# RULES+"JSSTRING ==N/length -> compareLength/==EQ" [~1] forall t n.+    (==) (length t) n = compareLength t n == EQ+  #-}++{-# RULES+"JSSTRING /=N/length -> compareLength//=EQ" [~1] forall t n.+    (/=) (length t) n = compareLength t n /= EQ+  #-}++{-# RULES+"JSSTRING <N/length -> compareLength/==LT" [~1] forall t n.+    (<) (length t) n = compareLength t n == LT+  #-}++{-# RULES+"JSSTRING <=N/length -> compareLength//=GT" [~1] forall t n.+    (<=) (length t) n = compareLength t n /= GT+  #-}++{-# RULES+"JSSTRING >N/length -> compareLength/==GT" [~1] forall t n.+    (>) (length t) n = compareLength t n == GT+  #-}++{-# RULES+"JSSTRING >=N/length -> compareLength//=LT" [~1] forall t n.+    (>=) (length t) n = compareLength t n /= LT+  #-}++-- -----------------------------------------------------------------------------+-- * Transformations+-- | /O(n)/ 'map' @f@ @t@ is the 'JSString' obtained by applying @f@ to+-- each element of @t@.  Subject to fusion.  Performs replacement on+-- invalid scalar values.+map :: (Char -> Char) -> JSString -> JSString+map = coerce T.map+{-# INLINE [1] map #-}++-- | /O(n)/ The 'intercalate' function takes a 'JSString' and a list of+-- 'JSString's and concatenates the list after interspersing the first+-- argument between each element of the list.+intercalate :: JSString -> [JSString] -> JSString+intercalate = coerce T.intercalate+{-# INLINE [1] intercalate #-}++-- | /O(n)/ The 'intersperse' function takes a character and places it+-- between the characters of a 'JSString'.  Subject to fusion.  Performs+-- replacement on invalid scalar values.+intersperse     :: Char -> JSString -> JSString+intersperse = coerce T.intersperse+{-# INLINE [1] intersperse #-}++{-# RULES+"JSSTRING intersperse -> fused" [~1] forall c x.+    intersperse c x = unstream (S.intersperse (safe c) (stream x))+"JSSTRING intersperse -> unfused" [1] forall c x.+    unstream (S.intersperse (safe c) (stream x)) = intersperse c x+ #-}++-- | /O(n)/ Reverse the characters of a string. Subject to fusion.+reverse :: JSString -> JSString+reverse = coerce T.reverse+{-# INLINE [1] reverse #-}++{-# RULES+"JSSTRING reverse -> fused" [~1] forall x.+    reverse x = S.reverse (stream x)+"JSSTRING reverse -> unfused" [1] forall x.+    S.reverse (stream x) = reverse x+ #-}++-- | /O(m+n)/ Replace every non-overlapping occurrence of @needle@ in+-- @haystack@ with @replacement@.+--+-- This function behaves as though it was defined as follows:+--+-- @+-- replace needle replacement haystack =+--   'intercalate' replacement ('splitOn' needle haystack)+-- @+--+-- As this suggests, each occurrence is replaced exactly once.  So if+-- @needle@ occurs in @replacement@, that occurrence will /not/ itself+-- be replaced recursively:+--+-- > replace "oo" "foo" "oo" == "foo"+--+-- In cases where several instances of @needle@ overlap, only the+-- first one will be replaced:+--+-- > replace "ofo" "bar" "ofofo" == "barfo"+--+-- In (unlikely) bad cases, this function's time complexity degrades+-- towards /O(n*m)/.+replace :: JSString+        -- ^ @needle@ to search for.  If this string is empty, an+        -- error will occur.+        -> JSString+        -- ^ @replacement@ to replace @needle@ with.+        -> JSString+        -- ^ @haystack@ in which to search.+        -> JSString+replace = coerce T.replace+{-# INLINE replace #-}++-- ----------------------------------------------------------------------------+-- ** Case conversions (folds)++-- $case+--+-- When case converting 'JSString' values, do not use combinators like+-- @map toUpper@ to case convert each character of a string+-- individually, as this gives incorrect results according to the+-- rules of some writing systems.  The whole-string case conversion+-- functions from this module, such as @toUpper@, obey the correct+-- case conversion rules.  As a result, these functions may map one+-- input character to two or three output characters. For examples,+-- see the documentation of each function.+--+-- /Note/: In some languages, case conversion is a locale- and+-- context-dependent operation. The case conversion functions in this+-- module are /not/ locale sensitive. Programs that require locale+-- sensitivity should use appropriate versions of the+-- <http://hackage.haskell.org/package/text-icu-0.6.3.7/docs/Data-Text-ICU.html#g:4 case mapping functions from the text-icu package >.++-- | /O(n)/ Convert a string to folded case.  Subject to fusion.+--+-- This function is mainly useful for performing caseless (also known+-- as case insensitive) string comparisons.+--+-- A string @x@ is a caseless match for a string @y@ if and only if:+--+-- @toCaseFold x == toCaseFold y@+--+-- The result string may be longer than the input string, and may+-- differ from applying 'toLower' to the input string.  For instance,+-- the Armenian small ligature \"&#xfb13;\" (men now, U+FB13) is case+-- folded to the sequence \"&#x574;\" (men, U+0574) followed by+-- \"&#x576;\" (now, U+0576), while the Greek \"&#xb5;\" (micro sign,+-- U+00B5) is case folded to \"&#x3bc;\" (small letter mu, U+03BC)+-- instead of itself.+toCaseFold :: JSString -> JSString+toCaseFold = coerce T.toCaseFold+{-# INLINE [0] toCaseFold #-}++-- | /O(n)/ Convert a string to lower case, using simple case+-- conversion.  Subject to fusion.+--+-- The result string may be longer than the input string.  For+-- instance, \"&#x130;\" (Latin capital letter I with dot above,+-- U+0130) maps to the sequence \"i\" (Latin small letter i, U+0069)+-- followed by \" &#x307;\" (combining dot above, U+0307).+toLower :: JSString -> JSString+toLower = coerce T.toLower+{-# INLINE [1] toLower #-}++{-# RULES+"JSSTRING toLower -> fused" [~1] forall x.+    toLower x = unstream (S.toLower (stream x))+"JSSTRING toLower -> unfused" [1] forall x.+    unstream (S.toLower (stream x)) = toLower x+ #-}++-- | /O(n)/ Convert a string to upper case, using simple case+-- conversion.  Subject to fusion.+--+-- The result string may be longer than the input string.  For+-- instance, the German \"&#xdf;\" (eszett, U+00DF) maps to the+-- two-letter sequence \"SS\".+toUpper :: JSString -> JSString+toUpper = coerce T.toUpper+{-# INLINE [1] toUpper #-}++{-# RULES+"JSSTRING toUpper -> fused" [~1] forall x.+    toUpper x = unstream (S.toUpper(stream x))+"JSSTRING toUpper -> unfused" [1] forall x.+    unstream (S.toUpper (stream x)) = toUpper x+ #-}++-- | /O(n)/ Convert a string to title case, using simple case+-- conversion. Subject to fusion.+--+-- The first letter of the input is converted to title case, as is+-- every subsequent letter that immediately follows a non-letter.+-- Every letter that immediately follows another letter is converted+-- to lower case.+--+-- The result string may be longer than the input string. For example,+-- the Latin small ligature &#xfb02; (U+FB02) is converted to the+-- sequence Latin capital letter F (U+0046) followed by Latin small+-- letter l (U+006C).+--+-- /Note/: this function does not take language or culture specific+-- rules into account. For instance, in English, different style+-- guides disagree on whether the book name \"The Hill of the Red+-- Fox\" is correctly title cased&#x2014;but this function will+-- capitalize /every/ word.+toTitle :: JSString -> JSString+toTitle = coerce T.toTitle+{-# INLINE toTitle #-}++-- | /O(n)/ Left-justify a string to the given length, using the+-- specified fill character on the right. Subject to fusion.+-- Performs replacement on invalid scalar values.+--+-- Examples:+--+-- > justifyLeft 7 'x' "foo"    == "fooxxxx"+-- > justifyLeft 3 'x' "foobar" == "foobar"+justifyLeft :: Int -> Char -> JSString -> JSString+justifyLeft = coerce T.justifyLeft+{-# INLINE [1] justifyLeft #-}++{-# RULES+"JSSTRING justifyLeft -> fused" [~1] forall k c t.+    justifyLeft k c t = unstream (S.justifyLeftI k c (stream t))+"JSSTRING justifyLeft -> unfused" [1] forall k c t.+    unstream (S.justifyLeftI k c (stream t)) = justifyLeft k c t+  #-}++-- | /O(n)/ Right-justify a string to the given length, using the+-- specified fill character on the left.  Performs replacement on+-- invalid scalar values.+--+-- Examples:+--+-- > justifyRight 7 'x' "bar"    == "xxxxbar"+-- > justifyRight 3 'x' "foobar" == "foobar"+justifyRight :: Int -> Char -> JSString -> JSString+justifyRight = coerce T.justifyRight+{-# INLINE justifyRight #-}++-- | /O(n)/ Center a string to the given length, using the specified+-- fill character on either side.  Performs replacement on invalid+-- scalar values.+--+-- Examples:+--+-- > center 8 'x' "HS" = "xxxHSxxx"+center :: Int -> Char -> JSString -> JSString+center = coerce T.center+{-# INLINE center #-}++-- | /O(n)/ The 'transpose' function transposes the rows and columns+-- of its 'JSString' argument.  Note that this function uses 'pack',+-- 'unpack', and the list version of transpose, and is thus not very+-- efficient.+transpose :: [JSString] -> [JSString]+transpose = coerce T.transpose++-- -----------------------------------------------------------------------------+-- * Reducing 'JSString's (folds)++-- | /O(n)/ 'foldl', applied to a binary operator, a starting value+-- (typically the left-identity of the operator), and a 'JSString',+-- reduces the 'JSString' using the binary operator, from left to right.+-- Subject to fusion.+foldl :: (a -> Char -> a) -> a -> JSString -> a+foldl f = coerce (T.foldl f)+{-# INLINE foldl #-}++-- | /O(n)/ A strict version of 'foldl'.  Subject to fusion.+foldl' :: (a -> Char -> a) -> a -> JSString -> a+foldl' f = coerce (T.foldl' f)+{-# INLINE foldl' #-}++-- | /O(n)/ A variant of 'foldl' that has no starting value argument,+-- and thus must be applied to a non-empty 'JSString'.  Subject to fusion.+foldl1 :: (Char -> Char -> Char) -> JSString -> Char+foldl1 = coerce T.foldl1+{-# INLINE foldl1 #-}++-- | /O(n)/ A strict version of 'foldl1'.  Subject to fusion.+foldl1' :: (Char -> Char -> Char) -> JSString -> Char+foldl1' = coerce T.foldl1'+{-# INLINE foldl1' #-}++-- | /O(n)/ 'foldr', applied to a binary operator, a starting value+-- (typically the right-identity of the operator), and a 'JSString',+-- reduces the 'JSString' using the binary operator, from right to left.+-- Subject to fusion.+foldr :: (Char -> a -> a) -> a -> JSString -> a+foldr f = coerce (T.foldr f)+{-# INLINE foldr #-}++-- | /O(n)/ A variant of 'foldr' that has no starting value argument,+-- and thus must be applied to a non-empty 'JSString'.  Subject to+-- fusion.+foldr1 :: (Char -> Char -> Char) -> JSString -> Char+foldr1 = coerce T.foldr1+{-# INLINE foldr1 #-}++-- -----------------------------------------------------------------------------+-- ** Special folds++-- | /O(n)/ Concatenate a list of 'JSString's.+concat :: [JSString] -> JSString+concat = coerce T.concat++-- | /O(n)/ Map a function over a 'JSString' that results in a 'JSString', and+-- concatenate the results.+concatMap :: (Char -> JSString) -> JSString -> JSString+concatMap = coerce T.concatMap+{-# INLINE concatMap #-}++-- | /O(n)/ 'any' @p@ @t@ determines whether any character in the+-- 'JSString' @t@ satisifes the predicate @p@. Subject to fusion.+any :: (Char -> Bool) -> JSString -> Bool+any = coerce T.any+{-# INLINE any #-}++-- | /O(n)/ 'all' @p@ @t@ determines whether all characters in the+-- 'JSString' @t@ satisify the predicate @p@. Subject to fusion.+all :: (Char -> Bool) -> JSString -> Bool+all = coerce T.all+{-# INLINE all #-}++-- | /O(n)/ 'maximum' returns the maximum value from a 'JSString', which+-- must be non-empty. Subject to fusion.+maximum :: JSString -> Char+maximum = coerce T.maximum+{-# INLINE maximum #-}++-- | /O(n)/ 'minimum' returns the minimum value from a 'JSString', which+-- must be non-empty. Subject to fusion.+minimum :: JSString -> Char+minimum = coerce T.minimum+{-# INLINE minimum #-}++-- -----------------------------------------------------------------------------+-- * Building 'JSString's++-- | /O(n)/ 'scanl' is similar to 'foldl', but returns a list of+-- successive reduced values from the left. Subject to fusion.+-- Performs replacement on invalid scalar values.+--+-- > scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]+--+-- Note that+--+-- > last (scanl f z xs) == foldl f z xs.+scanl :: (Char -> Char -> Char) -> Char -> JSString -> JSString+scanl = coerce T.scanl+{-# INLINE scanl #-}++-- | /O(n)/ 'scanl1' is a variant of 'scanl' that has no starting+-- value argument.  Subject to fusion.  Performs replacement on+-- invalid scalar values.+--+-- > scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]+scanl1 :: (Char -> Char -> Char) -> JSString -> JSString+scanl1 = coerce T.scanl1+{-# INLINE scanl1 #-}++-- | /O(n)/ 'scanr' is the right-to-left dual of 'scanl'.  Performs+-- replacement on invalid scalar values.+--+-- > scanr f v == reverse . scanl (flip f) v . reverse+scanr :: (Char -> Char -> Char) -> Char -> JSString -> JSString+scanr = coerce T.scanr+{-# INLINE scanr #-}++-- | /O(n)/ 'scanr1' is a variant of 'scanr' that has no starting+-- value argument.  Subject to fusion.  Performs replacement on+-- invalid scalar values.+scanr1 :: (Char -> Char -> Char) -> JSString -> JSString+scanr1 = coerce T.scanr1+{-# INLINE scanr1 #-}++-- | /O(n)/ Like a combination of 'map' and 'foldl''. Applies a+-- function to each element of a 'JSString', passing an accumulating+-- parameter from left to right, and returns a final 'JSString'.  Performs+-- replacement on invalid scalar values.+mapAccumL :: (a -> Char -> (a,Char)) -> a -> JSString -> (a, JSString)+mapAccumL f = coerce (T.mapAccumL f)+{-# INLINE mapAccumL #-}++-- | The 'mapAccumR' function behaves like a combination of 'map' and+-- a strict 'foldr'; it applies a function to each element of a+-- 'JSString', passing an accumulating parameter from right to left, and+-- returning a final value of this accumulator together with the new+-- 'JSString'.+-- Performs replacement on invalid scalar values.+mapAccumR :: (a -> Char -> (a,Char)) -> a -> JSString -> (a, JSString)+mapAccumR f = coerce (T.mapAccumR f)+{-# INLINE mapAccumR #-}++-- -----------------------------------------------------------------------------+-- ** Generating and unfolding 'JSString's++-- | /O(n*m)/ 'replicate' @n@ @t@ is a 'JSString' consisting of the input+-- @t@ repeated @n@ times.+replicate :: Int -> JSString -> JSString+replicate = coerce T.replicate+{-# INLINE [1] replicate #-}++-- | /O(n)/, where @n@ is the length of the result. The 'unfoldr'+-- function is analogous to the List 'L.unfoldr'. 'unfoldr' builds a+-- 'JSString' from a seed value. The function takes the element and+-- returns 'Nothing' if it is done producing the 'JSString', otherwise+-- 'Just' @(a,b)@.  In this case, @a@ is the next 'Char' in the+-- string, and @b@ is the seed value for further production. Subject+-- to fusion.  Performs replacement on invalid scalar values.+unfoldr     :: (a -> Maybe (Char,a)) -> a -> JSString+unfoldr f = coerce (T.unfoldr f)+{-# INLINE unfoldr #-}++-- | /O(n)/ Like 'unfoldr', 'unfoldrN' builds a 'JSString' from a seed+-- value. However, the length of the result should be limited by the+-- first argument to 'unfoldrN'. This function is more efficient than+-- 'unfoldr' when the maximum length of the result is known and+-- correct, otherwise its performance is similar to 'unfoldr'. Subject+-- to fusion.  Performs replacement on invalid scalar values.+unfoldrN     :: Int -> (a -> Maybe (Char,a)) -> a -> JSString+unfoldrN n f = coerce (T.unfoldrN n f)+{-# INLINE unfoldrN #-}++-- -----------------------------------------------------------------------------+-- * Substrings++-- | /O(n)/ 'take' @n@, applied to a 'JSString', returns the prefix of the+-- 'JSString' of length @n@, or the 'JSString' itself if @n@ is greater than+-- the length of the JSString. Subject to fusion.+take :: Int -> JSString -> JSString+take = coerce T.take+{-# INLINE [1] take #-}+{-+iterN :: Int -> JSString -> Int+iterN n t@(Text _arr _off len) = loop 0 0+  where loop !i !cnt+            | i >= len || cnt >= n = i+            | otherwise            = loop (i+d) (cnt+1)+          where d = iter_ t i+-}+{-# RULES+"JSSTRING take -> fused" [~1] forall n t.+    take n t = unstream (S.take n (stream t))+"JSSTRING take -> unfused" [1] forall n t.+    unstream (S.take n (stream t)) = take n t+  #-}++-- | /O(n)/ 'takeEnd' @n@ @t@ returns the suffix remaining after+-- taking @n@ characters from the end of @t@.+--+-- Examples:+--+-- > takeEnd 3 "foobar" == "bar"+takeEnd :: Int -> JSString -> JSString+takeEnd = coerce T.takeEnd++-- | /O(n)/ 'drop' @n@, applied to a 'JSString', returns the suffix of the+-- 'JSString' after the first @n@ characters, or the empty 'JSString' if @n@+-- is greater than the length of the 'JSString'. Subject to fusion.+drop :: Int -> JSString -> JSString+drop = coerce T.drop+{-# INLINE [1] drop #-}++{-# RULES+"JSSTRING drop -> fused" [~1] forall n t.+    drop n t = unstream (S.drop n (stream t))+"JSSTRING drop -> unfused" [1] forall n t.+    unstream (S.drop n (stream t)) = drop n t+  #-}++-- | /O(n)/ 'dropEnd' @n@ @t@ returns the prefix remaining after+-- dropping @n@ characters from the end of @t@.+--+-- Examples:+--+-- > dropEnd 3 "foobar" == "foo"+dropEnd :: Int -> JSString -> JSString+dropEnd = coerce T.dropEnd++-- | /O(n)/ 'takeWhile', applied to a predicate @p@ and a 'JSString',+-- returns the longest prefix (possibly empty) of elements that+-- satisfy @p@.  Subject to fusion.+takeWhile :: (Char -> Bool) -> JSString -> JSString+takeWhile = coerce T.takeWhile+{-# INLINE [1] takeWhile #-}++{-# RULES+"TEXT takeWhile -> fused" [~1] forall p t.+    takeWhile p t = unstream (S.takeWhile p (stream t))+"TEXT takeWhile -> unfused" [1] forall p t.+    unstream (S.takeWhile p (stream t)) = takeWhile p t+  #-}++-- | /O(n)/ 'dropWhile' @p@ @t@ returns the suffix remaining after+-- 'takeWhile' @p@ @t@. Subject to fusion.+dropWhile :: (Char -> Bool) -> JSString -> JSString+dropWhile = coerce T.dropWhile+{-# INLINE [1] dropWhile #-}++{-# RULES+"TEXT dropWhile -> fused" [~1] forall p t.+    dropWhile p t = unstream (S.dropWhile p (stream t))+"TEXT dropWhile -> unfused" [1] forall p t.+    unstream (S.dropWhile p (stream t)) = dropWhile p t+  #-}++-- | /O(n)/ 'dropWhileEnd' @p@ @t@ returns the prefix remaining after+-- dropping characters that fail the predicate @p@ from the end of+-- @t@.  Subject to fusion.+-- Examples:+--+-- > dropWhileEnd (=='.') "foo..." == "foo"+dropWhileEnd :: (Char -> Bool) -> JSString -> JSString+dropWhileEnd = coerce T.dropWhileEnd+{-# INLINE [1] dropWhileEnd #-}++{-# RULES+"TEXT dropWhileEnd -> fused" [~1] forall p t.+    dropWhileEnd p t = S.reverse (S.dropWhile p (S.reverseStream t))+"TEXT dropWhileEnd -> unfused" [1] forall p t.+    S.reverse (S.dropWhile p (S.reverseStream t)) = dropWhileEnd p t+  #-}++-- | /O(n)/ 'dropAround' @p@ @t@ returns the substring remaining after+-- dropping characters that fail the predicate @p@ from both the+-- beginning and end of @t@.  Subject to fusion.+dropAround :: (Char -> Bool) -> JSString -> JSString+dropAround = coerce T.dropAround+{-# INLINE [1] dropAround #-}++-- | /O(n)/ Remove leading white space from a string.  Equivalent to:+--+-- > dropWhile isSpace+stripStart :: JSString -> JSString+stripStart = coerce T.stripStart+{-# INLINE [1] stripStart #-}++-- | /O(n)/ Remove trailing white space from a string.  Equivalent to:+--+-- > dropWhileEnd isSpace+stripEnd :: JSString -> JSString+stripEnd = coerce T.stripEnd+{-# INLINE [1] stripEnd #-}++-- | /O(n)/ Remove leading and trailing white space from a string.+-- Equivalent to:+--+-- > dropAround isSpace+strip :: JSString -> JSString+strip = coerce T.strip+{-# INLINE [1] strip #-}++-- | /O(n)/ 'splitAt' @n t@ returns a pair whose first element is a+-- prefix of @t@ of length @n@, and whose second is the remainder of+-- the string. It is equivalent to @('take' n t, 'drop' n t)@.+splitAt :: Int -> JSString -> (JSString, JSString)+splitAt = coerce T.splitAt+{-# INLINE splitAt #-}++-- | /O(n)/ 'span', applied to a predicate @p@ and text @t@, returns+-- a pair whose first element is the longest prefix (possibly empty)+-- of @t@ of elements that satisfy @p@, and whose second is the+-- remainder of the list.+span :: (Char -> Bool) -> JSString -> (JSString, JSString)+span = coerce T.span+{-# INLINE span #-}++-- | /O(n)/ 'break' is like 'span', but the prefix returned is+-- over elements that fail the predicate @p@.+break :: (Char -> Bool) -> JSString -> (JSString, JSString)+break = coerce T.break+{-# INLINE break #-}++-- | /O(n)/ Group characters in a string according to a predicate.+groupBy :: (Char -> Char -> Bool) -> JSString -> [JSString]+groupBy = coerce T.groupBy++-- | /O(n)/ Group characters in a string by equality.+group :: JSString -> [JSString]+group = coerce T.group+{-# INLINE group #-}++group' :: JSString -> [JSString]+group' = coerce T.group+{-# INLINE group' #-}++-- | /O(n^2)/ Return all initial segments of the given 'JSString', shortest+-- first.+inits :: JSString -> [JSString]+inits = coerce T.inits++-- | /O(n^2)/ Return all final segments of the given 'JSString', longest+-- first.+tails :: JSString -> [JSString]+tails = coerce T.tails++-- $split+--+-- Splitting functions in this library do not perform character-wise+-- copies to create substrings; they just construct new 'JSString's that+-- are slices of the original.++-- | /O(m+n)/ Break a 'JSString' into pieces separated by the first 'JSString'+-- argument (which cannot be empty), consuming the delimiter. An empty+-- delimiter is invalid, and will cause an error to be raised.+--+-- Examples:+--+-- > splitOn "\r\n" "a\r\nb\r\nd\r\ne" == ["a","b","d","e"]+-- > splitOn "aaa"  "aaaXaaaXaaaXaaa"  == ["","X","X","X",""]+-- > splitOn "x"    "x"                == ["",""]+--+-- and+--+-- > intercalate s . splitOn s         == id+-- > splitOn (singleton c)             == split (==c)+--+-- (Note: the string @s@ to split on above cannot be empty.)+--+-- In (unlikely) bad cases, this function's time complexity degrades+-- towards /O(n*m)/.+splitOn :: JSString+        -- ^ String to split on. If this string is empty, an error+        -- will occur.+        -> JSString+        -- ^ Input text.+        -> [JSString]+splitOn = coerce T.splitOn+{-# INLINE [1] splitOn #-}++-- RULES+-- "JSSTRING splitOn/singleton -> split/==" [~1] forall c t.+--    splitOn (singleton c) t = split (==c) t+--++splitOn' :: JSString+         -- ^ String to split on. If this string is empty, an error+         -- will occur.+         -> JSString+         -- ^ Input text.+         -> [JSString]+splitOn' = coerce T.splitOn+{-# NOINLINE splitOn' #-}+--- {-# INLINE [1] splitOn' #-}++-- | /O(n)/ Splits a 'JSString' into components delimited by separators,+-- where the predicate returns True for a separator element.  The+-- resulting components do not contain the separators.  Two adjacent+-- separators result in an empty component in the output.  eg.+--+-- > split (=='a') "aabbaca" == ["","","bb","c",""]+-- > split (=='a') ""        == [""]+split :: (Char -> Bool) -> JSString -> [JSString]+split = coerce T.split+{-# INLINE split #-}++-- | /O(n)/ Splits a 'JSString' into components of length @k@.  The last+-- element may be shorter than the other chunks, depending on the+-- length of the input. Examples:+--+-- > chunksOf 3 "foobarbaz"   == ["foo","bar","baz"]+-- > chunksOf 4 "haskell.org" == ["hask","ell.","org"]+chunksOf :: Int -> JSString -> [JSString]+chunksOf = coerce T.chunksOf+{-# INLINE chunksOf #-}++-- | /O(n)/ Splits a 'JSString' into components of length @k@.  The last+-- element may be shorter than the other chunks, depending on the+-- length of the input. Examples:+--+-- > chunksOf 3 "foobarbaz"   == ["foo","bar","baz"]+-- > chunksOf 4 "haskell.org" == ["hask","ell.","org"]+chunksOf' :: Int -> JSString -> [JSString]+chunksOf' = coerce T.chunksOf+{-# INLINE chunksOf' #-}++-- ----------------------------------------------------------------------------+-- * Searching++-------------------------------------------------------------------------------+-- ** Searching with a predicate++-- | /O(n)/ The 'find' function takes a predicate and a 'JSString', and+-- returns the first element matching the predicate, or 'Nothing' if+-- there is no such element.+find :: (Char -> Bool) -> JSString -> Maybe Char+find = coerce T.find+{-# INLINE find #-}++-- | /O(n)/ The 'partition' function takes a predicate and a 'JSString',+-- and returns the pair of 'JSString's with elements which do and do not+-- satisfy the predicate, respectively; i.e.+--+-- > partition p t == (filter p t, filter (not . p) t)+partition :: (Char -> Bool) -> JSString -> (JSString, JSString)+partition = coerce T.partition+{-# INLINE partition #-}++-- | /O(n)/ 'filter', applied to a predicate and a 'JSString',+-- returns a 'JSString' containing those characters that satisfy the+-- predicate.+filter :: (Char -> Bool) -> JSString -> JSString+filter = coerce T.filter+{-# INLINE filter #-}++-- | /O(n+m)/ Find the first instance of @needle@ (which must be+-- non-'null') in @haystack@.  The first element of the returned tuple+-- is the prefix of @haystack@ before @needle@ is matched.  The second+-- is the remainder of @haystack@, starting with the match.+--+-- Examples:+--+-- > breakOn "::" "a::b::c" ==> ("a", "::b::c")+-- > breakOn "/" "foobar"   ==> ("foobar", "")+--+-- Laws:+--+-- > append prefix match == haystack+-- >   where (prefix, match) = breakOn needle haystack+--+-- If you need to break a string by a substring repeatedly (e.g. you+-- want to break on every instance of a substring), use 'breakOnAll'+-- instead, as it has lower startup overhead.+--+-- In (unlikely) bad cases, this function's time complexity degrades+-- towards /O(n*m)/.+breakOn :: JSString -> JSString -> (JSString, JSString)+breakOn = coerce T.breakOn+{-# INLINE breakOn #-}++-- | /O(n+m)/ Similar to 'breakOn', but searches from the end of the+-- string.+--+-- The first element of the returned tuple is the prefix of @haystack@+-- up to and including the last match of @needle@.  The second is the+-- remainder of @haystack@, following the match.+--+-- > breakOnEnd "::" "a::b::c" ==> ("a::b::", "c")+breakOnEnd :: JSString -> JSString -> (JSString, JSString)+breakOnEnd = coerce T.breakOnEnd+{-# INLINE breakOnEnd #-}++-- | /O(n+m)/ Find all non-overlapping instances of @needle@ in+-- @haystack@.  Each element of the returned list consists of a pair:+--+-- * The entire string prior to the /k/th match (i.e. the prefix)+--+-- * The /k/th match, followed by the remainder of the string+--+-- Examples:+--+-- > breakOnAll "::" ""+-- > ==> []+-- > breakOnAll "/" "a/b/c/"+-- > ==> [("a", "/b/c/"), ("a/b", "/c/"), ("a/b/c", "/")]+--+-- In (unlikely) bad cases, this function's time complexity degrades+-- towards /O(n*m)/.+--+-- The @needle@ parameter may not be empty.+breakOnAll :: JSString              -- ^ @needle@ to search for+           -> JSString              -- ^ @haystack@ in which to search+           -> [(JSString, JSString)]+breakOnAll = coerce T.breakOnAll+{-# INLINE breakOnAll #-}++breakOnAll' :: JSString              -- ^ @needle@ to search for+            -> JSString              -- ^ @haystack@ in which to search+            -> [(JSString, JSString)]+breakOnAll' = coerce T.breakOnAll+{-# INLINE breakOnAll' #-}++-------------------------------------------------------------------------------+-- ** Indexing 'JSString's++-- $index+--+-- If you think of a 'JSString' value as an array of 'Char' values (which+-- it is not), you run the risk of writing inefficient code.+--+-- An idiom that is common in some languages is to find the numeric+-- offset of a character or substring, then use that number to split+-- or trim the searched string.  With a 'JSString' value, this approach+-- would require two /O(n)/ operations: one to perform the search, and+-- one to operate from wherever the search ended.+--+-- For example, suppose you have a string that you want to split on+-- the substring @\"::\"@, such as @\"foo::bar::quux\"@. Instead of+-- searching for the index of @\"::\"@ and taking the substrings+-- before and after that index, you would instead use @breakOnAll \"::\"@.++-- | /O(n)/ 'JSString' index (subscript) operator, starting from 0.+index :: JSString -> Int -> Char+index = coerce T.index+{-# INLINE index #-}++-- | /O(n)/ The 'findIndex' function takes a predicate and a 'JSString'+-- and returns the index of the first element in the 'JSString' satisfying+-- the predicate. Subject to fusion.+findIndex :: (Char -> Bool) -> JSString -> Maybe Int+findIndex = coerce T.findIndex+{-# INLINE findIndex #-}++-- | /O(n+m)/ The 'count' function returns the number of times the+-- query string appears in the given 'JSString'. An empty query string is+-- invalid, and will cause an error to be raised.+--+-- In (unlikely) bad cases, this function's time complexity degrades+-- towards /O(n*m)/.+count :: JSString -> JSString -> Int+count = coerce T.count+{-# INLINE [1] count #-}++--  RULES+-- "JSSTRING count/singleton -> countChar" [~1] forall c t.+--    count (singleton c) t = countChar c t+--++-------------------------------------------------------------------------------+-- * Zipping++-- | /O(n)/ 'zip' takes two 'JSString's and returns a list of+-- corresponding pairs of bytes. If one input 'JSString' is short,+-- excess elements of the longer 'JSString' are discarded. This is+-- equivalent to a pair of 'unpack' operations.+zip :: JSString -> JSString -> [(Char,Char)]+zip = coerce T.zip+{-# INLINE [0] zip #-}++-- | /O(n)/ 'zipWith' generalises 'zip' by zipping with the function+-- given as the first argument, instead of a tupling function.+-- Performs replacement on invalid scalar values.+zipWith :: (Char -> Char -> Char) -> JSString -> JSString -> JSString+zipWith = coerce T.zipWith+{-# INLINE [0] zipWith #-}++-- | /O(n)/ Breaks a 'JSString' up into a list of words, delimited by 'Char's+-- representing white space.+words :: JSString -> [JSString]+words = coerce T.words+{-# INLINE words #-}++-- fixme: strict words' that allocates the whole list in one go+words' :: JSString -> [JSString]+words' = coerce T.words+{-# INLINE words' #-}++-- | /O(n)/ Breaks a 'JSString' up into a list of 'JSString's at+-- newline 'Char's. The resulting strings do not contain newlines.+lines :: JSString -> [JSString]+lines = coerce T.lines+{-# INLINE lines #-}++lines' :: JSString -> [JSString]+lines' = coerce T.lines+{-# INLINE lines' #-}++{-+-- | /O(n)/ Portably breaks a 'JSString' up into a list of 'JSString's at line+-- boundaries.+--+-- A line boundary is considered to be either a line feed, a carriage+-- return immediately followed by a line feed, or a carriage return.+-- This accounts for both Unix and Windows line ending conventions,+-- and for the old convention used on Mac OS 9 and earlier.+lines' :: Text -> [Text]+lines' ps | null ps   = []+          | otherwise = h : case uncons t of+                              Nothing -> []+                              Just (c,t')+                                  | c == '\n' -> lines t'+                                  | c == '\r' -> case uncons t' of+                                                   Just ('\n',t'') -> lines t''+                                                   _               -> lines t'+    where (h,t)    = span notEOL ps+          notEOL c = c /= '\n' && c /= '\r'++-}++-- | /O(n)/ Joins lines, after appending a terminating newline to+-- each.+unlines :: [JSString] -> JSString+unlines = coerce T.unlines+{-# INLINE unlines #-}++-- | /O(n)/ Joins words using single space characters.+unwords :: [JSString] -> JSString+unwords = coerce T.unwords+{-# INLINE unwords #-}++-- | /O(n)/ The 'isPrefixOf' function takes two 'JSString's and returns+-- 'True' iff the first is a prefix of the second.  Subject to fusion.+isPrefixOf :: JSString -> JSString -> Bool+isPrefixOf = coerce T.isPrefixOf+{-# INLINE [1] isPrefixOf #-}++{-# RULES+"JSSTRING isPrefixOf -> fused" [~1] forall x y.+    isPrefixOf x y = S.isPrefixOf (stream x) (stream y)+"JSSTRING isPrefixOf -> unfused" [1] forall x y.+     S.isPrefixOf (stream x) (stream y) = isPrefixOf x y+  #-}++-- | /O(n)/ The 'isSuffixOf' function takes two 'JSString's and returns+-- 'True' iff the first is a suffix of the second.+isSuffixOf :: JSString -> JSString -> Bool+isSuffixOf = coerce T.isSuffixOf+{-# INLINE isSuffixOf #-}++-- | The 'isInfixOf' function takes two 'JSString's and returns+-- 'True' iff the first is contained, wholly and intact, anywhere+-- within the second.+--+-- Complexity depends on how the JavaScript engine implements+-- String.prototype.find.+isInfixOf :: JSString -> JSString -> Bool+isInfixOf = coerce T.isInfixOf+{-# INLINE [1] isInfixOf #-}++{-# RULES+"JSSTRING isInfixOf/singleton -> S.elem/S.stream" [~1] forall n h.+    isInfixOf (singleton n) h = S.elem n (S.stream h)+  #-}++-------------------------------------------------------------------------------+-- * View patterns++-- | /O(n)/ Return the suffix of the second string if its prefix+-- matches the entire first string.+--+-- Examples:+--+-- > stripPrefix "foo" "foobar" == Just "bar"+-- > stripPrefix ""    "baz"    == Just "baz"+-- > stripPrefix "foo" "quux"   == Nothing+--+-- This is particularly useful with the @ViewPatterns@ extension to+-- GHC, as follows:+--+-- > {-# LANGUAGE ViewPatterns #-}+-- > import Data.Text as T+-- >+-- > fnordLength :: JSString -> Int+-- > fnordLength (stripPrefix "fnord" -> Just suf) = T.length suf+-- > fnordLength _                                 = -1+stripPrefix :: JSString -> JSString -> Maybe JSString+stripPrefix = coerce T.stripPrefix+{-# INLINE stripPrefix #-}++-- | /O(n)/ Find the longest non-empty common prefix of two strings+-- and return it, along with the suffixes of each string at which they+-- no longer match.+--+-- If the strings do not have a common prefix or either one is empty,+-- this function returns 'Nothing'.+--+-- Examples:+--+-- > commonPrefixes "foobar" "fooquux" == Just ("foo","bar","quux")+-- > commonPrefixes "veeble" "fetzer"  == Nothing+-- > commonPrefixes "" "baz"           == Nothing+commonPrefixes :: JSString -> JSString -> Maybe (JSString,JSString,JSString)+commonPrefixes = coerce T.commonPrefixes+{-# INLINE commonPrefixes #-}++-- | /O(n)/ Return the prefix of the second string if its suffix+-- matches the entire first string.+--+-- Examples:+--+-- > stripSuffix "bar" "foobar" == Just "foo"+-- > stripSuffix ""    "baz"    == Just "baz"+-- > stripSuffix "foo" "quux"   == Nothing+--+-- This is particularly useful with the @ViewPatterns@ extension to+-- GHC, as follows:+--+-- > {-# LANGUAGE ViewPatterns #-}+-- > import Data.Text as T+-- >+-- > quuxLength :: Text -> Int+-- > quuxLength (stripSuffix "quux" -> Just pre) = T.length pre+-- > quuxLength _                                = -1+stripSuffix :: JSString -> JSString -> Maybe JSString+stripSuffix = coerce T.stripSuffix+{-# INLINE stripSuffix #-}++---- | Add a list of non-negative numbers.  Errors out on overflow.+--sumP :: String -> [Int] -> Int+--sumP fun = go 0+--  where go !a (x:xs)+--            | ax >= 0   = go ax xs+--            | otherwise = overflowError fun+--          where ax = a + x+--        go a  _         = a+--+--emptyError :: String -> a+--emptyError fun = P.error $ "Data.JSString." ++ fun ++ ": empty input"+--+--overflowError :: String -> a+--overflowError fun = P.error $ "Data.JSString." ++ fun ++ ": size overflow"+--+--charWidth :: Int# -> Int#+--charWidth cp | isTrue# (cp >=# 0x10000#) = 2#+--             | otherwise                 = 1#+--{-# INLINE charWidth #-}
+ src-ghc/Data/JSString/Internal.hs view
@@ -0,0 +1,1 @@+module Data.JSString.Internal where
+ src-ghc/Data/JSString/Internal/Fusion.hs view
@@ -0,0 +1,127 @@+{-# LANGUAGE BangPatterns, MagicHash+  #-}+module Data.JSString.Internal.Fusion ( -- * Types+                                       Stream(..)+                                     , Step(..)++                                       -- * Creation and elimination+                                     , stream+                                     , unstream+                                     , reverseStream++                                     , length++                                       -- * Transformations+                                     , reverse++                                       -- * Construction+                                       -- ** Scans+                                     , reverseScanr++                                       -- ** Accumulating maps+                                     , mapAccumL++                                       -- ** Generation and unfolding+                                     , unfoldrN++                                       -- * Indexing+                                     , index+                                     , findIndex+                                     , countChar+                                     ) where++--import           GHC.Exts (Char(..), Int(..), chr#, Int#, isTrue#, (-#), (+#), (>=#))++import           Prelude hiding (length, reverse)+import qualified Data.Text.Internal.Fusion as T+--import           Data.Char+import           Data.Coerce (coerce)++import           Data.JSString.Internal.Type (JSString(..))+--import qualified Data.JSString.Internal.Type          as I+import           Data.JSString.Internal.Fusion.Types+import qualified Data.JSString.Internal.Fusion.Common as S++--import           System.IO.Unsafe++--import           GHCJS.Prim++default (Int)++-- | /O(n)/ Convert a 'JSString' into a 'Stream Char'.+stream :: JSString -> Stream Char+stream = coerce T.stream+{-# INLINE [0] stream #-}++-- | /O(n)/ Convert a 'JSString' into a 'Stream Char', but iterate+-- backwards.+reverseStream :: JSString -> Stream Char+reverseStream = coerce T.reverseStream+{-# INLINE [0] reverseStream #-}++-- | /O(n)/ Convert a 'Stream Char' into a 'JSString'.+unstream :: Stream Char -> JSString+unstream = coerce T.unstream+{-# INLINE [0] unstream #-}+{-# RULES "STREAM stream/unstream fusion" forall s. stream (unstream s) = s #-}+++-- ----------------------------------------------------------------------------+-- * Basic stream functions++--runJSString :: ((a -> IO a) -> IO a) -> a+--runJSString f = unsafePerformIO (f pure)++length :: Stream Char -> Int+length = S.lengthI+{-# INLINE[0] length #-}++-- | /O(n)/ Reverse the characters of a string.+reverse :: Stream Char -> JSString+reverse = coerce T.reverse+{-# INLINE [0] reverse #-}++-- | /O(n)/ Perform the equivalent of 'scanr' over a list, only with+-- the input and result reversed.+reverseScanr :: (Char -> Char -> Char) -> Char -> Stream Char -> Stream Char+reverseScanr = coerce T.reverseScanr+{-# INLINE reverseScanr #-}++-- | /O(n)/ Like 'unfoldr', 'unfoldrN' builds a stream from a seed+-- value. However, the length of the result is limited by the+-- first argument to 'unfoldrN'. This function is more efficient than+-- 'unfoldr' when the length of the result is known.+unfoldrN :: Int -> (a -> Maybe (Char,a)) -> a -> Stream Char+unfoldrN n = S.unfoldrNI n+{-# INLINE [0] unfoldrN #-}++-------------------------------------------------------------------------------+-- ** Indexing streams++-- | /O(n)/ stream index (subscript) operator, starting from 0.+index :: Stream Char -> Int -> Char+index = S.indexI+{-# INLINE [0] index #-}++-- | The 'findIndex' function takes a predicate and a stream and+-- returns the index of the first element in the stream+-- satisfying the predicate.+findIndex :: (Char -> Bool) -> Stream Char -> Maybe Int+findIndex = S.findIndexI+{-# INLINE [0] findIndex #-}++-- | /O(n)/ The 'count' function returns the number of times the query+-- element appears in the given stream.+countChar :: Char -> Stream Char -> Int+countChar = S.countCharI+{-# INLINE [0] countChar #-}++-- | /O(n)/ Like a combination of 'map' and 'foldl''. Applies a+-- function to each element of a 'Text', passing an accumulating+-- parameter from left to right, and returns a final 'JSString'.+mapAccumL :: (a -> Char -> (a, Char)) -> a -> Stream Char -> (a, JSString)+mapAccumL a b c = coerce (T.mapAccumL a b c)+{-# INLINE [0] mapAccumL #-}++-------------------------------------------------------------------------------+
+ src-ghc/Data/JSString/Internal/Fusion/CaseMapping.hs view
@@ -0,0 +1,7652 @@+-- AUTOMATICALLY GENERATED - DO NOT EDIT+-- Generated by scripts/CaseMapping.hs+-- CaseFolding-14.0.0.txt+-- Date: 2021-03-08, 19:35:41 GMT+-- SpecialCasing-14.0.0.txt+-- Date: 2021-03-08, 19:35:55 GMT++{-# LANGUAGE LambdaCase, MagicHash, PartialTypeSignatures #-}+{-# OPTIONS_GHC -Wno-partial-type-signatures #-}+module Data.JSString.Internal.Fusion.CaseMapping where+import GHC.Int+import GHC.Exts+unI64 :: Int64 -> _ {- unboxed Int64 -}+unI64 (I64# n) = n++upperMapping :: Char# -> _ {- unboxed Int64 -}+{-# NOINLINE upperMapping #-}+upperMapping = \case+  -- LATIN SMALL LETTER SHARP S+  '\x00df'# -> unI64 174063699+  -- LATIN SMALL LIGATURE FF+  '\xfb00'# -> unI64 146800710+  -- LATIN SMALL LIGATURE FI+  '\xfb01'# -> unI64 153092166+  -- LATIN SMALL LIGATURE FL+  '\xfb02'# -> unI64 159383622+  -- LATIN SMALL LIGATURE FFI+  '\xfb03'# -> unI64 321057542111302+  -- LATIN SMALL LIGATURE FFL+  '\xfb04'# -> unI64 334251681644614+  -- LATIN SMALL LIGATURE LONG S T+  '\xfb05'# -> unI64 176160851+  -- LATIN SMALL LIGATURE ST+  '\xfb06'# -> unI64 176160851+  -- ARMENIAN SMALL LIGATURE ECH YIWN+  '\x0587'# -> unI64 2856322357+  -- ARMENIAN SMALL LIGATURE MEN NOW+  '\xfb13'# -> unI64 2831156548+  -- ARMENIAN SMALL LIGATURE MEN ECH+  '\xfb14'# -> unI64 2795504964+  -- ARMENIAN SMALL LIGATURE MEN INI+  '\xfb15'# -> unI64 2808087876+  -- ARMENIAN SMALL LIGATURE VEW NOW+  '\xfb16'# -> unI64 2831156558+  -- ARMENIAN SMALL LIGATURE MEN XEH+  '\xfb17'# -> unI64 2812282180+  -- LATIN SMALL LETTER N PRECEDED BY APOSTROPHE+  '\x0149'# -> unI64 163578556+  -- GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS+  '\x0390'# -> unI64 3382099394429849+  -- GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS+  '\x03b0'# -> unI64 3382099394429861+  -- LATIN SMALL LETTER J WITH CARON+  '\x01f0'# -> unI64 1635778634+  -- LATIN SMALL LETTER H WITH LINE BELOW+  '\x1e96'# -> unI64 1713373256+  -- LATIN SMALL LETTER T WITH DIAERESIS+  '\x1e97'# -> unI64 1627390036+  -- LATIN SMALL LETTER W WITH RING ABOVE+  '\x1e98'# -> unI64 1631584343+  -- LATIN SMALL LETTER Y WITH RING ABOVE+  '\x1e99'# -> unI64 1631584345+  -- LATIN SMALL LETTER A WITH RIGHT HALF RING+  '\x1e9a'# -> unI64 1472200769+  -- GREEK SMALL LETTER UPSILON WITH PSILI+  '\x1f50'# -> unI64 1650459557+  -- GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA+  '\x1f52'# -> unI64 3377701370987429+  -- GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA+  '\x1f54'# -> unI64 3382099417498533+  -- GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI+  '\x1f56'# -> unI64 3667972440720293+  -- GREEK SMALL LETTER ALPHA WITH PERISPOMENI+  '\x1fb6'# -> unI64 1749025681+  -- GREEK SMALL LETTER ETA WITH PERISPOMENI+  '\x1fc6'# -> unI64 1749025687+  -- GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA+  '\x1fd2'# -> unI64 3377701347918745+  -- GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA+  '\x1fd3'# -> unI64 3382099394429849+  -- GREEK SMALL LETTER IOTA WITH PERISPOMENI+  '\x1fd6'# -> unI64 1749025689+  -- GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI+  '\x1fd7'# -> unI64 3667972417651609+  -- GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA+  '\x1fe2'# -> unI64 3377701347918757+  -- GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA+  '\x1fe3'# -> unI64 3382099394429861+  -- GREEK SMALL LETTER RHO WITH PSILI+  '\x1fe4'# -> unI64 1650459553+  -- GREEK SMALL LETTER UPSILON WITH PERISPOMENI+  '\x1fe6'# -> unI64 1749025701+  -- GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI+  '\x1fe7'# -> unI64 3667972417651621+  -- GREEK SMALL LETTER OMEGA WITH PERISPOMENI+  '\x1ff6'# -> unI64 1749025705+  -- GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI+  '\x1f80'# -> unI64 1931484936+  -- GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI+  '\x1f81'# -> unI64 1931484937+  -- GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI+  '\x1f82'# -> unI64 1931484938+  -- GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI+  '\x1f83'# -> unI64 1931484939+  -- GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI+  '\x1f84'# -> unI64 1931484940+  -- GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI+  '\x1f85'# -> unI64 1931484941+  -- GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI+  '\x1f86'# -> unI64 1931484942+  -- GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI+  '\x1f87'# -> unI64 1931484943+  -- GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI+  '\x1f88'# -> unI64 1931484936+  -- GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI+  '\x1f89'# -> unI64 1931484937+  -- GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI+  '\x1f8a'# -> unI64 1931484938+  -- GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI+  '\x1f8b'# -> unI64 1931484939+  -- GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI+  '\x1f8c'# -> unI64 1931484940+  -- GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI+  '\x1f8d'# -> unI64 1931484941+  -- GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI+  '\x1f8e'# -> unI64 1931484942+  -- GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI+  '\x1f8f'# -> unI64 1931484943+  -- GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI+  '\x1f90'# -> unI64 1931484968+  -- GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI+  '\x1f91'# -> unI64 1931484969+  -- GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI+  '\x1f92'# -> unI64 1931484970+  -- GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI+  '\x1f93'# -> unI64 1931484971+  -- GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI+  '\x1f94'# -> unI64 1931484972+  -- GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI+  '\x1f95'# -> unI64 1931484973+  -- GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI+  '\x1f96'# -> unI64 1931484974+  -- GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI+  '\x1f97'# -> unI64 1931484975+  -- GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI+  '\x1f98'# -> unI64 1931484968+  -- GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI+  '\x1f99'# -> unI64 1931484969+  -- GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI+  '\x1f9a'# -> unI64 1931484970+  -- GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI+  '\x1f9b'# -> unI64 1931484971+  -- GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI+  '\x1f9c'# -> unI64 1931484972+  -- GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI+  '\x1f9d'# -> unI64 1931484973+  -- GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI+  '\x1f9e'# -> unI64 1931484974+  -- GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI+  '\x1f9f'# -> unI64 1931484975+  -- GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI+  '\x1fa0'# -> unI64 1931485032+  -- GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI+  '\x1fa1'# -> unI64 1931485033+  -- GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI+  '\x1fa2'# -> unI64 1931485034+  -- GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI+  '\x1fa3'# -> unI64 1931485035+  -- GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI+  '\x1fa4'# -> unI64 1931485036+  -- GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI+  '\x1fa5'# -> unI64 1931485037+  -- GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI+  '\x1fa6'# -> unI64 1931485038+  -- GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI+  '\x1fa7'# -> unI64 1931485039+  -- GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI+  '\x1fa8'# -> unI64 1931485032+  -- GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI+  '\x1fa9'# -> unI64 1931485033+  -- GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI+  '\x1faa'# -> unI64 1931485034+  -- GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI+  '\x1fab'# -> unI64 1931485035+  -- GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI+  '\x1fac'# -> unI64 1931485036+  -- GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI+  '\x1fad'# -> unI64 1931485037+  -- GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI+  '\x1fae'# -> unI64 1931485038+  -- GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI+  '\x1faf'# -> unI64 1931485039+  -- GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI+  '\x1fb3'# -> unI64 1931477905+  -- GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI+  '\x1fbc'# -> unI64 1931477905+  -- GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI+  '\x1fc3'# -> unI64 1931477911+  -- GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI+  '\x1fcc'# -> unI64 1931477911+  -- GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI+  '\x1ff3'# -> unI64 1931477929+  -- GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI+  '\x1ffc'# -> unI64 1931477929+  -- GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI+  '\x1fb2'# -> unI64 1931485114+  -- GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI+  '\x1fb4'# -> unI64 1931477894+  -- GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI+  '\x1fc2'# -> unI64 1931485130+  -- GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI+  '\x1fc4'# -> unI64 1931477897+  -- GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI+  '\x1ff2'# -> unI64 1931485178+  -- GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI+  '\x1ff4'# -> unI64 1931477903+  -- GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI+  '\x1fb7'# -> unI64 4050602585752465+  -- GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI+  '\x1fc7'# -> unI64 4050602585752471+  -- GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI+  '\x1ff7'# -> unI64 4050602585752489+  '\x0061'# -> unI64 65+  '\x0062'# -> unI64 66+  '\x0063'# -> unI64 67+  '\x0064'# -> unI64 68+  '\x0065'# -> unI64 69+  '\x0066'# -> unI64 70+  '\x0067'# -> unI64 71+  '\x0068'# -> unI64 72+  '\x0069'# -> unI64 73+  '\x006a'# -> unI64 74+  '\x006b'# -> unI64 75+  '\x006c'# -> unI64 76+  '\x006d'# -> unI64 77+  '\x006e'# -> unI64 78+  '\x006f'# -> unI64 79+  '\x0070'# -> unI64 80+  '\x0071'# -> unI64 81+  '\x0072'# -> unI64 82+  '\x0073'# -> unI64 83+  '\x0074'# -> unI64 84+  '\x0075'# -> unI64 85+  '\x0076'# -> unI64 86+  '\x0077'# -> unI64 87+  '\x0078'# -> unI64 88+  '\x0079'# -> unI64 89+  '\x007a'# -> unI64 90+  '\x00b5'# -> unI64 924+  '\x00e0'# -> unI64 192+  '\x00e1'# -> unI64 193+  '\x00e2'# -> unI64 194+  '\x00e3'# -> unI64 195+  '\x00e4'# -> unI64 196+  '\x00e5'# -> unI64 197+  '\x00e6'# -> unI64 198+  '\x00e7'# -> unI64 199+  '\x00e8'# -> unI64 200+  '\x00e9'# -> unI64 201+  '\x00ea'# -> unI64 202+  '\x00eb'# -> unI64 203+  '\x00ec'# -> unI64 204+  '\x00ed'# -> unI64 205+  '\x00ee'# -> unI64 206+  '\x00ef'# -> unI64 207+  '\x00f0'# -> unI64 208+  '\x00f1'# -> unI64 209+  '\x00f2'# -> unI64 210+  '\x00f3'# -> unI64 211+  '\x00f4'# -> unI64 212+  '\x00f5'# -> unI64 213+  '\x00f6'# -> unI64 214+  '\x00f8'# -> unI64 216+  '\x00f9'# -> unI64 217+  '\x00fa'# -> unI64 218+  '\x00fb'# -> unI64 219+  '\x00fc'# -> unI64 220+  '\x00fd'# -> unI64 221+  '\x00fe'# -> unI64 222+  '\x00ff'# -> unI64 376+  '\x0101'# -> unI64 256+  '\x0103'# -> unI64 258+  '\x0105'# -> unI64 260+  '\x0107'# -> unI64 262+  '\x0109'# -> unI64 264+  '\x010b'# -> unI64 266+  '\x010d'# -> unI64 268+  '\x010f'# -> unI64 270+  '\x0111'# -> unI64 272+  '\x0113'# -> unI64 274+  '\x0115'# -> unI64 276+  '\x0117'# -> unI64 278+  '\x0119'# -> unI64 280+  '\x011b'# -> unI64 282+  '\x011d'# -> unI64 284+  '\x011f'# -> unI64 286+  '\x0121'# -> unI64 288+  '\x0123'# -> unI64 290+  '\x0125'# -> unI64 292+  '\x0127'# -> unI64 294+  '\x0129'# -> unI64 296+  '\x012b'# -> unI64 298+  '\x012d'# -> unI64 300+  '\x012f'# -> unI64 302+  '\x0131'# -> unI64 73+  '\x0133'# -> unI64 306+  '\x0135'# -> unI64 308+  '\x0137'# -> unI64 310+  '\x013a'# -> unI64 313+  '\x013c'# -> unI64 315+  '\x013e'# -> unI64 317+  '\x0140'# -> unI64 319+  '\x0142'# -> unI64 321+  '\x0144'# -> unI64 323+  '\x0146'# -> unI64 325+  '\x0148'# -> unI64 327+  '\x014b'# -> unI64 330+  '\x014d'# -> unI64 332+  '\x014f'# -> unI64 334+  '\x0151'# -> unI64 336+  '\x0153'# -> unI64 338+  '\x0155'# -> unI64 340+  '\x0157'# -> unI64 342+  '\x0159'# -> unI64 344+  '\x015b'# -> unI64 346+  '\x015d'# -> unI64 348+  '\x015f'# -> unI64 350+  '\x0161'# -> unI64 352+  '\x0163'# -> unI64 354+  '\x0165'# -> unI64 356+  '\x0167'# -> unI64 358+  '\x0169'# -> unI64 360+  '\x016b'# -> unI64 362+  '\x016d'# -> unI64 364+  '\x016f'# -> unI64 366+  '\x0171'# -> unI64 368+  '\x0173'# -> unI64 370+  '\x0175'# -> unI64 372+  '\x0177'# -> unI64 374+  '\x017a'# -> unI64 377+  '\x017c'# -> unI64 379+  '\x017e'# -> unI64 381+  '\x017f'# -> unI64 83+  '\x0180'# -> unI64 579+  '\x0183'# -> unI64 386+  '\x0185'# -> unI64 388+  '\x0188'# -> unI64 391+  '\x018c'# -> unI64 395+  '\x0192'# -> unI64 401+  '\x0195'# -> unI64 502+  '\x0199'# -> unI64 408+  '\x019a'# -> unI64 573+  '\x019e'# -> unI64 544+  '\x01a1'# -> unI64 416+  '\x01a3'# -> unI64 418+  '\x01a5'# -> unI64 420+  '\x01a8'# -> unI64 423+  '\x01ad'# -> unI64 428+  '\x01b0'# -> unI64 431+  '\x01b4'# -> unI64 435+  '\x01b6'# -> unI64 437+  '\x01b9'# -> unI64 440+  '\x01bd'# -> unI64 444+  '\x01bf'# -> unI64 503+  '\x01c5'# -> unI64 452+  '\x01c6'# -> unI64 452+  '\x01c8'# -> unI64 455+  '\x01c9'# -> unI64 455+  '\x01cb'# -> unI64 458+  '\x01cc'# -> unI64 458+  '\x01ce'# -> unI64 461+  '\x01d0'# -> unI64 463+  '\x01d2'# -> unI64 465+  '\x01d4'# -> unI64 467+  '\x01d6'# -> unI64 469+  '\x01d8'# -> unI64 471+  '\x01da'# -> unI64 473+  '\x01dc'# -> unI64 475+  '\x01dd'# -> unI64 398+  '\x01df'# -> unI64 478+  '\x01e1'# -> unI64 480+  '\x01e3'# -> unI64 482+  '\x01e5'# -> unI64 484+  '\x01e7'# -> unI64 486+  '\x01e9'# -> unI64 488+  '\x01eb'# -> unI64 490+  '\x01ed'# -> unI64 492+  '\x01ef'# -> unI64 494+  '\x01f2'# -> unI64 497+  '\x01f3'# -> unI64 497+  '\x01f5'# -> unI64 500+  '\x01f9'# -> unI64 504+  '\x01fb'# -> unI64 506+  '\x01fd'# -> unI64 508+  '\x01ff'# -> unI64 510+  '\x0201'# -> unI64 512+  '\x0203'# -> unI64 514+  '\x0205'# -> unI64 516+  '\x0207'# -> unI64 518+  '\x0209'# -> unI64 520+  '\x020b'# -> unI64 522+  '\x020d'# -> unI64 524+  '\x020f'# -> unI64 526+  '\x0211'# -> unI64 528+  '\x0213'# -> unI64 530+  '\x0215'# -> unI64 532+  '\x0217'# -> unI64 534+  '\x0219'# -> unI64 536+  '\x021b'# -> unI64 538+  '\x021d'# -> unI64 540+  '\x021f'# -> unI64 542+  '\x0223'# -> unI64 546+  '\x0225'# -> unI64 548+  '\x0227'# -> unI64 550+  '\x0229'# -> unI64 552+  '\x022b'# -> unI64 554+  '\x022d'# -> unI64 556+  '\x022f'# -> unI64 558+  '\x0231'# -> unI64 560+  '\x0233'# -> unI64 562+  '\x023c'# -> unI64 571+  '\x023f'# -> unI64 11390+  '\x0240'# -> unI64 11391+  '\x0242'# -> unI64 577+  '\x0247'# -> unI64 582+  '\x0249'# -> unI64 584+  '\x024b'# -> unI64 586+  '\x024d'# -> unI64 588+  '\x024f'# -> unI64 590+  '\x0250'# -> unI64 11375+  '\x0251'# -> unI64 11373+  '\x0252'# -> unI64 11376+  '\x0253'# -> unI64 385+  '\x0254'# -> unI64 390+  '\x0256'# -> unI64 393+  '\x0257'# -> unI64 394+  '\x0259'# -> unI64 399+  '\x025b'# -> unI64 400+  '\x025c'# -> unI64 42923+  '\x0260'# -> unI64 403+  '\x0261'# -> unI64 42924+  '\x0263'# -> unI64 404+  '\x0265'# -> unI64 42893+  '\x0266'# -> unI64 42922+  '\x0268'# -> unI64 407+  '\x0269'# -> unI64 406+  '\x026a'# -> unI64 42926+  '\x026b'# -> unI64 11362+  '\x026c'# -> unI64 42925+  '\x026f'# -> unI64 412+  '\x0271'# -> unI64 11374+  '\x0272'# -> unI64 413+  '\x0275'# -> unI64 415+  '\x027d'# -> unI64 11364+  '\x0280'# -> unI64 422+  '\x0282'# -> unI64 42949+  '\x0283'# -> unI64 425+  '\x0287'# -> unI64 42929+  '\x0288'# -> unI64 430+  '\x0289'# -> unI64 580+  '\x028a'# -> unI64 433+  '\x028b'# -> unI64 434+  '\x028c'# -> unI64 581+  '\x0292'# -> unI64 439+  '\x029d'# -> unI64 42930+  '\x029e'# -> unI64 42928+  '\x0345'# -> unI64 921+  '\x0371'# -> unI64 880+  '\x0373'# -> unI64 882+  '\x0377'# -> unI64 886+  '\x037b'# -> unI64 1021+  '\x037c'# -> unI64 1022+  '\x037d'# -> unI64 1023+  '\x03ac'# -> unI64 902+  '\x03ad'# -> unI64 904+  '\x03ae'# -> unI64 905+  '\x03af'# -> unI64 906+  '\x03b1'# -> unI64 913+  '\x03b2'# -> unI64 914+  '\x03b3'# -> unI64 915+  '\x03b4'# -> unI64 916+  '\x03b5'# -> unI64 917+  '\x03b6'# -> unI64 918+  '\x03b7'# -> unI64 919+  '\x03b8'# -> unI64 920+  '\x03b9'# -> unI64 921+  '\x03ba'# -> unI64 922+  '\x03bb'# -> unI64 923+  '\x03bc'# -> unI64 924+  '\x03bd'# -> unI64 925+  '\x03be'# -> unI64 926+  '\x03bf'# -> unI64 927+  '\x03c0'# -> unI64 928+  '\x03c1'# -> unI64 929+  '\x03c2'# -> unI64 931+  '\x03c3'# -> unI64 931+  '\x03c4'# -> unI64 932+  '\x03c5'# -> unI64 933+  '\x03c6'# -> unI64 934+  '\x03c7'# -> unI64 935+  '\x03c8'# -> unI64 936+  '\x03c9'# -> unI64 937+  '\x03ca'# -> unI64 938+  '\x03cb'# -> unI64 939+  '\x03cc'# -> unI64 908+  '\x03cd'# -> unI64 910+  '\x03ce'# -> unI64 911+  '\x03d0'# -> unI64 914+  '\x03d1'# -> unI64 920+  '\x03d5'# -> unI64 934+  '\x03d6'# -> unI64 928+  '\x03d7'# -> unI64 975+  '\x03d9'# -> unI64 984+  '\x03db'# -> unI64 986+  '\x03dd'# -> unI64 988+  '\x03df'# -> unI64 990+  '\x03e1'# -> unI64 992+  '\x03e3'# -> unI64 994+  '\x03e5'# -> unI64 996+  '\x03e7'# -> unI64 998+  '\x03e9'# -> unI64 1000+  '\x03eb'# -> unI64 1002+  '\x03ed'# -> unI64 1004+  '\x03ef'# -> unI64 1006+  '\x03f0'# -> unI64 922+  '\x03f1'# -> unI64 929+  '\x03f2'# -> unI64 1017+  '\x03f3'# -> unI64 895+  '\x03f5'# -> unI64 917+  '\x03f8'# -> unI64 1015+  '\x03fb'# -> unI64 1018+  '\x0430'# -> unI64 1040+  '\x0431'# -> unI64 1041+  '\x0432'# -> unI64 1042+  '\x0433'# -> unI64 1043+  '\x0434'# -> unI64 1044+  '\x0435'# -> unI64 1045+  '\x0436'# -> unI64 1046+  '\x0437'# -> unI64 1047+  '\x0438'# -> unI64 1048+  '\x0439'# -> unI64 1049+  '\x043a'# -> unI64 1050+  '\x043b'# -> unI64 1051+  '\x043c'# -> unI64 1052+  '\x043d'# -> unI64 1053+  '\x043e'# -> unI64 1054+  '\x043f'# -> unI64 1055+  '\x0440'# -> unI64 1056+  '\x0441'# -> unI64 1057+  '\x0442'# -> unI64 1058+  '\x0443'# -> unI64 1059+  '\x0444'# -> unI64 1060+  '\x0445'# -> unI64 1061+  '\x0446'# -> unI64 1062+  '\x0447'# -> unI64 1063+  '\x0448'# -> unI64 1064+  '\x0449'# -> unI64 1065+  '\x044a'# -> unI64 1066+  '\x044b'# -> unI64 1067+  '\x044c'# -> unI64 1068+  '\x044d'# -> unI64 1069+  '\x044e'# -> unI64 1070+  '\x044f'# -> unI64 1071+  '\x0450'# -> unI64 1024+  '\x0451'# -> unI64 1025+  '\x0452'# -> unI64 1026+  '\x0453'# -> unI64 1027+  '\x0454'# -> unI64 1028+  '\x0455'# -> unI64 1029+  '\x0456'# -> unI64 1030+  '\x0457'# -> unI64 1031+  '\x0458'# -> unI64 1032+  '\x0459'# -> unI64 1033+  '\x045a'# -> unI64 1034+  '\x045b'# -> unI64 1035+  '\x045c'# -> unI64 1036+  '\x045d'# -> unI64 1037+  '\x045e'# -> unI64 1038+  '\x045f'# -> unI64 1039+  '\x0461'# -> unI64 1120+  '\x0463'# -> unI64 1122+  '\x0465'# -> unI64 1124+  '\x0467'# -> unI64 1126+  '\x0469'# -> unI64 1128+  '\x046b'# -> unI64 1130+  '\x046d'# -> unI64 1132+  '\x046f'# -> unI64 1134+  '\x0471'# -> unI64 1136+  '\x0473'# -> unI64 1138+  '\x0475'# -> unI64 1140+  '\x0477'# -> unI64 1142+  '\x0479'# -> unI64 1144+  '\x047b'# -> unI64 1146+  '\x047d'# -> unI64 1148+  '\x047f'# -> unI64 1150+  '\x0481'# -> unI64 1152+  '\x048b'# -> unI64 1162+  '\x048d'# -> unI64 1164+  '\x048f'# -> unI64 1166+  '\x0491'# -> unI64 1168+  '\x0493'# -> unI64 1170+  '\x0495'# -> unI64 1172+  '\x0497'# -> unI64 1174+  '\x0499'# -> unI64 1176+  '\x049b'# -> unI64 1178+  '\x049d'# -> unI64 1180+  '\x049f'# -> unI64 1182+  '\x04a1'# -> unI64 1184+  '\x04a3'# -> unI64 1186+  '\x04a5'# -> unI64 1188+  '\x04a7'# -> unI64 1190+  '\x04a9'# -> unI64 1192+  '\x04ab'# -> unI64 1194+  '\x04ad'# -> unI64 1196+  '\x04af'# -> unI64 1198+  '\x04b1'# -> unI64 1200+  '\x04b3'# -> unI64 1202+  '\x04b5'# -> unI64 1204+  '\x04b7'# -> unI64 1206+  '\x04b9'# -> unI64 1208+  '\x04bb'# -> unI64 1210+  '\x04bd'# -> unI64 1212+  '\x04bf'# -> unI64 1214+  '\x04c2'# -> unI64 1217+  '\x04c4'# -> unI64 1219+  '\x04c6'# -> unI64 1221+  '\x04c8'# -> unI64 1223+  '\x04ca'# -> unI64 1225+  '\x04cc'# -> unI64 1227+  '\x04ce'# -> unI64 1229+  '\x04cf'# -> unI64 1216+  '\x04d1'# -> unI64 1232+  '\x04d3'# -> unI64 1234+  '\x04d5'# -> unI64 1236+  '\x04d7'# -> unI64 1238+  '\x04d9'# -> unI64 1240+  '\x04db'# -> unI64 1242+  '\x04dd'# -> unI64 1244+  '\x04df'# -> unI64 1246+  '\x04e1'# -> unI64 1248+  '\x04e3'# -> unI64 1250+  '\x04e5'# -> unI64 1252+  '\x04e7'# -> unI64 1254+  '\x04e9'# -> unI64 1256+  '\x04eb'# -> unI64 1258+  '\x04ed'# -> unI64 1260+  '\x04ef'# -> unI64 1262+  '\x04f1'# -> unI64 1264+  '\x04f3'# -> unI64 1266+  '\x04f5'# -> unI64 1268+  '\x04f7'# -> unI64 1270+  '\x04f9'# -> unI64 1272+  '\x04fb'# -> unI64 1274+  '\x04fd'# -> unI64 1276+  '\x04ff'# -> unI64 1278+  '\x0501'# -> unI64 1280+  '\x0503'# -> unI64 1282+  '\x0505'# -> unI64 1284+  '\x0507'# -> unI64 1286+  '\x0509'# -> unI64 1288+  '\x050b'# -> unI64 1290+  '\x050d'# -> unI64 1292+  '\x050f'# -> unI64 1294+  '\x0511'# -> unI64 1296+  '\x0513'# -> unI64 1298+  '\x0515'# -> unI64 1300+  '\x0517'# -> unI64 1302+  '\x0519'# -> unI64 1304+  '\x051b'# -> unI64 1306+  '\x051d'# -> unI64 1308+  '\x051f'# -> unI64 1310+  '\x0521'# -> unI64 1312+  '\x0523'# -> unI64 1314+  '\x0525'# -> unI64 1316+  '\x0527'# -> unI64 1318+  '\x0529'# -> unI64 1320+  '\x052b'# -> unI64 1322+  '\x052d'# -> unI64 1324+  '\x052f'# -> unI64 1326+  '\x0561'# -> unI64 1329+  '\x0562'# -> unI64 1330+  '\x0563'# -> unI64 1331+  '\x0564'# -> unI64 1332+  '\x0565'# -> unI64 1333+  '\x0566'# -> unI64 1334+  '\x0567'# -> unI64 1335+  '\x0568'# -> unI64 1336+  '\x0569'# -> unI64 1337+  '\x056a'# -> unI64 1338+  '\x056b'# -> unI64 1339+  '\x056c'# -> unI64 1340+  '\x056d'# -> unI64 1341+  '\x056e'# -> unI64 1342+  '\x056f'# -> unI64 1343+  '\x0570'# -> unI64 1344+  '\x0571'# -> unI64 1345+  '\x0572'# -> unI64 1346+  '\x0573'# -> unI64 1347+  '\x0574'# -> unI64 1348+  '\x0575'# -> unI64 1349+  '\x0576'# -> unI64 1350+  '\x0577'# -> unI64 1351+  '\x0578'# -> unI64 1352+  '\x0579'# -> unI64 1353+  '\x057a'# -> unI64 1354+  '\x057b'# -> unI64 1355+  '\x057c'# -> unI64 1356+  '\x057d'# -> unI64 1357+  '\x057e'# -> unI64 1358+  '\x057f'# -> unI64 1359+  '\x0580'# -> unI64 1360+  '\x0581'# -> unI64 1361+  '\x0582'# -> unI64 1362+  '\x0583'# -> unI64 1363+  '\x0584'# -> unI64 1364+  '\x0585'# -> unI64 1365+  '\x0586'# -> unI64 1366+  '\x10d0'# -> unI64 7312+  '\x10d1'# -> unI64 7313+  '\x10d2'# -> unI64 7314+  '\x10d3'# -> unI64 7315+  '\x10d4'# -> unI64 7316+  '\x10d5'# -> unI64 7317+  '\x10d6'# -> unI64 7318+  '\x10d7'# -> unI64 7319+  '\x10d8'# -> unI64 7320+  '\x10d9'# -> unI64 7321+  '\x10da'# -> unI64 7322+  '\x10db'# -> unI64 7323+  '\x10dc'# -> unI64 7324+  '\x10dd'# -> unI64 7325+  '\x10de'# -> unI64 7326+  '\x10df'# -> unI64 7327+  '\x10e0'# -> unI64 7328+  '\x10e1'# -> unI64 7329+  '\x10e2'# -> unI64 7330+  '\x10e3'# -> unI64 7331+  '\x10e4'# -> unI64 7332+  '\x10e5'# -> unI64 7333+  '\x10e6'# -> unI64 7334+  '\x10e7'# -> unI64 7335+  '\x10e8'# -> unI64 7336+  '\x10e9'# -> unI64 7337+  '\x10ea'# -> unI64 7338+  '\x10eb'# -> unI64 7339+  '\x10ec'# -> unI64 7340+  '\x10ed'# -> unI64 7341+  '\x10ee'# -> unI64 7342+  '\x10ef'# -> unI64 7343+  '\x10f0'# -> unI64 7344+  '\x10f1'# -> unI64 7345+  '\x10f2'# -> unI64 7346+  '\x10f3'# -> unI64 7347+  '\x10f4'# -> unI64 7348+  '\x10f5'# -> unI64 7349+  '\x10f6'# -> unI64 7350+  '\x10f7'# -> unI64 7351+  '\x10f8'# -> unI64 7352+  '\x10f9'# -> unI64 7353+  '\x10fa'# -> unI64 7354+  '\x10fd'# -> unI64 7357+  '\x10fe'# -> unI64 7358+  '\x10ff'# -> unI64 7359+  '\x13f8'# -> unI64 5104+  '\x13f9'# -> unI64 5105+  '\x13fa'# -> unI64 5106+  '\x13fb'# -> unI64 5107+  '\x13fc'# -> unI64 5108+  '\x13fd'# -> unI64 5109+  '\x1c80'# -> unI64 1042+  '\x1c81'# -> unI64 1044+  '\x1c82'# -> unI64 1054+  '\x1c83'# -> unI64 1057+  '\x1c84'# -> unI64 1058+  '\x1c85'# -> unI64 1058+  '\x1c86'# -> unI64 1066+  '\x1c87'# -> unI64 1122+  '\x1c88'# -> unI64 42570+  '\x1d79'# -> unI64 42877+  '\x1d7d'# -> unI64 11363+  '\x1d8e'# -> unI64 42950+  '\x1e01'# -> unI64 7680+  '\x1e03'# -> unI64 7682+  '\x1e05'# -> unI64 7684+  '\x1e07'# -> unI64 7686+  '\x1e09'# -> unI64 7688+  '\x1e0b'# -> unI64 7690+  '\x1e0d'# -> unI64 7692+  '\x1e0f'# -> unI64 7694+  '\x1e11'# -> unI64 7696+  '\x1e13'# -> unI64 7698+  '\x1e15'# -> unI64 7700+  '\x1e17'# -> unI64 7702+  '\x1e19'# -> unI64 7704+  '\x1e1b'# -> unI64 7706+  '\x1e1d'# -> unI64 7708+  '\x1e1f'# -> unI64 7710+  '\x1e21'# -> unI64 7712+  '\x1e23'# -> unI64 7714+  '\x1e25'# -> unI64 7716+  '\x1e27'# -> unI64 7718+  '\x1e29'# -> unI64 7720+  '\x1e2b'# -> unI64 7722+  '\x1e2d'# -> unI64 7724+  '\x1e2f'# -> unI64 7726+  '\x1e31'# -> unI64 7728+  '\x1e33'# -> unI64 7730+  '\x1e35'# -> unI64 7732+  '\x1e37'# -> unI64 7734+  '\x1e39'# -> unI64 7736+  '\x1e3b'# -> unI64 7738+  '\x1e3d'# -> unI64 7740+  '\x1e3f'# -> unI64 7742+  '\x1e41'# -> unI64 7744+  '\x1e43'# -> unI64 7746+  '\x1e45'# -> unI64 7748+  '\x1e47'# -> unI64 7750+  '\x1e49'# -> unI64 7752+  '\x1e4b'# -> unI64 7754+  '\x1e4d'# -> unI64 7756+  '\x1e4f'# -> unI64 7758+  '\x1e51'# -> unI64 7760+  '\x1e53'# -> unI64 7762+  '\x1e55'# -> unI64 7764+  '\x1e57'# -> unI64 7766+  '\x1e59'# -> unI64 7768+  '\x1e5b'# -> unI64 7770+  '\x1e5d'# -> unI64 7772+  '\x1e5f'# -> unI64 7774+  '\x1e61'# -> unI64 7776+  '\x1e63'# -> unI64 7778+  '\x1e65'# -> unI64 7780+  '\x1e67'# -> unI64 7782+  '\x1e69'# -> unI64 7784+  '\x1e6b'# -> unI64 7786+  '\x1e6d'# -> unI64 7788+  '\x1e6f'# -> unI64 7790+  '\x1e71'# -> unI64 7792+  '\x1e73'# -> unI64 7794+  '\x1e75'# -> unI64 7796+  '\x1e77'# -> unI64 7798+  '\x1e79'# -> unI64 7800+  '\x1e7b'# -> unI64 7802+  '\x1e7d'# -> unI64 7804+  '\x1e7f'# -> unI64 7806+  '\x1e81'# -> unI64 7808+  '\x1e83'# -> unI64 7810+  '\x1e85'# -> unI64 7812+  '\x1e87'# -> unI64 7814+  '\x1e89'# -> unI64 7816+  '\x1e8b'# -> unI64 7818+  '\x1e8d'# -> unI64 7820+  '\x1e8f'# -> unI64 7822+  '\x1e91'# -> unI64 7824+  '\x1e93'# -> unI64 7826+  '\x1e95'# -> unI64 7828+  '\x1e9b'# -> unI64 7776+  '\x1ea1'# -> unI64 7840+  '\x1ea3'# -> unI64 7842+  '\x1ea5'# -> unI64 7844+  '\x1ea7'# -> unI64 7846+  '\x1ea9'# -> unI64 7848+  '\x1eab'# -> unI64 7850+  '\x1ead'# -> unI64 7852+  '\x1eaf'# -> unI64 7854+  '\x1eb1'# -> unI64 7856+  '\x1eb3'# -> unI64 7858+  '\x1eb5'# -> unI64 7860+  '\x1eb7'# -> unI64 7862+  '\x1eb9'# -> unI64 7864+  '\x1ebb'# -> unI64 7866+  '\x1ebd'# -> unI64 7868+  '\x1ebf'# -> unI64 7870+  '\x1ec1'# -> unI64 7872+  '\x1ec3'# -> unI64 7874+  '\x1ec5'# -> unI64 7876+  '\x1ec7'# -> unI64 7878+  '\x1ec9'# -> unI64 7880+  '\x1ecb'# -> unI64 7882+  '\x1ecd'# -> unI64 7884+  '\x1ecf'# -> unI64 7886+  '\x1ed1'# -> unI64 7888+  '\x1ed3'# -> unI64 7890+  '\x1ed5'# -> unI64 7892+  '\x1ed7'# -> unI64 7894+  '\x1ed9'# -> unI64 7896+  '\x1edb'# -> unI64 7898+  '\x1edd'# -> unI64 7900+  '\x1edf'# -> unI64 7902+  '\x1ee1'# -> unI64 7904+  '\x1ee3'# -> unI64 7906+  '\x1ee5'# -> unI64 7908+  '\x1ee7'# -> unI64 7910+  '\x1ee9'# -> unI64 7912+  '\x1eeb'# -> unI64 7914+  '\x1eed'# -> unI64 7916+  '\x1eef'# -> unI64 7918+  '\x1ef1'# -> unI64 7920+  '\x1ef3'# -> unI64 7922+  '\x1ef5'# -> unI64 7924+  '\x1ef7'# -> unI64 7926+  '\x1ef9'# -> unI64 7928+  '\x1efb'# -> unI64 7930+  '\x1efd'# -> unI64 7932+  '\x1eff'# -> unI64 7934+  '\x1f00'# -> unI64 7944+  '\x1f01'# -> unI64 7945+  '\x1f02'# -> unI64 7946+  '\x1f03'# -> unI64 7947+  '\x1f04'# -> unI64 7948+  '\x1f05'# -> unI64 7949+  '\x1f06'# -> unI64 7950+  '\x1f07'# -> unI64 7951+  '\x1f10'# -> unI64 7960+  '\x1f11'# -> unI64 7961+  '\x1f12'# -> unI64 7962+  '\x1f13'# -> unI64 7963+  '\x1f14'# -> unI64 7964+  '\x1f15'# -> unI64 7965+  '\x1f20'# -> unI64 7976+  '\x1f21'# -> unI64 7977+  '\x1f22'# -> unI64 7978+  '\x1f23'# -> unI64 7979+  '\x1f24'# -> unI64 7980+  '\x1f25'# -> unI64 7981+  '\x1f26'# -> unI64 7982+  '\x1f27'# -> unI64 7983+  '\x1f30'# -> unI64 7992+  '\x1f31'# -> unI64 7993+  '\x1f32'# -> unI64 7994+  '\x1f33'# -> unI64 7995+  '\x1f34'# -> unI64 7996+  '\x1f35'# -> unI64 7997+  '\x1f36'# -> unI64 7998+  '\x1f37'# -> unI64 7999+  '\x1f40'# -> unI64 8008+  '\x1f41'# -> unI64 8009+  '\x1f42'# -> unI64 8010+  '\x1f43'# -> unI64 8011+  '\x1f44'# -> unI64 8012+  '\x1f45'# -> unI64 8013+  '\x1f51'# -> unI64 8025+  '\x1f53'# -> unI64 8027+  '\x1f55'# -> unI64 8029+  '\x1f57'# -> unI64 8031+  '\x1f60'# -> unI64 8040+  '\x1f61'# -> unI64 8041+  '\x1f62'# -> unI64 8042+  '\x1f63'# -> unI64 8043+  '\x1f64'# -> unI64 8044+  '\x1f65'# -> unI64 8045+  '\x1f66'# -> unI64 8046+  '\x1f67'# -> unI64 8047+  '\x1f70'# -> unI64 8122+  '\x1f71'# -> unI64 8123+  '\x1f72'# -> unI64 8136+  '\x1f73'# -> unI64 8137+  '\x1f74'# -> unI64 8138+  '\x1f75'# -> unI64 8139+  '\x1f76'# -> unI64 8154+  '\x1f77'# -> unI64 8155+  '\x1f78'# -> unI64 8184+  '\x1f79'# -> unI64 8185+  '\x1f7a'# -> unI64 8170+  '\x1f7b'# -> unI64 8171+  '\x1f7c'# -> unI64 8186+  '\x1f7d'# -> unI64 8187+  '\x1fb0'# -> unI64 8120+  '\x1fb1'# -> unI64 8121+  '\x1fbe'# -> unI64 921+  '\x1fd0'# -> unI64 8152+  '\x1fd1'# -> unI64 8153+  '\x1fe0'# -> unI64 8168+  '\x1fe1'# -> unI64 8169+  '\x1fe5'# -> unI64 8172+  '\x214e'# -> unI64 8498+  '\x2170'# -> unI64 8544+  '\x2171'# -> unI64 8545+  '\x2172'# -> unI64 8546+  '\x2173'# -> unI64 8547+  '\x2174'# -> unI64 8548+  '\x2175'# -> unI64 8549+  '\x2176'# -> unI64 8550+  '\x2177'# -> unI64 8551+  '\x2178'# -> unI64 8552+  '\x2179'# -> unI64 8553+  '\x217a'# -> unI64 8554+  '\x217b'# -> unI64 8555+  '\x217c'# -> unI64 8556+  '\x217d'# -> unI64 8557+  '\x217e'# -> unI64 8558+  '\x217f'# -> unI64 8559+  '\x2184'# -> unI64 8579+  '\x24d0'# -> unI64 9398+  '\x24d1'# -> unI64 9399+  '\x24d2'# -> unI64 9400+  '\x24d3'# -> unI64 9401+  '\x24d4'# -> unI64 9402+  '\x24d5'# -> unI64 9403+  '\x24d6'# -> unI64 9404+  '\x24d7'# -> unI64 9405+  '\x24d8'# -> unI64 9406+  '\x24d9'# -> unI64 9407+  '\x24da'# -> unI64 9408+  '\x24db'# -> unI64 9409+  '\x24dc'# -> unI64 9410+  '\x24dd'# -> unI64 9411+  '\x24de'# -> unI64 9412+  '\x24df'# -> unI64 9413+  '\x24e0'# -> unI64 9414+  '\x24e1'# -> unI64 9415+  '\x24e2'# -> unI64 9416+  '\x24e3'# -> unI64 9417+  '\x24e4'# -> unI64 9418+  '\x24e5'# -> unI64 9419+  '\x24e6'# -> unI64 9420+  '\x24e7'# -> unI64 9421+  '\x24e8'# -> unI64 9422+  '\x24e9'# -> unI64 9423+  '\x2c30'# -> unI64 11264+  '\x2c31'# -> unI64 11265+  '\x2c32'# -> unI64 11266+  '\x2c33'# -> unI64 11267+  '\x2c34'# -> unI64 11268+  '\x2c35'# -> unI64 11269+  '\x2c36'# -> unI64 11270+  '\x2c37'# -> unI64 11271+  '\x2c38'# -> unI64 11272+  '\x2c39'# -> unI64 11273+  '\x2c3a'# -> unI64 11274+  '\x2c3b'# -> unI64 11275+  '\x2c3c'# -> unI64 11276+  '\x2c3d'# -> unI64 11277+  '\x2c3e'# -> unI64 11278+  '\x2c3f'# -> unI64 11279+  '\x2c40'# -> unI64 11280+  '\x2c41'# -> unI64 11281+  '\x2c42'# -> unI64 11282+  '\x2c43'# -> unI64 11283+  '\x2c44'# -> unI64 11284+  '\x2c45'# -> unI64 11285+  '\x2c46'# -> unI64 11286+  '\x2c47'# -> unI64 11287+  '\x2c48'# -> unI64 11288+  '\x2c49'# -> unI64 11289+  '\x2c4a'# -> unI64 11290+  '\x2c4b'# -> unI64 11291+  '\x2c4c'# -> unI64 11292+  '\x2c4d'# -> unI64 11293+  '\x2c4e'# -> unI64 11294+  '\x2c4f'# -> unI64 11295+  '\x2c50'# -> unI64 11296+  '\x2c51'# -> unI64 11297+  '\x2c52'# -> unI64 11298+  '\x2c53'# -> unI64 11299+  '\x2c54'# -> unI64 11300+  '\x2c55'# -> unI64 11301+  '\x2c56'# -> unI64 11302+  '\x2c57'# -> unI64 11303+  '\x2c58'# -> unI64 11304+  '\x2c59'# -> unI64 11305+  '\x2c5a'# -> unI64 11306+  '\x2c5b'# -> unI64 11307+  '\x2c5c'# -> unI64 11308+  '\x2c5d'# -> unI64 11309+  '\x2c5e'# -> unI64 11310+  '\x2c5f'# -> unI64 11311+  '\x2c61'# -> unI64 11360+  '\x2c65'# -> unI64 570+  '\x2c66'# -> unI64 574+  '\x2c68'# -> unI64 11367+  '\x2c6a'# -> unI64 11369+  '\x2c6c'# -> unI64 11371+  '\x2c73'# -> unI64 11378+  '\x2c76'# -> unI64 11381+  '\x2c81'# -> unI64 11392+  '\x2c83'# -> unI64 11394+  '\x2c85'# -> unI64 11396+  '\x2c87'# -> unI64 11398+  '\x2c89'# -> unI64 11400+  '\x2c8b'# -> unI64 11402+  '\x2c8d'# -> unI64 11404+  '\x2c8f'# -> unI64 11406+  '\x2c91'# -> unI64 11408+  '\x2c93'# -> unI64 11410+  '\x2c95'# -> unI64 11412+  '\x2c97'# -> unI64 11414+  '\x2c99'# -> unI64 11416+  '\x2c9b'# -> unI64 11418+  '\x2c9d'# -> unI64 11420+  '\x2c9f'# -> unI64 11422+  '\x2ca1'# -> unI64 11424+  '\x2ca3'# -> unI64 11426+  '\x2ca5'# -> unI64 11428+  '\x2ca7'# -> unI64 11430+  '\x2ca9'# -> unI64 11432+  '\x2cab'# -> unI64 11434+  '\x2cad'# -> unI64 11436+  '\x2caf'# -> unI64 11438+  '\x2cb1'# -> unI64 11440+  '\x2cb3'# -> unI64 11442+  '\x2cb5'# -> unI64 11444+  '\x2cb7'# -> unI64 11446+  '\x2cb9'# -> unI64 11448+  '\x2cbb'# -> unI64 11450+  '\x2cbd'# -> unI64 11452+  '\x2cbf'# -> unI64 11454+  '\x2cc1'# -> unI64 11456+  '\x2cc3'# -> unI64 11458+  '\x2cc5'# -> unI64 11460+  '\x2cc7'# -> unI64 11462+  '\x2cc9'# -> unI64 11464+  '\x2ccb'# -> unI64 11466+  '\x2ccd'# -> unI64 11468+  '\x2ccf'# -> unI64 11470+  '\x2cd1'# -> unI64 11472+  '\x2cd3'# -> unI64 11474+  '\x2cd5'# -> unI64 11476+  '\x2cd7'# -> unI64 11478+  '\x2cd9'# -> unI64 11480+  '\x2cdb'# -> unI64 11482+  '\x2cdd'# -> unI64 11484+  '\x2cdf'# -> unI64 11486+  '\x2ce1'# -> unI64 11488+  '\x2ce3'# -> unI64 11490+  '\x2cec'# -> unI64 11499+  '\x2cee'# -> unI64 11501+  '\x2cf3'# -> unI64 11506+  '\x2d00'# -> unI64 4256+  '\x2d01'# -> unI64 4257+  '\x2d02'# -> unI64 4258+  '\x2d03'# -> unI64 4259+  '\x2d04'# -> unI64 4260+  '\x2d05'# -> unI64 4261+  '\x2d06'# -> unI64 4262+  '\x2d07'# -> unI64 4263+  '\x2d08'# -> unI64 4264+  '\x2d09'# -> unI64 4265+  '\x2d0a'# -> unI64 4266+  '\x2d0b'# -> unI64 4267+  '\x2d0c'# -> unI64 4268+  '\x2d0d'# -> unI64 4269+  '\x2d0e'# -> unI64 4270+  '\x2d0f'# -> unI64 4271+  '\x2d10'# -> unI64 4272+  '\x2d11'# -> unI64 4273+  '\x2d12'# -> unI64 4274+  '\x2d13'# -> unI64 4275+  '\x2d14'# -> unI64 4276+  '\x2d15'# -> unI64 4277+  '\x2d16'# -> unI64 4278+  '\x2d17'# -> unI64 4279+  '\x2d18'# -> unI64 4280+  '\x2d19'# -> unI64 4281+  '\x2d1a'# -> unI64 4282+  '\x2d1b'# -> unI64 4283+  '\x2d1c'# -> unI64 4284+  '\x2d1d'# -> unI64 4285+  '\x2d1e'# -> unI64 4286+  '\x2d1f'# -> unI64 4287+  '\x2d20'# -> unI64 4288+  '\x2d21'# -> unI64 4289+  '\x2d22'# -> unI64 4290+  '\x2d23'# -> unI64 4291+  '\x2d24'# -> unI64 4292+  '\x2d25'# -> unI64 4293+  '\x2d27'# -> unI64 4295+  '\x2d2d'# -> unI64 4301+  '\xa641'# -> unI64 42560+  '\xa643'# -> unI64 42562+  '\xa645'# -> unI64 42564+  '\xa647'# -> unI64 42566+  '\xa649'# -> unI64 42568+  '\xa64b'# -> unI64 42570+  '\xa64d'# -> unI64 42572+  '\xa64f'# -> unI64 42574+  '\xa651'# -> unI64 42576+  '\xa653'# -> unI64 42578+  '\xa655'# -> unI64 42580+  '\xa657'# -> unI64 42582+  '\xa659'# -> unI64 42584+  '\xa65b'# -> unI64 42586+  '\xa65d'# -> unI64 42588+  '\xa65f'# -> unI64 42590+  '\xa661'# -> unI64 42592+  '\xa663'# -> unI64 42594+  '\xa665'# -> unI64 42596+  '\xa667'# -> unI64 42598+  '\xa669'# -> unI64 42600+  '\xa66b'# -> unI64 42602+  '\xa66d'# -> unI64 42604+  '\xa681'# -> unI64 42624+  '\xa683'# -> unI64 42626+  '\xa685'# -> unI64 42628+  '\xa687'# -> unI64 42630+  '\xa689'# -> unI64 42632+  '\xa68b'# -> unI64 42634+  '\xa68d'# -> unI64 42636+  '\xa68f'# -> unI64 42638+  '\xa691'# -> unI64 42640+  '\xa693'# -> unI64 42642+  '\xa695'# -> unI64 42644+  '\xa697'# -> unI64 42646+  '\xa699'# -> unI64 42648+  '\xa69b'# -> unI64 42650+  '\xa723'# -> unI64 42786+  '\xa725'# -> unI64 42788+  '\xa727'# -> unI64 42790+  '\xa729'# -> unI64 42792+  '\xa72b'# -> unI64 42794+  '\xa72d'# -> unI64 42796+  '\xa72f'# -> unI64 42798+  '\xa733'# -> unI64 42802+  '\xa735'# -> unI64 42804+  '\xa737'# -> unI64 42806+  '\xa739'# -> unI64 42808+  '\xa73b'# -> unI64 42810+  '\xa73d'# -> unI64 42812+  '\xa73f'# -> unI64 42814+  '\xa741'# -> unI64 42816+  '\xa743'# -> unI64 42818+  '\xa745'# -> unI64 42820+  '\xa747'# -> unI64 42822+  '\xa749'# -> unI64 42824+  '\xa74b'# -> unI64 42826+  '\xa74d'# -> unI64 42828+  '\xa74f'# -> unI64 42830+  '\xa751'# -> unI64 42832+  '\xa753'# -> unI64 42834+  '\xa755'# -> unI64 42836+  '\xa757'# -> unI64 42838+  '\xa759'# -> unI64 42840+  '\xa75b'# -> unI64 42842+  '\xa75d'# -> unI64 42844+  '\xa75f'# -> unI64 42846+  '\xa761'# -> unI64 42848+  '\xa763'# -> unI64 42850+  '\xa765'# -> unI64 42852+  '\xa767'# -> unI64 42854+  '\xa769'# -> unI64 42856+  '\xa76b'# -> unI64 42858+  '\xa76d'# -> unI64 42860+  '\xa76f'# -> unI64 42862+  '\xa77a'# -> unI64 42873+  '\xa77c'# -> unI64 42875+  '\xa77f'# -> unI64 42878+  '\xa781'# -> unI64 42880+  '\xa783'# -> unI64 42882+  '\xa785'# -> unI64 42884+  '\xa787'# -> unI64 42886+  '\xa78c'# -> unI64 42891+  '\xa791'# -> unI64 42896+  '\xa793'# -> unI64 42898+  '\xa794'# -> unI64 42948+  '\xa797'# -> unI64 42902+  '\xa799'# -> unI64 42904+  '\xa79b'# -> unI64 42906+  '\xa79d'# -> unI64 42908+  '\xa79f'# -> unI64 42910+  '\xa7a1'# -> unI64 42912+  '\xa7a3'# -> unI64 42914+  '\xa7a5'# -> unI64 42916+  '\xa7a7'# -> unI64 42918+  '\xa7a9'# -> unI64 42920+  '\xa7b5'# -> unI64 42932+  '\xa7b7'# -> unI64 42934+  '\xa7b9'# -> unI64 42936+  '\xa7bb'# -> unI64 42938+  '\xa7bd'# -> unI64 42940+  '\xa7bf'# -> unI64 42942+  '\xa7c1'# -> unI64 42944+  '\xa7c3'# -> unI64 42946+  '\xa7c8'# -> unI64 42951+  '\xa7ca'# -> unI64 42953+  '\xa7d1'# -> unI64 42960+  '\xa7d7'# -> unI64 42966+  '\xa7d9'# -> unI64 42968+  '\xa7f6'# -> unI64 42997+  '\xab53'# -> unI64 42931+  '\xab70'# -> unI64 5024+  '\xab71'# -> unI64 5025+  '\xab72'# -> unI64 5026+  '\xab73'# -> unI64 5027+  '\xab74'# -> unI64 5028+  '\xab75'# -> unI64 5029+  '\xab76'# -> unI64 5030+  '\xab77'# -> unI64 5031+  '\xab78'# -> unI64 5032+  '\xab79'# -> unI64 5033+  '\xab7a'# -> unI64 5034+  '\xab7b'# -> unI64 5035+  '\xab7c'# -> unI64 5036+  '\xab7d'# -> unI64 5037+  '\xab7e'# -> unI64 5038+  '\xab7f'# -> unI64 5039+  '\xab80'# -> unI64 5040+  '\xab81'# -> unI64 5041+  '\xab82'# -> unI64 5042+  '\xab83'# -> unI64 5043+  '\xab84'# -> unI64 5044+  '\xab85'# -> unI64 5045+  '\xab86'# -> unI64 5046+  '\xab87'# -> unI64 5047+  '\xab88'# -> unI64 5048+  '\xab89'# -> unI64 5049+  '\xab8a'# -> unI64 5050+  '\xab8b'# -> unI64 5051+  '\xab8c'# -> unI64 5052+  '\xab8d'# -> unI64 5053+  '\xab8e'# -> unI64 5054+  '\xab8f'# -> unI64 5055+  '\xab90'# -> unI64 5056+  '\xab91'# -> unI64 5057+  '\xab92'# -> unI64 5058+  '\xab93'# -> unI64 5059+  '\xab94'# -> unI64 5060+  '\xab95'# -> unI64 5061+  '\xab96'# -> unI64 5062+  '\xab97'# -> unI64 5063+  '\xab98'# -> unI64 5064+  '\xab99'# -> unI64 5065+  '\xab9a'# -> unI64 5066+  '\xab9b'# -> unI64 5067+  '\xab9c'# -> unI64 5068+  '\xab9d'# -> unI64 5069+  '\xab9e'# -> unI64 5070+  '\xab9f'# -> unI64 5071+  '\xaba0'# -> unI64 5072+  '\xaba1'# -> unI64 5073+  '\xaba2'# -> unI64 5074+  '\xaba3'# -> unI64 5075+  '\xaba4'# -> unI64 5076+  '\xaba5'# -> unI64 5077+  '\xaba6'# -> unI64 5078+  '\xaba7'# -> unI64 5079+  '\xaba8'# -> unI64 5080+  '\xaba9'# -> unI64 5081+  '\xabaa'# -> unI64 5082+  '\xabab'# -> unI64 5083+  '\xabac'# -> unI64 5084+  '\xabad'# -> unI64 5085+  '\xabae'# -> unI64 5086+  '\xabaf'# -> unI64 5087+  '\xabb0'# -> unI64 5088+  '\xabb1'# -> unI64 5089+  '\xabb2'# -> unI64 5090+  '\xabb3'# -> unI64 5091+  '\xabb4'# -> unI64 5092+  '\xabb5'# -> unI64 5093+  '\xabb6'# -> unI64 5094+  '\xabb7'# -> unI64 5095+  '\xabb8'# -> unI64 5096+  '\xabb9'# -> unI64 5097+  '\xabba'# -> unI64 5098+  '\xabbb'# -> unI64 5099+  '\xabbc'# -> unI64 5100+  '\xabbd'# -> unI64 5101+  '\xabbe'# -> unI64 5102+  '\xabbf'# -> unI64 5103+  '\xff41'# -> unI64 65313+  '\xff42'# -> unI64 65314+  '\xff43'# -> unI64 65315+  '\xff44'# -> unI64 65316+  '\xff45'# -> unI64 65317+  '\xff46'# -> unI64 65318+  '\xff47'# -> unI64 65319+  '\xff48'# -> unI64 65320+  '\xff49'# -> unI64 65321+  '\xff4a'# -> unI64 65322+  '\xff4b'# -> unI64 65323+  '\xff4c'# -> unI64 65324+  '\xff4d'# -> unI64 65325+  '\xff4e'# -> unI64 65326+  '\xff4f'# -> unI64 65327+  '\xff50'# -> unI64 65328+  '\xff51'# -> unI64 65329+  '\xff52'# -> unI64 65330+  '\xff53'# -> unI64 65331+  '\xff54'# -> unI64 65332+  '\xff55'# -> unI64 65333+  '\xff56'# -> unI64 65334+  '\xff57'# -> unI64 65335+  '\xff58'# -> unI64 65336+  '\xff59'# -> unI64 65337+  '\xff5a'# -> unI64 65338+  '\x10428'# -> unI64 66560+  '\x10429'# -> unI64 66561+  '\x1042a'# -> unI64 66562+  '\x1042b'# -> unI64 66563+  '\x1042c'# -> unI64 66564+  '\x1042d'# -> unI64 66565+  '\x1042e'# -> unI64 66566+  '\x1042f'# -> unI64 66567+  '\x10430'# -> unI64 66568+  '\x10431'# -> unI64 66569+  '\x10432'# -> unI64 66570+  '\x10433'# -> unI64 66571+  '\x10434'# -> unI64 66572+  '\x10435'# -> unI64 66573+  '\x10436'# -> unI64 66574+  '\x10437'# -> unI64 66575+  '\x10438'# -> unI64 66576+  '\x10439'# -> unI64 66577+  '\x1043a'# -> unI64 66578+  '\x1043b'# -> unI64 66579+  '\x1043c'# -> unI64 66580+  '\x1043d'# -> unI64 66581+  '\x1043e'# -> unI64 66582+  '\x1043f'# -> unI64 66583+  '\x10440'# -> unI64 66584+  '\x10441'# -> unI64 66585+  '\x10442'# -> unI64 66586+  '\x10443'# -> unI64 66587+  '\x10444'# -> unI64 66588+  '\x10445'# -> unI64 66589+  '\x10446'# -> unI64 66590+  '\x10447'# -> unI64 66591+  '\x10448'# -> unI64 66592+  '\x10449'# -> unI64 66593+  '\x1044a'# -> unI64 66594+  '\x1044b'# -> unI64 66595+  '\x1044c'# -> unI64 66596+  '\x1044d'# -> unI64 66597+  '\x1044e'# -> unI64 66598+  '\x1044f'# -> unI64 66599+  '\x104d8'# -> unI64 66736+  '\x104d9'# -> unI64 66737+  '\x104da'# -> unI64 66738+  '\x104db'# -> unI64 66739+  '\x104dc'# -> unI64 66740+  '\x104dd'# -> unI64 66741+  '\x104de'# -> unI64 66742+  '\x104df'# -> unI64 66743+  '\x104e0'# -> unI64 66744+  '\x104e1'# -> unI64 66745+  '\x104e2'# -> unI64 66746+  '\x104e3'# -> unI64 66747+  '\x104e4'# -> unI64 66748+  '\x104e5'# -> unI64 66749+  '\x104e6'# -> unI64 66750+  '\x104e7'# -> unI64 66751+  '\x104e8'# -> unI64 66752+  '\x104e9'# -> unI64 66753+  '\x104ea'# -> unI64 66754+  '\x104eb'# -> unI64 66755+  '\x104ec'# -> unI64 66756+  '\x104ed'# -> unI64 66757+  '\x104ee'# -> unI64 66758+  '\x104ef'# -> unI64 66759+  '\x104f0'# -> unI64 66760+  '\x104f1'# -> unI64 66761+  '\x104f2'# -> unI64 66762+  '\x104f3'# -> unI64 66763+  '\x104f4'# -> unI64 66764+  '\x104f5'# -> unI64 66765+  '\x104f6'# -> unI64 66766+  '\x104f7'# -> unI64 66767+  '\x104f8'# -> unI64 66768+  '\x104f9'# -> unI64 66769+  '\x104fa'# -> unI64 66770+  '\x104fb'# -> unI64 66771+  '\x10597'# -> unI64 66928+  '\x10598'# -> unI64 66929+  '\x10599'# -> unI64 66930+  '\x1059a'# -> unI64 66931+  '\x1059b'# -> unI64 66932+  '\x1059c'# -> unI64 66933+  '\x1059d'# -> unI64 66934+  '\x1059e'# -> unI64 66935+  '\x1059f'# -> unI64 66936+  '\x105a0'# -> unI64 66937+  '\x105a1'# -> unI64 66938+  '\x105a3'# -> unI64 66940+  '\x105a4'# -> unI64 66941+  '\x105a5'# -> unI64 66942+  '\x105a6'# -> unI64 66943+  '\x105a7'# -> unI64 66944+  '\x105a8'# -> unI64 66945+  '\x105a9'# -> unI64 66946+  '\x105aa'# -> unI64 66947+  '\x105ab'# -> unI64 66948+  '\x105ac'# -> unI64 66949+  '\x105ad'# -> unI64 66950+  '\x105ae'# -> unI64 66951+  '\x105af'# -> unI64 66952+  '\x105b0'# -> unI64 66953+  '\x105b1'# -> unI64 66954+  '\x105b3'# -> unI64 66956+  '\x105b4'# -> unI64 66957+  '\x105b5'# -> unI64 66958+  '\x105b6'# -> unI64 66959+  '\x105b7'# -> unI64 66960+  '\x105b8'# -> unI64 66961+  '\x105b9'# -> unI64 66962+  '\x105bb'# -> unI64 66964+  '\x105bc'# -> unI64 66965+  '\x10cc0'# -> unI64 68736+  '\x10cc1'# -> unI64 68737+  '\x10cc2'# -> unI64 68738+  '\x10cc3'# -> unI64 68739+  '\x10cc4'# -> unI64 68740+  '\x10cc5'# -> unI64 68741+  '\x10cc6'# -> unI64 68742+  '\x10cc7'# -> unI64 68743+  '\x10cc8'# -> unI64 68744+  '\x10cc9'# -> unI64 68745+  '\x10cca'# -> unI64 68746+  '\x10ccb'# -> unI64 68747+  '\x10ccc'# -> unI64 68748+  '\x10ccd'# -> unI64 68749+  '\x10cce'# -> unI64 68750+  '\x10ccf'# -> unI64 68751+  '\x10cd0'# -> unI64 68752+  '\x10cd1'# -> unI64 68753+  '\x10cd2'# -> unI64 68754+  '\x10cd3'# -> unI64 68755+  '\x10cd4'# -> unI64 68756+  '\x10cd5'# -> unI64 68757+  '\x10cd6'# -> unI64 68758+  '\x10cd7'# -> unI64 68759+  '\x10cd8'# -> unI64 68760+  '\x10cd9'# -> unI64 68761+  '\x10cda'# -> unI64 68762+  '\x10cdb'# -> unI64 68763+  '\x10cdc'# -> unI64 68764+  '\x10cdd'# -> unI64 68765+  '\x10cde'# -> unI64 68766+  '\x10cdf'# -> unI64 68767+  '\x10ce0'# -> unI64 68768+  '\x10ce1'# -> unI64 68769+  '\x10ce2'# -> unI64 68770+  '\x10ce3'# -> unI64 68771+  '\x10ce4'# -> unI64 68772+  '\x10ce5'# -> unI64 68773+  '\x10ce6'# -> unI64 68774+  '\x10ce7'# -> unI64 68775+  '\x10ce8'# -> unI64 68776+  '\x10ce9'# -> unI64 68777+  '\x10cea'# -> unI64 68778+  '\x10ceb'# -> unI64 68779+  '\x10cec'# -> unI64 68780+  '\x10ced'# -> unI64 68781+  '\x10cee'# -> unI64 68782+  '\x10cef'# -> unI64 68783+  '\x10cf0'# -> unI64 68784+  '\x10cf1'# -> unI64 68785+  '\x10cf2'# -> unI64 68786+  '\x118c0'# -> unI64 71840+  '\x118c1'# -> unI64 71841+  '\x118c2'# -> unI64 71842+  '\x118c3'# -> unI64 71843+  '\x118c4'# -> unI64 71844+  '\x118c5'# -> unI64 71845+  '\x118c6'# -> unI64 71846+  '\x118c7'# -> unI64 71847+  '\x118c8'# -> unI64 71848+  '\x118c9'# -> unI64 71849+  '\x118ca'# -> unI64 71850+  '\x118cb'# -> unI64 71851+  '\x118cc'# -> unI64 71852+  '\x118cd'# -> unI64 71853+  '\x118ce'# -> unI64 71854+  '\x118cf'# -> unI64 71855+  '\x118d0'# -> unI64 71856+  '\x118d1'# -> unI64 71857+  '\x118d2'# -> unI64 71858+  '\x118d3'# -> unI64 71859+  '\x118d4'# -> unI64 71860+  '\x118d5'# -> unI64 71861+  '\x118d6'# -> unI64 71862+  '\x118d7'# -> unI64 71863+  '\x118d8'# -> unI64 71864+  '\x118d9'# -> unI64 71865+  '\x118da'# -> unI64 71866+  '\x118db'# -> unI64 71867+  '\x118dc'# -> unI64 71868+  '\x118dd'# -> unI64 71869+  '\x118de'# -> unI64 71870+  '\x118df'# -> unI64 71871+  '\x16e60'# -> unI64 93760+  '\x16e61'# -> unI64 93761+  '\x16e62'# -> unI64 93762+  '\x16e63'# -> unI64 93763+  '\x16e64'# -> unI64 93764+  '\x16e65'# -> unI64 93765+  '\x16e66'# -> unI64 93766+  '\x16e67'# -> unI64 93767+  '\x16e68'# -> unI64 93768+  '\x16e69'# -> unI64 93769+  '\x16e6a'# -> unI64 93770+  '\x16e6b'# -> unI64 93771+  '\x16e6c'# -> unI64 93772+  '\x16e6d'# -> unI64 93773+  '\x16e6e'# -> unI64 93774+  '\x16e6f'# -> unI64 93775+  '\x16e70'# -> unI64 93776+  '\x16e71'# -> unI64 93777+  '\x16e72'# -> unI64 93778+  '\x16e73'# -> unI64 93779+  '\x16e74'# -> unI64 93780+  '\x16e75'# -> unI64 93781+  '\x16e76'# -> unI64 93782+  '\x16e77'# -> unI64 93783+  '\x16e78'# -> unI64 93784+  '\x16e79'# -> unI64 93785+  '\x16e7a'# -> unI64 93786+  '\x16e7b'# -> unI64 93787+  '\x16e7c'# -> unI64 93788+  '\x16e7d'# -> unI64 93789+  '\x16e7e'# -> unI64 93790+  '\x16e7f'# -> unI64 93791+  '\x1e922'# -> unI64 125184+  '\x1e923'# -> unI64 125185+  '\x1e924'# -> unI64 125186+  '\x1e925'# -> unI64 125187+  '\x1e926'# -> unI64 125188+  '\x1e927'# -> unI64 125189+  '\x1e928'# -> unI64 125190+  '\x1e929'# -> unI64 125191+  '\x1e92a'# -> unI64 125192+  '\x1e92b'# -> unI64 125193+  '\x1e92c'# -> unI64 125194+  '\x1e92d'# -> unI64 125195+  '\x1e92e'# -> unI64 125196+  '\x1e92f'# -> unI64 125197+  '\x1e930'# -> unI64 125198+  '\x1e931'# -> unI64 125199+  '\x1e932'# -> unI64 125200+  '\x1e933'# -> unI64 125201+  '\x1e934'# -> unI64 125202+  '\x1e935'# -> unI64 125203+  '\x1e936'# -> unI64 125204+  '\x1e937'# -> unI64 125205+  '\x1e938'# -> unI64 125206+  '\x1e939'# -> unI64 125207+  '\x1e93a'# -> unI64 125208+  '\x1e93b'# -> unI64 125209+  '\x1e93c'# -> unI64 125210+  '\x1e93d'# -> unI64 125211+  '\x1e93e'# -> unI64 125212+  '\x1e93f'# -> unI64 125213+  '\x1e940'# -> unI64 125214+  '\x1e941'# -> unI64 125215+  '\x1e942'# -> unI64 125216+  '\x1e943'# -> unI64 125217+  _ -> unI64 0+lowerMapping :: Char# -> _ {- unboxed Int64 -}+{-# NOINLINE lowerMapping #-}+lowerMapping = \case+  -- LATIN CAPITAL LETTER I WITH DOT ABOVE+  '\x0130'# -> unI64 1625292905+  '\x0041'# -> unI64 97+  '\x0042'# -> unI64 98+  '\x0043'# -> unI64 99+  '\x0044'# -> unI64 100+  '\x0045'# -> unI64 101+  '\x0046'# -> unI64 102+  '\x0047'# -> unI64 103+  '\x0048'# -> unI64 104+  '\x0049'# -> unI64 105+  '\x004a'# -> unI64 106+  '\x004b'# -> unI64 107+  '\x004c'# -> unI64 108+  '\x004d'# -> unI64 109+  '\x004e'# -> unI64 110+  '\x004f'# -> unI64 111+  '\x0050'# -> unI64 112+  '\x0051'# -> unI64 113+  '\x0052'# -> unI64 114+  '\x0053'# -> unI64 115+  '\x0054'# -> unI64 116+  '\x0055'# -> unI64 117+  '\x0056'# -> unI64 118+  '\x0057'# -> unI64 119+  '\x0058'# -> unI64 120+  '\x0059'# -> unI64 121+  '\x005a'# -> unI64 122+  '\x00c0'# -> unI64 224+  '\x00c1'# -> unI64 225+  '\x00c2'# -> unI64 226+  '\x00c3'# -> unI64 227+  '\x00c4'# -> unI64 228+  '\x00c5'# -> unI64 229+  '\x00c6'# -> unI64 230+  '\x00c7'# -> unI64 231+  '\x00c8'# -> unI64 232+  '\x00c9'# -> unI64 233+  '\x00ca'# -> unI64 234+  '\x00cb'# -> unI64 235+  '\x00cc'# -> unI64 236+  '\x00cd'# -> unI64 237+  '\x00ce'# -> unI64 238+  '\x00cf'# -> unI64 239+  '\x00d0'# -> unI64 240+  '\x00d1'# -> unI64 241+  '\x00d2'# -> unI64 242+  '\x00d3'# -> unI64 243+  '\x00d4'# -> unI64 244+  '\x00d5'# -> unI64 245+  '\x00d6'# -> unI64 246+  '\x00d8'# -> unI64 248+  '\x00d9'# -> unI64 249+  '\x00da'# -> unI64 250+  '\x00db'# -> unI64 251+  '\x00dc'# -> unI64 252+  '\x00dd'# -> unI64 253+  '\x00de'# -> unI64 254+  '\x0100'# -> unI64 257+  '\x0102'# -> unI64 259+  '\x0104'# -> unI64 261+  '\x0106'# -> unI64 263+  '\x0108'# -> unI64 265+  '\x010a'# -> unI64 267+  '\x010c'# -> unI64 269+  '\x010e'# -> unI64 271+  '\x0110'# -> unI64 273+  '\x0112'# -> unI64 275+  '\x0114'# -> unI64 277+  '\x0116'# -> unI64 279+  '\x0118'# -> unI64 281+  '\x011a'# -> unI64 283+  '\x011c'# -> unI64 285+  '\x011e'# -> unI64 287+  '\x0120'# -> unI64 289+  '\x0122'# -> unI64 291+  '\x0124'# -> unI64 293+  '\x0126'# -> unI64 295+  '\x0128'# -> unI64 297+  '\x012a'# -> unI64 299+  '\x012c'# -> unI64 301+  '\x012e'# -> unI64 303+  '\x0132'# -> unI64 307+  '\x0134'# -> unI64 309+  '\x0136'# -> unI64 311+  '\x0139'# -> unI64 314+  '\x013b'# -> unI64 316+  '\x013d'# -> unI64 318+  '\x013f'# -> unI64 320+  '\x0141'# -> unI64 322+  '\x0143'# -> unI64 324+  '\x0145'# -> unI64 326+  '\x0147'# -> unI64 328+  '\x014a'# -> unI64 331+  '\x014c'# -> unI64 333+  '\x014e'# -> unI64 335+  '\x0150'# -> unI64 337+  '\x0152'# -> unI64 339+  '\x0154'# -> unI64 341+  '\x0156'# -> unI64 343+  '\x0158'# -> unI64 345+  '\x015a'# -> unI64 347+  '\x015c'# -> unI64 349+  '\x015e'# -> unI64 351+  '\x0160'# -> unI64 353+  '\x0162'# -> unI64 355+  '\x0164'# -> unI64 357+  '\x0166'# -> unI64 359+  '\x0168'# -> unI64 361+  '\x016a'# -> unI64 363+  '\x016c'# -> unI64 365+  '\x016e'# -> unI64 367+  '\x0170'# -> unI64 369+  '\x0172'# -> unI64 371+  '\x0174'# -> unI64 373+  '\x0176'# -> unI64 375+  '\x0178'# -> unI64 255+  '\x0179'# -> unI64 378+  '\x017b'# -> unI64 380+  '\x017d'# -> unI64 382+  '\x0181'# -> unI64 595+  '\x0182'# -> unI64 387+  '\x0184'# -> unI64 389+  '\x0186'# -> unI64 596+  '\x0187'# -> unI64 392+  '\x0189'# -> unI64 598+  '\x018a'# -> unI64 599+  '\x018b'# -> unI64 396+  '\x018e'# -> unI64 477+  '\x018f'# -> unI64 601+  '\x0190'# -> unI64 603+  '\x0191'# -> unI64 402+  '\x0193'# -> unI64 608+  '\x0194'# -> unI64 611+  '\x0196'# -> unI64 617+  '\x0197'# -> unI64 616+  '\x0198'# -> unI64 409+  '\x019c'# -> unI64 623+  '\x019d'# -> unI64 626+  '\x019f'# -> unI64 629+  '\x01a0'# -> unI64 417+  '\x01a2'# -> unI64 419+  '\x01a4'# -> unI64 421+  '\x01a6'# -> unI64 640+  '\x01a7'# -> unI64 424+  '\x01a9'# -> unI64 643+  '\x01ac'# -> unI64 429+  '\x01ae'# -> unI64 648+  '\x01af'# -> unI64 432+  '\x01b1'# -> unI64 650+  '\x01b2'# -> unI64 651+  '\x01b3'# -> unI64 436+  '\x01b5'# -> unI64 438+  '\x01b7'# -> unI64 658+  '\x01b8'# -> unI64 441+  '\x01bc'# -> unI64 445+  '\x01c4'# -> unI64 454+  '\x01c5'# -> unI64 454+  '\x01c7'# -> unI64 457+  '\x01c8'# -> unI64 457+  '\x01ca'# -> unI64 460+  '\x01cb'# -> unI64 460+  '\x01cd'# -> unI64 462+  '\x01cf'# -> unI64 464+  '\x01d1'# -> unI64 466+  '\x01d3'# -> unI64 468+  '\x01d5'# -> unI64 470+  '\x01d7'# -> unI64 472+  '\x01d9'# -> unI64 474+  '\x01db'# -> unI64 476+  '\x01de'# -> unI64 479+  '\x01e0'# -> unI64 481+  '\x01e2'# -> unI64 483+  '\x01e4'# -> unI64 485+  '\x01e6'# -> unI64 487+  '\x01e8'# -> unI64 489+  '\x01ea'# -> unI64 491+  '\x01ec'# -> unI64 493+  '\x01ee'# -> unI64 495+  '\x01f1'# -> unI64 499+  '\x01f2'# -> unI64 499+  '\x01f4'# -> unI64 501+  '\x01f6'# -> unI64 405+  '\x01f7'# -> unI64 447+  '\x01f8'# -> unI64 505+  '\x01fa'# -> unI64 507+  '\x01fc'# -> unI64 509+  '\x01fe'# -> unI64 511+  '\x0200'# -> unI64 513+  '\x0202'# -> unI64 515+  '\x0204'# -> unI64 517+  '\x0206'# -> unI64 519+  '\x0208'# -> unI64 521+  '\x020a'# -> unI64 523+  '\x020c'# -> unI64 525+  '\x020e'# -> unI64 527+  '\x0210'# -> unI64 529+  '\x0212'# -> unI64 531+  '\x0214'# -> unI64 533+  '\x0216'# -> unI64 535+  '\x0218'# -> unI64 537+  '\x021a'# -> unI64 539+  '\x021c'# -> unI64 541+  '\x021e'# -> unI64 543+  '\x0220'# -> unI64 414+  '\x0222'# -> unI64 547+  '\x0224'# -> unI64 549+  '\x0226'# -> unI64 551+  '\x0228'# -> unI64 553+  '\x022a'# -> unI64 555+  '\x022c'# -> unI64 557+  '\x022e'# -> unI64 559+  '\x0230'# -> unI64 561+  '\x0232'# -> unI64 563+  '\x023a'# -> unI64 11365+  '\x023b'# -> unI64 572+  '\x023d'# -> unI64 410+  '\x023e'# -> unI64 11366+  '\x0241'# -> unI64 578+  '\x0243'# -> unI64 384+  '\x0244'# -> unI64 649+  '\x0245'# -> unI64 652+  '\x0246'# -> unI64 583+  '\x0248'# -> unI64 585+  '\x024a'# -> unI64 587+  '\x024c'# -> unI64 589+  '\x024e'# -> unI64 591+  '\x0370'# -> unI64 881+  '\x0372'# -> unI64 883+  '\x0376'# -> unI64 887+  '\x037f'# -> unI64 1011+  '\x0386'# -> unI64 940+  '\x0388'# -> unI64 941+  '\x0389'# -> unI64 942+  '\x038a'# -> unI64 943+  '\x038c'# -> unI64 972+  '\x038e'# -> unI64 973+  '\x038f'# -> unI64 974+  '\x0391'# -> unI64 945+  '\x0392'# -> unI64 946+  '\x0393'# -> unI64 947+  '\x0394'# -> unI64 948+  '\x0395'# -> unI64 949+  '\x0396'# -> unI64 950+  '\x0397'# -> unI64 951+  '\x0398'# -> unI64 952+  '\x0399'# -> unI64 953+  '\x039a'# -> unI64 954+  '\x039b'# -> unI64 955+  '\x039c'# -> unI64 956+  '\x039d'# -> unI64 957+  '\x039e'# -> unI64 958+  '\x039f'# -> unI64 959+  '\x03a0'# -> unI64 960+  '\x03a1'# -> unI64 961+  '\x03a3'# -> unI64 963+  '\x03a4'# -> unI64 964+  '\x03a5'# -> unI64 965+  '\x03a6'# -> unI64 966+  '\x03a7'# -> unI64 967+  '\x03a8'# -> unI64 968+  '\x03a9'# -> unI64 969+  '\x03aa'# -> unI64 970+  '\x03ab'# -> unI64 971+  '\x03cf'# -> unI64 983+  '\x03d8'# -> unI64 985+  '\x03da'# -> unI64 987+  '\x03dc'# -> unI64 989+  '\x03de'# -> unI64 991+  '\x03e0'# -> unI64 993+  '\x03e2'# -> unI64 995+  '\x03e4'# -> unI64 997+  '\x03e6'# -> unI64 999+  '\x03e8'# -> unI64 1001+  '\x03ea'# -> unI64 1003+  '\x03ec'# -> unI64 1005+  '\x03ee'# -> unI64 1007+  '\x03f4'# -> unI64 952+  '\x03f7'# -> unI64 1016+  '\x03f9'# -> unI64 1010+  '\x03fa'# -> unI64 1019+  '\x03fd'# -> unI64 891+  '\x03fe'# -> unI64 892+  '\x03ff'# -> unI64 893+  '\x0400'# -> unI64 1104+  '\x0401'# -> unI64 1105+  '\x0402'# -> unI64 1106+  '\x0403'# -> unI64 1107+  '\x0404'# -> unI64 1108+  '\x0405'# -> unI64 1109+  '\x0406'# -> unI64 1110+  '\x0407'# -> unI64 1111+  '\x0408'# -> unI64 1112+  '\x0409'# -> unI64 1113+  '\x040a'# -> unI64 1114+  '\x040b'# -> unI64 1115+  '\x040c'# -> unI64 1116+  '\x040d'# -> unI64 1117+  '\x040e'# -> unI64 1118+  '\x040f'# -> unI64 1119+  '\x0410'# -> unI64 1072+  '\x0411'# -> unI64 1073+  '\x0412'# -> unI64 1074+  '\x0413'# -> unI64 1075+  '\x0414'# -> unI64 1076+  '\x0415'# -> unI64 1077+  '\x0416'# -> unI64 1078+  '\x0417'# -> unI64 1079+  '\x0418'# -> unI64 1080+  '\x0419'# -> unI64 1081+  '\x041a'# -> unI64 1082+  '\x041b'# -> unI64 1083+  '\x041c'# -> unI64 1084+  '\x041d'# -> unI64 1085+  '\x041e'# -> unI64 1086+  '\x041f'# -> unI64 1087+  '\x0420'# -> unI64 1088+  '\x0421'# -> unI64 1089+  '\x0422'# -> unI64 1090+  '\x0423'# -> unI64 1091+  '\x0424'# -> unI64 1092+  '\x0425'# -> unI64 1093+  '\x0426'# -> unI64 1094+  '\x0427'# -> unI64 1095+  '\x0428'# -> unI64 1096+  '\x0429'# -> unI64 1097+  '\x042a'# -> unI64 1098+  '\x042b'# -> unI64 1099+  '\x042c'# -> unI64 1100+  '\x042d'# -> unI64 1101+  '\x042e'# -> unI64 1102+  '\x042f'# -> unI64 1103+  '\x0460'# -> unI64 1121+  '\x0462'# -> unI64 1123+  '\x0464'# -> unI64 1125+  '\x0466'# -> unI64 1127+  '\x0468'# -> unI64 1129+  '\x046a'# -> unI64 1131+  '\x046c'# -> unI64 1133+  '\x046e'# -> unI64 1135+  '\x0470'# -> unI64 1137+  '\x0472'# -> unI64 1139+  '\x0474'# -> unI64 1141+  '\x0476'# -> unI64 1143+  '\x0478'# -> unI64 1145+  '\x047a'# -> unI64 1147+  '\x047c'# -> unI64 1149+  '\x047e'# -> unI64 1151+  '\x0480'# -> unI64 1153+  '\x048a'# -> unI64 1163+  '\x048c'# -> unI64 1165+  '\x048e'# -> unI64 1167+  '\x0490'# -> unI64 1169+  '\x0492'# -> unI64 1171+  '\x0494'# -> unI64 1173+  '\x0496'# -> unI64 1175+  '\x0498'# -> unI64 1177+  '\x049a'# -> unI64 1179+  '\x049c'# -> unI64 1181+  '\x049e'# -> unI64 1183+  '\x04a0'# -> unI64 1185+  '\x04a2'# -> unI64 1187+  '\x04a4'# -> unI64 1189+  '\x04a6'# -> unI64 1191+  '\x04a8'# -> unI64 1193+  '\x04aa'# -> unI64 1195+  '\x04ac'# -> unI64 1197+  '\x04ae'# -> unI64 1199+  '\x04b0'# -> unI64 1201+  '\x04b2'# -> unI64 1203+  '\x04b4'# -> unI64 1205+  '\x04b6'# -> unI64 1207+  '\x04b8'# -> unI64 1209+  '\x04ba'# -> unI64 1211+  '\x04bc'# -> unI64 1213+  '\x04be'# -> unI64 1215+  '\x04c0'# -> unI64 1231+  '\x04c1'# -> unI64 1218+  '\x04c3'# -> unI64 1220+  '\x04c5'# -> unI64 1222+  '\x04c7'# -> unI64 1224+  '\x04c9'# -> unI64 1226+  '\x04cb'# -> unI64 1228+  '\x04cd'# -> unI64 1230+  '\x04d0'# -> unI64 1233+  '\x04d2'# -> unI64 1235+  '\x04d4'# -> unI64 1237+  '\x04d6'# -> unI64 1239+  '\x04d8'# -> unI64 1241+  '\x04da'# -> unI64 1243+  '\x04dc'# -> unI64 1245+  '\x04de'# -> unI64 1247+  '\x04e0'# -> unI64 1249+  '\x04e2'# -> unI64 1251+  '\x04e4'# -> unI64 1253+  '\x04e6'# -> unI64 1255+  '\x04e8'# -> unI64 1257+  '\x04ea'# -> unI64 1259+  '\x04ec'# -> unI64 1261+  '\x04ee'# -> unI64 1263+  '\x04f0'# -> unI64 1265+  '\x04f2'# -> unI64 1267+  '\x04f4'# -> unI64 1269+  '\x04f6'# -> unI64 1271+  '\x04f8'# -> unI64 1273+  '\x04fa'# -> unI64 1275+  '\x04fc'# -> unI64 1277+  '\x04fe'# -> unI64 1279+  '\x0500'# -> unI64 1281+  '\x0502'# -> unI64 1283+  '\x0504'# -> unI64 1285+  '\x0506'# -> unI64 1287+  '\x0508'# -> unI64 1289+  '\x050a'# -> unI64 1291+  '\x050c'# -> unI64 1293+  '\x050e'# -> unI64 1295+  '\x0510'# -> unI64 1297+  '\x0512'# -> unI64 1299+  '\x0514'# -> unI64 1301+  '\x0516'# -> unI64 1303+  '\x0518'# -> unI64 1305+  '\x051a'# -> unI64 1307+  '\x051c'# -> unI64 1309+  '\x051e'# -> unI64 1311+  '\x0520'# -> unI64 1313+  '\x0522'# -> unI64 1315+  '\x0524'# -> unI64 1317+  '\x0526'# -> unI64 1319+  '\x0528'# -> unI64 1321+  '\x052a'# -> unI64 1323+  '\x052c'# -> unI64 1325+  '\x052e'# -> unI64 1327+  '\x0531'# -> unI64 1377+  '\x0532'# -> unI64 1378+  '\x0533'# -> unI64 1379+  '\x0534'# -> unI64 1380+  '\x0535'# -> unI64 1381+  '\x0536'# -> unI64 1382+  '\x0537'# -> unI64 1383+  '\x0538'# -> unI64 1384+  '\x0539'# -> unI64 1385+  '\x053a'# -> unI64 1386+  '\x053b'# -> unI64 1387+  '\x053c'# -> unI64 1388+  '\x053d'# -> unI64 1389+  '\x053e'# -> unI64 1390+  '\x053f'# -> unI64 1391+  '\x0540'# -> unI64 1392+  '\x0541'# -> unI64 1393+  '\x0542'# -> unI64 1394+  '\x0543'# -> unI64 1395+  '\x0544'# -> unI64 1396+  '\x0545'# -> unI64 1397+  '\x0546'# -> unI64 1398+  '\x0547'# -> unI64 1399+  '\x0548'# -> unI64 1400+  '\x0549'# -> unI64 1401+  '\x054a'# -> unI64 1402+  '\x054b'# -> unI64 1403+  '\x054c'# -> unI64 1404+  '\x054d'# -> unI64 1405+  '\x054e'# -> unI64 1406+  '\x054f'# -> unI64 1407+  '\x0550'# -> unI64 1408+  '\x0551'# -> unI64 1409+  '\x0552'# -> unI64 1410+  '\x0553'# -> unI64 1411+  '\x0554'# -> unI64 1412+  '\x0555'# -> unI64 1413+  '\x0556'# -> unI64 1414+  '\x10a0'# -> unI64 11520+  '\x10a1'# -> unI64 11521+  '\x10a2'# -> unI64 11522+  '\x10a3'# -> unI64 11523+  '\x10a4'# -> unI64 11524+  '\x10a5'# -> unI64 11525+  '\x10a6'# -> unI64 11526+  '\x10a7'# -> unI64 11527+  '\x10a8'# -> unI64 11528+  '\x10a9'# -> unI64 11529+  '\x10aa'# -> unI64 11530+  '\x10ab'# -> unI64 11531+  '\x10ac'# -> unI64 11532+  '\x10ad'# -> unI64 11533+  '\x10ae'# -> unI64 11534+  '\x10af'# -> unI64 11535+  '\x10b0'# -> unI64 11536+  '\x10b1'# -> unI64 11537+  '\x10b2'# -> unI64 11538+  '\x10b3'# -> unI64 11539+  '\x10b4'# -> unI64 11540+  '\x10b5'# -> unI64 11541+  '\x10b6'# -> unI64 11542+  '\x10b7'# -> unI64 11543+  '\x10b8'# -> unI64 11544+  '\x10b9'# -> unI64 11545+  '\x10ba'# -> unI64 11546+  '\x10bb'# -> unI64 11547+  '\x10bc'# -> unI64 11548+  '\x10bd'# -> unI64 11549+  '\x10be'# -> unI64 11550+  '\x10bf'# -> unI64 11551+  '\x10c0'# -> unI64 11552+  '\x10c1'# -> unI64 11553+  '\x10c2'# -> unI64 11554+  '\x10c3'# -> unI64 11555+  '\x10c4'# -> unI64 11556+  '\x10c5'# -> unI64 11557+  '\x10c7'# -> unI64 11559+  '\x10cd'# -> unI64 11565+  '\x13a0'# -> unI64 43888+  '\x13a1'# -> unI64 43889+  '\x13a2'# -> unI64 43890+  '\x13a3'# -> unI64 43891+  '\x13a4'# -> unI64 43892+  '\x13a5'# -> unI64 43893+  '\x13a6'# -> unI64 43894+  '\x13a7'# -> unI64 43895+  '\x13a8'# -> unI64 43896+  '\x13a9'# -> unI64 43897+  '\x13aa'# -> unI64 43898+  '\x13ab'# -> unI64 43899+  '\x13ac'# -> unI64 43900+  '\x13ad'# -> unI64 43901+  '\x13ae'# -> unI64 43902+  '\x13af'# -> unI64 43903+  '\x13b0'# -> unI64 43904+  '\x13b1'# -> unI64 43905+  '\x13b2'# -> unI64 43906+  '\x13b3'# -> unI64 43907+  '\x13b4'# -> unI64 43908+  '\x13b5'# -> unI64 43909+  '\x13b6'# -> unI64 43910+  '\x13b7'# -> unI64 43911+  '\x13b8'# -> unI64 43912+  '\x13b9'# -> unI64 43913+  '\x13ba'# -> unI64 43914+  '\x13bb'# -> unI64 43915+  '\x13bc'# -> unI64 43916+  '\x13bd'# -> unI64 43917+  '\x13be'# -> unI64 43918+  '\x13bf'# -> unI64 43919+  '\x13c0'# -> unI64 43920+  '\x13c1'# -> unI64 43921+  '\x13c2'# -> unI64 43922+  '\x13c3'# -> unI64 43923+  '\x13c4'# -> unI64 43924+  '\x13c5'# -> unI64 43925+  '\x13c6'# -> unI64 43926+  '\x13c7'# -> unI64 43927+  '\x13c8'# -> unI64 43928+  '\x13c9'# -> unI64 43929+  '\x13ca'# -> unI64 43930+  '\x13cb'# -> unI64 43931+  '\x13cc'# -> unI64 43932+  '\x13cd'# -> unI64 43933+  '\x13ce'# -> unI64 43934+  '\x13cf'# -> unI64 43935+  '\x13d0'# -> unI64 43936+  '\x13d1'# -> unI64 43937+  '\x13d2'# -> unI64 43938+  '\x13d3'# -> unI64 43939+  '\x13d4'# -> unI64 43940+  '\x13d5'# -> unI64 43941+  '\x13d6'# -> unI64 43942+  '\x13d7'# -> unI64 43943+  '\x13d8'# -> unI64 43944+  '\x13d9'# -> unI64 43945+  '\x13da'# -> unI64 43946+  '\x13db'# -> unI64 43947+  '\x13dc'# -> unI64 43948+  '\x13dd'# -> unI64 43949+  '\x13de'# -> unI64 43950+  '\x13df'# -> unI64 43951+  '\x13e0'# -> unI64 43952+  '\x13e1'# -> unI64 43953+  '\x13e2'# -> unI64 43954+  '\x13e3'# -> unI64 43955+  '\x13e4'# -> unI64 43956+  '\x13e5'# -> unI64 43957+  '\x13e6'# -> unI64 43958+  '\x13e7'# -> unI64 43959+  '\x13e8'# -> unI64 43960+  '\x13e9'# -> unI64 43961+  '\x13ea'# -> unI64 43962+  '\x13eb'# -> unI64 43963+  '\x13ec'# -> unI64 43964+  '\x13ed'# -> unI64 43965+  '\x13ee'# -> unI64 43966+  '\x13ef'# -> unI64 43967+  '\x13f0'# -> unI64 5112+  '\x13f1'# -> unI64 5113+  '\x13f2'# -> unI64 5114+  '\x13f3'# -> unI64 5115+  '\x13f4'# -> unI64 5116+  '\x13f5'# -> unI64 5117+  '\x1c90'# -> unI64 4304+  '\x1c91'# -> unI64 4305+  '\x1c92'# -> unI64 4306+  '\x1c93'# -> unI64 4307+  '\x1c94'# -> unI64 4308+  '\x1c95'# -> unI64 4309+  '\x1c96'# -> unI64 4310+  '\x1c97'# -> unI64 4311+  '\x1c98'# -> unI64 4312+  '\x1c99'# -> unI64 4313+  '\x1c9a'# -> unI64 4314+  '\x1c9b'# -> unI64 4315+  '\x1c9c'# -> unI64 4316+  '\x1c9d'# -> unI64 4317+  '\x1c9e'# -> unI64 4318+  '\x1c9f'# -> unI64 4319+  '\x1ca0'# -> unI64 4320+  '\x1ca1'# -> unI64 4321+  '\x1ca2'# -> unI64 4322+  '\x1ca3'# -> unI64 4323+  '\x1ca4'# -> unI64 4324+  '\x1ca5'# -> unI64 4325+  '\x1ca6'# -> unI64 4326+  '\x1ca7'# -> unI64 4327+  '\x1ca8'# -> unI64 4328+  '\x1ca9'# -> unI64 4329+  '\x1caa'# -> unI64 4330+  '\x1cab'# -> unI64 4331+  '\x1cac'# -> unI64 4332+  '\x1cad'# -> unI64 4333+  '\x1cae'# -> unI64 4334+  '\x1caf'# -> unI64 4335+  '\x1cb0'# -> unI64 4336+  '\x1cb1'# -> unI64 4337+  '\x1cb2'# -> unI64 4338+  '\x1cb3'# -> unI64 4339+  '\x1cb4'# -> unI64 4340+  '\x1cb5'# -> unI64 4341+  '\x1cb6'# -> unI64 4342+  '\x1cb7'# -> unI64 4343+  '\x1cb8'# -> unI64 4344+  '\x1cb9'# -> unI64 4345+  '\x1cba'# -> unI64 4346+  '\x1cbd'# -> unI64 4349+  '\x1cbe'# -> unI64 4350+  '\x1cbf'# -> unI64 4351+  '\x1e00'# -> unI64 7681+  '\x1e02'# -> unI64 7683+  '\x1e04'# -> unI64 7685+  '\x1e06'# -> unI64 7687+  '\x1e08'# -> unI64 7689+  '\x1e0a'# -> unI64 7691+  '\x1e0c'# -> unI64 7693+  '\x1e0e'# -> unI64 7695+  '\x1e10'# -> unI64 7697+  '\x1e12'# -> unI64 7699+  '\x1e14'# -> unI64 7701+  '\x1e16'# -> unI64 7703+  '\x1e18'# -> unI64 7705+  '\x1e1a'# -> unI64 7707+  '\x1e1c'# -> unI64 7709+  '\x1e1e'# -> unI64 7711+  '\x1e20'# -> unI64 7713+  '\x1e22'# -> unI64 7715+  '\x1e24'# -> unI64 7717+  '\x1e26'# -> unI64 7719+  '\x1e28'# -> unI64 7721+  '\x1e2a'# -> unI64 7723+  '\x1e2c'# -> unI64 7725+  '\x1e2e'# -> unI64 7727+  '\x1e30'# -> unI64 7729+  '\x1e32'# -> unI64 7731+  '\x1e34'# -> unI64 7733+  '\x1e36'# -> unI64 7735+  '\x1e38'# -> unI64 7737+  '\x1e3a'# -> unI64 7739+  '\x1e3c'# -> unI64 7741+  '\x1e3e'# -> unI64 7743+  '\x1e40'# -> unI64 7745+  '\x1e42'# -> unI64 7747+  '\x1e44'# -> unI64 7749+  '\x1e46'# -> unI64 7751+  '\x1e48'# -> unI64 7753+  '\x1e4a'# -> unI64 7755+  '\x1e4c'# -> unI64 7757+  '\x1e4e'# -> unI64 7759+  '\x1e50'# -> unI64 7761+  '\x1e52'# -> unI64 7763+  '\x1e54'# -> unI64 7765+  '\x1e56'# -> unI64 7767+  '\x1e58'# -> unI64 7769+  '\x1e5a'# -> unI64 7771+  '\x1e5c'# -> unI64 7773+  '\x1e5e'# -> unI64 7775+  '\x1e60'# -> unI64 7777+  '\x1e62'# -> unI64 7779+  '\x1e64'# -> unI64 7781+  '\x1e66'# -> unI64 7783+  '\x1e68'# -> unI64 7785+  '\x1e6a'# -> unI64 7787+  '\x1e6c'# -> unI64 7789+  '\x1e6e'# -> unI64 7791+  '\x1e70'# -> unI64 7793+  '\x1e72'# -> unI64 7795+  '\x1e74'# -> unI64 7797+  '\x1e76'# -> unI64 7799+  '\x1e78'# -> unI64 7801+  '\x1e7a'# -> unI64 7803+  '\x1e7c'# -> unI64 7805+  '\x1e7e'# -> unI64 7807+  '\x1e80'# -> unI64 7809+  '\x1e82'# -> unI64 7811+  '\x1e84'# -> unI64 7813+  '\x1e86'# -> unI64 7815+  '\x1e88'# -> unI64 7817+  '\x1e8a'# -> unI64 7819+  '\x1e8c'# -> unI64 7821+  '\x1e8e'# -> unI64 7823+  '\x1e90'# -> unI64 7825+  '\x1e92'# -> unI64 7827+  '\x1e94'# -> unI64 7829+  '\x1e9e'# -> unI64 223+  '\x1ea0'# -> unI64 7841+  '\x1ea2'# -> unI64 7843+  '\x1ea4'# -> unI64 7845+  '\x1ea6'# -> unI64 7847+  '\x1ea8'# -> unI64 7849+  '\x1eaa'# -> unI64 7851+  '\x1eac'# -> unI64 7853+  '\x1eae'# -> unI64 7855+  '\x1eb0'# -> unI64 7857+  '\x1eb2'# -> unI64 7859+  '\x1eb4'# -> unI64 7861+  '\x1eb6'# -> unI64 7863+  '\x1eb8'# -> unI64 7865+  '\x1eba'# -> unI64 7867+  '\x1ebc'# -> unI64 7869+  '\x1ebe'# -> unI64 7871+  '\x1ec0'# -> unI64 7873+  '\x1ec2'# -> unI64 7875+  '\x1ec4'# -> unI64 7877+  '\x1ec6'# -> unI64 7879+  '\x1ec8'# -> unI64 7881+  '\x1eca'# -> unI64 7883+  '\x1ecc'# -> unI64 7885+  '\x1ece'# -> unI64 7887+  '\x1ed0'# -> unI64 7889+  '\x1ed2'# -> unI64 7891+  '\x1ed4'# -> unI64 7893+  '\x1ed6'# -> unI64 7895+  '\x1ed8'# -> unI64 7897+  '\x1eda'# -> unI64 7899+  '\x1edc'# -> unI64 7901+  '\x1ede'# -> unI64 7903+  '\x1ee0'# -> unI64 7905+  '\x1ee2'# -> unI64 7907+  '\x1ee4'# -> unI64 7909+  '\x1ee6'# -> unI64 7911+  '\x1ee8'# -> unI64 7913+  '\x1eea'# -> unI64 7915+  '\x1eec'# -> unI64 7917+  '\x1eee'# -> unI64 7919+  '\x1ef0'# -> unI64 7921+  '\x1ef2'# -> unI64 7923+  '\x1ef4'# -> unI64 7925+  '\x1ef6'# -> unI64 7927+  '\x1ef8'# -> unI64 7929+  '\x1efa'# -> unI64 7931+  '\x1efc'# -> unI64 7933+  '\x1efe'# -> unI64 7935+  '\x1f08'# -> unI64 7936+  '\x1f09'# -> unI64 7937+  '\x1f0a'# -> unI64 7938+  '\x1f0b'# -> unI64 7939+  '\x1f0c'# -> unI64 7940+  '\x1f0d'# -> unI64 7941+  '\x1f0e'# -> unI64 7942+  '\x1f0f'# -> unI64 7943+  '\x1f18'# -> unI64 7952+  '\x1f19'# -> unI64 7953+  '\x1f1a'# -> unI64 7954+  '\x1f1b'# -> unI64 7955+  '\x1f1c'# -> unI64 7956+  '\x1f1d'# -> unI64 7957+  '\x1f28'# -> unI64 7968+  '\x1f29'# -> unI64 7969+  '\x1f2a'# -> unI64 7970+  '\x1f2b'# -> unI64 7971+  '\x1f2c'# -> unI64 7972+  '\x1f2d'# -> unI64 7973+  '\x1f2e'# -> unI64 7974+  '\x1f2f'# -> unI64 7975+  '\x1f38'# -> unI64 7984+  '\x1f39'# -> unI64 7985+  '\x1f3a'# -> unI64 7986+  '\x1f3b'# -> unI64 7987+  '\x1f3c'# -> unI64 7988+  '\x1f3d'# -> unI64 7989+  '\x1f3e'# -> unI64 7990+  '\x1f3f'# -> unI64 7991+  '\x1f48'# -> unI64 8000+  '\x1f49'# -> unI64 8001+  '\x1f4a'# -> unI64 8002+  '\x1f4b'# -> unI64 8003+  '\x1f4c'# -> unI64 8004+  '\x1f4d'# -> unI64 8005+  '\x1f59'# -> unI64 8017+  '\x1f5b'# -> unI64 8019+  '\x1f5d'# -> unI64 8021+  '\x1f5f'# -> unI64 8023+  '\x1f68'# -> unI64 8032+  '\x1f69'# -> unI64 8033+  '\x1f6a'# -> unI64 8034+  '\x1f6b'# -> unI64 8035+  '\x1f6c'# -> unI64 8036+  '\x1f6d'# -> unI64 8037+  '\x1f6e'# -> unI64 8038+  '\x1f6f'# -> unI64 8039+  '\x1f88'# -> unI64 8064+  '\x1f89'# -> unI64 8065+  '\x1f8a'# -> unI64 8066+  '\x1f8b'# -> unI64 8067+  '\x1f8c'# -> unI64 8068+  '\x1f8d'# -> unI64 8069+  '\x1f8e'# -> unI64 8070+  '\x1f8f'# -> unI64 8071+  '\x1f98'# -> unI64 8080+  '\x1f99'# -> unI64 8081+  '\x1f9a'# -> unI64 8082+  '\x1f9b'# -> unI64 8083+  '\x1f9c'# -> unI64 8084+  '\x1f9d'# -> unI64 8085+  '\x1f9e'# -> unI64 8086+  '\x1f9f'# -> unI64 8087+  '\x1fa8'# -> unI64 8096+  '\x1fa9'# -> unI64 8097+  '\x1faa'# -> unI64 8098+  '\x1fab'# -> unI64 8099+  '\x1fac'# -> unI64 8100+  '\x1fad'# -> unI64 8101+  '\x1fae'# -> unI64 8102+  '\x1faf'# -> unI64 8103+  '\x1fb8'# -> unI64 8112+  '\x1fb9'# -> unI64 8113+  '\x1fba'# -> unI64 8048+  '\x1fbb'# -> unI64 8049+  '\x1fbc'# -> unI64 8115+  '\x1fc8'# -> unI64 8050+  '\x1fc9'# -> unI64 8051+  '\x1fca'# -> unI64 8052+  '\x1fcb'# -> unI64 8053+  '\x1fcc'# -> unI64 8131+  '\x1fd8'# -> unI64 8144+  '\x1fd9'# -> unI64 8145+  '\x1fda'# -> unI64 8054+  '\x1fdb'# -> unI64 8055+  '\x1fe8'# -> unI64 8160+  '\x1fe9'# -> unI64 8161+  '\x1fea'# -> unI64 8058+  '\x1feb'# -> unI64 8059+  '\x1fec'# -> unI64 8165+  '\x1ff8'# -> unI64 8056+  '\x1ff9'# -> unI64 8057+  '\x1ffa'# -> unI64 8060+  '\x1ffb'# -> unI64 8061+  '\x1ffc'# -> unI64 8179+  '\x2126'# -> unI64 969+  '\x212a'# -> unI64 107+  '\x212b'# -> unI64 229+  '\x2132'# -> unI64 8526+  '\x2160'# -> unI64 8560+  '\x2161'# -> unI64 8561+  '\x2162'# -> unI64 8562+  '\x2163'# -> unI64 8563+  '\x2164'# -> unI64 8564+  '\x2165'# -> unI64 8565+  '\x2166'# -> unI64 8566+  '\x2167'# -> unI64 8567+  '\x2168'# -> unI64 8568+  '\x2169'# -> unI64 8569+  '\x216a'# -> unI64 8570+  '\x216b'# -> unI64 8571+  '\x216c'# -> unI64 8572+  '\x216d'# -> unI64 8573+  '\x216e'# -> unI64 8574+  '\x216f'# -> unI64 8575+  '\x2183'# -> unI64 8580+  '\x24b6'# -> unI64 9424+  '\x24b7'# -> unI64 9425+  '\x24b8'# -> unI64 9426+  '\x24b9'# -> unI64 9427+  '\x24ba'# -> unI64 9428+  '\x24bb'# -> unI64 9429+  '\x24bc'# -> unI64 9430+  '\x24bd'# -> unI64 9431+  '\x24be'# -> unI64 9432+  '\x24bf'# -> unI64 9433+  '\x24c0'# -> unI64 9434+  '\x24c1'# -> unI64 9435+  '\x24c2'# -> unI64 9436+  '\x24c3'# -> unI64 9437+  '\x24c4'# -> unI64 9438+  '\x24c5'# -> unI64 9439+  '\x24c6'# -> unI64 9440+  '\x24c7'# -> unI64 9441+  '\x24c8'# -> unI64 9442+  '\x24c9'# -> unI64 9443+  '\x24ca'# -> unI64 9444+  '\x24cb'# -> unI64 9445+  '\x24cc'# -> unI64 9446+  '\x24cd'# -> unI64 9447+  '\x24ce'# -> unI64 9448+  '\x24cf'# -> unI64 9449+  '\x2c00'# -> unI64 11312+  '\x2c01'# -> unI64 11313+  '\x2c02'# -> unI64 11314+  '\x2c03'# -> unI64 11315+  '\x2c04'# -> unI64 11316+  '\x2c05'# -> unI64 11317+  '\x2c06'# -> unI64 11318+  '\x2c07'# -> unI64 11319+  '\x2c08'# -> unI64 11320+  '\x2c09'# -> unI64 11321+  '\x2c0a'# -> unI64 11322+  '\x2c0b'# -> unI64 11323+  '\x2c0c'# -> unI64 11324+  '\x2c0d'# -> unI64 11325+  '\x2c0e'# -> unI64 11326+  '\x2c0f'# -> unI64 11327+  '\x2c10'# -> unI64 11328+  '\x2c11'# -> unI64 11329+  '\x2c12'# -> unI64 11330+  '\x2c13'# -> unI64 11331+  '\x2c14'# -> unI64 11332+  '\x2c15'# -> unI64 11333+  '\x2c16'# -> unI64 11334+  '\x2c17'# -> unI64 11335+  '\x2c18'# -> unI64 11336+  '\x2c19'# -> unI64 11337+  '\x2c1a'# -> unI64 11338+  '\x2c1b'# -> unI64 11339+  '\x2c1c'# -> unI64 11340+  '\x2c1d'# -> unI64 11341+  '\x2c1e'# -> unI64 11342+  '\x2c1f'# -> unI64 11343+  '\x2c20'# -> unI64 11344+  '\x2c21'# -> unI64 11345+  '\x2c22'# -> unI64 11346+  '\x2c23'# -> unI64 11347+  '\x2c24'# -> unI64 11348+  '\x2c25'# -> unI64 11349+  '\x2c26'# -> unI64 11350+  '\x2c27'# -> unI64 11351+  '\x2c28'# -> unI64 11352+  '\x2c29'# -> unI64 11353+  '\x2c2a'# -> unI64 11354+  '\x2c2b'# -> unI64 11355+  '\x2c2c'# -> unI64 11356+  '\x2c2d'# -> unI64 11357+  '\x2c2e'# -> unI64 11358+  '\x2c2f'# -> unI64 11359+  '\x2c60'# -> unI64 11361+  '\x2c62'# -> unI64 619+  '\x2c63'# -> unI64 7549+  '\x2c64'# -> unI64 637+  '\x2c67'# -> unI64 11368+  '\x2c69'# -> unI64 11370+  '\x2c6b'# -> unI64 11372+  '\x2c6d'# -> unI64 593+  '\x2c6e'# -> unI64 625+  '\x2c6f'# -> unI64 592+  '\x2c70'# -> unI64 594+  '\x2c72'# -> unI64 11379+  '\x2c75'# -> unI64 11382+  '\x2c7e'# -> unI64 575+  '\x2c7f'# -> unI64 576+  '\x2c80'# -> unI64 11393+  '\x2c82'# -> unI64 11395+  '\x2c84'# -> unI64 11397+  '\x2c86'# -> unI64 11399+  '\x2c88'# -> unI64 11401+  '\x2c8a'# -> unI64 11403+  '\x2c8c'# -> unI64 11405+  '\x2c8e'# -> unI64 11407+  '\x2c90'# -> unI64 11409+  '\x2c92'# -> unI64 11411+  '\x2c94'# -> unI64 11413+  '\x2c96'# -> unI64 11415+  '\x2c98'# -> unI64 11417+  '\x2c9a'# -> unI64 11419+  '\x2c9c'# -> unI64 11421+  '\x2c9e'# -> unI64 11423+  '\x2ca0'# -> unI64 11425+  '\x2ca2'# -> unI64 11427+  '\x2ca4'# -> unI64 11429+  '\x2ca6'# -> unI64 11431+  '\x2ca8'# -> unI64 11433+  '\x2caa'# -> unI64 11435+  '\x2cac'# -> unI64 11437+  '\x2cae'# -> unI64 11439+  '\x2cb0'# -> unI64 11441+  '\x2cb2'# -> unI64 11443+  '\x2cb4'# -> unI64 11445+  '\x2cb6'# -> unI64 11447+  '\x2cb8'# -> unI64 11449+  '\x2cba'# -> unI64 11451+  '\x2cbc'# -> unI64 11453+  '\x2cbe'# -> unI64 11455+  '\x2cc0'# -> unI64 11457+  '\x2cc2'# -> unI64 11459+  '\x2cc4'# -> unI64 11461+  '\x2cc6'# -> unI64 11463+  '\x2cc8'# -> unI64 11465+  '\x2cca'# -> unI64 11467+  '\x2ccc'# -> unI64 11469+  '\x2cce'# -> unI64 11471+  '\x2cd0'# -> unI64 11473+  '\x2cd2'# -> unI64 11475+  '\x2cd4'# -> unI64 11477+  '\x2cd6'# -> unI64 11479+  '\x2cd8'# -> unI64 11481+  '\x2cda'# -> unI64 11483+  '\x2cdc'# -> unI64 11485+  '\x2cde'# -> unI64 11487+  '\x2ce0'# -> unI64 11489+  '\x2ce2'# -> unI64 11491+  '\x2ceb'# -> unI64 11500+  '\x2ced'# -> unI64 11502+  '\x2cf2'# -> unI64 11507+  '\xa640'# -> unI64 42561+  '\xa642'# -> unI64 42563+  '\xa644'# -> unI64 42565+  '\xa646'# -> unI64 42567+  '\xa648'# -> unI64 42569+  '\xa64a'# -> unI64 42571+  '\xa64c'# -> unI64 42573+  '\xa64e'# -> unI64 42575+  '\xa650'# -> unI64 42577+  '\xa652'# -> unI64 42579+  '\xa654'# -> unI64 42581+  '\xa656'# -> unI64 42583+  '\xa658'# -> unI64 42585+  '\xa65a'# -> unI64 42587+  '\xa65c'# -> unI64 42589+  '\xa65e'# -> unI64 42591+  '\xa660'# -> unI64 42593+  '\xa662'# -> unI64 42595+  '\xa664'# -> unI64 42597+  '\xa666'# -> unI64 42599+  '\xa668'# -> unI64 42601+  '\xa66a'# -> unI64 42603+  '\xa66c'# -> unI64 42605+  '\xa680'# -> unI64 42625+  '\xa682'# -> unI64 42627+  '\xa684'# -> unI64 42629+  '\xa686'# -> unI64 42631+  '\xa688'# -> unI64 42633+  '\xa68a'# -> unI64 42635+  '\xa68c'# -> unI64 42637+  '\xa68e'# -> unI64 42639+  '\xa690'# -> unI64 42641+  '\xa692'# -> unI64 42643+  '\xa694'# -> unI64 42645+  '\xa696'# -> unI64 42647+  '\xa698'# -> unI64 42649+  '\xa69a'# -> unI64 42651+  '\xa722'# -> unI64 42787+  '\xa724'# -> unI64 42789+  '\xa726'# -> unI64 42791+  '\xa728'# -> unI64 42793+  '\xa72a'# -> unI64 42795+  '\xa72c'# -> unI64 42797+  '\xa72e'# -> unI64 42799+  '\xa732'# -> unI64 42803+  '\xa734'# -> unI64 42805+  '\xa736'# -> unI64 42807+  '\xa738'# -> unI64 42809+  '\xa73a'# -> unI64 42811+  '\xa73c'# -> unI64 42813+  '\xa73e'# -> unI64 42815+  '\xa740'# -> unI64 42817+  '\xa742'# -> unI64 42819+  '\xa744'# -> unI64 42821+  '\xa746'# -> unI64 42823+  '\xa748'# -> unI64 42825+  '\xa74a'# -> unI64 42827+  '\xa74c'# -> unI64 42829+  '\xa74e'# -> unI64 42831+  '\xa750'# -> unI64 42833+  '\xa752'# -> unI64 42835+  '\xa754'# -> unI64 42837+  '\xa756'# -> unI64 42839+  '\xa758'# -> unI64 42841+  '\xa75a'# -> unI64 42843+  '\xa75c'# -> unI64 42845+  '\xa75e'# -> unI64 42847+  '\xa760'# -> unI64 42849+  '\xa762'# -> unI64 42851+  '\xa764'# -> unI64 42853+  '\xa766'# -> unI64 42855+  '\xa768'# -> unI64 42857+  '\xa76a'# -> unI64 42859+  '\xa76c'# -> unI64 42861+  '\xa76e'# -> unI64 42863+  '\xa779'# -> unI64 42874+  '\xa77b'# -> unI64 42876+  '\xa77d'# -> unI64 7545+  '\xa77e'# -> unI64 42879+  '\xa780'# -> unI64 42881+  '\xa782'# -> unI64 42883+  '\xa784'# -> unI64 42885+  '\xa786'# -> unI64 42887+  '\xa78b'# -> unI64 42892+  '\xa78d'# -> unI64 613+  '\xa790'# -> unI64 42897+  '\xa792'# -> unI64 42899+  '\xa796'# -> unI64 42903+  '\xa798'# -> unI64 42905+  '\xa79a'# -> unI64 42907+  '\xa79c'# -> unI64 42909+  '\xa79e'# -> unI64 42911+  '\xa7a0'# -> unI64 42913+  '\xa7a2'# -> unI64 42915+  '\xa7a4'# -> unI64 42917+  '\xa7a6'# -> unI64 42919+  '\xa7a8'# -> unI64 42921+  '\xa7aa'# -> unI64 614+  '\xa7ab'# -> unI64 604+  '\xa7ac'# -> unI64 609+  '\xa7ad'# -> unI64 620+  '\xa7ae'# -> unI64 618+  '\xa7b0'# -> unI64 670+  '\xa7b1'# -> unI64 647+  '\xa7b2'# -> unI64 669+  '\xa7b3'# -> unI64 43859+  '\xa7b4'# -> unI64 42933+  '\xa7b6'# -> unI64 42935+  '\xa7b8'# -> unI64 42937+  '\xa7ba'# -> unI64 42939+  '\xa7bc'# -> unI64 42941+  '\xa7be'# -> unI64 42943+  '\xa7c0'# -> unI64 42945+  '\xa7c2'# -> unI64 42947+  '\xa7c4'# -> unI64 42900+  '\xa7c5'# -> unI64 642+  '\xa7c6'# -> unI64 7566+  '\xa7c7'# -> unI64 42952+  '\xa7c9'# -> unI64 42954+  '\xa7d0'# -> unI64 42961+  '\xa7d6'# -> unI64 42967+  '\xa7d8'# -> unI64 42969+  '\xa7f5'# -> unI64 42998+  '\xff21'# -> unI64 65345+  '\xff22'# -> unI64 65346+  '\xff23'# -> unI64 65347+  '\xff24'# -> unI64 65348+  '\xff25'# -> unI64 65349+  '\xff26'# -> unI64 65350+  '\xff27'# -> unI64 65351+  '\xff28'# -> unI64 65352+  '\xff29'# -> unI64 65353+  '\xff2a'# -> unI64 65354+  '\xff2b'# -> unI64 65355+  '\xff2c'# -> unI64 65356+  '\xff2d'# -> unI64 65357+  '\xff2e'# -> unI64 65358+  '\xff2f'# -> unI64 65359+  '\xff30'# -> unI64 65360+  '\xff31'# -> unI64 65361+  '\xff32'# -> unI64 65362+  '\xff33'# -> unI64 65363+  '\xff34'# -> unI64 65364+  '\xff35'# -> unI64 65365+  '\xff36'# -> unI64 65366+  '\xff37'# -> unI64 65367+  '\xff38'# -> unI64 65368+  '\xff39'# -> unI64 65369+  '\xff3a'# -> unI64 65370+  '\x10400'# -> unI64 66600+  '\x10401'# -> unI64 66601+  '\x10402'# -> unI64 66602+  '\x10403'# -> unI64 66603+  '\x10404'# -> unI64 66604+  '\x10405'# -> unI64 66605+  '\x10406'# -> unI64 66606+  '\x10407'# -> unI64 66607+  '\x10408'# -> unI64 66608+  '\x10409'# -> unI64 66609+  '\x1040a'# -> unI64 66610+  '\x1040b'# -> unI64 66611+  '\x1040c'# -> unI64 66612+  '\x1040d'# -> unI64 66613+  '\x1040e'# -> unI64 66614+  '\x1040f'# -> unI64 66615+  '\x10410'# -> unI64 66616+  '\x10411'# -> unI64 66617+  '\x10412'# -> unI64 66618+  '\x10413'# -> unI64 66619+  '\x10414'# -> unI64 66620+  '\x10415'# -> unI64 66621+  '\x10416'# -> unI64 66622+  '\x10417'# -> unI64 66623+  '\x10418'# -> unI64 66624+  '\x10419'# -> unI64 66625+  '\x1041a'# -> unI64 66626+  '\x1041b'# -> unI64 66627+  '\x1041c'# -> unI64 66628+  '\x1041d'# -> unI64 66629+  '\x1041e'# -> unI64 66630+  '\x1041f'# -> unI64 66631+  '\x10420'# -> unI64 66632+  '\x10421'# -> unI64 66633+  '\x10422'# -> unI64 66634+  '\x10423'# -> unI64 66635+  '\x10424'# -> unI64 66636+  '\x10425'# -> unI64 66637+  '\x10426'# -> unI64 66638+  '\x10427'# -> unI64 66639+  '\x104b0'# -> unI64 66776+  '\x104b1'# -> unI64 66777+  '\x104b2'# -> unI64 66778+  '\x104b3'# -> unI64 66779+  '\x104b4'# -> unI64 66780+  '\x104b5'# -> unI64 66781+  '\x104b6'# -> unI64 66782+  '\x104b7'# -> unI64 66783+  '\x104b8'# -> unI64 66784+  '\x104b9'# -> unI64 66785+  '\x104ba'# -> unI64 66786+  '\x104bb'# -> unI64 66787+  '\x104bc'# -> unI64 66788+  '\x104bd'# -> unI64 66789+  '\x104be'# -> unI64 66790+  '\x104bf'# -> unI64 66791+  '\x104c0'# -> unI64 66792+  '\x104c1'# -> unI64 66793+  '\x104c2'# -> unI64 66794+  '\x104c3'# -> unI64 66795+  '\x104c4'# -> unI64 66796+  '\x104c5'# -> unI64 66797+  '\x104c6'# -> unI64 66798+  '\x104c7'# -> unI64 66799+  '\x104c8'# -> unI64 66800+  '\x104c9'# -> unI64 66801+  '\x104ca'# -> unI64 66802+  '\x104cb'# -> unI64 66803+  '\x104cc'# -> unI64 66804+  '\x104cd'# -> unI64 66805+  '\x104ce'# -> unI64 66806+  '\x104cf'# -> unI64 66807+  '\x104d0'# -> unI64 66808+  '\x104d1'# -> unI64 66809+  '\x104d2'# -> unI64 66810+  '\x104d3'# -> unI64 66811+  '\x10570'# -> unI64 66967+  '\x10571'# -> unI64 66968+  '\x10572'# -> unI64 66969+  '\x10573'# -> unI64 66970+  '\x10574'# -> unI64 66971+  '\x10575'# -> unI64 66972+  '\x10576'# -> unI64 66973+  '\x10577'# -> unI64 66974+  '\x10578'# -> unI64 66975+  '\x10579'# -> unI64 66976+  '\x1057a'# -> unI64 66977+  '\x1057c'# -> unI64 66979+  '\x1057d'# -> unI64 66980+  '\x1057e'# -> unI64 66981+  '\x1057f'# -> unI64 66982+  '\x10580'# -> unI64 66983+  '\x10581'# -> unI64 66984+  '\x10582'# -> unI64 66985+  '\x10583'# -> unI64 66986+  '\x10584'# -> unI64 66987+  '\x10585'# -> unI64 66988+  '\x10586'# -> unI64 66989+  '\x10587'# -> unI64 66990+  '\x10588'# -> unI64 66991+  '\x10589'# -> unI64 66992+  '\x1058a'# -> unI64 66993+  '\x1058c'# -> unI64 66995+  '\x1058d'# -> unI64 66996+  '\x1058e'# -> unI64 66997+  '\x1058f'# -> unI64 66998+  '\x10590'# -> unI64 66999+  '\x10591'# -> unI64 67000+  '\x10592'# -> unI64 67001+  '\x10594'# -> unI64 67003+  '\x10595'# -> unI64 67004+  '\x10c80'# -> unI64 68800+  '\x10c81'# -> unI64 68801+  '\x10c82'# -> unI64 68802+  '\x10c83'# -> unI64 68803+  '\x10c84'# -> unI64 68804+  '\x10c85'# -> unI64 68805+  '\x10c86'# -> unI64 68806+  '\x10c87'# -> unI64 68807+  '\x10c88'# -> unI64 68808+  '\x10c89'# -> unI64 68809+  '\x10c8a'# -> unI64 68810+  '\x10c8b'# -> unI64 68811+  '\x10c8c'# -> unI64 68812+  '\x10c8d'# -> unI64 68813+  '\x10c8e'# -> unI64 68814+  '\x10c8f'# -> unI64 68815+  '\x10c90'# -> unI64 68816+  '\x10c91'# -> unI64 68817+  '\x10c92'# -> unI64 68818+  '\x10c93'# -> unI64 68819+  '\x10c94'# -> unI64 68820+  '\x10c95'# -> unI64 68821+  '\x10c96'# -> unI64 68822+  '\x10c97'# -> unI64 68823+  '\x10c98'# -> unI64 68824+  '\x10c99'# -> unI64 68825+  '\x10c9a'# -> unI64 68826+  '\x10c9b'# -> unI64 68827+  '\x10c9c'# -> unI64 68828+  '\x10c9d'# -> unI64 68829+  '\x10c9e'# -> unI64 68830+  '\x10c9f'# -> unI64 68831+  '\x10ca0'# -> unI64 68832+  '\x10ca1'# -> unI64 68833+  '\x10ca2'# -> unI64 68834+  '\x10ca3'# -> unI64 68835+  '\x10ca4'# -> unI64 68836+  '\x10ca5'# -> unI64 68837+  '\x10ca6'# -> unI64 68838+  '\x10ca7'# -> unI64 68839+  '\x10ca8'# -> unI64 68840+  '\x10ca9'# -> unI64 68841+  '\x10caa'# -> unI64 68842+  '\x10cab'# -> unI64 68843+  '\x10cac'# -> unI64 68844+  '\x10cad'# -> unI64 68845+  '\x10cae'# -> unI64 68846+  '\x10caf'# -> unI64 68847+  '\x10cb0'# -> unI64 68848+  '\x10cb1'# -> unI64 68849+  '\x10cb2'# -> unI64 68850+  '\x118a0'# -> unI64 71872+  '\x118a1'# -> unI64 71873+  '\x118a2'# -> unI64 71874+  '\x118a3'# -> unI64 71875+  '\x118a4'# -> unI64 71876+  '\x118a5'# -> unI64 71877+  '\x118a6'# -> unI64 71878+  '\x118a7'# -> unI64 71879+  '\x118a8'# -> unI64 71880+  '\x118a9'# -> unI64 71881+  '\x118aa'# -> unI64 71882+  '\x118ab'# -> unI64 71883+  '\x118ac'# -> unI64 71884+  '\x118ad'# -> unI64 71885+  '\x118ae'# -> unI64 71886+  '\x118af'# -> unI64 71887+  '\x118b0'# -> unI64 71888+  '\x118b1'# -> unI64 71889+  '\x118b2'# -> unI64 71890+  '\x118b3'# -> unI64 71891+  '\x118b4'# -> unI64 71892+  '\x118b5'# -> unI64 71893+  '\x118b6'# -> unI64 71894+  '\x118b7'# -> unI64 71895+  '\x118b8'# -> unI64 71896+  '\x118b9'# -> unI64 71897+  '\x118ba'# -> unI64 71898+  '\x118bb'# -> unI64 71899+  '\x118bc'# -> unI64 71900+  '\x118bd'# -> unI64 71901+  '\x118be'# -> unI64 71902+  '\x118bf'# -> unI64 71903+  '\x16e40'# -> unI64 93792+  '\x16e41'# -> unI64 93793+  '\x16e42'# -> unI64 93794+  '\x16e43'# -> unI64 93795+  '\x16e44'# -> unI64 93796+  '\x16e45'# -> unI64 93797+  '\x16e46'# -> unI64 93798+  '\x16e47'# -> unI64 93799+  '\x16e48'# -> unI64 93800+  '\x16e49'# -> unI64 93801+  '\x16e4a'# -> unI64 93802+  '\x16e4b'# -> unI64 93803+  '\x16e4c'# -> unI64 93804+  '\x16e4d'# -> unI64 93805+  '\x16e4e'# -> unI64 93806+  '\x16e4f'# -> unI64 93807+  '\x16e50'# -> unI64 93808+  '\x16e51'# -> unI64 93809+  '\x16e52'# -> unI64 93810+  '\x16e53'# -> unI64 93811+  '\x16e54'# -> unI64 93812+  '\x16e55'# -> unI64 93813+  '\x16e56'# -> unI64 93814+  '\x16e57'# -> unI64 93815+  '\x16e58'# -> unI64 93816+  '\x16e59'# -> unI64 93817+  '\x16e5a'# -> unI64 93818+  '\x16e5b'# -> unI64 93819+  '\x16e5c'# -> unI64 93820+  '\x16e5d'# -> unI64 93821+  '\x16e5e'# -> unI64 93822+  '\x16e5f'# -> unI64 93823+  '\x1e900'# -> unI64 125218+  '\x1e901'# -> unI64 125219+  '\x1e902'# -> unI64 125220+  '\x1e903'# -> unI64 125221+  '\x1e904'# -> unI64 125222+  '\x1e905'# -> unI64 125223+  '\x1e906'# -> unI64 125224+  '\x1e907'# -> unI64 125225+  '\x1e908'# -> unI64 125226+  '\x1e909'# -> unI64 125227+  '\x1e90a'# -> unI64 125228+  '\x1e90b'# -> unI64 125229+  '\x1e90c'# -> unI64 125230+  '\x1e90d'# -> unI64 125231+  '\x1e90e'# -> unI64 125232+  '\x1e90f'# -> unI64 125233+  '\x1e910'# -> unI64 125234+  '\x1e911'# -> unI64 125235+  '\x1e912'# -> unI64 125236+  '\x1e913'# -> unI64 125237+  '\x1e914'# -> unI64 125238+  '\x1e915'# -> unI64 125239+  '\x1e916'# -> unI64 125240+  '\x1e917'# -> unI64 125241+  '\x1e918'# -> unI64 125242+  '\x1e919'# -> unI64 125243+  '\x1e91a'# -> unI64 125244+  '\x1e91b'# -> unI64 125245+  '\x1e91c'# -> unI64 125246+  '\x1e91d'# -> unI64 125247+  '\x1e91e'# -> unI64 125248+  '\x1e91f'# -> unI64 125249+  '\x1e920'# -> unI64 125250+  '\x1e921'# -> unI64 125251+  _ -> unI64 0+titleMapping :: Char# -> _ {- unboxed Int64 -}+{-# NOINLINE titleMapping #-}+titleMapping = \case+  -- LATIN SMALL LETTER SHARP S+  '\x00df'# -> unI64 241172563+  -- LATIN SMALL LIGATURE FF+  '\xfb00'# -> unI64 213909574+  -- LATIN SMALL LIGATURE FI+  '\xfb01'# -> unI64 220201030+  -- LATIN SMALL LIGATURE FL+  '\xfb02'# -> unI64 226492486+  -- LATIN SMALL LIGATURE FFI+  '\xfb03'# -> unI64 461795097575494+  -- LATIN SMALL LIGATURE FFL+  '\xfb04'# -> unI64 474989237108806+  -- LATIN SMALL LIGATURE LONG S T+  '\xfb05'# -> unI64 243269715+  -- LATIN SMALL LIGATURE ST+  '\xfb06'# -> unI64 243269715+  -- ARMENIAN SMALL LIGATURE ECH YIWN+  '\x0587'# -> unI64 2956985653+  -- ARMENIAN SMALL LIGATURE MEN NOW+  '\xfb13'# -> unI64 2931819844+  -- ARMENIAN SMALL LIGATURE MEN ECH+  '\xfb14'# -> unI64 2896168260+  -- ARMENIAN SMALL LIGATURE MEN INI+  '\xfb15'# -> unI64 2908751172+  -- ARMENIAN SMALL LIGATURE VEW NOW+  '\xfb16'# -> unI64 2931819854+  -- ARMENIAN SMALL LIGATURE MEN XEH+  '\xfb17'# -> unI64 2912945476+  -- LATIN SMALL LETTER N PRECEDED BY APOSTROPHE+  '\x0149'# -> unI64 163578556+  -- GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS+  '\x0390'# -> unI64 3382099394429849+  -- GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS+  '\x03b0'# -> unI64 3382099394429861+  -- LATIN SMALL LETTER J WITH CARON+  '\x01f0'# -> unI64 1635778634+  -- LATIN SMALL LETTER H WITH LINE BELOW+  '\x1e96'# -> unI64 1713373256+  -- LATIN SMALL LETTER T WITH DIAERESIS+  '\x1e97'# -> unI64 1627390036+  -- LATIN SMALL LETTER W WITH RING ABOVE+  '\x1e98'# -> unI64 1631584343+  -- LATIN SMALL LETTER Y WITH RING ABOVE+  '\x1e99'# -> unI64 1631584345+  -- LATIN SMALL LETTER A WITH RIGHT HALF RING+  '\x1e9a'# -> unI64 1472200769+  -- GREEK SMALL LETTER UPSILON WITH PSILI+  '\x1f50'# -> unI64 1650459557+  -- GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA+  '\x1f52'# -> unI64 3377701370987429+  -- GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA+  '\x1f54'# -> unI64 3382099417498533+  -- GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI+  '\x1f56'# -> unI64 3667972440720293+  -- GREEK SMALL LETTER ALPHA WITH PERISPOMENI+  '\x1fb6'# -> unI64 1749025681+  -- GREEK SMALL LETTER ETA WITH PERISPOMENI+  '\x1fc6'# -> unI64 1749025687+  -- GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA+  '\x1fd2'# -> unI64 3377701347918745+  -- GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA+  '\x1fd3'# -> unI64 3382099394429849+  -- GREEK SMALL LETTER IOTA WITH PERISPOMENI+  '\x1fd6'# -> unI64 1749025689+  -- GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI+  '\x1fd7'# -> unI64 3667972417651609+  -- GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA+  '\x1fe2'# -> unI64 3377701347918757+  -- GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA+  '\x1fe3'# -> unI64 3382099394429861+  -- GREEK SMALL LETTER RHO WITH PSILI+  '\x1fe4'# -> unI64 1650459553+  -- GREEK SMALL LETTER UPSILON WITH PERISPOMENI+  '\x1fe6'# -> unI64 1749025701+  -- GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI+  '\x1fe7'# -> unI64 3667972417651621+  -- GREEK SMALL LETTER OMEGA WITH PERISPOMENI+  '\x1ff6'# -> unI64 1749025705+  -- GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI+  '\x1fb2'# -> unI64 1755324346+  -- GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI+  '\x1fb4'# -> unI64 1755317126+  -- GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI+  '\x1fc2'# -> unI64 1755324362+  -- GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI+  '\x1fc4'# -> unI64 1755317129+  -- GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI+  '\x1ff2'# -> unI64 1755324410+  -- GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI+  '\x1ff4'# -> unI64 1755317135+  -- GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI+  '\x1fb7'# -> unI64 3681166678819729+  -- GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI+  '\x1fc7'# -> unI64 3681166678819735+  -- GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI+  '\x1ff7'# -> unI64 3681166678819753+  '\x0061'# -> unI64 65+  '\x0062'# -> unI64 66+  '\x0063'# -> unI64 67+  '\x0064'# -> unI64 68+  '\x0065'# -> unI64 69+  '\x0066'# -> unI64 70+  '\x0067'# -> unI64 71+  '\x0068'# -> unI64 72+  '\x0069'# -> unI64 73+  '\x006a'# -> unI64 74+  '\x006b'# -> unI64 75+  '\x006c'# -> unI64 76+  '\x006d'# -> unI64 77+  '\x006e'# -> unI64 78+  '\x006f'# -> unI64 79+  '\x0070'# -> unI64 80+  '\x0071'# -> unI64 81+  '\x0072'# -> unI64 82+  '\x0073'# -> unI64 83+  '\x0074'# -> unI64 84+  '\x0075'# -> unI64 85+  '\x0076'# -> unI64 86+  '\x0077'# -> unI64 87+  '\x0078'# -> unI64 88+  '\x0079'# -> unI64 89+  '\x007a'# -> unI64 90+  '\x00b5'# -> unI64 924+  '\x00e0'# -> unI64 192+  '\x00e1'# -> unI64 193+  '\x00e2'# -> unI64 194+  '\x00e3'# -> unI64 195+  '\x00e4'# -> unI64 196+  '\x00e5'# -> unI64 197+  '\x00e6'# -> unI64 198+  '\x00e7'# -> unI64 199+  '\x00e8'# -> unI64 200+  '\x00e9'# -> unI64 201+  '\x00ea'# -> unI64 202+  '\x00eb'# -> unI64 203+  '\x00ec'# -> unI64 204+  '\x00ed'# -> unI64 205+  '\x00ee'# -> unI64 206+  '\x00ef'# -> unI64 207+  '\x00f0'# -> unI64 208+  '\x00f1'# -> unI64 209+  '\x00f2'# -> unI64 210+  '\x00f3'# -> unI64 211+  '\x00f4'# -> unI64 212+  '\x00f5'# -> unI64 213+  '\x00f6'# -> unI64 214+  '\x00f8'# -> unI64 216+  '\x00f9'# -> unI64 217+  '\x00fa'# -> unI64 218+  '\x00fb'# -> unI64 219+  '\x00fc'# -> unI64 220+  '\x00fd'# -> unI64 221+  '\x00fe'# -> unI64 222+  '\x00ff'# -> unI64 376+  '\x0101'# -> unI64 256+  '\x0103'# -> unI64 258+  '\x0105'# -> unI64 260+  '\x0107'# -> unI64 262+  '\x0109'# -> unI64 264+  '\x010b'# -> unI64 266+  '\x010d'# -> unI64 268+  '\x010f'# -> unI64 270+  '\x0111'# -> unI64 272+  '\x0113'# -> unI64 274+  '\x0115'# -> unI64 276+  '\x0117'# -> unI64 278+  '\x0119'# -> unI64 280+  '\x011b'# -> unI64 282+  '\x011d'# -> unI64 284+  '\x011f'# -> unI64 286+  '\x0121'# -> unI64 288+  '\x0123'# -> unI64 290+  '\x0125'# -> unI64 292+  '\x0127'# -> unI64 294+  '\x0129'# -> unI64 296+  '\x012b'# -> unI64 298+  '\x012d'# -> unI64 300+  '\x012f'# -> unI64 302+  '\x0131'# -> unI64 73+  '\x0133'# -> unI64 306+  '\x0135'# -> unI64 308+  '\x0137'# -> unI64 310+  '\x013a'# -> unI64 313+  '\x013c'# -> unI64 315+  '\x013e'# -> unI64 317+  '\x0140'# -> unI64 319+  '\x0142'# -> unI64 321+  '\x0144'# -> unI64 323+  '\x0146'# -> unI64 325+  '\x0148'# -> unI64 327+  '\x014b'# -> unI64 330+  '\x014d'# -> unI64 332+  '\x014f'# -> unI64 334+  '\x0151'# -> unI64 336+  '\x0153'# -> unI64 338+  '\x0155'# -> unI64 340+  '\x0157'# -> unI64 342+  '\x0159'# -> unI64 344+  '\x015b'# -> unI64 346+  '\x015d'# -> unI64 348+  '\x015f'# -> unI64 350+  '\x0161'# -> unI64 352+  '\x0163'# -> unI64 354+  '\x0165'# -> unI64 356+  '\x0167'# -> unI64 358+  '\x0169'# -> unI64 360+  '\x016b'# -> unI64 362+  '\x016d'# -> unI64 364+  '\x016f'# -> unI64 366+  '\x0171'# -> unI64 368+  '\x0173'# -> unI64 370+  '\x0175'# -> unI64 372+  '\x0177'# -> unI64 374+  '\x017a'# -> unI64 377+  '\x017c'# -> unI64 379+  '\x017e'# -> unI64 381+  '\x017f'# -> unI64 83+  '\x0180'# -> unI64 579+  '\x0183'# -> unI64 386+  '\x0185'# -> unI64 388+  '\x0188'# -> unI64 391+  '\x018c'# -> unI64 395+  '\x0192'# -> unI64 401+  '\x0195'# -> unI64 502+  '\x0199'# -> unI64 408+  '\x019a'# -> unI64 573+  '\x019e'# -> unI64 544+  '\x01a1'# -> unI64 416+  '\x01a3'# -> unI64 418+  '\x01a5'# -> unI64 420+  '\x01a8'# -> unI64 423+  '\x01ad'# -> unI64 428+  '\x01b0'# -> unI64 431+  '\x01b4'# -> unI64 435+  '\x01b6'# -> unI64 437+  '\x01b9'# -> unI64 440+  '\x01bd'# -> unI64 444+  '\x01bf'# -> unI64 503+  '\x01c4'# -> unI64 453+  '\x01c6'# -> unI64 453+  '\x01c7'# -> unI64 456+  '\x01c9'# -> unI64 456+  '\x01ca'# -> unI64 459+  '\x01cc'# -> unI64 459+  '\x01ce'# -> unI64 461+  '\x01d0'# -> unI64 463+  '\x01d2'# -> unI64 465+  '\x01d4'# -> unI64 467+  '\x01d6'# -> unI64 469+  '\x01d8'# -> unI64 471+  '\x01da'# -> unI64 473+  '\x01dc'# -> unI64 475+  '\x01dd'# -> unI64 398+  '\x01df'# -> unI64 478+  '\x01e1'# -> unI64 480+  '\x01e3'# -> unI64 482+  '\x01e5'# -> unI64 484+  '\x01e7'# -> unI64 486+  '\x01e9'# -> unI64 488+  '\x01eb'# -> unI64 490+  '\x01ed'# -> unI64 492+  '\x01ef'# -> unI64 494+  '\x01f1'# -> unI64 498+  '\x01f3'# -> unI64 498+  '\x01f5'# -> unI64 500+  '\x01f9'# -> unI64 504+  '\x01fb'# -> unI64 506+  '\x01fd'# -> unI64 508+  '\x01ff'# -> unI64 510+  '\x0201'# -> unI64 512+  '\x0203'# -> unI64 514+  '\x0205'# -> unI64 516+  '\x0207'# -> unI64 518+  '\x0209'# -> unI64 520+  '\x020b'# -> unI64 522+  '\x020d'# -> unI64 524+  '\x020f'# -> unI64 526+  '\x0211'# -> unI64 528+  '\x0213'# -> unI64 530+  '\x0215'# -> unI64 532+  '\x0217'# -> unI64 534+  '\x0219'# -> unI64 536+  '\x021b'# -> unI64 538+  '\x021d'# -> unI64 540+  '\x021f'# -> unI64 542+  '\x0223'# -> unI64 546+  '\x0225'# -> unI64 548+  '\x0227'# -> unI64 550+  '\x0229'# -> unI64 552+  '\x022b'# -> unI64 554+  '\x022d'# -> unI64 556+  '\x022f'# -> unI64 558+  '\x0231'# -> unI64 560+  '\x0233'# -> unI64 562+  '\x023c'# -> unI64 571+  '\x023f'# -> unI64 11390+  '\x0240'# -> unI64 11391+  '\x0242'# -> unI64 577+  '\x0247'# -> unI64 582+  '\x0249'# -> unI64 584+  '\x024b'# -> unI64 586+  '\x024d'# -> unI64 588+  '\x024f'# -> unI64 590+  '\x0250'# -> unI64 11375+  '\x0251'# -> unI64 11373+  '\x0252'# -> unI64 11376+  '\x0253'# -> unI64 385+  '\x0254'# -> unI64 390+  '\x0256'# -> unI64 393+  '\x0257'# -> unI64 394+  '\x0259'# -> unI64 399+  '\x025b'# -> unI64 400+  '\x025c'# -> unI64 42923+  '\x0260'# -> unI64 403+  '\x0261'# -> unI64 42924+  '\x0263'# -> unI64 404+  '\x0265'# -> unI64 42893+  '\x0266'# -> unI64 42922+  '\x0268'# -> unI64 407+  '\x0269'# -> unI64 406+  '\x026a'# -> unI64 42926+  '\x026b'# -> unI64 11362+  '\x026c'# -> unI64 42925+  '\x026f'# -> unI64 412+  '\x0271'# -> unI64 11374+  '\x0272'# -> unI64 413+  '\x0275'# -> unI64 415+  '\x027d'# -> unI64 11364+  '\x0280'# -> unI64 422+  '\x0282'# -> unI64 42949+  '\x0283'# -> unI64 425+  '\x0287'# -> unI64 42929+  '\x0288'# -> unI64 430+  '\x0289'# -> unI64 580+  '\x028a'# -> unI64 433+  '\x028b'# -> unI64 434+  '\x028c'# -> unI64 581+  '\x0292'# -> unI64 439+  '\x029d'# -> unI64 42930+  '\x029e'# -> unI64 42928+  '\x0345'# -> unI64 921+  '\x0371'# -> unI64 880+  '\x0373'# -> unI64 882+  '\x0377'# -> unI64 886+  '\x037b'# -> unI64 1021+  '\x037c'# -> unI64 1022+  '\x037d'# -> unI64 1023+  '\x03ac'# -> unI64 902+  '\x03ad'# -> unI64 904+  '\x03ae'# -> unI64 905+  '\x03af'# -> unI64 906+  '\x03b1'# -> unI64 913+  '\x03b2'# -> unI64 914+  '\x03b3'# -> unI64 915+  '\x03b4'# -> unI64 916+  '\x03b5'# -> unI64 917+  '\x03b6'# -> unI64 918+  '\x03b7'# -> unI64 919+  '\x03b8'# -> unI64 920+  '\x03b9'# -> unI64 921+  '\x03ba'# -> unI64 922+  '\x03bb'# -> unI64 923+  '\x03bc'# -> unI64 924+  '\x03bd'# -> unI64 925+  '\x03be'# -> unI64 926+  '\x03bf'# -> unI64 927+  '\x03c0'# -> unI64 928+  '\x03c1'# -> unI64 929+  '\x03c2'# -> unI64 931+  '\x03c3'# -> unI64 931+  '\x03c4'# -> unI64 932+  '\x03c5'# -> unI64 933+  '\x03c6'# -> unI64 934+  '\x03c7'# -> unI64 935+  '\x03c8'# -> unI64 936+  '\x03c9'# -> unI64 937+  '\x03ca'# -> unI64 938+  '\x03cb'# -> unI64 939+  '\x03cc'# -> unI64 908+  '\x03cd'# -> unI64 910+  '\x03ce'# -> unI64 911+  '\x03d0'# -> unI64 914+  '\x03d1'# -> unI64 920+  '\x03d5'# -> unI64 934+  '\x03d6'# -> unI64 928+  '\x03d7'# -> unI64 975+  '\x03d9'# -> unI64 984+  '\x03db'# -> unI64 986+  '\x03dd'# -> unI64 988+  '\x03df'# -> unI64 990+  '\x03e1'# -> unI64 992+  '\x03e3'# -> unI64 994+  '\x03e5'# -> unI64 996+  '\x03e7'# -> unI64 998+  '\x03e9'# -> unI64 1000+  '\x03eb'# -> unI64 1002+  '\x03ed'# -> unI64 1004+  '\x03ef'# -> unI64 1006+  '\x03f0'# -> unI64 922+  '\x03f1'# -> unI64 929+  '\x03f2'# -> unI64 1017+  '\x03f3'# -> unI64 895+  '\x03f5'# -> unI64 917+  '\x03f8'# -> unI64 1015+  '\x03fb'# -> unI64 1018+  '\x0430'# -> unI64 1040+  '\x0431'# -> unI64 1041+  '\x0432'# -> unI64 1042+  '\x0433'# -> unI64 1043+  '\x0434'# -> unI64 1044+  '\x0435'# -> unI64 1045+  '\x0436'# -> unI64 1046+  '\x0437'# -> unI64 1047+  '\x0438'# -> unI64 1048+  '\x0439'# -> unI64 1049+  '\x043a'# -> unI64 1050+  '\x043b'# -> unI64 1051+  '\x043c'# -> unI64 1052+  '\x043d'# -> unI64 1053+  '\x043e'# -> unI64 1054+  '\x043f'# -> unI64 1055+  '\x0440'# -> unI64 1056+  '\x0441'# -> unI64 1057+  '\x0442'# -> unI64 1058+  '\x0443'# -> unI64 1059+  '\x0444'# -> unI64 1060+  '\x0445'# -> unI64 1061+  '\x0446'# -> unI64 1062+  '\x0447'# -> unI64 1063+  '\x0448'# -> unI64 1064+  '\x0449'# -> unI64 1065+  '\x044a'# -> unI64 1066+  '\x044b'# -> unI64 1067+  '\x044c'# -> unI64 1068+  '\x044d'# -> unI64 1069+  '\x044e'# -> unI64 1070+  '\x044f'# -> unI64 1071+  '\x0450'# -> unI64 1024+  '\x0451'# -> unI64 1025+  '\x0452'# -> unI64 1026+  '\x0453'# -> unI64 1027+  '\x0454'# -> unI64 1028+  '\x0455'# -> unI64 1029+  '\x0456'# -> unI64 1030+  '\x0457'# -> unI64 1031+  '\x0458'# -> unI64 1032+  '\x0459'# -> unI64 1033+  '\x045a'# -> unI64 1034+  '\x045b'# -> unI64 1035+  '\x045c'# -> unI64 1036+  '\x045d'# -> unI64 1037+  '\x045e'# -> unI64 1038+  '\x045f'# -> unI64 1039+  '\x0461'# -> unI64 1120+  '\x0463'# -> unI64 1122+  '\x0465'# -> unI64 1124+  '\x0467'# -> unI64 1126+  '\x0469'# -> unI64 1128+  '\x046b'# -> unI64 1130+  '\x046d'# -> unI64 1132+  '\x046f'# -> unI64 1134+  '\x0471'# -> unI64 1136+  '\x0473'# -> unI64 1138+  '\x0475'# -> unI64 1140+  '\x0477'# -> unI64 1142+  '\x0479'# -> unI64 1144+  '\x047b'# -> unI64 1146+  '\x047d'# -> unI64 1148+  '\x047f'# -> unI64 1150+  '\x0481'# -> unI64 1152+  '\x048b'# -> unI64 1162+  '\x048d'# -> unI64 1164+  '\x048f'# -> unI64 1166+  '\x0491'# -> unI64 1168+  '\x0493'# -> unI64 1170+  '\x0495'# -> unI64 1172+  '\x0497'# -> unI64 1174+  '\x0499'# -> unI64 1176+  '\x049b'# -> unI64 1178+  '\x049d'# -> unI64 1180+  '\x049f'# -> unI64 1182+  '\x04a1'# -> unI64 1184+  '\x04a3'# -> unI64 1186+  '\x04a5'# -> unI64 1188+  '\x04a7'# -> unI64 1190+  '\x04a9'# -> unI64 1192+  '\x04ab'# -> unI64 1194+  '\x04ad'# -> unI64 1196+  '\x04af'# -> unI64 1198+  '\x04b1'# -> unI64 1200+  '\x04b3'# -> unI64 1202+  '\x04b5'# -> unI64 1204+  '\x04b7'# -> unI64 1206+  '\x04b9'# -> unI64 1208+  '\x04bb'# -> unI64 1210+  '\x04bd'# -> unI64 1212+  '\x04bf'# -> unI64 1214+  '\x04c2'# -> unI64 1217+  '\x04c4'# -> unI64 1219+  '\x04c6'# -> unI64 1221+  '\x04c8'# -> unI64 1223+  '\x04ca'# -> unI64 1225+  '\x04cc'# -> unI64 1227+  '\x04ce'# -> unI64 1229+  '\x04cf'# -> unI64 1216+  '\x04d1'# -> unI64 1232+  '\x04d3'# -> unI64 1234+  '\x04d5'# -> unI64 1236+  '\x04d7'# -> unI64 1238+  '\x04d9'# -> unI64 1240+  '\x04db'# -> unI64 1242+  '\x04dd'# -> unI64 1244+  '\x04df'# -> unI64 1246+  '\x04e1'# -> unI64 1248+  '\x04e3'# -> unI64 1250+  '\x04e5'# -> unI64 1252+  '\x04e7'# -> unI64 1254+  '\x04e9'# -> unI64 1256+  '\x04eb'# -> unI64 1258+  '\x04ed'# -> unI64 1260+  '\x04ef'# -> unI64 1262+  '\x04f1'# -> unI64 1264+  '\x04f3'# -> unI64 1266+  '\x04f5'# -> unI64 1268+  '\x04f7'# -> unI64 1270+  '\x04f9'# -> unI64 1272+  '\x04fb'# -> unI64 1274+  '\x04fd'# -> unI64 1276+  '\x04ff'# -> unI64 1278+  '\x0501'# -> unI64 1280+  '\x0503'# -> unI64 1282+  '\x0505'# -> unI64 1284+  '\x0507'# -> unI64 1286+  '\x0509'# -> unI64 1288+  '\x050b'# -> unI64 1290+  '\x050d'# -> unI64 1292+  '\x050f'# -> unI64 1294+  '\x0511'# -> unI64 1296+  '\x0513'# -> unI64 1298+  '\x0515'# -> unI64 1300+  '\x0517'# -> unI64 1302+  '\x0519'# -> unI64 1304+  '\x051b'# -> unI64 1306+  '\x051d'# -> unI64 1308+  '\x051f'# -> unI64 1310+  '\x0521'# -> unI64 1312+  '\x0523'# -> unI64 1314+  '\x0525'# -> unI64 1316+  '\x0527'# -> unI64 1318+  '\x0529'# -> unI64 1320+  '\x052b'# -> unI64 1322+  '\x052d'# -> unI64 1324+  '\x052f'# -> unI64 1326+  '\x0561'# -> unI64 1329+  '\x0562'# -> unI64 1330+  '\x0563'# -> unI64 1331+  '\x0564'# -> unI64 1332+  '\x0565'# -> unI64 1333+  '\x0566'# -> unI64 1334+  '\x0567'# -> unI64 1335+  '\x0568'# -> unI64 1336+  '\x0569'# -> unI64 1337+  '\x056a'# -> unI64 1338+  '\x056b'# -> unI64 1339+  '\x056c'# -> unI64 1340+  '\x056d'# -> unI64 1341+  '\x056e'# -> unI64 1342+  '\x056f'# -> unI64 1343+  '\x0570'# -> unI64 1344+  '\x0571'# -> unI64 1345+  '\x0572'# -> unI64 1346+  '\x0573'# -> unI64 1347+  '\x0574'# -> unI64 1348+  '\x0575'# -> unI64 1349+  '\x0576'# -> unI64 1350+  '\x0577'# -> unI64 1351+  '\x0578'# -> unI64 1352+  '\x0579'# -> unI64 1353+  '\x057a'# -> unI64 1354+  '\x057b'# -> unI64 1355+  '\x057c'# -> unI64 1356+  '\x057d'# -> unI64 1357+  '\x057e'# -> unI64 1358+  '\x057f'# -> unI64 1359+  '\x0580'# -> unI64 1360+  '\x0581'# -> unI64 1361+  '\x0582'# -> unI64 1362+  '\x0583'# -> unI64 1363+  '\x0584'# -> unI64 1364+  '\x0585'# -> unI64 1365+  '\x0586'# -> unI64 1366+  '\x13f8'# -> unI64 5104+  '\x13f9'# -> unI64 5105+  '\x13fa'# -> unI64 5106+  '\x13fb'# -> unI64 5107+  '\x13fc'# -> unI64 5108+  '\x13fd'# -> unI64 5109+  '\x1c80'# -> unI64 1042+  '\x1c81'# -> unI64 1044+  '\x1c82'# -> unI64 1054+  '\x1c83'# -> unI64 1057+  '\x1c84'# -> unI64 1058+  '\x1c85'# -> unI64 1058+  '\x1c86'# -> unI64 1066+  '\x1c87'# -> unI64 1122+  '\x1c88'# -> unI64 42570+  '\x1d79'# -> unI64 42877+  '\x1d7d'# -> unI64 11363+  '\x1d8e'# -> unI64 42950+  '\x1e01'# -> unI64 7680+  '\x1e03'# -> unI64 7682+  '\x1e05'# -> unI64 7684+  '\x1e07'# -> unI64 7686+  '\x1e09'# -> unI64 7688+  '\x1e0b'# -> unI64 7690+  '\x1e0d'# -> unI64 7692+  '\x1e0f'# -> unI64 7694+  '\x1e11'# -> unI64 7696+  '\x1e13'# -> unI64 7698+  '\x1e15'# -> unI64 7700+  '\x1e17'# -> unI64 7702+  '\x1e19'# -> unI64 7704+  '\x1e1b'# -> unI64 7706+  '\x1e1d'# -> unI64 7708+  '\x1e1f'# -> unI64 7710+  '\x1e21'# -> unI64 7712+  '\x1e23'# -> unI64 7714+  '\x1e25'# -> unI64 7716+  '\x1e27'# -> unI64 7718+  '\x1e29'# -> unI64 7720+  '\x1e2b'# -> unI64 7722+  '\x1e2d'# -> unI64 7724+  '\x1e2f'# -> unI64 7726+  '\x1e31'# -> unI64 7728+  '\x1e33'# -> unI64 7730+  '\x1e35'# -> unI64 7732+  '\x1e37'# -> unI64 7734+  '\x1e39'# -> unI64 7736+  '\x1e3b'# -> unI64 7738+  '\x1e3d'# -> unI64 7740+  '\x1e3f'# -> unI64 7742+  '\x1e41'# -> unI64 7744+  '\x1e43'# -> unI64 7746+  '\x1e45'# -> unI64 7748+  '\x1e47'# -> unI64 7750+  '\x1e49'# -> unI64 7752+  '\x1e4b'# -> unI64 7754+  '\x1e4d'# -> unI64 7756+  '\x1e4f'# -> unI64 7758+  '\x1e51'# -> unI64 7760+  '\x1e53'# -> unI64 7762+  '\x1e55'# -> unI64 7764+  '\x1e57'# -> unI64 7766+  '\x1e59'# -> unI64 7768+  '\x1e5b'# -> unI64 7770+  '\x1e5d'# -> unI64 7772+  '\x1e5f'# -> unI64 7774+  '\x1e61'# -> unI64 7776+  '\x1e63'# -> unI64 7778+  '\x1e65'# -> unI64 7780+  '\x1e67'# -> unI64 7782+  '\x1e69'# -> unI64 7784+  '\x1e6b'# -> unI64 7786+  '\x1e6d'# -> unI64 7788+  '\x1e6f'# -> unI64 7790+  '\x1e71'# -> unI64 7792+  '\x1e73'# -> unI64 7794+  '\x1e75'# -> unI64 7796+  '\x1e77'# -> unI64 7798+  '\x1e79'# -> unI64 7800+  '\x1e7b'# -> unI64 7802+  '\x1e7d'# -> unI64 7804+  '\x1e7f'# -> unI64 7806+  '\x1e81'# -> unI64 7808+  '\x1e83'# -> unI64 7810+  '\x1e85'# -> unI64 7812+  '\x1e87'# -> unI64 7814+  '\x1e89'# -> unI64 7816+  '\x1e8b'# -> unI64 7818+  '\x1e8d'# -> unI64 7820+  '\x1e8f'# -> unI64 7822+  '\x1e91'# -> unI64 7824+  '\x1e93'# -> unI64 7826+  '\x1e95'# -> unI64 7828+  '\x1e9b'# -> unI64 7776+  '\x1ea1'# -> unI64 7840+  '\x1ea3'# -> unI64 7842+  '\x1ea5'# -> unI64 7844+  '\x1ea7'# -> unI64 7846+  '\x1ea9'# -> unI64 7848+  '\x1eab'# -> unI64 7850+  '\x1ead'# -> unI64 7852+  '\x1eaf'# -> unI64 7854+  '\x1eb1'# -> unI64 7856+  '\x1eb3'# -> unI64 7858+  '\x1eb5'# -> unI64 7860+  '\x1eb7'# -> unI64 7862+  '\x1eb9'# -> unI64 7864+  '\x1ebb'# -> unI64 7866+  '\x1ebd'# -> unI64 7868+  '\x1ebf'# -> unI64 7870+  '\x1ec1'# -> unI64 7872+  '\x1ec3'# -> unI64 7874+  '\x1ec5'# -> unI64 7876+  '\x1ec7'# -> unI64 7878+  '\x1ec9'# -> unI64 7880+  '\x1ecb'# -> unI64 7882+  '\x1ecd'# -> unI64 7884+  '\x1ecf'# -> unI64 7886+  '\x1ed1'# -> unI64 7888+  '\x1ed3'# -> unI64 7890+  '\x1ed5'# -> unI64 7892+  '\x1ed7'# -> unI64 7894+  '\x1ed9'# -> unI64 7896+  '\x1edb'# -> unI64 7898+  '\x1edd'# -> unI64 7900+  '\x1edf'# -> unI64 7902+  '\x1ee1'# -> unI64 7904+  '\x1ee3'# -> unI64 7906+  '\x1ee5'# -> unI64 7908+  '\x1ee7'# -> unI64 7910+  '\x1ee9'# -> unI64 7912+  '\x1eeb'# -> unI64 7914+  '\x1eed'# -> unI64 7916+  '\x1eef'# -> unI64 7918+  '\x1ef1'# -> unI64 7920+  '\x1ef3'# -> unI64 7922+  '\x1ef5'# -> unI64 7924+  '\x1ef7'# -> unI64 7926+  '\x1ef9'# -> unI64 7928+  '\x1efb'# -> unI64 7930+  '\x1efd'# -> unI64 7932+  '\x1eff'# -> unI64 7934+  '\x1f00'# -> unI64 7944+  '\x1f01'# -> unI64 7945+  '\x1f02'# -> unI64 7946+  '\x1f03'# -> unI64 7947+  '\x1f04'# -> unI64 7948+  '\x1f05'# -> unI64 7949+  '\x1f06'# -> unI64 7950+  '\x1f07'# -> unI64 7951+  '\x1f10'# -> unI64 7960+  '\x1f11'# -> unI64 7961+  '\x1f12'# -> unI64 7962+  '\x1f13'# -> unI64 7963+  '\x1f14'# -> unI64 7964+  '\x1f15'# -> unI64 7965+  '\x1f20'# -> unI64 7976+  '\x1f21'# -> unI64 7977+  '\x1f22'# -> unI64 7978+  '\x1f23'# -> unI64 7979+  '\x1f24'# -> unI64 7980+  '\x1f25'# -> unI64 7981+  '\x1f26'# -> unI64 7982+  '\x1f27'# -> unI64 7983+  '\x1f30'# -> unI64 7992+  '\x1f31'# -> unI64 7993+  '\x1f32'# -> unI64 7994+  '\x1f33'# -> unI64 7995+  '\x1f34'# -> unI64 7996+  '\x1f35'# -> unI64 7997+  '\x1f36'# -> unI64 7998+  '\x1f37'# -> unI64 7999+  '\x1f40'# -> unI64 8008+  '\x1f41'# -> unI64 8009+  '\x1f42'# -> unI64 8010+  '\x1f43'# -> unI64 8011+  '\x1f44'# -> unI64 8012+  '\x1f45'# -> unI64 8013+  '\x1f51'# -> unI64 8025+  '\x1f53'# -> unI64 8027+  '\x1f55'# -> unI64 8029+  '\x1f57'# -> unI64 8031+  '\x1f60'# -> unI64 8040+  '\x1f61'# -> unI64 8041+  '\x1f62'# -> unI64 8042+  '\x1f63'# -> unI64 8043+  '\x1f64'# -> unI64 8044+  '\x1f65'# -> unI64 8045+  '\x1f66'# -> unI64 8046+  '\x1f67'# -> unI64 8047+  '\x1f70'# -> unI64 8122+  '\x1f71'# -> unI64 8123+  '\x1f72'# -> unI64 8136+  '\x1f73'# -> unI64 8137+  '\x1f74'# -> unI64 8138+  '\x1f75'# -> unI64 8139+  '\x1f76'# -> unI64 8154+  '\x1f77'# -> unI64 8155+  '\x1f78'# -> unI64 8184+  '\x1f79'# -> unI64 8185+  '\x1f7a'# -> unI64 8170+  '\x1f7b'# -> unI64 8171+  '\x1f7c'# -> unI64 8186+  '\x1f7d'# -> unI64 8187+  '\x1f80'# -> unI64 8072+  '\x1f81'# -> unI64 8073+  '\x1f82'# -> unI64 8074+  '\x1f83'# -> unI64 8075+  '\x1f84'# -> unI64 8076+  '\x1f85'# -> unI64 8077+  '\x1f86'# -> unI64 8078+  '\x1f87'# -> unI64 8079+  '\x1f90'# -> unI64 8088+  '\x1f91'# -> unI64 8089+  '\x1f92'# -> unI64 8090+  '\x1f93'# -> unI64 8091+  '\x1f94'# -> unI64 8092+  '\x1f95'# -> unI64 8093+  '\x1f96'# -> unI64 8094+  '\x1f97'# -> unI64 8095+  '\x1fa0'# -> unI64 8104+  '\x1fa1'# -> unI64 8105+  '\x1fa2'# -> unI64 8106+  '\x1fa3'# -> unI64 8107+  '\x1fa4'# -> unI64 8108+  '\x1fa5'# -> unI64 8109+  '\x1fa6'# -> unI64 8110+  '\x1fa7'# -> unI64 8111+  '\x1fb0'# -> unI64 8120+  '\x1fb1'# -> unI64 8121+  '\x1fb3'# -> unI64 8124+  '\x1fbe'# -> unI64 921+  '\x1fc3'# -> unI64 8140+  '\x1fd0'# -> unI64 8152+  '\x1fd1'# -> unI64 8153+  '\x1fe0'# -> unI64 8168+  '\x1fe1'# -> unI64 8169+  '\x1fe5'# -> unI64 8172+  '\x1ff3'# -> unI64 8188+  '\x214e'# -> unI64 8498+  '\x2170'# -> unI64 8544+  '\x2171'# -> unI64 8545+  '\x2172'# -> unI64 8546+  '\x2173'# -> unI64 8547+  '\x2174'# -> unI64 8548+  '\x2175'# -> unI64 8549+  '\x2176'# -> unI64 8550+  '\x2177'# -> unI64 8551+  '\x2178'# -> unI64 8552+  '\x2179'# -> unI64 8553+  '\x217a'# -> unI64 8554+  '\x217b'# -> unI64 8555+  '\x217c'# -> unI64 8556+  '\x217d'# -> unI64 8557+  '\x217e'# -> unI64 8558+  '\x217f'# -> unI64 8559+  '\x2184'# -> unI64 8579+  '\x24d0'# -> unI64 9398+  '\x24d1'# -> unI64 9399+  '\x24d2'# -> unI64 9400+  '\x24d3'# -> unI64 9401+  '\x24d4'# -> unI64 9402+  '\x24d5'# -> unI64 9403+  '\x24d6'# -> unI64 9404+  '\x24d7'# -> unI64 9405+  '\x24d8'# -> unI64 9406+  '\x24d9'# -> unI64 9407+  '\x24da'# -> unI64 9408+  '\x24db'# -> unI64 9409+  '\x24dc'# -> unI64 9410+  '\x24dd'# -> unI64 9411+  '\x24de'# -> unI64 9412+  '\x24df'# -> unI64 9413+  '\x24e0'# -> unI64 9414+  '\x24e1'# -> unI64 9415+  '\x24e2'# -> unI64 9416+  '\x24e3'# -> unI64 9417+  '\x24e4'# -> unI64 9418+  '\x24e5'# -> unI64 9419+  '\x24e6'# -> unI64 9420+  '\x24e7'# -> unI64 9421+  '\x24e8'# -> unI64 9422+  '\x24e9'# -> unI64 9423+  '\x2c30'# -> unI64 11264+  '\x2c31'# -> unI64 11265+  '\x2c32'# -> unI64 11266+  '\x2c33'# -> unI64 11267+  '\x2c34'# -> unI64 11268+  '\x2c35'# -> unI64 11269+  '\x2c36'# -> unI64 11270+  '\x2c37'# -> unI64 11271+  '\x2c38'# -> unI64 11272+  '\x2c39'# -> unI64 11273+  '\x2c3a'# -> unI64 11274+  '\x2c3b'# -> unI64 11275+  '\x2c3c'# -> unI64 11276+  '\x2c3d'# -> unI64 11277+  '\x2c3e'# -> unI64 11278+  '\x2c3f'# -> unI64 11279+  '\x2c40'# -> unI64 11280+  '\x2c41'# -> unI64 11281+  '\x2c42'# -> unI64 11282+  '\x2c43'# -> unI64 11283+  '\x2c44'# -> unI64 11284+  '\x2c45'# -> unI64 11285+  '\x2c46'# -> unI64 11286+  '\x2c47'# -> unI64 11287+  '\x2c48'# -> unI64 11288+  '\x2c49'# -> unI64 11289+  '\x2c4a'# -> unI64 11290+  '\x2c4b'# -> unI64 11291+  '\x2c4c'# -> unI64 11292+  '\x2c4d'# -> unI64 11293+  '\x2c4e'# -> unI64 11294+  '\x2c4f'# -> unI64 11295+  '\x2c50'# -> unI64 11296+  '\x2c51'# -> unI64 11297+  '\x2c52'# -> unI64 11298+  '\x2c53'# -> unI64 11299+  '\x2c54'# -> unI64 11300+  '\x2c55'# -> unI64 11301+  '\x2c56'# -> unI64 11302+  '\x2c57'# -> unI64 11303+  '\x2c58'# -> unI64 11304+  '\x2c59'# -> unI64 11305+  '\x2c5a'# -> unI64 11306+  '\x2c5b'# -> unI64 11307+  '\x2c5c'# -> unI64 11308+  '\x2c5d'# -> unI64 11309+  '\x2c5e'# -> unI64 11310+  '\x2c5f'# -> unI64 11311+  '\x2c61'# -> unI64 11360+  '\x2c65'# -> unI64 570+  '\x2c66'# -> unI64 574+  '\x2c68'# -> unI64 11367+  '\x2c6a'# -> unI64 11369+  '\x2c6c'# -> unI64 11371+  '\x2c73'# -> unI64 11378+  '\x2c76'# -> unI64 11381+  '\x2c81'# -> unI64 11392+  '\x2c83'# -> unI64 11394+  '\x2c85'# -> unI64 11396+  '\x2c87'# -> unI64 11398+  '\x2c89'# -> unI64 11400+  '\x2c8b'# -> unI64 11402+  '\x2c8d'# -> unI64 11404+  '\x2c8f'# -> unI64 11406+  '\x2c91'# -> unI64 11408+  '\x2c93'# -> unI64 11410+  '\x2c95'# -> unI64 11412+  '\x2c97'# -> unI64 11414+  '\x2c99'# -> unI64 11416+  '\x2c9b'# -> unI64 11418+  '\x2c9d'# -> unI64 11420+  '\x2c9f'# -> unI64 11422+  '\x2ca1'# -> unI64 11424+  '\x2ca3'# -> unI64 11426+  '\x2ca5'# -> unI64 11428+  '\x2ca7'# -> unI64 11430+  '\x2ca9'# -> unI64 11432+  '\x2cab'# -> unI64 11434+  '\x2cad'# -> unI64 11436+  '\x2caf'# -> unI64 11438+  '\x2cb1'# -> unI64 11440+  '\x2cb3'# -> unI64 11442+  '\x2cb5'# -> unI64 11444+  '\x2cb7'# -> unI64 11446+  '\x2cb9'# -> unI64 11448+  '\x2cbb'# -> unI64 11450+  '\x2cbd'# -> unI64 11452+  '\x2cbf'# -> unI64 11454+  '\x2cc1'# -> unI64 11456+  '\x2cc3'# -> unI64 11458+  '\x2cc5'# -> unI64 11460+  '\x2cc7'# -> unI64 11462+  '\x2cc9'# -> unI64 11464+  '\x2ccb'# -> unI64 11466+  '\x2ccd'# -> unI64 11468+  '\x2ccf'# -> unI64 11470+  '\x2cd1'# -> unI64 11472+  '\x2cd3'# -> unI64 11474+  '\x2cd5'# -> unI64 11476+  '\x2cd7'# -> unI64 11478+  '\x2cd9'# -> unI64 11480+  '\x2cdb'# -> unI64 11482+  '\x2cdd'# -> unI64 11484+  '\x2cdf'# -> unI64 11486+  '\x2ce1'# -> unI64 11488+  '\x2ce3'# -> unI64 11490+  '\x2cec'# -> unI64 11499+  '\x2cee'# -> unI64 11501+  '\x2cf3'# -> unI64 11506+  '\x2d00'# -> unI64 4256+  '\x2d01'# -> unI64 4257+  '\x2d02'# -> unI64 4258+  '\x2d03'# -> unI64 4259+  '\x2d04'# -> unI64 4260+  '\x2d05'# -> unI64 4261+  '\x2d06'# -> unI64 4262+  '\x2d07'# -> unI64 4263+  '\x2d08'# -> unI64 4264+  '\x2d09'# -> unI64 4265+  '\x2d0a'# -> unI64 4266+  '\x2d0b'# -> unI64 4267+  '\x2d0c'# -> unI64 4268+  '\x2d0d'# -> unI64 4269+  '\x2d0e'# -> unI64 4270+  '\x2d0f'# -> unI64 4271+  '\x2d10'# -> unI64 4272+  '\x2d11'# -> unI64 4273+  '\x2d12'# -> unI64 4274+  '\x2d13'# -> unI64 4275+  '\x2d14'# -> unI64 4276+  '\x2d15'# -> unI64 4277+  '\x2d16'# -> unI64 4278+  '\x2d17'# -> unI64 4279+  '\x2d18'# -> unI64 4280+  '\x2d19'# -> unI64 4281+  '\x2d1a'# -> unI64 4282+  '\x2d1b'# -> unI64 4283+  '\x2d1c'# -> unI64 4284+  '\x2d1d'# -> unI64 4285+  '\x2d1e'# -> unI64 4286+  '\x2d1f'# -> unI64 4287+  '\x2d20'# -> unI64 4288+  '\x2d21'# -> unI64 4289+  '\x2d22'# -> unI64 4290+  '\x2d23'# -> unI64 4291+  '\x2d24'# -> unI64 4292+  '\x2d25'# -> unI64 4293+  '\x2d27'# -> unI64 4295+  '\x2d2d'# -> unI64 4301+  '\xa641'# -> unI64 42560+  '\xa643'# -> unI64 42562+  '\xa645'# -> unI64 42564+  '\xa647'# -> unI64 42566+  '\xa649'# -> unI64 42568+  '\xa64b'# -> unI64 42570+  '\xa64d'# -> unI64 42572+  '\xa64f'# -> unI64 42574+  '\xa651'# -> unI64 42576+  '\xa653'# -> unI64 42578+  '\xa655'# -> unI64 42580+  '\xa657'# -> unI64 42582+  '\xa659'# -> unI64 42584+  '\xa65b'# -> unI64 42586+  '\xa65d'# -> unI64 42588+  '\xa65f'# -> unI64 42590+  '\xa661'# -> unI64 42592+  '\xa663'# -> unI64 42594+  '\xa665'# -> unI64 42596+  '\xa667'# -> unI64 42598+  '\xa669'# -> unI64 42600+  '\xa66b'# -> unI64 42602+  '\xa66d'# -> unI64 42604+  '\xa681'# -> unI64 42624+  '\xa683'# -> unI64 42626+  '\xa685'# -> unI64 42628+  '\xa687'# -> unI64 42630+  '\xa689'# -> unI64 42632+  '\xa68b'# -> unI64 42634+  '\xa68d'# -> unI64 42636+  '\xa68f'# -> unI64 42638+  '\xa691'# -> unI64 42640+  '\xa693'# -> unI64 42642+  '\xa695'# -> unI64 42644+  '\xa697'# -> unI64 42646+  '\xa699'# -> unI64 42648+  '\xa69b'# -> unI64 42650+  '\xa723'# -> unI64 42786+  '\xa725'# -> unI64 42788+  '\xa727'# -> unI64 42790+  '\xa729'# -> unI64 42792+  '\xa72b'# -> unI64 42794+  '\xa72d'# -> unI64 42796+  '\xa72f'# -> unI64 42798+  '\xa733'# -> unI64 42802+  '\xa735'# -> unI64 42804+  '\xa737'# -> unI64 42806+  '\xa739'# -> unI64 42808+  '\xa73b'# -> unI64 42810+  '\xa73d'# -> unI64 42812+  '\xa73f'# -> unI64 42814+  '\xa741'# -> unI64 42816+  '\xa743'# -> unI64 42818+  '\xa745'# -> unI64 42820+  '\xa747'# -> unI64 42822+  '\xa749'# -> unI64 42824+  '\xa74b'# -> unI64 42826+  '\xa74d'# -> unI64 42828+  '\xa74f'# -> unI64 42830+  '\xa751'# -> unI64 42832+  '\xa753'# -> unI64 42834+  '\xa755'# -> unI64 42836+  '\xa757'# -> unI64 42838+  '\xa759'# -> unI64 42840+  '\xa75b'# -> unI64 42842+  '\xa75d'# -> unI64 42844+  '\xa75f'# -> unI64 42846+  '\xa761'# -> unI64 42848+  '\xa763'# -> unI64 42850+  '\xa765'# -> unI64 42852+  '\xa767'# -> unI64 42854+  '\xa769'# -> unI64 42856+  '\xa76b'# -> unI64 42858+  '\xa76d'# -> unI64 42860+  '\xa76f'# -> unI64 42862+  '\xa77a'# -> unI64 42873+  '\xa77c'# -> unI64 42875+  '\xa77f'# -> unI64 42878+  '\xa781'# -> unI64 42880+  '\xa783'# -> unI64 42882+  '\xa785'# -> unI64 42884+  '\xa787'# -> unI64 42886+  '\xa78c'# -> unI64 42891+  '\xa791'# -> unI64 42896+  '\xa793'# -> unI64 42898+  '\xa794'# -> unI64 42948+  '\xa797'# -> unI64 42902+  '\xa799'# -> unI64 42904+  '\xa79b'# -> unI64 42906+  '\xa79d'# -> unI64 42908+  '\xa79f'# -> unI64 42910+  '\xa7a1'# -> unI64 42912+  '\xa7a3'# -> unI64 42914+  '\xa7a5'# -> unI64 42916+  '\xa7a7'# -> unI64 42918+  '\xa7a9'# -> unI64 42920+  '\xa7b5'# -> unI64 42932+  '\xa7b7'# -> unI64 42934+  '\xa7b9'# -> unI64 42936+  '\xa7bb'# -> unI64 42938+  '\xa7bd'# -> unI64 42940+  '\xa7bf'# -> unI64 42942+  '\xa7c1'# -> unI64 42944+  '\xa7c3'# -> unI64 42946+  '\xa7c8'# -> unI64 42951+  '\xa7ca'# -> unI64 42953+  '\xa7d1'# -> unI64 42960+  '\xa7d7'# -> unI64 42966+  '\xa7d9'# -> unI64 42968+  '\xa7f6'# -> unI64 42997+  '\xab53'# -> unI64 42931+  '\xab70'# -> unI64 5024+  '\xab71'# -> unI64 5025+  '\xab72'# -> unI64 5026+  '\xab73'# -> unI64 5027+  '\xab74'# -> unI64 5028+  '\xab75'# -> unI64 5029+  '\xab76'# -> unI64 5030+  '\xab77'# -> unI64 5031+  '\xab78'# -> unI64 5032+  '\xab79'# -> unI64 5033+  '\xab7a'# -> unI64 5034+  '\xab7b'# -> unI64 5035+  '\xab7c'# -> unI64 5036+  '\xab7d'# -> unI64 5037+  '\xab7e'# -> unI64 5038+  '\xab7f'# -> unI64 5039+  '\xab80'# -> unI64 5040+  '\xab81'# -> unI64 5041+  '\xab82'# -> unI64 5042+  '\xab83'# -> unI64 5043+  '\xab84'# -> unI64 5044+  '\xab85'# -> unI64 5045+  '\xab86'# -> unI64 5046+  '\xab87'# -> unI64 5047+  '\xab88'# -> unI64 5048+  '\xab89'# -> unI64 5049+  '\xab8a'# -> unI64 5050+  '\xab8b'# -> unI64 5051+  '\xab8c'# -> unI64 5052+  '\xab8d'# -> unI64 5053+  '\xab8e'# -> unI64 5054+  '\xab8f'# -> unI64 5055+  '\xab90'# -> unI64 5056+  '\xab91'# -> unI64 5057+  '\xab92'# -> unI64 5058+  '\xab93'# -> unI64 5059+  '\xab94'# -> unI64 5060+  '\xab95'# -> unI64 5061+  '\xab96'# -> unI64 5062+  '\xab97'# -> unI64 5063+  '\xab98'# -> unI64 5064+  '\xab99'# -> unI64 5065+  '\xab9a'# -> unI64 5066+  '\xab9b'# -> unI64 5067+  '\xab9c'# -> unI64 5068+  '\xab9d'# -> unI64 5069+  '\xab9e'# -> unI64 5070+  '\xab9f'# -> unI64 5071+  '\xaba0'# -> unI64 5072+  '\xaba1'# -> unI64 5073+  '\xaba2'# -> unI64 5074+  '\xaba3'# -> unI64 5075+  '\xaba4'# -> unI64 5076+  '\xaba5'# -> unI64 5077+  '\xaba6'# -> unI64 5078+  '\xaba7'# -> unI64 5079+  '\xaba8'# -> unI64 5080+  '\xaba9'# -> unI64 5081+  '\xabaa'# -> unI64 5082+  '\xabab'# -> unI64 5083+  '\xabac'# -> unI64 5084+  '\xabad'# -> unI64 5085+  '\xabae'# -> unI64 5086+  '\xabaf'# -> unI64 5087+  '\xabb0'# -> unI64 5088+  '\xabb1'# -> unI64 5089+  '\xabb2'# -> unI64 5090+  '\xabb3'# -> unI64 5091+  '\xabb4'# -> unI64 5092+  '\xabb5'# -> unI64 5093+  '\xabb6'# -> unI64 5094+  '\xabb7'# -> unI64 5095+  '\xabb8'# -> unI64 5096+  '\xabb9'# -> unI64 5097+  '\xabba'# -> unI64 5098+  '\xabbb'# -> unI64 5099+  '\xabbc'# -> unI64 5100+  '\xabbd'# -> unI64 5101+  '\xabbe'# -> unI64 5102+  '\xabbf'# -> unI64 5103+  '\xff41'# -> unI64 65313+  '\xff42'# -> unI64 65314+  '\xff43'# -> unI64 65315+  '\xff44'# -> unI64 65316+  '\xff45'# -> unI64 65317+  '\xff46'# -> unI64 65318+  '\xff47'# -> unI64 65319+  '\xff48'# -> unI64 65320+  '\xff49'# -> unI64 65321+  '\xff4a'# -> unI64 65322+  '\xff4b'# -> unI64 65323+  '\xff4c'# -> unI64 65324+  '\xff4d'# -> unI64 65325+  '\xff4e'# -> unI64 65326+  '\xff4f'# -> unI64 65327+  '\xff50'# -> unI64 65328+  '\xff51'# -> unI64 65329+  '\xff52'# -> unI64 65330+  '\xff53'# -> unI64 65331+  '\xff54'# -> unI64 65332+  '\xff55'# -> unI64 65333+  '\xff56'# -> unI64 65334+  '\xff57'# -> unI64 65335+  '\xff58'# -> unI64 65336+  '\xff59'# -> unI64 65337+  '\xff5a'# -> unI64 65338+  '\x10428'# -> unI64 66560+  '\x10429'# -> unI64 66561+  '\x1042a'# -> unI64 66562+  '\x1042b'# -> unI64 66563+  '\x1042c'# -> unI64 66564+  '\x1042d'# -> unI64 66565+  '\x1042e'# -> unI64 66566+  '\x1042f'# -> unI64 66567+  '\x10430'# -> unI64 66568+  '\x10431'# -> unI64 66569+  '\x10432'# -> unI64 66570+  '\x10433'# -> unI64 66571+  '\x10434'# -> unI64 66572+  '\x10435'# -> unI64 66573+  '\x10436'# -> unI64 66574+  '\x10437'# -> unI64 66575+  '\x10438'# -> unI64 66576+  '\x10439'# -> unI64 66577+  '\x1043a'# -> unI64 66578+  '\x1043b'# -> unI64 66579+  '\x1043c'# -> unI64 66580+  '\x1043d'# -> unI64 66581+  '\x1043e'# -> unI64 66582+  '\x1043f'# -> unI64 66583+  '\x10440'# -> unI64 66584+  '\x10441'# -> unI64 66585+  '\x10442'# -> unI64 66586+  '\x10443'# -> unI64 66587+  '\x10444'# -> unI64 66588+  '\x10445'# -> unI64 66589+  '\x10446'# -> unI64 66590+  '\x10447'# -> unI64 66591+  '\x10448'# -> unI64 66592+  '\x10449'# -> unI64 66593+  '\x1044a'# -> unI64 66594+  '\x1044b'# -> unI64 66595+  '\x1044c'# -> unI64 66596+  '\x1044d'# -> unI64 66597+  '\x1044e'# -> unI64 66598+  '\x1044f'# -> unI64 66599+  '\x104d8'# -> unI64 66736+  '\x104d9'# -> unI64 66737+  '\x104da'# -> unI64 66738+  '\x104db'# -> unI64 66739+  '\x104dc'# -> unI64 66740+  '\x104dd'# -> unI64 66741+  '\x104de'# -> unI64 66742+  '\x104df'# -> unI64 66743+  '\x104e0'# -> unI64 66744+  '\x104e1'# -> unI64 66745+  '\x104e2'# -> unI64 66746+  '\x104e3'# -> unI64 66747+  '\x104e4'# -> unI64 66748+  '\x104e5'# -> unI64 66749+  '\x104e6'# -> unI64 66750+  '\x104e7'# -> unI64 66751+  '\x104e8'# -> unI64 66752+  '\x104e9'# -> unI64 66753+  '\x104ea'# -> unI64 66754+  '\x104eb'# -> unI64 66755+  '\x104ec'# -> unI64 66756+  '\x104ed'# -> unI64 66757+  '\x104ee'# -> unI64 66758+  '\x104ef'# -> unI64 66759+  '\x104f0'# -> unI64 66760+  '\x104f1'# -> unI64 66761+  '\x104f2'# -> unI64 66762+  '\x104f3'# -> unI64 66763+  '\x104f4'# -> unI64 66764+  '\x104f5'# -> unI64 66765+  '\x104f6'# -> unI64 66766+  '\x104f7'# -> unI64 66767+  '\x104f8'# -> unI64 66768+  '\x104f9'# -> unI64 66769+  '\x104fa'# -> unI64 66770+  '\x104fb'# -> unI64 66771+  '\x10597'# -> unI64 66928+  '\x10598'# -> unI64 66929+  '\x10599'# -> unI64 66930+  '\x1059a'# -> unI64 66931+  '\x1059b'# -> unI64 66932+  '\x1059c'# -> unI64 66933+  '\x1059d'# -> unI64 66934+  '\x1059e'# -> unI64 66935+  '\x1059f'# -> unI64 66936+  '\x105a0'# -> unI64 66937+  '\x105a1'# -> unI64 66938+  '\x105a3'# -> unI64 66940+  '\x105a4'# -> unI64 66941+  '\x105a5'# -> unI64 66942+  '\x105a6'# -> unI64 66943+  '\x105a7'# -> unI64 66944+  '\x105a8'# -> unI64 66945+  '\x105a9'# -> unI64 66946+  '\x105aa'# -> unI64 66947+  '\x105ab'# -> unI64 66948+  '\x105ac'# -> unI64 66949+  '\x105ad'# -> unI64 66950+  '\x105ae'# -> unI64 66951+  '\x105af'# -> unI64 66952+  '\x105b0'# -> unI64 66953+  '\x105b1'# -> unI64 66954+  '\x105b3'# -> unI64 66956+  '\x105b4'# -> unI64 66957+  '\x105b5'# -> unI64 66958+  '\x105b6'# -> unI64 66959+  '\x105b7'# -> unI64 66960+  '\x105b8'# -> unI64 66961+  '\x105b9'# -> unI64 66962+  '\x105bb'# -> unI64 66964+  '\x105bc'# -> unI64 66965+  '\x10cc0'# -> unI64 68736+  '\x10cc1'# -> unI64 68737+  '\x10cc2'# -> unI64 68738+  '\x10cc3'# -> unI64 68739+  '\x10cc4'# -> unI64 68740+  '\x10cc5'# -> unI64 68741+  '\x10cc6'# -> unI64 68742+  '\x10cc7'# -> unI64 68743+  '\x10cc8'# -> unI64 68744+  '\x10cc9'# -> unI64 68745+  '\x10cca'# -> unI64 68746+  '\x10ccb'# -> unI64 68747+  '\x10ccc'# -> unI64 68748+  '\x10ccd'# -> unI64 68749+  '\x10cce'# -> unI64 68750+  '\x10ccf'# -> unI64 68751+  '\x10cd0'# -> unI64 68752+  '\x10cd1'# -> unI64 68753+  '\x10cd2'# -> unI64 68754+  '\x10cd3'# -> unI64 68755+  '\x10cd4'# -> unI64 68756+  '\x10cd5'# -> unI64 68757+  '\x10cd6'# -> unI64 68758+  '\x10cd7'# -> unI64 68759+  '\x10cd8'# -> unI64 68760+  '\x10cd9'# -> unI64 68761+  '\x10cda'# -> unI64 68762+  '\x10cdb'# -> unI64 68763+  '\x10cdc'# -> unI64 68764+  '\x10cdd'# -> unI64 68765+  '\x10cde'# -> unI64 68766+  '\x10cdf'# -> unI64 68767+  '\x10ce0'# -> unI64 68768+  '\x10ce1'# -> unI64 68769+  '\x10ce2'# -> unI64 68770+  '\x10ce3'# -> unI64 68771+  '\x10ce4'# -> unI64 68772+  '\x10ce5'# -> unI64 68773+  '\x10ce6'# -> unI64 68774+  '\x10ce7'# -> unI64 68775+  '\x10ce8'# -> unI64 68776+  '\x10ce9'# -> unI64 68777+  '\x10cea'# -> unI64 68778+  '\x10ceb'# -> unI64 68779+  '\x10cec'# -> unI64 68780+  '\x10ced'# -> unI64 68781+  '\x10cee'# -> unI64 68782+  '\x10cef'# -> unI64 68783+  '\x10cf0'# -> unI64 68784+  '\x10cf1'# -> unI64 68785+  '\x10cf2'# -> unI64 68786+  '\x118c0'# -> unI64 71840+  '\x118c1'# -> unI64 71841+  '\x118c2'# -> unI64 71842+  '\x118c3'# -> unI64 71843+  '\x118c4'# -> unI64 71844+  '\x118c5'# -> unI64 71845+  '\x118c6'# -> unI64 71846+  '\x118c7'# -> unI64 71847+  '\x118c8'# -> unI64 71848+  '\x118c9'# -> unI64 71849+  '\x118ca'# -> unI64 71850+  '\x118cb'# -> unI64 71851+  '\x118cc'# -> unI64 71852+  '\x118cd'# -> unI64 71853+  '\x118ce'# -> unI64 71854+  '\x118cf'# -> unI64 71855+  '\x118d0'# -> unI64 71856+  '\x118d1'# -> unI64 71857+  '\x118d2'# -> unI64 71858+  '\x118d3'# -> unI64 71859+  '\x118d4'# -> unI64 71860+  '\x118d5'# -> unI64 71861+  '\x118d6'# -> unI64 71862+  '\x118d7'# -> unI64 71863+  '\x118d8'# -> unI64 71864+  '\x118d9'# -> unI64 71865+  '\x118da'# -> unI64 71866+  '\x118db'# -> unI64 71867+  '\x118dc'# -> unI64 71868+  '\x118dd'# -> unI64 71869+  '\x118de'# -> unI64 71870+  '\x118df'# -> unI64 71871+  '\x16e60'# -> unI64 93760+  '\x16e61'# -> unI64 93761+  '\x16e62'# -> unI64 93762+  '\x16e63'# -> unI64 93763+  '\x16e64'# -> unI64 93764+  '\x16e65'# -> unI64 93765+  '\x16e66'# -> unI64 93766+  '\x16e67'# -> unI64 93767+  '\x16e68'# -> unI64 93768+  '\x16e69'# -> unI64 93769+  '\x16e6a'# -> unI64 93770+  '\x16e6b'# -> unI64 93771+  '\x16e6c'# -> unI64 93772+  '\x16e6d'# -> unI64 93773+  '\x16e6e'# -> unI64 93774+  '\x16e6f'# -> unI64 93775+  '\x16e70'# -> unI64 93776+  '\x16e71'# -> unI64 93777+  '\x16e72'# -> unI64 93778+  '\x16e73'# -> unI64 93779+  '\x16e74'# -> unI64 93780+  '\x16e75'# -> unI64 93781+  '\x16e76'# -> unI64 93782+  '\x16e77'# -> unI64 93783+  '\x16e78'# -> unI64 93784+  '\x16e79'# -> unI64 93785+  '\x16e7a'# -> unI64 93786+  '\x16e7b'# -> unI64 93787+  '\x16e7c'# -> unI64 93788+  '\x16e7d'# -> unI64 93789+  '\x16e7e'# -> unI64 93790+  '\x16e7f'# -> unI64 93791+  '\x1e922'# -> unI64 125184+  '\x1e923'# -> unI64 125185+  '\x1e924'# -> unI64 125186+  '\x1e925'# -> unI64 125187+  '\x1e926'# -> unI64 125188+  '\x1e927'# -> unI64 125189+  '\x1e928'# -> unI64 125190+  '\x1e929'# -> unI64 125191+  '\x1e92a'# -> unI64 125192+  '\x1e92b'# -> unI64 125193+  '\x1e92c'# -> unI64 125194+  '\x1e92d'# -> unI64 125195+  '\x1e92e'# -> unI64 125196+  '\x1e92f'# -> unI64 125197+  '\x1e930'# -> unI64 125198+  '\x1e931'# -> unI64 125199+  '\x1e932'# -> unI64 125200+  '\x1e933'# -> unI64 125201+  '\x1e934'# -> unI64 125202+  '\x1e935'# -> unI64 125203+  '\x1e936'# -> unI64 125204+  '\x1e937'# -> unI64 125205+  '\x1e938'# -> unI64 125206+  '\x1e939'# -> unI64 125207+  '\x1e93a'# -> unI64 125208+  '\x1e93b'# -> unI64 125209+  '\x1e93c'# -> unI64 125210+  '\x1e93d'# -> unI64 125211+  '\x1e93e'# -> unI64 125212+  '\x1e93f'# -> unI64 125213+  '\x1e940'# -> unI64 125214+  '\x1e941'# -> unI64 125215+  '\x1e942'# -> unI64 125216+  '\x1e943'# -> unI64 125217+  _ -> unI64 0+foldMapping :: Char# -> _ {- unboxed Int64 -}+{-# NOINLINE foldMapping #-}+foldMapping = \case+  -- LATIN CAPITAL LETTER A+  '\x0041'# -> unI64 97+  -- LATIN CAPITAL LETTER B+  '\x0042'# -> unI64 98+  -- LATIN CAPITAL LETTER C+  '\x0043'# -> unI64 99+  -- LATIN CAPITAL LETTER D+  '\x0044'# -> unI64 100+  -- LATIN CAPITAL LETTER E+  '\x0045'# -> unI64 101+  -- LATIN CAPITAL LETTER F+  '\x0046'# -> unI64 102+  -- LATIN CAPITAL LETTER G+  '\x0047'# -> unI64 103+  -- LATIN CAPITAL LETTER H+  '\x0048'# -> unI64 104+  -- LATIN CAPITAL LETTER I+  '\x0049'# -> unI64 105+  -- LATIN CAPITAL LETTER J+  '\x004a'# -> unI64 106+  -- LATIN CAPITAL LETTER K+  '\x004b'# -> unI64 107+  -- LATIN CAPITAL LETTER L+  '\x004c'# -> unI64 108+  -- LATIN CAPITAL LETTER M+  '\x004d'# -> unI64 109+  -- LATIN CAPITAL LETTER N+  '\x004e'# -> unI64 110+  -- LATIN CAPITAL LETTER O+  '\x004f'# -> unI64 111+  -- LATIN CAPITAL LETTER P+  '\x0050'# -> unI64 112+  -- LATIN CAPITAL LETTER Q+  '\x0051'# -> unI64 113+  -- LATIN CAPITAL LETTER R+  '\x0052'# -> unI64 114+  -- LATIN CAPITAL LETTER S+  '\x0053'# -> unI64 115+  -- LATIN CAPITAL LETTER T+  '\x0054'# -> unI64 116+  -- LATIN CAPITAL LETTER U+  '\x0055'# -> unI64 117+  -- LATIN CAPITAL LETTER V+  '\x0056'# -> unI64 118+  -- LATIN CAPITAL LETTER W+  '\x0057'# -> unI64 119+  -- LATIN CAPITAL LETTER X+  '\x0058'# -> unI64 120+  -- LATIN CAPITAL LETTER Y+  '\x0059'# -> unI64 121+  -- LATIN CAPITAL LETTER Z+  '\x005a'# -> unI64 122+  -- MICRO SIGN+  '\x00b5'# -> unI64 956+  -- LATIN CAPITAL LETTER A WITH GRAVE+  '\x00c0'# -> unI64 224+  -- LATIN CAPITAL LETTER A WITH ACUTE+  '\x00c1'# -> unI64 225+  -- LATIN CAPITAL LETTER A WITH CIRCUMFLEX+  '\x00c2'# -> unI64 226+  -- LATIN CAPITAL LETTER A WITH TILDE+  '\x00c3'# -> unI64 227+  -- LATIN CAPITAL LETTER A WITH DIAERESIS+  '\x00c4'# -> unI64 228+  -- LATIN CAPITAL LETTER A WITH RING ABOVE+  '\x00c5'# -> unI64 229+  -- LATIN CAPITAL LETTER AE+  '\x00c6'# -> unI64 230+  -- LATIN CAPITAL LETTER C WITH CEDILLA+  '\x00c7'# -> unI64 231+  -- LATIN CAPITAL LETTER E WITH GRAVE+  '\x00c8'# -> unI64 232+  -- LATIN CAPITAL LETTER E WITH ACUTE+  '\x00c9'# -> unI64 233+  -- LATIN CAPITAL LETTER E WITH CIRCUMFLEX+  '\x00ca'# -> unI64 234+  -- LATIN CAPITAL LETTER E WITH DIAERESIS+  '\x00cb'# -> unI64 235+  -- LATIN CAPITAL LETTER I WITH GRAVE+  '\x00cc'# -> unI64 236+  -- LATIN CAPITAL LETTER I WITH ACUTE+  '\x00cd'# -> unI64 237+  -- LATIN CAPITAL LETTER I WITH CIRCUMFLEX+  '\x00ce'# -> unI64 238+  -- LATIN CAPITAL LETTER I WITH DIAERESIS+  '\x00cf'# -> unI64 239+  -- LATIN CAPITAL LETTER ETH+  '\x00d0'# -> unI64 240+  -- LATIN CAPITAL LETTER N WITH TILDE+  '\x00d1'# -> unI64 241+  -- LATIN CAPITAL LETTER O WITH GRAVE+  '\x00d2'# -> unI64 242+  -- LATIN CAPITAL LETTER O WITH ACUTE+  '\x00d3'# -> unI64 243+  -- LATIN CAPITAL LETTER O WITH CIRCUMFLEX+  '\x00d4'# -> unI64 244+  -- LATIN CAPITAL LETTER O WITH TILDE+  '\x00d5'# -> unI64 245+  -- LATIN CAPITAL LETTER O WITH DIAERESIS+  '\x00d6'# -> unI64 246+  -- LATIN CAPITAL LETTER O WITH STROKE+  '\x00d8'# -> unI64 248+  -- LATIN CAPITAL LETTER U WITH GRAVE+  '\x00d9'# -> unI64 249+  -- LATIN CAPITAL LETTER U WITH ACUTE+  '\x00da'# -> unI64 250+  -- LATIN CAPITAL LETTER U WITH CIRCUMFLEX+  '\x00db'# -> unI64 251+  -- LATIN CAPITAL LETTER U WITH DIAERESIS+  '\x00dc'# -> unI64 252+  -- LATIN CAPITAL LETTER Y WITH ACUTE+  '\x00dd'# -> unI64 253+  -- LATIN CAPITAL LETTER THORN+  '\x00de'# -> unI64 254+  -- LATIN SMALL LETTER SHARP S+  '\x00df'# -> unI64 241172595+  -- LATIN CAPITAL LETTER A WITH MACRON+  '\x0100'# -> unI64 257+  -- LATIN CAPITAL LETTER A WITH BREVE+  '\x0102'# -> unI64 259+  -- LATIN CAPITAL LETTER A WITH OGONEK+  '\x0104'# -> unI64 261+  -- LATIN CAPITAL LETTER C WITH ACUTE+  '\x0106'# -> unI64 263+  -- LATIN CAPITAL LETTER C WITH CIRCUMFLEX+  '\x0108'# -> unI64 265+  -- LATIN CAPITAL LETTER C WITH DOT ABOVE+  '\x010a'# -> unI64 267+  -- LATIN CAPITAL LETTER C WITH CARON+  '\x010c'# -> unI64 269+  -- LATIN CAPITAL LETTER D WITH CARON+  '\x010e'# -> unI64 271+  -- LATIN CAPITAL LETTER D WITH STROKE+  '\x0110'# -> unI64 273+  -- LATIN CAPITAL LETTER E WITH MACRON+  '\x0112'# -> unI64 275+  -- LATIN CAPITAL LETTER E WITH BREVE+  '\x0114'# -> unI64 277+  -- LATIN CAPITAL LETTER E WITH DOT ABOVE+  '\x0116'# -> unI64 279+  -- LATIN CAPITAL LETTER E WITH OGONEK+  '\x0118'# -> unI64 281+  -- LATIN CAPITAL LETTER E WITH CARON+  '\x011a'# -> unI64 283+  -- LATIN CAPITAL LETTER G WITH CIRCUMFLEX+  '\x011c'# -> unI64 285+  -- LATIN CAPITAL LETTER G WITH BREVE+  '\x011e'# -> unI64 287+  -- LATIN CAPITAL LETTER G WITH DOT ABOVE+  '\x0120'# -> unI64 289+  -- LATIN CAPITAL LETTER G WITH CEDILLA+  '\x0122'# -> unI64 291+  -- LATIN CAPITAL LETTER H WITH CIRCUMFLEX+  '\x0124'# -> unI64 293+  -- LATIN CAPITAL LETTER H WITH STROKE+  '\x0126'# -> unI64 295+  -- LATIN CAPITAL LETTER I WITH TILDE+  '\x0128'# -> unI64 297+  -- LATIN CAPITAL LETTER I WITH MACRON+  '\x012a'# -> unI64 299+  -- LATIN CAPITAL LETTER I WITH BREVE+  '\x012c'# -> unI64 301+  -- LATIN CAPITAL LETTER I WITH OGONEK+  '\x012e'# -> unI64 303+  -- LATIN CAPITAL LETTER I WITH DOT ABOVE+  '\x0130'# -> unI64 1625292905+  -- LATIN CAPITAL LIGATURE IJ+  '\x0132'# -> unI64 307+  -- LATIN CAPITAL LETTER J WITH CIRCUMFLEX+  '\x0134'# -> unI64 309+  -- LATIN CAPITAL LETTER K WITH CEDILLA+  '\x0136'# -> unI64 311+  -- LATIN CAPITAL LETTER L WITH ACUTE+  '\x0139'# -> unI64 314+  -- LATIN CAPITAL LETTER L WITH CEDILLA+  '\x013b'# -> unI64 316+  -- LATIN CAPITAL LETTER L WITH CARON+  '\x013d'# -> unI64 318+  -- LATIN CAPITAL LETTER L WITH MIDDLE DOT+  '\x013f'# -> unI64 320+  -- LATIN CAPITAL LETTER L WITH STROKE+  '\x0141'# -> unI64 322+  -- LATIN CAPITAL LETTER N WITH ACUTE+  '\x0143'# -> unI64 324+  -- LATIN CAPITAL LETTER N WITH CEDILLA+  '\x0145'# -> unI64 326+  -- LATIN CAPITAL LETTER N WITH CARON+  '\x0147'# -> unI64 328+  -- LATIN SMALL LETTER N PRECEDED BY APOSTROPHE+  '\x0149'# -> unI64 230687420+  -- LATIN CAPITAL LETTER ENG+  '\x014a'# -> unI64 331+  -- LATIN CAPITAL LETTER O WITH MACRON+  '\x014c'# -> unI64 333+  -- LATIN CAPITAL LETTER O WITH BREVE+  '\x014e'# -> unI64 335+  -- LATIN CAPITAL LETTER O WITH DOUBLE ACUTE+  '\x0150'# -> unI64 337+  -- LATIN CAPITAL LIGATURE OE+  '\x0152'# -> unI64 339+  -- LATIN CAPITAL LETTER R WITH ACUTE+  '\x0154'# -> unI64 341+  -- LATIN CAPITAL LETTER R WITH CEDILLA+  '\x0156'# -> unI64 343+  -- LATIN CAPITAL LETTER R WITH CARON+  '\x0158'# -> unI64 345+  -- LATIN CAPITAL LETTER S WITH ACUTE+  '\x015a'# -> unI64 347+  -- LATIN CAPITAL LETTER S WITH CIRCUMFLEX+  '\x015c'# -> unI64 349+  -- LATIN CAPITAL LETTER S WITH CEDILLA+  '\x015e'# -> unI64 351+  -- LATIN CAPITAL LETTER S WITH CARON+  '\x0160'# -> unI64 353+  -- LATIN CAPITAL LETTER T WITH CEDILLA+  '\x0162'# -> unI64 355+  -- LATIN CAPITAL LETTER T WITH CARON+  '\x0164'# -> unI64 357+  -- LATIN CAPITAL LETTER T WITH STROKE+  '\x0166'# -> unI64 359+  -- LATIN CAPITAL LETTER U WITH TILDE+  '\x0168'# -> unI64 361+  -- LATIN CAPITAL LETTER U WITH MACRON+  '\x016a'# -> unI64 363+  -- LATIN CAPITAL LETTER U WITH BREVE+  '\x016c'# -> unI64 365+  -- LATIN CAPITAL LETTER U WITH RING ABOVE+  '\x016e'# -> unI64 367+  -- LATIN CAPITAL LETTER U WITH DOUBLE ACUTE+  '\x0170'# -> unI64 369+  -- LATIN CAPITAL LETTER U WITH OGONEK+  '\x0172'# -> unI64 371+  -- LATIN CAPITAL LETTER W WITH CIRCUMFLEX+  '\x0174'# -> unI64 373+  -- LATIN CAPITAL LETTER Y WITH CIRCUMFLEX+  '\x0176'# -> unI64 375+  -- LATIN CAPITAL LETTER Y WITH DIAERESIS+  '\x0178'# -> unI64 255+  -- LATIN CAPITAL LETTER Z WITH ACUTE+  '\x0179'# -> unI64 378+  -- LATIN CAPITAL LETTER Z WITH DOT ABOVE+  '\x017b'# -> unI64 380+  -- LATIN CAPITAL LETTER Z WITH CARON+  '\x017d'# -> unI64 382+  -- LATIN SMALL LETTER LONG S+  '\x017f'# -> unI64 115+  -- LATIN CAPITAL LETTER B WITH HOOK+  '\x0181'# -> unI64 595+  -- LATIN CAPITAL LETTER B WITH TOPBAR+  '\x0182'# -> unI64 387+  -- LATIN CAPITAL LETTER TONE SIX+  '\x0184'# -> unI64 389+  -- LATIN CAPITAL LETTER OPEN O+  '\x0186'# -> unI64 596+  -- LATIN CAPITAL LETTER C WITH HOOK+  '\x0187'# -> unI64 392+  -- LATIN CAPITAL LETTER AFRICAN D+  '\x0189'# -> unI64 598+  -- LATIN CAPITAL LETTER D WITH HOOK+  '\x018a'# -> unI64 599+  -- LATIN CAPITAL LETTER D WITH TOPBAR+  '\x018b'# -> unI64 396+  -- LATIN CAPITAL LETTER REVERSED E+  '\x018e'# -> unI64 477+  -- LATIN CAPITAL LETTER SCHWA+  '\x018f'# -> unI64 601+  -- LATIN CAPITAL LETTER OPEN E+  '\x0190'# -> unI64 603+  -- LATIN CAPITAL LETTER F WITH HOOK+  '\x0191'# -> unI64 402+  -- LATIN CAPITAL LETTER G WITH HOOK+  '\x0193'# -> unI64 608+  -- LATIN CAPITAL LETTER GAMMA+  '\x0194'# -> unI64 611+  -- LATIN CAPITAL LETTER IOTA+  '\x0196'# -> unI64 617+  -- LATIN CAPITAL LETTER I WITH STROKE+  '\x0197'# -> unI64 616+  -- LATIN CAPITAL LETTER K WITH HOOK+  '\x0198'# -> unI64 409+  -- LATIN CAPITAL LETTER TURNED M+  '\x019c'# -> unI64 623+  -- LATIN CAPITAL LETTER N WITH LEFT HOOK+  '\x019d'# -> unI64 626+  -- LATIN CAPITAL LETTER O WITH MIDDLE TILDE+  '\x019f'# -> unI64 629+  -- LATIN CAPITAL LETTER O WITH HORN+  '\x01a0'# -> unI64 417+  -- LATIN CAPITAL LETTER OI+  '\x01a2'# -> unI64 419+  -- LATIN CAPITAL LETTER P WITH HOOK+  '\x01a4'# -> unI64 421+  -- LATIN LETTER YR+  '\x01a6'# -> unI64 640+  -- LATIN CAPITAL LETTER TONE TWO+  '\x01a7'# -> unI64 424+  -- LATIN CAPITAL LETTER ESH+  '\x01a9'# -> unI64 643+  -- LATIN CAPITAL LETTER T WITH HOOK+  '\x01ac'# -> unI64 429+  -- LATIN CAPITAL LETTER T WITH RETROFLEX HOOK+  '\x01ae'# -> unI64 648+  -- LATIN CAPITAL LETTER U WITH HORN+  '\x01af'# -> unI64 432+  -- LATIN CAPITAL LETTER UPSILON+  '\x01b1'# -> unI64 650+  -- LATIN CAPITAL LETTER V WITH HOOK+  '\x01b2'# -> unI64 651+  -- LATIN CAPITAL LETTER Y WITH HOOK+  '\x01b3'# -> unI64 436+  -- LATIN CAPITAL LETTER Z WITH STROKE+  '\x01b5'# -> unI64 438+  -- LATIN CAPITAL LETTER EZH+  '\x01b7'# -> unI64 658+  -- LATIN CAPITAL LETTER EZH REVERSED+  '\x01b8'# -> unI64 441+  -- LATIN CAPITAL LETTER TONE FIVE+  '\x01bc'# -> unI64 445+  -- LATIN CAPITAL LETTER DZ WITH CARON+  '\x01c4'# -> unI64 454+  -- LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON+  '\x01c5'# -> unI64 454+  -- LATIN CAPITAL LETTER LJ+  '\x01c7'# -> unI64 457+  -- LATIN CAPITAL LETTER L WITH SMALL LETTER J+  '\x01c8'# -> unI64 457+  -- LATIN CAPITAL LETTER NJ+  '\x01ca'# -> unI64 460+  -- LATIN CAPITAL LETTER N WITH SMALL LETTER J+  '\x01cb'# -> unI64 460+  -- LATIN CAPITAL LETTER A WITH CARON+  '\x01cd'# -> unI64 462+  -- LATIN CAPITAL LETTER I WITH CARON+  '\x01cf'# -> unI64 464+  -- LATIN CAPITAL LETTER O WITH CARON+  '\x01d1'# -> unI64 466+  -- LATIN CAPITAL LETTER U WITH CARON+  '\x01d3'# -> unI64 468+  -- LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON+  '\x01d5'# -> unI64 470+  -- LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE+  '\x01d7'# -> unI64 472+  -- LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON+  '\x01d9'# -> unI64 474+  -- LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE+  '\x01db'# -> unI64 476+  -- LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON+  '\x01de'# -> unI64 479+  -- LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON+  '\x01e0'# -> unI64 481+  -- LATIN CAPITAL LETTER AE WITH MACRON+  '\x01e2'# -> unI64 483+  -- LATIN CAPITAL LETTER G WITH STROKE+  '\x01e4'# -> unI64 485+  -- LATIN CAPITAL LETTER G WITH CARON+  '\x01e6'# -> unI64 487+  -- LATIN CAPITAL LETTER K WITH CARON+  '\x01e8'# -> unI64 489+  -- LATIN CAPITAL LETTER O WITH OGONEK+  '\x01ea'# -> unI64 491+  -- LATIN CAPITAL LETTER O WITH OGONEK AND MACRON+  '\x01ec'# -> unI64 493+  -- LATIN CAPITAL LETTER EZH WITH CARON+  '\x01ee'# -> unI64 495+  -- LATIN SMALL LETTER J WITH CARON+  '\x01f0'# -> unI64 1635778666+  -- LATIN CAPITAL LETTER DZ+  '\x01f1'# -> unI64 499+  -- LATIN CAPITAL LETTER D WITH SMALL LETTER Z+  '\x01f2'# -> unI64 499+  -- LATIN CAPITAL LETTER G WITH ACUTE+  '\x01f4'# -> unI64 501+  -- LATIN CAPITAL LETTER HWAIR+  '\x01f6'# -> unI64 405+  -- LATIN CAPITAL LETTER WYNN+  '\x01f7'# -> unI64 447+  -- LATIN CAPITAL LETTER N WITH GRAVE+  '\x01f8'# -> unI64 505+  -- LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE+  '\x01fa'# -> unI64 507+  -- LATIN CAPITAL LETTER AE WITH ACUTE+  '\x01fc'# -> unI64 509+  -- LATIN CAPITAL LETTER O WITH STROKE AND ACUTE+  '\x01fe'# -> unI64 511+  -- LATIN CAPITAL LETTER A WITH DOUBLE GRAVE+  '\x0200'# -> unI64 513+  -- LATIN CAPITAL LETTER A WITH INVERTED BREVE+  '\x0202'# -> unI64 515+  -- LATIN CAPITAL LETTER E WITH DOUBLE GRAVE+  '\x0204'# -> unI64 517+  -- LATIN CAPITAL LETTER E WITH INVERTED BREVE+  '\x0206'# -> unI64 519+  -- LATIN CAPITAL LETTER I WITH DOUBLE GRAVE+  '\x0208'# -> unI64 521+  -- LATIN CAPITAL LETTER I WITH INVERTED BREVE+  '\x020a'# -> unI64 523+  -- LATIN CAPITAL LETTER O WITH DOUBLE GRAVE+  '\x020c'# -> unI64 525+  -- LATIN CAPITAL LETTER O WITH INVERTED BREVE+  '\x020e'# -> unI64 527+  -- LATIN CAPITAL LETTER R WITH DOUBLE GRAVE+  '\x0210'# -> unI64 529+  -- LATIN CAPITAL LETTER R WITH INVERTED BREVE+  '\x0212'# -> unI64 531+  -- LATIN CAPITAL LETTER U WITH DOUBLE GRAVE+  '\x0214'# -> unI64 533+  -- LATIN CAPITAL LETTER U WITH INVERTED BREVE+  '\x0216'# -> unI64 535+  -- LATIN CAPITAL LETTER S WITH COMMA BELOW+  '\x0218'# -> unI64 537+  -- LATIN CAPITAL LETTER T WITH COMMA BELOW+  '\x021a'# -> unI64 539+  -- LATIN CAPITAL LETTER YOGH+  '\x021c'# -> unI64 541+  -- LATIN CAPITAL LETTER H WITH CARON+  '\x021e'# -> unI64 543+  -- LATIN CAPITAL LETTER N WITH LONG RIGHT LEG+  '\x0220'# -> unI64 414+  -- LATIN CAPITAL LETTER OU+  '\x0222'# -> unI64 547+  -- LATIN CAPITAL LETTER Z WITH HOOK+  '\x0224'# -> unI64 549+  -- LATIN CAPITAL LETTER A WITH DOT ABOVE+  '\x0226'# -> unI64 551+  -- LATIN CAPITAL LETTER E WITH CEDILLA+  '\x0228'# -> unI64 553+  -- LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON+  '\x022a'# -> unI64 555+  -- LATIN CAPITAL LETTER O WITH TILDE AND MACRON+  '\x022c'# -> unI64 557+  -- LATIN CAPITAL LETTER O WITH DOT ABOVE+  '\x022e'# -> unI64 559+  -- LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON+  '\x0230'# -> unI64 561+  -- LATIN CAPITAL LETTER Y WITH MACRON+  '\x0232'# -> unI64 563+  -- LATIN CAPITAL LETTER A WITH STROKE+  '\x023a'# -> unI64 11365+  -- LATIN CAPITAL LETTER C WITH STROKE+  '\x023b'# -> unI64 572+  -- LATIN CAPITAL LETTER L WITH BAR+  '\x023d'# -> unI64 410+  -- LATIN CAPITAL LETTER T WITH DIAGONAL STROKE+  '\x023e'# -> unI64 11366+  -- LATIN CAPITAL LETTER GLOTTAL STOP+  '\x0241'# -> unI64 578+  -- LATIN CAPITAL LETTER B WITH STROKE+  '\x0243'# -> unI64 384+  -- LATIN CAPITAL LETTER U BAR+  '\x0244'# -> unI64 649+  -- LATIN CAPITAL LETTER TURNED V+  '\x0245'# -> unI64 652+  -- LATIN CAPITAL LETTER E WITH STROKE+  '\x0246'# -> unI64 583+  -- LATIN CAPITAL LETTER J WITH STROKE+  '\x0248'# -> unI64 585+  -- LATIN CAPITAL LETTER SMALL Q WITH HOOK TAIL+  '\x024a'# -> unI64 587+  -- LATIN CAPITAL LETTER R WITH STROKE+  '\x024c'# -> unI64 589+  -- LATIN CAPITAL LETTER Y WITH STROKE+  '\x024e'# -> unI64 591+  -- COMBINING GREEK YPOGEGRAMMENI+  '\x0345'# -> unI64 953+  -- GREEK CAPITAL LETTER HETA+  '\x0370'# -> unI64 881+  -- GREEK CAPITAL LETTER ARCHAIC SAMPI+  '\x0372'# -> unI64 883+  -- GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA+  '\x0376'# -> unI64 887+  -- GREEK CAPITAL LETTER YOT+  '\x037f'# -> unI64 1011+  -- GREEK CAPITAL LETTER ALPHA WITH TONOS+  '\x0386'# -> unI64 940+  -- GREEK CAPITAL LETTER EPSILON WITH TONOS+  '\x0388'# -> unI64 941+  -- GREEK CAPITAL LETTER ETA WITH TONOS+  '\x0389'# -> unI64 942+  -- GREEK CAPITAL LETTER IOTA WITH TONOS+  '\x038a'# -> unI64 943+  -- GREEK CAPITAL LETTER OMICRON WITH TONOS+  '\x038c'# -> unI64 972+  -- GREEK CAPITAL LETTER UPSILON WITH TONOS+  '\x038e'# -> unI64 973+  -- GREEK CAPITAL LETTER OMEGA WITH TONOS+  '\x038f'# -> unI64 974+  -- GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS+  '\x0390'# -> unI64 3382099394429881+  -- GREEK CAPITAL LETTER ALPHA+  '\x0391'# -> unI64 945+  -- GREEK CAPITAL LETTER BETA+  '\x0392'# -> unI64 946+  -- GREEK CAPITAL LETTER GAMMA+  '\x0393'# -> unI64 947+  -- GREEK CAPITAL LETTER DELTA+  '\x0394'# -> unI64 948+  -- GREEK CAPITAL LETTER EPSILON+  '\x0395'# -> unI64 949+  -- GREEK CAPITAL LETTER ZETA+  '\x0396'# -> unI64 950+  -- GREEK CAPITAL LETTER ETA+  '\x0397'# -> unI64 951+  -- GREEK CAPITAL LETTER THETA+  '\x0398'# -> unI64 952+  -- GREEK CAPITAL LETTER IOTA+  '\x0399'# -> unI64 953+  -- GREEK CAPITAL LETTER KAPPA+  '\x039a'# -> unI64 954+  -- GREEK CAPITAL LETTER LAMDA+  '\x039b'# -> unI64 955+  -- GREEK CAPITAL LETTER MU+  '\x039c'# -> unI64 956+  -- GREEK CAPITAL LETTER NU+  '\x039d'# -> unI64 957+  -- GREEK CAPITAL LETTER XI+  '\x039e'# -> unI64 958+  -- GREEK CAPITAL LETTER OMICRON+  '\x039f'# -> unI64 959+  -- GREEK CAPITAL LETTER PI+  '\x03a0'# -> unI64 960+  -- GREEK CAPITAL LETTER RHO+  '\x03a1'# -> unI64 961+  -- GREEK CAPITAL LETTER SIGMA+  '\x03a3'# -> unI64 963+  -- GREEK CAPITAL LETTER TAU+  '\x03a4'# -> unI64 964+  -- GREEK CAPITAL LETTER UPSILON+  '\x03a5'# -> unI64 965+  -- GREEK CAPITAL LETTER PHI+  '\x03a6'# -> unI64 966+  -- GREEK CAPITAL LETTER CHI+  '\x03a7'# -> unI64 967+  -- GREEK CAPITAL LETTER PSI+  '\x03a8'# -> unI64 968+  -- GREEK CAPITAL LETTER OMEGA+  '\x03a9'# -> unI64 969+  -- GREEK CAPITAL LETTER IOTA WITH DIALYTIKA+  '\x03aa'# -> unI64 970+  -- GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA+  '\x03ab'# -> unI64 971+  -- GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS+  '\x03b0'# -> unI64 3382099394429893+  -- GREEK SMALL LETTER FINAL SIGMA+  '\x03c2'# -> unI64 963+  -- GREEK CAPITAL KAI SYMBOL+  '\x03cf'# -> unI64 983+  -- GREEK BETA SYMBOL+  '\x03d0'# -> unI64 946+  -- GREEK THETA SYMBOL+  '\x03d1'# -> unI64 952+  -- GREEK PHI SYMBOL+  '\x03d5'# -> unI64 966+  -- GREEK PI SYMBOL+  '\x03d6'# -> unI64 960+  -- GREEK LETTER ARCHAIC KOPPA+  '\x03d8'# -> unI64 985+  -- GREEK LETTER STIGMA+  '\x03da'# -> unI64 987+  -- GREEK LETTER DIGAMMA+  '\x03dc'# -> unI64 989+  -- GREEK LETTER KOPPA+  '\x03de'# -> unI64 991+  -- GREEK LETTER SAMPI+  '\x03e0'# -> unI64 993+  -- COPTIC CAPITAL LETTER SHEI+  '\x03e2'# -> unI64 995+  -- COPTIC CAPITAL LETTER FEI+  '\x03e4'# -> unI64 997+  -- COPTIC CAPITAL LETTER KHEI+  '\x03e6'# -> unI64 999+  -- COPTIC CAPITAL LETTER HORI+  '\x03e8'# -> unI64 1001+  -- COPTIC CAPITAL LETTER GANGIA+  '\x03ea'# -> unI64 1003+  -- COPTIC CAPITAL LETTER SHIMA+  '\x03ec'# -> unI64 1005+  -- COPTIC CAPITAL LETTER DEI+  '\x03ee'# -> unI64 1007+  -- GREEK KAPPA SYMBOL+  '\x03f0'# -> unI64 954+  -- GREEK RHO SYMBOL+  '\x03f1'# -> unI64 961+  -- GREEK CAPITAL THETA SYMBOL+  '\x03f4'# -> unI64 952+  -- GREEK LUNATE EPSILON SYMBOL+  '\x03f5'# -> unI64 949+  -- GREEK CAPITAL LETTER SHO+  '\x03f7'# -> unI64 1016+  -- GREEK CAPITAL LUNATE SIGMA SYMBOL+  '\x03f9'# -> unI64 1010+  -- GREEK CAPITAL LETTER SAN+  '\x03fa'# -> unI64 1019+  -- GREEK CAPITAL REVERSED LUNATE SIGMA SYMBOL+  '\x03fd'# -> unI64 891+  -- GREEK CAPITAL DOTTED LUNATE SIGMA SYMBOL+  '\x03fe'# -> unI64 892+  -- GREEK CAPITAL REVERSED DOTTED LUNATE SIGMA SYMBOL+  '\x03ff'# -> unI64 893+  -- CYRILLIC CAPITAL LETTER IE WITH GRAVE+  '\x0400'# -> unI64 1104+  -- CYRILLIC CAPITAL LETTER IO+  '\x0401'# -> unI64 1105+  -- CYRILLIC CAPITAL LETTER DJE+  '\x0402'# -> unI64 1106+  -- CYRILLIC CAPITAL LETTER GJE+  '\x0403'# -> unI64 1107+  -- CYRILLIC CAPITAL LETTER UKRAINIAN IE+  '\x0404'# -> unI64 1108+  -- CYRILLIC CAPITAL LETTER DZE+  '\x0405'# -> unI64 1109+  -- CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I+  '\x0406'# -> unI64 1110+  -- CYRILLIC CAPITAL LETTER YI+  '\x0407'# -> unI64 1111+  -- CYRILLIC CAPITAL LETTER JE+  '\x0408'# -> unI64 1112+  -- CYRILLIC CAPITAL LETTER LJE+  '\x0409'# -> unI64 1113+  -- CYRILLIC CAPITAL LETTER NJE+  '\x040a'# -> unI64 1114+  -- CYRILLIC CAPITAL LETTER TSHE+  '\x040b'# -> unI64 1115+  -- CYRILLIC CAPITAL LETTER KJE+  '\x040c'# -> unI64 1116+  -- CYRILLIC CAPITAL LETTER I WITH GRAVE+  '\x040d'# -> unI64 1117+  -- CYRILLIC CAPITAL LETTER SHORT U+  '\x040e'# -> unI64 1118+  -- CYRILLIC CAPITAL LETTER DZHE+  '\x040f'# -> unI64 1119+  -- CYRILLIC CAPITAL LETTER A+  '\x0410'# -> unI64 1072+  -- CYRILLIC CAPITAL LETTER BE+  '\x0411'# -> unI64 1073+  -- CYRILLIC CAPITAL LETTER VE+  '\x0412'# -> unI64 1074+  -- CYRILLIC CAPITAL LETTER GHE+  '\x0413'# -> unI64 1075+  -- CYRILLIC CAPITAL LETTER DE+  '\x0414'# -> unI64 1076+  -- CYRILLIC CAPITAL LETTER IE+  '\x0415'# -> unI64 1077+  -- CYRILLIC CAPITAL LETTER ZHE+  '\x0416'# -> unI64 1078+  -- CYRILLIC CAPITAL LETTER ZE+  '\x0417'# -> unI64 1079+  -- CYRILLIC CAPITAL LETTER I+  '\x0418'# -> unI64 1080+  -- CYRILLIC CAPITAL LETTER SHORT I+  '\x0419'# -> unI64 1081+  -- CYRILLIC CAPITAL LETTER KA+  '\x041a'# -> unI64 1082+  -- CYRILLIC CAPITAL LETTER EL+  '\x041b'# -> unI64 1083+  -- CYRILLIC CAPITAL LETTER EM+  '\x041c'# -> unI64 1084+  -- CYRILLIC CAPITAL LETTER EN+  '\x041d'# -> unI64 1085+  -- CYRILLIC CAPITAL LETTER O+  '\x041e'# -> unI64 1086+  -- CYRILLIC CAPITAL LETTER PE+  '\x041f'# -> unI64 1087+  -- CYRILLIC CAPITAL LETTER ER+  '\x0420'# -> unI64 1088+  -- CYRILLIC CAPITAL LETTER ES+  '\x0421'# -> unI64 1089+  -- CYRILLIC CAPITAL LETTER TE+  '\x0422'# -> unI64 1090+  -- CYRILLIC CAPITAL LETTER U+  '\x0423'# -> unI64 1091+  -- CYRILLIC CAPITAL LETTER EF+  '\x0424'# -> unI64 1092+  -- CYRILLIC CAPITAL LETTER HA+  '\x0425'# -> unI64 1093+  -- CYRILLIC CAPITAL LETTER TSE+  '\x0426'# -> unI64 1094+  -- CYRILLIC CAPITAL LETTER CHE+  '\x0427'# -> unI64 1095+  -- CYRILLIC CAPITAL LETTER SHA+  '\x0428'# -> unI64 1096+  -- CYRILLIC CAPITAL LETTER SHCHA+  '\x0429'# -> unI64 1097+  -- CYRILLIC CAPITAL LETTER HARD SIGN+  '\x042a'# -> unI64 1098+  -- CYRILLIC CAPITAL LETTER YERU+  '\x042b'# -> unI64 1099+  -- CYRILLIC CAPITAL LETTER SOFT SIGN+  '\x042c'# -> unI64 1100+  -- CYRILLIC CAPITAL LETTER E+  '\x042d'# -> unI64 1101+  -- CYRILLIC CAPITAL LETTER YU+  '\x042e'# -> unI64 1102+  -- CYRILLIC CAPITAL LETTER YA+  '\x042f'# -> unI64 1103+  -- CYRILLIC CAPITAL LETTER OMEGA+  '\x0460'# -> unI64 1121+  -- CYRILLIC CAPITAL LETTER YAT+  '\x0462'# -> unI64 1123+  -- CYRILLIC CAPITAL LETTER IOTIFIED E+  '\x0464'# -> unI64 1125+  -- CYRILLIC CAPITAL LETTER LITTLE YUS+  '\x0466'# -> unI64 1127+  -- CYRILLIC CAPITAL LETTER IOTIFIED LITTLE YUS+  '\x0468'# -> unI64 1129+  -- CYRILLIC CAPITAL LETTER BIG YUS+  '\x046a'# -> unI64 1131+  -- CYRILLIC CAPITAL LETTER IOTIFIED BIG YUS+  '\x046c'# -> unI64 1133+  -- CYRILLIC CAPITAL LETTER KSI+  '\x046e'# -> unI64 1135+  -- CYRILLIC CAPITAL LETTER PSI+  '\x0470'# -> unI64 1137+  -- CYRILLIC CAPITAL LETTER FITA+  '\x0472'# -> unI64 1139+  -- CYRILLIC CAPITAL LETTER IZHITSA+  '\x0474'# -> unI64 1141+  -- CYRILLIC CAPITAL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT+  '\x0476'# -> unI64 1143+  -- CYRILLIC CAPITAL LETTER UK+  '\x0478'# -> unI64 1145+  -- CYRILLIC CAPITAL LETTER ROUND OMEGA+  '\x047a'# -> unI64 1147+  -- CYRILLIC CAPITAL LETTER OMEGA WITH TITLO+  '\x047c'# -> unI64 1149+  -- CYRILLIC CAPITAL LETTER OT+  '\x047e'# -> unI64 1151+  -- CYRILLIC CAPITAL LETTER KOPPA+  '\x0480'# -> unI64 1153+  -- CYRILLIC CAPITAL LETTER SHORT I WITH TAIL+  '\x048a'# -> unI64 1163+  -- CYRILLIC CAPITAL LETTER SEMISOFT SIGN+  '\x048c'# -> unI64 1165+  -- CYRILLIC CAPITAL LETTER ER WITH TICK+  '\x048e'# -> unI64 1167+  -- CYRILLIC CAPITAL LETTER GHE WITH UPTURN+  '\x0490'# -> unI64 1169+  -- CYRILLIC CAPITAL LETTER GHE WITH STROKE+  '\x0492'# -> unI64 1171+  -- CYRILLIC CAPITAL LETTER GHE WITH MIDDLE HOOK+  '\x0494'# -> unI64 1173+  -- CYRILLIC CAPITAL LETTER ZHE WITH DESCENDER+  '\x0496'# -> unI64 1175+  -- CYRILLIC CAPITAL LETTER ZE WITH DESCENDER+  '\x0498'# -> unI64 1177+  -- CYRILLIC CAPITAL LETTER KA WITH DESCENDER+  '\x049a'# -> unI64 1179+  -- CYRILLIC CAPITAL LETTER KA WITH VERTICAL STROKE+  '\x049c'# -> unI64 1181+  -- CYRILLIC CAPITAL LETTER KA WITH STROKE+  '\x049e'# -> unI64 1183+  -- CYRILLIC CAPITAL LETTER BASHKIR KA+  '\x04a0'# -> unI64 1185+  -- CYRILLIC CAPITAL LETTER EN WITH DESCENDER+  '\x04a2'# -> unI64 1187+  -- CYRILLIC CAPITAL LIGATURE EN GHE+  '\x04a4'# -> unI64 1189+  -- CYRILLIC CAPITAL LETTER PE WITH MIDDLE HOOK+  '\x04a6'# -> unI64 1191+  -- CYRILLIC CAPITAL LETTER ABKHASIAN HA+  '\x04a8'# -> unI64 1193+  -- CYRILLIC CAPITAL LETTER ES WITH DESCENDER+  '\x04aa'# -> unI64 1195+  -- CYRILLIC CAPITAL LETTER TE WITH DESCENDER+  '\x04ac'# -> unI64 1197+  -- CYRILLIC CAPITAL LETTER STRAIGHT U+  '\x04ae'# -> unI64 1199+  -- CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE+  '\x04b0'# -> unI64 1201+  -- CYRILLIC CAPITAL LETTER HA WITH DESCENDER+  '\x04b2'# -> unI64 1203+  -- CYRILLIC CAPITAL LIGATURE TE TSE+  '\x04b4'# -> unI64 1205+  -- CYRILLIC CAPITAL LETTER CHE WITH DESCENDER+  '\x04b6'# -> unI64 1207+  -- CYRILLIC CAPITAL LETTER CHE WITH VERTICAL STROKE+  '\x04b8'# -> unI64 1209+  -- CYRILLIC CAPITAL LETTER SHHA+  '\x04ba'# -> unI64 1211+  -- CYRILLIC CAPITAL LETTER ABKHASIAN CHE+  '\x04bc'# -> unI64 1213+  -- CYRILLIC CAPITAL LETTER ABKHASIAN CHE WITH DESCENDER+  '\x04be'# -> unI64 1215+  -- CYRILLIC LETTER PALOCHKA+  '\x04c0'# -> unI64 1231+  -- CYRILLIC CAPITAL LETTER ZHE WITH BREVE+  '\x04c1'# -> unI64 1218+  -- CYRILLIC CAPITAL LETTER KA WITH HOOK+  '\x04c3'# -> unI64 1220+  -- CYRILLIC CAPITAL LETTER EL WITH TAIL+  '\x04c5'# -> unI64 1222+  -- CYRILLIC CAPITAL LETTER EN WITH HOOK+  '\x04c7'# -> unI64 1224+  -- CYRILLIC CAPITAL LETTER EN WITH TAIL+  '\x04c9'# -> unI64 1226+  -- CYRILLIC CAPITAL LETTER KHAKASSIAN CHE+  '\x04cb'# -> unI64 1228+  -- CYRILLIC CAPITAL LETTER EM WITH TAIL+  '\x04cd'# -> unI64 1230+  -- CYRILLIC CAPITAL LETTER A WITH BREVE+  '\x04d0'# -> unI64 1233+  -- CYRILLIC CAPITAL LETTER A WITH DIAERESIS+  '\x04d2'# -> unI64 1235+  -- CYRILLIC CAPITAL LIGATURE A IE+  '\x04d4'# -> unI64 1237+  -- CYRILLIC CAPITAL LETTER IE WITH BREVE+  '\x04d6'# -> unI64 1239+  -- CYRILLIC CAPITAL LETTER SCHWA+  '\x04d8'# -> unI64 1241+  -- CYRILLIC CAPITAL LETTER SCHWA WITH DIAERESIS+  '\x04da'# -> unI64 1243+  -- CYRILLIC CAPITAL LETTER ZHE WITH DIAERESIS+  '\x04dc'# -> unI64 1245+  -- CYRILLIC CAPITAL LETTER ZE WITH DIAERESIS+  '\x04de'# -> unI64 1247+  -- CYRILLIC CAPITAL LETTER ABKHASIAN DZE+  '\x04e0'# -> unI64 1249+  -- CYRILLIC CAPITAL LETTER I WITH MACRON+  '\x04e2'# -> unI64 1251+  -- CYRILLIC CAPITAL LETTER I WITH DIAERESIS+  '\x04e4'# -> unI64 1253+  -- CYRILLIC CAPITAL LETTER O WITH DIAERESIS+  '\x04e6'# -> unI64 1255+  -- CYRILLIC CAPITAL LETTER BARRED O+  '\x04e8'# -> unI64 1257+  -- CYRILLIC CAPITAL LETTER BARRED O WITH DIAERESIS+  '\x04ea'# -> unI64 1259+  -- CYRILLIC CAPITAL LETTER E WITH DIAERESIS+  '\x04ec'# -> unI64 1261+  -- CYRILLIC CAPITAL LETTER U WITH MACRON+  '\x04ee'# -> unI64 1263+  -- CYRILLIC CAPITAL LETTER U WITH DIAERESIS+  '\x04f0'# -> unI64 1265+  -- CYRILLIC CAPITAL LETTER U WITH DOUBLE ACUTE+  '\x04f2'# -> unI64 1267+  -- CYRILLIC CAPITAL LETTER CHE WITH DIAERESIS+  '\x04f4'# -> unI64 1269+  -- CYRILLIC CAPITAL LETTER GHE WITH DESCENDER+  '\x04f6'# -> unI64 1271+  -- CYRILLIC CAPITAL LETTER YERU WITH DIAERESIS+  '\x04f8'# -> unI64 1273+  -- CYRILLIC CAPITAL LETTER GHE WITH STROKE AND HOOK+  '\x04fa'# -> unI64 1275+  -- CYRILLIC CAPITAL LETTER HA WITH HOOK+  '\x04fc'# -> unI64 1277+  -- CYRILLIC CAPITAL LETTER HA WITH STROKE+  '\x04fe'# -> unI64 1279+  -- CYRILLIC CAPITAL LETTER KOMI DE+  '\x0500'# -> unI64 1281+  -- CYRILLIC CAPITAL LETTER KOMI DJE+  '\x0502'# -> unI64 1283+  -- CYRILLIC CAPITAL LETTER KOMI ZJE+  '\x0504'# -> unI64 1285+  -- CYRILLIC CAPITAL LETTER KOMI DZJE+  '\x0506'# -> unI64 1287+  -- CYRILLIC CAPITAL LETTER KOMI LJE+  '\x0508'# -> unI64 1289+  -- CYRILLIC CAPITAL LETTER KOMI NJE+  '\x050a'# -> unI64 1291+  -- CYRILLIC CAPITAL LETTER KOMI SJE+  '\x050c'# -> unI64 1293+  -- CYRILLIC CAPITAL LETTER KOMI TJE+  '\x050e'# -> unI64 1295+  -- CYRILLIC CAPITAL LETTER REVERSED ZE+  '\x0510'# -> unI64 1297+  -- CYRILLIC CAPITAL LETTER EL WITH HOOK+  '\x0512'# -> unI64 1299+  -- CYRILLIC CAPITAL LETTER LHA+  '\x0514'# -> unI64 1301+  -- CYRILLIC CAPITAL LETTER RHA+  '\x0516'# -> unI64 1303+  -- CYRILLIC CAPITAL LETTER YAE+  '\x0518'# -> unI64 1305+  -- CYRILLIC CAPITAL LETTER QA+  '\x051a'# -> unI64 1307+  -- CYRILLIC CAPITAL LETTER WE+  '\x051c'# -> unI64 1309+  -- CYRILLIC CAPITAL LETTER ALEUT KA+  '\x051e'# -> unI64 1311+  -- CYRILLIC CAPITAL LETTER EL WITH MIDDLE HOOK+  '\x0520'# -> unI64 1313+  -- CYRILLIC CAPITAL LETTER EN WITH MIDDLE HOOK+  '\x0522'# -> unI64 1315+  -- CYRILLIC CAPITAL LETTER PE WITH DESCENDER+  '\x0524'# -> unI64 1317+  -- CYRILLIC CAPITAL LETTER SHHA WITH DESCENDER+  '\x0526'# -> unI64 1319+  -- CYRILLIC CAPITAL LETTER EN WITH LEFT HOOK+  '\x0528'# -> unI64 1321+  -- CYRILLIC CAPITAL LETTER DZZHE+  '\x052a'# -> unI64 1323+  -- CYRILLIC CAPITAL LETTER DCHE+  '\x052c'# -> unI64 1325+  -- CYRILLIC CAPITAL LETTER EL WITH DESCENDER+  '\x052e'# -> unI64 1327+  -- ARMENIAN CAPITAL LETTER AYB+  '\x0531'# -> unI64 1377+  -- ARMENIAN CAPITAL LETTER BEN+  '\x0532'# -> unI64 1378+  -- ARMENIAN CAPITAL LETTER GIM+  '\x0533'# -> unI64 1379+  -- ARMENIAN CAPITAL LETTER DA+  '\x0534'# -> unI64 1380+  -- ARMENIAN CAPITAL LETTER ECH+  '\x0535'# -> unI64 1381+  -- ARMENIAN CAPITAL LETTER ZA+  '\x0536'# -> unI64 1382+  -- ARMENIAN CAPITAL LETTER EH+  '\x0537'# -> unI64 1383+  -- ARMENIAN CAPITAL LETTER ET+  '\x0538'# -> unI64 1384+  -- ARMENIAN CAPITAL LETTER TO+  '\x0539'# -> unI64 1385+  -- ARMENIAN CAPITAL LETTER ZHE+  '\x053a'# -> unI64 1386+  -- ARMENIAN CAPITAL LETTER INI+  '\x053b'# -> unI64 1387+  -- ARMENIAN CAPITAL LETTER LIWN+  '\x053c'# -> unI64 1388+  -- ARMENIAN CAPITAL LETTER XEH+  '\x053d'# -> unI64 1389+  -- ARMENIAN CAPITAL LETTER CA+  '\x053e'# -> unI64 1390+  -- ARMENIAN CAPITAL LETTER KEN+  '\x053f'# -> unI64 1391+  -- ARMENIAN CAPITAL LETTER HO+  '\x0540'# -> unI64 1392+  -- ARMENIAN CAPITAL LETTER JA+  '\x0541'# -> unI64 1393+  -- ARMENIAN CAPITAL LETTER GHAD+  '\x0542'# -> unI64 1394+  -- ARMENIAN CAPITAL LETTER CHEH+  '\x0543'# -> unI64 1395+  -- ARMENIAN CAPITAL LETTER MEN+  '\x0544'# -> unI64 1396+  -- ARMENIAN CAPITAL LETTER YI+  '\x0545'# -> unI64 1397+  -- ARMENIAN CAPITAL LETTER NOW+  '\x0546'# -> unI64 1398+  -- ARMENIAN CAPITAL LETTER SHA+  '\x0547'# -> unI64 1399+  -- ARMENIAN CAPITAL LETTER VO+  '\x0548'# -> unI64 1400+  -- ARMENIAN CAPITAL LETTER CHA+  '\x0549'# -> unI64 1401+  -- ARMENIAN CAPITAL LETTER PEH+  '\x054a'# -> unI64 1402+  -- ARMENIAN CAPITAL LETTER JHEH+  '\x054b'# -> unI64 1403+  -- ARMENIAN CAPITAL LETTER RA+  '\x054c'# -> unI64 1404+  -- ARMENIAN CAPITAL LETTER SEH+  '\x054d'# -> unI64 1405+  -- ARMENIAN CAPITAL LETTER VEW+  '\x054e'# -> unI64 1406+  -- ARMENIAN CAPITAL LETTER TIWN+  '\x054f'# -> unI64 1407+  -- ARMENIAN CAPITAL LETTER REH+  '\x0550'# -> unI64 1408+  -- ARMENIAN CAPITAL LETTER CO+  '\x0551'# -> unI64 1409+  -- ARMENIAN CAPITAL LETTER YIWN+  '\x0552'# -> unI64 1410+  -- ARMENIAN CAPITAL LETTER PIWR+  '\x0553'# -> unI64 1411+  -- ARMENIAN CAPITAL LETTER KEH+  '\x0554'# -> unI64 1412+  -- ARMENIAN CAPITAL LETTER OH+  '\x0555'# -> unI64 1413+  -- ARMENIAN CAPITAL LETTER FEH+  '\x0556'# -> unI64 1414+  -- ARMENIAN SMALL LIGATURE ECH YIWN+  '\x0587'# -> unI64 2956985701+  -- GEORGIAN CAPITAL LETTER AN+  '\x10a0'# -> unI64 11520+  -- GEORGIAN CAPITAL LETTER BAN+  '\x10a1'# -> unI64 11521+  -- GEORGIAN CAPITAL LETTER GAN+  '\x10a2'# -> unI64 11522+  -- GEORGIAN CAPITAL LETTER DON+  '\x10a3'# -> unI64 11523+  -- GEORGIAN CAPITAL LETTER EN+  '\x10a4'# -> unI64 11524+  -- GEORGIAN CAPITAL LETTER VIN+  '\x10a5'# -> unI64 11525+  -- GEORGIAN CAPITAL LETTER ZEN+  '\x10a6'# -> unI64 11526+  -- GEORGIAN CAPITAL LETTER TAN+  '\x10a7'# -> unI64 11527+  -- GEORGIAN CAPITAL LETTER IN+  '\x10a8'# -> unI64 11528+  -- GEORGIAN CAPITAL LETTER KAN+  '\x10a9'# -> unI64 11529+  -- GEORGIAN CAPITAL LETTER LAS+  '\x10aa'# -> unI64 11530+  -- GEORGIAN CAPITAL LETTER MAN+  '\x10ab'# -> unI64 11531+  -- GEORGIAN CAPITAL LETTER NAR+  '\x10ac'# -> unI64 11532+  -- GEORGIAN CAPITAL LETTER ON+  '\x10ad'# -> unI64 11533+  -- GEORGIAN CAPITAL LETTER PAR+  '\x10ae'# -> unI64 11534+  -- GEORGIAN CAPITAL LETTER ZHAR+  '\x10af'# -> unI64 11535+  -- GEORGIAN CAPITAL LETTER RAE+  '\x10b0'# -> unI64 11536+  -- GEORGIAN CAPITAL LETTER SAN+  '\x10b1'# -> unI64 11537+  -- GEORGIAN CAPITAL LETTER TAR+  '\x10b2'# -> unI64 11538+  -- GEORGIAN CAPITAL LETTER UN+  '\x10b3'# -> unI64 11539+  -- GEORGIAN CAPITAL LETTER PHAR+  '\x10b4'# -> unI64 11540+  -- GEORGIAN CAPITAL LETTER KHAR+  '\x10b5'# -> unI64 11541+  -- GEORGIAN CAPITAL LETTER GHAN+  '\x10b6'# -> unI64 11542+  -- GEORGIAN CAPITAL LETTER QAR+  '\x10b7'# -> unI64 11543+  -- GEORGIAN CAPITAL LETTER SHIN+  '\x10b8'# -> unI64 11544+  -- GEORGIAN CAPITAL LETTER CHIN+  '\x10b9'# -> unI64 11545+  -- GEORGIAN CAPITAL LETTER CAN+  '\x10ba'# -> unI64 11546+  -- GEORGIAN CAPITAL LETTER JIL+  '\x10bb'# -> unI64 11547+  -- GEORGIAN CAPITAL LETTER CIL+  '\x10bc'# -> unI64 11548+  -- GEORGIAN CAPITAL LETTER CHAR+  '\x10bd'# -> unI64 11549+  -- GEORGIAN CAPITAL LETTER XAN+  '\x10be'# -> unI64 11550+  -- GEORGIAN CAPITAL LETTER JHAN+  '\x10bf'# -> unI64 11551+  -- GEORGIAN CAPITAL LETTER HAE+  '\x10c0'# -> unI64 11552+  -- GEORGIAN CAPITAL LETTER HE+  '\x10c1'# -> unI64 11553+  -- GEORGIAN CAPITAL LETTER HIE+  '\x10c2'# -> unI64 11554+  -- GEORGIAN CAPITAL LETTER WE+  '\x10c3'# -> unI64 11555+  -- GEORGIAN CAPITAL LETTER HAR+  '\x10c4'# -> unI64 11556+  -- GEORGIAN CAPITAL LETTER HOE+  '\x10c5'# -> unI64 11557+  -- GEORGIAN CAPITAL LETTER YN+  '\x10c7'# -> unI64 11559+  -- GEORGIAN CAPITAL LETTER AEN+  '\x10cd'# -> unI64 11565+  -- CHEROKEE SMALL LETTER YE+  '\x13f8'# -> unI64 5104+  -- CHEROKEE SMALL LETTER YI+  '\x13f9'# -> unI64 5105+  -- CHEROKEE SMALL LETTER YO+  '\x13fa'# -> unI64 5106+  -- CHEROKEE SMALL LETTER YU+  '\x13fb'# -> unI64 5107+  -- CHEROKEE SMALL LETTER YV+  '\x13fc'# -> unI64 5108+  -- CHEROKEE SMALL LETTER MV+  '\x13fd'# -> unI64 5109+  -- CYRILLIC SMALL LETTER ROUNDED VE+  '\x1c80'# -> unI64 1074+  -- CYRILLIC SMALL LETTER LONG-LEGGED DE+  '\x1c81'# -> unI64 1076+  -- CYRILLIC SMALL LETTER NARROW O+  '\x1c82'# -> unI64 1086+  -- CYRILLIC SMALL LETTER WIDE ES+  '\x1c83'# -> unI64 1089+  -- CYRILLIC SMALL LETTER TALL TE+  '\x1c84'# -> unI64 1090+  -- CYRILLIC SMALL LETTER THREE-LEGGED TE+  '\x1c85'# -> unI64 1090+  -- CYRILLIC SMALL LETTER TALL HARD SIGN+  '\x1c86'# -> unI64 1098+  -- CYRILLIC SMALL LETTER TALL YAT+  '\x1c87'# -> unI64 1123+  -- CYRILLIC SMALL LETTER UNBLENDED UK+  '\x1c88'# -> unI64 42571+  -- GEORGIAN MTAVRULI CAPITAL LETTER AN+  '\x1c90'# -> unI64 4304+  -- GEORGIAN MTAVRULI CAPITAL LETTER BAN+  '\x1c91'# -> unI64 4305+  -- GEORGIAN MTAVRULI CAPITAL LETTER GAN+  '\x1c92'# -> unI64 4306+  -- GEORGIAN MTAVRULI CAPITAL LETTER DON+  '\x1c93'# -> unI64 4307+  -- GEORGIAN MTAVRULI CAPITAL LETTER EN+  '\x1c94'# -> unI64 4308+  -- GEORGIAN MTAVRULI CAPITAL LETTER VIN+  '\x1c95'# -> unI64 4309+  -- GEORGIAN MTAVRULI CAPITAL LETTER ZEN+  '\x1c96'# -> unI64 4310+  -- GEORGIAN MTAVRULI CAPITAL LETTER TAN+  '\x1c97'# -> unI64 4311+  -- GEORGIAN MTAVRULI CAPITAL LETTER IN+  '\x1c98'# -> unI64 4312+  -- GEORGIAN MTAVRULI CAPITAL LETTER KAN+  '\x1c99'# -> unI64 4313+  -- GEORGIAN MTAVRULI CAPITAL LETTER LAS+  '\x1c9a'# -> unI64 4314+  -- GEORGIAN MTAVRULI CAPITAL LETTER MAN+  '\x1c9b'# -> unI64 4315+  -- GEORGIAN MTAVRULI CAPITAL LETTER NAR+  '\x1c9c'# -> unI64 4316+  -- GEORGIAN MTAVRULI CAPITAL LETTER ON+  '\x1c9d'# -> unI64 4317+  -- GEORGIAN MTAVRULI CAPITAL LETTER PAR+  '\x1c9e'# -> unI64 4318+  -- GEORGIAN MTAVRULI CAPITAL LETTER ZHAR+  '\x1c9f'# -> unI64 4319+  -- GEORGIAN MTAVRULI CAPITAL LETTER RAE+  '\x1ca0'# -> unI64 4320+  -- GEORGIAN MTAVRULI CAPITAL LETTER SAN+  '\x1ca1'# -> unI64 4321+  -- GEORGIAN MTAVRULI CAPITAL LETTER TAR+  '\x1ca2'# -> unI64 4322+  -- GEORGIAN MTAVRULI CAPITAL LETTER UN+  '\x1ca3'# -> unI64 4323+  -- GEORGIAN MTAVRULI CAPITAL LETTER PHAR+  '\x1ca4'# -> unI64 4324+  -- GEORGIAN MTAVRULI CAPITAL LETTER KHAR+  '\x1ca5'# -> unI64 4325+  -- GEORGIAN MTAVRULI CAPITAL LETTER GHAN+  '\x1ca6'# -> unI64 4326+  -- GEORGIAN MTAVRULI CAPITAL LETTER QAR+  '\x1ca7'# -> unI64 4327+  -- GEORGIAN MTAVRULI CAPITAL LETTER SHIN+  '\x1ca8'# -> unI64 4328+  -- GEORGIAN MTAVRULI CAPITAL LETTER CHIN+  '\x1ca9'# -> unI64 4329+  -- GEORGIAN MTAVRULI CAPITAL LETTER CAN+  '\x1caa'# -> unI64 4330+  -- GEORGIAN MTAVRULI CAPITAL LETTER JIL+  '\x1cab'# -> unI64 4331+  -- GEORGIAN MTAVRULI CAPITAL LETTER CIL+  '\x1cac'# -> unI64 4332+  -- GEORGIAN MTAVRULI CAPITAL LETTER CHAR+  '\x1cad'# -> unI64 4333+  -- GEORGIAN MTAVRULI CAPITAL LETTER XAN+  '\x1cae'# -> unI64 4334+  -- GEORGIAN MTAVRULI CAPITAL LETTER JHAN+  '\x1caf'# -> unI64 4335+  -- GEORGIAN MTAVRULI CAPITAL LETTER HAE+  '\x1cb0'# -> unI64 4336+  -- GEORGIAN MTAVRULI CAPITAL LETTER HE+  '\x1cb1'# -> unI64 4337+  -- GEORGIAN MTAVRULI CAPITAL LETTER HIE+  '\x1cb2'# -> unI64 4338+  -- GEORGIAN MTAVRULI CAPITAL LETTER WE+  '\x1cb3'# -> unI64 4339+  -- GEORGIAN MTAVRULI CAPITAL LETTER HAR+  '\x1cb4'# -> unI64 4340+  -- GEORGIAN MTAVRULI CAPITAL LETTER HOE+  '\x1cb5'# -> unI64 4341+  -- GEORGIAN MTAVRULI CAPITAL LETTER FI+  '\x1cb6'# -> unI64 4342+  -- GEORGIAN MTAVRULI CAPITAL LETTER YN+  '\x1cb7'# -> unI64 4343+  -- GEORGIAN MTAVRULI CAPITAL LETTER ELIFI+  '\x1cb8'# -> unI64 4344+  -- GEORGIAN MTAVRULI CAPITAL LETTER TURNED GAN+  '\x1cb9'# -> unI64 4345+  -- GEORGIAN MTAVRULI CAPITAL LETTER AIN+  '\x1cba'# -> unI64 4346+  -- GEORGIAN MTAVRULI CAPITAL LETTER AEN+  '\x1cbd'# -> unI64 4349+  -- GEORGIAN MTAVRULI CAPITAL LETTER HARD SIGN+  '\x1cbe'# -> unI64 4350+  -- GEORGIAN MTAVRULI CAPITAL LETTER LABIAL SIGN+  '\x1cbf'# -> unI64 4351+  -- LATIN CAPITAL LETTER A WITH RING BELOW+  '\x1e00'# -> unI64 7681+  -- LATIN CAPITAL LETTER B WITH DOT ABOVE+  '\x1e02'# -> unI64 7683+  -- LATIN CAPITAL LETTER B WITH DOT BELOW+  '\x1e04'# -> unI64 7685+  -- LATIN CAPITAL LETTER B WITH LINE BELOW+  '\x1e06'# -> unI64 7687+  -- LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE+  '\x1e08'# -> unI64 7689+  -- LATIN CAPITAL LETTER D WITH DOT ABOVE+  '\x1e0a'# -> unI64 7691+  -- LATIN CAPITAL LETTER D WITH DOT BELOW+  '\x1e0c'# -> unI64 7693+  -- LATIN CAPITAL LETTER D WITH LINE BELOW+  '\x1e0e'# -> unI64 7695+  -- LATIN CAPITAL LETTER D WITH CEDILLA+  '\x1e10'# -> unI64 7697+  -- LATIN CAPITAL LETTER D WITH CIRCUMFLEX BELOW+  '\x1e12'# -> unI64 7699+  -- LATIN CAPITAL LETTER E WITH MACRON AND GRAVE+  '\x1e14'# -> unI64 7701+  -- LATIN CAPITAL LETTER E WITH MACRON AND ACUTE+  '\x1e16'# -> unI64 7703+  -- LATIN CAPITAL LETTER E WITH CIRCUMFLEX BELOW+  '\x1e18'# -> unI64 7705+  -- LATIN CAPITAL LETTER E WITH TILDE BELOW+  '\x1e1a'# -> unI64 7707+  -- LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE+  '\x1e1c'# -> unI64 7709+  -- LATIN CAPITAL LETTER F WITH DOT ABOVE+  '\x1e1e'# -> unI64 7711+  -- LATIN CAPITAL LETTER G WITH MACRON+  '\x1e20'# -> unI64 7713+  -- LATIN CAPITAL LETTER H WITH DOT ABOVE+  '\x1e22'# -> unI64 7715+  -- LATIN CAPITAL LETTER H WITH DOT BELOW+  '\x1e24'# -> unI64 7717+  -- LATIN CAPITAL LETTER H WITH DIAERESIS+  '\x1e26'# -> unI64 7719+  -- LATIN CAPITAL LETTER H WITH CEDILLA+  '\x1e28'# -> unI64 7721+  -- LATIN CAPITAL LETTER H WITH BREVE BELOW+  '\x1e2a'# -> unI64 7723+  -- LATIN CAPITAL LETTER I WITH TILDE BELOW+  '\x1e2c'# -> unI64 7725+  -- LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE+  '\x1e2e'# -> unI64 7727+  -- LATIN CAPITAL LETTER K WITH ACUTE+  '\x1e30'# -> unI64 7729+  -- LATIN CAPITAL LETTER K WITH DOT BELOW+  '\x1e32'# -> unI64 7731+  -- LATIN CAPITAL LETTER K WITH LINE BELOW+  '\x1e34'# -> unI64 7733+  -- LATIN CAPITAL LETTER L WITH DOT BELOW+  '\x1e36'# -> unI64 7735+  -- LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON+  '\x1e38'# -> unI64 7737+  -- LATIN CAPITAL LETTER L WITH LINE BELOW+  '\x1e3a'# -> unI64 7739+  -- LATIN CAPITAL LETTER L WITH CIRCUMFLEX BELOW+  '\x1e3c'# -> unI64 7741+  -- LATIN CAPITAL LETTER M WITH ACUTE+  '\x1e3e'# -> unI64 7743+  -- LATIN CAPITAL LETTER M WITH DOT ABOVE+  '\x1e40'# -> unI64 7745+  -- LATIN CAPITAL LETTER M WITH DOT BELOW+  '\x1e42'# -> unI64 7747+  -- LATIN CAPITAL LETTER N WITH DOT ABOVE+  '\x1e44'# -> unI64 7749+  -- LATIN CAPITAL LETTER N WITH DOT BELOW+  '\x1e46'# -> unI64 7751+  -- LATIN CAPITAL LETTER N WITH LINE BELOW+  '\x1e48'# -> unI64 7753+  -- LATIN CAPITAL LETTER N WITH CIRCUMFLEX BELOW+  '\x1e4a'# -> unI64 7755+  -- LATIN CAPITAL LETTER O WITH TILDE AND ACUTE+  '\x1e4c'# -> unI64 7757+  -- LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS+  '\x1e4e'# -> unI64 7759+  -- LATIN CAPITAL LETTER O WITH MACRON AND GRAVE+  '\x1e50'# -> unI64 7761+  -- LATIN CAPITAL LETTER O WITH MACRON AND ACUTE+  '\x1e52'# -> unI64 7763+  -- LATIN CAPITAL LETTER P WITH ACUTE+  '\x1e54'# -> unI64 7765+  -- LATIN CAPITAL LETTER P WITH DOT ABOVE+  '\x1e56'# -> unI64 7767+  -- LATIN CAPITAL LETTER R WITH DOT ABOVE+  '\x1e58'# -> unI64 7769+  -- LATIN CAPITAL LETTER R WITH DOT BELOW+  '\x1e5a'# -> unI64 7771+  -- LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON+  '\x1e5c'# -> unI64 7773+  -- LATIN CAPITAL LETTER R WITH LINE BELOW+  '\x1e5e'# -> unI64 7775+  -- LATIN CAPITAL LETTER S WITH DOT ABOVE+  '\x1e60'# -> unI64 7777+  -- LATIN CAPITAL LETTER S WITH DOT BELOW+  '\x1e62'# -> unI64 7779+  -- LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE+  '\x1e64'# -> unI64 7781+  -- LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE+  '\x1e66'# -> unI64 7783+  -- LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE+  '\x1e68'# -> unI64 7785+  -- LATIN CAPITAL LETTER T WITH DOT ABOVE+  '\x1e6a'# -> unI64 7787+  -- LATIN CAPITAL LETTER T WITH DOT BELOW+  '\x1e6c'# -> unI64 7789+  -- LATIN CAPITAL LETTER T WITH LINE BELOW+  '\x1e6e'# -> unI64 7791+  -- LATIN CAPITAL LETTER T WITH CIRCUMFLEX BELOW+  '\x1e70'# -> unI64 7793+  -- LATIN CAPITAL LETTER U WITH DIAERESIS BELOW+  '\x1e72'# -> unI64 7795+  -- LATIN CAPITAL LETTER U WITH TILDE BELOW+  '\x1e74'# -> unI64 7797+  -- LATIN CAPITAL LETTER U WITH CIRCUMFLEX BELOW+  '\x1e76'# -> unI64 7799+  -- LATIN CAPITAL LETTER U WITH TILDE AND ACUTE+  '\x1e78'# -> unI64 7801+  -- LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS+  '\x1e7a'# -> unI64 7803+  -- LATIN CAPITAL LETTER V WITH TILDE+  '\x1e7c'# -> unI64 7805+  -- LATIN CAPITAL LETTER V WITH DOT BELOW+  '\x1e7e'# -> unI64 7807+  -- LATIN CAPITAL LETTER W WITH GRAVE+  '\x1e80'# -> unI64 7809+  -- LATIN CAPITAL LETTER W WITH ACUTE+  '\x1e82'# -> unI64 7811+  -- LATIN CAPITAL LETTER W WITH DIAERESIS+  '\x1e84'# -> unI64 7813+  -- LATIN CAPITAL LETTER W WITH DOT ABOVE+  '\x1e86'# -> unI64 7815+  -- LATIN CAPITAL LETTER W WITH DOT BELOW+  '\x1e88'# -> unI64 7817+  -- LATIN CAPITAL LETTER X WITH DOT ABOVE+  '\x1e8a'# -> unI64 7819+  -- LATIN CAPITAL LETTER X WITH DIAERESIS+  '\x1e8c'# -> unI64 7821+  -- LATIN CAPITAL LETTER Y WITH DOT ABOVE+  '\x1e8e'# -> unI64 7823+  -- LATIN CAPITAL LETTER Z WITH CIRCUMFLEX+  '\x1e90'# -> unI64 7825+  -- LATIN CAPITAL LETTER Z WITH DOT BELOW+  '\x1e92'# -> unI64 7827+  -- LATIN CAPITAL LETTER Z WITH LINE BELOW+  '\x1e94'# -> unI64 7829+  -- LATIN SMALL LETTER H WITH LINE BELOW+  '\x1e96'# -> unI64 1713373288+  -- LATIN SMALL LETTER T WITH DIAERESIS+  '\x1e97'# -> unI64 1627390068+  -- LATIN SMALL LETTER W WITH RING ABOVE+  '\x1e98'# -> unI64 1631584375+  -- LATIN SMALL LETTER Y WITH RING ABOVE+  '\x1e99'# -> unI64 1631584377+  -- LATIN SMALL LETTER A WITH RIGHT HALF RING+  '\x1e9a'# -> unI64 1472200801+  -- LATIN SMALL LETTER LONG S WITH DOT ABOVE+  '\x1e9b'# -> unI64 7777+  -- LATIN CAPITAL LETTER SHARP S+  '\x1e9e'# -> unI64 241172595+  -- LATIN CAPITAL LETTER A WITH DOT BELOW+  '\x1ea0'# -> unI64 7841+  -- LATIN CAPITAL LETTER A WITH HOOK ABOVE+  '\x1ea2'# -> unI64 7843+  -- LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE+  '\x1ea4'# -> unI64 7845+  -- LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE+  '\x1ea6'# -> unI64 7847+  -- LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE+  '\x1ea8'# -> unI64 7849+  -- LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE+  '\x1eaa'# -> unI64 7851+  -- LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW+  '\x1eac'# -> unI64 7853+  -- LATIN CAPITAL LETTER A WITH BREVE AND ACUTE+  '\x1eae'# -> unI64 7855+  -- LATIN CAPITAL LETTER A WITH BREVE AND GRAVE+  '\x1eb0'# -> unI64 7857+  -- LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE+  '\x1eb2'# -> unI64 7859+  -- LATIN CAPITAL LETTER A WITH BREVE AND TILDE+  '\x1eb4'# -> unI64 7861+  -- LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW+  '\x1eb6'# -> unI64 7863+  -- LATIN CAPITAL LETTER E WITH DOT BELOW+  '\x1eb8'# -> unI64 7865+  -- LATIN CAPITAL LETTER E WITH HOOK ABOVE+  '\x1eba'# -> unI64 7867+  -- LATIN CAPITAL LETTER E WITH TILDE+  '\x1ebc'# -> unI64 7869+  -- LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE+  '\x1ebe'# -> unI64 7871+  -- LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE+  '\x1ec0'# -> unI64 7873+  -- LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE+  '\x1ec2'# -> unI64 7875+  -- LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE+  '\x1ec4'# -> unI64 7877+  -- LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW+  '\x1ec6'# -> unI64 7879+  -- LATIN CAPITAL LETTER I WITH HOOK ABOVE+  '\x1ec8'# -> unI64 7881+  -- LATIN CAPITAL LETTER I WITH DOT BELOW+  '\x1eca'# -> unI64 7883+  -- LATIN CAPITAL LETTER O WITH DOT BELOW+  '\x1ecc'# -> unI64 7885+  -- LATIN CAPITAL LETTER O WITH HOOK ABOVE+  '\x1ece'# -> unI64 7887+  -- LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE+  '\x1ed0'# -> unI64 7889+  -- LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE+  '\x1ed2'# -> unI64 7891+  -- LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE+  '\x1ed4'# -> unI64 7893+  -- LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE+  '\x1ed6'# -> unI64 7895+  -- LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW+  '\x1ed8'# -> unI64 7897+  -- LATIN CAPITAL LETTER O WITH HORN AND ACUTE+  '\x1eda'# -> unI64 7899+  -- LATIN CAPITAL LETTER O WITH HORN AND GRAVE+  '\x1edc'# -> unI64 7901+  -- LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE+  '\x1ede'# -> unI64 7903+  -- LATIN CAPITAL LETTER O WITH HORN AND TILDE+  '\x1ee0'# -> unI64 7905+  -- LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW+  '\x1ee2'# -> unI64 7907+  -- LATIN CAPITAL LETTER U WITH DOT BELOW+  '\x1ee4'# -> unI64 7909+  -- LATIN CAPITAL LETTER U WITH HOOK ABOVE+  '\x1ee6'# -> unI64 7911+  -- LATIN CAPITAL LETTER U WITH HORN AND ACUTE+  '\x1ee8'# -> unI64 7913+  -- LATIN CAPITAL LETTER U WITH HORN AND GRAVE+  '\x1eea'# -> unI64 7915+  -- LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE+  '\x1eec'# -> unI64 7917+  -- LATIN CAPITAL LETTER U WITH HORN AND TILDE+  '\x1eee'# -> unI64 7919+  -- LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW+  '\x1ef0'# -> unI64 7921+  -- LATIN CAPITAL LETTER Y WITH GRAVE+  '\x1ef2'# -> unI64 7923+  -- LATIN CAPITAL LETTER Y WITH DOT BELOW+  '\x1ef4'# -> unI64 7925+  -- LATIN CAPITAL LETTER Y WITH HOOK ABOVE+  '\x1ef6'# -> unI64 7927+  -- LATIN CAPITAL LETTER Y WITH TILDE+  '\x1ef8'# -> unI64 7929+  -- LATIN CAPITAL LETTER MIDDLE-WELSH LL+  '\x1efa'# -> unI64 7931+  -- LATIN CAPITAL LETTER MIDDLE-WELSH V+  '\x1efc'# -> unI64 7933+  -- LATIN CAPITAL LETTER Y WITH LOOP+  '\x1efe'# -> unI64 7935+  -- GREEK CAPITAL LETTER ALPHA WITH PSILI+  '\x1f08'# -> unI64 7936+  -- GREEK CAPITAL LETTER ALPHA WITH DASIA+  '\x1f09'# -> unI64 7937+  -- GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA+  '\x1f0a'# -> unI64 7938+  -- GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA+  '\x1f0b'# -> unI64 7939+  -- GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA+  '\x1f0c'# -> unI64 7940+  -- GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA+  '\x1f0d'# -> unI64 7941+  -- GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI+  '\x1f0e'# -> unI64 7942+  -- GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI+  '\x1f0f'# -> unI64 7943+  -- GREEK CAPITAL LETTER EPSILON WITH PSILI+  '\x1f18'# -> unI64 7952+  -- GREEK CAPITAL LETTER EPSILON WITH DASIA+  '\x1f19'# -> unI64 7953+  -- GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA+  '\x1f1a'# -> unI64 7954+  -- GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA+  '\x1f1b'# -> unI64 7955+  -- GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA+  '\x1f1c'# -> unI64 7956+  -- GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA+  '\x1f1d'# -> unI64 7957+  -- GREEK CAPITAL LETTER ETA WITH PSILI+  '\x1f28'# -> unI64 7968+  -- GREEK CAPITAL LETTER ETA WITH DASIA+  '\x1f29'# -> unI64 7969+  -- GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA+  '\x1f2a'# -> unI64 7970+  -- GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA+  '\x1f2b'# -> unI64 7971+  -- GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA+  '\x1f2c'# -> unI64 7972+  -- GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA+  '\x1f2d'# -> unI64 7973+  -- GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI+  '\x1f2e'# -> unI64 7974+  -- GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI+  '\x1f2f'# -> unI64 7975+  -- GREEK CAPITAL LETTER IOTA WITH PSILI+  '\x1f38'# -> unI64 7984+  -- GREEK CAPITAL LETTER IOTA WITH DASIA+  '\x1f39'# -> unI64 7985+  -- GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA+  '\x1f3a'# -> unI64 7986+  -- GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA+  '\x1f3b'# -> unI64 7987+  -- GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA+  '\x1f3c'# -> unI64 7988+  -- GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA+  '\x1f3d'# -> unI64 7989+  -- GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI+  '\x1f3e'# -> unI64 7990+  -- GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI+  '\x1f3f'# -> unI64 7991+  -- GREEK CAPITAL LETTER OMICRON WITH PSILI+  '\x1f48'# -> unI64 8000+  -- GREEK CAPITAL LETTER OMICRON WITH DASIA+  '\x1f49'# -> unI64 8001+  -- GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA+  '\x1f4a'# -> unI64 8002+  -- GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA+  '\x1f4b'# -> unI64 8003+  -- GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA+  '\x1f4c'# -> unI64 8004+  -- GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA+  '\x1f4d'# -> unI64 8005+  -- GREEK SMALL LETTER UPSILON WITH PSILI+  '\x1f50'# -> unI64 1650459589+  -- GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA+  '\x1f52'# -> unI64 3377701370987461+  -- GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA+  '\x1f54'# -> unI64 3382099417498565+  -- GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI+  '\x1f56'# -> unI64 3667972440720325+  -- GREEK CAPITAL LETTER UPSILON WITH DASIA+  '\x1f59'# -> unI64 8017+  -- GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA+  '\x1f5b'# -> unI64 8019+  -- GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA+  '\x1f5d'# -> unI64 8021+  -- GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI+  '\x1f5f'# -> unI64 8023+  -- GREEK CAPITAL LETTER OMEGA WITH PSILI+  '\x1f68'# -> unI64 8032+  -- GREEK CAPITAL LETTER OMEGA WITH DASIA+  '\x1f69'# -> unI64 8033+  -- GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA+  '\x1f6a'# -> unI64 8034+  -- GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA+  '\x1f6b'# -> unI64 8035+  -- GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA+  '\x1f6c'# -> unI64 8036+  -- GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA+  '\x1f6d'# -> unI64 8037+  -- GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI+  '\x1f6e'# -> unI64 8038+  -- GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI+  '\x1f6f'# -> unI64 8039+  -- GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI+  '\x1f80'# -> unI64 1998593792+  -- GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI+  '\x1f81'# -> unI64 1998593793+  -- GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI+  '\x1f82'# -> unI64 1998593794+  -- GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI+  '\x1f83'# -> unI64 1998593795+  -- GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI+  '\x1f84'# -> unI64 1998593796+  -- GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI+  '\x1f85'# -> unI64 1998593797+  -- GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI+  '\x1f86'# -> unI64 1998593798+  -- GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI+  '\x1f87'# -> unI64 1998593799+  -- GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI+  '\x1f88'# -> unI64 1998593792+  -- GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI+  '\x1f89'# -> unI64 1998593793+  -- GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI+  '\x1f8a'# -> unI64 1998593794+  -- GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI+  '\x1f8b'# -> unI64 1998593795+  -- GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI+  '\x1f8c'# -> unI64 1998593796+  -- GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI+  '\x1f8d'# -> unI64 1998593797+  -- GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI+  '\x1f8e'# -> unI64 1998593798+  -- GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI+  '\x1f8f'# -> unI64 1998593799+  -- GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI+  '\x1f90'# -> unI64 1998593824+  -- GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI+  '\x1f91'# -> unI64 1998593825+  -- GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI+  '\x1f92'# -> unI64 1998593826+  -- GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI+  '\x1f93'# -> unI64 1998593827+  -- GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI+  '\x1f94'# -> unI64 1998593828+  -- GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI+  '\x1f95'# -> unI64 1998593829+  -- GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI+  '\x1f96'# -> unI64 1998593830+  -- GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI+  '\x1f97'# -> unI64 1998593831+  -- GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI+  '\x1f98'# -> unI64 1998593824+  -- GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI+  '\x1f99'# -> unI64 1998593825+  -- GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI+  '\x1f9a'# -> unI64 1998593826+  -- GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI+  '\x1f9b'# -> unI64 1998593827+  -- GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI+  '\x1f9c'# -> unI64 1998593828+  -- GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI+  '\x1f9d'# -> unI64 1998593829+  -- GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI+  '\x1f9e'# -> unI64 1998593830+  -- GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI+  '\x1f9f'# -> unI64 1998593831+  -- GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI+  '\x1fa0'# -> unI64 1998593888+  -- GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI+  '\x1fa1'# -> unI64 1998593889+  -- GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI+  '\x1fa2'# -> unI64 1998593890+  -- GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI+  '\x1fa3'# -> unI64 1998593891+  -- GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI+  '\x1fa4'# -> unI64 1998593892+  -- GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI+  '\x1fa5'# -> unI64 1998593893+  -- GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI+  '\x1fa6'# -> unI64 1998593894+  -- GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI+  '\x1fa7'# -> unI64 1998593895+  -- GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI+  '\x1fa8'# -> unI64 1998593888+  -- GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI+  '\x1fa9'# -> unI64 1998593889+  -- GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI+  '\x1faa'# -> unI64 1998593890+  -- GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI+  '\x1fab'# -> unI64 1998593891+  -- GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI+  '\x1fac'# -> unI64 1998593892+  -- GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI+  '\x1fad'# -> unI64 1998593893+  -- GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI+  '\x1fae'# -> unI64 1998593894+  -- GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI+  '\x1faf'# -> unI64 1998593895+  -- GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI+  '\x1fb2'# -> unI64 1998593904+  -- GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI+  '\x1fb3'# -> unI64 1998586801+  -- GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI+  '\x1fb4'# -> unI64 1998586796+  -- GREEK SMALL LETTER ALPHA WITH PERISPOMENI+  '\x1fb6'# -> unI64 1749025713+  -- GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI+  '\x1fb7'# -> unI64 4191340074107825+  -- GREEK CAPITAL LETTER ALPHA WITH VRACHY+  '\x1fb8'# -> unI64 8112+  -- GREEK CAPITAL LETTER ALPHA WITH MACRON+  '\x1fb9'# -> unI64 8113+  -- GREEK CAPITAL LETTER ALPHA WITH VARIA+  '\x1fba'# -> unI64 8048+  -- GREEK CAPITAL LETTER ALPHA WITH OXIA+  '\x1fbb'# -> unI64 8049+  -- GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI+  '\x1fbc'# -> unI64 1998586801+  -- GREEK PROSGEGRAMMENI+  '\x1fbe'# -> unI64 953+  -- GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI+  '\x1fc2'# -> unI64 1998593908+  -- GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI+  '\x1fc3'# -> unI64 1998586807+  -- GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI+  '\x1fc4'# -> unI64 1998586798+  -- GREEK SMALL LETTER ETA WITH PERISPOMENI+  '\x1fc6'# -> unI64 1749025719+  -- GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI+  '\x1fc7'# -> unI64 4191340074107831+  -- GREEK CAPITAL LETTER EPSILON WITH VARIA+  '\x1fc8'# -> unI64 8050+  -- GREEK CAPITAL LETTER EPSILON WITH OXIA+  '\x1fc9'# -> unI64 8051+  -- GREEK CAPITAL LETTER ETA WITH VARIA+  '\x1fca'# -> unI64 8052+  -- GREEK CAPITAL LETTER ETA WITH OXIA+  '\x1fcb'# -> unI64 8053+  -- GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI+  '\x1fcc'# -> unI64 1998586807+  -- GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA+  '\x1fd2'# -> unI64 3377701347918777+  -- GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA+  '\x1fd3'# -> unI64 3382099394429881+  -- GREEK SMALL LETTER IOTA WITH PERISPOMENI+  '\x1fd6'# -> unI64 1749025721+  -- GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI+  '\x1fd7'# -> unI64 3667972417651641+  -- GREEK CAPITAL LETTER IOTA WITH VRACHY+  '\x1fd8'# -> unI64 8144+  -- GREEK CAPITAL LETTER IOTA WITH MACRON+  '\x1fd9'# -> unI64 8145+  -- GREEK CAPITAL LETTER IOTA WITH VARIA+  '\x1fda'# -> unI64 8054+  -- GREEK CAPITAL LETTER IOTA WITH OXIA+  '\x1fdb'# -> unI64 8055+  -- GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA+  '\x1fe2'# -> unI64 3377701347918789+  -- GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA+  '\x1fe3'# -> unI64 3382099394429893+  -- GREEK SMALL LETTER RHO WITH PSILI+  '\x1fe4'# -> unI64 1650459585+  -- GREEK SMALL LETTER UPSILON WITH PERISPOMENI+  '\x1fe6'# -> unI64 1749025733+  -- GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI+  '\x1fe7'# -> unI64 3667972417651653+  -- GREEK CAPITAL LETTER UPSILON WITH VRACHY+  '\x1fe8'# -> unI64 8160+  -- GREEK CAPITAL LETTER UPSILON WITH MACRON+  '\x1fe9'# -> unI64 8161+  -- GREEK CAPITAL LETTER UPSILON WITH VARIA+  '\x1fea'# -> unI64 8058+  -- GREEK CAPITAL LETTER UPSILON WITH OXIA+  '\x1feb'# -> unI64 8059+  -- GREEK CAPITAL LETTER RHO WITH DASIA+  '\x1fec'# -> unI64 8165+  -- GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI+  '\x1ff2'# -> unI64 1998593916+  -- GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI+  '\x1ff3'# -> unI64 1998586825+  -- GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI+  '\x1ff4'# -> unI64 1998586830+  -- GREEK SMALL LETTER OMEGA WITH PERISPOMENI+  '\x1ff6'# -> unI64 1749025737+  -- GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI+  '\x1ff7'# -> unI64 4191340074107849+  -- GREEK CAPITAL LETTER OMICRON WITH VARIA+  '\x1ff8'# -> unI64 8056+  -- GREEK CAPITAL LETTER OMICRON WITH OXIA+  '\x1ff9'# -> unI64 8057+  -- GREEK CAPITAL LETTER OMEGA WITH VARIA+  '\x1ffa'# -> unI64 8060+  -- GREEK CAPITAL LETTER OMEGA WITH OXIA+  '\x1ffb'# -> unI64 8061+  -- GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI+  '\x1ffc'# -> unI64 1998586825+  -- OHM SIGN+  '\x2126'# -> unI64 969+  -- KELVIN SIGN+  '\x212a'# -> unI64 107+  -- ANGSTROM SIGN+  '\x212b'# -> unI64 229+  -- TURNED CAPITAL F+  '\x2132'# -> unI64 8526+  -- ROMAN NUMERAL ONE+  '\x2160'# -> unI64 8560+  -- ROMAN NUMERAL TWO+  '\x2161'# -> unI64 8561+  -- ROMAN NUMERAL THREE+  '\x2162'# -> unI64 8562+  -- ROMAN NUMERAL FOUR+  '\x2163'# -> unI64 8563+  -- ROMAN NUMERAL FIVE+  '\x2164'# -> unI64 8564+  -- ROMAN NUMERAL SIX+  '\x2165'# -> unI64 8565+  -- ROMAN NUMERAL SEVEN+  '\x2166'# -> unI64 8566+  -- ROMAN NUMERAL EIGHT+  '\x2167'# -> unI64 8567+  -- ROMAN NUMERAL NINE+  '\x2168'# -> unI64 8568+  -- ROMAN NUMERAL TEN+  '\x2169'# -> unI64 8569+  -- ROMAN NUMERAL ELEVEN+  '\x216a'# -> unI64 8570+  -- ROMAN NUMERAL TWELVE+  '\x216b'# -> unI64 8571+  -- ROMAN NUMERAL FIFTY+  '\x216c'# -> unI64 8572+  -- ROMAN NUMERAL ONE HUNDRED+  '\x216d'# -> unI64 8573+  -- ROMAN NUMERAL FIVE HUNDRED+  '\x216e'# -> unI64 8574+  -- ROMAN NUMERAL ONE THOUSAND+  '\x216f'# -> unI64 8575+  -- ROMAN NUMERAL REVERSED ONE HUNDRED+  '\x2183'# -> unI64 8580+  -- CIRCLED LATIN CAPITAL LETTER A+  '\x24b6'# -> unI64 9424+  -- CIRCLED LATIN CAPITAL LETTER B+  '\x24b7'# -> unI64 9425+  -- CIRCLED LATIN CAPITAL LETTER C+  '\x24b8'# -> unI64 9426+  -- CIRCLED LATIN CAPITAL LETTER D+  '\x24b9'# -> unI64 9427+  -- CIRCLED LATIN CAPITAL LETTER E+  '\x24ba'# -> unI64 9428+  -- CIRCLED LATIN CAPITAL LETTER F+  '\x24bb'# -> unI64 9429+  -- CIRCLED LATIN CAPITAL LETTER G+  '\x24bc'# -> unI64 9430+  -- CIRCLED LATIN CAPITAL LETTER H+  '\x24bd'# -> unI64 9431+  -- CIRCLED LATIN CAPITAL LETTER I+  '\x24be'# -> unI64 9432+  -- CIRCLED LATIN CAPITAL LETTER J+  '\x24bf'# -> unI64 9433+  -- CIRCLED LATIN CAPITAL LETTER K+  '\x24c0'# -> unI64 9434+  -- CIRCLED LATIN CAPITAL LETTER L+  '\x24c1'# -> unI64 9435+  -- CIRCLED LATIN CAPITAL LETTER M+  '\x24c2'# -> unI64 9436+  -- CIRCLED LATIN CAPITAL LETTER N+  '\x24c3'# -> unI64 9437+  -- CIRCLED LATIN CAPITAL LETTER O+  '\x24c4'# -> unI64 9438+  -- CIRCLED LATIN CAPITAL LETTER P+  '\x24c5'# -> unI64 9439+  -- CIRCLED LATIN CAPITAL LETTER Q+  '\x24c6'# -> unI64 9440+  -- CIRCLED LATIN CAPITAL LETTER R+  '\x24c7'# -> unI64 9441+  -- CIRCLED LATIN CAPITAL LETTER S+  '\x24c8'# -> unI64 9442+  -- CIRCLED LATIN CAPITAL LETTER T+  '\x24c9'# -> unI64 9443+  -- CIRCLED LATIN CAPITAL LETTER U+  '\x24ca'# -> unI64 9444+  -- CIRCLED LATIN CAPITAL LETTER V+  '\x24cb'# -> unI64 9445+  -- CIRCLED LATIN CAPITAL LETTER W+  '\x24cc'# -> unI64 9446+  -- CIRCLED LATIN CAPITAL LETTER X+  '\x24cd'# -> unI64 9447+  -- CIRCLED LATIN CAPITAL LETTER Y+  '\x24ce'# -> unI64 9448+  -- CIRCLED LATIN CAPITAL LETTER Z+  '\x24cf'# -> unI64 9449+  -- GLAGOLITIC CAPITAL LETTER AZU+  '\x2c00'# -> unI64 11312+  -- GLAGOLITIC CAPITAL LETTER BUKY+  '\x2c01'# -> unI64 11313+  -- GLAGOLITIC CAPITAL LETTER VEDE+  '\x2c02'# -> unI64 11314+  -- GLAGOLITIC CAPITAL LETTER GLAGOLI+  '\x2c03'# -> unI64 11315+  -- GLAGOLITIC CAPITAL LETTER DOBRO+  '\x2c04'# -> unI64 11316+  -- GLAGOLITIC CAPITAL LETTER YESTU+  '\x2c05'# -> unI64 11317+  -- GLAGOLITIC CAPITAL LETTER ZHIVETE+  '\x2c06'# -> unI64 11318+  -- GLAGOLITIC CAPITAL LETTER DZELO+  '\x2c07'# -> unI64 11319+  -- GLAGOLITIC CAPITAL LETTER ZEMLJA+  '\x2c08'# -> unI64 11320+  -- GLAGOLITIC CAPITAL LETTER IZHE+  '\x2c09'# -> unI64 11321+  -- GLAGOLITIC CAPITAL LETTER INITIAL IZHE+  '\x2c0a'# -> unI64 11322+  -- GLAGOLITIC CAPITAL LETTER I+  '\x2c0b'# -> unI64 11323+  -- GLAGOLITIC CAPITAL LETTER DJERVI+  '\x2c0c'# -> unI64 11324+  -- GLAGOLITIC CAPITAL LETTER KAKO+  '\x2c0d'# -> unI64 11325+  -- GLAGOLITIC CAPITAL LETTER LJUDIJE+  '\x2c0e'# -> unI64 11326+  -- GLAGOLITIC CAPITAL LETTER MYSLITE+  '\x2c0f'# -> unI64 11327+  -- GLAGOLITIC CAPITAL LETTER NASHI+  '\x2c10'# -> unI64 11328+  -- GLAGOLITIC CAPITAL LETTER ONU+  '\x2c11'# -> unI64 11329+  -- GLAGOLITIC CAPITAL LETTER POKOJI+  '\x2c12'# -> unI64 11330+  -- GLAGOLITIC CAPITAL LETTER RITSI+  '\x2c13'# -> unI64 11331+  -- GLAGOLITIC CAPITAL LETTER SLOVO+  '\x2c14'# -> unI64 11332+  -- GLAGOLITIC CAPITAL LETTER TVRIDO+  '\x2c15'# -> unI64 11333+  -- GLAGOLITIC CAPITAL LETTER UKU+  '\x2c16'# -> unI64 11334+  -- GLAGOLITIC CAPITAL LETTER FRITU+  '\x2c17'# -> unI64 11335+  -- GLAGOLITIC CAPITAL LETTER HERU+  '\x2c18'# -> unI64 11336+  -- GLAGOLITIC CAPITAL LETTER OTU+  '\x2c19'# -> unI64 11337+  -- GLAGOLITIC CAPITAL LETTER PE+  '\x2c1a'# -> unI64 11338+  -- GLAGOLITIC CAPITAL LETTER SHTA+  '\x2c1b'# -> unI64 11339+  -- GLAGOLITIC CAPITAL LETTER TSI+  '\x2c1c'# -> unI64 11340+  -- GLAGOLITIC CAPITAL LETTER CHRIVI+  '\x2c1d'# -> unI64 11341+  -- GLAGOLITIC CAPITAL LETTER SHA+  '\x2c1e'# -> unI64 11342+  -- GLAGOLITIC CAPITAL LETTER YERU+  '\x2c1f'# -> unI64 11343+  -- GLAGOLITIC CAPITAL LETTER YERI+  '\x2c20'# -> unI64 11344+  -- GLAGOLITIC CAPITAL LETTER YATI+  '\x2c21'# -> unI64 11345+  -- GLAGOLITIC CAPITAL LETTER SPIDERY HA+  '\x2c22'# -> unI64 11346+  -- GLAGOLITIC CAPITAL LETTER YU+  '\x2c23'# -> unI64 11347+  -- GLAGOLITIC CAPITAL LETTER SMALL YUS+  '\x2c24'# -> unI64 11348+  -- GLAGOLITIC CAPITAL LETTER SMALL YUS WITH TAIL+  '\x2c25'# -> unI64 11349+  -- GLAGOLITIC CAPITAL LETTER YO+  '\x2c26'# -> unI64 11350+  -- GLAGOLITIC CAPITAL LETTER IOTATED SMALL YUS+  '\x2c27'# -> unI64 11351+  -- GLAGOLITIC CAPITAL LETTER BIG YUS+  '\x2c28'# -> unI64 11352+  -- GLAGOLITIC CAPITAL LETTER IOTATED BIG YUS+  '\x2c29'# -> unI64 11353+  -- GLAGOLITIC CAPITAL LETTER FITA+  '\x2c2a'# -> unI64 11354+  -- GLAGOLITIC CAPITAL LETTER IZHITSA+  '\x2c2b'# -> unI64 11355+  -- GLAGOLITIC CAPITAL LETTER SHTAPIC+  '\x2c2c'# -> unI64 11356+  -- GLAGOLITIC CAPITAL LETTER TROKUTASTI A+  '\x2c2d'# -> unI64 11357+  -- GLAGOLITIC CAPITAL LETTER LATINATE MYSLITE+  '\x2c2e'# -> unI64 11358+  -- GLAGOLITIC CAPITAL LETTER CAUDATE CHRIVI+  '\x2c2f'# -> unI64 11359+  -- LATIN CAPITAL LETTER L WITH DOUBLE BAR+  '\x2c60'# -> unI64 11361+  -- LATIN CAPITAL LETTER L WITH MIDDLE TILDE+  '\x2c62'# -> unI64 619+  -- LATIN CAPITAL LETTER P WITH STROKE+  '\x2c63'# -> unI64 7549+  -- LATIN CAPITAL LETTER R WITH TAIL+  '\x2c64'# -> unI64 637+  -- LATIN CAPITAL LETTER H WITH DESCENDER+  '\x2c67'# -> unI64 11368+  -- LATIN CAPITAL LETTER K WITH DESCENDER+  '\x2c69'# -> unI64 11370+  -- LATIN CAPITAL LETTER Z WITH DESCENDER+  '\x2c6b'# -> unI64 11372+  -- LATIN CAPITAL LETTER ALPHA+  '\x2c6d'# -> unI64 593+  -- LATIN CAPITAL LETTER M WITH HOOK+  '\x2c6e'# -> unI64 625+  -- LATIN CAPITAL LETTER TURNED A+  '\x2c6f'# -> unI64 592+  -- LATIN CAPITAL LETTER TURNED ALPHA+  '\x2c70'# -> unI64 594+  -- LATIN CAPITAL LETTER W WITH HOOK+  '\x2c72'# -> unI64 11379+  -- LATIN CAPITAL LETTER HALF H+  '\x2c75'# -> unI64 11382+  -- LATIN CAPITAL LETTER S WITH SWASH TAIL+  '\x2c7e'# -> unI64 575+  -- LATIN CAPITAL LETTER Z WITH SWASH TAIL+  '\x2c7f'# -> unI64 576+  -- COPTIC CAPITAL LETTER ALFA+  '\x2c80'# -> unI64 11393+  -- COPTIC CAPITAL LETTER VIDA+  '\x2c82'# -> unI64 11395+  -- COPTIC CAPITAL LETTER GAMMA+  '\x2c84'# -> unI64 11397+  -- COPTIC CAPITAL LETTER DALDA+  '\x2c86'# -> unI64 11399+  -- COPTIC CAPITAL LETTER EIE+  '\x2c88'# -> unI64 11401+  -- COPTIC CAPITAL LETTER SOU+  '\x2c8a'# -> unI64 11403+  -- COPTIC CAPITAL LETTER ZATA+  '\x2c8c'# -> unI64 11405+  -- COPTIC CAPITAL LETTER HATE+  '\x2c8e'# -> unI64 11407+  -- COPTIC CAPITAL LETTER THETHE+  '\x2c90'# -> unI64 11409+  -- COPTIC CAPITAL LETTER IAUDA+  '\x2c92'# -> unI64 11411+  -- COPTIC CAPITAL LETTER KAPA+  '\x2c94'# -> unI64 11413+  -- COPTIC CAPITAL LETTER LAULA+  '\x2c96'# -> unI64 11415+  -- COPTIC CAPITAL LETTER MI+  '\x2c98'# -> unI64 11417+  -- COPTIC CAPITAL LETTER NI+  '\x2c9a'# -> unI64 11419+  -- COPTIC CAPITAL LETTER KSI+  '\x2c9c'# -> unI64 11421+  -- COPTIC CAPITAL LETTER O+  '\x2c9e'# -> unI64 11423+  -- COPTIC CAPITAL LETTER PI+  '\x2ca0'# -> unI64 11425+  -- COPTIC CAPITAL LETTER RO+  '\x2ca2'# -> unI64 11427+  -- COPTIC CAPITAL LETTER SIMA+  '\x2ca4'# -> unI64 11429+  -- COPTIC CAPITAL LETTER TAU+  '\x2ca6'# -> unI64 11431+  -- COPTIC CAPITAL LETTER UA+  '\x2ca8'# -> unI64 11433+  -- COPTIC CAPITAL LETTER FI+  '\x2caa'# -> unI64 11435+  -- COPTIC CAPITAL LETTER KHI+  '\x2cac'# -> unI64 11437+  -- COPTIC CAPITAL LETTER PSI+  '\x2cae'# -> unI64 11439+  -- COPTIC CAPITAL LETTER OOU+  '\x2cb0'# -> unI64 11441+  -- COPTIC CAPITAL LETTER DIALECT-P ALEF+  '\x2cb2'# -> unI64 11443+  -- COPTIC CAPITAL LETTER OLD COPTIC AIN+  '\x2cb4'# -> unI64 11445+  -- COPTIC CAPITAL LETTER CRYPTOGRAMMIC EIE+  '\x2cb6'# -> unI64 11447+  -- COPTIC CAPITAL LETTER DIALECT-P KAPA+  '\x2cb8'# -> unI64 11449+  -- COPTIC CAPITAL LETTER DIALECT-P NI+  '\x2cba'# -> unI64 11451+  -- COPTIC CAPITAL LETTER CRYPTOGRAMMIC NI+  '\x2cbc'# -> unI64 11453+  -- COPTIC CAPITAL LETTER OLD COPTIC OOU+  '\x2cbe'# -> unI64 11455+  -- COPTIC CAPITAL LETTER SAMPI+  '\x2cc0'# -> unI64 11457+  -- COPTIC CAPITAL LETTER CROSSED SHEI+  '\x2cc2'# -> unI64 11459+  -- COPTIC CAPITAL LETTER OLD COPTIC SHEI+  '\x2cc4'# -> unI64 11461+  -- COPTIC CAPITAL LETTER OLD COPTIC ESH+  '\x2cc6'# -> unI64 11463+  -- COPTIC CAPITAL LETTER AKHMIMIC KHEI+  '\x2cc8'# -> unI64 11465+  -- COPTIC CAPITAL LETTER DIALECT-P HORI+  '\x2cca'# -> unI64 11467+  -- COPTIC CAPITAL LETTER OLD COPTIC HORI+  '\x2ccc'# -> unI64 11469+  -- COPTIC CAPITAL LETTER OLD COPTIC HA+  '\x2cce'# -> unI64 11471+  -- COPTIC CAPITAL LETTER L-SHAPED HA+  '\x2cd0'# -> unI64 11473+  -- COPTIC CAPITAL LETTER OLD COPTIC HEI+  '\x2cd2'# -> unI64 11475+  -- COPTIC CAPITAL LETTER OLD COPTIC HAT+  '\x2cd4'# -> unI64 11477+  -- COPTIC CAPITAL LETTER OLD COPTIC GANGIA+  '\x2cd6'# -> unI64 11479+  -- COPTIC CAPITAL LETTER OLD COPTIC DJA+  '\x2cd8'# -> unI64 11481+  -- COPTIC CAPITAL LETTER OLD COPTIC SHIMA+  '\x2cda'# -> unI64 11483+  -- COPTIC CAPITAL LETTER OLD NUBIAN SHIMA+  '\x2cdc'# -> unI64 11485+  -- COPTIC CAPITAL LETTER OLD NUBIAN NGI+  '\x2cde'# -> unI64 11487+  -- COPTIC CAPITAL LETTER OLD NUBIAN NYI+  '\x2ce0'# -> unI64 11489+  -- COPTIC CAPITAL LETTER OLD NUBIAN WAU+  '\x2ce2'# -> unI64 11491+  -- COPTIC CAPITAL LETTER CRYPTOGRAMMIC SHEI+  '\x2ceb'# -> unI64 11500+  -- COPTIC CAPITAL LETTER CRYPTOGRAMMIC GANGIA+  '\x2ced'# -> unI64 11502+  -- COPTIC CAPITAL LETTER BOHAIRIC KHEI+  '\x2cf2'# -> unI64 11507+  -- CYRILLIC CAPITAL LETTER ZEMLYA+  '\xa640'# -> unI64 42561+  -- CYRILLIC CAPITAL LETTER DZELO+  '\xa642'# -> unI64 42563+  -- CYRILLIC CAPITAL LETTER REVERSED DZE+  '\xa644'# -> unI64 42565+  -- CYRILLIC CAPITAL LETTER IOTA+  '\xa646'# -> unI64 42567+  -- CYRILLIC CAPITAL LETTER DJERV+  '\xa648'# -> unI64 42569+  -- CYRILLIC CAPITAL LETTER MONOGRAPH UK+  '\xa64a'# -> unI64 42571+  -- CYRILLIC CAPITAL LETTER BROAD OMEGA+  '\xa64c'# -> unI64 42573+  -- CYRILLIC CAPITAL LETTER NEUTRAL YER+  '\xa64e'# -> unI64 42575+  -- CYRILLIC CAPITAL LETTER YERU WITH BACK YER+  '\xa650'# -> unI64 42577+  -- CYRILLIC CAPITAL LETTER IOTIFIED YAT+  '\xa652'# -> unI64 42579+  -- CYRILLIC CAPITAL LETTER REVERSED YU+  '\xa654'# -> unI64 42581+  -- CYRILLIC CAPITAL LETTER IOTIFIED A+  '\xa656'# -> unI64 42583+  -- CYRILLIC CAPITAL LETTER CLOSED LITTLE YUS+  '\xa658'# -> unI64 42585+  -- CYRILLIC CAPITAL LETTER BLENDED YUS+  '\xa65a'# -> unI64 42587+  -- CYRILLIC CAPITAL LETTER IOTIFIED CLOSED LITTLE YUS+  '\xa65c'# -> unI64 42589+  -- CYRILLIC CAPITAL LETTER YN+  '\xa65e'# -> unI64 42591+  -- CYRILLIC CAPITAL LETTER REVERSED TSE+  '\xa660'# -> unI64 42593+  -- CYRILLIC CAPITAL LETTER SOFT DE+  '\xa662'# -> unI64 42595+  -- CYRILLIC CAPITAL LETTER SOFT EL+  '\xa664'# -> unI64 42597+  -- CYRILLIC CAPITAL LETTER SOFT EM+  '\xa666'# -> unI64 42599+  -- CYRILLIC CAPITAL LETTER MONOCULAR O+  '\xa668'# -> unI64 42601+  -- CYRILLIC CAPITAL LETTER BINOCULAR O+  '\xa66a'# -> unI64 42603+  -- CYRILLIC CAPITAL LETTER DOUBLE MONOCULAR O+  '\xa66c'# -> unI64 42605+  -- CYRILLIC CAPITAL LETTER DWE+  '\xa680'# -> unI64 42625+  -- CYRILLIC CAPITAL LETTER DZWE+  '\xa682'# -> unI64 42627+  -- CYRILLIC CAPITAL LETTER ZHWE+  '\xa684'# -> unI64 42629+  -- CYRILLIC CAPITAL LETTER CCHE+  '\xa686'# -> unI64 42631+  -- CYRILLIC CAPITAL LETTER DZZE+  '\xa688'# -> unI64 42633+  -- CYRILLIC CAPITAL LETTER TE WITH MIDDLE HOOK+  '\xa68a'# -> unI64 42635+  -- CYRILLIC CAPITAL LETTER TWE+  '\xa68c'# -> unI64 42637+  -- CYRILLIC CAPITAL LETTER TSWE+  '\xa68e'# -> unI64 42639+  -- CYRILLIC CAPITAL LETTER TSSE+  '\xa690'# -> unI64 42641+  -- CYRILLIC CAPITAL LETTER TCHE+  '\xa692'# -> unI64 42643+  -- CYRILLIC CAPITAL LETTER HWE+  '\xa694'# -> unI64 42645+  -- CYRILLIC CAPITAL LETTER SHWE+  '\xa696'# -> unI64 42647+  -- CYRILLIC CAPITAL LETTER DOUBLE O+  '\xa698'# -> unI64 42649+  -- CYRILLIC CAPITAL LETTER CROSSED O+  '\xa69a'# -> unI64 42651+  -- LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF+  '\xa722'# -> unI64 42787+  -- LATIN CAPITAL LETTER EGYPTOLOGICAL AIN+  '\xa724'# -> unI64 42789+  -- LATIN CAPITAL LETTER HENG+  '\xa726'# -> unI64 42791+  -- LATIN CAPITAL LETTER TZ+  '\xa728'# -> unI64 42793+  -- LATIN CAPITAL LETTER TRESILLO+  '\xa72a'# -> unI64 42795+  -- LATIN CAPITAL LETTER CUATRILLO+  '\xa72c'# -> unI64 42797+  -- LATIN CAPITAL LETTER CUATRILLO WITH COMMA+  '\xa72e'# -> unI64 42799+  -- LATIN CAPITAL LETTER AA+  '\xa732'# -> unI64 42803+  -- LATIN CAPITAL LETTER AO+  '\xa734'# -> unI64 42805+  -- LATIN CAPITAL LETTER AU+  '\xa736'# -> unI64 42807+  -- LATIN CAPITAL LETTER AV+  '\xa738'# -> unI64 42809+  -- LATIN CAPITAL LETTER AV WITH HORIZONTAL BAR+  '\xa73a'# -> unI64 42811+  -- LATIN CAPITAL LETTER AY+  '\xa73c'# -> unI64 42813+  -- LATIN CAPITAL LETTER REVERSED C WITH DOT+  '\xa73e'# -> unI64 42815+  -- LATIN CAPITAL LETTER K WITH STROKE+  '\xa740'# -> unI64 42817+  -- LATIN CAPITAL LETTER K WITH DIAGONAL STROKE+  '\xa742'# -> unI64 42819+  -- LATIN CAPITAL LETTER K WITH STROKE AND DIAGONAL STROKE+  '\xa744'# -> unI64 42821+  -- LATIN CAPITAL LETTER BROKEN L+  '\xa746'# -> unI64 42823+  -- LATIN CAPITAL LETTER L WITH HIGH STROKE+  '\xa748'# -> unI64 42825+  -- LATIN CAPITAL LETTER O WITH LONG STROKE OVERLAY+  '\xa74a'# -> unI64 42827+  -- LATIN CAPITAL LETTER O WITH LOOP+  '\xa74c'# -> unI64 42829+  -- LATIN CAPITAL LETTER OO+  '\xa74e'# -> unI64 42831+  -- LATIN CAPITAL LETTER P WITH STROKE THROUGH DESCENDER+  '\xa750'# -> unI64 42833+  -- LATIN CAPITAL LETTER P WITH FLOURISH+  '\xa752'# -> unI64 42835+  -- LATIN CAPITAL LETTER P WITH SQUIRREL TAIL+  '\xa754'# -> unI64 42837+  -- LATIN CAPITAL LETTER Q WITH STROKE THROUGH DESCENDER+  '\xa756'# -> unI64 42839+  -- LATIN CAPITAL LETTER Q WITH DIAGONAL STROKE+  '\xa758'# -> unI64 42841+  -- LATIN CAPITAL LETTER R ROTUNDA+  '\xa75a'# -> unI64 42843+  -- LATIN CAPITAL LETTER RUM ROTUNDA+  '\xa75c'# -> unI64 42845+  -- LATIN CAPITAL LETTER V WITH DIAGONAL STROKE+  '\xa75e'# -> unI64 42847+  -- LATIN CAPITAL LETTER VY+  '\xa760'# -> unI64 42849+  -- LATIN CAPITAL LETTER VISIGOTHIC Z+  '\xa762'# -> unI64 42851+  -- LATIN CAPITAL LETTER THORN WITH STROKE+  '\xa764'# -> unI64 42853+  -- LATIN CAPITAL LETTER THORN WITH STROKE THROUGH DESCENDER+  '\xa766'# -> unI64 42855+  -- LATIN CAPITAL LETTER VEND+  '\xa768'# -> unI64 42857+  -- LATIN CAPITAL LETTER ET+  '\xa76a'# -> unI64 42859+  -- LATIN CAPITAL LETTER IS+  '\xa76c'# -> unI64 42861+  -- LATIN CAPITAL LETTER CON+  '\xa76e'# -> unI64 42863+  -- LATIN CAPITAL LETTER INSULAR D+  '\xa779'# -> unI64 42874+  -- LATIN CAPITAL LETTER INSULAR F+  '\xa77b'# -> unI64 42876+  -- LATIN CAPITAL LETTER INSULAR G+  '\xa77d'# -> unI64 7545+  -- LATIN CAPITAL LETTER TURNED INSULAR G+  '\xa77e'# -> unI64 42879+  -- LATIN CAPITAL LETTER TURNED L+  '\xa780'# -> unI64 42881+  -- LATIN CAPITAL LETTER INSULAR R+  '\xa782'# -> unI64 42883+  -- LATIN CAPITAL LETTER INSULAR S+  '\xa784'# -> unI64 42885+  -- LATIN CAPITAL LETTER INSULAR T+  '\xa786'# -> unI64 42887+  -- LATIN CAPITAL LETTER SALTILLO+  '\xa78b'# -> unI64 42892+  -- LATIN CAPITAL LETTER TURNED H+  '\xa78d'# -> unI64 613+  -- LATIN CAPITAL LETTER N WITH DESCENDER+  '\xa790'# -> unI64 42897+  -- LATIN CAPITAL LETTER C WITH BAR+  '\xa792'# -> unI64 42899+  -- LATIN CAPITAL LETTER B WITH FLOURISH+  '\xa796'# -> unI64 42903+  -- LATIN CAPITAL LETTER F WITH STROKE+  '\xa798'# -> unI64 42905+  -- LATIN CAPITAL LETTER VOLAPUK AE+  '\xa79a'# -> unI64 42907+  -- LATIN CAPITAL LETTER VOLAPUK OE+  '\xa79c'# -> unI64 42909+  -- LATIN CAPITAL LETTER VOLAPUK UE+  '\xa79e'# -> unI64 42911+  -- LATIN CAPITAL LETTER G WITH OBLIQUE STROKE+  '\xa7a0'# -> unI64 42913+  -- LATIN CAPITAL LETTER K WITH OBLIQUE STROKE+  '\xa7a2'# -> unI64 42915+  -- LATIN CAPITAL LETTER N WITH OBLIQUE STROKE+  '\xa7a4'# -> unI64 42917+  -- LATIN CAPITAL LETTER R WITH OBLIQUE STROKE+  '\xa7a6'# -> unI64 42919+  -- LATIN CAPITAL LETTER S WITH OBLIQUE STROKE+  '\xa7a8'# -> unI64 42921+  -- LATIN CAPITAL LETTER H WITH HOOK+  '\xa7aa'# -> unI64 614+  -- LATIN CAPITAL LETTER REVERSED OPEN E+  '\xa7ab'# -> unI64 604+  -- LATIN CAPITAL LETTER SCRIPT G+  '\xa7ac'# -> unI64 609+  -- LATIN CAPITAL LETTER L WITH BELT+  '\xa7ad'# -> unI64 620+  -- LATIN CAPITAL LETTER SMALL CAPITAL I+  '\xa7ae'# -> unI64 618+  -- LATIN CAPITAL LETTER TURNED K+  '\xa7b0'# -> unI64 670+  -- LATIN CAPITAL LETTER TURNED T+  '\xa7b1'# -> unI64 647+  -- LATIN CAPITAL LETTER J WITH CROSSED-TAIL+  '\xa7b2'# -> unI64 669+  -- LATIN CAPITAL LETTER CHI+  '\xa7b3'# -> unI64 43859+  -- LATIN CAPITAL LETTER BETA+  '\xa7b4'# -> unI64 42933+  -- LATIN CAPITAL LETTER OMEGA+  '\xa7b6'# -> unI64 42935+  -- LATIN CAPITAL LETTER U WITH STROKE+  '\xa7b8'# -> unI64 42937+  -- LATIN CAPITAL LETTER GLOTTAL A+  '\xa7ba'# -> unI64 42939+  -- LATIN CAPITAL LETTER GLOTTAL I+  '\xa7bc'# -> unI64 42941+  -- LATIN CAPITAL LETTER GLOTTAL U+  '\xa7be'# -> unI64 42943+  -- LATIN CAPITAL LETTER OLD POLISH O+  '\xa7c0'# -> unI64 42945+  -- LATIN CAPITAL LETTER ANGLICANA W+  '\xa7c2'# -> unI64 42947+  -- LATIN CAPITAL LETTER C WITH PALATAL HOOK+  '\xa7c4'# -> unI64 42900+  -- LATIN CAPITAL LETTER S WITH HOOK+  '\xa7c5'# -> unI64 642+  -- LATIN CAPITAL LETTER Z WITH PALATAL HOOK+  '\xa7c6'# -> unI64 7566+  -- LATIN CAPITAL LETTER D WITH SHORT STROKE OVERLAY+  '\xa7c7'# -> unI64 42952+  -- LATIN CAPITAL LETTER S WITH SHORT STROKE OVERLAY+  '\xa7c9'# -> unI64 42954+  -- LATIN CAPITAL LETTER CLOSED INSULAR G+  '\xa7d0'# -> unI64 42961+  -- LATIN CAPITAL LETTER MIDDLE SCOTS S+  '\xa7d6'# -> unI64 42967+  -- LATIN CAPITAL LETTER SIGMOID S+  '\xa7d8'# -> unI64 42969+  -- LATIN CAPITAL LETTER REVERSED HALF H+  '\xa7f5'# -> unI64 42998+  -- CHEROKEE SMALL LETTER A+  '\xab70'# -> unI64 5024+  -- CHEROKEE SMALL LETTER E+  '\xab71'# -> unI64 5025+  -- CHEROKEE SMALL LETTER I+  '\xab72'# -> unI64 5026+  -- CHEROKEE SMALL LETTER O+  '\xab73'# -> unI64 5027+  -- CHEROKEE SMALL LETTER U+  '\xab74'# -> unI64 5028+  -- CHEROKEE SMALL LETTER V+  '\xab75'# -> unI64 5029+  -- CHEROKEE SMALL LETTER GA+  '\xab76'# -> unI64 5030+  -- CHEROKEE SMALL LETTER KA+  '\xab77'# -> unI64 5031+  -- CHEROKEE SMALL LETTER GE+  '\xab78'# -> unI64 5032+  -- CHEROKEE SMALL LETTER GI+  '\xab79'# -> unI64 5033+  -- CHEROKEE SMALL LETTER GO+  '\xab7a'# -> unI64 5034+  -- CHEROKEE SMALL LETTER GU+  '\xab7b'# -> unI64 5035+  -- CHEROKEE SMALL LETTER GV+  '\xab7c'# -> unI64 5036+  -- CHEROKEE SMALL LETTER HA+  '\xab7d'# -> unI64 5037+  -- CHEROKEE SMALL LETTER HE+  '\xab7e'# -> unI64 5038+  -- CHEROKEE SMALL LETTER HI+  '\xab7f'# -> unI64 5039+  -- CHEROKEE SMALL LETTER HO+  '\xab80'# -> unI64 5040+  -- CHEROKEE SMALL LETTER HU+  '\xab81'# -> unI64 5041+  -- CHEROKEE SMALL LETTER HV+  '\xab82'# -> unI64 5042+  -- CHEROKEE SMALL LETTER LA+  '\xab83'# -> unI64 5043+  -- CHEROKEE SMALL LETTER LE+  '\xab84'# -> unI64 5044+  -- CHEROKEE SMALL LETTER LI+  '\xab85'# -> unI64 5045+  -- CHEROKEE SMALL LETTER LO+  '\xab86'# -> unI64 5046+  -- CHEROKEE SMALL LETTER LU+  '\xab87'# -> unI64 5047+  -- CHEROKEE SMALL LETTER LV+  '\xab88'# -> unI64 5048+  -- CHEROKEE SMALL LETTER MA+  '\xab89'# -> unI64 5049+  -- CHEROKEE SMALL LETTER ME+  '\xab8a'# -> unI64 5050+  -- CHEROKEE SMALL LETTER MI+  '\xab8b'# -> unI64 5051+  -- CHEROKEE SMALL LETTER MO+  '\xab8c'# -> unI64 5052+  -- CHEROKEE SMALL LETTER MU+  '\xab8d'# -> unI64 5053+  -- CHEROKEE SMALL LETTER NA+  '\xab8e'# -> unI64 5054+  -- CHEROKEE SMALL LETTER HNA+  '\xab8f'# -> unI64 5055+  -- CHEROKEE SMALL LETTER NAH+  '\xab90'# -> unI64 5056+  -- CHEROKEE SMALL LETTER NE+  '\xab91'# -> unI64 5057+  -- CHEROKEE SMALL LETTER NI+  '\xab92'# -> unI64 5058+  -- CHEROKEE SMALL LETTER NO+  '\xab93'# -> unI64 5059+  -- CHEROKEE SMALL LETTER NU+  '\xab94'# -> unI64 5060+  -- CHEROKEE SMALL LETTER NV+  '\xab95'# -> unI64 5061+  -- CHEROKEE SMALL LETTER QUA+  '\xab96'# -> unI64 5062+  -- CHEROKEE SMALL LETTER QUE+  '\xab97'# -> unI64 5063+  -- CHEROKEE SMALL LETTER QUI+  '\xab98'# -> unI64 5064+  -- CHEROKEE SMALL LETTER QUO+  '\xab99'# -> unI64 5065+  -- CHEROKEE SMALL LETTER QUU+  '\xab9a'# -> unI64 5066+  -- CHEROKEE SMALL LETTER QUV+  '\xab9b'# -> unI64 5067+  -- CHEROKEE SMALL LETTER SA+  '\xab9c'# -> unI64 5068+  -- CHEROKEE SMALL LETTER S+  '\xab9d'# -> unI64 5069+  -- CHEROKEE SMALL LETTER SE+  '\xab9e'# -> unI64 5070+  -- CHEROKEE SMALL LETTER SI+  '\xab9f'# -> unI64 5071+  -- CHEROKEE SMALL LETTER SO+  '\xaba0'# -> unI64 5072+  -- CHEROKEE SMALL LETTER SU+  '\xaba1'# -> unI64 5073+  -- CHEROKEE SMALL LETTER SV+  '\xaba2'# -> unI64 5074+  -- CHEROKEE SMALL LETTER DA+  '\xaba3'# -> unI64 5075+  -- CHEROKEE SMALL LETTER TA+  '\xaba4'# -> unI64 5076+  -- CHEROKEE SMALL LETTER DE+  '\xaba5'# -> unI64 5077+  -- CHEROKEE SMALL LETTER TE+  '\xaba6'# -> unI64 5078+  -- CHEROKEE SMALL LETTER DI+  '\xaba7'# -> unI64 5079+  -- CHEROKEE SMALL LETTER TI+  '\xaba8'# -> unI64 5080+  -- CHEROKEE SMALL LETTER DO+  '\xaba9'# -> unI64 5081+  -- CHEROKEE SMALL LETTER DU+  '\xabaa'# -> unI64 5082+  -- CHEROKEE SMALL LETTER DV+  '\xabab'# -> unI64 5083+  -- CHEROKEE SMALL LETTER DLA+  '\xabac'# -> unI64 5084+  -- CHEROKEE SMALL LETTER TLA+  '\xabad'# -> unI64 5085+  -- CHEROKEE SMALL LETTER TLE+  '\xabae'# -> unI64 5086+  -- CHEROKEE SMALL LETTER TLI+  '\xabaf'# -> unI64 5087+  -- CHEROKEE SMALL LETTER TLO+  '\xabb0'# -> unI64 5088+  -- CHEROKEE SMALL LETTER TLU+  '\xabb1'# -> unI64 5089+  -- CHEROKEE SMALL LETTER TLV+  '\xabb2'# -> unI64 5090+  -- CHEROKEE SMALL LETTER TSA+  '\xabb3'# -> unI64 5091+  -- CHEROKEE SMALL LETTER TSE+  '\xabb4'# -> unI64 5092+  -- CHEROKEE SMALL LETTER TSI+  '\xabb5'# -> unI64 5093+  -- CHEROKEE SMALL LETTER TSO+  '\xabb6'# -> unI64 5094+  -- CHEROKEE SMALL LETTER TSU+  '\xabb7'# -> unI64 5095+  -- CHEROKEE SMALL LETTER TSV+  '\xabb8'# -> unI64 5096+  -- CHEROKEE SMALL LETTER WA+  '\xabb9'# -> unI64 5097+  -- CHEROKEE SMALL LETTER WE+  '\xabba'# -> unI64 5098+  -- CHEROKEE SMALL LETTER WI+  '\xabbb'# -> unI64 5099+  -- CHEROKEE SMALL LETTER WO+  '\xabbc'# -> unI64 5100+  -- CHEROKEE SMALL LETTER WU+  '\xabbd'# -> unI64 5101+  -- CHEROKEE SMALL LETTER WV+  '\xabbe'# -> unI64 5102+  -- CHEROKEE SMALL LETTER YA+  '\xabbf'# -> unI64 5103+  -- LATIN SMALL LIGATURE FF+  '\xfb00'# -> unI64 213909606+  -- LATIN SMALL LIGATURE FI+  '\xfb01'# -> unI64 220201062+  -- LATIN SMALL LIGATURE FL+  '\xfb02'# -> unI64 226492518+  -- LATIN SMALL LIGATURE FFI+  '\xfb03'# -> unI64 461795097575526+  -- LATIN SMALL LIGATURE FFL+  '\xfb04'# -> unI64 474989237108838+  -- LATIN SMALL LIGATURE LONG S T+  '\xfb05'# -> unI64 243269747+  -- LATIN SMALL LIGATURE ST+  '\xfb06'# -> unI64 243269747+  -- ARMENIAN SMALL LIGATURE MEN NOW+  '\xfb13'# -> unI64 2931819892+  -- ARMENIAN SMALL LIGATURE MEN ECH+  '\xfb14'# -> unI64 2896168308+  -- ARMENIAN SMALL LIGATURE MEN INI+  '\xfb15'# -> unI64 2908751220+  -- ARMENIAN SMALL LIGATURE VEW NOW+  '\xfb16'# -> unI64 2931819902+  -- ARMENIAN SMALL LIGATURE MEN XEH+  '\xfb17'# -> unI64 2912945524+  -- FULLWIDTH LATIN CAPITAL LETTER A+  '\xff21'# -> unI64 65345+  -- FULLWIDTH LATIN CAPITAL LETTER B+  '\xff22'# -> unI64 65346+  -- FULLWIDTH LATIN CAPITAL LETTER C+  '\xff23'# -> unI64 65347+  -- FULLWIDTH LATIN CAPITAL LETTER D+  '\xff24'# -> unI64 65348+  -- FULLWIDTH LATIN CAPITAL LETTER E+  '\xff25'# -> unI64 65349+  -- FULLWIDTH LATIN CAPITAL LETTER F+  '\xff26'# -> unI64 65350+  -- FULLWIDTH LATIN CAPITAL LETTER G+  '\xff27'# -> unI64 65351+  -- FULLWIDTH LATIN CAPITAL LETTER H+  '\xff28'# -> unI64 65352+  -- FULLWIDTH LATIN CAPITAL LETTER I+  '\xff29'# -> unI64 65353+  -- FULLWIDTH LATIN CAPITAL LETTER J+  '\xff2a'# -> unI64 65354+  -- FULLWIDTH LATIN CAPITAL LETTER K+  '\xff2b'# -> unI64 65355+  -- FULLWIDTH LATIN CAPITAL LETTER L+  '\xff2c'# -> unI64 65356+  -- FULLWIDTH LATIN CAPITAL LETTER M+  '\xff2d'# -> unI64 65357+  -- FULLWIDTH LATIN CAPITAL LETTER N+  '\xff2e'# -> unI64 65358+  -- FULLWIDTH LATIN CAPITAL LETTER O+  '\xff2f'# -> unI64 65359+  -- FULLWIDTH LATIN CAPITAL LETTER P+  '\xff30'# -> unI64 65360+  -- FULLWIDTH LATIN CAPITAL LETTER Q+  '\xff31'# -> unI64 65361+  -- FULLWIDTH LATIN CAPITAL LETTER R+  '\xff32'# -> unI64 65362+  -- FULLWIDTH LATIN CAPITAL LETTER S+  '\xff33'# -> unI64 65363+  -- FULLWIDTH LATIN CAPITAL LETTER T+  '\xff34'# -> unI64 65364+  -- FULLWIDTH LATIN CAPITAL LETTER U+  '\xff35'# -> unI64 65365+  -- FULLWIDTH LATIN CAPITAL LETTER V+  '\xff36'# -> unI64 65366+  -- FULLWIDTH LATIN CAPITAL LETTER W+  '\xff37'# -> unI64 65367+  -- FULLWIDTH LATIN CAPITAL LETTER X+  '\xff38'# -> unI64 65368+  -- FULLWIDTH LATIN CAPITAL LETTER Y+  '\xff39'# -> unI64 65369+  -- FULLWIDTH LATIN CAPITAL LETTER Z+  '\xff3a'# -> unI64 65370+  -- DESERET CAPITAL LETTER LONG I+  '\x10400'# -> unI64 66600+  -- DESERET CAPITAL LETTER LONG E+  '\x10401'# -> unI64 66601+  -- DESERET CAPITAL LETTER LONG A+  '\x10402'# -> unI64 66602+  -- DESERET CAPITAL LETTER LONG AH+  '\x10403'# -> unI64 66603+  -- DESERET CAPITAL LETTER LONG O+  '\x10404'# -> unI64 66604+  -- DESERET CAPITAL LETTER LONG OO+  '\x10405'# -> unI64 66605+  -- DESERET CAPITAL LETTER SHORT I+  '\x10406'# -> unI64 66606+  -- DESERET CAPITAL LETTER SHORT E+  '\x10407'# -> unI64 66607+  -- DESERET CAPITAL LETTER SHORT A+  '\x10408'# -> unI64 66608+  -- DESERET CAPITAL LETTER SHORT AH+  '\x10409'# -> unI64 66609+  -- DESERET CAPITAL LETTER SHORT O+  '\x1040a'# -> unI64 66610+  -- DESERET CAPITAL LETTER SHORT OO+  '\x1040b'# -> unI64 66611+  -- DESERET CAPITAL LETTER AY+  '\x1040c'# -> unI64 66612+  -- DESERET CAPITAL LETTER OW+  '\x1040d'# -> unI64 66613+  -- DESERET CAPITAL LETTER WU+  '\x1040e'# -> unI64 66614+  -- DESERET CAPITAL LETTER YEE+  '\x1040f'# -> unI64 66615+  -- DESERET CAPITAL LETTER H+  '\x10410'# -> unI64 66616+  -- DESERET CAPITAL LETTER PEE+  '\x10411'# -> unI64 66617+  -- DESERET CAPITAL LETTER BEE+  '\x10412'# -> unI64 66618+  -- DESERET CAPITAL LETTER TEE+  '\x10413'# -> unI64 66619+  -- DESERET CAPITAL LETTER DEE+  '\x10414'# -> unI64 66620+  -- DESERET CAPITAL LETTER CHEE+  '\x10415'# -> unI64 66621+  -- DESERET CAPITAL LETTER JEE+  '\x10416'# -> unI64 66622+  -- DESERET CAPITAL LETTER KAY+  '\x10417'# -> unI64 66623+  -- DESERET CAPITAL LETTER GAY+  '\x10418'# -> unI64 66624+  -- DESERET CAPITAL LETTER EF+  '\x10419'# -> unI64 66625+  -- DESERET CAPITAL LETTER VEE+  '\x1041a'# -> unI64 66626+  -- DESERET CAPITAL LETTER ETH+  '\x1041b'# -> unI64 66627+  -- DESERET CAPITAL LETTER THEE+  '\x1041c'# -> unI64 66628+  -- DESERET CAPITAL LETTER ES+  '\x1041d'# -> unI64 66629+  -- DESERET CAPITAL LETTER ZEE+  '\x1041e'# -> unI64 66630+  -- DESERET CAPITAL LETTER ESH+  '\x1041f'# -> unI64 66631+  -- DESERET CAPITAL LETTER ZHEE+  '\x10420'# -> unI64 66632+  -- DESERET CAPITAL LETTER ER+  '\x10421'# -> unI64 66633+  -- DESERET CAPITAL LETTER EL+  '\x10422'# -> unI64 66634+  -- DESERET CAPITAL LETTER EM+  '\x10423'# -> unI64 66635+  -- DESERET CAPITAL LETTER EN+  '\x10424'# -> unI64 66636+  -- DESERET CAPITAL LETTER ENG+  '\x10425'# -> unI64 66637+  -- DESERET CAPITAL LETTER OI+  '\x10426'# -> unI64 66638+  -- DESERET CAPITAL LETTER EW+  '\x10427'# -> unI64 66639+  -- OSAGE CAPITAL LETTER A+  '\x104b0'# -> unI64 66776+  -- OSAGE CAPITAL LETTER AI+  '\x104b1'# -> unI64 66777+  -- OSAGE CAPITAL LETTER AIN+  '\x104b2'# -> unI64 66778+  -- OSAGE CAPITAL LETTER AH+  '\x104b3'# -> unI64 66779+  -- OSAGE CAPITAL LETTER BRA+  '\x104b4'# -> unI64 66780+  -- OSAGE CAPITAL LETTER CHA+  '\x104b5'# -> unI64 66781+  -- OSAGE CAPITAL LETTER EHCHA+  '\x104b6'# -> unI64 66782+  -- OSAGE CAPITAL LETTER E+  '\x104b7'# -> unI64 66783+  -- OSAGE CAPITAL LETTER EIN+  '\x104b8'# -> unI64 66784+  -- OSAGE CAPITAL LETTER HA+  '\x104b9'# -> unI64 66785+  -- OSAGE CAPITAL LETTER HYA+  '\x104ba'# -> unI64 66786+  -- OSAGE CAPITAL LETTER I+  '\x104bb'# -> unI64 66787+  -- OSAGE CAPITAL LETTER KA+  '\x104bc'# -> unI64 66788+  -- OSAGE CAPITAL LETTER EHKA+  '\x104bd'# -> unI64 66789+  -- OSAGE CAPITAL LETTER KYA+  '\x104be'# -> unI64 66790+  -- OSAGE CAPITAL LETTER LA+  '\x104bf'# -> unI64 66791+  -- OSAGE CAPITAL LETTER MA+  '\x104c0'# -> unI64 66792+  -- OSAGE CAPITAL LETTER NA+  '\x104c1'# -> unI64 66793+  -- OSAGE CAPITAL LETTER O+  '\x104c2'# -> unI64 66794+  -- OSAGE CAPITAL LETTER OIN+  '\x104c3'# -> unI64 66795+  -- OSAGE CAPITAL LETTER PA+  '\x104c4'# -> unI64 66796+  -- OSAGE CAPITAL LETTER EHPA+  '\x104c5'# -> unI64 66797+  -- OSAGE CAPITAL LETTER SA+  '\x104c6'# -> unI64 66798+  -- OSAGE CAPITAL LETTER SHA+  '\x104c7'# -> unI64 66799+  -- OSAGE CAPITAL LETTER TA+  '\x104c8'# -> unI64 66800+  -- OSAGE CAPITAL LETTER EHTA+  '\x104c9'# -> unI64 66801+  -- OSAGE CAPITAL LETTER TSA+  '\x104ca'# -> unI64 66802+  -- OSAGE CAPITAL LETTER EHTSA+  '\x104cb'# -> unI64 66803+  -- OSAGE CAPITAL LETTER TSHA+  '\x104cc'# -> unI64 66804+  -- OSAGE CAPITAL LETTER DHA+  '\x104cd'# -> unI64 66805+  -- OSAGE CAPITAL LETTER U+  '\x104ce'# -> unI64 66806+  -- OSAGE CAPITAL LETTER WA+  '\x104cf'# -> unI64 66807+  -- OSAGE CAPITAL LETTER KHA+  '\x104d0'# -> unI64 66808+  -- OSAGE CAPITAL LETTER GHA+  '\x104d1'# -> unI64 66809+  -- OSAGE CAPITAL LETTER ZA+  '\x104d2'# -> unI64 66810+  -- OSAGE CAPITAL LETTER ZHA+  '\x104d3'# -> unI64 66811+  -- VITHKUQI CAPITAL LETTER A+  '\x10570'# -> unI64 66967+  -- VITHKUQI CAPITAL LETTER BBE+  '\x10571'# -> unI64 66968+  -- VITHKUQI CAPITAL LETTER BE+  '\x10572'# -> unI64 66969+  -- VITHKUQI CAPITAL LETTER CE+  '\x10573'# -> unI64 66970+  -- VITHKUQI CAPITAL LETTER CHE+  '\x10574'# -> unI64 66971+  -- VITHKUQI CAPITAL LETTER DE+  '\x10575'# -> unI64 66972+  -- VITHKUQI CAPITAL LETTER DHE+  '\x10576'# -> unI64 66973+  -- VITHKUQI CAPITAL LETTER EI+  '\x10577'# -> unI64 66974+  -- VITHKUQI CAPITAL LETTER E+  '\x10578'# -> unI64 66975+  -- VITHKUQI CAPITAL LETTER FE+  '\x10579'# -> unI64 66976+  -- VITHKUQI CAPITAL LETTER GA+  '\x1057a'# -> unI64 66977+  -- VITHKUQI CAPITAL LETTER HA+  '\x1057c'# -> unI64 66979+  -- VITHKUQI CAPITAL LETTER HHA+  '\x1057d'# -> unI64 66980+  -- VITHKUQI CAPITAL LETTER I+  '\x1057e'# -> unI64 66981+  -- VITHKUQI CAPITAL LETTER IJE+  '\x1057f'# -> unI64 66982+  -- VITHKUQI CAPITAL LETTER JE+  '\x10580'# -> unI64 66983+  -- VITHKUQI CAPITAL LETTER KA+  '\x10581'# -> unI64 66984+  -- VITHKUQI CAPITAL LETTER LA+  '\x10582'# -> unI64 66985+  -- VITHKUQI CAPITAL LETTER LLA+  '\x10583'# -> unI64 66986+  -- VITHKUQI CAPITAL LETTER ME+  '\x10584'# -> unI64 66987+  -- VITHKUQI CAPITAL LETTER NE+  '\x10585'# -> unI64 66988+  -- VITHKUQI CAPITAL LETTER NJE+  '\x10586'# -> unI64 66989+  -- VITHKUQI CAPITAL LETTER O+  '\x10587'# -> unI64 66990+  -- VITHKUQI CAPITAL LETTER PE+  '\x10588'# -> unI64 66991+  -- VITHKUQI CAPITAL LETTER QA+  '\x10589'# -> unI64 66992+  -- VITHKUQI CAPITAL LETTER RE+  '\x1058a'# -> unI64 66993+  -- VITHKUQI CAPITAL LETTER SE+  '\x1058c'# -> unI64 66995+  -- VITHKUQI CAPITAL LETTER SHE+  '\x1058d'# -> unI64 66996+  -- VITHKUQI CAPITAL LETTER TE+  '\x1058e'# -> unI64 66997+  -- VITHKUQI CAPITAL LETTER THE+  '\x1058f'# -> unI64 66998+  -- VITHKUQI CAPITAL LETTER U+  '\x10590'# -> unI64 66999+  -- VITHKUQI CAPITAL LETTER VE+  '\x10591'# -> unI64 67000+  -- VITHKUQI CAPITAL LETTER XE+  '\x10592'# -> unI64 67001+  -- VITHKUQI CAPITAL LETTER Y+  '\x10594'# -> unI64 67003+  -- VITHKUQI CAPITAL LETTER ZE+  '\x10595'# -> unI64 67004+  -- OLD HUNGARIAN CAPITAL LETTER A+  '\x10c80'# -> unI64 68800+  -- OLD HUNGARIAN CAPITAL LETTER AA+  '\x10c81'# -> unI64 68801+  -- OLD HUNGARIAN CAPITAL LETTER EB+  '\x10c82'# -> unI64 68802+  -- OLD HUNGARIAN CAPITAL LETTER AMB+  '\x10c83'# -> unI64 68803+  -- OLD HUNGARIAN CAPITAL LETTER EC+  '\x10c84'# -> unI64 68804+  -- OLD HUNGARIAN CAPITAL LETTER ENC+  '\x10c85'# -> unI64 68805+  -- OLD HUNGARIAN CAPITAL LETTER ECS+  '\x10c86'# -> unI64 68806+  -- OLD HUNGARIAN CAPITAL LETTER ED+  '\x10c87'# -> unI64 68807+  -- OLD HUNGARIAN CAPITAL LETTER AND+  '\x10c88'# -> unI64 68808+  -- OLD HUNGARIAN CAPITAL LETTER E+  '\x10c89'# -> unI64 68809+  -- OLD HUNGARIAN CAPITAL LETTER CLOSE E+  '\x10c8a'# -> unI64 68810+  -- OLD HUNGARIAN CAPITAL LETTER EE+  '\x10c8b'# -> unI64 68811+  -- OLD HUNGARIAN CAPITAL LETTER EF+  '\x10c8c'# -> unI64 68812+  -- OLD HUNGARIAN CAPITAL LETTER EG+  '\x10c8d'# -> unI64 68813+  -- OLD HUNGARIAN CAPITAL LETTER EGY+  '\x10c8e'# -> unI64 68814+  -- OLD HUNGARIAN CAPITAL LETTER EH+  '\x10c8f'# -> unI64 68815+  -- OLD HUNGARIAN CAPITAL LETTER I+  '\x10c90'# -> unI64 68816+  -- OLD HUNGARIAN CAPITAL LETTER II+  '\x10c91'# -> unI64 68817+  -- OLD HUNGARIAN CAPITAL LETTER EJ+  '\x10c92'# -> unI64 68818+  -- OLD HUNGARIAN CAPITAL LETTER EK+  '\x10c93'# -> unI64 68819+  -- OLD HUNGARIAN CAPITAL LETTER AK+  '\x10c94'# -> unI64 68820+  -- OLD HUNGARIAN CAPITAL LETTER UNK+  '\x10c95'# -> unI64 68821+  -- OLD HUNGARIAN CAPITAL LETTER EL+  '\x10c96'# -> unI64 68822+  -- OLD HUNGARIAN CAPITAL LETTER ELY+  '\x10c97'# -> unI64 68823+  -- OLD HUNGARIAN CAPITAL LETTER EM+  '\x10c98'# -> unI64 68824+  -- OLD HUNGARIAN CAPITAL LETTER EN+  '\x10c99'# -> unI64 68825+  -- OLD HUNGARIAN CAPITAL LETTER ENY+  '\x10c9a'# -> unI64 68826+  -- OLD HUNGARIAN CAPITAL LETTER O+  '\x10c9b'# -> unI64 68827+  -- OLD HUNGARIAN CAPITAL LETTER OO+  '\x10c9c'# -> unI64 68828+  -- OLD HUNGARIAN CAPITAL LETTER NIKOLSBURG OE+  '\x10c9d'# -> unI64 68829+  -- OLD HUNGARIAN CAPITAL LETTER RUDIMENTA OE+  '\x10c9e'# -> unI64 68830+  -- OLD HUNGARIAN CAPITAL LETTER OEE+  '\x10c9f'# -> unI64 68831+  -- OLD HUNGARIAN CAPITAL LETTER EP+  '\x10ca0'# -> unI64 68832+  -- OLD HUNGARIAN CAPITAL LETTER EMP+  '\x10ca1'# -> unI64 68833+  -- OLD HUNGARIAN CAPITAL LETTER ER+  '\x10ca2'# -> unI64 68834+  -- OLD HUNGARIAN CAPITAL LETTER SHORT ER+  '\x10ca3'# -> unI64 68835+  -- OLD HUNGARIAN CAPITAL LETTER ES+  '\x10ca4'# -> unI64 68836+  -- OLD HUNGARIAN CAPITAL LETTER ESZ+  '\x10ca5'# -> unI64 68837+  -- OLD HUNGARIAN CAPITAL LETTER ET+  '\x10ca6'# -> unI64 68838+  -- OLD HUNGARIAN CAPITAL LETTER ENT+  '\x10ca7'# -> unI64 68839+  -- OLD HUNGARIAN CAPITAL LETTER ETY+  '\x10ca8'# -> unI64 68840+  -- OLD HUNGARIAN CAPITAL LETTER ECH+  '\x10ca9'# -> unI64 68841+  -- OLD HUNGARIAN CAPITAL LETTER U+  '\x10caa'# -> unI64 68842+  -- OLD HUNGARIAN CAPITAL LETTER UU+  '\x10cab'# -> unI64 68843+  -- OLD HUNGARIAN CAPITAL LETTER NIKOLSBURG UE+  '\x10cac'# -> unI64 68844+  -- OLD HUNGARIAN CAPITAL LETTER RUDIMENTA UE+  '\x10cad'# -> unI64 68845+  -- OLD HUNGARIAN CAPITAL LETTER EV+  '\x10cae'# -> unI64 68846+  -- OLD HUNGARIAN CAPITAL LETTER EZ+  '\x10caf'# -> unI64 68847+  -- OLD HUNGARIAN CAPITAL LETTER EZS+  '\x10cb0'# -> unI64 68848+  -- OLD HUNGARIAN CAPITAL LETTER ENT-SHAPED SIGN+  '\x10cb1'# -> unI64 68849+  -- OLD HUNGARIAN CAPITAL LETTER US+  '\x10cb2'# -> unI64 68850+  -- WARANG CITI CAPITAL LETTER NGAA+  '\x118a0'# -> unI64 71872+  -- WARANG CITI CAPITAL LETTER A+  '\x118a1'# -> unI64 71873+  -- WARANG CITI CAPITAL LETTER WI+  '\x118a2'# -> unI64 71874+  -- WARANG CITI CAPITAL LETTER YU+  '\x118a3'# -> unI64 71875+  -- WARANG CITI CAPITAL LETTER YA+  '\x118a4'# -> unI64 71876+  -- WARANG CITI CAPITAL LETTER YO+  '\x118a5'# -> unI64 71877+  -- WARANG CITI CAPITAL LETTER II+  '\x118a6'# -> unI64 71878+  -- WARANG CITI CAPITAL LETTER UU+  '\x118a7'# -> unI64 71879+  -- WARANG CITI CAPITAL LETTER E+  '\x118a8'# -> unI64 71880+  -- WARANG CITI CAPITAL LETTER O+  '\x118a9'# -> unI64 71881+  -- WARANG CITI CAPITAL LETTER ANG+  '\x118aa'# -> unI64 71882+  -- WARANG CITI CAPITAL LETTER GA+  '\x118ab'# -> unI64 71883+  -- WARANG CITI CAPITAL LETTER KO+  '\x118ac'# -> unI64 71884+  -- WARANG CITI CAPITAL LETTER ENY+  '\x118ad'# -> unI64 71885+  -- WARANG CITI CAPITAL LETTER YUJ+  '\x118ae'# -> unI64 71886+  -- WARANG CITI CAPITAL LETTER UC+  '\x118af'# -> unI64 71887+  -- WARANG CITI CAPITAL LETTER ENN+  '\x118b0'# -> unI64 71888+  -- WARANG CITI CAPITAL LETTER ODD+  '\x118b1'# -> unI64 71889+  -- WARANG CITI CAPITAL LETTER TTE+  '\x118b2'# -> unI64 71890+  -- WARANG CITI CAPITAL LETTER NUNG+  '\x118b3'# -> unI64 71891+  -- WARANG CITI CAPITAL LETTER DA+  '\x118b4'# -> unI64 71892+  -- WARANG CITI CAPITAL LETTER AT+  '\x118b5'# -> unI64 71893+  -- WARANG CITI CAPITAL LETTER AM+  '\x118b6'# -> unI64 71894+  -- WARANG CITI CAPITAL LETTER BU+  '\x118b7'# -> unI64 71895+  -- WARANG CITI CAPITAL LETTER PU+  '\x118b8'# -> unI64 71896+  -- WARANG CITI CAPITAL LETTER HIYO+  '\x118b9'# -> unI64 71897+  -- WARANG CITI CAPITAL LETTER HOLO+  '\x118ba'# -> unI64 71898+  -- WARANG CITI CAPITAL LETTER HORR+  '\x118bb'# -> unI64 71899+  -- WARANG CITI CAPITAL LETTER HAR+  '\x118bc'# -> unI64 71900+  -- WARANG CITI CAPITAL LETTER SSUU+  '\x118bd'# -> unI64 71901+  -- WARANG CITI CAPITAL LETTER SII+  '\x118be'# -> unI64 71902+  -- WARANG CITI CAPITAL LETTER VIYO+  '\x118bf'# -> unI64 71903+  -- MEDEFAIDRIN CAPITAL LETTER M+  '\x16e40'# -> unI64 93792+  -- MEDEFAIDRIN CAPITAL LETTER S+  '\x16e41'# -> unI64 93793+  -- MEDEFAIDRIN CAPITAL LETTER V+  '\x16e42'# -> unI64 93794+  -- MEDEFAIDRIN CAPITAL LETTER W+  '\x16e43'# -> unI64 93795+  -- MEDEFAIDRIN CAPITAL LETTER ATIU+  '\x16e44'# -> unI64 93796+  -- MEDEFAIDRIN CAPITAL LETTER Z+  '\x16e45'# -> unI64 93797+  -- MEDEFAIDRIN CAPITAL LETTER KP+  '\x16e46'# -> unI64 93798+  -- MEDEFAIDRIN CAPITAL LETTER P+  '\x16e47'# -> unI64 93799+  -- MEDEFAIDRIN CAPITAL LETTER T+  '\x16e48'# -> unI64 93800+  -- MEDEFAIDRIN CAPITAL LETTER G+  '\x16e49'# -> unI64 93801+  -- MEDEFAIDRIN CAPITAL LETTER F+  '\x16e4a'# -> unI64 93802+  -- MEDEFAIDRIN CAPITAL LETTER I+  '\x16e4b'# -> unI64 93803+  -- MEDEFAIDRIN CAPITAL LETTER K+  '\x16e4c'# -> unI64 93804+  -- MEDEFAIDRIN CAPITAL LETTER A+  '\x16e4d'# -> unI64 93805+  -- MEDEFAIDRIN CAPITAL LETTER J+  '\x16e4e'# -> unI64 93806+  -- MEDEFAIDRIN CAPITAL LETTER E+  '\x16e4f'# -> unI64 93807+  -- MEDEFAIDRIN CAPITAL LETTER B+  '\x16e50'# -> unI64 93808+  -- MEDEFAIDRIN CAPITAL LETTER C+  '\x16e51'# -> unI64 93809+  -- MEDEFAIDRIN CAPITAL LETTER U+  '\x16e52'# -> unI64 93810+  -- MEDEFAIDRIN CAPITAL LETTER YU+  '\x16e53'# -> unI64 93811+  -- MEDEFAIDRIN CAPITAL LETTER L+  '\x16e54'# -> unI64 93812+  -- MEDEFAIDRIN CAPITAL LETTER Q+  '\x16e55'# -> unI64 93813+  -- MEDEFAIDRIN CAPITAL LETTER HP+  '\x16e56'# -> unI64 93814+  -- MEDEFAIDRIN CAPITAL LETTER NY+  '\x16e57'# -> unI64 93815+  -- MEDEFAIDRIN CAPITAL LETTER X+  '\x16e58'# -> unI64 93816+  -- MEDEFAIDRIN CAPITAL LETTER D+  '\x16e59'# -> unI64 93817+  -- MEDEFAIDRIN CAPITAL LETTER OE+  '\x16e5a'# -> unI64 93818+  -- MEDEFAIDRIN CAPITAL LETTER N+  '\x16e5b'# -> unI64 93819+  -- MEDEFAIDRIN CAPITAL LETTER R+  '\x16e5c'# -> unI64 93820+  -- MEDEFAIDRIN CAPITAL LETTER O+  '\x16e5d'# -> unI64 93821+  -- MEDEFAIDRIN CAPITAL LETTER AI+  '\x16e5e'# -> unI64 93822+  -- MEDEFAIDRIN CAPITAL LETTER Y+  '\x16e5f'# -> unI64 93823+  -- ADLAM CAPITAL LETTER ALIF+  '\x1e900'# -> unI64 125218+  -- ADLAM CAPITAL LETTER DAALI+  '\x1e901'# -> unI64 125219+  -- ADLAM CAPITAL LETTER LAAM+  '\x1e902'# -> unI64 125220+  -- ADLAM CAPITAL LETTER MIIM+  '\x1e903'# -> unI64 125221+  -- ADLAM CAPITAL LETTER BA+  '\x1e904'# -> unI64 125222+  -- ADLAM CAPITAL LETTER SINNYIIYHE+  '\x1e905'# -> unI64 125223+  -- ADLAM CAPITAL LETTER PE+  '\x1e906'# -> unI64 125224+  -- ADLAM CAPITAL LETTER BHE+  '\x1e907'# -> unI64 125225+  -- ADLAM CAPITAL LETTER RA+  '\x1e908'# -> unI64 125226+  -- ADLAM CAPITAL LETTER E+  '\x1e909'# -> unI64 125227+  -- ADLAM CAPITAL LETTER FA+  '\x1e90a'# -> unI64 125228+  -- ADLAM CAPITAL LETTER I+  '\x1e90b'# -> unI64 125229+  -- ADLAM CAPITAL LETTER O+  '\x1e90c'# -> unI64 125230+  -- ADLAM CAPITAL LETTER DHA+  '\x1e90d'# -> unI64 125231+  -- ADLAM CAPITAL LETTER YHE+  '\x1e90e'# -> unI64 125232+  -- ADLAM CAPITAL LETTER WAW+  '\x1e90f'# -> unI64 125233+  -- ADLAM CAPITAL LETTER NUN+  '\x1e910'# -> unI64 125234+  -- ADLAM CAPITAL LETTER KAF+  '\x1e911'# -> unI64 125235+  -- ADLAM CAPITAL LETTER YA+  '\x1e912'# -> unI64 125236+  -- ADLAM CAPITAL LETTER U+  '\x1e913'# -> unI64 125237+  -- ADLAM CAPITAL LETTER JIIM+  '\x1e914'# -> unI64 125238+  -- ADLAM CAPITAL LETTER CHI+  '\x1e915'# -> unI64 125239+  -- ADLAM CAPITAL LETTER HA+  '\x1e916'# -> unI64 125240+  -- ADLAM CAPITAL LETTER QAAF+  '\x1e917'# -> unI64 125241+  -- ADLAM CAPITAL LETTER GA+  '\x1e918'# -> unI64 125242+  -- ADLAM CAPITAL LETTER NYA+  '\x1e919'# -> unI64 125243+  -- ADLAM CAPITAL LETTER TU+  '\x1e91a'# -> unI64 125244+  -- ADLAM CAPITAL LETTER NHA+  '\x1e91b'# -> unI64 125245+  -- ADLAM CAPITAL LETTER VA+  '\x1e91c'# -> unI64 125246+  -- ADLAM CAPITAL LETTER KHA+  '\x1e91d'# -> unI64 125247+  -- ADLAM CAPITAL LETTER GBE+  '\x1e91e'# -> unI64 125248+  -- ADLAM CAPITAL LETTER ZAL+  '\x1e91f'# -> unI64 125249+  -- ADLAM CAPITAL LETTER KPO+  '\x1e920'# -> unI64 125250+  -- ADLAM CAPITAL LETTER SHA+  '\x1e921'# -> unI64 125251+  _ -> unI64 0
+ src-ghc/Data/JSString/Internal/Fusion/Common.hs view
@@ -0,0 +1,92 @@+{-# LANGUAGE BangPatterns, MagicHash, RankNTypes #-}++module Data.JSString.Internal.Fusion.Common ( -- * Creation and elimination+                                              singleton+                                            , streamList+                                            , unstreamList+                                            , streamCString#++                                              -- * Basic interface+                                            , cons+                                            , snoc+                                            , append+                                            , head+                                            , uncons+                                            , last+                                            , tail+                                            , init+                                            , null+                                            , lengthI+                                            , compareLengthI+                                            , isSingleton++                                              -- * Transformations+                                            , map+                                            , intercalate+                                            , intersperse++                                              -- ** Case conversion+                                              -- $case+                                            , toCaseFold+                                            , toLower+                                            , toTitle+                                            , toUpper++                                              -- ** Justification+                                            , justifyLeftI++                                              -- * Folds+                                            , foldl+                                            , foldl'+                                            , foldl1+                                            , foldl1'+                                            , foldr+                                            , foldr1++                                              -- ** Special folds+                                            , concat+                                            , concatMap+                                            , any+                                            , all+                                            , maximum+                                            , minimum++                                              -- * Construction+                                              -- ** Scans+                                            , scanl++                                              -- ** Accumulating maps+                                              -- , mapAccumL++                                              -- ** Generation and unfolding+                                            , replicateCharI+                                            , replicateI+                                            , unfoldr+                                            , unfoldrNI++                                              -- * Substrings+                                              -- ** Breaking strings+                                            , take+                                            , drop+                                            , takeWhile+                                            , dropWhile++                                              -- * Predicates+                                            , isPrefixOf++                                              -- * Searching+                                            , elem+                                            , filter++                                              -- * Indexing+                                            , findBy+                                            , indexI+                                            , findIndexI+                                            , countCharI++                                              -- * Zipping and unzipping+                                            , zipWith+                                            ) where++import Data.Text.Internal.Fusion.Common+import Prelude ()
+ src-ghc/Data/JSString/Internal/Fusion/Types.hs view
@@ -0,0 +1,122 @@+{-# LANGUAGE BangPatterns, ExistentialQuantification #-}+-- |+-- Module      : Data.Text.Internal.Fusion.Types+-- Copyright   : (c) Tom Harper 2008-2009,+--               (c) Bryan O'Sullivan 2009,+--               (c) Duncan Coutts 2009,+--               (c) Jasper Van der Jeugt 2011+--+-- License     : BSD-style+-- Maintainer  : bos@serpentine.com+-- Stability   : experimental+-- Portability : GHC+--+-- /Warning/: this is an internal module, and does not have a stable+-- API or name. Functions in this module may not check or enforce+-- preconditions expected by public modules. Use at your own risk!+--+-- Core stream fusion functionality for text.++module Data.JSString.Internal.Fusion.Types+    (+      CC(..)+--    , M(..)+--    , M8+    , PairS(..)+    , RS(..)+    , Step(..)+    , Stream(..)+--    , Switch(..)+    , empty+    ) where++import Data.Text.Internal.Fusion.Types+-- import Data.Text.Internal.Fusion.Size+-- import Data.Word (Word8)++---- | Specialised tuple for case conversion.+--data CC s = CC !s {-# UNPACK #-} !Char {-# UNPACK #-} !Char+--+---- | Specialised, strict Maybe-like type.+--data M a = N+--         | J !a+--+--type M8 = M Word8+--+---- Restreaming state.+--data RS s+--    = RS0 !s+--    | RS1 !s {-# UNPACK #-} !Word8+--    | RS2 !s {-# UNPACK #-} !Word8 {-# UNPACK #-} !Word8+--    | RS3 !s {-# UNPACK #-} !Word8 {-# UNPACK #-} !Word8 {-# UNPACK #-} !Word8+--+--infixl 2 :*:+--data PairS a b = !a :*: !b+--                 -- deriving (Eq, Ord, Show)+--+---- | Allow a function over a stream to switch between two states.+--data Switch = S1 | S2+--+--data Step s a = Done+--              | Skip !s+--              | Yield !a !s+--+--{-+--instance (Show a) => Show (Step s a)+--    where show Done        = "Done"+--          show (Skip _)    = "Skip"+--          show (Yield x _) = "Yield " ++ show x+---}+--+--instance (Eq a) => Eq (Stream a) where+--    (==) = eq+--+--instance (Ord a) => Ord (Stream a) where+--    compare = cmp+--+---- The length hint in a Stream has two roles.  If its value is zero,+---- we trust it, and treat the stream as empty.  Otherwise, we treat it+---- as a hint: it should usually be accurate, so we use it when+---- unstreaming to decide what size array to allocate.  However, the+---- unstreaming functions must be able to cope with the hint being too+---- small or too large.+--+--data Stream a =+--    forall s. Stream+--    (s -> Step s a)             -- stepper function+--    !s                          -- current state+--+---- | /O(n)/ Determines if two streams are equal.+--eq :: (Eq a) => Stream a -> Stream a -> Bool+--eq (Stream next1 s1) (Stream next2 s2) = loop (next1 s1) (next2 s2)+--    where+--      loop Done Done                     = True+--      loop (Skip s1')     (Skip s2')     = loop (next1 s1') (next2 s2')+--      loop (Skip s1')     x2             = loop (next1 s1') x2+--      loop x1             (Skip s2')     = loop x1          (next2 s2')+--      loop Done _                        = False+--      loop _    Done                     = False+--      loop (Yield x1 s1') (Yield x2 s2') = x1 == x2 &&+--                                           loop (next1 s1') (next2 s2')+--{-# INLINE [0] eq #-}+--+--cmp :: (Ord a) => Stream a -> Stream a -> Ordering+--cmp (Stream next1 s1) (Stream next2 s2) = loop (next1 s1) (next2 s2)+--    where+--      loop Done Done                     = EQ+--      loop (Skip s1')     (Skip s2')     = loop (next1 s1') (next2 s2')+--      loop (Skip s1')     x2             = loop (next1 s1') x2+--      loop x1             (Skip s2')     = loop x1          (next2 s2')+--      loop Done _                        = LT+--      loop _    Done                     = GT+--      loop (Yield x1 s1') (Yield x2 s2') =+--          case compare x1 x2 of+--            EQ    -> loop (next1 s1') (next2 s2')+--            other -> other+--{-# INLINE [0] cmp #-}+--+---- | The empty stream.+--empty :: Stream a+--empty = Stream next ()+--    where next _ = Done+--{-# INLINE [0] empty #-}
+ src-ghc/Data/JSString/Internal/Search.hs view
@@ -0,0 +1,11 @@+module Data.JSString.Internal.Search ( indices+                                     ) where++import Data.Coerce (coerce)++import Data.JSString.Internal.Type (JSString(..))++import qualified Data.Text.Internal.Search as T++indices :: JSString -> JSString -> [Int]+indices = coerce T.indices
+ src-ghc/Data/JSString/Internal/Type.hs view
@@ -0,0 +1,119 @@+{-# LANGUAGE DeriveDataTypeable, UnboxedTuples, MagicHash,+             BangPatterns, GeneralizedNewtypeDeriving #-}+{-# OPTIONS_HADDOCK not-home #-}+module Data.JSString.Internal.Type ( JSString(..)+                                   , empty+                                   , empty_+                                   , safe+                                   , firstf+                                   ) where++                                     {-+    -- * Construction+    , text+    , textP+    -- * Safety+    , safe+    -- * Code that must be here for accessibility+    , empty+    , empty_+    -- * Utilities+    , firstf+    -- * Checked multiplication+    , mul+    , mul32+    , mul64+    -- * Debugging+    , showText++                                   ) where+-}++import Prelude ()+import Prelude.Compat++import Control.DeepSeq++import Data.Coerce                    (coerce)+import Data.Text                      (Text)+import qualified Data.Text as T       (empty)+import Data.String                    (IsString)+import Data.Aeson                     (ToJSON(..), FromJSON(..))+import Data.Data                      (Data)+-- import Data.Text.Internal.Unsafe.Char (ord)+import Data.Typeable                  (Typeable)+import GHC.Exts                       (Char(..), ord#, andI#, (/=#), isTrue#)++-- | A wrapper around a JavaScript string+newtype JSString = JSString Text deriving(Show, Read, IsString, Semigroup, Monoid, Ord, Eq, Data, ToJSON, FromJSON, Typeable)++instance NFData JSString where rnf !_ = ()++-- | /O(1)/ The empty 'JSString'.+empty :: JSString+empty = coerce T.empty+{-# INLINE [1] empty #-}++-- | A non-inlined version of 'empty'.+empty_ :: JSString+empty_ = coerce T.empty+{-# NOINLINE empty_ #-}++safe :: Char -> Char+safe c@(C# cc)+    | isTrue# (andI# (ord# cc) 0x1ff800# /=# 0xd800#) = c+    | otherwise                    = '\xfffd'+{-# INLINE [0] safe #-}+++-- | Apply a function to the first element of an optional pair.+firstf :: (a -> c) -> Maybe (a,b) -> Maybe (c,b)+firstf f (Just (a, b)) = Just (f a, b)+firstf _  Nothing      = Nothing++{-+-- | Checked multiplication.  Calls 'error' if the result would+-- overflow.+mul :: Int -> Int -> Int+#if WORD_SIZE_IN_BITS == 64+mul a b = fromIntegral $ fromIntegral a `mul64` fromIntegral b+#else+mul a b = fromIntegral $ fromIntegral a `mul32` fromIntegral b+#endif+{-# INLINE mul #-}+infixl 7 `mul`++-- | Checked multiplication.  Calls 'error' if the result would+-- overflow.+mul64 :: Int64 -> Int64 -> Int64+mul64 a b+  | a >= 0 && b >= 0 =  mul64_ a b+  | a >= 0           = -mul64_ a (-b)+  | b >= 0           = -mul64_ (-a) b+  | otherwise        =  mul64_ (-a) (-b)+{-# INLINE mul64 #-}+infixl 7 `mul64`++mul64_ :: Int64 -> Int64 -> Int64+mul64_ a b+  | ahi > 0 && bhi > 0 = error "overflow"+  | top > 0x7fffffff   = error "overflow"+  | total < 0          = error "overflow"+  | otherwise          = total+  where (# ahi, alo #) = (# a `shiftR` 32, a .&. 0xffffffff #)+        (# bhi, blo #) = (# b `shiftR` 32, b .&. 0xffffffff #)+        top            = ahi * blo + alo * bhi+        total          = (top `shiftL` 32) + alo * blo+{-# INLINE mul64_ #-}++-- | Checked multiplication.  Calls 'error' if the result would+-- overflow.+mul32 :: Int32 -> Int32 -> Int32+mul32 a b = case fromIntegral a * fromIntegral b of+              ab | ab < min32 || ab > max32 -> error "overflow"+                 | otherwise                -> fromIntegral ab+  where min32 = -0x80000000 :: Int64+        max32 =  0x7fffffff+{-# INLINE mul32 #-}+infixl 7 `mul32`+-}
+ src-ghc/Data/JSString/Text.hs view
@@ -0,0 +1,52 @@+{- | Conversion between 'Data.Text.Text' and 'Data.JSString.JSString'  -}++module Data.JSString.Text+    ( textToJSString+    , textFromJSString+    , lazyTextToJSString+    , lazyTextFromJSString+    , textFromJSVal+    , lazyTextFromJSVal+    ) where++import GHCJS.Prim.Internal (JSVal)++import Data.Coerce (coerce)+import qualified Data.Text as T+import qualified Data.Text.Lazy as TL++import Data.JSString.Internal.Type++import Language.Javascript.JSaddle.Types (JSM, GHCJSPure(..))+import Language.Javascript.JSaddle.Native.Internal+       (valueToString)++textToJSString :: T.Text -> JSString+textToJSString = coerce+{-# INLINE textToJSString #-}++textFromJSString :: JSString -> T.Text+textFromJSString = coerce+{-# INLINE  textFromJSString #-}++lazyTextToJSString :: TL.Text -> JSString+lazyTextToJSString = coerce . TL.toStrict+{-# INLINE lazyTextToJSString #-}++lazyTextFromJSString :: JSString -> TL.Text+lazyTextFromJSString = TL.fromStrict . coerce+{-# INLINE lazyTextFromJSString #-}++-- | returns the empty Text if not a string+textFromJSVal :: JSVal -> GHCJSPure T.Text+textFromJSVal j = GHCJSPure $ textFromJSString <$> valToJSString j+{-# INLINE textFromJSVal #-}++-- | returns the empty Text if not a string+lazyTextFromJSVal :: JSVal -> GHCJSPure TL.Text+lazyTextFromJSVal j = GHCJSPure $ lazyTextFromJSString <$> valToJSString j+{-# INLINE lazyTextFromJSVal #-}++valToJSString :: JSVal -> JSM JSString+valToJSString = valueToString+{-# INLINE valToJSString #-}
+ src-ghc/GHCJS/Buffer.hs view
@@ -0,0 +1,117 @@+module GHCJS.Buffer+    ( Buffer+    , MutableBuffer+    , create+    , createFromArrayBuffer+    , thaw, freeze, clone+      -- * JavaScript properties+    , byteLength+    , getArrayBuffer+    , getUint8Array+    , getUint16Array+    , getInt32Array+    , getDataView+    , getFloat32Array+    , getFloat64Array+      -- * bytestring+    , toByteString, fromByteString+    ) where++import GHCJS.Buffer.Types++import Control.Lens.Operators ((^.))++import Data.ByteString (ByteString)+import qualified Data.ByteString as BS+import qualified Data.ByteString.Base64 as B64 (encode, decode)+import Data.Text.Encoding (encodeUtf8, decodeUtf8)++import qualified JavaScript.TypedArray.Internal.Types as I+import           JavaScript.TypedArray.ArrayBuffer.Internal (SomeArrayBuffer(..))+import           JavaScript.TypedArray.DataView.Internal    (SomeDataView(..))++import GHCJS.Marshal (FromJSVal(..))+import Language.Javascript.JSaddle.Types (JSM, GHCJSPure(..), ghcjsPure)+import Language.Javascript.JSaddle.Object (js, js2, jsg1, jsg3)++create :: Int -> JSM MutableBuffer+create n | n >= 0    = SomeBuffer <$> jsg1 "h$newByteArray" n+         | otherwise = error "create: negative size"+{-# INLINE create #-}++createFromArrayBuffer :: SomeArrayBuffer any -> GHCJSPure (SomeBuffer any)+createFromArrayBuffer (SomeArrayBuffer buf) = GHCJSPure $ SomeBuffer <$> jsg1 "h$wrapBuffer" buf+{-# INLINE createFromArrayBuffer #-}++getArrayBuffer :: SomeBuffer any -> GHCJSPure (SomeArrayBuffer any)+getArrayBuffer (SomeBuffer buf) = GHCJSPure $ SomeArrayBuffer <$> buf ^. js "buf"+{-# INLINE getArrayBuffer #-}++getInt32Array :: SomeBuffer any -> GHCJSPure (I.SomeInt32Array any)+getInt32Array (SomeBuffer buf) = GHCJSPure $ I.SomeTypedArray <$> buf ^. js "i3"+{-# INLINE getInt32Array #-}++getUint8Array :: SomeBuffer any -> GHCJSPure (I.SomeUint8Array any)+getUint8Array (SomeBuffer buf) = GHCJSPure $ I.SomeTypedArray <$> buf ^. js "u8"+{-# INLINE getUint8Array #-}++getUint16Array :: SomeBuffer any -> GHCJSPure (I.SomeUint16Array any)+getUint16Array (SomeBuffer buf) = GHCJSPure $ I.SomeTypedArray <$> buf ^. js "u1"+{-# INLINE getUint16Array #-}++getFloat32Array :: SomeBuffer any -> GHCJSPure (I.SomeFloat32Array any)+getFloat32Array (SomeBuffer buf) = GHCJSPure $ I.SomeTypedArray <$> buf ^. js "f3"+{-# INLINE getFloat32Array #-}++getFloat64Array :: SomeBuffer any -> GHCJSPure (I.SomeFloat64Array any)+getFloat64Array (SomeBuffer buf) = GHCJSPure $ I.SomeTypedArray <$> buf ^. js "f6"+{-# INLINE getFloat64Array #-}++getDataView :: SomeBuffer any -> GHCJSPure (SomeDataView any)+getDataView (SomeBuffer buf) = GHCJSPure $ SomeDataView  <$> buf ^. js "dv"+{-# INLINE getDataView #-}++freeze :: MutableBuffer -> JSM Buffer+freeze = js_clone+{-# INLINE freeze #-}++thaw :: Buffer -> JSM MutableBuffer+thaw  = js_clone+{-# INLINE thaw #-}++clone :: MutableBuffer -> JSM (SomeBuffer any2)+clone = js_clone+{-# INLINE clone #-}++fromByteString :: ByteString -> GHCJSPure (Buffer, Int, Int)+fromByteString bs = GHCJSPure $ do+  buffer <- SomeBuffer <$> jsg1 "h$newByteArrayFromBase64String" (decodeUtf8 $ B64.encode bs)+  return (buffer, 0, BS.length bs)+{-# INLINE fromByteString #-}++-- | Wrap a 'Buffer' into a 'ByteString' using the given offset+-- and length.+toByteString :: Int -> Maybe Int -> Buffer -> GHCJSPure ByteString+toByteString off mbLen buf = GHCJSPure $ do+  bufLen <- ghcjsPure $ byteLength buf+  case mbLen of+    _        | off < 0            -> error "toByteString: negative offset"+             | off > bufLen       -> error "toByteString: offset past end of buffer"+    Just len | len < 0            -> error "toByteString: negative length"+             | len > bufLen - off -> error "toByteString: length past end of buffer"+             | otherwise          -> ghcjsPure $ unsafeToByteString off len buf+    Nothing                       -> ghcjsPure $ unsafeToByteString off (bufLen - off) buf++unsafeToByteString :: Int -> Int -> Buffer -> GHCJSPure ByteString+unsafeToByteString off len (SomeBuffer buf) = GHCJSPure $ do+  b64 <- jsg3 "h$byteArrayToBase64String" off len buf >>= fromJSValUnchecked+  return $ case B64.decode (encodeUtf8 b64) of+            Left err -> error $ "unsafeToByteString base 64 decode error :" ++ err+            Right bs -> bs++byteLength :: SomeBuffer any -> GHCJSPure Int+byteLength (SomeBuffer buf) = GHCJSPure $ buf ^. js "len" >>= fromJSValUnchecked+{-# INLINE byteLength #-}++js_clone :: SomeBuffer any1 -> JSM (SomeBuffer any2)+js_clone (SomeBuffer buf) = SomeBuffer <$> jsg1 "h$wrapBuffer" (buf ^. js "buf" ^. js2 "slice" (buf ^. js "u8" ^. js "byteOffset") (buf ^. js "len"))
+ src-ghc/GHCJS/Buffer/Types.hs view
@@ -0,0 +1,11 @@+{-# LANGUAGE DataKinds, KindSignatures, PolyKinds #-}++module GHCJS.Buffer.Types where++import GHCJS.Types+import GHCJS.Internal.Types++newtype SomeBuffer (a :: MutabilityType s) = SomeBuffer JSVal++type    Buffer         = SomeBuffer Immutable+type    MutableBuffer  = SomeBuffer Mutable
+ src-ghc/GHCJS/Concurrent.hs view
@@ -0,0 +1,22 @@+{-# LANGUAGE DeriveDataTypeable #-}++module GHCJS.Concurrent ( OnBlocked(..)+                        , WouldBlockException(..)+                        ) where++import           GHCJS.Prim++import           Data.Data++{- |+     The runtime tries to run synchronous threads to completion. Sometimes it's+     not possible to continue running a thread, for example when the thread+     tries to take an empty 'MVar'. The runtime can then either throw a+     'WouldBlockException', aborting the blocking action, or continue the+     thread asynchronously.+ -}++data OnBlocked = ContinueAsync -- ^ continue the thread asynchronously if blocked+               | ThrowWouldBlock -- ^ throw 'WouldBlockException' if blocked+               deriving (Data, Typeable, Enum, Show, Eq, Ord)+
+ src-ghc/GHCJS/Foreign.hs view
@@ -0,0 +1,64 @@+{-# LANGUAGE CPP #-}+-----------------------------------------------------------------------------+--+-- Module      :  Language.Javascript.JSaddle.Value+-- Copyright   :  (c) Hamish Mackenzie+-- License     :  MIT+--+-- Maintainer  :  Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com>+--+-- |+--+-----------------------------------------------------------------------------+module GHCJS.Foreign (+    jsTrue+  , jsFalse+  , jsNull+  , toJSBool+--  , fromJSBool+  , jsUndefined+  , isTruthy+  , isNull+  , isUndefined+  , isObject+  , isFunction+  , isString+  , isBoolean+  , isSymbol+  , isNumber+  , JSType(..)+  , jsTypeOf+) where++import GHCJS.Foreign.Internal+import Language.Javascript.JSaddle.Types (JSVal(..), GHCJSPure(..))+import Language.Javascript.JSaddle.Object (jsg1)+import GHCJS.Marshal (FromJSVal(..))++isObject :: JSVal -> GHCJSPure Bool+isObject v = GHCJSPure $ jsg1 "h$isObject" v >>= fromJSValUnchecked+{-# INLINE isObject #-}++isFunction :: JSVal -> GHCJSPure Bool+isFunction v = GHCJSPure $ jsg1 "h$isFunction" v >>= fromJSValUnchecked+{-# INLINE isFunction #-}++isString :: JSVal -> GHCJSPure Bool+isString v = GHCJSPure $ jsg1 "h$isString" v >>= fromJSValUnchecked+{-# INLINE isString #-}++isBoolean :: JSVal -> GHCJSPure Bool+isBoolean v = GHCJSPure $ jsg1 "h$isBoolean" v >>= fromJSValUnchecked+{-# INLINE isBoolean #-}++isSymbol :: JSVal -> GHCJSPure Bool+isSymbol v = GHCJSPure $ jsg1 "h$isSymbol" v >>= fromJSValUnchecked+{-# INLINE isSymbol #-}++isNumber :: JSVal -> GHCJSPure Bool+isNumber v = GHCJSPure $ jsg1 "h$isNumber" v >>= fromJSValUnchecked+{-# INLINE isNumber #-}++jsTypeOf :: JSVal -> GHCJSPure JSType+jsTypeOf v = GHCJSPure $ toEnum <$> (jsg1 "h$jsonTypeOf" v >>= fromJSValUnchecked)+{-# INLINE jsTypeOf #-}
+ src-ghc/GHCJS/Foreign/Internal.hs view
@@ -0,0 +1,67 @@+-----------------------------------------------------------------------------+--+-- Module      :  Language.Javascript.JSaddle.Value+-- Copyright   :  (c) Hamish Mackenzie+-- License     :  MIT+--+-- Maintainer  :  Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com>+--+-- |+--+-----------------------------------------------------------------------------+module GHCJS.Foreign.Internal (+    jsTrue+  , jsFalse+  , jsNull+  , toJSBool+--  , fromJSBool+  , jsUndefined+  , isTruthy+  , isNull+  , isUndefined+  , JSType(..)+) where++import Language.Javascript.JSaddle.Types (JSVal(..), GHCJSPure(..))+import Language.Javascript.JSaddle.Native.Internal+       (valueToBool)+import Data.Typeable (Typeable)+import GHCJS.Prim (isNull, isUndefined)+import System.IO.Unsafe (unsafePerformIO)+import Data.IORef (newIORef)++jsTrue :: JSVal+jsTrue = JSVal . unsafePerformIO $ newIORef 3+{-# NOINLINE jsTrue #-}++jsFalse :: JSVal+jsFalse = JSVal . unsafePerformIO $ newIORef 2+{-# NOINLINE jsFalse #-}++jsNull :: JSVal+jsNull = JSVal . unsafePerformIO $ newIORef 0+{-# NOINLINE jsNull #-}++toJSBool :: Bool -> JSVal+toJSBool b = JSVal . unsafePerformIO . newIORef $ if b then 3 else 2+{-# NOINLINE toJSBool #-}++jsUndefined :: JSVal+jsUndefined = JSVal . unsafePerformIO $ newIORef 1+{-# NOINLINE jsUndefined #-}++isTruthy :: JSVal -> GHCJSPure Bool+isTruthy = GHCJSPure . valueToBool+{-# INLINE isTruthy #-}++-- types returned by JS typeof operator+data JSType = Undefined+            | Object+            | Boolean+            | Number+            | String+            | Symbol+            | Function+            | Other    -- ^ implementation dependent+            deriving (Show, Eq, Ord, Enum, Typeable)+
+ src-ghc/GHCJS/Internal/Types.hs view
@@ -0,0 +1,16 @@+module GHCJS.Internal.Types ( IsJSVal(..)+                            , jsval+                            , MutabilityType(..)+                            , Mutable+                            , Immutable+                            , IsItMutable(..)+                            , Mutability+                            ) where++import Language.Javascript.JSaddle.Types+import Language.Javascript.JSaddle.Native.Internal (stringToValue)++instance IsJSVal JSString where+  jsval_ a = GHCJSPure $ stringToValue a+  {-# INLINE jsval_ #-}+
+ src-ghc/GHCJS/Marshal.hs view
@@ -0,0 +1,169 @@+{-# LANGUAGE ScopedTypeVariables,+             FlexibleContexts,+             FlexibleInstances,+             OverloadedStrings,+             TupleSections,+             LambdaCase #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}++module GHCJS.Marshal ( FromJSVal(..)+                     , ToJSVal(..)+                     , toJSVal_aeson+                     , toJSVal_pure+                     ) where++import           Control.Monad (join)+import           Control.Monad.Trans.Maybe (MaybeT(..), runMaybeT)++import qualified Data.Aeson as AE+import           Data.Int (Int8, Int16, Int32)+import           Data.Text (Text)+import           Data.Word (Word8, Word16, Word32, Word)++import           GHC.Prim++import           Language.Javascript.JSaddle.Types (JSM, JSVal, SomeJSArray(..), ghcjsPure)+import           Language.Javascript.JSaddle.Native.Internal+                 (valueToJSONValue, jsonValueToValue, valueToNumber)++import           GHCJS.Types (JSString, isUndefined, isNull)+import           GHCJS.Foreign.Internal (isTruthy)+import           GHCJS.Marshal.Pure ()++import           JavaScript.Array (fromListIO)+import qualified JavaScript.Array as A (read)++import           GHCJS.Marshal.Internal++instance FromJSVal JSVal where+  fromJSValUnchecked x = return x+  {-# INLINE fromJSValUnchecked #-}+  fromJSVal = return . Just+  {-# INLINE fromJSVal #-}+instance FromJSVal () where+  fromJSValUnchecked = fromJSValUnchecked_pure+  {-# INLINE fromJSValUnchecked #-}+  fromJSVal = fromJSVal_pure+--    {-# INLINE fromJSVal #-}+instance FromJSVal Bool where+    fromJSValUnchecked = ghcjsPure . isTruthy+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap Just . ghcjsPure . isTruthy+    {-# INLINE fromJSVal #-}+instance FromJSVal Int where+    fromJSValUnchecked = fmap round . valueToNumber+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap (Just . round) . valueToNumber+    {-# INLINE fromJSVal #-}+instance FromJSVal Int8 where+    fromJSValUnchecked = fmap round . valueToNumber+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap (Just . round) . valueToNumber+    {-# INLINE fromJSVal #-}+instance FromJSVal Int16 where+    fromJSValUnchecked = fmap round . valueToNumber+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap (Just . round) . valueToNumber+    {-# INLINE fromJSVal #-}+instance FromJSVal Int32 where+    fromJSValUnchecked = fmap round . valueToNumber+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap (Just . round) . valueToNumber+    {-# INLINE fromJSVal #-}+instance FromJSVal Word where+    fromJSValUnchecked = fmap round . valueToNumber+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap (Just . round) . valueToNumber+    {-# INLINE fromJSVal #-}+instance FromJSVal Word8 where+    fromJSValUnchecked = fmap round . valueToNumber+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap (Just . round) . valueToNumber+    {-# INLINE fromJSVal #-}+instance FromJSVal Word16 where+    fromJSValUnchecked = fmap round . valueToNumber+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap (Just . round) . valueToNumber+    {-# INLINE fromJSVal #-}+instance FromJSVal Word32 where+    fromJSValUnchecked = fmap round . valueToNumber+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap (Just . round) . valueToNumber+    {-# INLINE fromJSVal #-}+instance FromJSVal Float where+    fromJSValUnchecked = fmap realToFrac . valueToNumber+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap (Just . realToFrac) . valueToNumber+    {-# INLINE fromJSVal #-}+instance FromJSVal Double where+    fromJSValUnchecked = valueToNumber+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap Just . valueToNumber+    {-# INLINE fromJSVal #-}+instance FromJSVal AE.Value where+    fromJSVal r = Just <$> valueToJSONValue r+    {-# INLINE fromJSVal #-}+instance (FromJSVal a, FromJSVal b) => FromJSVal (a,b) where+    fromJSVal r = runMaybeT $ (,) <$> jf r 0 <*> jf r 1+    {-# INLINE fromJSVal #-}+instance (FromJSVal a, FromJSVal b, FromJSVal c) => FromJSVal (a,b,c) where+    fromJSVal r = runMaybeT $ (,,) <$> jf r 0 <*> jf r 1 <*> jf r 2+    {-# INLINE fromJSVal #-}+instance (FromJSVal a, FromJSVal b, FromJSVal c, FromJSVal d) => FromJSVal (a,b,c,d) where+    fromJSVal r = runMaybeT $ (,,,) <$> jf r 0 <*> jf r 1 <*> jf r 2 <*> jf r 3+    {-# INLINE fromJSVal #-}+instance (FromJSVal a, FromJSVal b, FromJSVal c, FromJSVal d, FromJSVal e) => FromJSVal (a,b,c,d,e) where+    fromJSVal r = runMaybeT $ (,,,,) <$> jf r 0 <*> jf r 1 <*> jf r 2 <*> jf r 3 <*> jf r 4+    {-# INLINE fromJSVal #-}+instance (FromJSVal a, FromJSVal b, FromJSVal c, FromJSVal d, FromJSVal e, FromJSVal f) => FromJSVal (a,b,c,d,e,f) where+    fromJSVal r = runMaybeT $ (,,,,,) <$> jf r 0 <*> jf r 1 <*> jf r 2 <*> jf r 3 <*> jf r 4 <*> jf r 5+    {-# INLINE fromJSVal #-}+instance (FromJSVal a, FromJSVal b, FromJSVal c, FromJSVal d, FromJSVal e, FromJSVal f, FromJSVal g) => FromJSVal (a,b,c,d,e,f,g) where+    fromJSVal r = runMaybeT $ (,,,,,,) <$> jf r 0 <*> jf r 1 <*> jf r 2 <*> jf r 3 <*> jf r 4 <*> jf r 5 <*> jf r 6+    {-# INLINE fromJSVal #-}+instance (FromJSVal a, FromJSVal b, FromJSVal c, FromJSVal d, FromJSVal e, FromJSVal f, FromJSVal g, FromJSVal h) => FromJSVal (a,b,c,d,e,f,g,h) where+    fromJSVal r = runMaybeT $ (,,,,,,,) <$> jf r 0 <*> jf r 1 <*> jf r 2 <*> jf r 3 <*> jf r 4 <*> jf r 5 <*> jf r 6 <*> jf r 7+    {-# INLINE fromJSVal #-}++jf :: FromJSVal a => JSVal -> Int -> MaybeT JSM a+jf r n = MaybeT $ do+  r' <- A.read n (SomeJSArray r)+  ghcjsPure (isUndefined r) >>= \case+    True -> return Nothing+    False -> fromJSVal r'++instance (ToJSVal a, ToJSVal b) => ToJSVal (a,b) where+    toJSVal (a,b) = join $ arr2 <$> toJSVal a <*> toJSVal b+    {-# INLINE toJSVal #-}+instance (ToJSVal a, ToJSVal b, ToJSVal c) => ToJSVal (a,b,c) where+    toJSVal (a,b,c) = join $ arr3 <$> toJSVal a <*> toJSVal b <*> toJSVal c+    {-# INLINE toJSVal #-}+instance (ToJSVal a, ToJSVal b, ToJSVal c, ToJSVal d) => ToJSVal (a,b,c,d) where+    toJSVal (a,b,c,d) = join $ arr4 <$> toJSVal a <*> toJSVal b <*> toJSVal c <*> toJSVal d+    {-# INLINE toJSVal #-}+instance (ToJSVal a, ToJSVal b, ToJSVal c, ToJSVal d, ToJSVal e) => ToJSVal (a,b,c,d,e) where+    toJSVal (a,b,c,d,e) = join $ arr5 <$> toJSVal a <*> toJSVal b <*> toJSVal c <*> toJSVal d <*> toJSVal e+    {-# INLINE toJSVal #-}+instance (ToJSVal a, ToJSVal b, ToJSVal c, ToJSVal d, ToJSVal e, ToJSVal f) => ToJSVal (a,b,c,d,e,f) where+    toJSVal (a,b,c,d,e,f) = join $ arr6 <$> toJSVal a <*> toJSVal b <*> toJSVal c <*> toJSVal d <*> toJSVal e <*> toJSVal f+    {-# INLINE toJSVal #-}+instance (ToJSVal a, ToJSVal b, ToJSVal c, ToJSVal d, ToJSVal e, ToJSVal f, ToJSVal g) => ToJSVal (a,b,c,d,e,f,g) where+    toJSVal (a,b,c,d,e,f,g) = join $ arr7 <$> toJSVal a <*> toJSVal b <*> toJSVal c <*> toJSVal d <*> toJSVal e <*> toJSVal f <*> toJSVal g+    {-# INLINE toJSVal #-}++arr2 :: JSVal -> JSVal -> JSM JSVal+arr2 a b           = coerce <$> fromListIO [a,b]+arr3 :: JSVal -> JSVal -> JSVal -> JSM JSVal+arr3 a b c         = coerce <$> fromListIO [a,b,c]+arr4 :: JSVal -> JSVal -> JSVal -> JSVal -> JSM JSVal+arr4 a b c d       = coerce <$> fromListIO [a,b,c,d]+arr5 :: JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> JSM JSVal+arr5 a b c d e     = coerce <$> fromListIO [a,b,c,d,e]+arr6 :: JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> JSM JSVal+arr6 a b c d e f   = coerce <$> fromListIO [a,b,c,d,e,f]+arr7 :: JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> JSVal -> JSM JSVal+arr7 a b c d e f g = coerce <$> fromListIO [a,b,c,d,e,f,g]++toJSVal_aeson :: AE.ToJSON a => a -> JSM JSVal+toJSVal_aeson = jsonValueToValue . AE.toJSON+
+ src-ghc/GHCJS/Marshal/Internal.hs view
@@ -0,0 +1,282 @@+{-# LANGUAGE CPP, ScopedTypeVariables, DeriveDataTypeable, DefaultSignatures,+             TypeOperators, TupleSections, FlexibleContexts, FlexibleInstances,+             LambdaCase+  #-}++module GHCJS.Marshal.Internal ( FromJSVal(..)+                              , ToJSVal(..)+                              , PToJSVal(..)+                              , PFromJSVal(..)+                              , Purity(..)+                              , toJSVal_generic+                              , fromJSVal_generic+                              , toJSVal_pure+                              , fromJSVal_pure+                              , fromJSValUnchecked_pure+                              ) where++import           Control.Applicative+import           Control.Monad++import           Data.Data+import           Data.Maybe+import           Data.Coerce (coerce)+import qualified Data.Text as T (pack)++import           GHC.Generics++import qualified GHCJS.Prim.Internal        as Prim+import qualified GHCJS.Foreign.Internal     as F+import           GHCJS.Types++import qualified Data.JSString.Internal.Type as JSS++import qualified JavaScript.Object.Internal as OI (Object(..), create, setProp, getProp)+import qualified JavaScript.Array.Internal as AI (SomeJSArray(..), create, push, read, fromListIO, toListIO)++import           Language.Javascript.JSaddle.Types (JSM, MutableJSArray, GHCJSPure(..), ghcjsPure, ghcjsPureMap, JSaddleHasCallStack)+import           Language.Javascript.JSaddle.String (textToStr)++data Purity = PureShared    -- ^ conversion is pure even if the original value is shared+            | PureExclusive -- ^ conversion is pure if the we only convert once+  deriving (Eq, Ord, Typeable, Data)++class PToJSVal a where+--  type PureOut a :: Purity+  pToJSVal :: a -> JSVal++class PFromJSVal a where+--  type PureIn a :: Purity+  pFromJSVal :: JSVal -> a++class ToJSVal a where+  toJSVal :: a -> JSM JSVal++  toJSValListOf :: [a] -> JSM JSVal+  toJSValListOf = fmap coerce . AI.fromListIO <=< mapM toJSVal++  -- default toJSVal :: PToJSVal a => a -> JSM (JSVal a)+  -- toJSVal x = return (pToJSVal x)++  default toJSVal :: (Generic a, GToJSVal (Rep a ())) => a -> JSM JSVal+  toJSVal = toJSVal_generic id++fromJustWithStack :: JSaddleHasCallStack => Maybe a -> a+fromJustWithStack Nothing = error "fromJSValUnchecked: fromJSVal result was Nothing"+fromJustWithStack (Just x) = x++class FromJSVal a where+  fromJSVal :: JSVal -> JSM (Maybe a)++#if MIN_VERSION_base(4,9,0) && defined(JSADDLE_HAS_CALL_STACK)+  fromJSValUnchecked :: JSaddleHasCallStack => JSVal -> JSM a+#ifdef CHECK_UNCHECKED+  fromJSValUnchecked v = fromJSVal v >>= \case+                             Nothing -> error "fromJSValUnchecked: fromJSVal result was Nothing"+                             Just x  -> return x+#else+  fromJSValUnchecked = fmap fromJustWithStack . fromJSVal+#endif+#else+  fromJSValUnchecked :: JSVal -> JSM a+  fromJSValUnchecked = fmap fromJust . fromJSVal+#endif+  {-# INLINE fromJSValUnchecked #-}++  fromJSValListOf :: JSVal -> JSM (Maybe [a])+  fromJSValListOf = fmap sequence . (mapM fromJSVal <=< AI.toListIO . coerce) -- fixme should check that it's an array++#if MIN_VERSION_base(4,9,0) && defined(JSADDLE_HAS_CALL_STACK)+  fromJSValUncheckedListOf :: JSaddleHasCallStack => JSVal -> JSM [a]+#else+  fromJSValUncheckedListOf :: JSVal -> JSM [a]+#endif+  fromJSValUncheckedListOf = mapM fromJSValUnchecked <=< AI.toListIO . coerce++  -- default fromJSVal :: PFromJSVal a => JSVal a -> JSM (Maybe a)+  -- fromJSVal x = return (Just (pFromJSVal x))++  default fromJSVal :: (Generic a, GFromJSVal (Rep a ())) => JSVal -> JSM (Maybe a)+  fromJSVal = fromJSVal_generic id++  -- default fromJSValUnchecked :: PFromJSVal a => a -> IO a+  -- fromJSValUnchecked x = return (pFromJSVal x)++-- -----------------------------------------------------------------------------++class GToJSVal a where+  gToJSVal :: (String -> String) -> Bool -> a -> JSM JSVal++class GToJSProp a where+  gToJSProp :: (String -> String) -> JSVal -> a -> JSM ()++class GToJSArr a where+  gToJSArr :: (String -> String) -> MutableJSArray -> a -> JSM ()++instance (ToJSVal b) => GToJSVal (K1 a b c) where+  gToJSVal _ _ (K1 x) = toJSVal x++instance GToJSVal p => GToJSVal (Par1 p) where+  gToJSVal f b (Par1 p) = gToJSVal f b p++instance GToJSVal (f p) => GToJSVal (Rec1 f p) where+  gToJSVal f b (Rec1 x) = gToJSVal f b x++instance (GToJSVal (a p), GToJSVal (b p)) => GToJSVal ((a :+: b) p) where+  gToJSVal f _ (L1 x) = gToJSVal f True x+  gToJSVal f _ (R1 x) = gToJSVal f True x++instance (Datatype c, GToJSVal (a p)) => GToJSVal (M1 D c a p) where+  gToJSVal f b m@(M1 x) = gToJSVal f b x++instance (Constructor c, GToJSVal (a p)) => GToJSVal (M1 C c a p) where+  gToJSVal f True m@(M1 x) = do+    obj@(OI.Object obj') <- OI.create+    v   <- gToJSVal f (conIsRecord m) x+    OI.setProp (packJSS . f $ conName m) v obj+    return obj'+  gToJSVal f _ m@(M1 x) = gToJSVal f (conIsRecord m) x++instance (GToJSArr (a p), GToJSArr (b p), GToJSProp (a p), GToJSProp (b p)) => GToJSVal ((a :*: b) p) where+  gToJSVal f True xy = do+    (OI.Object obj') <- OI.create+    gToJSProp f obj' xy+    return obj'+  gToJSVal f False xy = do+    arr@(AI.SomeJSArray arr') <- AI.create+    gToJSArr f arr xy+    return arr'++instance GToJSVal (a p) => GToJSVal (M1 S c a p) where+  gToJSVal f b (M1 x) = gToJSVal f b x++instance (GToJSProp (a p), GToJSProp (b p)) => GToJSProp ((a :*: b) p) where+  gToJSProp f o (x :*: y) = gToJSProp f o x >> gToJSProp f o y++instance (Selector c, GToJSVal (a p)) => GToJSProp (M1 S c a p) where+  gToJSProp f o m@(M1 x) = do+    r <- gToJSVal f False x+    OI.setProp (packJSS . f $ selName m) r (OI.Object o)++instance (GToJSArr (a p), GToJSArr (b p)) => GToJSArr ((a :*: b) p) where+  gToJSArr f a (x :*: y) = gToJSArr f a x >> gToJSArr f a y++instance GToJSVal (a p) => GToJSArr (M1 S c a p) where+  gToJSArr f a (M1 x) = do+    r <- gToJSVal f False x+    AI.push r a++instance GToJSVal (V1 p) where+  gToJSVal _ _ _ = return Prim.jsNull++instance GToJSVal (U1 p) where+  gToJSVal _ _ _ = return F.jsTrue++toJSVal_generic :: forall a . (Generic a, GToJSVal (Rep a ()))+                => (String -> String) -> a -> JSM JSVal+toJSVal_generic f x = gToJSVal f False (from x :: Rep a ())++-- -----------------------------------------------------------------------------++class GFromJSVal a where+  gFromJSVal :: (String -> String) -> Bool -> JSVal -> JSM (Maybe a)++class GFromJSProp a where+  gFromJSProp :: (String -> String) -> JSVal -> JSM (Maybe a)++class GFromJSArr a where+  gFromJSArr :: (String -> String) -> MutableJSArray -> Int -> JSM (Maybe (a,Int))++instance FromJSVal b => GFromJSVal (K1 a b c) where+  gFromJSVal _ _ r = fmap K1 <$> fromJSVal r++instance GFromJSVal p => GFromJSVal (Par1 p) where+  gFromJSVal f b r = gFromJSVal f b r++instance GFromJSVal (f p) => GFromJSVal (Rec1 f p) where+  gFromJSVal f b r = gFromJSVal f b r++instance (GFromJSVal (a p), GFromJSVal (b p)) => GFromJSVal ((a :+: b) p) where+  gFromJSVal f b r = do+    l <- gFromJSVal f True r+    case l of+      Just x  -> return (L1 <$> Just x)+      Nothing -> fmap R1 <$> gFromJSVal f True r++instance (Datatype c, GFromJSVal (a p)) => GFromJSVal (M1 D c a p) where+  gFromJSVal f b r = fmap M1 <$> gFromJSVal f b r++instance forall c a p . (Constructor c, GFromJSVal (a p)) => GFromJSVal (M1 C c a p) where+  gFromJSVal f True r = do+    r' <- OI.getProp (packJSS . f $ conName (undefined :: M1 C c a p)) (OI.Object r)+    ghcjsPure (isUndefined r') >>= \case+      True -> return Nothing+      False -> fmap M1 <$> gFromJSVal f (conIsRecord (undefined :: M1 C c a p)) r'+  gFromJSVal f _ r = fmap M1 <$> gFromJSVal f (conIsRecord (undefined :: M1 C c a p)) r++instance (GFromJSArr (a p), GFromJSArr (b p), GFromJSProp (a p), GFromJSProp (b p)) => GFromJSVal ((a :*: b) p) where+  gFromJSVal f True  r = gFromJSProp f r+  gFromJSVal f False r = fmap fst <$> gFromJSArr f (AI.SomeJSArray r) 0++instance GFromJSVal (a p) => GFromJSVal (M1 S c a p) where+  gFromJSVal f b r = fmap M1 <$> gFromJSVal f b r++instance (GFromJSProp (a p), GFromJSProp (b p)) => GFromJSProp ((a :*: b) p) where+  gFromJSProp f r = do+    a <- gFromJSProp f r+    case a of+      Nothing -> return Nothing+      Just a' -> fmap (a':*:) <$> gFromJSProp f r++instance forall c a p . (Selector c, GFromJSVal (a p)) => GFromJSProp (M1 S c a p) where+  gFromJSProp f o = do+    p <- OI.getProp (packJSS . f $ selName (undefined :: M1 S c a p)) (OI.Object o)+    ghcjsPure (isUndefined p) >>= \case+      True -> return Nothing+      False -> fmap M1 <$> gFromJSVal f False p++instance (GFromJSArr (a p), GFromJSArr (b p)) => GFromJSArr ((a :*: b) p) where+  gFromJSArr f r _n = do+    a <- gFromJSArr f r 0+    case a of+      Just (a',an) -> do+        b <- gFromJSArr f r an+        case b of+          Just (b',bn) -> return (Just (a' :*: b',bn))+          _            -> return Nothing++instance (GFromJSVal (a p)) => GFromJSArr (M1 S c a p) where+  gFromJSArr f o n = do+    r <- AI.read n o+    ghcjsPure (isUndefined r) >>= \case+      True -> return Nothing+      False -> fmap ((,n+1) . M1) <$> gFromJSVal f False r++instance GFromJSVal (V1 p) where+  gFromJSVal _ _ _ = return Nothing++instance GFromJSVal (U1 p) where+  gFromJSVal _ _ _ = return (Just U1)++fromJSVal_generic :: forall a . (Generic a, GFromJSVal (Rep a ()))+                => (String -> String) -> JSVal -> JSM (Maybe a)+fromJSVal_generic f x = fmap to <$> (gFromJSVal f False x :: JSM (Maybe (Rep a ())))++-- -----------------------------------------------------------------------------++fromJSVal_pure :: PFromJSVal a => JSVal -> JSM (Maybe a)+fromJSVal_pure = return . Just . pFromJSVal+{-# INLINE fromJSVal_pure #-}++fromJSValUnchecked_pure :: PFromJSVal a => JSVal -> JSM a+fromJSValUnchecked_pure = return . pFromJSVal+{-# INLINE fromJSValUnchecked_pure #-}++toJSVal_pure :: PToJSVal a => a -> JSM JSVal+toJSVal_pure = return . pToJSVal+{-# INLINE toJSVal_pure #-}++-- -----------------------------------------------------------------------------++packJSS :: String -> JSString+packJSS = textToStr . T.pack
+ src-ghc/GHCJS/Marshal/Pure.hs view
@@ -0,0 +1,19 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+module GHCJS.Marshal.Pure ( PFromJSVal(..)+                          , PToJSVal(..)+                          ) where++import           GHCJS.Types+import           GHCJS.Foreign.Internal (jsFalse, jsTrue)+import           GHCJS.Marshal.Internal++instance PFromJSVal JSVal where pFromJSVal = id+                                {-# INLINE pFromJSVal #-}+instance PFromJSVal ()    where pFromJSVal _ = ()+                                {-# INLINE pFromJSVal #-}++instance PToJSVal JSVal     where pToJSVal = id+                                  {-# INLINE pToJSVal #-}+instance PToJSVal Bool      where pToJSVal True     = jsTrue+                                  pToJSVal False    = jsFalse+                                  {-# INLINE pToJSVal #-}
+ src-ghc/GHCJS/Prim.hs view
@@ -0,0 +1,84 @@+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}++module GHCJS.Prim ( module GHCJS.Prim.Internal+                  , fromJSString+                  , toJSString+                  , isNull+                  , isUndefined+                  ) where++import           GHCJS.Prim.Internal+--import           Data.Int (Int64)+--import           Data.Typeable (Typeable)+--import           Unsafe.Coerce (unsafeCoerce)++--import           Data.Aeson (ToJSON(..), FromJSON(..))+import qualified Data.Text as T (unpack, pack)+import           Data.JSString.Text (textFromJSVal)++--import           GHC.Prim+--import qualified GHC.Exception as Ex+--import qualified GHC.Exts as Exts++import Language.Javascript.JSaddle.Types (JSVal(..), JSString(..), GHCJSPure(..), ghcjsPureMap)+import qualified Language.Javascript.JSaddle.Native.Internal as N+       (stringToValue, isNull, isUndefined)+{- | Low-level conversion utilities for packages that cannot+     depend on ghcjs-base+ -}++fromJSString :: JSVal -> GHCJSPure String+fromJSString = ghcjsPureMap T.unpack . textFromJSVal+{-# INLINE fromJSString #-}++toJSString :: String -> GHCJSPure JSVal+toJSString s = GHCJSPure $ N.stringToValue (JSString $ T.pack s)+{-# INLINE toJSString #-}++--fromJSArray :: JSVal -> IO [JSVal]+--fromJSArray = unsafeCoerce . js_fromJSArray+--{-# INLINE fromJSArray #-}+--+--toJSArray :: [JSVal] -> IO JSVal+--toJSArray = js_toJSArray . unsafeCoerce . seqList+--{-# INLINE toJSArray #-}+--+--{- | returns zero if the JSVal does not contain a number+-- -}+--fromJSInt :: JSVal -> Int+--fromJSInt = js_fromJSInt+--{-# INLINE fromJSInt #-}+--+--toJSInt :: Int -> JSVal+--toJSInt = js_toJSInt+--{-# INLINE toJSInt #-}+--++isNull :: JSVal -> GHCJSPure Bool+isNull = GHCJSPure . N.isNull+{-# INLINE isNull #-}++isUndefined :: JSVal -> GHCJSPure Bool+isUndefined = GHCJSPure . N.isUndefined+{-# INLINE isUndefined #-}++--getProp :: JSVal -> String -> IO JSVal+--getProp o p = js_getProp o (unsafeCoerce $ seqList p)+--{-# INLINE getProp #-}+--+--getProp' :: JSVal -> JSVal -> IO JSVal+--getProp' o p = js_getProp' o p+--{-# INLINE getProp' #-}+--+---- reduce the spine and all list elements to whnf+--seqList :: [a] -> [a]+--seqList xs = go xs `seq` xs+--  where go (x:xs) = x `seq` go xs+--        go []     = ()+--+--seqListSpine :: [a] -> [a]+--seqListSpine xs = go xs `seq` xs+--  where go (x:xs) = go xs+--        go []     = ()
+ src-ghc/GHCJS/Prim/Internal.hs view
@@ -0,0 +1,66 @@+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}++module GHCJS.Prim.Internal ( JSVal(..)+                           , JSValueRef+                           , JSException(..)+                           , WouldBlockException(..)+                           , mkJSException+                           , jsNull+                           ) where++import           Control.DeepSeq (NFData(..))+import           Data.Int (Int64)+import           Data.Typeable (Typeable)+import           Unsafe.Coerce (unsafeCoerce)++import qualified GHC.Exception as Ex+import Data.IORef (newIORef, IORef)+import System.IO.Unsafe (unsafePerformIO)++-- A reference to a particular JavaScript value inside the JavaScript context+type JSValueRef = Int64++{-+  JSVal is a boxed type that can be used as FFI+  argument or result.+-}+newtype JSVal = JSVal (IORef JSValueRef)++instance NFData JSVal where+  rnf x = x `seq` ()+++{-+  When a JavaScript exception is raised inside+  a safe or interruptible foreign call, it is converted+  to a JSException+ -}+data JSException = JSException JSVal String+  deriving (Typeable)++instance Ex.Exception JSException++instance Show JSException where+  show (JSException _ xs) = "JavaScript exception: " ++ xs++mkJSException :: JSVal -> IO JSException+mkJSException ref =+  return (JSException (unsafeCoerce ref) "")++jsNull :: JSVal+jsNull = JSVal . unsafePerformIO $ newIORef 0+{-# NOINLINE jsNull #-}++{- | If a synchronous thread tries to do something that can only+     be done asynchronously, and the thread is set up to not+     continue asynchronously, it receives this exception.+ -}+data WouldBlockException = WouldBlockException+  deriving (Typeable)++instance Show WouldBlockException where+  show _ = "thread would block"++instance Ex.Exception WouldBlockException+
+ src-ghc/GHCJS/Types.hs view
@@ -0,0 +1,60 @@+{-# LANGUAGE EmptyDataDecls #-}+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE BangPatterns #-}++module GHCJS.Types ( JSVal+                   , WouldBlockException(..)+                   , JSException(..)+                   , IsJSVal+                   , jsval+                   , isNull+                   , isUndefined+                   , nullRef+                   , JSString+                   , mkRef+                   , Ref#+--                   , toPtr+--                   , fromPtr+                   , JSRef+                   ) where++import Data.JSString.Internal.Type (JSString)+import GHCJS.Internal.Types++import GHCJS.Prim++import GHC.Int+import GHC.Types+import GHC.Prim+import GHC.Ptr+import GHC.IORef+import GHC.IO.Unsafe (unsafePerformIO)++import Control.DeepSeq+import Unsafe.Coerce++type Ref# = IORef Int64++mkRef :: Ref# -> JSVal+mkRef = JSVal+{-# INLINE mkRef #-}++nullRef :: JSVal+nullRef = JSVal . unsafePerformIO $ newIORef 0+{-# NOINLINE nullRef #-}++--toPtr :: JSVal -> Ptr a+--toPtr (JSVal x) = unsafeCoerce (Ptr' x 0#)+--{-# INLINE toPtr #-}+--+--fromPtr :: Ptr a -> JSVal+--fromPtr p = js_ptrVal p+--{-# INLINE fromPtr #-}+--+--data Ptr' a = Ptr' ByteArray# Int#++-- | This is a deprecated copmatibility wrapper for the old JSRef type.+--+-- See https://github.com/ghcjs/ghcjs/issues/421+type JSRef a = JSVal+{-# DEPRECATED JSRef "Use JSVal instead, or a more specific newtype wrapper of JSVal " #-}
+ src-ghc/JavaScript/Array.hs view
@@ -0,0 +1,134 @@+-----------------------------------------------------------------------------+--+-- Module      :  JavaScript.Array+-- Copyright   :  (c) Hamish Mackenzie+-- License     :  MIT+--+-- Maintainer  :  Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com>+--+-- | Interface to JavaScript array+--+-----------------------------------------------------------------------------+module JavaScript.Array+    ( SomeJSArray(..)+    , JSArray+    , MutableJSArray+    , create+    , length+    , lengthIO+    , null+    , fromList+    , fromListIO+    , toList+    , toListIO+    , index, (!)+    , read+    , write+    , append+    , push+    , pop+    , unshift+    , shift+    , reverse+    , take+    , takeIO+    , drop+    , dropIO+    , slice+    , sliceIO+    , freeze+    , unsafeFreeze+    , thaw+    , unsafeThaw+    ) where++import Prelude hiding (length, drop, read, take, reverse, null)+import Control.Monad (void)+import Language.Javascript.JSaddle.Types+       (JSM, JSVal, SomeJSArray(..), JSArray,+        MutableJSArray, GHCJSPure(..))+import Control.Lens.Operators ((^.))+import Language.Javascript.JSaddle.Object (js2, js0, (<##), js1, js)+import Language.Javascript.JSaddle.Value (valToNumber)+import JavaScript.Array.Internal (create, fromList, fromListIO, toList, toListIO, index, read, push)++length :: SomeJSArray m -> GHCJSPure Int+length = GHCJSPure . lengthIO+{-# INLINE length #-}++lengthIO :: SomeJSArray m -> JSM Int+lengthIO (SomeJSArray x) = round <$> (x ^. js "length" >>= valToNumber)+{-# INLINE lengthIO #-}++null :: SomeJSArray m -> GHCJSPure Bool+null = GHCJSPure . fmap (== 0) . lengthIO+{-# INLINE null #-}++append :: SomeJSArray m -> SomeJSArray m -> JSM (SomeJSArray m1)+append (SomeJSArray x) (SomeJSArray y) = SomeJSArray <$> x ^. js1 "concat" y+{-# INLINE append #-}++write :: Int -> JSVal -> MutableJSArray -> JSM ()+write n e (SomeJSArray x) = void $ (x <## n) e+{-# INLINE write #-}++pop :: MutableJSArray -> JSM JSVal+pop (SomeJSArray x) = x ^. js0 "pop"+{-# INLINE pop #-}++unshift :: JSVal -> MutableJSArray -> JSM ()+unshift e (SomeJSArray x) = void $ x ^. js1 "unshift" e+{-# INLINE unshift #-}++shift :: MutableJSArray -> JSM JSVal+shift (SomeJSArray x) = x ^. js0 "shift"+{-# INLINE shift #-}++reverse :: MutableJSArray -> JSM ()+reverse (SomeJSArray x) = void $ x ^. js0 "reverse"+{-# INLINE reverse #-}++take :: Int -> SomeJSArray m -> GHCJSPure (SomeJSArray m1)+take n = GHCJSPure . takeIO n+{-# INLINE take #-}++takeIO :: Int -> SomeJSArray m -> JSM (SomeJSArray m1)+takeIO n (SomeJSArray x) = SomeJSArray <$> x ^. js2 "slice" (0::Int) n+{-# INLINE takeIO #-}++drop :: Int -> SomeJSArray m -> GHCJSPure (SomeJSArray m1)+drop n = GHCJSPure . dropIO n+{-# INLINE drop #-}++dropIO :: Int -> SomeJSArray m -> JSM (SomeJSArray m1)+dropIO n (SomeJSArray x) = SomeJSArray <$> x ^. js1 "slice1" n+{-# INLINE dropIO #-}++slice :: Int -> Int -> JSArray -> GHCJSPure (SomeJSArray m1)+slice s n = GHCJSPure . sliceIO s n+{-# INLINE slice #-}++sliceIO :: Int -> Int -> JSArray -> JSM (SomeJSArray m1)+sliceIO s n (SomeJSArray x) = SomeJSArray <$> x ^. js2 "slice" s n+{-# INLINE sliceIO #-}++freeze :: MutableJSArray -> JSM JSArray+freeze (SomeJSArray x) = SomeJSArray <$> x ^. js1 "slice" (0::Int)+{-# INLINE freeze #-}++unsafeFreeze :: MutableJSArray -> JSM JSArray+unsafeFreeze (SomeJSArray x) = pure (SomeJSArray x)+{-# INLINE unsafeFreeze #-}++thaw :: JSArray -> JSM MutableJSArray+thaw (SomeJSArray x) = SomeJSArray <$> x ^. js1 "slice" (0::Int)+{-# INLINE thaw #-}++unsafeThaw :: JSArray -> JSM MutableJSArray+unsafeThaw (SomeJSArray x) = pure (SomeJSArray x)+{-# INLINE unsafeThaw #-}++(!) :: JSArray -> Int -> GHCJSPure JSVal+x ! n = GHCJSPure $ read n x+{-# INLINE (!) #-}+
+ src-ghc/JavaScript/Array/Internal.hs view
@@ -0,0 +1,59 @@+{-# LANGUAGE OverloadedStrings #-}+module JavaScript.Array.Internal+    ( SomeJSArray(..)+    , JSArray+    , MutableJSArray+    , STJSArray+    , create+    , fromList+    , fromListIO+    , toList+    , toListIO+    , index+    , read+    , push+    ) where++import Prelude hiding(read)+import Control.Monad (void)+import GHCJS.Types (JSVal)+import Data.JSString.Internal.Type (JSString(..))+import Language.Javascript.JSaddle.Types (JSM, SomeJSArray(..), JSArray, MutableJSArray, STJSArray, Object(..), GHCJSPure(..))+import Language.Javascript.JSaddle.Native.Internal+       (newArray, getPropertyByName, getPropertyAtIndex, callAsFunction, valueToNumber)++create :: JSM MutableJSArray+create = SomeJSArray <$> newArray []+{-# INLINE create #-}++fromList :: [JSVal] -> GHCJSPure (SomeJSArray m)+fromList = GHCJSPure . fromListIO+{-# INLINE fromList #-}++fromListIO :: [JSVal] -> JSM (SomeJSArray m)+fromListIO xs = SomeJSArray <$> newArray xs+{-# INLINE fromListIO #-}++toList :: SomeJSArray m -> GHCJSPure [JSVal]+toList = GHCJSPure . toListIO+{-# INLINE toList #-}++toListIO :: SomeJSArray m -> JSM [JSVal]+toListIO (SomeJSArray x) = do+    len <- getPropertyByName (JSString "length") (Object x) >>= valueToNumber+    mapM (`getPropertyAtIndex` Object x) [0..round len - 1]+{-# INLINE toListIO #-}++index :: Int -> SomeJSArray m -> GHCJSPure JSVal+index n = GHCJSPure . read n+{-# INLINE index #-}++read :: Int -> SomeJSArray m -> JSM JSVal+read n (SomeJSArray x) = getPropertyAtIndex n $ Object x+{-# INLINE read #-}++push :: JSVal -> MutableJSArray -> JSM ()+push e (SomeJSArray x) = void $ do+    f <- getPropertyByName (JSString "push") (Object x)+    void $ callAsFunction (Object f) (Object x) [e]+{-# INLINE push #-}
+ src-ghc/JavaScript/Object.hs view
@@ -0,0 +1,10 @@+module JavaScript.Object ( Object+                         , create+                         , getProp, unsafeGetProp+                         , setProp, unsafeSetProp+                         -- , allProps+                         , listProps+                         -- , isInstanceOf+                         ) where++import JavaScript.Object.Internal
+ src-ghc/JavaScript/Object/Internal.hs view
@@ -0,0 +1,53 @@+module JavaScript.Object.Internal+    ( Object(..)+    , create+--    , allProps+    , listProps+    , getProp+    , unsafeGetProp+    , setProp+    , unsafeSetProp+--    , isInstanceOf+    ) where++import Language.Javascript.JSaddle.Types (JSM, JSVal, Object(..), JSString)+import Language.Javascript.JSaddle.Native.Internal+       (newEmptyObject, propertyNames, getPropertyByName, setPropertyByName)++-- | create an empty object+create :: JSM Object+create = newEmptyObject+{-# INLINE create #-}++--allProps :: Object -> JSM JSArray+--allProps o = js_allProps o+--{-# INLINE allProps #-}++listProps :: Object -> JSM [JSString]+listProps = propertyNames+{-# INLINE listProps #-}++{- | get a property from an object. If accessing the property results in+     an exception, the exception is converted to a JSException. Since exception+     handling code prevents some optimizations in some JS engines, you may want+     to use unsafeGetProp instead+ -}+getProp :: JSString -> Object -> JSM JSVal+getProp = unsafeGetProp+{-# INLINE getProp #-}++unsafeGetProp :: JSString -> Object -> JSM JSVal+unsafeGetProp = getPropertyByName+{-# INLINE unsafeGetProp #-}++setProp :: JSString -> JSVal -> Object -> JSM ()+setProp = unsafeSetProp+{-# INLINE setProp #-}++unsafeSetProp :: JSString -> JSVal -> Object -> JSM ()+unsafeSetProp = setPropertyByName+{-# INLINE unsafeSetProp #-}++--isInstanceOf :: Object -> JSVal -> GHCJSPure Bool+--isInstanceOf o s = js_isInstanceOf o s+--{-# INLINE isInstanceOf #-}
+ src-ghc/JavaScript/TypedArray.hs view
@@ -0,0 +1,19 @@+module JavaScript.TypedArray+    ( TypedArray(..)+    , Int8Array, Int16Array, Int32Array+    , Uint8Array, Uint16Array, Uint32Array+    , Uint8ClampedArray, Float32Array, Float64Array+    , length+    , byteLength+    , byteOffset+    , buffer+    , subarray+    , set+    , unsafeSet+    ) where++import Prelude ()++import JavaScript.TypedArray.Internal+import JavaScript.TypedArray.Internal.Types+
+ src-ghc/JavaScript/TypedArray/ArrayBuffer.hs view
@@ -0,0 +1,51 @@+module JavaScript.TypedArray.ArrayBuffer+    ( ArrayBuffer+    , MutableArrayBuffer+    , freeze, unsafeFreeze+    , thaw, unsafeThaw+    , byteLengthIO+    ) where++import Control.Lens.Operators ((^.))++import GHCJS.Marshal (fromJSValUnchecked)++import Language.Javascript.JSaddle.Types (JSM)+import Language.Javascript.JSaddle.Object (jsg, new, js, js1, js2)+import JavaScript.TypedArray.ArrayBuffer.Internal++create :: Int -> JSM MutableArrayBuffer+create n = SomeArrayBuffer <$> new (jsg "ArrayBuffer") [n]+{-# INLINE create #-}++{- | Create an immutable 'ArrayBuffer' by copying a 'MutableArrayBuffer' -}+freeze :: MutableArrayBuffer -> JSM ArrayBuffer+freeze (SomeArrayBuffer b) = SomeArrayBuffer <$> b ^. js1 "slice" (0 :: Int)+{-# INLINE freeze #-}++{- | Create an immutable 'ArrayBuffer' from a 'MutableArrayBuffer' without+     copying. The result shares the buffer with the argument,  not modify+     the data in the 'MutableArrayBuffer' after freezing+ -}+unsafeFreeze :: MutableArrayBuffer -> JSM ArrayBuffer+unsafeFreeze (SomeArrayBuffer b) = pure (SomeArrayBuffer b)+{-# INLINE unsafeFreeze #-}++{- | Create a 'MutableArrayBuffer' by copying an immutable 'ArrayBuffer' -}+thaw :: ArrayBuffer -> JSM MutableArrayBuffer+thaw (SomeArrayBuffer b) = SomeArrayBuffer <$> b ^. js1 "slice" (0 :: Int)+{-# INLINE thaw #-}++unsafeThaw :: ArrayBuffer -> JSM MutableArrayBuffer+unsafeThaw (SomeArrayBuffer b) = pure (SomeArrayBuffer b)+{-# INLINE unsafeThaw #-}++sliceIO :: Int -> Maybe Int -> SomeArrayBuffer any -> JSM (SomeArrayBuffer any)+sliceIO begin (Just end) (SomeArrayBuffer b) = SomeArrayBuffer <$> b ^. js2 "slice" begin end+sliceIO begin _          (SomeArrayBuffer b) = SomeArrayBuffer <$> b ^. js1 "slice" begin+{-# INLINE sliceIO #-}++byteLengthIO :: SomeArrayBuffer any -> JSM Int+byteLengthIO (SomeArrayBuffer b) = b ^. js "byteLength" >>= fromJSValUnchecked+{-# INLINE byteLengthIO #-}+
+ src-ghc/JavaScript/TypedArray/ArrayBuffer/Internal.hs view
@@ -0,0 +1,33 @@+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE UnboxedTuples #-}+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE PolyKinds #-}+{-# LANGUAGE DeriveDataTypeable #-}++module JavaScript.TypedArray.ArrayBuffer.Internal where++import GHCJS.Types++import GHCJS.Internal.Types+import GHCJS.Marshal.Pure++import GHC.Exts (State#)++import Data.Typeable++newtype SomeArrayBuffer (a :: MutabilityType s) =+  SomeArrayBuffer JSVal deriving Typeable+instance IsJSVal (SomeArrayBuffer m)++type ArrayBuffer           = SomeArrayBuffer Immutable+type MutableArrayBuffer    = SomeArrayBuffer Mutable+type STArrayBuffer s       = SomeArrayBuffer (STMutable s)++instance PToJSVal MutableArrayBuffer where+  pToJSVal (SomeArrayBuffer b) = b+instance PFromJSVal MutableArrayBuffer where+  pFromJSVal = SomeArrayBuffer
+ src-ghc/JavaScript/TypedArray/ArrayBuffer/Type.hs view
@@ -0,0 +1,6 @@+module JavaScript.TypedArray.ArrayBuffer.Type where++import GHCJS.Prim+++
+ src-ghc/JavaScript/TypedArray/DataView/Internal.hs view
@@ -0,0 +1,146 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE ForeignFunctionInterface #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE UnboxedTuples #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE KindSignatures #-}+{-# LANGUAGE PolyKinds #-}++module JavaScript.TypedArray.DataView.Internal where++import Data.Int+import Data.Typeable+import Data.Word++import GHC.Exts ( State# )++import GHCJS.Prim+import GHCJS.Internal.Types++import JavaScript.TypedArray.ArrayBuffer.Internal++newtype SomeDataView (a :: MutabilityType s) = SomeDataView JSVal+  deriving Typeable++type DataView        = SomeDataView Immutable+type MutableDataView = SomeDataView Mutable+type STDataView s    = SomeDataView (STMutable s)++-- #define JSU foreign import javascript unsafe+-- #define JSS foreign import javascript safe+--+--JSU "new DataView($1)"+--    js_dataView1 :: JSVal -> JSVal+--JSS "new DataView($2,$1)"+--    js_dataView2 :: Int -> JSVal -> SomeDataView m+--JSU "new DataView($2,$1)"+--    js_unsafeDataView2 :: Int -> JSVal-> SomeDataView m+--JSS "new DataView($3,$1,$2)"+--    js_dataView :: Int -> Int -> JSVal -> SomeDataView m+--JSU "new DataView($3,$1,$2)"+--    js_unsafeDataView :: Int -> Int -> JSVal -> JSVal+--JSU "new DataView($1.buffer.slice($1.byteOffset, $1.byteLength))"+--    js_cloneDataView :: SomeDataView m -> IO (SomeDataView m1)+--+---- ----------------------------------------------------------------------------+---- immutable getters+--+--JSU "$2.getInt8($1)"          js_i_unsafeGetInt8       :: Int -> DataView -> Int8+--JSU "$2.getUint8($1)"         js_i_unsafeGetUint8      :: Int -> DataView -> Word8+--JSU "$2.getInt16($1)"         js_i_unsafeGetInt16BE    :: Int -> DataView -> Int16+--JSU "$2.getInt32($1)"         js_i_unsafeGetInt32BE    :: Int -> DataView -> Int+--JSU "$2.getUint16($1)"        js_i_unsafeGetUint16BE   :: Int -> DataView -> Word16+--JSU "$2.getUint32($1)|0"      js_i_unsafeGetUint32BE   :: Int -> DataView -> Word+--JSU "$2.getFloat32($1)"       js_i_unsafeGetFloat32BE  :: Int -> DataView -> Double+--JSU "$2.getFloat64($1)"       js_i_unsafeGetFloat64BE  :: Int -> DataView -> Double+--JSU "$2.getInt16($1,true)"    js_i_unsafeGetInt16LE    :: Int -> DataView -> Int16+--JSU "$2.getInt32($1,true)"    js_i_unsafeGetInt32LE    :: Int -> DataView -> Int+--JSU "$2.getUint16($1,true)"   js_i_unsafeGetUint16LE   :: Int -> DataView -> Word16+--JSU "$2.getUint32($1,true)|0" js_i_unsafeGetUint32LE   :: Int -> DataView -> Word+--JSU "$2.getFloat32($1,true)"  js_i_unsafeGetFloat32LE  :: Int -> DataView -> Double+--JSU "$2.getFloat64($1,true)"  js_i_unsafeGetFloat64LE  :: Int -> DataView -> Double+--+--JSS "$2.getInt8($1)"          js_i_getInt8       :: Int -> DataView -> Int8+--JSS "$2.getUint8($1)"         js_i_getUint8      :: Int -> DataView -> Word8+--JSS "$2.getInt16($1)"         js_i_getInt16BE    :: Int -> DataView -> Int16+--JSS "$2.getInt32($1)"         js_i_getInt32BE    :: Int -> DataView -> Int+--JSS "$2.getUint16($1)"        js_i_getUint16BE   :: Int -> DataView -> Word16+--JSS "$2.getUint32($1)|0"      js_i_getUint32BE   :: Int -> DataView -> Word+--JSS "$2.getFloat32($1)"       js_i_getFloat32BE  :: Int -> DataView -> Double+--JSS "$2.getFloat64($1)"       js_i_getFloat64BE  :: Int -> DataView -> Double+--JSS "$2.getInt16($1,true)"    js_i_getInt16LE    :: Int -> DataView -> Int16+--JSS "$2.getInt32($1,true)"    js_i_getInt32LE    :: Int -> DataView -> Int+--JSS "$2.getUint16($1,true)"   js_i_getUint16LE   :: Int -> DataView -> Word16+--JSS "$2.getUint32($1,true)|0" js_i_getUint32LE   :: Int -> DataView -> Word+--JSS "$2.getFloat32($1,true)"  js_i_getFloat32LE  :: Int -> DataView -> Double+--JSS "$2.getFloat64($1,true)"  js_i_getFloat64LE  :: Int -> DataView -> Double+--+---- ----------------------------------------------------------------------------+---- mutable getters+--+--JSU "$2.getInt8($1)"          js_m_unsafeGetInt8      :: Int -> SomeDataView m -> State# s -> (# State# s, Int8   #)+--JSU "$2.getUint8($1)"         js_m_unsafeGetUint8     :: Int -> SomeDataView m -> State# s -> (# State# s, Word8  #)+--JSU "$2.getInt16($1)"         js_m_unsafeGetInt16BE   :: Int -> SomeDataView m -> State# s -> (# State# s, Int16  #)+--JSU "$2.getInt32($1)"         js_m_unsafeGetInt32BE   :: Int -> SomeDataView m -> State# s -> (# State# s, Int    #)+--JSU "$2.getUint16($1)"        js_m_unsafeGetUint16BE  :: Int -> SomeDataView m -> State# s -> (# State# s, Word16 #)+--JSU "$2.getUint32($1)|0"      js_m_unsafeGetUint32BE  :: Int -> SomeDataView m -> State# s -> (# State# s, Word   #)+--JSU "$2.getFloat32($1)"       js_m_unsafeGetFloat32BE :: Int -> SomeDataView m -> State# s -> (# State# s, Double #)+--JSU "$2.getFloat64($1)"       js_m_unsafeGetFloat64BE :: Int -> SomeDataView m -> State# s -> (# State# s, Double #)+--JSU "$2.getInt16($1,true)"    js_m_unsafeGetInt16LE   :: Int -> SomeDataView m -> State# s -> (# State# s, Int16  #)+--JSU "$2.getInt32($1,true)"    js_m_unsafeGetInt32LE   :: Int -> SomeDataView m -> State# s -> (# State# s, Int    #)+--JSU "$2.getUint16($1,true)"   js_m_unsafeGetUint16LE  :: Int -> SomeDataView m -> State# s -> (# State# s, Word16 #)+--JSU "$2.getUint32($1,true)|0" js_m_unsafeGetUint32LE  :: Int -> SomeDataView m -> State# s -> (# State# s, Word   #)+--JSU "$2.getFloat32($1,true)"  js_m_unsafeGetFloat32LE :: Int -> SomeDataView m -> State# s -> (# State# s, Double #)+--JSU "$2.getFloat64($1,true)"  js_m_unsafeGetFloat64LE :: Int -> SomeDataView m -> State# s -> (# State# s, Double #)+--+--JSS "$2.getInt8($1)"          js_m_getInt8            :: Int -> SomeDataView m -> State# s -> (# State# s, Int8   #)+--JSS "$2.getUint8($1)"         js_m_getUint8           :: Int -> SomeDataView m -> State# s -> (# State# s, Word8  #)+--JSS "$2.getInt16($1)"         js_m_getInt16BE         :: Int -> SomeDataView m -> State# s -> (# State# s, Int16  #)+--JSS "$2.getInt32($1)"         js_m_getInt32BE         :: Int -> SomeDataView m -> State# s -> (# State# s, Int    #)+--JSS "$2.getUint16($1)"        js_m_getUint16BE        :: Int -> SomeDataView m -> State# s -> (# State# s, Word16 #)+--JSS "$2.getUint32($1)|0"      js_m_getUint32BE        :: Int -> SomeDataView m -> State# s -> (# State# s, Word   #)+--JSS "$2.getFloat32($1)"       js_m_getFloat32BE       :: Int -> SomeDataView m -> State# s -> (# State# s, Double #)+--JSS "$2.getFloat64($1)"       js_m_getFloat64BE       :: Int -> SomeDataView m -> State# s -> (# State# s, Double #)+--JSS "$2.getInt16($1,true)"    js_m_getInt16LE         :: Int -> SomeDataView m -> State# s -> (# State# s, Int16  #)+--JSS "$2.getInt32($1,true)"    js_m_getInt32LE         :: Int -> SomeDataView m -> State# s -> (# State# s, Int    #)+--JSS "$2.getUint16($1,true)"   js_m_getUint16LE        :: Int -> SomeDataView m -> State# s -> (# State# s, Word16 #)+--JSS "$2.getUint32($1,true)|0" js_m_getUint32LE        :: Int -> SomeDataView m -> State# s -> (# State# s, Word   #)+--JSS "$2.getFloat32($1,true)"  js_m_getFloat32LE       :: Int -> SomeDataView m -> State# s -> (# State# s, Double #)+--JSS "$2.getFloat64($1,true)"  js_m_getFloat64LE       :: Int -> SomeDataView m -> State# s -> (# State# s, Double #)+--+---- ----------------------------------------------------------------------------+---- mutable setters+--+--JSU "$3.setInt8($1,$2)"         js_unsafeSetInt8      :: Int -> Int8   -> SomeDataView m -> State# s -> (# State# s, () #)+--JSU "$3.setUint8($1,$2)"        js_unsafeSetUint8     :: Int -> Word8  -> SomeDataView m -> State# s -> (# State# s, () #)+--JSU "$3.setInt16($1,$2)"        js_unsafeSetInt16BE   :: Int -> Int16  -> SomeDataView m -> State# s -> (# State# s, () #)+--JSU "$3.setInt32($1,$2)"        js_unsafeSetInt32BE   :: Int -> Int    -> SomeDataView m -> State# s -> (# State# s, () #)+--JSU "$3.setUint16($1,$2)"       js_unsafeSetUint16BE  :: Int -> Word16 -> SomeDataView m -> State# s -> (# State# s, () #)+--JSU "$3.setUint32($1,$2)"       js_unsafeSetUint32BE  :: Int -> Word   -> SomeDataView m -> State# s -> (# State# s, () #)+--JSU "$3.setFloat32($1,$2)"      js_unsafeSetFloat32BE :: Int -> Double -> SomeDataView m -> State# s -> (# State# s, () #)+--JSU "$3.setFloat64($1,$2)"      js_unsafeSetFloat64BE :: Int -> Double -> SomeDataView m -> State# s -> (# State# s, () #)+--JSU "$3.setInt16($1,$2,true)"   js_unsafeSetInt16LE   :: Int -> Int16  -> SomeDataView m -> State# s -> (# State# s, () #)+--JSU "$3.setInt32($1,$2,true)"   js_unsafeSetInt32LE   :: Int -> Int    -> SomeDataView m -> State# s -> (# State# s, () #)+--JSU "$3.setUint16($1,$2,true)"  js_unsafeSetUint16LE  :: Int -> Word16 -> SomeDataView m -> State# s -> (# State# s, () #)+--JSU "$3.setUint32($1,$2,true)"  js_unsafeSetUint32LE  :: Int -> Word   -> SomeDataView m -> State# s -> (# State# s, () #)+--JSU "$3.setFloat32($1,$2,true)" js_unsafeSetFloat32LE :: Int -> Double -> SomeDataView m -> State# s -> (# State# s, () #)+--JSU "$3.setFloat64($1,$2,true)" js_unsafeSetFloat64LE :: Int -> Double -> SomeDataView m -> State# s -> (# State# s, () #)+--+--JSS "$3.setInt8($1,$2)"         js_setInt8            :: Int -> Int8   -> SomeDataView m -> State# s -> (# State# s, () #)+--JSS "$3.setUint8($1,$2)"        js_setUint8           :: Int -> Word8  -> SomeDataView m -> State# s -> (# State# s, () #)+--JSS "$3.setInt16($1,$2)"        js_setInt16BE         :: Int -> Int16  -> SomeDataView m -> State# s -> (# State# s, () #)+--JSS "$3.setInt32($1,$2)"        js_setInt32BE         :: Int -> Int    -> SomeDataView m -> State# s -> (# State# s, () #)+--JSS "$3.setUint16($1,$2)"       js_setUint16BE        :: Int -> Word16 -> SomeDataView m -> State# s -> (# State# s, () #)+--JSS "$3.setUint32($1,$2)"       js_setUint32BE        :: Int -> Word   -> SomeDataView m -> State# s -> (# State# s, () #)+--JSS "$3.setFloat32($1,$2)"      js_setFloat32BE       :: Int -> Double -> SomeDataView m -> State# s -> (# State# s, () #)+--JSS "$3.setFloat64($1,$2)"      js_setFloat64BE       :: Int -> Double -> SomeDataView m -> State# s -> (# State# s, () #)+--JSS "$3.setInt16($1,$2,true)"   js_setInt16LE         :: Int -> Int16  -> SomeDataView m -> State# s -> (# State# s, () #)+--JSS "$3.setInt32($1,$2,true)"   js_setInt32LE         :: Int -> Int    -> SomeDataView m -> State# s -> (# State# s, () #)+--JSS "$3.setUint16($1,$2,true)"  js_setUint16LE        :: Int -> Word16 -> SomeDataView m -> State# s -> (# State# s, () #)+--JSS "$3.setUint32($1,$2,true)"  js_setUint32LE        :: Int -> Word   -> SomeDataView m -> State# s -> (# State# s, () #)+--JSS "$3.setFloat32($1,$2,true)" js_setFloat32LE       :: Int -> Double -> SomeDataView m -> State# s -> (# State# s, () #)+--JSS "$3.setFloat64($1,$2,true)" js_setFloat64LE       :: Int -> Double -> SomeDataView m -> State# s -> (# State# s, () #)+
+ src-ghc/JavaScript/TypedArray/Immutable.hs view
@@ -0,0 +1,1 @@+module JavaScript.TypedArray.Immutable where
+ src-ghc/JavaScript/TypedArray/Internal.hs view
@@ -0,0 +1,345 @@+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE PolyKinds #-}+{-# LANGUAGE TypeOperators #-}++module JavaScript.TypedArray.Internal where++import Prelude hiding ((!!))++import GHC.Int+import GHC.Word++import GHCJS.Internal.Types++import Control.Monad (void)+import Control.Lens.Operators ((^.))++import GHCJS.Marshal (fromJSValUnchecked)++import JavaScript.Array.Internal (SomeJSArray(..))+import JavaScript.TypedArray.ArrayBuffer+import JavaScript.TypedArray.ArrayBuffer.Internal (SomeArrayBuffer(..))+import JavaScript.TypedArray.Internal.Types++import Language.Javascript.JSaddle.Types (JSM, GHCJSPure(..))+import Language.Javascript.JSaddle.Object (js, jsg, js1, js2, new, (!!), (<##))++elemSize :: SomeTypedArray e m -> GHCJSPure Int+elemSize (SomeTypedArray a) = GHCJSPure $ a ^. js "BYTES_PER_ELEMENT" >>= fromJSValUnchecked+{-# INLINE [1] elemSize #-}+{-# RULES "elemSizeUint8Clamped" forall (x :: SomeUint8ClampedArray m). elemSize x = GHCJSPure $ return 1 #-}+{-# RULES "elemSizeUint8"        forall (x :: SomeUint8Array m).        elemSize x = GHCJSPure $ return 1 #-}+{-# RULES "elemSizeUint16"       forall (x :: SomeUint16Array m).       elemSize x = GHCJSPure $ return 2 #-}+{-# RULES "elemSizeUint32"       forall (x :: SomeUint32Array m).       elemSize x = GHCJSPure $ return 4 #-}+{-# RULES "elemSizeInt8"         forall (x :: SomeInt8Array m).         elemSize x = GHCJSPure $ return 1 #-}+{-# RULES "elemSizeInt16"        forall (x :: SomeInt16Array m).        elemSize x = GHCJSPure $ return 2 #-}+{-# RULES "elemSizeInt32"        forall (x :: SomeInt32Array m).        elemSize x = GHCJSPure $ return 4 #-}+{-# RULES "elemSizeFloat32"      forall (x :: SomeFloat32Array m).      elemSize x = GHCJSPure $ return 4 #-}+{-# RULES "elemSizeFloat64"      forall (x :: SomeFloat64Array m).      elemSize x = GHCJSPure $ return 8 #-}++instance TypedArray IOInt8Array where+  index              = indexI8+  unsafeIndex        = unsafeIndexI8+  setIndex i x       = setIndexI i (fromIntegral x)+  unsafeSetIndex i x = unsafeSetIndexI i (fromIntegral x)+  indexOf s x        = indexOfI s (fromIntegral x)+  lastIndexOf s x    = lastIndexOfI s (fromIntegral x)+  create l           = SomeTypedArray <$> new (jsg "Int8Array") [l]+  fromArray          = int8ArrayFrom+  fromArrayBuffer    = undefined++instance TypedArray IOInt16Array where+  index              = indexI16+  unsafeIndex        = unsafeIndexI16+  setIndex i x       = setIndexI i (fromIntegral x)+  unsafeSetIndex i x = unsafeSetIndexI i (fromIntegral x)+  indexOf s x        = indexOfI s (fromIntegral x)+  lastIndexOf s x    = lastIndexOfI s (fromIntegral x)+  create l           = SomeTypedArray <$> new (jsg "Int16Array") [l]+  fromArray          = int16ArrayFrom+  fromArrayBuffer    = undefined++instance TypedArray IOInt32Array where+  index           = indexI+  unsafeIndex     = unsafeIndexI+  setIndex        = setIndexI+  unsafeSetIndex  = unsafeSetIndexI+  indexOf         = indexOfI+  lastIndexOf     = lastIndexOfI+  create l        = SomeTypedArray <$> new (jsg "Int32Array") [l]+  fromArray       = int32ArrayFrom+  fromArrayBuffer = undefined++instance TypedArray IOUint8ClampedArray where+  index              = indexW8+  unsafeIndex        = unsafeIndexW8+  setIndex i x       = setIndexW i (fromIntegral x)+  unsafeSetIndex i x = unsafeSetIndexW i (fromIntegral x)+  indexOf s x        = indexOfW s (fromIntegral x)+  lastIndexOf s x    = lastIndexOfW s (fromIntegral x)+  create l           = SomeTypedArray <$> new (jsg "Uint8ClampedArray") [l]+  fromArray          = uint8ClampedArrayFrom+  fromArrayBuffer    = undefined++instance TypedArray IOUint8Array where+  index              = indexW8+  unsafeIndex        = unsafeIndexW8+  setIndex i x       = setIndexW i (fromIntegral x)+  unsafeSetIndex i x = unsafeSetIndexW i (fromIntegral x)+  indexOf s x        = indexOfW s (fromIntegral x)+  lastIndexOf s x    = lastIndexOfW s (fromIntegral x)+  create l           = SomeTypedArray <$> new (jsg "Uint8Array") [l]+  fromArray          = uint8ArrayFrom+  fromArrayBuffer    = undefined++instance TypedArray IOUint16Array where+  index              = indexW16+  unsafeIndex        = unsafeIndexW16+  setIndex i x       = setIndexW i (fromIntegral x)+  unsafeSetIndex i x = unsafeSetIndexW i (fromIntegral x)+  indexOf s x        = indexOfW s (fromIntegral x)+  lastIndexOf s x    = lastIndexOfW s (fromIntegral x)+  create l           = SomeTypedArray <$> new (jsg "Uint16Array") [l]+  fromArray          = uint16ArrayFrom+  fromArrayBuffer    = undefined++instance TypedArray IOUint32Array where+  index           = indexW+  unsafeIndex     = unsafeIndexW+  setIndex        = setIndexW+  unsafeSetIndex  = unsafeSetIndexW+  indexOf         = indexOfW+  lastIndexOf     = lastIndexOfW+  create l        = SomeTypedArray <$> new (jsg "Uint32Array") [l]+  fromArray       = uint32ArrayFrom+  fromArrayBuffer = undefined++instance TypedArray IOFloat32Array where+  index           = indexD+  unsafeIndex     = unsafeIndexD+  setIndex        = setIndexD+  unsafeSetIndex  = unsafeSetIndexD+  indexOf         = indexOfD+  lastIndexOf     = lastIndexOfD+  create l        = SomeTypedArray <$> new (jsg "Float32Array") [l]+  fromArray       = float32ArrayFrom+  fromArrayBuffer = undefined++instance TypedArray IOFloat64Array where+  index           = indexD+  unsafeIndex     = unsafeIndexD+  setIndex        = setIndexD+  unsafeSetIndex  = unsafeSetIndexD+  indexOf         = indexOfD+  lastIndexOf     = lastIndexOfD+  create l        = SomeTypedArray <$> new (jsg "Float64Array") [l]+  fromArray       = float64ArrayFrom+  fromArrayBuffer = undefined+++class TypedArray a where+  unsafeIndex     :: Int           -> a -> JSM (Elem a)+  index           :: Int           -> a -> JSM (Elem a)+  unsafeSetIndex  :: Int -> Elem a -> a -> JSM ()+  setIndex        :: Int -> Elem a -> a -> JSM ()+  create          :: Int                -> JSM a+  fromArray       :: SomeJSArray m      -> JSM a+  fromArrayBuffer :: MutableArrayBuffer -> Int    -> Maybe Int -> JSM a+  indexOf         :: Int                -> Elem a -> a -> JSM Int+  lastIndexOf     :: Int                -> Elem a -> a -> JSM Int++-- -----------------------------------------------------------------------------++indexI :: Int -> SomeTypedArray e m -> JSM Int+indexI i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE indexI #-}++indexI16 :: Int -> SomeTypedArray e m -> JSM Int16+indexI16 i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE indexI16 #-}++indexI8 :: Int -> SomeTypedArray e m -> JSM Int8+indexI8 i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE indexI8 #-}++indexW :: Int -> SomeTypedArray e m -> JSM Word+indexW i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE indexW #-}++indexW16 :: Int -> SomeTypedArray e m -> JSM Word16+indexW16 i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE indexW16 #-}++indexW8 :: Int -> SomeTypedArray e m -> JSM Word8+indexW8 i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE indexW8 #-}++indexD :: Int -> SomeTypedArray e m -> JSM Double+indexD i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE indexD #-}++-- -----------------------------------------------------------------------------++unsafeIndexI :: Int -> SomeTypedArray e m -> JSM Int+unsafeIndexI i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE unsafeIndexI #-}++unsafeIndexI16 :: Int -> SomeTypedArray e m -> JSM Int16+unsafeIndexI16 i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE unsafeIndexI16 #-}++unsafeIndexI8 :: Int -> SomeTypedArray e m -> JSM Int8+unsafeIndexI8 i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE unsafeIndexI8 #-}++unsafeIndexW :: Int -> SomeTypedArray e m -> JSM  Word+unsafeIndexW i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE unsafeIndexW #-}++unsafeIndexW16 :: Int -> SomeTypedArray e m -> JSM Word16+unsafeIndexW16 i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE unsafeIndexW16 #-}++unsafeIndexW8 :: Int -> SomeTypedArray e m -> JSM Word8+unsafeIndexW8 i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE unsafeIndexW8 #-}++unsafeIndexD :: Int -> SomeTypedArray e m -> JSM Double+unsafeIndexD i (SomeTypedArray a) = a !! i >>= fromJSValUnchecked+{-# INLINE unsafeIndexD #-}++-- -----------------------------------------------------------------------------++int8ArrayFrom :: SomeJSArray m0 -> JSM (SomeInt8Array m1)+int8ArrayFrom (SomeJSArray a) = SomeTypedArray <$> jsg "Int8Array" ^. js1 "from" a+{-# INLINE int8ArrayFrom #-}++int16ArrayFrom :: SomeJSArray m0 -> JSM (SomeInt16Array m1)+int16ArrayFrom (SomeJSArray a) = SomeTypedArray <$> jsg "Int16Array" ^. js1 "from" a+{-# INLINE int16ArrayFrom #-}++int32ArrayFrom :: SomeJSArray m0 -> JSM (SomeInt32Array m1)+int32ArrayFrom (SomeJSArray a) = SomeTypedArray <$> jsg "Int32Array" ^. js1 "from" a+{-# INLINE int32ArrayFrom #-}++uint8ArrayFrom :: SomeJSArray m0 -> JSM (SomeUint8Array m1)+uint8ArrayFrom (SomeJSArray a) = SomeTypedArray <$> jsg "Uint8Array" ^. js1 "from" a+{-# INLINE uint8ArrayFrom #-}++uint8ClampedArrayFrom :: SomeJSArray m0 -> JSM (SomeUint8ClampedArray m1)+uint8ClampedArrayFrom (SomeJSArray a) = SomeTypedArray <$> jsg "Uint8ClampedArray" ^. js1 "from" a+{-# INLINE uint8ClampedArrayFrom #-}++uint16ArrayFrom :: SomeJSArray m0 -> JSM (SomeUint16Array m1)+uint16ArrayFrom (SomeJSArray a) = SomeTypedArray <$> jsg "Uint16Array" ^. js1 "from" a+{-# INLINE uint16ArrayFrom #-}++uint32ArrayFrom :: SomeJSArray m0 -> JSM (SomeUint32Array m1)+uint32ArrayFrom (SomeJSArray a) = SomeTypedArray <$> jsg "Uint32Array" ^. js1 "from" a+{-# INLINE uint32ArrayFrom #-}++float32ArrayFrom :: SomeJSArray m0 -> JSM (SomeFloat32Array m1)+float32ArrayFrom (SomeJSArray a) = SomeTypedArray <$> jsg "Float32Array" ^. js1 "from" a+{-# INLINE float32ArrayFrom #-}++float64ArrayFrom :: SomeJSArray m0 -> JSM (SomeFloat64Array m1)+float64ArrayFrom (SomeJSArray a) = SomeTypedArray <$> jsg "Float64Array" ^. js1 "from" a+{-# INLINE float64ArrayFrom #-}++-- -----------------------------------------------------------------------------++setIndexI :: Mutability m ~ IsMutable+          => Int -> Int -> SomeTypedArray e m -> JSM ()+setIndexI i x (SomeTypedArray a) = (a <## i) x+{-# INLINE setIndexI #-}++unsafeSetIndexI :: Mutability m ~ IsMutable+                => Int -> Int -> SomeTypedArray e m -> JSM ()+unsafeSetIndexI i x (SomeTypedArray a) = (a <## i) x+{-# INLINE unsafeSetIndexI #-}++setIndexW :: Mutability m ~ IsMutable+           => Int -> Word -> SomeTypedArray e m -> JSM ()+setIndexW i x (SomeTypedArray a) = (a <## i) x+{-# INLINE setIndexW #-}++unsafeSetIndexW :: Mutability m ~ IsMutable+                => Int -> Word -> SomeTypedArray e m -> JSM ()+unsafeSetIndexW i x (SomeTypedArray a) = (a <## i) x+{-# INLINE unsafeSetIndexW #-}++setIndexD :: Mutability m ~ IsMutable+          => Int -> Double -> SomeTypedArray e m -> JSM ()+setIndexD i x (SomeTypedArray a) = (a <## i) x+{-# INLINE setIndexD #-}++unsafeSetIndexD :: Mutability m ~ IsMutable+                => Int -> Double -> SomeTypedArray e m -> JSM ()+unsafeSetIndexD i x (SomeTypedArray a) = (a <## i) x+{-# INLINE unsafeSetIndexD #-}++indexOfI :: Mutability m ~ IsMutable+         => Int -> Int -> SomeTypedArray e m -> JSM Int+indexOfI s x (SomeTypedArray a) = a ^. js2 "indexOf" x s >>= fromJSValUnchecked+{-# INLINE indexOfI #-}++indexOfW :: Int -> Word -> SomeTypedArray e m -> JSM Int+indexOfW s x (SomeTypedArray a) = a ^. js2 "indexOf" x s >>= fromJSValUnchecked+{-# INLINE indexOfW #-}++indexOfD :: Int -> Double -> SomeTypedArray e m -> JSM Int+indexOfD s x (SomeTypedArray a) = a ^. js2 "indexOf" x s >>= fromJSValUnchecked+{-# INLINE indexOfD #-}++lastIndexOfI :: Int -> Int -> SomeTypedArray e m -> JSM Int+lastIndexOfI s x (SomeTypedArray a) = a ^. js2 "lastIndexOf" x s >>= fromJSValUnchecked+{-# INLINE lastIndexOfI #-}++lastIndexOfW :: Int -> Word -> SomeTypedArray e m -> JSM Int+lastIndexOfW s x (SomeTypedArray a) = a ^. js2 "lastIndexOf" x s >>= fromJSValUnchecked+{-# INLINE lastIndexOfW #-}++lastIndexOfD :: Int -> Double -> SomeTypedArray e m -> JSM Int+lastIndexOfD s x (SomeTypedArray a) = a ^. js2 "lastIndexOf" x s >>= fromJSValUnchecked+{-# INLINE lastIndexOfD #-}++-- -----------------------------------------------------------------------------+-- non-class operations usable for all typed array+{-| length of the typed array in elements -}+length :: SomeTypedArray e m -> GHCJSPure Int+length (SomeTypedArray a) = GHCJSPure $ a ^. js "length" >>= fromJSValUnchecked+{-# INLINE length #-}++{-| length of the array in bytes -}+byteLength :: SomeTypedArray e m -> GHCJSPure Int+byteLength (SomeTypedArray a) = GHCJSPure $ a ^. js "byteLength" >>= fromJSValUnchecked+{-# INLINE byteLength #-}++{-| offset of the array in the buffer -}+byteOffset :: SomeTypedArray e m -> GHCJSPure Int+byteOffset (SomeTypedArray a) = GHCJSPure $ a ^. js "byteOffset" >>= fromJSValUnchecked+{-# INLINE byteOffset #-}++{-| the underlying buffer of the array -}+buffer :: SomeTypedArray e m -> GHCJSPure (SomeArrayBuffer m)+buffer (SomeTypedArray a) = GHCJSPure $ SomeArrayBuffer <$> a ^. js "buffer"+{-# INLINE buffer #-}++{-| create a view of the existing array -}+subarray :: Int -> Int -> SomeTypedArray e m -> GHCJSPure (SomeTypedArray e m)+subarray begin end (SomeTypedArray a) = GHCJSPure$ SomeTypedArray <$> a ^. js2 "subarray" begin end+{-# INLINE subarray #-}++-- fixme convert JSException to Haskell exception+{-| copy the elements of one typed array to another -}+set :: Int -> SomeTypedArray e m -> SomeTypedArray e1 Mutable -> GHCJSPure ()+set offset (SomeTypedArray src) (SomeTypedArray dest) = GHCJSPure $ void $ dest ^. js2 "set" offset src+{-# INLINE set #-}++unsafeSet :: Int -> SomeTypedArray e m -> SomeTypedArray e1 Mutable -> GHCJSPure ()+unsafeSet offset (SomeTypedArray src) (SomeTypedArray dest) = GHCJSPure $ void $ dest ^. js2 "set" offset src+{-# INLINE unsafeSet #-}+
+ src-ghc/JavaScript/TypedArray/Internal/Types.hs view
@@ -0,0 +1,121 @@+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE PolyKinds #-}++module JavaScript.TypedArray.Internal.Types where++import GHCJS.Types+import GHCJS.Internal.Types+import Language.Javascript.JSaddle (IsJSVal)++import Data.Int+import Data.Typeable+import Data.Word++newtype SomeTypedArray (e :: TypedArrayElem) (m :: MutabilityType s) =+  SomeTypedArray JSVal deriving Typeable+instance IsJSVal (SomeTypedArray e m)++{-+newtype SomeSTTypedArray s e = SomeSTTypedArray JSVal+  deriving (Typeable)+-}++type SomeSTTypedArray s (e :: TypedArrayElem) = SomeTypedArray e (STMutable s)++-- -----------------------------------------------------------------------------++data TypedArrayElem = Int8Elem+                    | Int16Elem+                    | Int32Elem+                    | Uint8Elem+                    | Uint16Elem+                    | Uint32Elem+                    | Uint8ClampedElem+                    | Float32Elem+                    | Float64Elem++-- -----------------------------------------------------------------------------++type SomeInt8Array         = SomeTypedArray        Int8Elem+type SomeInt16Array        = SomeTypedArray        Int16Elem+type SomeInt32Array        = SomeTypedArray        Int32Elem++type SomeUint8Array        = SomeTypedArray        Uint8Elem+type SomeUint16Array       = SomeTypedArray        Uint16Elem+type SomeUint32Array       = SomeTypedArray        Uint32Elem++type SomeFloat32Array      = SomeTypedArray        Float32Elem+type SomeFloat64Array      = SomeTypedArray        Float64Elem++type SomeUint8ClampedArray = SomeTypedArray        Uint8ClampedElem++-- -----------------------------------------------------------------------------++type Int8Array             = SomeInt8Array         Immutable+type Int16Array            = SomeInt16Array        Immutable+type Int32Array            = SomeInt32Array        Immutable++type Uint8Array            = SomeUint8Array        Immutable+type Uint16Array           = SomeUint16Array       Immutable+type Uint32Array           = SomeUint32Array       Immutable++type Uint8ClampedArray     = SomeUint8ClampedArray Immutable++type Float32Array          = SomeFloat32Array      Immutable+type Float64Array          = SomeFloat64Array      Immutable++-- -----------------------------------------------------------------------------++type IOInt8Array           = SomeInt8Array         Mutable+type IOInt16Array          = SomeInt16Array        Mutable+type IOInt32Array          = SomeInt32Array        Mutable++type IOUint8Array          = SomeUint8Array        Mutable+type IOUint16Array         = SomeUint16Array       Mutable+type IOUint32Array         = SomeUint32Array       Mutable++type IOUint8ClampedArray   = SomeUint8ClampedArray Mutable++type IOFloat32Array        = SomeFloat32Array      Mutable+type IOFloat64Array        = SomeFloat64Array      Mutable++-- -----------------------------------------------------------------------------++type STInt8Array s         = SomeSTTypedArray s Int8Elem+type STInt16Array s        = SomeSTTypedArray s Int16Elem+type STInt32Array s        = SomeSTTypedArray s Int32Elem++type STUint8Array s        = SomeSTTypedArray s Uint8Elem+type STUint16Array s       = SomeSTTypedArray s Uint16Elem+type STUint32Array s       = SomeSTTypedArray s Uint32Elem++type STFloat32Array s      = SomeSTTypedArray s Float32Elem+type STFloat64Array s      = SomeSTTypedArray s Float64Elem++type STUint8ClampedArray s = SomeSTTypedArray s Uint8ClampedElem++-- -----------------------------------------------------------------------------++type family Elem x where+    Elem (SomeUint8Array m)        = Word8+    Elem (SomeUint8ClampedArray m) = Word8+    Elem (SomeUint16Array m)       = Word16+    Elem (SomeUint32Array m)       = Word+    Elem (SomeInt8Array m)         = Int8+    Elem (SomeInt16Array m)        = Int16+    Elem (SomeInt32Array m)        = Int+    Elem (SomeFloat32Array m)      = Double+    Elem (SomeFloat64Array m)      = Double++    Elem (STUint8Array s)          = Word8+    Elem (STUint8ClampedArray s)   = Word8+    Elem (STUint16Array s)         = Word16+    Elem (STUint32Array s)         = Word+    Elem (STInt8Array s)           = Int8+    Elem (STInt16Array s)          = Int16+    Elem (STInt32Array s)          = Int+    Elem (STFloat32Array s)        = Double+    Elem (STFloat64Array s)        = Double+
src/Language/Javascript/JSaddle.hs view
@@ -1,4 +1,3 @@-{-# LANGUAGE CPP #-} ----------------------------------------------------------------------------- -- -- Module      :  Language.Javascript.JSaddle@@ -7,9 +6,10 @@ -- -- Maintainer  :  Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com> ----- | This package provides an EDSL for calling JavaScript code using---   the JavaScriptCore engine and low level Haskell bindings---   in the webkit-javascriptcore library <https://github.com/ghcjs/webkit-javascriptcore>.+-- | This package provides an EDSL for calling JavaScript that+--   can be used both from GHCJS and GHC.  When using GHC+--   the application is run using Warp and WebSockets to+--   drive a small JavaScript helper. -----------------------------------------------------------------------------  module Language.Javascript.JSaddle (@@ -35,29 +35,42 @@   --   --   Where it makes sense code examples are given in two forms.  One   --   that uses 'eval' to run a purely JavaScript version and one that-  --   uses more of the JSaddle EDSL feature being demonstated.+  --   uses more of the JSaddle EDSL feature being demonstrated.    -- * Calling Haskell from JavaScript-  -- | You can call back into haskell from JavaScript using 'fun' to+  -- | You can call back into Haskell from JavaScript using 'fun' to   --   convert a Haskell function in the JSM monad into a javascript   --   value.    -- * GHCJS Support   -- | When built with ghcjs the code works using JavaScript FFI by default.-  --   It can also be built to use webkitgtk3-javascriptcore C FFI as there-  --   are shims for these (but this introduces a dependancy on WebKitGTK+-  --   and is probably not as fast). +  -- * GHC Support+  -- | When built with ghc the code runs a small Warp server that provides+  --   index.html and jsaddle.js files.  When a browser is connected the+  --   code in jsaddle.js will open a WebSockets connection to the server+  --   and the server will run the Haskell code.  The JSaddle parts will+  --   be executed by sending commands back to the browser.++  --   Although the JavaScript code is executed in the strict order+  --   set out by the EDSL it is done asynchronously to the Haskell code.+  --   This improves the performance by reducing the number of round trips+  --   needed between the Haskell and JavaScript code.++  --+   -- * Modules     module JSaddle ) where +import GHCJS.Marshal as JSaddle import Language.Javascript.JSaddle.Types as JSaddle import Language.Javascript.JSaddle.Classes as JSaddle+import Language.Javascript.JSaddle.Marshal.String as JSaddle () import Language.Javascript.JSaddle.Monad as JSaddle import Language.Javascript.JSaddle.Exception as JSaddle import Language.Javascript.JSaddle.Value as JSaddle-import Language.Javascript.JSaddle.Arguments as JSaddle+import Language.Javascript.JSaddle.Arguments as JSaddle () import Language.Javascript.JSaddle.Properties as JSaddle import Language.Javascript.JSaddle.Object as JSaddle import Language.Javascript.JSaddle.Evaluate as JSaddle
src/Language/Javascript/JSaddle/Arguments.hs view
@@ -1,5 +1,6 @@ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TypeSynonymInstances #-}+{-# OPTIONS_GHC -fno-warn-orphans #-} ----------------------------------------------------------------------------- -- -- Module      :  Language.Javascript.JSaddle.Arguments@@ -16,18 +17,8 @@     MakeArgs(..) ) where -import Language.Javascript.JSaddle.Classes-       (ToJSVal(..))-import Language.Javascript.JSaddle.Monad (JSM)-import Language.Javascript.JSaddle.Types (JSVal)---- | Anything that can be used to make a list of JavaScript value---   references for use as function arguments-class MakeArgs this where-    makeArgs :: this -> JSM [JSVal]--instance MakeArgs arg => MakeArgs (JSM arg) where-    makeArgs arg = arg >>= makeArgs+import Language.Javascript.JSaddle.Classes (MakeArgs(..))+import GHCJS.Marshal.Internal (ToJSVal(..))  instance ToJSVal arg => MakeArgs [arg] where     makeArgs = mapM toJSVal@@ -61,7 +52,6 @@         rarg4 <- toJSVal arg4         rarg5 <- toJSVal arg5         return [rarg1, rarg2, rarg3, rarg4, rarg5]-  instance (ToJSVal arg1, ToJSVal arg2, ToJSVal arg3, ToJSVal arg4, ToJSVal arg5, ToJSVal arg6) => MakeArgs (arg1, arg2, arg3, arg4, arg5, arg6) where     makeArgs (arg1, arg2, arg3, arg4, arg5, arg6) = do
src/Language/Javascript/JSaddle/Classes.hs view
@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TypeSynonymInstances #-} -----------------------------------------------------------------------------@@ -16,30 +17,21 @@  module Language.Javascript.JSaddle.Classes (   -- * Type classes to convert Haskell data to JavaScript-    ToJSVal(..)+    PToJSVal(..)+  , PFromJSVal(..)+  , ToJSVal(..)+  , FromJSVal(..)   , ToJSString(..)+  , FromJSString(..)   , MakeObject(..)+  , MakeArgs(..) ) where -import Language.Javascript.JSaddle.Types-       (JSM, Object(..), JSString, JSVal)---- | Anything that can be used to make a JavaScript value reference-class ToJSVal a where-    toJSVal :: a -> JSM JSVal---- | Anything that can be used to make a JavaScript string reference-class ToJSVal a => ToJSString a where-    toJSString :: a -> JSString---- | Anything that can be used to make a JavaScript object reference-class MakeObject this where-    makeObject :: this -> JSM Object--instance ToJSVal Object where-    toJSVal (Object r) = return r---- | If we already have a Object we are fine-instance MakeObject Object where-    makeObject = return-+#ifdef ghcjs_HOST_OS+import GHCJS.Marshal (ToJSVal(..), FromJSVal(..))+#else+import GHCJS.Marshal.Internal (ToJSVal(..), FromJSVal(..))+#endif+import GHCJS.Marshal.Pure (PToJSVal(..), PFromJSVal(..))+import Language.Javascript.JSaddle.Classes.Internal (MakeObject(..), MakeArgs(..))+import Language.Javascript.JSaddle.Marshal.String (ToJSString(..), FromJSString(..))
+ src/Language/Javascript/JSaddle/Classes/Internal.hs view
@@ -0,0 +1,41 @@+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE TypeSynonymInstances #-}+-----------------------------------------------------------------------------+--+-- Module      :  Language.Javascript.JSaddle.Classes.Internal+-- Copyright   :  (c) Hamish Mackenzie+-- License     :  MIT+--+-- Maintainer  :  Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com>+--+-- | These classes are used to make various JavaScript types+--   out of whatever we have.  Functions in jsaddle take these as inputs.+--   This alows implicit casting and eager evaluation.+--+-----------------------------------------------------------------------------++module Language.Javascript.JSaddle.Classes.Internal (+  -- * Type classes to convert Haskell data to JavaScript+    MakeObject(..)+  , MakeArgs(..)+) where++import Language.Javascript.JSaddle.Types+       (JSM, Object(..), JSVal)++-- | Anything that can be used to make a JavaScript object reference+class MakeObject this where+    makeObject :: this -> JSM Object++-- | If we already have a Object we are fine+instance MakeObject Object where+    makeObject = return++-- | Anything that can be used to make a list of JavaScript value+--   references for use as function arguments+class MakeArgs this where+    makeArgs :: this -> JSM [JSVal]++instance MakeArgs arg => MakeArgs (JSM arg) where+    makeArgs arg = arg >>= makeArgs+
+ src/Language/Javascript/JSaddle/Debug.hs view
@@ -0,0 +1,48 @@+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedStrings #-}+-----------------------------------------------------------------------------+--+-- Module      :  Language.Javascript.JSaddle.WebSockets+-- Copyright   :  (c) Hamish Mackenzie+-- License     :  MIT+--+-- Maintainer  :  Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com>+--+-- |+--+-----------------------------------------------------------------------------++module Language.Javascript.JSaddle.Debug (+    contexts+  , addContext+  , removeContext+  , runOnAll+  , runOnAll_+) where++import Language.Javascript.JSaddle+       (runJSM, askJSM, JSM, JSContextRef(..))+import Data.IORef (readIORef, atomicModifyIORef', newIORef, IORef)+import System.IO.Unsafe (unsafePerformIO)+import Data.Monoid ((<>))+import Control.Monad.IO.Class (MonadIO(..))+import Data.Int (Int64)++contexts :: IORef [JSContextRef]+contexts = unsafePerformIO $ newIORef []+{-# NOINLINE contexts #-}++addContext :: JSM ()+addContext = do+    ctx <- askJSM+    liftIO $ atomicModifyIORef' contexts $ \c -> (c <> [ctx], ())++removeContext :: MonadIO m => Int64 -> m ()+removeContext cid =+    liftIO $ atomicModifyIORef' contexts $ \c -> (filter ((/= cid) . contextId) c, ())++runOnAll :: MonadIO m => JSM a -> m [a]+runOnAll f = liftIO (readIORef contexts) >>= mapM (runJSM f)++runOnAll_ :: MonadIO m => JSM a -> m ()+runOnAll_ f = liftIO (readIORef contexts) >>= mapM_ (runJSM f)
src/Language/Javascript/JSaddle/Evaluate.hs view
@@ -2,6 +2,7 @@ {-# LANGUAGE FlexibleInstances #-} #ifdef ghcjs_HOST_OS {-# LANGUAGE ForeignFunctionInterface, JavaScriptFFI #-}+{-# OPTIONS_GHC -Wno-dodgy-exports -Wno-dodgy-imports #-} #endif ----------------------------------------------------------------------------- --@@ -17,28 +18,18 @@ -----------------------------------------------------------------------------  module Language.Javascript.JSaddle.Evaluate (-    evaluateScript-  , eval+    eval ) where -import Control.Monad.Trans.Reader (ask)-import Control.Monad.IO.Class (MonadIO(..)) import Language.Javascript.JSaddle.Types (JSVal) #ifdef ghcjs_HOST_OS-import GHCJS.Types (nullRef)-import GHCJS.Marshal.Pure (pFromJSVal)+import Control.Monad.IO.Class (MonadIO(..)) import Language.Javascript.JSaddle.Types (JSString) #else-import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSBase-       (jsevaluatescript)-import Language.Javascript.JSaddle.Native-       (makeNewJSVal, withObject, withJSString)+import Language.Javascript.JSaddle.Native.Internal+       (evaluateScript) #endif-import Language.Javascript.JSaddle.Exception (rethrow)-import Language.Javascript.JSaddle.String (nullJSString)-import Language.Javascript.JSaddle.Object (nullObject)-import Language.Javascript.JSaddle.Classes-       (MakeObject(..), ToJSString(..))+import Language.Javascript.JSaddle.Marshal.String (ToJSString(..)) import Language.Javascript.JSaddle.Monad (JSM)  -- $setup@@ -50,38 +41,22 @@ -- >>> testJSaddle $ return () -- ... --- | Evaluates a script (like eval in java script).  Unlike 'eval' this function lets you---   specify a source URL and starting line number for beter error information.------ >>> testJSaddle $ (evaluateScript "\n\n{" global "FileName" 53 >>= valToText) `catch` \(JSException e) -> array (e,e!"sourceURL", e!"line") >>= valToText--- SyntaxError: ...,FileName,55-evaluateScript :: (ToJSString script, MakeObject this, ToJSString url)-               => script         -- ^ JavaScript to evaluate-               -> this-               -> url-               -> Int            -- ^ The Line number of the first line of the script-               -> JSM JSVal-#ifdef ghcjs_HOST_OS-evaluateScript script this url line = liftIO $ js_eval (toJSString script)-foreign import javascript unsafe "$r = eval($1);"-    js_eval :: JSString -> IO JSVal-#else-evaluateScript script this url line = do-    gctxt <- ask-    rthis <- makeObject this-    result <--        withJSString (toJSString script) $ \script' ->-            withObject rthis $ \this' ->-                withJSString (toJSString url) $ \url' ->-                    rethrow $ liftIO . jsevaluatescript gctxt script' this' url' line-    makeNewJSVal result-#endif- -- | Evaluates a script (like eval in java script) -- -- >>> testJSaddle $ eval "1+1" -- 2-eval :: ToJSString script+eval :: (ToJSString script)      => script         -- ^ JavaScript to evaluate      -> JSM JSVal-eval script = evaluateScript script nullObject nullJSString 1+#ifdef ghcjs_HOST_OS+eval script = liftIO $ js_eval (toJSString script)+foreign import javascript safe+#if __GLASGOW_HASKELL__ >= 900+  "(($1) => { return eval($1); })"+#else+  "$r = eval($1);"+#endif+    js_eval :: JSString -> IO JSVal+#else+eval = evaluateScript . toJSString+#endif
src/Language/Javascript/JSaddle/Exception.hs view
@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} ----------------------------------------------------------------------------- --@@ -13,23 +14,30 @@  module Language.Javascript.JSaddle.Exception (     JSException(..)-  , rethrow+--  , rethrow ) where -import qualified Control.Exception as E (throwIO, Exception)-import Language.Javascript.JSaddle.Types-       (MutableJSArray, JSVal)+import qualified Control.Exception as E (Exception)+#ifdef ghcjs_HOST_OS+#if __GLASGOW_HASKELL__ >= 900+import GHC.JS.Prim (JSVal)+#else+import GHCJS.Prim (JSVal)+#endif+#else+import GHCJS.Prim.Internal (JSVal)+#endif import Data.Typeable (Typeable)-import Language.Javascript.JSaddle.Monad (catchval, JSM)-import Control.Monad.IO.Class (MonadIO(..))  newtype JSException = JSException JSVal deriving (Typeable) +-- | JavaScript exception+-- >>> instance Show JSException where show _ = "JSException" instance E.Exception JSException --- | Catch JavaScript exceptions and rethrow Haskell ones-rethrow :: (MutableJSArray -> JSM a) -> JSM a-rethrow f = f `catchval` \e ->-    liftIO . E.throwIO $ JSException e+---- | Catch JavaScript exceptions and rethrow Haskell ones+--rethrow :: (MutableJSArray -> JSM a) -> JSM a+--rethrow f = f `catchval` \e ->+--    liftIO . E.throwIO $ JSException e
+ src/Language/Javascript/JSaddle/Helper.hs view
@@ -0,0 +1,30 @@+{-# LANGUAGE CPP #-}+module Language.Javascript.JSaddle.Helper where++import GHCJS.Types (JSVal)+import Language.Javascript.JSaddle.Types (JSM)++#ifdef ghcjs_HOST_OS+import GHCJS.Marshal.Pure (pFromJSVal, pToJSVal)+import JavaScript.TypedArray.ArrayBuffer (MutableArrayBuffer)+#else+import JavaScript.TypedArray.ArrayBuffer.Internal (MutableArrayBuffer, SomeArrayBuffer(..))+#endif++-- | Helper function needed because there is no FromJSVal instance for MutableArrayBuffer+mutableArrayBufferFromJSVal :: JSVal -> JSM MutableArrayBuffer+#ifdef ghcjs_HOST_OS+mutableArrayBufferFromJSVal = return . pFromJSVal+#else+mutableArrayBufferFromJSVal = return . SomeArrayBuffer+#endif+{-# INLINE mutableArrayBufferFromJSVal #-}++-- | Helper function needed because there is no ToJSVal instance for MutableArrayBuffer+mutableArrayBufferToJSVal :: MutableArrayBuffer -> JSM JSVal+#ifdef ghcjs_HOST_OS+mutableArrayBufferToJSVal = return . pToJSVal+#else+mutableArrayBufferToJSVal (SomeArrayBuffer v) = return v+#endif+{-# INLINE mutableArrayBufferToJSVal #-}
+ src/Language/Javascript/JSaddle/Marshal/String.hs view
@@ -0,0 +1,32 @@+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE TypeSynonymInstances #-}+-----------------------------------------------------------------------------+--+-- Module      :  Language.Javascript.JSaddle.Marshal.String+-- Copyright   :  (c) Hamish Mackenzie+-- License     :  MIT+--+-- Maintainer  :  Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com>+--+-- | `JSStrings` in JSaddle (when compiled with GHC) is not a `JSVal` instead it+--   is implemented with a `Text`.+--+-----------------------------------------------------------------------------++module Language.Javascript.JSaddle.Marshal.String (+  -- * Type class to convert Haskell to JavaScript string+    ToJSString(..)+  , FromJSString(..)+) where++import Language.Javascript.JSaddle.Types (JSString)+import GHCJS.Marshal.Internal (ToJSVal(..), FromJSVal(..))++-- | Anything that can be used to make a JavaScript string+class ToJSVal a => ToJSString a where+    toJSString :: a -> JSString++-- | Anything that can be constructed from a JavaScript string+class FromJSVal a => FromJSString a where+    fromJSString :: JSString -> a+
src/Language/Javascript/JSaddle/Monad.hs view
@@ -1,5 +1,8 @@ {-# LANGUAGE CPP #-} {-# LANGUAGE PatternSynonyms #-}+#ifdef ghcjs_HOST_OS+{-# OPTIONS_GHC -Wno-dodgy-exports -Wno-dodgy-imports #-}+#endif ----------------------------------------------------------------------------- -- -- Module      :  Language.Javascript.JSaddle.Monad@@ -14,138 +17,51 @@  module Language.Javascript.JSaddle.Monad (   -- * Types-    JSM+    JSM(..)   , JSContextRef+  , MonadJSM+  , liftJSM -  -- * Running JSaddle given a DOM Window+  -- * Running JavaScript in a JavaScript context+  , askJSM+  , runJSM   , runJSaddle +  -- * Syncronizing with the JavaScript context+  , syncPoint+  , syncAfter+  , waitForAnimationFrame+  , nextAnimationFrame+   -- * Exception Handling-  , catchval   , catch   , bracket--  -- * GUI thread support-  , postGUIAsyncJS-  , postGUISyncJS ) where -import Prelude hiding (catch, read)-import Control.Monad.Trans.Reader (runReaderT, ask, ReaderT(..))-import Language.Javascript.JSaddle.Types-       (JSM, JSVal, MutableJSArray, JSContextRef)-import Control.Monad.IO.Class (MonadIO(..))-#ifdef ghcjs_HOST_OS-import GHCJS.Types (isUndefined, isNull)-import qualified JavaScript.Array as Array (create, read)-#else-import Language.Javascript.JSaddle.Native (makeNewJSVal)-import Foreign (nullPtr, alloca)-import Foreign.Storable (Storable(..))-import GI.WebKit.Objects.WebView-       (WebView(..), webViewGetMainFrame)-import GI.WebKit.Objects.WebFrame-       (webFrameGetGlobalContext)-import GI.GLib (idleAdd)-import GI.GLib.Constants(pattern PRIORITY_DEFAULT)-import Foreign.Ptr (castPtr)-import GI.JavaScriptCore.Structs.GlobalContext (GlobalContext(..))-import Foreign.ForeignPtr (withForeignPtr)-#endif-import qualified Control.Exception as E (Exception, catch, bracket)-import Control.Concurrent.MVar (takeMVar, putMVar, newEmptyMVar)- #ifndef ghcjs_HOST_OS--- | Post an action to be run in the main GUI thread.------ The current thread blocks until the action completes and the result is--- returned.----postGUISync :: IO a -> IO a-postGUISync action = do-  resultVar <- newEmptyMVar-  idleAdd PRIORITY_DEFAULT $ action >>= putMVar resultVar >> return False-  takeMVar resultVar---- | Post an action to be run in the main GUI thread.------ The current thread continues and does not wait for the result of the--- action.----postGUIAsync :: IO () -> IO ()-postGUIAsync action = do-  idleAdd PRIORITY_DEFAULT $ action >> return False-  return ()-#endif---- | Wrapped version of 'E.catch' that runs in a MonadIO that works---   a bit better with 'JSM'-catch :: (MonadIO m, E.Exception e)-      => ReaderT r IO b-      -> (e -> ReaderT r IO b)-      -> ReaderT r m b-t `catch` c = do-    r <- ask-    liftIO (runReaderT t r `E.catch` \e -> runReaderT (c e) r)---- | Wrapped version of 'E.bracket' that runs in a MonadIO that works---   a bit better with 'JSM'-bracket :: MonadIO m => ReaderT r IO a -> (a -> ReaderT r IO b) -> (a -> ReaderT r IO c) -> ReaderT r m c-bracket aquire release f = do-    r <- ask-    liftIO $ E.bracket-        (runReaderT aquire r)-        (\x -> runReaderT (release x) r)-        (\x -> runReaderT (f x) r)---- | Handle JavaScriptCore functions that take a MutableJSArray in order---   to throw exceptions.-catchval :: (MutableJSArray -> JSM a) -> (JSVal -> JSM a) -> JSM a-catchval f catcher = do-#ifdef ghcjs_HOST_OS-    pexc   <- liftIO Array.create-    result <- f pexc-    exc    <- liftIO $ Array.read 0 pexc-    if isUndefined exc || isNull exc-        then return result-        else catcher exc-#else-    gctxt <- ask-    liftIO . alloca $ \pexc -> flip runReaderT gctxt $ do-        liftIO $ poke pexc nullPtr-        result <- f pexc-        exc <- liftIO $ peek pexc-        if exc == nullPtr-            then return result-            else makeNewJSVal exc >>= catcher-#endif--#ifdef ghcjs_HOST_OS-runJSaddle :: MonadIO m => w -> JSM a -> m a-runJSaddle _ f = liftIO $ runReaderT f ()-#else-runJSaddle :: MonadIO m => WebView -> JSM a -> m a-runJSaddle webView f = liftIO $ do-    GlobalContext gctxt <- webViewGetMainFrame webView >>= webFrameGetGlobalContext-    withForeignPtr gctxt $ \ptr ->-        runReaderT f (castPtr ptr)+import Control.Monad.Trans.Reader (runReaderT, ask) #endif+import Control.Monad.IO.Class (MonadIO(..))+import Control.Monad.Catch (catch, bracket)+import Language.Javascript.JSaddle.Types (JSM(..), MonadJSM, liftJSM, JSContextRef)+import Language.Javascript.JSaddle.Run (syncPoint, syncAfter, waitForAnimationFrame, nextAnimationFrame) -postGUIAsyncJS :: JSM () -> JSM ()+-- | Gets the JavaScript context from the monad+askJSM :: MonadJSM m => m JSContextRef #ifdef ghcjs_HOST_OS-postGUIAsyncJS = id+askJSM = return () #else-postGUIAsyncJS f = do-    r <- ask-    liftIO . postGUIAsync $ runReaderT f r+askJSM = liftJSM $ JSM ask #endif -postGUISyncJS :: JSM a -> JSM a+-- | Runs a 'JSM' JavaScript function in a given JavaScript context.+runJSM :: MonadIO m => JSM a -> JSContextRef -> m a #ifdef ghcjs_HOST_OS-postGUISyncJS = id+runJSM f = liftIO . const f #else-postGUISyncJS f = do-    r <- ask-    liftIO . postGUISync $ runReaderT f r+runJSM f = liftIO . runReaderT (unJSM f) #endif +-- | Alternative version of 'runJSM'+runJSaddle :: MonadIO m => JSContextRef -> JSM a -> m a+runJSaddle = flip runJSM
src/Language/Javascript/JSaddle/Native.hs view
@@ -1,4 +1,3 @@-{-# LANGUAGE CPP #-} ----------------------------------------------------------------------------- -- -- Module      :  Language.Javascript.JSaddle.Native@@ -12,90 +11,17 @@ -----------------------------------------------------------------------------  module Language.Javascript.JSaddle.Native (-#if !defined(ghcjs_HOST_OS)-    makeNewJSVal-  , makeNewJSString-  , wrapJSString-  , withJSVal-  , withJSVals-  , withObject-  , withJSString+    module Language.Javascript.JSaddle.Native.Internal   , withToJSVal-#endif ) where -#if !defined(ghcjs_HOST_OS)-import Control.Monad.Trans.Reader (ask)-import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSBase-       (JSObjectRef, OpaqueJSString, JSStringRef, OpaqueJSContext,-        OpaqueJSValue, JSValueRef)-import Foreign.ForeignPtr-       (newForeignPtr_, touchForeignPtr, FinalizerPtr, newForeignPtr,-        FinalizerEnvPtr, newForeignPtrEnv, ForeignPtr)-import Control.Monad.IO.Class (MonadIO, MonadIO(..))-import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSValueRef-       (jsvalueprotect)-import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSStringRef-       (jsstringretain)+import GHCJS.Marshal.Internal (ToJSVal(..)) import Language.Javascript.JSaddle.Types-       (JSM, JSString, Object(..), JSVal)-import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)-import Language.Javascript.JSaddle.Classes (ToJSVal(..), ToJSVal)-import Foreign.Ptr (nullPtr)--makeNewJSVal :: JSValueRef -> JSM (ForeignPtr OpaqueJSValue)-makeNewJSVal val = do-    ctx <- ask-    liftIO $ do-        jsvalueprotect ctx val-        newForeignPtrEnv jsValueUnprotect ctx val--foreign import ccall unsafe "&JSValueUnprotect"-  jsValueUnprotect :: FinalizerEnvPtr OpaqueJSContext OpaqueJSValue--makeNewJSString :: MonadIO m => JSStringRef -> m (ForeignPtr OpaqueJSString)-makeNewJSString s | s == nullPtr =-    liftIO $ newForeignPtr_ s-makeNewJSString s =-    liftIO $ do-        s' <- jsstringretain s-        newForeignPtr jsStringRelease s'--wrapJSString :: MonadIO m => JSStringRef -> m (ForeignPtr OpaqueJSString)-wrapJSString s | s == nullPtr =-    liftIO $ newForeignPtr_ s-wrapJSString s = liftIO $ newForeignPtr jsStringRelease s--foreign import ccall unsafe "&JSStringRelease"-  jsStringRelease :: FinalizerPtr OpaqueJSString--withJSVal :: MonadIO m => JSVal -> (JSValueRef -> m a) -> m a-withJSVal v f =- do result <- f (unsafeForeignPtrToPtr v)-    liftIO $ touchForeignPtr v-    return result--withJSVals :: MonadIO m => [JSVal] -> ([JSValueRef] -> m a) -> m a-withJSVals v f =- do result <- f (map unsafeForeignPtrToPtr v)-    liftIO $ mapM_ touchForeignPtr v-    return result--withObject :: MonadIO m => Object -> (JSObjectRef -> m a) -> m a-withObject (Object o) f = do-    result <- f (unsafeForeignPtrToPtr o)-    liftIO $ touchForeignPtr o-    return result--withJSString :: MonadIO m => JSString -> (JSStringRef -> m a) -> m a-withJSString v f =- do result <- f (unsafeForeignPtrToPtr v)-    liftIO $ touchForeignPtr v-    return result+       (JSM(..), JSValueForSend(..))+import Language.Javascript.JSaddle.Native.Internal -withToJSVal :: ToJSVal val => val -> (JSValueRef -> JSM a) -> JSM a+withToJSVal :: ToJSVal val => val -> (JSValueForSend -> JSM a) -> JSM a withToJSVal val f = do     v <- toJSVal val     withJSVal v f-#endif
+ src/Language/Javascript/JSaddle/Native/Internal.hs view
@@ -0,0 +1,253 @@+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE UnboxedTuples #-}+-----------------------------------------------------------------------------+--+-- Module      :  Language.Javascript.JSaddle.Native+-- Copyright   :  (c) Hamish Mackenzie+-- License     :  MIT+--+-- Maintainer  :  Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com>+--+-- |+--+-----------------------------------------------------------------------------++module Language.Javascript.JSaddle.Native.Internal (+    wrapJSVal+  , wrapJSString+  , withJSVal+  , withJSVals+  , withObject+  , withJSString+  , setPropertyByName+  , setPropertyAtIndex+  , stringToValue+  , numberToValue+  , jsonValueToValue+  , getPropertyByName+  , getPropertyAtIndex+  , callAsFunction+  , callAsConstructor+  , newEmptyObject+  , newAsyncCallback+  , newSyncCallback+  , newArray+  , evaluateScript+  , deRefVal+  , valueToBool+  , valueToNumber+  , valueToString+  , valueToJSON+  , valueToJSONValue+  , isNull+  , isUndefined+  , strictEqual+  , instanceOf+  , propertyNames+) where++import Control.Monad.IO.Class (MonadIO(..))++import Data.Aeson (Value)++import Language.Javascript.JSaddle.Types+       (AsyncCommand(..), JSM(..), JSString(..), addCallback,+        Object(..), JSVal(..), JSValueForSend(..), JSCallAsFunction,+        JSStringReceived(..), JSStringForSend(..), JSObjectForSend(..))+import Language.Javascript.JSaddle.Monad (askJSM)+import Language.Javascript.JSaddle.Run+       (Command(..), Result(..), sendCommand,+        sendAsyncCommand, sendLazyCommand, wrapJSVal)+import GHC.IORef (IORef(..), readIORef)+import GHC.STRef (STRef(..))+import GHC.IO (IO(..))+import GHC.Base (touch#)++wrapJSString :: MonadIO m => JSStringReceived -> m JSString+wrapJSString (JSStringReceived ref) = return $ JSString ref++touchIORef :: IORef a -> IO ()+touchIORef (IORef (STRef r#)) = IO $ \s -> case touch# r# s of s' -> (# s', () #)++withJSVal :: MonadIO m => JSVal -> (JSValueForSend -> m a) -> m a+withJSVal (JSVal ref) f = do+    result <- (f . JSValueForSend) =<< liftIO (readIORef ref)+    liftIO $ touchIORef ref+    return result++withJSVals :: MonadIO m => [JSVal] -> ([JSValueForSend] -> m a) -> m a+withJSVals v f =+ do result <- f =<< mapM (\(JSVal ref) -> liftIO $ JSValueForSend <$> readIORef ref) v+    liftIO $ mapM_ (\(JSVal ref) -> touchIORef ref) v+    return result++withObject :: MonadIO m => Object -> (JSObjectForSend -> m a) -> m a+withObject (Object o) f = withJSVal o (f . JSObjectForSend)++withJSString :: MonadIO m => JSString -> (JSStringForSend -> m a) -> m a+withJSString (JSString ref) f = f (JSStringForSend ref)++setPropertyByName :: JSString -> JSVal -> Object -> JSM ()+setPropertyByName name val this =+    withObject this $ \rthis ->+        withJSString name $ \rname ->+            withJSVal val $ \rval ->+                sendAsyncCommand $ SetPropertyByName rthis rname rval+{-# INLINE setPropertyByName #-}++setPropertyAtIndex :: Int -> JSVal -> Object -> JSM ()+setPropertyAtIndex index val this =+    withObject this $ \rthis ->+        withJSVal val $ \rval ->+            sendAsyncCommand $ SetPropertyAtIndex rthis index rval+{-# INLINE setPropertyAtIndex #-}++stringToValue :: JSString -> JSM JSVal+stringToValue s = withJSString s $ sendLazyCommand . StringToValue+{-# INLINE stringToValue #-}++numberToValue :: Double -> JSM JSVal+numberToValue = sendLazyCommand . NumberToValue+{-# INLINE numberToValue #-}++jsonValueToValue :: Value -> JSM JSVal+jsonValueToValue = sendLazyCommand . JSONValueToValue+{-# INLINE jsonValueToValue #-}++getPropertyByName :: JSString -> Object -> JSM JSVal+getPropertyByName name this =+    withObject this $ \rthis ->+        withJSString name $ sendLazyCommand . GetPropertyByName rthis+{-# INLINE getPropertyByName #-}++getPropertyAtIndex :: Int -> Object -> JSM JSVal+getPropertyAtIndex index this =+    withObject this $ \rthis -> sendLazyCommand $ GetPropertyAtIndex rthis index+{-# INLINE getPropertyAtIndex #-}++callAsFunction :: Object -> Object -> [JSVal] -> JSM JSVal+callAsFunction f this args =+    withObject f $ \rfunction ->+        withObject this $ \rthis ->+            withJSVals args $ sendLazyCommand . CallAsFunction rfunction rthis+{-# INLINE callAsFunction #-}++callAsConstructor :: Object -> [JSVal] -> JSM JSVal+callAsConstructor f args =+    withObject f $ \rfunction ->+        withJSVals args $ sendLazyCommand . CallAsConstructor rfunction+{-# INLINE callAsConstructor #-}++newEmptyObject :: JSM Object+newEmptyObject = Object <$> sendLazyCommand NewEmptyObject+{-# INLINE newEmptyObject #-}++newAsyncCallback :: JSCallAsFunction -> JSM Object+newAsyncCallback f = do+    object <- Object <$> sendLazyCommand NewAsyncCallback+    add <- addCallback <$> askJSM+    liftIO $ add object f+    return object+{-# INLINE newAsyncCallback #-}++newSyncCallback :: JSCallAsFunction -> JSM Object+newSyncCallback f = do+    object <- Object <$> sendLazyCommand NewSyncCallback+    add <- addCallback <$> askJSM+    liftIO $ add object f+    return object+{-# INLINE newSyncCallback #-}++newArray :: [JSVal] -> JSM JSVal+newArray xs = withJSVals xs $ \xs' -> sendLazyCommand (NewArray xs')+{-# INLINE newArray #-}++evaluateScript :: JSString -> JSM JSVal+evaluateScript script = withJSString script $ sendLazyCommand . EvaluateScript+{-# INLINE evaluateScript #-}++deRefVal :: JSVal -> JSM Result+deRefVal value = withJSVal value $ sendCommand . DeRefVal+{-# INLINE deRefVal #-}++valueToBool :: JSVal -> JSM Bool+valueToBool v@(JSVal ref) = liftIO (readIORef ref) >>= \case+    0 -> return False -- null+    1 -> return False -- undefined+    2 -> return False -- false+    3 -> return True  -- true+    _ -> withJSVal v $ \rval -> do+        (ValueToBoolResult result) <- sendCommand (ValueToBool rval)+        return result+{-# INLINE valueToBool #-}++valueToNumber :: JSVal -> JSM Double+valueToNumber value =+    withJSVal value $ \rval -> do+        (ValueToNumberResult result) <- sendCommand (ValueToNumber rval)+        return result+{-# INLINE valueToNumber #-}++valueToString :: JSVal -> JSM JSString+valueToString value = withJSVal value $ \rval -> do+    (ValueToStringResult result) <- sendCommand (ValueToString rval)+    wrapJSString result+{-# INLINE valueToString #-}++valueToJSON :: JSVal -> JSM JSString+valueToJSON value = withJSVal value $ \rval -> do+    (ValueToJSONResult result) <- sendCommand (ValueToJSON rval)+    wrapJSString result+{-# INLINE valueToJSON #-}++valueToJSONValue :: JSVal -> JSM Value+valueToJSONValue value = withJSVal value $ \rval -> do+    (ValueToJSONValueResult result) <- sendCommand (ValueToJSONValue rval)+    return result+{-# INLINE valueToJSONValue #-}++isNull :: JSVal -> JSM Bool+isNull v@(JSVal ref) = liftIO (readIORef ref) >>= \case+    0 -> return True  -- null+    1 -> return False -- undefined+    2 -> return False -- false+    3 -> return False -- true+    _ -> withJSVal v $ \rval -> do+        (IsNullResult result) <- sendCommand $ IsNull rval+        return result+{-# INLINE isNull #-}++isUndefined :: JSVal -> JSM Bool+isUndefined v@(JSVal ref) = liftIO (readIORef ref) >>= \case+    0 -> return False -- null+    1 -> return True  -- undefined+    2 -> return False -- false+    3 -> return False -- true+    _ -> withJSVal v $ \rval -> do+        (IsUndefinedResult result) <- sendCommand $ IsUndefined rval+        return result+{-# INLINE isUndefined #-}++strictEqual :: JSVal -> JSVal -> JSM Bool+strictEqual a b =+    withJSVal a $ \aref ->+        withJSVal b $ \bref -> do+            (StrictEqualResult result) <- sendCommand $ StrictEqual aref bref+            return result+{-# INLINE strictEqual #-}++instanceOf :: JSVal -> Object -> JSM Bool+instanceOf value constructor =+    withJSVal value $ \rval ->+        withObject constructor $ \c' -> do+            (InstanceOfResult result) <- sendCommand $ InstanceOf rval c'+            return result+{-# INLINE instanceOf #-}++propertyNames :: Object -> JSM [JSString]+propertyNames this =+    withObject this $ \rthis -> do+        (PropertyNamesResult result) <- sendCommand $ PropertyNames rthis+        mapM wrapJSString result+{-# INLINE propertyNames #-}
+ src/Language/Javascript/JSaddle/Null.hs view
@@ -0,0 +1,56 @@+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedStrings #-}+-----------------------------------------------------------------------------+--+-- Module      :  Language.Javascript.JSaddle.WebSockets+-- Copyright   :  (c) Hamish Mackenzie+-- License     :  MIT+--+-- Maintainer  :  Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com>+--+-- |+--+-----------------------------------------------------------------------------++module Language.Javascript.JSaddle.Null (+    run+) where++import Language.Javascript.JSaddle.Types+       (BatchResults(..), JSM, JSStringReceived(..), Batch(..),+        Results(..), Result(..), Command(..))+import Control.Concurrent.Chan (readChan, writeChan, newChan)+import Language.Javascript.JSaddle.Run (runJavaScript)+import Control.Concurrent (forkIO)+import Control.Monad (forever)+import Data.Aeson (Value(..))+import Data.Maybe (mapMaybe)++-- | This is for performance testing JSaddle code that does not need to+-- to read anything back from the JavaScript context.+-- Anthing that does try to read will get JS null, 0 or "" back (depending+-- on how the value is read).+run :: JSM () -> IO ()+run f = do+    batches <- newChan+    (processResult, _processSyncResult, start) <- runJavaScript (writeChan batches) f+    _ <- forkIO $ forever $+        readChan batches >>= \case+            Batch commands _ batchNumber ->+                processResult $ BatchResults batchNumber . Success [] $ mapMaybe (\case+                        Left _ -> Nothing+                        Right command -> Just $+                            case command of+                                DeRefVal _ -> DeRefValResult 0 ""+                                ValueToBool _ -> ValueToBoolResult False+                                ValueToNumber _ -> ValueToNumberResult 0+                                ValueToString _ -> ValueToStringResult (JSStringReceived "")+                                ValueToJSON _ -> ValueToJSONResult (JSStringReceived "null")+                                ValueToJSONValue _ -> ValueToJSONValueResult Null+                                IsNull _ -> IsNullResult True+                                IsUndefined _ -> IsUndefinedResult False+                                StrictEqual _ _ -> StrictEqualResult False+                                InstanceOf _ _ -> InstanceOfResult False+                                PropertyNames _ -> PropertyNamesResult []+                                Sync -> SyncResult) commands+    start
src/Language/Javascript/JSaddle/Object.hs view
@@ -6,6 +6,7 @@ #ifdef ghcjs_HOST_OS {-# LANGUAGE ForeignFunctionInterface #-} {-# LANGUAGE JavaScriptFFI #-}+{-# OPTIONS_GHC -Wno-dodgy-exports -Wno-dodgy-imports #-} #endif {-# OPTIONS_GHC -fno-warn-orphans #-} -----------------------------------------------------------------------------@@ -21,7 +22,7 @@ -----------------------------------------------------------------------------  module Language.Javascript.JSaddle.Object (-    Object+    Object(..)   , MakeObject(..)    -- * Property lookup@@ -56,10 +57,16 @@   , new   , call   , obj+  , create+  , getProp+  , unsafeGetProp+  , setProp+  , unsafeSetProp    -- * Calling Haskell From JavaScript   , Function(..)   , function+  , asyncFunction   , freeFunction   , fun   , JSCallAsFunction@@ -74,12 +81,14 @@   --   and pass it to the continuation.    -- * Arrays+  , fromListIO   , array    -- * Global Object   , global    -- * Enumerating Properties+  , listProps   , propertyNames   , properties @@ -89,69 +98,57 @@   , nullObject ) where -import Control.Applicative import Prelude hiding ((!!))-import Language.Javascript.JSaddle.Types-       (JSPropertyNameArray, JSString, Object(..), MutableJSArray,-        JSVal, Index)-import Foreign.C.Types (CSize(..), CULong(..), CUInt(..), CULLong(..))+import Data.Coerce (coerce) #ifdef ghcjs_HOST_OS-import GHCJS.Types (nullRef, jsval)+import GHCJS.Types (nullRef)+#if __GLASGOW_HASKELL__ >= 900+import GHC.JS.Foreign.Callback+#else import GHCJS.Foreign.Callback-       (releaseCallback, syncCallback2, OnBlocked(..), Callback)-import GHCJS.Marshal.Pure (pFromJSVal)-import JavaScript.Array (JSArray)+#endif+       (releaseCallback, syncCallback2, asyncCallback2, OnBlocked(..), Callback)+import GHCJS.Marshal (ToJSVal(..))+import JavaScript.Array (MutableJSArray) import qualified JavaScript.Array as Array (toListIO, fromListIO) import JavaScript.Array.Internal (SomeJSArray(..))-import qualified JavaScript.Object as Object (create)-import Control.Monad (liftM)-import Data.Coerce (coerce)+import JavaScript.Object (create, listProps)+import Language.Javascript.JSaddle.Monad (JSM)+import Language.Javascript.JSaddle.Types+       (JSString, Object(..),+        JSVal(..), JSCallAsFunction) #else-import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSObjectRef-       (jsobjectmake, jspropertynamearraygetnameatindex,-        jspropertynamearraygetcount, jsobjectcopypropertynames,-        jsobjectcallasconstructor, jsobjectmakearray,-        jsobjectcallasfunction,-        JSObjectCallAsFunctionCallback, mkJSObjectCallAsFunctionCallback,-        jsobjectmakefunctionwithcallback)-import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSValueRef-       (jsvaluemakeundefined)-import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSContextRef-       (jscontextgetglobalobject)-import Foreign (peekArray, nullPtr, withArrayLen)-import Foreign.Ptr (freeHaskellFunPtr)+import GHCJS.Marshal.Internal (ToJSVal(..)) import Language.Javascript.JSaddle.Native-       (makeNewJSString, makeNewJSVal, wrapJSString, withJSVals,-        withObject, withJSString, withToJSVal)-import System.IO.Unsafe (unsafePerformIO)-import Foreign.ForeignPtr (newForeignPtr_)+       (newAsyncCallback, newSyncCallback, callAsFunction, callAsConstructor)+import Language.Javascript.JSaddle.Monad (askJSM, JSM)+import Language.Javascript.JSaddle.Types+       (JSValueForSend(..), AsyncCommand(..), JSString, Object(..),+        SomeJSArray(..), JSVal(..), JSCallAsFunction, JSContextRef(..))+import JavaScript.Object.Internal (create, listProps)+import Language.Javascript.JSaddle.Run (sendAsyncCommand) #endif-import Language.Javascript.JSaddle.Exception (rethrow)-import Language.Javascript.JSaddle.Value-       (JSUndefined, valToObject)-import Language.Javascript.JSaddle.Classes-       (ToJSVal(..), ToJSString(..), MakeObject(..))+import JavaScript.Array.Internal (fromListIO)+import Language.Javascript.JSaddle.Value (valToObject)+import Language.Javascript.JSaddle.Classes (MakeObject(..))+import Language.Javascript.JSaddle.Marshal.String (ToJSString(..)) import Language.Javascript.JSaddle.Arguments (MakeArgs(..))-import Language.Javascript.JSaddle.Monad-       (JSM)-import Control.Monad.Trans.Reader (runReaderT, ask) import Control.Monad.IO.Class (MonadIO(..))-import qualified Control.Exception as E (catch)-import Control.Exception (SomeException)-import Foreign.Storable (Storable(..)) import Language.Javascript.JSaddle.Properties import Control.Lens (IndexPreservingGetter, to)-import Language.Javascript.JSaddle.String (nullJSString)-import Data.Text (Text)+import Data.IORef (newIORef, readIORef)+import System.IO.Unsafe (unsafePerformIO)  -- $setup+-- >>> import Control.Concurrent.MVar (newEmptyMVar, takeMVar, putMVar) -- >>> import Language.Javascript.JSaddle.Test (testJSaddle) -- >>> import Language.Javascript.JSaddle.Evaluate (eval)--- >>> import Language.Javascript.JSaddle.Value (val, valToText, JSNull(..))+-- >>> import Language.Javascript.JSaddle.Value (val, valToText, JSNull(..), deRefVal)+-- >>> import Language.Javascript.JSaddle.String (strToText) -- >>> import Control.Lens.Operators ((^.)) -- >>> import qualified Data.Text as T (unpack) --- | Object can be made by evaluating a fnction in 'JSM' as long+-- | Object can be made by evaluating a function in 'JSM' as long --   as it returns something we can make into a Object. instance MakeObject v => MakeObject (JSM v) where     makeObject v = v >>= makeObject@@ -168,9 +165,7 @@     -> JSM JSVal -- ^ Property reference this ! name = do     rthis <- makeObject this-    rethrow $ objGetPropertyByName rthis rname-  where-    rname = toJSString name+    objGetPropertyByName rthis name  -- | Lookup a property based on its index. --@@ -179,12 +174,12 @@ -- >>> testJSaddle $ val "Hello World" !! 6 -- W (!!) :: (MakeObject this)-     => this           -- ^ Object to look on-     -> Index          -- ^ Index of the property to lookup+     => this      -- ^ Object to look on+     -> Int       -- ^ Index of the property to lookup      -> JSM JSVal -- ^ Property reference this !! index = do     rthis <- makeObject this-    rethrow $ objGetPropertyAtIndex rthis index+    objGetPropertyAtIndex rthis index  -- | Makes a getter for a particular property name. --@@ -197,7 +192,7 @@ js :: (MakeObject s, ToJSString name)    => name          -- ^ Name of the property to find    -> IndexPreservingGetter s (JSM JSVal)-js name = to (!name)+js name = to (! name)  -- | Makes a setter for a particular property name. --@@ -206,7 +201,7 @@ -- >>> testJSaddle $ eval "'Hello World'.length = 12" -- 12 -- >>> testJSaddle $ val "Hello World" ^. jss "length" 12--- 12+-- undefined jss :: (ToJSString name, ToJSVal val)    => name          -- ^ Name of the property to find    -> val@@ -268,12 +263,8 @@ -- | Handy way to get and hold onto a reference top level javascript -- -- >>> testJSaddle $ eval "w = console; w.log('Hello World')"--- ** Message: console message:  @1: Hello World--- <BLANKLINE> -- undefined -- >>> testJSaddle $ do w <- jsg "console"; w ^. js1 "log" "Hello World"--- ** Message: console message:...@0: Hello World--- <BLANKLINE> -- undefined jsg :: ToJSString a => a -> JSM JSVal jsg name = global ! name@@ -293,8 +284,9 @@ -- -- > jsg0 name = jsgf name () ----- >>> testJSaddle $ jsg0 "globalFunc"--- TypeError:...undefined...is not an objec...+-- >>> testJSaddle $ jsg0 "globalFunc" >>= valToText+-- A JavaScript exception was thrown! (may not reach Haskell code)+-- TypeError:...undefine... jsg0 :: (ToJSString name) => name -> JSM JSVal jsg0 name = jsgf name () @@ -339,9 +331,9 @@     => this -> name -> args -> JSM JSVal (#) this name args = do     rthis <- makeObject this-    f <- rethrow $ objGetPropertyByName rthis name+    f <- objGetPropertyByName rthis name     f' <- valToObject f-    rethrow $ objCallAsFunction f' rthis args+    objCallAsFunction f' rthis args  -- | Call a JavaScript function --@@ -351,12 +343,12 @@ -- 5 infixr 2 ## (##) :: (MakeObject this, MakeArgs args)-    => this -> Index -> args -> JSM JSVal+    => this -> Int -> args -> JSM JSVal (##) this index args = do     rthis <- makeObject this-    f <- rethrow $ objGetPropertyAtIndex rthis index+    f <- objGetPropertyAtIndex rthis index     f' <- valToObject f-    rethrow $ objCallAsFunction f' rthis args+    objCallAsFunction f' rthis args  -- | Set a JavaScript property --@@ -372,7 +364,7 @@      -> JSM () (<#) this name val = do     rthis <- makeObject this-    rethrow $ objSetPropertyByName rthis name val 0+    objSetPropertyByName rthis name val  -- | Set a JavaScript property --@@ -382,13 +374,13 @@ -- 1 infixr 1 <## (<##) :: (MakeObject this, ToJSVal val)-     => this           -- ^ Object to set the property on-     -> Index          -- ^ Index of the property to set-     -> val            -- ^ Value to set it to+     => this   -- ^ Object to set the property on+     -> Int    -- ^ Index of the property to set+     -> val    -- ^ Value to set it to      -> JSM () (<##) this index val = do     rthis <- makeObject this-    rethrow $ objSetPropertyAtIndex rthis index val+    objSetPropertyAtIndex rthis index val  -- | Use this to create a new JavaScript object --@@ -403,7 +395,7 @@     -> JSM JSVal new constructor args = do     f <- makeObject constructor-    rethrow $ objCallAsConstructor f args+    objCallAsConstructor f args  -- | Call function with a given @this@.  In most cases you should use '#'. --@@ -416,7 +408,7 @@ call f this args = do     rfunction <- makeObject f     rthis     <- makeObject this-    rethrow $ objCallAsFunction rfunction rthis args+    objCallAsFunction rfunction rthis args  -- | Make an empty object using the default constuctor --@@ -425,119 +417,109 @@ -- >>> testJSaddle $ do { a <- obj; (a <# "x") "Hello"; a ^. js "x" } -- Hello obj :: JSM Object-#ifdef ghcjs_HOST_OS-obj = liftIO Object.create-#else-obj = do-    gctxt <- ask-    Object <$> (liftIO (jsobjectmake gctxt nullPtr nullPtr) >>= makeNewJSVal)-#endif---- | Type used for Haskell functions called from JavaScript.-type JSCallAsFunction = JSVal      -- ^ Function object-                     -> JSVal      -- ^ this-                     -> [JSVal]    -- ^ Function arguments-                     -> JSM JSUndefined -- ^ Only 'JSUndefined' can be returned because-                                        --   the function may need to be executed in a-                                        --   different thread.  If you need to get a-                                        --   value out pass in a continuation function-                                        --   as an argument and invoke it from haskell.+obj = create  -- | Short hand @::JSCallAsFunction@ so a haskell function can be passed to --   a to a JavaScipt one. -- -- >>> testJSaddle $ eval "(function(f) {f('Hello');})(function (a) {console.log(a)})"--- ** Message: console message:  @1: Hello--- <BLANKLINE> -- undefined--- >>> testJSaddle $ call (eval "(function(f) {f('Hello');})") global [fun $ \ _ _ args -> valToText (head args) >>= (liftIO . putStrLn . T.unpack) ]+-- >>> :{+--  testJSaddle $ do+--    result <- liftIO newEmptyMVar+--    deRefVal $ call (eval "(function(f) {f('Hello');})") global [fun $ \ _ _ [arg1] -> do+--         valToText arg1 >>= (liftIO . putMVar result)+--         ]+--    liftIO $ takeMVar result+-- :} -- Hello--- undefined fun :: JSCallAsFunction -> JSCallAsFunction fun = id  #ifdef ghcjs_HOST_OS-type HaskellCallback = Callback (JSVal -> JSVal -> IO ())+data Function = Function {functionCallback :: Callback (JSVal -> JSVal -> IO ()), functionObject :: Object} #else-type HaskellCallback = JSObjectCallAsFunctionCallback+newtype Function = Function {functionObject :: Object} #endif -data Function = Function {functionCallback :: HaskellCallback, functionObject :: Object} --- ^ Make a JavaScript function object that wraps a Haskell function.-function :: ToJSString name-         => name             -- ^ Name of the function-         -> JSCallAsFunction -- ^ Haskell function to call-         -> JSM Function       -- ^ Returns a JavaScript function object that will+#ifdef ghcjs_HOST_OS+-- Do not replace `function ()` with `=>` as `arguments` will not work+foreign import javascript unsafe+#if __GLASGOW_HASKELL__ >= 900+  "(($1) => { return function () { $1(this, arguments); }; })"+#else+  "$r = function () { $1(this, arguments); }"+#endif+    makeFunctionWithCallback :: Callback (JSVal -> JSVal -> IO ()) -> IO Object+#endif++-- | Make a JavaScript function object that wraps a Haskell function.+-- Calls made to the function will be synchronous where possible+-- (on GHCJS it uses on `syncCallback2` with `ContinueAsync`).+function :: JSCallAsFunction -- ^ Haskell function to call+         -> JSM Function     -- ^ Returns a JavaScript function object that will                              --   call the Haskell one when it is called #ifdef ghcjs_HOST_OS-function name f = liftIO $ do+function f = do     callback <- syncCallback2 ContinueAsync $ \this args -> do         rargs <- Array.toListIO (coerce args)-        runReaderT (f this this rargs) () -- TODO pass function object through-    Function callback <$> makeFunctionWithCallback (toJSString name) callback-foreign import javascript unsafe "$r = function () { $2(this, arguments); }"-    makeFunctionWithCallback :: JSString -> Callback (JSVal -> JSVal -> IO ()) -> IO Object+        f this this rargs -- TODO pass function object through+    Function callback <$> makeFunctionWithCallback callback #else-function name f = do-    gctxt <- ask-    callback <- liftIO $ mkJSObjectCallAsFunctionCallback (wrap gctxt)-    withJSString (toJSString name) $ \name' ->-        Function callback . Object <$>-            (liftIO (jsobjectmakefunctionwithcallback gctxt name' callback) >>= makeNewJSVal)-  where-    wrap gctxt _ctx fobj' this' argc argv exception = do-            args' <- peekArray (fromIntegral argc) argv-            (`runReaderT` gctxt) $ do-                fobj <- makeNewJSVal fobj'-                this <- makeNewJSVal this'-                args <- mapM makeNewJSVal args'-                f fobj this args-                liftIO $ jsvaluemakeundefined gctxt-      `E.catch` \(e :: SomeException) ->-            (`runReaderT` gctxt) $ do-                withToJSVal (show e) $ liftIO . poke exception-                liftIO $ jsvaluemakeundefined gctxt+function f = do+    object <- newSyncCallback f+    return $ Function object #endif -freeFunction :: MonadIO m => Function -> m ()-freeFunction (Function callback _) = liftIO $+-- | Make a JavaScript function object that wraps a Haskell function.+-- Calls made to the function will be asynchronous.+asyncFunction :: JSCallAsFunction -- ^ Haskell function to call+              -> JSM Function     -- ^ Returns a JavaScript function object that will+                                  --   call the Haskell one when it is called #ifdef ghcjs_HOST_OS+asyncFunction f = do+    callback <- asyncCallback2 $ \this args -> do+        rargs <- Array.toListIO (coerce args)+        f this this rargs -- TODO pass function object through+    Function callback <$> makeFunctionWithCallback callback+#else+asyncFunction f = do+    object <- newAsyncCallback f+    return $ Function object+#endif++freeFunction :: Function -> JSM ()+#ifdef ghcjs_HOST_OS+freeFunction (Function callback _) = liftIO $     releaseCallback callback #else-    freeHaskellFunPtr callback+freeFunction (Function (Object (JSVal objectRef))) = do+    -- By now the callback should ideally have been removed from whatever+    -- events it was added to.+    -- In case a call to the callback is still pending (perhaps just being sent+    -- on the JS side) we use FreeCallback to queue the callback to be freed when+    -- the next batch of results comes back fro JS.+    -- We are not using withJSVal to keep JS value "alive" because FreeCallback+    -- does not use the it.+    n <- liftIO $ readIORef objectRef+    sendAsyncCommand (FreeCallback (JSValueForSend n)) #endif  instance ToJSVal Function where-    toJSVal (Function _ f) = toJSVal f+    toJSVal = toJSVal . functionObject  -- | A callback to Haskell can be used as a JavaScript value.  This will create --   an anonymous JavaScript function object.  Use 'function' to create one with --   a name. instance ToJSVal JSCallAsFunction where-    toJSVal f = functionObject <$> function nullJSString f >>= toJSVal+    toJSVal f = functionObject <$> function f >>= toJSVal  instance MakeArgs JSCallAsFunction where     makeArgs f = do-        rarg <- functionObject <$> function nullJSString f >>= toJSVal+        rarg <- functionObject <$> function f >>= toJSVal         return [rarg] -makeArray :: MakeArgs args => args -> MutableJSArray -> JSM Object-#ifdef ghcjs_HOST_OS-makeArray args exceptions = do-    rargs <- makeArgs args-    liftIO $ Object . jsval <$> Array.fromListIO rargs-#else-makeArray args exceptions = do-    gctxt <- ask-    rargs <- makeArgs args-    result <--        withJSVals rargs $ \rargs' ->-            liftIO $ withArrayLen rargs' $ \ len ptr ->-                jsobjectmakearray gctxt (fromIntegral len) ptr exceptions-    Object <$> makeNewJSVal result-#endif- -- | Make an JavaScript array from a list of values -- -- >>> testJSaddle $ eval "['Hello', 'World'][1]"@@ -549,82 +531,31 @@ -- >>> testJSaddle $ array ("Hello", JSNull, (), True, 1.0::Double) -- Hello,,,true,1 array :: MakeArgs args => args -> JSM Object-array = rethrow . makeArray---- Make an array out of various lists-instance ToJSVal [JSVal] where-    toJSVal = toJSVal . array--instance ToJSVal [JSM JSVal] where-    toJSVal = toJSVal . array--instance ToJSVal [Double] where-    toJSVal = toJSVal . array--instance ToJSVal [Float] where-    toJSVal = toJSVal . array--instance ToJSVal [Int] where-    toJSVal = toJSVal . array--instance ToJSVal [JSString] where-    toJSVal = toJSVal . array--instance ToJSVal [String] where-    toJSVal = toJSVal . array--instance ToJSVal [Text] where-    toJSVal = toJSVal . array--instance ToJSVal [Bool] where-    toJSVal = toJSVal . array+array args = do+    rargs <- makeArgs args+    Object . coerce <$> fromListIO rargs  -- | JavaScript's global object-global :: JSM Object #ifdef ghcjs_HOST_OS-global = liftIO js_window-foreign import javascript unsafe "$r = window"-    js_window :: IO Object+foreign import javascript unsafe+#if __GLASGOW_HASKELL__ >= 900+  "(() => { return globalThis; })" #else-global = do-    gctxt <- ask-    result <- liftIO $ jscontextgetglobalobject gctxt-    Object <$> makeNewJSVal result+  "$r = globalThis" #endif---- | Get an array containing the property names present on a given object-#if !defined(ghcjs_HOST_OS)-copyPropertyNames :: MakeObject this => this -> JSM JSPropertyNameArray-copyPropertyNames this = do-    gctxt <- ask-    this' <- makeObject this-    withObject this' $ \rthis ->-        liftIO $ jsobjectcopypropertynames gctxt rthis---- | Get the number of names in a property name array-propertyNamesCount :: MonadIO m => JSPropertyNameArray -> m CSize-propertyNamesCount names = liftIO $ jspropertynamearraygetcount names---- | Get a name out of a property name array-propertyNamesAt :: MonadIO m => JSPropertyNameArray -> CSize -> m JSString-propertyNamesAt names index = liftIO $ jspropertynamearraygetnameatindex names index >>= makeNewJSString---- | Convert property array to a list-propertyNamesList :: MonadIO m => JSPropertyNameArray -> m [JSString]-propertyNamesList names = do-    count <- propertyNamesCount names-    mapM (propertyNamesAt names) $ enumFromTo 0 (count - 1)+    global :: Object+#else+global :: Object+global = Object . JSVal . unsafePerformIO $ newIORef 4 #endif  -- | Get a list containing the property names present on a given object+-- >>> testJSaddle $ show . map strToText <$> propertyNames obj+-- []+-- >>> testJSaddle $ show . map strToText <$> propertyNames (eval "({x:1, y:2})")+-- ["x","y"] propertyNames :: MakeObject this => this -> JSM [JSString]-#ifdef ghcjs_HOST_OS-propertyNames this = makeObject this >>= liftIO . js_propertyNames >>= liftIO . (fmap (map pFromJSVal)) . Array.toListIO-foreign import javascript unsafe "$r = []; h$forIn($1, function(n){$r.push(n);})"-    js_propertyNames :: Object -> IO JSArray-#else-propertyNames this = copyPropertyNames this >>= propertyNamesList-#endif+propertyNames this = makeObject this >>= listProps  -- | Get a list containing references to all the  properties present on a given object properties :: MakeObject this => this -> JSM [JSVal]@@ -635,25 +566,22 @@                   => Object                   -> Object                   -> args-                  -> MutableJSArray                   -> JSM JSVal #ifdef ghcjs_HOST_OS-objCallAsFunction f this args exceptions = do+objCallAsFunction f this args = do     rargs <- makeArgs args >>= liftIO . Array.fromListIO-    liftIO $ js_apply f this rargs exceptions-foreign import javascript unsafe "try { $r = $1.apply($2, $3) } catch(e) { $4[0] = e }"-    js_apply :: Object -> Object -> MutableJSArray -> MutableJSArray -> IO JSVal+    liftIO $ js_apply f this rargs+foreign import javascript safe+#if __GLASGOW_HASKELL__ >= 900+  "(($1,$2,$3) => { return $1.apply($2, $3); })" #else-objCallAsFunction f this args exceptions = do-    gctxt <- ask+  "$r = $1.apply($2, $3)"+#endif+    js_apply :: Object -> Object -> MutableJSArray -> IO JSVal+#else+objCallAsFunction f this args = do     rargs <- makeArgs args-    result <--        withObject f $ \rfunction ->-            withObject this $ \rthis ->-                withJSVals rargs $ \rargs' ->-                    liftIO $ withArrayLen rargs' $ \ largs pargs ->-                        jsobjectcallasfunction gctxt rfunction rthis (fromIntegral largs) pargs exceptions-    makeNewJSVal result+    callAsFunction f this rargs #endif  -- | Call a JavaScript object as a constructor. Consider using 'new'.@@ -663,15 +591,39 @@ objCallAsConstructor :: MakeArgs args                      => Object                      -> args-                     -> MutableJSArray                      -> JSM JSVal #ifdef ghcjs_HOST_OS-objCallAsConstructor f args exceptions = do+objCallAsConstructor f args = do     rargs <- makeArgs args >>= liftIO . Array.fromListIO-    liftIO $ js_new f rargs exceptions-foreign import javascript unsafe "\-    try {\+    liftIO $ js_new f rargs+foreign import javascript safe+#if __GLASGOW_HASKELL__ >= 900+  "(($1,$2) => {\         switch($2.length) {\+            case 0 : return new $1();\+            case 1 : return new $1($2[0]);\+            case 2 : return new $1($2[0],$2[1]);\+            case 3 : return new $1($2[0],$2[1],$2[2]);\+            case 4 : return new $1($2[0],$2[1],$2[2],$2[3]);\+            case 5 : return new $1($2[0],$2[1],$2[2],$2[3],$2[4]);\+            case 6 : return new $1($2[0],$2[1],$2[2],$2[3],$2[4],$2[5]);\+            case 7 : return new $1($2[0],$2[1],$2[2],$2[3],$2[4],$2[5],$2[6]);\+            default:\+                var temp = function() {\+                    ret = $1.apply(this, $2);\+                };\+                temp.prototype = $1.prototype;\+                var i = new temp();\+                if(ret instanceof Object) {\+                    return ret;\+                } else {\+                    i.constructor = $1;\+                    return i;\+                }\+        }\+  })"+#else+       "switch($2.length) {\             case 0 : $r = new $1(); break;\             case 1 : $r = new $1($2[0]); break;\             case 2 : $r = new $1($2[0],$2[1]); break;\@@ -681,37 +633,31 @@             case 6 : $r = new $1($2[0],$2[1],$2[2],$2[3],$2[4],$2[5]); break;\             case 7 : $r = new $1($2[0],$2[1],$2[2],$2[3],$2[4],$2[5],$2[6]); break;\             default:\-                var ret;\                 var temp = function() {\                     ret = $1.apply(this, $2);\                 };\                 temp.prototype = $1.prototype;\                 var i = new temp();\-                if(ret instanceof Object)\-                    return ret;\-                i.constructor = $1;\-                return i;\-        }\-    }\-    catch(e) {\-        $3[0] = e;\-    }"-    js_new :: Object -> MutableJSArray -> MutableJSArray -> IO JSVal+                if(ret instanceof Object) {\+                    $r = ret;\+                } else {\+                    i.constructor = $1;\+                    $r = i;\+                }\+        }"+#endif+    js_new :: Object -> MutableJSArray -> IO JSVal #else-objCallAsConstructor f args exceptions = do-    gctxt <- ask+objCallAsConstructor f args = do     rargs <- makeArgs args-    result <--        withObject f $ \rfunction ->-            withJSVals rargs $ \rargs' ->-                liftIO $ withArrayLen rargs' $ \ largs pargs ->-                    jsobjectcallasconstructor gctxt rfunction (fromIntegral largs) pargs exceptions-    makeNewJSVal result+    callAsConstructor f rargs #endif +-- >>> testJSaddle $ strictEqual nullObject (eval "null")+-- true nullObject :: Object #ifdef ghcjs_HOST_OS nullObject = Object nullRef #else-nullObject = Object . unsafePerformIO $ newForeignPtr_ nullPtr+nullObject = Object . JSVal . unsafePerformIO $ newIORef 0 #endif
src/Language/Javascript/JSaddle/Properties.hs view
@@ -22,109 +22,87 @@  module Language.Javascript.JSaddle.Properties (   -- * Getting Property Values-    objGetPropertyByName+    getProp, unsafeGetProp+  , objGetPropertyByName   , objGetPropertyAtIndex   -- * Setting Property Values+  , setProp, unsafeSetProp   , objSetPropertyByName   , objSetPropertyAtIndex ) where -import Language.Javascript.JSaddle.Classes-       (ToJSVal(..), ToJSString(..)) import Language.Javascript.JSaddle.Monad (JSM)-import Language.Javascript.JSaddle.Types-       (MutableJSArray, Object(..), JSPropertyAttributes,-        Index)+import Language.Javascript.JSaddle.Types (JSVal, Object(..))+import JavaScript.Object.Internal (getProp, unsafeGetProp, setProp, unsafeSetProp) #ifdef ghcjs_HOST_OS-import Language.Javascript.JSaddle.Types (JSString)+import GHCJS.Marshal (ToJSVal(..)) #else-import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSObjectRef-       (jsobjectgetpropertyatindex, jsobjectgetproperty,-        jsobjectsetpropertyatindex, jsobjectsetproperty)+import GHCJS.Marshal.Internal (ToJSVal(..)) import Language.Javascript.JSaddle.Native-       (makeNewJSVal, withObject, withJSString, withToJSVal)+       (withObject, withToJSVal)+import Language.Javascript.JSaddle.Run+       (AsyncCommand(..), sendLazyCommand, sendAsyncCommand) #endif-import Control.Monad.Trans.Reader (ask)-import Control.Monad.IO.Class (MonadIO(..))-import Language.Javascript.JSaddle.Value (JSVal) import Language.Javascript.JSaddle.Arguments () import Language.Javascript.JSaddle.String ()+import Language.Javascript.JSaddle.Marshal.String (ToJSString(..))  -- | Get a property value given the object and the name of the property. objGetPropertyByName :: ToJSString name                      => Object         -- ^ object to find the property on.                      -> name           -- ^ name of the property.-                     -> MutableJSArray -- ^ exception if one is raised.                      -> JSM JSVal      -- ^ returns the property value.-#ifdef ghcjs_HOST_OS-objGetPropertyByName this name = liftIO . js_tryGetProp (toJSString name) this-foreign import javascript unsafe "try { $r=$2[$1] } catch(e) { $3[0] = e }"-    js_tryGetProp :: JSString -> Object -> MutableJSArray -> IO JSVal-#else-objGetPropertyByName this name exceptions = do-    gctxt <- ask-    withObject this $ \rthis ->-        withJSString (toJSString name) $ \name' ->-            (liftIO $ jsobjectgetproperty gctxt rthis name' exceptions) >>= makeNewJSVal-#endif+objGetPropertyByName this name = unsafeGetProp (toJSString name) this  -- | Get a property value given the object and the index of the property.-objGetPropertyAtIndex :: Object         -- ^ object to find the property on.-                      -> Index          -- ^ index of the property.-                      -> MutableJSArray -- ^ exception if one is raised.-                      -> JSM JSVal      -- ^ returns the property value.+objGetPropertyAtIndex :: Object    -- ^ object to find the property on.+                      -> Int       -- ^ index of the property.+                      -> JSM JSVal -- ^ returns the property value. #ifdef ghcjs_HOST_OS-objGetPropertyAtIndex this index = liftIO . js_tryIndex index this-foreign import javascript unsafe "try { $r=$2[$1] } catch(e) { $3[0] = e }"-    js_tryIndex :: Index -> Object -> MutableJSArray -> IO JSVal+objGetPropertyAtIndex this index = js_tryIndex index this+foreign import javascript unsafe+#if __GLASGOW_HASKELL__ >= 900+  "(($1,$2) => { return $2[$1]; })" #else-objGetPropertyAtIndex this index exceptions = do-    gctxt <- ask-    withObject this $ \rthis ->-        (liftIO $ jsobjectgetpropertyatindex gctxt rthis index exceptions) >>= makeNewJSVal+  "$r=$2[$1]" #endif+    js_tryIndex :: Int -> Object -> IO JSVal+#else+objGetPropertyAtIndex this index =+    withObject this $ \rthis -> sendLazyCommand $ GetPropertyAtIndex rthis index+#endif  -- | Set a property value given the object and the name of the property. objSetPropertyByName :: (ToJSString name, ToJSVal val)                      => Object               -- ^ object to set the property on.                      -> name                 -- ^ name of the property.                      -> val                  -- ^ new value to set the property to.-                     -> JSPropertyAttributes -- ^ property attributes to give the property.-                     -> MutableJSArray       -- ^ exception if one is raised.                      -> JSM ()-#ifdef ghcjs_HOST_OS-objSetPropertyByName this name val attributes exceptions = do+objSetPropertyByName this name val = do     vref <- toJSVal val-    liftIO $ js_trySetProp (toJSString name) this vref exceptions-foreign import javascript unsafe "try { $2[$1]=$3 } catch(e) { $4[0] = e }"-    js_trySetProp :: JSString -> Object -> JSVal -> MutableJSArray -> IO ()-#else-objSetPropertyByName this name val attributes exceptions = do-    gctxt <- ask-    withObject this $ \rthis ->-        withJSString (toJSString name) $ \name' ->-        withToJSVal val $ \rval ->-            liftIO $ jsobjectsetproperty gctxt rthis name' rval attributes exceptions-#endif+    unsafeSetProp (toJSString name) vref this  -- | Set a property value given the object and the index of the property. objSetPropertyAtIndex :: (ToJSVal val)                       => Object         -- ^ object to find property on.-                      -> Index          -- ^ index of the property.+                      -> Int          -- ^ index of the property.                       -> val            -- ^ new value to set the property to.-                      -> MutableJSArray -- ^ exception if one is raised.                       -> JSM () #ifdef ghcjs_HOST_OS-objSetPropertyAtIndex this index val exceptions = do+objSetPropertyAtIndex this index val = do     vref <- toJSVal val-    liftIO $ js_trySetAtIndex index this vref exceptions-foreign import javascript unsafe "try { $2[$1]=$3 } catch(e) { $4[0] = e }"-    js_trySetAtIndex :: Index -> Object -> JSVal -> MutableJSArray -> IO ()+    js_trySetAtIndex index this vref+foreign import javascript unsafe+#if __GLASGOW_HASKELL__ >= 900+  "(($1,$2,$3) => { return $2[$1]=$3; })" #else-objSetPropertyAtIndex this index val exceptions = do-    gctxt <- ask+  "$2[$1]=$3"+#endif+    js_trySetAtIndex :: Int -> Object -> JSVal -> IO ()+#else+objSetPropertyAtIndex this index val =     withObject this $ \rthis ->         withToJSVal val $ \rval ->-            liftIO $ jsobjectsetpropertyatindex gctxt rthis index rval exceptions+            sendAsyncCommand $ SetPropertyAtIndex rthis index rval #endif
+ src/Language/Javascript/JSaddle/Run.hs view
@@ -0,0 +1,312 @@+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE UnboxedTuples #-}+-----------------------------------------------------------------------------+--+-- Module      :  Language.Javascript.JSaddle.Run+-- Copyright   :  (c) Hamish Mackenzie+-- License     :  MIT+--+-- Maintainer  :  Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com>+--+-- |+--+-----------------------------------------------------------------------------++module Language.Javascript.JSaddle.Run (+  -- * Running JSM+    syncPoint+  , syncAfter+  , waitForAnimationFrame+  , nextAnimationFrame+  , enableLogging+#ifndef ghcjs_HOST_OS+  -- * Functions used to implement JSaddle using JSON messaging+  , runJavaScript+  , AsyncCommand(..)+  , Command(..)+  , Result(..)+  , sendCommand+  , sendLazyCommand+  , sendAsyncCommand+  , wrapJSVal+#endif+) where++import Prelude ()+import Prelude.Compat++#ifdef ghcjs_HOST_OS+import Language.Javascript.JSaddle.Types (JSM, syncPoint, syncAfter)+import qualified JavaScript.Web.AnimationFrame as GHCJS+       (waitForAnimationFrame)+#else+import Control.Exception (throwIO, evaluate)+import Control.Monad (void, when, zipWithM_)+import Control.Monad.IO.Class (MonadIO(..))+import Control.Monad.Trans.Reader (ask, runReaderT)+import Control.Monad.STM (atomically)+import Control.Concurrent (forkIO, myThreadId)+import Control.Concurrent.STM.TChan+       (tryReadTChan, TChan, readTChan, writeTChan, newTChanIO)+import Control.Concurrent.STM.TVar+       (writeTVar, readTVar, readTVarIO, modifyTVar', newTVarIO)+import Control.Concurrent.MVar+       (tryTakeMVar, MVar, putMVar, takeMVar, newMVar, newEmptyMVar, readMVar, modifyMVar)++import System.IO.Unsafe (unsafeInterleaveIO)+import System.Random++import GHC.Base (IO(..), mkWeak#)+import GHC.Conc (ThreadId(..))+import qualified Data.Text as T (unpack, pack)+import qualified Data.Map as M (lookup, delete, insert, empty, size)+import qualified Data.Set as S (empty, member, insert, delete)+import Data.Time.Clock (getCurrentTime,diffUTCTime)+import Data.IORef+       (mkWeakIORef, newIORef, atomicWriteIORef, readIORef)++import Language.Javascript.JSaddle.Types+       (Command(..), AsyncCommand(..), Result(..), BatchResults(..), Results(..), JSContextRef(..), JSVal(..),+        Object(..), JSValueReceived(..), JSM(..), Batch(..), JSValueForSend(..), syncPoint, syncAfter, sendCommand)+import Language.Javascript.JSaddle.Exception (JSException(..))+import Control.DeepSeq (deepseq)+#if MIN_VERSION_base(4,11,0)+import GHC.Stats (getRTSStatsEnabled, getRTSStats, RTSStats(..), gcdetails_live_bytes, gc)+#else+import GHC.Stats (getGCStatsEnabled, getGCStats, GCStats(..))+#endif+import Data.Foldable (forM_)+#endif++-- | Enable (or disable) JSaddle logging+enableLogging :: Bool -> JSM ()+#ifdef ghcjs_HOST_OS+enableLogging _ = return ()+#else+enableLogging v = do+    f <- doEnableLogging <$> JSM ask+    liftIO $ f v+#endif++-- | On GHCJS this is 'JavaScript.Web.AnimationFrame.waitForAnimationFrame'.+--   On GHC it will delay the execution of the current batch of asynchronous+--   command when they are sent to JavaScript.  It will not delay the Haskell+--   code execution.  The time returned will be based on the Haskell clock+--   (not the JavaScript clock).+waitForAnimationFrame :: JSM Double+#ifdef ghcjs_HOST_OS+waitForAnimationFrame = GHCJS.waitForAnimationFrame+#else+waitForAnimationFrame = do+    -- We can't get the timestamp from requestAnimationFrame so this will have to do+    start <- startTime <$> JSM ask+    now <- liftIO getCurrentTime+    void $ sendLazyCommand SyncWithAnimationFrame+    return $ realToFrac (diffUTCTime now start)+#endif++-- | Tries to executes the given code in the next animation frame callback.+--   Avoid synchronous opperations where possible.+nextAnimationFrame :: (Double -> JSM a) -> JSM a+nextAnimationFrame f = do+    t <- waitForAnimationFrame+    syncAfter (f t)++#ifndef ghcjs_HOST_OS+sendLazyCommand :: (JSValueForSend -> AsyncCommand) -> JSM JSVal+sendLazyCommand cmd = do+    nextRefTVar <- nextRef <$> JSM ask+    n <- liftIO . atomically $ do+        n <- subtract 1 <$> readTVar nextRefTVar+        writeTVar nextRefTVar $! n+        return n+    s <- doSendAsyncCommand <$> JSM ask+    liftIO $ s (cmd $ JSValueForSend n)+    wrapJSVal (JSValueReceived n)++sendAsyncCommand :: AsyncCommand -> JSM ()+sendAsyncCommand cmd = do+    s <- doSendAsyncCommand <$> JSM ask+    liftIO $ s cmd++runJavaScript :: (Batch -> IO ()) -> JSM () -> IO (Results -> IO (), Results -> IO Batch, IO ())+runJavaScript sendBatch entryPoint = do+    contextId' <- randomIO+    startTime' <- getCurrentTime+    recvMVar <- newEmptyMVar+    lastAsyncBatch <- newEmptyMVar+    commandChan <- newTChanIO+    callbacks <- newTVarIO M.empty+    nextRef' <- newTVarIO 0+    finalizerThreads' <- newMVar S.empty+    animationFrameHandlers' <- newMVar []+    loggingEnabled <- newIORef False+    liveRefs' <- newMVar S.empty+    let ctx = JSContextRef {+            contextId = contextId'+          , startTime = startTime'+          , doSendCommand = \cmd -> cmd `deepseq` do+                result <- newEmptyMVar+                atomically $ writeTChan commandChan (Right (cmd, result))+                unsafeInterleaveIO $+                    takeMVar result >>= \case+                        (ThrowJSValue v) -> do+                            jsval <- wrapJSVal' ctx v+                            throwIO $ JSException jsval+                        r -> return r+          , doSendAsyncCommand = \cmd -> cmd `deepseq` atomically (writeTChan commandChan $ Left cmd)+          , addCallback = \(Object (JSVal ioref)) cb -> do+                val <- readIORef ioref+                atomically $ modifyTVar' callbacks (M.insert val cb)+          , nextRef = nextRef'+          , doEnableLogging = atomicWriteIORef loggingEnabled+          , finalizerThreads = finalizerThreads'+          , animationFrameHandlers = animationFrameHandlers'+          , liveRefs = liveRefs'+          }+        processResults :: Bool -> Results -> IO ()+        processResults syncCallbacks = \case+            (ProtocolError err) -> error $ "Protocol error : " <> T.unpack err+            (Callback n br (JSValueReceived fNumber) f this a) -> do+                putMVar recvMVar (n, br)+                f' <- runReaderT (unJSM $ wrapJSVal f) ctx+                this' <- runReaderT  (unJSM $ wrapJSVal this) ctx+                args <- runReaderT (unJSM $ mapM wrapJSVal a) ctx+                logInfo (("Call " <> show fNumber <> " ") <>)+                (M.lookup fNumber <$> liftIO (readTVarIO callbacks)) >>= \case+                    Nothing -> liftIO $ putStrLn "Callback called after it was freed"+                    Just cb -> void . forkIO $ do+                        runReaderT (unJSM $ cb f' this' args) ctx+                        when syncCallbacks $+                            doSendAsyncCommand ctx EndSyncBlock+            Duplicate nBatch nExpected -> do+                putStrLn $ "Error : Unexpected Duplicate. syncCallbacks=" <> show syncCallbacks <>+                    " nBatch=" <> show nBatch <> " nExpected=" <> show nExpected+                void $ doSendCommand ctx Sync+            BatchResults n br -> putMVar recvMVar (n, br)+        asyncResults :: Results -> IO ()+        asyncResults results =+            void . forkIO $ processResults False results+        syncResults :: Results -> IO Batch+        syncResults results = do+            void . forkIO $ processResults True results+            readMVar lastAsyncBatch+        logInfo s =+            readIORef loggingEnabled >>= \case+                True -> do+                    currentBytesUsedStr <- getRTSStatsEnabled >>= \case+                        True  -> show . currentBytesUsed <$> getRTSStats+                        False -> return "??"+                    cbCount <- M.size <$> readTVarIO callbacks+                    putStrLn . s $ "M " <> currentBytesUsedStr <> " CB " <> show cbCount <> " "+                False -> return ()+    _ <- forkIO . numberForeverFromM_ 1 $ \nBatch ->+        readBatch nBatch commandChan >>= \case+            (batch@(Batch cmds _ _), resultMVars) -> do+                logInfo (\x -> "Sync " <> x <> show (length cmds, last cmds))+                _ <- tryTakeMVar lastAsyncBatch+                putMVar lastAsyncBatch batch+                sendBatch batch+                takeResult recvMVar nBatch >>= \case+                    (n, _) | n /= nBatch -> error $ "Unexpected jsaddle results (expected batch " <> show nBatch <> ", got batch " <> show n <> ")"+                    (_, Success callbacksToFree results)+                           | length results /= length resultMVars -> error "Unexpected number of jsaddle results"+                           | otherwise -> do+                        zipWithM_ putMVar resultMVars results+                        forM_ callbacksToFree $ \(JSValueReceived val) ->+                            atomically (modifyTVar' callbacks (M.delete val))+                    (_, Failure callbacksToFree results exception err) -> do+                        -- The exception will only be rethrown in Haskell if/when one of the+                        -- missing results (if any) is evaluated.+                        putStrLn "A JavaScript exception was thrown! (may not reach Haskell code)"+                        putStrLn err+                        zipWithM_ putMVar resultMVars $ results <> repeat (ThrowJSValue exception)+                        forM_ callbacksToFree $ \(JSValueReceived val) ->+                            atomically (modifyTVar' callbacks (M.delete val))+    return (asyncResults, syncResults, runReaderT (unJSM entryPoint) ctx)+  where+    numberForeverFromM_ :: (Monad m, Enum n) => n -> (n -> m a) -> m ()+    numberForeverFromM_ !n f = do+      _ <- f n+      numberForeverFromM_ (succ n) f+    takeResult recvMVar nBatch =+        takeMVar recvMVar >>= \case+            (n, _) | n < nBatch -> takeResult recvMVar nBatch+            r -> return r+    readBatch :: Int -> TChan (Either AsyncCommand (Command, MVar Result)) -> IO (Batch, [MVar Result])+    readBatch nBatch chan = do+        first <- atomically $ readTChan chan -- We want at least one command to send+        loop first ([], [])+      where+        loop :: Either AsyncCommand (Command, MVar Result) -> ([Either AsyncCommand Command], [MVar Result]) -> IO (Batch, [MVar Result])+        loop (Left asyncCmd@(SyncWithAnimationFrame _)) (cmds, resultMVars) =+            atomically (readTChan chan) >>= \cmd -> loopAnimation cmd (Left asyncCmd:cmds, resultMVars)+        loop (Right (syncCmd, resultMVar)) (cmds', resultMVars') = do+            let cmds = Right syncCmd:cmds'+                resultMVars = resultMVar:resultMVars'+            atomically (tryReadTChan chan) >>= \case+                Nothing -> return (Batch (reverse cmds) False nBatch, reverse resultMVars)+                Just cmd -> loop cmd (cmds, resultMVars)+        loop (Left asyncCmd) (cmds', resultMVars) = do+            let cmds = Left asyncCmd:cmds'+            atomically (tryReadTChan chan) >>= \case+                Nothing -> return (Batch (reverse cmds) False nBatch, reverse resultMVars)+                Just cmd -> loop cmd (cmds, resultMVars)+        -- When we have seen a SyncWithAnimationFrame command only a synchronous command should end the batch+        loopAnimation :: Either AsyncCommand (Command, MVar Result) -> ([Either AsyncCommand Command], [MVar Result]) -> IO (Batch, [MVar Result])+        loopAnimation (Right (Sync, resultMVar)) (cmds, resultMVars) =+            return (Batch (reverse (Right Sync:cmds)) True nBatch, reverse (resultMVar:resultMVars))+        loopAnimation (Right (syncCmd, resultMVar)) (cmds, resultMVars) =+            atomically (readTChan chan) >>= \cmd -> loopAnimation cmd (Right syncCmd:cmds, resultMVar:resultMVars)+        loopAnimation (Left asyncCmd) (cmds, resultMVars) =+            atomically (readTChan chan) >>= \cmd -> loopAnimation cmd (Left asyncCmd:cmds, resultMVars)+#ifndef ghcjs_HOST_OS+#if MIN_VERSION_base(4,11,0)+    currentBytesUsed = gcdetails_live_bytes . gc+#else+    getRTSStatsEnabled = getGCStatsEnabled+    getRTSStats = getGCStats+#endif+#endif+++addThreadFinalizer :: ThreadId -> IO () -> IO ()+addThreadFinalizer t@(ThreadId t#) (IO finalizer) =+    IO $ \s -> case mkWeak# t# t finalizer s of { (# s1, _ #) -> (# s1, () #) }+++wrapJSVal :: JSValueReceived -> JSM JSVal+wrapJSVal v = do+    ctx <- JSM ask+    liftIO $ wrapJSVal' ctx v++wrapJSVal' :: JSContextRef -> JSValueReceived -> IO JSVal+wrapJSVal' ctx (JSValueReceived n) = do+    ref <- liftIO $ newIORef n+    when (n >= 5 || n < 0) $+#ifdef JSADDLE_CHECK_WRAPJSVAL+     do lr <- takeMVar $ liveRefs ctx+        if n `S.member` lr+            then do+                putStrLn $ "JS Value Ref " <> show n <> " already wrapped"+                putMVar (liveRefs ctx) lr+            else putMVar (liveRefs ctx) =<< evaluate (S.insert n lr)+#endif+        void . mkWeakIORef ref $ do+            ft <- takeMVar $ finalizerThreads ctx+            t <- myThreadId+            let tname = T.pack $ show t+            doSendAsyncCommand ctx $ FreeRef tname $ JSValueForSend n+            if tname `S.member` ft+                then putMVar (finalizerThreads ctx) ft+                else do+                    addThreadFinalizer t $ do+                        modifyMVar (finalizerThreads ctx) $ \s -> return (S.delete tname s, ())+                        doSendAsyncCommand ctx $ FreeRefs tname+                    putMVar (finalizerThreads ctx) =<< evaluate (S.insert tname ft)+    return (JSVal ref)+#endif
+ src/Language/Javascript/JSaddle/Run/Files.hs view
@@ -0,0 +1,466 @@+{-# LANGUAGE OverloadedStrings #-}+-----------------------------------------------------------------------------+--+-- Module      :  Language.Javascript.JSaddle.WebSockets.Files+-- Copyright   :  (c) Hamish Mackenzie+-- License     :  MIT+--+-- Maintainer  :  Hamish Mackenzie <Hamish.K.Mackenzie@gmail.com>+--+-- |+--+-----------------------------------------------------------------------------++module Language.Javascript.JSaddle.Run.Files (+    indexHtml+  , initState+  , runBatch+  , ghcjsHelpers+) where++import Prelude ()+import Prelude.Compat++import Data.ByteString.Lazy (ByteString)++indexHtml :: ByteString+indexHtml =+    "<!DOCTYPE html>\n\+    \<html>\n\+    \<head>\n\+    \<title>JSaddle</title>\n\+    \</head>\n\+    \<body>\n\+    \</body>\n\+    \<script src=\"/jsaddle.js\"></script>\n\+    \</html>"++initState :: ByteString+initState = "\+    \        var jsaddle_values = new Map();\n\+    \        var jsaddle_free = new Map();\n\+    \        jsaddle_values.set(0, null);\n\+    \        jsaddle_values.set(1, undefined);\n\+    \        jsaddle_values.set(2, false);\n\+    \        jsaddle_values.set(3, true);\n\+    \        jsaddle_values.set(4, globalThis);\n\+    \        var jsaddle_index = 100;\n\+    \        var expectedBatch = 1;\n\+    \        var lastResults = [0, {\"tag\": \"Success\", \"contents\": [[], []]}];\n\+    \        var inCallback = 0;\n\+    \        var asyncBatch = null;\n\+    \"++runBatch :: (ByteString -> ByteString) -> Maybe (ByteString -> ByteString) -> ByteString+runBatch send sendSync = "\+    \  var runBatch = function(firstBatch) {\n\+    \    var processBatch = function(timestamp) {\n\+    \      var batch = firstBatch;\n\+    \      var callbacksToFree = [];\n\+    \      var results = [];\n\+    \      inCallback++;\n\+    \      try {\n\+    \        syncDepth = initialSyncDepth || 0;\n\+    \        for(;;){\n\+    \          if(batch[2] === expectedBatch) {\n\+    \            expectedBatch++;\n\+    \            var nCommandsLength = batch[0].length;\n\+    \            for (var nCommand = 0; nCommand != nCommandsLength; nCommand++) {\n\+    \                var cmd = batch[0][nCommand];\n\+    \                if (cmd.Left) {\n\+    \                    var d = cmd.Left;\n\+    \                    switch (d.tag) {\n\+    \                            case \"FreeRef\":\n\+    \                                var refsToFree = jsaddle_free.get(d.contents[0]) || [];\n\+    \                                refsToFree.push(d.contents[1]);\n\+    \                                jsaddle_free.set(d.contents[0], refsToFree);\n\+    \                                break;\n\+    \                            case \"FreeRefs\":\n\+    \                                var refsToFree = jsaddle_free.get(d.contents) || [];\n\+    \                                for(var nRef = 0; nRef != refsToFree.length; nRef++)\n\+    \                                    jsaddle_values.delete(refsToFree[nRef]);\n\+    \                                jsaddle_free.delete(d.contents);\n\+    \                                break;\n\+    \                            case \"SetPropertyByName\":\n\+    \                                jsaddle_values.get(d.contents[0])[d.contents[1]]=jsaddle_values.get(d.contents[2]);\n\+    \                                break;\n\+    \                            case \"SetPropertyAtIndex\":\n\+    \                                jsaddle_values.get(d.contents[0])[d.contents[1]]=jsaddle_values.get(d.contents[2]);\n\+    \                                break;\n\+    \                            case \"EvaluateScript\":\n\+    \                                var n = d.contents[1];\n\+    \                                jsaddle_values.set(n, eval(d.contents[0]));\n\+    \                                break;\n\+    \                            case \"StringToValue\":\n\+    \                                var n = d.contents[1];\n\+    \                                jsaddle_values.set(n, d.contents[0]);\n\+    \                                break;\n\+    \                            case \"JSONValueToValue\":\n\+    \                                var n = d.contents[1];\n\+    \                                jsaddle_values.set(n, d.contents[0]);\n\+    \                                break;\n\+    \                            case \"GetPropertyByName\":\n\+    \                                var n = d.contents[2];\n\+    \                                jsaddle_values.set(n, jsaddle_values.get(d.contents[0])[d.contents[1]]);\n\+    \                                break;\n\+    \                            case \"GetPropertyAtIndex\":\n\+    \                                var n = d.contents[2];\n\+    \                                jsaddle_values.set(n, jsaddle_values.get(d.contents[0])[d.contents[1]]);\n\+    \                                break;\n\+    \                            case \"NumberToValue\":\n\+    \                                var n = d.contents[1];\n\+    \                                jsaddle_values.set(n, d.contents[0]);\n\+    \                                break;\n\+    \                            case \"NewEmptyObject\":\n\+    \                                var n = d.contents;\n\+    \                                jsaddle_values.set(n, {});\n\+    \                                break;\n\+    \                            case \"NewAsyncCallback\":\n\+    \                                (function() {\n\+    \                                    var nFunction = d.contents;\n\+    \                                    var func = function() {\n\+    \                                        var nFunctionInFunc = ++jsaddle_index;\n\+    \                                        jsaddle_values.set(nFunctionInFunc, func);\n\+    \                                        var nThis = ++jsaddle_index;\n\+    \                                        jsaddle_values.set(nThis, this);\n\+    \                                        var args = [];\n\+    \                                        for (var i = 0; i != arguments.length; i++) {\n\+    \                                            var nArg = ++jsaddle_index;\n\+    \                                            jsaddle_values.set(nArg, arguments[i]);\n\+    \                                            args[i] = nArg;\n\+    \                                        }\n\+    \                                        " <> send "{\"tag\": \"Callback\", \"contents\": [lastResults[0], lastResults[1], nFunction, nFunctionInFunc, nThis, args]}" <> "\n\+    \                                    };\n\+    \                                    jsaddle_values.set(nFunction, func);\n\+    \                                })();\n\+    \                                break;\n\+    \                            case \"NewSyncCallback\":\n\+    \                                (function() {\n\+    \                                    var nFunction = d.contents;\n\+    \                                    var func = function() {\n\+    \                                        var nFunctionInFunc = ++jsaddle_index;\n\+    \                                        jsaddle_values.set(nFunctionInFunc, func);\n\+    \                                        var nThis = ++jsaddle_index;\n\+    \                                        jsaddle_values.set(nThis, this);\n\+    \                                        var args = [];\n\+    \                                        for (var i = 0; i != arguments.length; i++) {\n\+    \                                            var nArg = ++jsaddle_index;\n\+    \                                            jsaddle_values.set(nArg, arguments[i]);\n\+    \                                            args[i] = nArg;\n\+    \                                        }\n" <> (+    case sendSync of+      Just s  ->+        "                                        if(inCallback > 0) {\n\+        \                                          " <> send "{\"tag\": \"Callback\", \"contents\": [lastResults[0], lastResults[1], nFunction, nFunctionInFunc, nThis, args]}" <> "\n\+        \                                        } else {\n\+        \                                          initialSyncDepth = 1;\n\+        \                                          runBatch(" <> s "{\"tag\": \"Callback\", \"contents\": [lastResults[0], lastResults[1], nFunction, nFunctionInFunc, nThis, args]}" <> ");\n\+        \                                        }\n"+      Nothing ->+        "                                        " <> send "{\"tag\": \"Callback\", \"contents\": [lastResults[0], lastResults[1], nFunction, nFunctionInFunc, nThis, args]}" <> "\n"+    ) <>+    "                                    };\n\+    \                                    jsaddle_values.set(nFunction, func);\n\+    \                                })();\n\+    \                                break;\n\+    \                            case \"FreeCallback\":\n\+    \                                callbacksToFree.push(d.contents);\n\+    \                                break;\n\+    \                            case \"CallAsFunction\":\n\+    \                                var n = d.contents[3];\n\+    \                                jsaddle_values.set(n,\n\+    \                                    jsaddle_values.get(d.contents[0]).apply(jsaddle_values.get(d.contents[1]),\n\+    \                                        d.contents[2].map(function(arg){return jsaddle_values.get(arg);})));\n\+    \                                break;\n\+    \                            case \"CallAsConstructor\":\n\+    \                                var n = d.contents[2];\n\+    \                                var r;\n\+    \                                var f = jsaddle_values.get(d.contents[0]);\n\+    \                                var a = d.contents[1].map(function(arg){return jsaddle_values.get(arg);});\n\+    \                                switch(a.length) {\n\+    \                                    case 0 : r = new f(); break;\n\+    \                                    case 1 : r = new f(a[0]); break;\n\+    \                                    case 2 : r = new f(a[0],a[1]); break;\n\+    \                                    case 3 : r = new f(a[0],a[1],a[2]); break;\n\+    \                                    case 4 : r = new f(a[0],a[1],a[2],a[3]); break;\n\+    \                                    case 5 : r = new f(a[0],a[1],a[2],a[3],a[4]); break;\n\+    \                                    case 6 : r = new f(a[0],a[1],a[2],a[3],a[4],a[5]); break;\n\+    \                                    case 7 : r = new f(a[0],a[1],a[2],a[3],a[4],a[5],a[6]); break;\n\+    \                                    default:\n\+    \                                        var ret;\n\+    \                                        var temp = function() {\n\+    \                                            ret = f.apply(this, a);\n\+    \                                        };\n\+    \                                        temp.prototype = f.prototype;\n\+    \                                        var i = new temp();\n\+    \                                        if(ret instanceof Object)\n\+    \                                            r = ret;\n\+    \                                        else {\n\+    \                                            i.constructor = f;\n\+    \                                            r = i;\n\+    \                                        }\n\+    \                                }\n\+    \                                jsaddle_values.set(n, r);\n\+    \                                break;\n\+    \                            case \"NewArray\":\n\+    \                                var n = d.contents[1];\n\+    \                                jsaddle_values.set(n, d.contents[0].map(function(v){return jsaddle_values.get(v);}));\n\+    \                                break;\n\+    \                            case \"SyncWithAnimationFrame\":\n\+    \                                var n = d.contents;\n\+    \                                jsaddle_values.set(n, timestamp);\n\+    \                                break;\n\+    \                            case \"StartSyncBlock\":\n\+    \                                syncDepth++;\n\+    \                                break;\n\+    \                            case \"EndSyncBlock\":\n\+    \                                syncDepth--;\n\+    \                                break;\n\+    \                            default:\n\+    \                                " <> send "{\"tag\": \"ProtocolError\", \"contents\": e.data}" <> "\n\+    \                                return;\n\+    \                    }\n\+    \                } else {\n\+    \                    var d = cmd.Right;\n\+    \                    switch (d.tag) {\n\+    \                            case \"ValueToString\":\n\+    \                                var val = jsaddle_values.get(d.contents);\n\+    \                                var s = val === null ? \"null\" : val === undefined ? \"undefined\" : val.toString();\n\+    \                                results.push({\"tag\": \"ValueToStringResult\", \"contents\": s});\n\+    \                                break;\n\+    \                            case \"ValueToBool\":\n\+    \                                results.push({\"tag\": \"ValueToBoolResult\", \"contents\": jsaddle_values.get(d.contents) ? true : false});\n\+    \                                break;\n\+    \                            case \"ValueToNumber\":\n\+    \                                results.push({\"tag\": \"ValueToNumberResult\", \"contents\": Number(jsaddle_values.get(d.contents))});\n\+    \                                break;\n\+    \                            case \"ValueToJSON\":\n\+    \                                var s = jsaddle_values.get(d.contents) === undefined ? \"\" : JSON.stringify(jsaddle_values.get(d.contents));\n\+    \                                results.push({\"tag\": \"ValueToJSONResult\", \"contents\": s});\n\+    \                                break;\n\+    \                            case \"ValueToJSONValue\":\n\+    \                                results.push({\"tag\": \"ValueToJSONValueResult\", \"contents\": jsaddle_values.get(d.contents)});\n\+    \                                break;\n\+    \                            case \"DeRefVal\":\n\+    \                                var n = d.contents;\n\+    \                                var v = jsaddle_values.get(n);\n\+    \                                var c = (v === null           ) ? [0, \"\"] :\n\+    \                                        (v === undefined      ) ? [1, \"\"] :\n\+    \                                        (v === false          ) ? [2, \"\"] :\n\+    \                                        (v === true           ) ? [3, \"\"] :\n\+    \                                        (typeof v === \"number\") ? [-1, v.toString()] :\n\+    \                                        (typeof v === \"string\") ? [-2, v]\n\+    \                                                                : [-3, \"\"];\n\+    \                                results.push({\"tag\": \"DeRefValResult\", \"contents\": c});\n\+    \                                break;\n\+    \                            case \"IsNull\":\n\+    \                                results.push({\"tag\": \"IsNullResult\", \"contents\": jsaddle_values.get(d.contents) === null});\n\+    \                                break;\n\+    \                            case \"IsUndefined\":\n\+    \                                results.push({\"tag\": \"IsUndefinedResult\", \"contents\": jsaddle_values.get(d.contents) === undefined});\n\+    \                                break;\n\+    \                            case \"InstanceOf\":\n\+    \                                results.push({\"tag\": \"InstanceOfResult\", \"contents\": jsaddle_values.get(d.contents[0]) instanceof jsaddle_values.get(d.contents[1])});\n\+    \                                break;\n\+    \                            case \"StrictEqual\":\n\+    \                                results.push({\"tag\": \"StrictEqualResult\", \"contents\": jsaddle_values.get(d.contents[0]) === jsaddle_values.get(d.contents[1])});\n\+    \                                break;\n\+    \                            case \"PropertyNames\":\n\+    \                                var result = [];\n\+    \                                for (name in jsaddle_values.get(d.contents)) { result.push(name); }\n\+    \                                results.push({\"tag\": \"PropertyNamesResult\", \"contents\": result});\n\+    \                                break;\n\+    \                            case \"Sync\":\n\+    \                                results.push({\"tag\": \"SyncResult\", \"contents\": []});\n\+    \                                break;\n\+    \                            default:\n\+    \                                results.push({\"tag\": \"ProtocolError\", \"contents\": e.data});\n\+    \                        }\n\+    \                }\n\+    \            }\n\+    \            if(syncDepth <= 0) {\n\+    \              lastResults = [batch[2], {\"tag\": \"Success\", \"contents\": [callbacksToFree, results]}];\n\+    \              " <> send "{\"tag\": \"BatchResults\", \"contents\": [lastResults[0], lastResults[1]]}" <> "\n\+    \              break;\n\+    \            } else {\n" <> (+    case sendSync of+      Just s  ->+        "              lastResults = [batch[2], {\"tag\": \"Success\", \"contents\": [callbacksToFree, results]}];\n\+        \              batch = " <> s "{\"tag\": \"BatchResults\", \"contents\": [lastResults[0], lastResults[1]]}" <> ";\n\+        \              results = [];\n\+        \              callbacksToFree = [];\n"+      Nothing ->+        "              " <> send "{\"tag\": \"BatchResults\", \"contents\": [batch[2], {\"tag\": \"Success\", \"contents\": [callbacksToFree, results]}]}" <> "\n\+        \              break;\n"+    ) <>+    "            }\n\+    \          } else {\n\+    \            if(syncDepth <= 0) {\n\+    \              break;\n\+    \            } else {\n" <> (+    case sendSync of+      Just s  ->+        "              if(batch[2] === expectedBatch - 1) {\n\+        \                batch = " <> s "{\"tag\": \"BatchResults\", \"contents\": [lastResults[0], lastResults[1]]}" <> ";\n\+        \              } else {\n\+        \                batch = " <> s "{\"tag\": \"Duplicate\", \"contents\": [batch[2], expectedBatch]}" <> ";\n\+        \              }\n\+        \              results = [];\n\+        \              callbacksToFree = [];\n"+      Nothing ->+        "              " <> send "{\"tag\": \"Duplicate\", \"contents\": [batch[2], expectedBatch]}" <> "\n\+        \              break;\n"+    ) <>+    "            }\n\+    \          }\n\+    \        }\n\+    \      }\n\+    \      catch (err) {\n\+    \        var n = ++jsaddle_index;\n\+    \        jsaddle_values.set(n, err);\n\+    \        console.log(err);\n\+    \        " <> send "{\"tag\": \"BatchResults\", \"contents\": [batch[2], {\"tag\": \"Failure\", \"contents\": [callbacksToFree, results, n, String(err)]}]}" <> "\n\+    \      }\n\+    \      if(inCallback == 1) {\n\+    \          while(asyncBatch !== null) {\n\+    \              var b = asyncBatch;\n\+    \              asyncBatch = null;\n\+    \              if(b[2] == expectedBatch) runBatch(b);\n\+    \          }\n\+    \      }\n\+    \      inCallback--;\n\+    \    };\n\+    \    if(batch[1] && (initialSyncDepth || 0) === 0) {\n\+    \        globalThis.requestAnimationFrame(processBatch);\n\+    \    }\n\+    \    else {\n\+    \        processBatch(globalThis.performance ? globalThis.performance.now() : null);\n\+    \    }\n\+    \  };\n\+    \  initialSyncDepth = 0;\n\+    \  runBatch(batch);\n\+    \"++ghcjsHelpers :: ByteString+ghcjsHelpers = "\+    \function h$isNumber(o) {\+    \    return typeof(o) === 'number';\n\+    \}\n\+    \\n\+    \// returns true for null, but not for functions and host objects\n\+    \function h$isObject(o) {\n\+    \    return typeof(o) === 'object';\n\+    \}\n\+    \\n\+    \function h$isString(o) {\n\+    \    return typeof(o) === 'string';\n\+    \}\n\+    \\n\+    \function h$isSymbol(o) {\n\+    \    return typeof(o) === 'symbol';\n\+    \}\n\+    \\n\+    \function h$isBoolean(o) {\n\+    \    return typeof(o) === 'boolean';\n\+    \}\n\+    \\n\+    \function h$isFunction(o) {\n\+    \    return typeof(o) === 'function';\n\+    \}\n\+    \\n\+    \function h$jsTypeOf(o) {\n\+    \    var t = typeof(o);\n\+    \    if(t === 'undefined') return 0;\n\+    \    if(t === 'object')    return 1;\n\+    \    if(t === 'boolean')   return 2;\n\+    \    if(t === 'number')    return 3;\n\+    \    if(t === 'string')    return 4;\n\+    \    if(t === 'symbol')    return 5;\n\+    \    if(t === 'function')  return 6;\n\+    \    return 7; // other, host object etc\n\+    \}\n\+    \\n\+    \function h$jsonTypeOf(o) {\n\+    \    if (!(o instanceof Object)) {\n\+    \        if (o == null) {\n\+    \            return 0;\n\+    \        } else if (typeof o == 'number') {\n\+    \            if (h$isInteger(o)) {\n\+    \                return 1;\n\+    \            } else {\n\+    \                return 2;\n\+    \            }\n\+    \        } else if (typeof o == 'boolean') {\n\+    \            return 3;\n\+    \        } else {\n\+    \            return 4;\n\+    \        }\n\+    \    } else {\n\+    \        if (Object.prototype.toString.call(o) == '[object Array]') {\n\+    \            // it's an array\n\+    \            return 5;\n\+    \        } else if (!o) {\n\+    \            // null \n\+    \            return 0;\n\+    \        } else {\n\+    \            // it's an object\n\+    \            return 6;\n\+    \        }\n\+    \    }\n\+    \\n\+    \}\n\+    \function h$roundUpToMultipleOf(n,m) {\n\+    \  var rem = n % m;\n\+    \  return rem === 0 ? n : n - rem + m;\n\+    \}\n\+    \\n\+    \function h$newByteArray(len) {\n\+    \  var len0 = Math.max(h$roundUpToMultipleOf(len, 8), 8);\n\+    \  var buf = new ArrayBuffer(len0);\n\+    \  return { buf: buf\n\+    \         , len: len\n\+    \         , i3: new Int32Array(buf)\n\+    \         , u8: new Uint8Array(buf)\n\+    \         , u1: new Uint16Array(buf)\n\+    \         , f3: new Float32Array(buf)\n\+    \         , f6: new Float64Array(buf)\n\+    \         , dv: new DataView(buf)\n\+    \         }\n\+    \}\n\+    \function h$wrapBuffer(buf, unalignedOk, offset, length) {\n\+    \  if(!unalignedOk && offset && offset % 8 !== 0) {\n\+    \    throw (\"h$wrapBuffer: offset not aligned:\" + offset);\n\+    \  }\n\+    \  if(!buf || !(buf instanceof ArrayBuffer))\n\+    \    throw \"h$wrapBuffer: not an ArrayBuffer\"\n\+    \  if(!offset) { offset = 0; }\n\+    \  if(!length || length < 0) { length = buf.byteLength - offset; }\n\+    \  return { buf: buf\n\+    \         , len: length\n\+    \         , i3: (offset%4) ? null : new Int32Array(buf, offset, length >> 2)\n\+    \         , u8: new Uint8Array(buf, offset, length)\n\+    \         , u1: (offset%2) ? null : new Uint16Array(buf, offset, length >> 1)\n\+    \         , f3: (offset%4) ? null : new Float32Array(buf, offset, length >> 2)\n\+    \         , f6: (offset%8) ? null : new Float64Array(buf, offset, length >> 3)\n\+    \         , dv: new DataView(buf, offset, length)\n\+    \         };\n\+    \}\n\+    \function h$newByteArrayFromBase64String(base64) {\n\+    \  var bin = globalThis.atob(base64);\n\+    \  var ba = h$newByteArray(bin.length);\n\+    \  var u8 = ba.u8;\n\+    \  for (var i = 0; i < bin.length; i++) {\n\+    \    u8[i] = bin.charCodeAt(i);\n\+    \  }\n\+    \  return ba;\n\+    \}\n\+    \function h$byteArrayToBase64String(off, len, ba) {\n\+    \  var bin = '';\n\+    \  var u8 = ba.u8;\n\+    \  var end = off + len;\n\+    \  for (var i = off; i < end; i++) {\n\+    \    bin += String.fromCharCode(u8[i]);\n\+    \  }\n\+    \  return globalThis.btoa(bin);\n\+    \}\n\+    \"
src/Language/Javascript/JSaddle/String.hs view
@@ -1,6 +1,9 @@ {-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TypeSynonymInstances #-}+#ifdef ghcjs_HOST_OS+{-# OPTIONS_GHC -Wno-dodgy-imports #-}+#endif ----------------------------------------------------------------------------- -- -- Module      :  Language.Javascript.JSaddle.String@@ -15,60 +18,32 @@  module Language.Javascript.JSaddle.String (     JSString-  , ToJSString(..)    -- * Data.Text helpers+  , textFromJSString+  , textToJSString   , strToText   , textToStr-  , nullJSString ) where  import Data.Text (Text)-import Control.Monad.IO.Class (MonadIO(..))-import Language.Javascript.JSaddle.Types (JSString)+import Language.Javascript.JSaddle.Types (JSString(..)) #ifdef ghcjs_HOST_OS import Data.JSString.Text (textFromJSString, textToJSString)-import GHCJS.Marshal.Internal (PFromJSVal(..))-import GHCJS.Types (nullRef)-#else-import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSStringRef-       (jsstringcreatewithcharacters, jsstringgetcharactersptr,-        jsstringgetlength)-import Language.Javascript.JSaddle.Native (makeNewJSString, withJSString)-import System.IO.Unsafe (unsafePerformIO)-import Foreign.ForeignPtr (newForeignPtr_)-import Foreign.Ptr (nullPtr)-import qualified Data.Text.Foreign as T (fromPtr)-import Foreign (castPtr)-import Data.Text.Foreign (useAsPtr) #endif-import Language.Javascript.JSaddle.Classes (ToJSString(..)) --- | Convert a JavaScript string to a Haskell 'Text'-strToText :: MonadIO m => JSString -> m Text-#ifdef ghcjs_HOST_OS-strToText = return . textFromJSString-#else-strToText jsstring' = liftIO $ withJSString jsstring' $ \jsstring -> do-    l <- jsstringgetlength jsstring-    p <- jsstringgetcharactersptr jsstring-    T.fromPtr (castPtr p) (fromIntegral l)+#ifndef ghcjs_HOST_OS+textFromJSString :: JSString -> Text+textFromJSString (JSString text) = text++textToJSString :: Text -> JSString+textToJSString = JSString #endif +-- | Convert a JavaScript string to a Haskell 'Text'+strToText :: JSString -> Text+strToText = textFromJSString+ -- | Convert a Haskell 'Text' to a JavaScript string textToStr :: Text -> JSString-#ifdef ghcjs_HOST_OS textToStr = textToJSString-#else-textToStr text = unsafePerformIO $-    useAsPtr text $ \p l ->-        jsstringcreatewithcharacters (castPtr p) (fromIntegral l) >>= makeNewJSString-#endif--nullJSString :: JSString-#ifdef ghcjs_HOST_OS-nullJSString = pFromJSVal nullRef-#else-nullJSString = unsafePerformIO $ newForeignPtr_ nullPtr-#endif-
− src/Language/Javascript/JSaddle/Test.hs 
@@ -1,176 +0,0 @@-{-# LANGUAGE RecordWildCards #-}-{-# LANGUAGE PatternSynonyms #-}------------------------------------------------------------------------------------ Module      :  TestJSC--- Copyright   :  (c) Hamish Mackenzie--- License     :  MIT------ Maintainer  :  Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com>------ |-----------------------------------------------------------------------------------module Language.Javascript.JSaddle.Test (-    testJSaddle-  , showJSaddle-  , listWindowProperties-) where--import Control.Applicative-import Prelude hiding((!!), catch)-import GI.Gtk-       (Window, widgetDestroy, widgetShowAll,-        mainQuit, containerAdd, scrolledWindowNew,-        windowSetPosition, windowSetDefaultSize, windowNew)-import Control.Concurrent-       (tryTakeMVar, forkIO, newMVar, putMVar, takeMVar, newEmptyMVar,-        yield)-import GI.Gtk.Enums (WindowType(..), WindowPosition(..))-import GI.WebKit.Objects.WebView-       (webViewGetMainFrame, webViewNew)-import System.IO.Unsafe (unsafePerformIO)-import Control.Monad.Trans.Reader (runReaderT)-import GI.WebKit.Objects.WebFrame-       (webFrameGetGlobalContext)-import Language.Javascript.JSaddle-import qualified Data.Text as T-import Control.Monad.IO.Class (MonadIO(..))-import Control.Monad (forM, when)-import Control.Lens.Getter ((^.))-import Data.Monoid ((<>))-import Control.Concurrent.MVar (MVar)-import qualified GI.Gtk.Functions as Gtk (init, main)-import GI.GLib.Functions (timeoutAdd)-import GI.Gtk.Enums (WindowPosition(..))-import Data.GI.Base.Signals (on)-import GI.GLib (idleAdd)-import GI.GLib.Constants(pattern PRIORITY_DEFAULT, pattern PRIORITY_LOW)-import GI.Gtk.Objects.Widget (onWidgetDestroy)-import GI.JavaScriptCore.Structs.GlobalContext (GlobalContext(..))-import Foreign.ForeignPtr (withForeignPtr)-import Foreign.Ptr (castPtr)-import GI.Gtk.Objects.Adjustment (Adjustment(..))---- | Post an action to be run in the main GUI thread.------ The current thread blocks until the action completes and the result is--- returned.----postGUISync :: IO a -> IO a-postGUISync action = do-  resultVar <- newEmptyMVar-  idleAdd PRIORITY_DEFAULT $ action >>= putMVar resultVar >> return False-  takeMVar resultVar---- | Post an action to be run in the main GUI thread.------ The current thread continues and does not wait for the result of the--- action.----postGUIAsync :: IO () -> IO ()-postGUIAsync action = do-  idleAdd PRIORITY_DEFAULT $ action >> return False-  return ()--data TestState = TestState { jsContext :: GlobalContext, window :: Window }--state :: MVar (Maybe TestState)-state = unsafePerformIO $ newMVar Nothing-{-# NOINLINE state #-}--done :: MVar ()-done = unsafePerformIO newEmptyMVar-{-# NOINLINE done #-}---- >>> testJSaddle $ ((global ^. js "console" . js "log") # ["Hello"])-testJSaddle :: ToJSVal val => JSM val -> IO ()-testJSaddle = testJSaddle' False---- >>> showJSaddle $ eval "document.body.innerHTML = 'Test'"-showJSaddle :: ToJSVal val => JSM val -> IO ()-showJSaddle = testJSaddle' True--debugLog :: String -> IO ()-debugLog _ = return ()--testJSaddle' :: ToJSVal val => Bool -> JSM val -> IO ()-testJSaddle' showWindow f = do-    debugLog "taking done"-    _ <- tryTakeMVar done-    debugLog "taking state"-    mbState <- takeMVar state-    TestState {..} <- case mbState of-        Nothing -> do-            debugLog "newState"-            newState <- newEmptyMVar-            debugLog "fork"-            _ <- forkIO $ do-                debugLog "initGUI"-                _ <- Gtk.init mempty-                debugLog "windowNew"-                window <- windowNew WindowTypeToplevel-                debugLog "timeoutAdd"-                _ <- timeoutAdd PRIORITY_LOW 10 $ yield >> return True-                windowSetDefaultSize window 900 600-                windowSetPosition window WindowPositionCenter-                scrollWin <- scrolledWindowNew (Nothing :: Maybe Adjustment) (Nothing :: Maybe Adjustment)-                webView <- webViewNew-                window `containerAdd` scrollWin-                scrollWin `containerAdd` webView-                _ <- onWidgetDestroy window $ do-                    debugLog "onDestroy"-                    _ <- tryTakeMVar state-                    debugLog "put state"-                    putMVar state Nothing-                    debugLog "mainQuit"-                    mainQuit-                    debugLog "put done"-                    putMVar done ()-                    return ()-                debugLog "get context"-                jsContext <- webViewGetMainFrame webView >>= webFrameGetGlobalContext-                debugLog "put initial state"-                putMVar newState TestState {..}-                debugLog "maybe show"-                when showWindow $ widgetShowAll window-                debugLog "mainGUI"-                Gtk.main-                debugLog "mainGUI exited"-            takeMVar newState-        Just s@TestState {..} -> do-            debugLog "maybe show (2)"-            when showWindow . postGUISync $ widgetShowAll window-            return s-    x <- postGUISync $ withContext jsContext $ runReaderT ((f >>= valToText >>= liftIO . putStrLn . T.unpack)-            `catch` \ (JSException e) -> valToText e >>= liftIO . putStrLn . T.unpack)-    debugLog "put state"-    putMVar state $ Just TestState {..}-    return x--withContext :: GlobalContext -> (JSContextRef -> IO a) -> IO a-withContext (GlobalContext fptr) f = withForeignPtr fptr $ f . castPtr--listWindowProperties :: IO ()-listWindowProperties = testJSaddle $ T.pack . show <$> do-  window <- jsg "window"-  names <- propertyNames window-  forM names $ \name -> do-        v <- window ^. js name >>= valToText-        n <- strToText name-        return (n, v)-    `catch`-        \(JSException e) -> do-            n <- strToText name-            msg <- valToText e-            return (n, T.pack " error " <> msg)---------
src/Language/Javascript/JSaddle/Types.hs view
@@ -1,8 +1,24 @@-{-# LANGUAGE CPP                   #-}-{-# LANGUAGE FlexibleInstances     #-}+{-# LANGUAGE CPP                        #-}+#ifdef ghcjs_HOST_OS+{-# OPTIONS_GHC -Wno-dodgy-exports      #-}+#else+{-# LANGUAGE TypeFamilies               #-}+{-# LANGUAGE UndecidableInstances       #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE DeriveGeneric              #-}+{-# LANGUAGE DataKinds                  #-}+{-# LANGUAGE PolyKinds                  #-}+{-# LANGUAGE FlexibleContexts           #-}+{-# LANGUAGE DefaultSignatures          #-}+{-# LANGUAGE ImplicitParams             #-}+#endif+{-# LANGUAGE ConstraintKinds            #-}+{-# LANGUAGE KindSignatures             #-}+{-# LANGUAGE AllowAmbiguousTypes        #-}+{-# LANGUAGE TypeOperators              #-} ----------------------------------------------------------------------------- ----- Module      :  Language.Javascript.JSaddle.Properties+-- Module      :  Language.Javascript.JSaddle.Types -- Copyright   :  (c) Hamish Mackenzie -- License     :  MIT --@@ -13,57 +29,503 @@ -----------------------------------------------------------------------------  module Language.Javascript.JSaddle.Types (-    JSVal+  -- * JavaScript Context+    JSContextRef(..)++  -- * The JSM Monad+  , JSM(..)+  , MonadJSM(..)+  , liftJSM++  -- * Pure GHCJS functions+  , GHCJSPure(..)+  , ghcjsPure+  , ghcjsPureMap+  , ghcjsPureId++  -- * JavaScript Value Types+  , JSVal(..)+  , IsJSVal(..)+  , jsval+  , SomeJSArray(..)+  , JSArray   , MutableJSArray+  , STJSArray   , Object(..)-  , JSPropertyNameArray-  , JSPropertyAttributes-  , JSContextRef-  , JSString-  , Index+  , JSString(..)   , Nullable(..)-  , JSM+  , JSCallAsFunction++  -- * Debugging+  , JSaddleHasCallStack++  -- * Sync JSM+  , syncPoint+  , syncAfter++#ifndef ghcjs_HOST_OS+  , sendCommand++  -- * JavaScript Context Commands+  , MutabilityType(..)+  , Mutable+  , Immutable+  , IsItMutable(..)+  , Mutability+  , JSValueReceived(..)+  , JSValueForSend(..)+  , JSStringReceived(..)+  , JSStringForSend(..)+  , JSObjectForSend(..)+  , AsyncCommand(..)+  , Command(..)+  , Batch(..)+  , Result(..)+  , BatchResults(..)+  , Results(..)+#endif ) where -import Control.Monad.Trans.Reader (ReaderT(..))+import Control.Monad.IO.Class (MonadIO(..)) #ifdef ghcjs_HOST_OS import GHCJS.Types import JavaScript.Object.Internal (Object(..))-import JavaScript.Array (MutableJSArray)-import Data.Word (Word(..))+import JavaScript.Array.Internal (SomeJSArray(..), JSArray, MutableJSArray, STJSArray) import GHCJS.Nullable (Nullable(..)) #else-import Foreign.ForeignPtr (ForeignPtr)-import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSBase-       (OpaqueJSString, JSValueRefRef,-        JSContextRef, JSPropertyNameArrayRef, OpaqueJSValue)-import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSObjectRef (JSPropertyAttributes)-import Foreign.C (CUInt(..))+import GHCJS.Prim.Internal (JSVal(..), JSValueRef)+import Data.JSString.Internal.Type (JSString(..))+import Control.DeepSeq (NFData(..))+import Control.Monad.Catch (MonadThrow, MonadCatch(..), MonadMask(..))+import Control.Monad.Codensity (Codensity(..))+import Control.Monad.Trans.Cont (ContT(..))+import Control.Monad.Trans.Except (ExceptT(..))+import Control.Monad.Trans.Identity (IdentityT(..))+import Control.Monad.Trans.Maybe (MaybeT(..))+import Control.Monad.Trans.Reader (ReaderT(..), ask)+import Control.Monad.Trans.RWS.Lazy as Lazy (RWST(..))+import Control.Monad.Trans.RWS.Strict as Strict (RWST(..))+import Control.Monad.Trans.State.Lazy as Lazy (StateT(..))+import Control.Monad.Trans.State.Strict as Strict (StateT(..))+import Control.Monad.Trans.Writer.Lazy as Lazy (WriterT(..))+import Control.Monad.Trans.Writer.Strict as Strict (WriterT(..))+import Control.Monad.Trans.Class (MonadTrans(..))+import Control.Monad.Fix (MonadFix)+import Control.Monad.Ref (MonadAtomicRef(..), MonadRef(..))+import Control.Concurrent.STM.TVar (TVar)+import Control.Concurrent.MVar (MVar)+import Data.Int (Int64)+import Data.Set (Set)+import Data.Text (Text)+import Data.Time.Clock (UTCTime(..))+import Data.Type.Equality (type (~~))+import Data.Typeable (Typeable)+import Data.Coerce (coerce, Coercible)+import Data.Aeson+       (defaultOptions, genericToEncoding, ToJSON(..), FromJSON(..), Value)+import GHC.Exts (TYPE)+import GHC.Generics (Generic)+import Control.Monad.IO.Unlift (MonadUnliftIO)+import qualified Control.Monad.Fail as Fail #endif +#if MIN_VERSION_base(4,9,0) && defined(CHECK_UNCHECKED)+import GHC.Stack (HasCallStack)+#else+import GHC.Exts (Constraint)+#endif++-- | Identifies a JavaScript execution context.+--   When using GHCJS this is just '()' since their is only one context.+--   When using GHC it includes the functions JSaddle needs to communicate+--   with the JavaScript context. #ifdef ghcjs_HOST_OS-newtype JSPropertyNameArray = JSPropertyNameArray { unJSPropertyNameArrayRef :: JSVal }-type JSPropertyAttributes = Word-type JSContextRef  = ()-type Index         = Int+type JSContextRef = () #else-type JSVal = ForeignPtr OpaqueJSValue-type MutableJSArray = JSValueRefRef-type JSPropertyNameArray = JSPropertyNameArrayRef-type Index = CUInt-newtype Object = Object (ForeignPtr OpaqueJSValue)-type JSString = ForeignPtr OpaqueJSString-newtype Nullable a = Nullable a+data JSContextRef = JSContextRef {+    contextId              :: Int64+  , startTime              :: UTCTime+  , doSendCommand          :: Command -> IO Result+  , doSendAsyncCommand     :: AsyncCommand -> IO ()+  , addCallback            :: Object -> JSCallAsFunction -> IO ()+  , nextRef                :: TVar JSValueRef+  , doEnableLogging        :: Bool -> IO ()+  , finalizerThreads       :: MVar (Set Text)+  , animationFrameHandlers :: MVar [Double -> JSM ()]+  , liveRefs               :: MVar (Set Int64)+} #endif --- | The @JSM@ monad keeps track of the JavaScript context.+-- | The 'JSM' monad keeps track of the JavaScript execution context. ----- Given a @JSM@ function and a 'JSContextRef' you can run the--- function like this...+--   When using GHCJS it is `IO`. ----- > runReaderT jsmFunction javaScriptContext+--   Given a 'JSM' function and a 'JSContextRef' you can run the+--   function like this... ----- For an example of how to set up WebKitGTK+ see tests/TestJSaddle.hs-type JSM = ReaderT JSContextRef IO+-- > runJSM jsmFunction javaScriptContext+#ifdef ghcjs_HOST_OS+type JSM = IO+#else+newtype JSM a = JSM { unJSM :: ReaderT JSContextRef IO a }+    deriving (Functor, Applicative, Monad, MonadIO, MonadFix, MonadThrow, MonadUnliftIO, Fail.MonadFail)++instance MonadCatch JSM where+    t `catch` c = JSM (unJSM (syncAfter t) `catch` \e -> unJSM (c e))++instance MonadMask JSM where+  mask a = JSM $ mask $ \unmask -> unJSM (a $ q unmask)+    where q :: (ReaderT JSContextRef IO a -> ReaderT JSContextRef IO a) -> JSM a -> JSM a+          q unmask (JSM b) = syncAfter . JSM $ unmask b+  uninterruptibleMask a =+    JSM $ uninterruptibleMask $ \unmask -> unJSM (a $ q unmask)+      where q :: (ReaderT JSContextRef IO a -> ReaderT JSContextRef IO a) -> JSM a -> JSM a+            q unmask (JSM b) = syncAfter . JSM $ unmask b+#if MIN_VERSION_exceptions(0,9,0)+  generalBracket acquire release use =+    JSM $ generalBracket+      (unJSM acquire)+      (\resource exitCase -> unJSM $ release resource exitCase)+      (unJSM . syncAfter . use)+#endif++#endif++-- | Forces execution of pending asyncronous code+syncPoint :: JSM ()+#ifdef ghcjs_HOST_OS+syncPoint = return ()+#else+syncPoint = do+    SyncResult <- sendCommand Sync+    return ()+#endif++-- | Forces execution of pending asyncronous code after performing `f`+syncAfter :: JSM a -> JSM a+#ifdef ghcjs_HOST_OS+syncAfter = id+#else+syncAfter f = do+    result <- f+    syncPoint+    return result+#endif++#ifndef ghcjs_HOST_OS+sendCommand :: Command -> JSM Result+sendCommand cmd = do+    s <- doSendCommand <$> JSM ask+    liftIO $ s cmd+#endif++-- | Type we can give to functions that are pure when using ghcjs, but+--   live in JSM when using jsaddle.+--+--   Some functions that can be pure in GHCJS cannot be implemented in+--   a pure way in JSaddle (because we need to know the JSContextRef).+--   Instead we implement versions of these functions in that return+--   `GHCJSPure a` instead of `a`.  To call them in a way that will+--   work when compiling with GHCJS use `ghcjsPure`.+#ifdef ghcjs_HOST_OS+type GHCJSPure a = a+#else+newtype GHCJSPure a = GHCJSPure (JSM a)+#endif++-- | Used when you want to call a functions that is pure in GHCJS, but+--   lives in the JSM in jsaddle.+ghcjsPure :: GHCJSPure a -> JSM a+#ifdef ghcjs_HOST_OS+ghcjsPure = pure+#else+ghcjsPure (GHCJSPure x) = x+#endif+{-# INLINE ghcjsPure #-}++ghcjsPureMap :: (a -> b) -> GHCJSPure a -> GHCJSPure b+#ifdef ghcjs_HOST_OS+ghcjsPureMap = id+#else+ghcjsPureMap f (GHCJSPure x) = GHCJSPure (f <$> x)+#endif+{-# INLINE ghcjsPureMap #-}++ghcjsPureId :: a -> GHCJSPure a+#ifdef ghcjs_HOST_OS+ghcjsPureId = id+#else+ghcjsPureId = GHCJSPure . return+#endif+{-# INLINE ghcjsPureId #-}++-- | The 'MonadJSM' is to 'JSM' what 'MonadIO' is to 'IO'.+--   When using GHCJS it is 'MonadIO'.+#ifdef ghcjs_HOST_OS+type MonadJSM = MonadIO+#else+class (Applicative m, MonadIO m) => MonadJSM m where+    liftJSM' :: JSM a -> m a++    default liftJSM' :: (MonadJSM m', MonadTrans t, m ~ t m') => JSM a -> m a+    liftJSM' = lift . (liftJSM' :: MonadJSM m' => JSM a -> m' a)+    {-# INLINE liftJSM' #-}++instance MonadJSM JSM where+    liftJSM' = id+    {-# INLINE liftJSM' #-}++instance (MonadJSM m) => MonadJSM (ContT r m) where+    liftJSM' = lift . liftJSM'+    {-# INLINE liftJSM' #-}++instance (MonadJSM m) => MonadJSM (ExceptT e m) where+    liftJSM' = lift . liftJSM'+    {-# INLINE liftJSM' #-}++instance (MonadJSM m) => MonadJSM (IdentityT m) where+    liftJSM' = lift . liftJSM'+    {-# INLINE liftJSM' #-}++instance (MonadJSM m) => MonadJSM (MaybeT m) where+    liftJSM' = lift . liftJSM'+    {-# INLINE liftJSM' #-}++instance (MonadJSM m) => MonadJSM (ReaderT r m) where+    liftJSM' = lift . liftJSM'+    {-# INLINE liftJSM' #-}++instance (Monoid w, MonadJSM m) => MonadJSM (Lazy.RWST r w s m) where+    liftJSM' = lift . liftJSM'+    {-# INLINE liftJSM' #-}++instance (Monoid w, MonadJSM m) => MonadJSM (Strict.RWST r w s m) where+    liftJSM' = lift . liftJSM'+    {-# INLINE liftJSM' #-}++instance (MonadJSM m) => MonadJSM (Lazy.StateT s m) where+    liftJSM' = lift . liftJSM'+    {-# INLINE liftJSM' #-}++instance (MonadJSM m) => MonadJSM (Strict.StateT s m) where+    liftJSM' = lift . liftJSM'+    {-# INLINE liftJSM' #-}++instance (Monoid w, MonadJSM m) => MonadJSM (Lazy.WriterT w m) where+    liftJSM' = lift . liftJSM'+    {-# INLINE liftJSM' #-}++instance (Monoid w, MonadJSM m) => MonadJSM (Strict.WriterT w m) where+    liftJSM' = lift . liftJSM'+    {-# INLINE liftJSM' #-}++instance (m ~~ m', MonadJSM m') => MonadJSM (Codensity (m :: k -> TYPE rep)) where+    liftJSM' = lift . liftJSM'++instance MonadRef JSM where+    type Ref JSM = Ref IO+    newRef = liftIO . newRef+    readRef = liftIO . readRef+    writeRef r = liftIO . writeRef r++instance MonadAtomicRef JSM where+    atomicModifyRef r = liftIO . atomicModifyRef r+#endif++-- | The 'liftJSM' is to 'JSM' what 'liftIO' is to 'IO'.+--   When using GHCJS it is 'liftIO'.+liftJSM :: MonadJSM m => JSM a -> m a+#ifdef ghcjs_HOST_OS+liftJSM = liftIO+#else+liftJSM = liftJSM'+#endif+{-# INLINE liftJSM #-}++-- | Type used for Haskell functions called from JavaScript.+type JSCallAsFunction = JSVal      -- ^ Function object+                     -> JSVal      -- ^ this+                     -> [JSVal]    -- ^ Function arguments+                     -> JSM ()     -- ^ Only () (aka 'JSUndefined') can be returned because+                                   --   the function may need to be executed in a+                                   --   different thread.  If you need to get a+                                   --   value out pass in a continuation function+                                   --   as an argument and invoke it from haskell.++#ifndef ghcjs_HOST_OS++class IsJSVal a where+  jsval_ :: a -> GHCJSPure JSVal++  default jsval_ :: Coercible a JSVal => a -> GHCJSPure JSVal+  jsval_ = GHCJSPure . return . coerce+  {-# INLINE jsval_ #-}++jsval :: IsJSVal a => a -> GHCJSPure JSVal+jsval = jsval_+{-# INLINE jsval #-}++data MutabilityType s = Mutable_ s+                      | Immutable_ s+                      | STMutable s++type Mutable   = Mutable_ ()+type Immutable = Immutable_ ()++data IsItMutable = IsImmutable+                 | IsMutable++type family Mutability (a :: MutabilityType s) :: IsItMutable where+  Mutability Immutable     = IsImmutable+  Mutability Mutable       = IsMutable+  Mutability (STMutable s) = IsMutable++newtype SomeJSArray (m :: MutabilityType s) = SomeJSArray JSVal+  deriving (Typeable)+instance IsJSVal (SomeJSArray m)++-- | See 'JavaScript.Array.Internal.JSArray'+type JSArray        = SomeJSArray Immutable+-- | See 'JavaScript.Array.Internal.MutableJSArray'+type MutableJSArray = SomeJSArray Mutable++-- | See 'JavaScript.Array.Internal.STJSArray'+type STJSArray s    = SomeJSArray (STMutable s)++-- | See 'JavaScript.Object.Internal.Object'+newtype Object = Object JSVal++-- | See 'GHCJS.Nullable.Nullable'+newtype Nullable a = Nullable a++-- | Wrapper used when receiving a 'JSVal' from the JavaScript context+newtype JSValueReceived = JSValueReceived JSValueRef deriving(Show, ToJSON, FromJSON)++-- | Wrapper used when sending a 'JSVal' to the JavaScript context+newtype JSValueForSend = JSValueForSend JSValueRef deriving(Show, ToJSON, FromJSON, Generic)+instance NFData JSValueForSend++-- | Wrapper used when sending a 'Object' to the JavaScript context+newtype JSObjectForSend = JSObjectForSend JSValueForSend deriving(Show, ToJSON, FromJSON, Generic)+instance NFData JSObjectForSend++-- | Wrapper used when receiving a 'JSString' from the JavaScript context+newtype JSStringReceived = JSStringReceived Text deriving(Show, ToJSON, FromJSON)++-- | Wrapper used when sending a 'JString' to the JavaScript context+newtype JSStringForSend = JSStringForSend Text deriving(Show, ToJSON, FromJSON, Generic)+instance NFData JSStringForSend++-- | Command sent to a JavaScript context for execution asynchronously+data AsyncCommand = FreeRef Text JSValueForSend+                  | FreeRefs Text+                  | SetPropertyByName JSObjectForSend JSStringForSend JSValueForSend+                  | SetPropertyAtIndex JSObjectForSend Int JSValueForSend+                  | StringToValue JSStringForSend JSValueForSend+                  | NumberToValue Double JSValueForSend+                  | JSONValueToValue Value JSValueForSend+                  | GetPropertyByName JSObjectForSend JSStringForSend JSValueForSend+                  | GetPropertyAtIndex JSObjectForSend Int JSValueForSend+                  | CallAsFunction JSObjectForSend JSObjectForSend [JSValueForSend] JSValueForSend+                  | CallAsConstructor JSObjectForSend [JSValueForSend] JSValueForSend+                  | NewEmptyObject JSValueForSend+                  | NewAsyncCallback JSValueForSend+                  | NewSyncCallback JSValueForSend+                  | FreeCallback JSValueForSend+                  | NewArray [JSValueForSend] JSValueForSend+                  | EvaluateScript JSStringForSend JSValueForSend+                  | SyncWithAnimationFrame JSValueForSend+                  | StartSyncBlock+                  | EndSyncBlock+                   deriving (Show, Generic)++instance ToJSON AsyncCommand where+    toEncoding = genericToEncoding defaultOptions++instance FromJSON AsyncCommand++instance NFData AsyncCommand++-- | Command sent to a JavaScript context for execution synchronously+data Command = DeRefVal JSValueForSend+             | ValueToBool JSValueForSend+             | ValueToNumber JSValueForSend+             | ValueToString JSValueForSend+             | ValueToJSON JSValueForSend+             | ValueToJSONValue JSValueForSend+             | IsNull JSValueForSend+             | IsUndefined JSValueForSend+             | StrictEqual JSValueForSend JSValueForSend+             | InstanceOf JSValueForSend JSObjectForSend+             | PropertyNames JSObjectForSend+             | Sync+             deriving (Show, Generic)++instance ToJSON Command where+    toEncoding = genericToEncoding defaultOptions++instance FromJSON Command++instance NFData Command++-- | Batch of commands that can be sent together to the JavaScript context+data Batch = Batch [Either AsyncCommand Command] Bool Int+             deriving (Show, Generic)++instance ToJSON Batch where+    toEncoding = genericToEncoding defaultOptions++instance FromJSON Batch++instance NFData Batch++-- | Result of a 'Command' returned from the JavaScript context+data Result = DeRefValResult JSValueRef Text+            | ValueToBoolResult Bool+            | ValueToNumberResult Double+            | ValueToStringResult JSStringReceived+            | ValueToJSONResult JSStringReceived+            | ValueToJSONValueResult Value+            | IsNullResult Bool+            | IsUndefinedResult Bool+            | StrictEqualResult Bool+            | InstanceOfResult Bool+            | PropertyNamesResult [JSStringReceived]+            | ThrowJSValue JSValueReceived+            | SyncResult+            deriving (Show, Generic)++instance ToJSON Result where+    toEncoding = genericToEncoding defaultOptions++instance FromJSON Result++data BatchResults = Success [JSValueReceived] [Result]+                  | Failure [JSValueReceived] [Result] JSValueReceived String+             deriving (Show, Generic)++instance ToJSON BatchResults where+    toEncoding = genericToEncoding defaultOptions++instance FromJSON BatchResults++data Results = BatchResults Int BatchResults+             | Duplicate Int Int+             | Callback Int BatchResults JSValueReceived JSValueReceived JSValueReceived [JSValueReceived]+             | ProtocolError Text+             deriving (Show, Generic)++instance ToJSON Results where+    toEncoding = genericToEncoding defaultOptions++instance FromJSON Results+#endif++-- | Like HasCallStack, but only when jsaddle cabal flag check-unchecked is set+#if MIN_VERSION_base(4,9,0) && defined(CHECK_UNCHECKED)+type JSaddleHasCallStack = HasCallStack+#else+type JSaddleHasCallStack = (() :: Constraint)+#endif
src/Language/Javascript/JSaddle/Value.hs view
@@ -5,6 +5,7 @@ {-# LANGUAGE LambdaCase #-} #ifdef ghcjs_HOST_OS {-# LANGUAGE ForeignFunctionInterface, JavaScriptFFI #-}+{-# OPTIONS_GHC -Wno-dodgy-exports -Wno-dodgy-imports #-} #endif {-# OPTIONS_GHC -fno-warn-orphans #-} -----------------------------------------------------------------------------@@ -44,6 +45,7 @@   , showJSValue    -- * Converting JavaScript values+  , isTruthy   , valToBool   , valToNumber   , valToStr@@ -53,15 +55,24 @@    -- * Make JavaScript values from Haskell ones   , val-  , valMakeNull+  , jsNull+  , valNull+  , isNull   , valIsNull-  , valMakeUndefined+  , jsUndefined+  , valUndefined+  , isUndefined   , valIsUndefined   , maybeNullOrUndefined   , maybeNullOrUndefined'-  , valMakeBool+  , toJSBool+  , jsTrue+  , jsFalse+  , valBool   , valMakeNumber   , valMakeString+  , valMakeText+  , valMakeJSON    -- * Convert to and from JSValue   , deRefVal@@ -70,48 +81,40 @@   , instanceOf ) where -import Control.Applicative-import Prelude hiding (catch)-import Language.Javascript.JSaddle.Types-       (Object(..), JSString, JSVal)+import Data.Text (Text)+import qualified Data.Text as T (pack, unpack)+import Data.Aeson (Value)+import Data.JSString.Text (textToJSString)+ #ifdef ghcjs_HOST_OS import Language.Javascript.JSaddle.Types-       (MutableJSArray)-import GHCJS.Types (JSVal(..), isNull, isUndefined)-import GHCJS.Foreign (toJSBool, isTruthy, jsNull, jsUndefined)-import qualified GHCJS.Marshal as GHCJS (toJSVal)-import GHCJS.Marshal.Pure (pToJSVal)-import Data.JSString.Text (textToJSString)+       (Object(..), JSString(..), JSVal(..), ghcjsPure)+import GHCJS.Marshal (ToJSVal(..)) #else-import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSValueRef-       (jsvalueisinstanceofconstructor, jsvaluecreatejsonstring,-        JSType(..), jsvaluegettype, jsvaluemakestring, jsvaluemakenumber,-        jsvaluemakeboolean, jsvaluemakeundefined, jsvaluemakenull,-        jsvaluetoobject, jsvaluetostringcopy, jsvaluetonumber,-        jsvaluetoboolean, jsvalueisnull, jsvalueisundefined,-        jsvalueisstrictequal)+import Data.Char (chr, ord)+import Data.Word (Word, Word8, Word16, Word32)+import Data.Int (Int8, Int16, Int32)+import GHCJS.Marshal.Internal (ToJSVal(..), FromJSVal(..))+import Language.Javascript.JSaddle.Types+       (Object(..), JSString(..), JSVal(..), ghcjsPure) import Language.Javascript.JSaddle.Native-       (makeNewJSVal, wrapJSString, withJSVal, withObject, withJSString,-        withToJSVal)+       (valueToNumber, valueToString, valueToJSON, numberToValue, stringToValue, jsonValueToValue)+import qualified Language.Javascript.JSaddle.Native as N+       (deRefVal, strictEqual, instanceOf)+import Language.Javascript.JSaddle.Run (Result(..)) #endif import Language.Javascript.JSaddle.Monad (JSM)-import Language.Javascript.JSaddle.Exception (rethrow)-import Control.Monad.Trans.Reader (ask)-import Control.Monad.IO.Class (MonadIO(..))-import Data.Text (Text)-import qualified Data.Text as T (pack) import Language.Javascript.JSaddle.Classes-       (MakeObject(..), ToJSString(..), ToJSVal(..))+       (MakeObject(..), MakeArgs(..))+import Language.Javascript.JSaddle.Marshal.String (ToJSString(..), FromJSString(..)) import Language.Javascript.JSaddle.String (strToText, textToStr)-import Language.Javascript.JSaddle.Arguments (MakeArgs(..))-import Data.Word (Word32, Word, Word64)-import Data.Int (Int32, Int64)+import GHCJS.Foreign.Internal (jsTrue, jsFalse, jsNull, toJSBool, jsUndefined, isTruthy, isNull, isUndefined)  -- $setup -- >>> import Language.Javascript.JSaddle.Test (testJSaddle) -- >>> import Language.Javascript.JSaddle.Monad (catch) -- >>> import Language.Javascript.JSaddle.Exception (JSException(..))--- >>> import Language.Javascript.JSaddle.Object (obj)+-- >>> import Language.Javascript.JSaddle.Object (obj, jsg) -- >>> import qualified Data.Text as T (pack)  data JSNull      = JSNull -- ^ Type that represents a value that can only be null.@@ -162,14 +165,7 @@ -- >>> testJSaddle $ valToBool "1" -- true valToBool :: ToJSVal value => value -> JSM Bool-#ifdef ghcjs_HOST_OS-valToBool value = isTruthy <$> toJSVal value-#else-valToBool value = do-    gctxt <- ask-    withToJSVal value $ \rval ->-        liftIO $ jsvaluetoboolean gctxt rval-#endif+valToBool value = toJSVal value >>= ghcjsPure . isTruthy  -- | Given a JavaScript value get its numeric value. --   May throw JSException.@@ -193,43 +189,49 @@ valToNumber :: ToJSVal value => value -> JSM Double #ifdef ghcjs_HOST_OS valToNumber value = jsrefToNumber <$> toJSVal value-foreign import javascript unsafe "$r = Number($1);" jsrefToNumber :: JSVal -> Double+foreign import javascript unsafe+#if __GLASGOW_HASKELL__ >= 900+  "(($1) => { return Number($1); })" #else-valToNumber value = do-    gctxt <- ask-    withToJSVal value $ \rval ->-        rethrow $ liftIO . jsvaluetonumber gctxt rval+  "$r = Number($1);" #endif+     jsrefToNumber :: JSVal -> Double+#else+valToNumber value = toJSVal value >>= valueToNumber+#endif  -- | Given a JavaScript value get its string value (as a JavaScript string). --   May throw JSException. ----- >>> testJSaddle $ valToStr JSNull >>= strToText+-- >>> testJSaddle $ strToText <$> valToStr JSNull -- null--- >>> testJSaddle $ valToStr () >>= strToText+-- >>> testJSaddle $ strToText <$> valToStr () -- undefined--- >>> testJSaddle $ valToStr True >>= strToText+-- >>> testJSaddle $ strToText <$> valToStr True -- true--- >>> testJSaddle $ valToStr False >>= strToText+-- >>> testJSaddle $ strToText <$> valToStr False -- false--- >>> testJSaddle $ valToStr (1.0 :: Double) >>= strToText+-- >>> testJSaddle $ strToText <$> valToStr (1.0 :: Double) -- 1--- >>> testJSaddle $ valToStr (0.0 :: Double) >>= strToText+-- >>> testJSaddle $ strToText <$> valToStr (0.0 :: Double) -- 0--- >>> testJSaddle $ valToStr "" >>= strToText+-- >>> testJSaddle $ strToText <$> valToStr "" -- <BLANKLINE>--- >>> testJSaddle $ valToStr "1" >>= strToText+-- >>> testJSaddle $ strToText <$> valToStr "1" -- 1 valToStr :: ToJSVal value => value -> JSM JSString #ifdef ghcjs_HOST_OS valToStr value = jsrefToString <$> toJSVal value-foreign import javascript unsafe "$r = $1.toString();" jsrefToString :: JSVal -> JSString+foreign import javascript unsafe+#if __GLASGOW_HASKELL__ >= 900+  "(($1) => { return $1.toString(); })" #else-valToStr value = do-    gctxt <- ask-    withToJSVal value $ \rval ->-        rethrow (liftIO . jsvaluetostringcopy gctxt rval) >>= wrapJSString+  "$r = $1.toString();" #endif+    jsrefToString :: JSVal -> JSString+#else+valToStr value = toJSVal value >>= valueToString+#endif  -- | Given a JavaScript value get its string value (as a Haskell 'Text'). --   May throw JSException.@@ -251,47 +253,50 @@ -- >>> testJSaddle $ show <$> valToText "1" -- "1" valToText :: ToJSVal value => value -> JSM Text-valToText jsvar = valToStr jsvar >>= strToText+valToText jsvar = strToText <$> valToStr jsvar  -- | Given a JavaScript value get a JSON string value. --   May throw JSException. ----- >>> testJSaddle $ valToJSON 0 JSNull >>= strToText+-- >>> testJSaddle $ strToText <$> valToJSON JSNull -- null--- >>> testJSaddle $ valToJSON 0 () >>= strToText+-- >>> testJSaddle $ strToText <$> valToJSON () -- <BLANKLINE>--- >>> testJSaddle $ valToJSON 0 True >>= strToText+-- >>> testJSaddle $ strToText <$> valToJSON True -- true--- >>> testJSaddle $ valToJSON 0 False >>= strToText+-- >>> testJSaddle $ strToText <$> valToJSON False -- false--- >>> testJSaddle $ valToJSON 0 (1.0 :: Double) >>= strToText+-- >>> testJSaddle $ strToText <$> valToJSON (1.0 :: Double) -- 1--- >>> testJSaddle $ valToJSON 0 (0.0 :: Double) >>= strToText+-- >>> testJSaddle $ strToText <$> valToJSON (0.0 :: Double) -- 0--- >>> testJSaddle $ valToJSON 0 "" >>= strToText+-- >>> testJSaddle $ strToText <$> valToJSON "" -- ""--- >>> testJSaddle $ valToJSON 0 "1" >>= strToText+-- >>> testJSaddle $ strToText <$> valToJSON "1" -- "1"--- >>> testJSaddle $ obj >>= valToJSON 0 >>= strToText+-- >>> testJSaddle $ strToText <$> (obj >>= valToJSON) -- {}-valToJSON :: ToJSVal value => Word -> value -> JSM JSString+valToJSON :: ToJSVal value => value -> JSM JSString #ifdef ghcjs_HOST_OS-valToJSON indent value = jsrefToJSON <$> toJSVal value-foreign import javascript unsafe "$r = JSON.stringify($1);" jsrefToJSON :: JSVal -> JSString+valToJSON value = jsrefToJSON <$> toJSVal value+foreign import javascript unsafe+#if __GLASGOW_HASKELL__ >= 900+  "(($1) => { return $1 === undefined ? \"\" : JSON.stringify($1); })" #else-valToJSON indent value = do-    gctxt <- ask-    withToJSVal value $ \rval ->-        rethrow (liftIO . jsvaluecreatejsonstring gctxt rval (fromIntegral indent)) >>= wrapJSString+  "$r = $1 === undefined ? \"\" : JSON.stringify($1);" #endif+    jsrefToJSON :: JSVal -> JSString+#else+valToJSON value = toJSVal value >>= valueToJSON+#endif  -- | Given a JavaScript value get its object value. --   May throw JSException. -- -- >>> testJSaddle $ (valToObject JSNull >>= valToText) `catch` \ (JSException e) -> valToText e--- TypeError:...null...is not an object+-- null -- >>> testJSaddle $ (valToObject () >>= valToText) `catch` \ (JSException e) -> valToText e--- TypeError:...undefined...is not an object+-- undefined -- >>> testJSaddle $ valToObject True -- true -- >>> testJSaddle $ valToObject False@@ -305,27 +310,26 @@ -- >>> testJSaddle $ valToObject "1" -- 1 valToObject :: ToJSVal value => value -> JSM Object-valToObject value = Object <$>-#ifdef ghcjs_HOST_OS-    toJSVal value-#else- do gctxt <- ask-    withToJSVal value $ \rval ->-        rethrow (liftIO . jsvaluetoobject gctxt rval) >>= makeNewJSVal-#endif+valToObject value = Object <$> toJSVal value  instance MakeObject JSVal where-    makeObject = valToObject+    makeObject = return . Object +instance ToJSVal Object where+    toJSVal (Object r) = return r+ -- | Convert to a JavaScript value (just an alias for 'toJSVal') val :: ToJSVal value     => value          -- ^ value to convert to a JavaScript value     -> JSM JSVal val = toJSVal +#ifndef ghcjs_HOST_OS -- | If we already have a JSVal we are fine instance ToJSVal JSVal where     toJSVal = return+    {-# INLINE toJSVal #-}+#endif  -- | A single JSVal can be used as the argument list instance MakeArgs JSVal where@@ -335,52 +339,68 @@ --   as it returns something we can make into a JSVal. instance ToJSVal v => ToJSVal (JSM v) where     toJSVal v = v >>= toJSVal+    {-# INLINE toJSVal #-}  ----------- null ------------------ | Make a @null@ JavaScript value-valMakeNull :: JSM JSVal-#ifdef ghcjs_HOST_OS-valMakeNull = return jsNull-#else-valMakeNull = ask >>= (liftIO . jsvaluemakenull) >>= makeNewJSVal-#endif+-- | A @null@ JavaScript value+valNull :: JSVal+valNull = jsNull+{-# INLINE valNull #-}  -- | Makes a @null@ JavaScript value instance ToJSVal JSNull where-    toJSVal = const valMakeNull+    toJSVal = const (return jsNull)+    {-# INLINE toJSVal #-}  -- | Makes an argument list with just a single @null@ JavaScript value instance MakeArgs JSNull where-    makeArgs _ = valMakeNull >>= (\ref -> return [ref])+    makeArgs _ = return [jsNull] +#ifndef ghcjs_HOST_OS -- | Makes a JSVal or @null@ JavaScript value instance ToJSVal a => ToJSVal (Maybe a) where-    toJSVal Nothing = valMakeNull+    toJSVal Nothing = return jsNull     toJSVal (Just a) = toJSVal a+    {-# INLINE toJSVal #-}+instance FromJSVal a => FromJSVal (Maybe a) where+    fromJSValUnchecked x =+        ghcjsPure (isUndefined x) >>= \case+            True  -> return Nothing+            False -> ghcjsPure (isNull x) >>= \case+                    True  -> return Nothing+                    False -> fromJSVal x+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal x =+        ghcjsPure (isUndefined x) >>= \case+            True  -> return (Just Nothing)+            False -> ghcjsPure (isNull x) >>= \case+                    True  -> return (Just Nothing)+                    False -> fmap (fmap Just) fromJSVal x+    {-# INLINE fromJSVal #-} +-- Make an array out of various lists+instance ToJSVal a => ToJSVal [a] where+    toJSVal = toJSValListOf+    {-# INLINE toJSVal #-}++instance FromJSVal a => FromJSVal [a] where+    fromJSVal = fromJSValListOf+    {-# INLINE fromJSVal #-}+#endif+ -- | Test a JavaScript value to see if it is @null@ valIsNull :: ToJSVal value => value -> JSM Bool-#ifdef ghcjs_HOST_OS-valIsNull value = isNull <$> toJSVal value-#else-valIsNull value = do-    gctxt <- ask-    withToJSVal value $ \rval ->-        liftIO $ jsvalueisnull gctxt rval-#endif+valIsNull value = toJSVal value >>= ghcjsPure . isNull  ----------- undefined ------------------ | Make an @undefined@ JavaScript value-valMakeUndefined :: JSM JSVal-#ifdef ghcjs_HOST_OS-valMakeUndefined = return jsUndefined-#else-valMakeUndefined = ask >>= (liftIO . jsvaluemakeundefined) >>= makeNewJSVal-#endif+-- | An @undefined@ JavaScript value+valUndefined :: JSVal+valUndefined = jsUndefined+{-# INLINE valUndefined #-}  -- | Makes an @undefined@ JavaScript value instance ToJSVal JSUndefined where-    toJSVal = const valMakeUndefined+    toJSVal = const (return jsUndefined)  --We can't allow this if JSUndefined is () as () is no args not "(null)". --Use [()] instead.@@ -393,132 +413,136 @@  -- | Test a JavaScript value to see if it is @undefined@ valIsUndefined :: ToJSVal value => value -> JSM Bool-#ifdef ghcjs_HOST_OS-valIsUndefined value = isUndefined <$> toJSVal value-#else-valIsUndefined value = do-    gctxt <- ask-    withToJSVal value $ \rval ->-        liftIO $ jsvalueisundefined gctxt rval-#endif+valIsUndefined value = toJSVal value >>= ghcjsPure . isUndefined  -- | Convert a JSVal to a Maybe JSVal (converting null and undefined to Nothing) maybeNullOrUndefined :: ToJSVal value => value -> JSM (Maybe JSVal) maybeNullOrUndefined value = do     rval <- toJSVal value-    valIsNull rval >>= \case+    ghcjsPure (isNull rval) >>= \case         True -> return Nothing         _    ->-            valIsUndefined rval >>= \case+            ghcjsPure (isUndefined rval) >>= \case                 True -> return Nothing                 _    -> return (Just rval)  maybeNullOrUndefined' :: ToJSVal value => (JSVal -> JSM a) -> value -> JSM (Maybe a) maybeNullOrUndefined' f value = do     rval <- toJSVal value-    valIsNull rval >>= \case+    ghcjsPure (isNull rval) >>= \case         True -> return Nothing         _    ->-            valIsUndefined rval >>= \case+            ghcjsPure (isUndefined rval) >>= \case                 True -> return Nothing                 _    -> Just <$> f rval  ----------- booleans ------------------ | Make a JavaScript boolean value-valMakeBool :: Bool -> JSM JSVal-#ifdef ghcjs_HOST_OS-valMakeBool b = return  $ toJSBool b-#else-valMakeBool b = do-    gctxt <- ask-    liftIO (jsvaluemakeboolean gctxt b) >>= makeNewJSVal-#endif+-- | A JavaScript boolean value+valBool :: Bool -> JSVal+valBool = toJSBool+{-# INLINE valBool #-} +#ifndef ghcjs_HOST_OS -- | Make a JavaScript boolean value instance ToJSVal Bool where-    toJSVal = valMakeBool+    toJSVal = return . valBool+    {-# INLINE toJSVal #-}+#endif  -- | Makes an argument list with just a single JavaScript boolean value instance MakeArgs Bool where-    makeArgs b = valMakeBool b >>= (\ref -> return [ref])+    makeArgs b = return [valBool b]  ----------- numbers --------------- -- | Make a JavaScript number valMakeNumber :: Double -> JSM JSVal-#ifdef ghcjs_HOST_OS-valMakeNumber n = liftIO $ GHCJS.toJSVal n-#else-valMakeNumber n = do-    gctxt <- ask-    liftIO (jsvaluemakenumber gctxt n) >>= makeNewJSVal-#endif+valMakeNumber = toJSVal+{-# INLINE valMakeNumber #-} +#ifndef ghcjs_HOST_OS -- | Makes a JavaScript number instance ToJSVal Double where-    toJSVal = valMakeNumber+    toJSVal = numberToValue+    {-# INLINE toJSVal #-}  instance ToJSVal Float where-    toJSVal = valMakeNumber . realToFrac+    toJSVal = numberToValue . realToFrac+    {-# INLINE toJSVal #-}  instance ToJSVal Word where-    toJSVal = valMakeNumber . fromIntegral+    toJSVal = numberToValue . fromIntegral+    {-# INLINE toJSVal #-} -instance ToJSVal Word32 where-    toJSVal = valMakeNumber . fromIntegral+instance ToJSVal Word8 where+    toJSVal = numberToValue . fromIntegral+    {-# INLINE toJSVal #-} -instance ToJSVal Word64 where-    toJSVal = valMakeNumber . fromIntegral+instance ToJSVal Word16 where+    toJSVal = numberToValue . fromIntegral+    {-# INLINE toJSVal #-} +instance ToJSVal Word32 where+    toJSVal = numberToValue . fromIntegral+    {-# INLINE toJSVal #-}+ instance ToJSVal Int where-    toJSVal = valMakeNumber . fromIntegral+    toJSVal = numberToValue . fromIntegral+    {-# INLINE toJSVal #-} -instance ToJSVal Int32 where-    toJSVal = valMakeNumber . fromIntegral+instance ToJSVal Int8 where+    toJSVal = numberToValue . fromIntegral+    {-# INLINE toJSVal #-} -instance ToJSVal Int64 where-    toJSVal = valMakeNumber . fromIntegral+instance ToJSVal Int16 where+    toJSVal = numberToValue . fromIntegral+    {-# INLINE toJSVal #-} +instance ToJSVal Int32 where+    toJSVal = numberToValue . fromIntegral+    {-# INLINE toJSVal #-}+#endif+ -- | Makes an argument list with just a single JavaScript number instance MakeArgs Double where     makeArgs n = valMakeNumber n >>= (\ref -> return [ref])  -- | Make a JavaScript string from `Text` valMakeText :: Text -> JSM JSVal-#ifdef ghcjs_HOST_OS-valMakeText = return . pToJSVal . textToJSString-#else-valMakeText text = do-    gctxt <- ask-    withJSString (textToStr text) $ \s ->-        liftIO (jsvaluemakestring gctxt s) >>= makeNewJSVal-#endif+valMakeText = toJSVal . textToJSString+{-# INLINE valMakeText #-}  -- | Make a JavaScript string from `JSString` valMakeString :: JSString -> JSM JSVal-#ifdef ghcjs_HOST_OS-valMakeString = return . pToJSVal-#else-valMakeString str = do-    gctxt <- ask-    withJSString str $ \s ->-        liftIO (jsvaluemakestring gctxt s) >>= makeNewJSVal-#endif+valMakeString = toJSVal+{-# INLINE valMakeString #-} +#ifndef ghcjs_HOST_OS -- | Makes a JavaScript string instance ToJSVal Text where-    toJSVal = valMakeText+    toJSVal = stringToValue . JSString+    {-# INLINE toJSVal #-}+instance FromJSVal Text where+    fromJSValUnchecked = valToText+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap Just . valToText+    {-# INLINE fromJSVal #-}+#endif  -- | Makes an argument list with just a single JavaScript string instance MakeArgs Text where     makeArgs t = valMakeText t >>= (\ref -> return [ref]) --- | Makes a JavaScript string-instance ToJSVal String where-    toJSVal = valMakeText . T.pack-+#ifndef ghcjs_HOST_OS -- | Makes a JavaScript string instance ToJSVal JSString where-    toJSVal = valMakeString+    toJSVal = stringToValue+    {-# INLINE toJSVal #-}+instance FromJSVal JSString where+    fromJSValUnchecked = valToStr+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap Just . valToStr+    {-# INLINE fromJSVal #-}+#endif  -- | If we already have a JSString we are fine instance ToJSString JSString where@@ -530,6 +554,47 @@ instance ToJSString String where     toJSString = textToStr . T.pack +instance FromJSString Text where+    fromJSString = strToText++instance FromJSString String where+    fromJSString v = T.unpack $ strToText v++instance FromJSString JSString where+    fromJSString = id++#ifndef ghcjs_HOST_OS+instance ToJSVal Char where+    toJSVal = valMakeNumber . fromIntegral . ord+    {-# INLINE toJSVal #-}+    toJSValListOf = valMakeText . T.pack+    {-# INLINE toJSValListOf #-}+instance FromJSVal Char where+    fromJSValUnchecked = fmap (chr . round) . valToNumber+    {-# INLINE fromJSValUnchecked #-}+    fromJSVal = fmap (Just . chr . round) . valToNumber+    {-# INLINE fromJSVal #-}+    fromJSValUncheckedListOf = fmap (T.unpack . strToText) . valToStr+    {-# INLINE fromJSValListOf #-}+    fromJSValListOf = fmap (Just . T.unpack . strToText) . valToStr+    {-# INLINE fromJSValUncheckedListOf #-}+#endif++-- | Make a JavaScript string from AESON `Value`+valMakeJSON :: Value -> JSM JSVal+valMakeJSON = toJSVal++#ifndef ghcjs_HOST_OS+-- | Makes a JSON value+instance ToJSVal Value where+    toJSVal = jsonValueToValue+    {-# INLINE toJSVal #-}+#endif++-- | Makes an argument list with just a single JSON value+instance MakeArgs Value where+    makeArgs t = valMakeJSON t >>= (\ref -> return [ref])+ -- | Derefernce a value reference. -- -- >>> testJSaddle $ showJSValue <$> deRefVal JSNull@@ -549,6 +614,8 @@ -- >>> testJSaddle $ showJSValue <$> deRefVal "1" -- "1" -- >>> testJSaddle $ showJSValue <$> (valToObject True >>= deRefVal)+-- true+-- >>> testJSaddle $ showJSValue <$> (obj >>= deRefVal) -- object deRefVal :: ToJSVal value => value -> JSM JSValue #ifdef ghcjs_HOST_OS@@ -561,24 +628,37 @@         3 -> ValNumber <$> valToNumber valref         4 -> ValString <$> valToText valref         5 -> ValObject <$> valToObject valref-foreign import javascript unsafe "$r = ($1 === undefined)?0:\-                                       ($1===null)?1:\-                                       (typeof $1===\"boolean\")?2:\-                                       (typeof $1===\"number\")?3:\-                                       (typeof $1===\"string\")?4:\-                                       (typeof $1===\"object\")?5:-1;" jsrefGetType :: JSVal -> Int+        _ -> error "Unexpected result dereferencing JSaddle value"+foreign import javascript unsafe+#if __GLASGOW_HASKELL__ >= 900+  "(($1) => { return ($1 === undefined)?0:\+                     ($1===null)?1:\+                     (typeof $1===\"boolean\")?2:\+                     (typeof $1===\"number\")?3:\+                     (typeof $1===\"string\")?4:\+                     (typeof $1===\"object\")?5:-1; })" #else+  "$r = ($1 === undefined)?0:\+        ($1===null)?1:\+        (typeof $1===\"boolean\")?2:\+        (typeof $1===\"number\")?3:\+        (typeof $1===\"string\")?4:\+        (typeof $1===\"object\")?5:-1;"+#endif+    jsrefGetType :: JSVal -> Int+#else deRefVal value = do-    gctxt <- ask     v <- toJSVal value-    withJSVal v $ \rval ->-        liftIO (jsvaluegettype gctxt rval) >>= \case-            Kjstypenull      -> return ValNull-            Kjstypeundefined -> return ValUndefined-            Kjstypeboolean   -> ValBool   <$> valToBool v-            Kjstypenumber    -> ValNumber <$> valToNumber v-            Kjstypestring    -> ValString <$> valToText v-            Kjstypeobject    -> ValObject <$> valToObject v+    result <- N.deRefVal v+    return $ case result of+        DeRefValResult 0    _ -> ValNull+        DeRefValResult 1    _ -> ValUndefined+        DeRefValResult 2    _ -> ValBool False+        DeRefValResult 3    _ -> ValBool True+        DeRefValResult (-1) s -> ValNumber (read (T.unpack s))+        DeRefValResult (-2) s -> ValString s+        DeRefValResult (-3) _ -> ValObject (Object v)+        _                     -> error "Unexpected result dereferencing JSaddle value" #endif  -- | Make a JavaScript value out of a 'JSValue' ADT.@@ -596,9 +676,9 @@ valMakeRef :: JSValue -> JSM JSVal valMakeRef value =     case value of-        ValNull              -> valMakeNull-        ValUndefined         -> valMakeUndefined-        ValBool b            -> valMakeBool b+        ValNull              -> return valNull+        ValUndefined         -> return valUndefined+        ValBool b            -> return $ valBool b         ValNumber n          -> valMakeNumber n         ValString s          -> valMakeText s         ValObject (Object o) -> return o@@ -606,6 +686,7 @@ -- | Makes a JavaScript value from a 'JSValue' ADT. instance ToJSVal JSValue where     toJSVal = valMakeRef+    {-# INLINE toJSVal #-}  -- | Makes an argument list with just a single JavaScript value from a 'JSValue' ADT. instance MakeArgs JSValue where@@ -617,9 +698,23 @@  #ifdef ghcjs_HOST_OS foreign import javascript unsafe-  "$1===$2" jsvalueisstrictequal :: JSVal -> JSVal -> Bool+#if __GLASGOW_HASKELL__ >= 900+  "(($1,$2) => { return $1===$2; })"+#else+  "$1===$2" #endif+    jsvalueisstrictequal :: JSVal -> JSVal -> Bool+#endif +-- | Determine if two values are equal (JavaScripts ===)+-- >>> testJSaddle $ strictEqual True False+-- false+-- >>> testJSaddle $ strictEqual True True+-- true+-- >>> testJSaddle $ strictEqual "Hello" ()+-- false+-- >>> testJSaddle $ strictEqual "Hello" "Hello"+-- true strictEqual :: (ToJSVal a, ToJSVal b) => a -> b -> JSM Bool strictEqual a b = do     aval <- toJSVal a@@ -627,36 +722,31 @@ #ifdef ghcjs_HOST_OS     return $ jsvalueisstrictequal aval bval #else-    gctxt <- ask-    withJSVal aval $ \aref ->-        withJSVal bval $ \bref ->-            liftIO $ jsvalueisstrictequal gctxt aref bref+    N.strictEqual aval bval #endif  #ifdef ghcjs_HOST_OS-foreign import javascript unsafe "\-    try {\-        $r = $1 instanceof $2\-    }\-    catch(e) {\-        $3[0] = e;\-    }"-  js_isInstanceOf :: JSVal -> Object -> MutableJSArray -> Bool+foreign import javascript unsafe+#if __GLASGOW_HASKELL__ >= 900+  "(($1,$2) => { return $1 instanceof $2; })"+#else+  "$1 instanceof $2" #endif+  js_isInstanceOf :: JSVal -> Object -> Bool+#endif +-- | Determine if two values are equal (JavaScripts ===)+-- >>> testJSaddle $ instanceOf obj (Object <$> jsg "Object")+-- true instanceOf :: (ToJSVal value, MakeObject constructor) => value -> constructor -> JSM Bool instanceOf value constructor = do     v <- toJSVal value     c <- makeObject constructor #ifdef ghcjs_HOST_OS-    rethrow $ return . js_isInstanceOf v c+    return $ js_isInstanceOf v c #else-    gctxt <- ask-    withJSVal v $ \rval ->-        withObject c $ \c' ->-            rethrow $ liftIO . jsvalueisinstanceofconstructor gctxt rval c'+    N.instanceOf v c #endif-
− tests/DocTest.hs 
@@ -1,35 +0,0 @@-{-# LANGUAGE CPP #-}-module Main (-    main-) where--import Test.DocTest--main :: IO ()-main = doctest [-    "-hide-all-packages",-    "-package=webkitgtk3-javascriptcore-" ++ VERSION_webkitgtk3_javascriptcore,-    "-package=template-haskell-" ++ VERSION_template_haskell,-    "-package=base-" ++ VERSION_base,-    "-package=lens-" ++ VERSION_lens,-    "-package=text-" ++ VERSION_text,-    "-package=transformers-" ++ VERSION_transformers,-    "-package=haskell-gi-base-" ++ VERSION_haskell_gi_base,-    "-package=gi-glib-" ++ VERSION_gi_glib,-    "-package=gi-gtk-" ++ VERSION_gi_gtk,-    "-package=gi-webkit-" ++ VERSION_gi_webkit,-    "-package=gi-javascriptcore-" ++ VERSION_gi_javascriptcore,-    "-isrc",-    "src/Language/Javascript/JSaddle/Arguments.hs",-    "src/Language/Javascript/JSaddle/Classes.hs",-    "src/Language/Javascript/JSaddle/Evaluate.hs",-    "src/Language/Javascript/JSaddle/Exception.hs",-    "src/Language/Javascript/JSaddle/Monad.hs",-    "src/Language/Javascript/JSaddle/Native.hs",-    "src/Language/Javascript/JSaddle/Object.hs",-    "src/Language/Javascript/JSaddle/Properties.hs",-    "src/Language/Javascript/JSaddle/String.hs",-    "src/Language/Javascript/JSaddle/Test.hs",-    "src/Language/Javascript/JSaddle/Types.hs",-    "src/Language/Javascript/JSaddle/Value.hs" ]-