diff --git a/jsaddle.cabal b/jsaddle.cabal --- a/jsaddle.cabal +++ b/jsaddle.cabal @@ -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 -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 . + 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 diff --git a/src-ghc/Data/JSString.hs b/src-ghc/Data/JSString.hs new file mode 100644 --- /dev/null +++ b/src-ghc/Data/JSString.hs @@ -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 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 +-- . + +-- | /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 \"ﬓ\" (men now, U+FB13) is case +-- folded to the sequence \"մ\" (men, U+0574) followed by +-- \"ն\" (now, U+0576), while the Greek \"µ\" (micro sign, +-- U+00B5) is case folded to \"μ\" (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, \"İ\" (Latin capital letter I with dot above, +-- U+0130) maps to the sequence \"i\" (Latin small letter i, U+0069) +-- followed by \" ̇\" (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 \"ß\" (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 fl (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—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 #-} diff --git a/src-ghc/Data/JSString/Internal.hs b/src-ghc/Data/JSString/Internal.hs new file mode 100644 --- /dev/null +++ b/src-ghc/Data/JSString/Internal.hs @@ -0,0 +1,1 @@ +module Data.JSString.Internal where diff --git a/src-ghc/Data/JSString/Internal/Fusion.hs b/src-ghc/Data/JSString/Internal/Fusion.hs new file mode 100644 --- /dev/null +++ b/src-ghc/Data/JSString/Internal/Fusion.hs @@ -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 #-} + +------------------------------------------------------------------------------- + diff --git a/src-ghc/Data/JSString/Internal/Fusion/CaseMapping.hs b/src-ghc/Data/JSString/Internal/Fusion/CaseMapping.hs new file mode 100644 --- /dev/null +++ b/src-ghc/Data/JSString/Internal/Fusion/CaseMapping.hs @@ -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 diff --git a/src-ghc/Data/JSString/Internal/Fusion/Common.hs b/src-ghc/Data/JSString/Internal/Fusion/Common.hs new file mode 100644 --- /dev/null +++ b/src-ghc/Data/JSString/Internal/Fusion/Common.hs @@ -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 () diff --git a/src-ghc/Data/JSString/Internal/Fusion/Types.hs b/src-ghc/Data/JSString/Internal/Fusion/Types.hs new file mode 100644 --- /dev/null +++ b/src-ghc/Data/JSString/Internal/Fusion/Types.hs @@ -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 #-} diff --git a/src-ghc/Data/JSString/Internal/Search.hs b/src-ghc/Data/JSString/Internal/Search.hs new file mode 100644 --- /dev/null +++ b/src-ghc/Data/JSString/Internal/Search.hs @@ -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 diff --git a/src-ghc/Data/JSString/Internal/Type.hs b/src-ghc/Data/JSString/Internal/Type.hs new file mode 100644 --- /dev/null +++ b/src-ghc/Data/JSString/Internal/Type.hs @@ -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` +-} diff --git a/src-ghc/Data/JSString/Text.hs b/src-ghc/Data/JSString/Text.hs new file mode 100644 --- /dev/null +++ b/src-ghc/Data/JSString/Text.hs @@ -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 #-} diff --git a/src-ghc/GHCJS/Buffer.hs b/src-ghc/GHCJS/Buffer.hs new file mode 100644 --- /dev/null +++ b/src-ghc/GHCJS/Buffer.hs @@ -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")) diff --git a/src-ghc/GHCJS/Buffer/Types.hs b/src-ghc/GHCJS/Buffer/Types.hs new file mode 100644 --- /dev/null +++ b/src-ghc/GHCJS/Buffer/Types.hs @@ -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 diff --git a/src-ghc/GHCJS/Concurrent.hs b/src-ghc/GHCJS/Concurrent.hs new file mode 100644 --- /dev/null +++ b/src-ghc/GHCJS/Concurrent.hs @@ -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) + diff --git a/src-ghc/GHCJS/Foreign.hs b/src-ghc/GHCJS/Foreign.hs new file mode 100644 --- /dev/null +++ b/src-ghc/GHCJS/Foreign.hs @@ -0,0 +1,64 @@ +{-# LANGUAGE CPP #-} +----------------------------------------------------------------------------- +-- +-- Module : Language.Javascript.JSaddle.Value +-- Copyright : (c) Hamish Mackenzie +-- License : MIT +-- +-- Maintainer : Hamish Mackenzie +-- +-- | +-- +----------------------------------------------------------------------------- +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 #-} diff --git a/src-ghc/GHCJS/Foreign/Internal.hs b/src-ghc/GHCJS/Foreign/Internal.hs new file mode 100644 --- /dev/null +++ b/src-ghc/GHCJS/Foreign/Internal.hs @@ -0,0 +1,67 @@ +----------------------------------------------------------------------------- +-- +-- Module : Language.Javascript.JSaddle.Value +-- Copyright : (c) Hamish Mackenzie +-- License : MIT +-- +-- Maintainer : Hamish Mackenzie +-- +-- | +-- +----------------------------------------------------------------------------- +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) + diff --git a/src-ghc/GHCJS/Internal/Types.hs b/src-ghc/GHCJS/Internal/Types.hs new file mode 100644 --- /dev/null +++ b/src-ghc/GHCJS/Internal/Types.hs @@ -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_ #-} + diff --git a/src-ghc/GHCJS/Marshal.hs b/src-ghc/GHCJS/Marshal.hs new file mode 100644 --- /dev/null +++ b/src-ghc/GHCJS/Marshal.hs @@ -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 + diff --git a/src-ghc/GHCJS/Marshal/Internal.hs b/src-ghc/GHCJS/Marshal/Internal.hs new file mode 100644 --- /dev/null +++ b/src-ghc/GHCJS/Marshal/Internal.hs @@ -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 diff --git a/src-ghc/GHCJS/Marshal/Pure.hs b/src-ghc/GHCJS/Marshal/Pure.hs new file mode 100644 --- /dev/null +++ b/src-ghc/GHCJS/Marshal/Pure.hs @@ -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 #-} diff --git a/src-ghc/GHCJS/Prim.hs b/src-ghc/GHCJS/Prim.hs new file mode 100644 --- /dev/null +++ b/src-ghc/GHCJS/Prim.hs @@ -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 [] = () diff --git a/src-ghc/GHCJS/Prim/Internal.hs b/src-ghc/GHCJS/Prim/Internal.hs new file mode 100644 --- /dev/null +++ b/src-ghc/GHCJS/Prim/Internal.hs @@ -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 + diff --git a/src-ghc/GHCJS/Types.hs b/src-ghc/GHCJS/Types.hs new file mode 100644 --- /dev/null +++ b/src-ghc/GHCJS/Types.hs @@ -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 " #-} diff --git a/src-ghc/JavaScript/Array.hs b/src-ghc/JavaScript/Array.hs new file mode 100644 --- /dev/null +++ b/src-ghc/JavaScript/Array.hs @@ -0,0 +1,134 @@ +----------------------------------------------------------------------------- +-- +-- Module : JavaScript.Array +-- Copyright : (c) Hamish Mackenzie +-- License : MIT +-- +-- Maintainer : Hamish Mackenzie +-- +-- | 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 (!) #-} + diff --git a/src-ghc/JavaScript/Array/Internal.hs b/src-ghc/JavaScript/Array/Internal.hs new file mode 100644 --- /dev/null +++ b/src-ghc/JavaScript/Array/Internal.hs @@ -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 #-} diff --git a/src-ghc/JavaScript/Object.hs b/src-ghc/JavaScript/Object.hs new file mode 100644 --- /dev/null +++ b/src-ghc/JavaScript/Object.hs @@ -0,0 +1,10 @@ +module JavaScript.Object ( Object + , create + , getProp, unsafeGetProp + , setProp, unsafeSetProp + -- , allProps + , listProps + -- , isInstanceOf + ) where + +import JavaScript.Object.Internal diff --git a/src-ghc/JavaScript/Object/Internal.hs b/src-ghc/JavaScript/Object/Internal.hs new file mode 100644 --- /dev/null +++ b/src-ghc/JavaScript/Object/Internal.hs @@ -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 #-} diff --git a/src-ghc/JavaScript/TypedArray.hs b/src-ghc/JavaScript/TypedArray.hs new file mode 100644 --- /dev/null +++ b/src-ghc/JavaScript/TypedArray.hs @@ -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 + diff --git a/src-ghc/JavaScript/TypedArray/ArrayBuffer.hs b/src-ghc/JavaScript/TypedArray/ArrayBuffer.hs new file mode 100644 --- /dev/null +++ b/src-ghc/JavaScript/TypedArray/ArrayBuffer.hs @@ -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 #-} + diff --git a/src-ghc/JavaScript/TypedArray/ArrayBuffer/Internal.hs b/src-ghc/JavaScript/TypedArray/ArrayBuffer/Internal.hs new file mode 100644 --- /dev/null +++ b/src-ghc/JavaScript/TypedArray/ArrayBuffer/Internal.hs @@ -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 diff --git a/src-ghc/JavaScript/TypedArray/ArrayBuffer/Type.hs b/src-ghc/JavaScript/TypedArray/ArrayBuffer/Type.hs new file mode 100644 --- /dev/null +++ b/src-ghc/JavaScript/TypedArray/ArrayBuffer/Type.hs @@ -0,0 +1,6 @@ +module JavaScript.TypedArray.ArrayBuffer.Type where + +import GHCJS.Prim + + + diff --git a/src-ghc/JavaScript/TypedArray/DataView/Internal.hs b/src-ghc/JavaScript/TypedArray/DataView/Internal.hs new file mode 100644 --- /dev/null +++ b/src-ghc/JavaScript/TypedArray/DataView/Internal.hs @@ -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, () #) + diff --git a/src-ghc/JavaScript/TypedArray/Immutable.hs b/src-ghc/JavaScript/TypedArray/Immutable.hs new file mode 100644 --- /dev/null +++ b/src-ghc/JavaScript/TypedArray/Immutable.hs @@ -0,0 +1,1 @@ +module JavaScript.TypedArray.Immutable where diff --git a/src-ghc/JavaScript/TypedArray/Internal.hs b/src-ghc/JavaScript/TypedArray/Internal.hs new file mode 100644 --- /dev/null +++ b/src-ghc/JavaScript/TypedArray/Internal.hs @@ -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 #-} + diff --git a/src-ghc/JavaScript/TypedArray/Internal/Types.hs b/src-ghc/JavaScript/TypedArray/Internal/Types.hs new file mode 100644 --- /dev/null +++ b/src-ghc/JavaScript/TypedArray/Internal/Types.hs @@ -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 + diff --git a/src/Language/Javascript/JSaddle.hs b/src/Language/Javascript/JSaddle.hs --- a/src/Language/Javascript/JSaddle.hs +++ b/src/Language/Javascript/JSaddle.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} ----------------------------------------------------------------------------- -- -- Module : Language.Javascript.JSaddle @@ -7,9 +6,10 @@ -- -- Maintainer : Hamish Mackenzie -- --- | This package provides an EDSL for calling JavaScript code using --- the JavaScriptCore engine and low level Haskell bindings --- in the webkit-javascriptcore library . +-- | 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 diff --git a/src/Language/Javascript/JSaddle/Arguments.hs b/src/Language/Javascript/JSaddle/Arguments.hs --- a/src/Language/Javascript/JSaddle/Arguments.hs +++ b/src/Language/Javascript/JSaddle/Arguments.hs @@ -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 diff --git a/src/Language/Javascript/JSaddle/Classes.hs b/src/Language/Javascript/JSaddle/Classes.hs --- a/src/Language/Javascript/JSaddle/Classes.hs +++ b/src/Language/Javascript/JSaddle/Classes.hs @@ -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(..)) diff --git a/src/Language/Javascript/JSaddle/Classes/Internal.hs b/src/Language/Javascript/JSaddle/Classes/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Language/Javascript/JSaddle/Classes/Internal.hs @@ -0,0 +1,41 @@ +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE TypeSynonymInstances #-} +----------------------------------------------------------------------------- +-- +-- Module : Language.Javascript.JSaddle.Classes.Internal +-- Copyright : (c) Hamish Mackenzie +-- License : MIT +-- +-- Maintainer : Hamish Mackenzie +-- +-- | 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 + diff --git a/src/Language/Javascript/JSaddle/Debug.hs b/src/Language/Javascript/JSaddle/Debug.hs new file mode 100644 --- /dev/null +++ b/src/Language/Javascript/JSaddle/Debug.hs @@ -0,0 +1,48 @@ +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} +----------------------------------------------------------------------------- +-- +-- Module : Language.Javascript.JSaddle.WebSockets +-- Copyright : (c) Hamish Mackenzie +-- License : MIT +-- +-- Maintainer : Hamish Mackenzie +-- +-- | +-- +----------------------------------------------------------------------------- + +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) diff --git a/src/Language/Javascript/JSaddle/Evaluate.hs b/src/Language/Javascript/JSaddle/Evaluate.hs --- a/src/Language/Javascript/JSaddle/Evaluate.hs +++ b/src/Language/Javascript/JSaddle/Evaluate.hs @@ -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 diff --git a/src/Language/Javascript/JSaddle/Exception.hs b/src/Language/Javascript/JSaddle/Exception.hs --- a/src/Language/Javascript/JSaddle/Exception.hs +++ b/src/Language/Javascript/JSaddle/Exception.hs @@ -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 diff --git a/src/Language/Javascript/JSaddle/Helper.hs b/src/Language/Javascript/JSaddle/Helper.hs new file mode 100644 --- /dev/null +++ b/src/Language/Javascript/JSaddle/Helper.hs @@ -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 #-} diff --git a/src/Language/Javascript/JSaddle/Marshal/String.hs b/src/Language/Javascript/JSaddle/Marshal/String.hs new file mode 100644 --- /dev/null +++ b/src/Language/Javascript/JSaddle/Marshal/String.hs @@ -0,0 +1,32 @@ +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE TypeSynonymInstances #-} +----------------------------------------------------------------------------- +-- +-- Module : Language.Javascript.JSaddle.Marshal.String +-- Copyright : (c) Hamish Mackenzie +-- License : MIT +-- +-- Maintainer : Hamish Mackenzie +-- +-- | `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 + diff --git a/src/Language/Javascript/JSaddle/Monad.hs b/src/Language/Javascript/JSaddle/Monad.hs --- a/src/Language/Javascript/JSaddle/Monad.hs +++ b/src/Language/Javascript/JSaddle/Monad.hs @@ -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 diff --git a/src/Language/Javascript/JSaddle/Native.hs b/src/Language/Javascript/JSaddle/Native.hs --- a/src/Language/Javascript/JSaddle/Native.hs +++ b/src/Language/Javascript/JSaddle/Native.hs @@ -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 diff --git a/src/Language/Javascript/JSaddle/Native/Internal.hs b/src/Language/Javascript/JSaddle/Native/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Language/Javascript/JSaddle/Native/Internal.hs @@ -0,0 +1,253 @@ +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE UnboxedTuples #-} +----------------------------------------------------------------------------- +-- +-- Module : Language.Javascript.JSaddle.Native +-- Copyright : (c) Hamish Mackenzie +-- License : MIT +-- +-- Maintainer : Hamish Mackenzie +-- +-- | +-- +----------------------------------------------------------------------------- + +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 #-} diff --git a/src/Language/Javascript/JSaddle/Null.hs b/src/Language/Javascript/JSaddle/Null.hs new file mode 100644 --- /dev/null +++ b/src/Language/Javascript/JSaddle/Null.hs @@ -0,0 +1,56 @@ +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} +----------------------------------------------------------------------------- +-- +-- Module : Language.Javascript.JSaddle.WebSockets +-- Copyright : (c) Hamish Mackenzie +-- License : MIT +-- +-- Maintainer : Hamish Mackenzie +-- +-- | +-- +----------------------------------------------------------------------------- + +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 diff --git a/src/Language/Javascript/JSaddle/Object.hs b/src/Language/Javascript/JSaddle/Object.hs --- a/src/Language/Javascript/JSaddle/Object.hs +++ b/src/Language/Javascript/JSaddle/Object.hs @@ -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 --- -- undefined -- >>> testJSaddle $ do w <- jsg "console"; w ^. js1 "log" "Hello World" --- ** Message: console message:...@0: Hello World --- -- 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 --- -- 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 diff --git a/src/Language/Javascript/JSaddle/Properties.hs b/src/Language/Javascript/JSaddle/Properties.hs --- a/src/Language/Javascript/JSaddle/Properties.hs +++ b/src/Language/Javascript/JSaddle/Properties.hs @@ -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 diff --git a/src/Language/Javascript/JSaddle/Run.hs b/src/Language/Javascript/JSaddle/Run.hs new file mode 100644 --- /dev/null +++ b/src/Language/Javascript/JSaddle/Run.hs @@ -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 +-- +-- | +-- +----------------------------------------------------------------------------- + +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 diff --git a/src/Language/Javascript/JSaddle/Run/Files.hs b/src/Language/Javascript/JSaddle/Run/Files.hs new file mode 100644 --- /dev/null +++ b/src/Language/Javascript/JSaddle/Run/Files.hs @@ -0,0 +1,466 @@ +{-# LANGUAGE OverloadedStrings #-} +----------------------------------------------------------------------------- +-- +-- Module : Language.Javascript.JSaddle.WebSockets.Files +-- Copyright : (c) Hamish Mackenzie +-- License : MIT +-- +-- Maintainer : Hamish Mackenzie +-- +-- | +-- +----------------------------------------------------------------------------- + +module Language.Javascript.JSaddle.Run.Files ( + indexHtml + , initState + , runBatch + , ghcjsHelpers +) where + +import Prelude () +import Prelude.Compat + +import Data.ByteString.Lazy (ByteString) + +indexHtml :: ByteString +indexHtml = + "\n\ + \\n\ + \\n\ + \JSaddle\n\ + \\n\ + \\n\ + \\n\ + \\n\ + \" + +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\ + \" diff --git a/src/Language/Javascript/JSaddle/String.hs b/src/Language/Javascript/JSaddle/String.hs --- a/src/Language/Javascript/JSaddle/String.hs +++ b/src/Language/Javascript/JSaddle/String.hs @@ -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 - diff --git a/src/Language/Javascript/JSaddle/Test.hs b/src/Language/Javascript/JSaddle/Test.hs deleted file mode 100644 --- a/src/Language/Javascript/JSaddle/Test.hs +++ /dev/null @@ -1,176 +0,0 @@ -{-# LANGUAGE RecordWildCards #-} -{-# LANGUAGE PatternSynonyms #-} ------------------------------------------------------------------------------ --- --- Module : TestJSC --- Copyright : (c) Hamish Mackenzie --- License : MIT --- --- Maintainer : Hamish Mackenzie --- --- | --- ------------------------------------------------------------------------------ - -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) - - - - - - - - - diff --git a/src/Language/Javascript/JSaddle/Types.hs b/src/Language/Javascript/JSaddle/Types.hs --- a/src/Language/Javascript/JSaddle/Types.hs +++ b/src/Language/Javascript/JSaddle/Types.hs @@ -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 diff --git a/src/Language/Javascript/JSaddle/Value.hs b/src/Language/Javascript/JSaddle/Value.hs --- a/src/Language/Javascript/JSaddle/Value.hs +++ b/src/Language/Javascript/JSaddle/Value.hs @@ -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 "" -- --- >>> 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 () -- --- >>> 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 - diff --git a/tests/DocTest.hs b/tests/DocTest.hs deleted file mode 100644 --- a/tests/DocTest.hs +++ /dev/null @@ -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" ] -