All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.jopendocument.dom.oofficeDTDs.OpenDocument-schema-v1.1.rng Maven / Gradle / Ivy






    
        
            
        
    


    
        
        
        
        
        
    


    
        
        
        
        
        
        
        
        
        
        
    


    
        
        
        
        
        
    


    
        
        
        
        
        
    


    
        
        
    


    
        
        
    


    
        
            
        
    


    
        
    


    
        
            
        
    



    



    
        
    


    
        
    


    
        
        
        
            
        
        
    


    
    
    
    


    
        
            
        
        
            
            
                
                    
                    
                
            
        
    



    
        
        
        
        
        
        
        
         
        
        
        
        
        
        
        
        
        
    


    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
        
    



    


    
    


    
        
    


    


    
        
        
        
        
    



    


    
    
    


    
        
    


    
    


    
        
        
        
        
    


    
            
    
    
    



    
            
    
    
            
    
    
            
    


    
        
    


        



    
            
    
    
            
    
    
            
    
    
            
    
    
            
    


    
        
        
        
        
    



    


    
    


    


        


    
        
        
        
        
    



    


    


    


    


    
        
            
                
            
        
    


    
        
        
    



    
        
            
            
            
            
        
    


    
        
    


    
        
        
    


    
        
    


    
        
            boolean
            short
            int
            long
            double
            string
            datetime
            base64Binary
        
    


    
        
        
            
        
    


    
        
    


    
        
        
    


    
        
            
        
    


    
        
        
            
        
    


    
        
    


    
        
            
                
            
            
                
            
        
    


    
        
        
            
        
    


    
        
    


    
        
            
                
            
        
    


    
        
            
                
                
                    
                
                
                    
                
                
                    
                
                
                    
                
                
                    
                
                
                    
                
                
                    
                
                
                    
                
                
                    
                
                
                    
                
                
                    
                
                
                    
                
                
                    
                
                
                    
                
            
        
    


    
        
            
                
                
                    
                
            
        
    


    
        
            
                
                    
                
                
                    
                
                
                    
                
            
        
    



    
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
    


    
        
    


    
        
    


    
        
    


    
        
    


    
        
    


    
        
    


    


    
        
    


    
        
    


    
        
    


    


    
        
    


    
        
    


    
        
            
        
        
            
                simple
            
        
        
            
                onRequest
            
        
        
            
                
            
        
        
            
                
            
        
    


    
        
            
                simple
            
        
        
            
                replace
            
        
        
            
                onLoad
            
        
        
            
                
            
        
        
            
                
            
        
    


    
        
            
                
            
        
        
            
                
                    new
                    replace
                
            
        
    


    
        
    


    
        
    


    
        
    


    
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
    


    
        
            
        
        
            
                
                    float
                
                
            
            
                
                    date
                
                
            
            
                
                    time
                
                
            
            
                
                    boolean
                
                
            
            
                
                    string
                
                
            
            
        
    


    
        
        
        
            
        
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
        
            
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
        
    
    
        
            
            
            
            
        
    


    
        
            
        
    


    
        
    


    
        
        
            
        
        
            
            
        
    


    
        
            
        
    


    


    


    
        
        
            
            
            
        
        
            
        
    


    


    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                true
                none
            
        
        
            
                condition
            
            
                
            
        
        
    


    
        
    


    
        
            
        
        
            
                simple
            
        
        
            
                embed
            
        
    


    
        
            
        
    


    
        
            
        
    


    


    
        
            
            
                
            
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
    


    
        
        
            
        
    


    
        
    


    
        
            
        
        
            
        
        
            
        
    


    
        
    


    
        
    


    
        
            
                
            
        
    
    
        
            
                
            
        
    
    
        
            
                
            
        
    
    
        
            
                
            
        
    
    
        
    


    


    
        
            
                
            
        
    


    
        
    


    
        
            
        
    


    
        
    


    


    
        
            
                
            
        
        
            
                
            
        
        
            
        
    


    
        
        
            
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    
    
        
            simple
        
    
    
        
            onRequest
        
    


    
        
            
        
    
    
        
            
                new
                replace
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
                
            
        
        
            
                
            
        
        
            
                
            
        
    


    
        
            
        
    


    
        
            
                
            
        
        
            
                
            
        
    


    
        
        
            
                
            
        
        
            
                
                    
                
            
            
        
        
            
                
            
        
    


    
        
            footnote
            endnote
        
    


    
        
            
                
            
        
        
            
        
        
            
                
                    
                
            
            
        
    


    


    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
        
        
    


    
        
            
        
    


    
        
            
                previous
                current
                next
            
        
    


    
        
        
    


    
        
            previous
            next
        
    


    
        
            
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
            name
            number
            number-and-name
            plain-number-and-name
            plain-number
        
    


    
        
    


    
        
        
    


    
        
            
                full
                path
                name
                name-and-extension
            
        
    


    


    
        
        
    


    
        
            
                full
                path
                name
                name-and-extension
                area
                title
            
        
    


    
        
    


    
        
        
    


    
        
            
            
            
            
            
        
        
    


    
        
            
            
            
        
        
    


    
        
            
            
            
            
            
        
        
    


    
        
        
            
        
        
    


    
        
            
            
            
        
        
    


    
        
            
            
            
        
        
    


    
        
    


    


    
        
    


    
        
            
        
    


    
        
            
            
            
            
        
        
    


    
        
            
        
    


    
        
            
            
                
            
            
            
        
        
    


    
        
        
    


    
        
        
    


    
        
            
            
            
                
                    
                
            
        
        
    


    
        
            
            
            
                
                    
                
            
        
        
    


    
        
        
    


    
        
            
            
                
            
            
            
                
                    
                
            
            
                
                    
                
            
            
                
                    
                
            
            
                
                    
                
            
            
                
                    
                
            
        
        
    


    
        
            
            
            
                
                    
                
            
        
        
    


    
        
            
            
            
                
                    
                
            
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
            
            
            
                
                    
                
            
        
        
    


    
        
            
            
            
                
                    
                
            
        
        
    


    
        
            
            
            
                
                    
                
            
        
        
    


    
        
        
    


    
        
            text:page-count
            text:paragraph-count
            text:word-count
            text:character-count
            text:table-count
            text:image-count
            text:object-count
        
        
        
    


    
    


    
        
            
        
    


    


    
        
    


    
        
            
                table
                query
                command
            
        
    


    
        
        
    


    


    


    
        
    


    
        
    


    


    
        
            
        
    


    
        
    


    


    
        
            
        
    


    
        
            
        
    


    
        
            
            
            
                
                    
                
            
        
        
    


    
        
        
    


    
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    


    
        
        
    


    
        
            text
            table
            text-box
            image
            object
        
    


    


    
        
        
    


    
        
    


    
        
    


    
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
    


    
        
            
        
    


    
        
            text:reference-ref
            text:bookmark-ref
        
        
            
            
        
    


    
        
            
            
            
        
    


    
        
            
            
        
    


    


    
        
            
        
    


    


    
        
            
                page
                chapter
                direction
                text
            
        
    


    
        
            
                page
                chapter
                direction
                text
                category-and-value
                caption
                value
            
        
    


    
        
            
                
                    
                        
                    
                    
                        
                            simple
                        
                    
                    
                
            
            
                
                    
                
            
        
    


    
        
            
                
            
        
        
            
        
        
    


    
        
        
    


    
        
    


    
        
            
        
    


    
        
            
        
        
    


    
        
            
                value
                unit
                gap
            
        
        
    


    
        
            
            
            
        
        
    


    
        
    


    
        
            
                float
            
            
                
            
        
        
            
                percentage
            
            
                
            
        
        
            
                currency
            
            
                
            
            
                
                    
                
            
        
        
            
                date
            
            
                
            
        
        
            
                time
            
            
                
            
        
        
            
                boolean
            
            
                
            
        
        
            
                string
            
            
                
                    
                
            
        
    


    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
                value
                none
            
        
    


    
        
            
                value
                formula
                none
            
        
    


    
        
            
                value
                formula
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
    


    
    


    
        
            
        
    


    
        
    


    
        
    


    
        
            
        
        
    


    
        
        
        
    


    
        
        
    


    
        
            
        
        
        
    


    
        
    


    
        
        
    


    
        
    


    
        
            
        
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
        
            
                
                    text:identifier
                    text:address
                    text:annote
                    text:author
                    text:booktitle
                    text:chapter
                    text:edition
                    text:editor
                    text:howpublished
                    text:institution
                    text:journal
                    text:month
                    text:note
                    text:number
                    text:organizations
                    text:pages
                    text:publisher
                    text:school
                    text:series
                    text:title
                    text:report-type
                    text:volume
                    text:year
                    text:url
                    text:custom1
                    text:custom2
                    text:custom3
                    text:custom4
                    text:custom5
                    text:isbn
                    text:issn
                
                
            
        
        
    


    
        article
        book
        booklet
        conference
        custom1
        custom2
        custom3
        custom4
        custom5
        email
        inbook
        incollection
        inproceedings
        journal
        manual
        mastersthesis
        misc
        phdthesis
        proceedings
        techreport
        unpublished
        www
    


    
        
            
        
    


    
        
        
    


    
        
        
            
        
    


    
        
        
        
    


    
        
        
            
        
        
            
        
        
            
        
    


    
        
            
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                document
                chapter
            
        
    


    
        
            
        
    


    
        
        
            

        
    


    
        
        
        
        
        
        
        
    


    
        
    


    
        
    


    
        
        
        
    


    
        
        
            
        
        
            
        
    


    


    
        
            
                document
                chapter
            
        
    


    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                text
                category-and-value
                caption
            
        
    


    
        
    


    
    
        
            
            
            
            
        
    


    
        
    


    
        
        
        
    


    
        
        
            
        
        
            
        
    


    
        
    


    
        
        
        
    


    
        
        
            
        
        
            
        
    


    


    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
        
        
    


    
        
        
            
        
        
            
        
        
            
        
    


    
    
    
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
        
            
                
                
                
                
                
            
        
    


    
        
    


    
        
    


    
        
        
        
    


    
        
        
            
        
        
            
        
    


    
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
        
            
                simple
            
        
    


    
        
        
            
                
                
                
                
                
            
        
    


    
        
            1
            2
            3
            separator
        
    


    
        
    


    
        
        
        
    


    
        
            
        
        
            
        
    


    
        
        
            
                
                
                
            
        
    


    
        
    


    
        
    


    
        
            
        
        
            
        
    


    
        
            
        
        
    


    
        
            
                
            
        
        
    


    
        
            
                
            
        
        
    


    
        
            
                name
                number
                number-and-name
            
        
    


    
        
            
                
            
        
    


    
        
            
                
            
        
    


    
        
            
                
            
        
        
    


    
        
    


    
        
            
        
    


    
        
            address
            annote
            author
            bibliography-type
            booktitle
            chapter
            custom1
            custom2
            custom3
            custom4
            custom5
            edition
            editor
            howpublished
            identifier
            institution
            isbn
            issn
            journal
            month
            note
            number
            organizations
            pages
            publisher
            report-type
            school
            series
            title
            url
            volume
            year
        
    


    
        
            
                
            
        
        
    


    
        
            
        
    


    
        
            right
        
        
            
                left
            
            
                
            
        
    


    
        
            
                
            
        
    


    
        
            
                
            
        
    


    
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
        
        
    


    
        
            
            
        
    



    
        
            
            
                
                
                    
                
            
        
        
            
            
                
            
        
    



    
        
        
                
        
    



    
        
            
            
        
    



    
        
            
            
                
                
                    
                
            
        
        
            
            
                
            
        
    



    
        
        
            
                
            
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
            
                
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    



    
        visible
        collapse
        filter
    


    
        
        
        
    



    
        
        
    



    
        
    
    
        
    
    
        
    
    
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    



    
        
            
        
    


    
        
        
    


    
        
            
        
    


    
        
            
                
            
            
        
    



    
        
            
                
            
            
        
    


    
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        ($?([^\. ']+|'([^']|'')+'))?\.$?[A-Z]+$?[0-9]+

    


    
        ($?([^\. ']+|'([^']|'')+'))?\.$?[A-Z]+$?[0-9]+(:($?([^\. ']+|'([^']|'')+'))?\.$?[A-Z]+$?[0-9]+)?

    


    
     


    
        
        
        
    


    
        
            
                copy-all
                copy-results-only
            
        
    


    
        
            
        
    


    
        
            simple
        
    
    
        
            onRequest
        
    
    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
    


    
        
    


    
        
    
    
        
    


    
        
            
        
        
            
        
    


    
        
        
    


    
        
            trace-dependents
            remove-dependents
            trace-precedents
            remove-precedents
            trace-errors
        
    


    
        
    


    
        
            
                
            
            
                
            
        
        
    


    
        
            
        
    


    
        
            from-another-table
            to-another-table
            from-same-table
        
    


    
        
            
        
    


    
        
    


    
        
            
        
    
    
        
            
        
    


    
        
        
            
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                
            
        
        
            
                
            
        
        
    


    
        
            
                
                    enable
                    disable
                
            
        
        
            
                
            
        
        
            
                
            
        
        
    


    
        
            
        
    



    
        
        
            
        
        
            
                
                
                    
                    
                        
                    
                
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                none
                unsorted
                sort-ascending
            
        
    


    
        
            
                
            
        
        
            
                
            
        
        
            
        
    


    
        
            
                
            
        
        
            
                
            
        
        
            
                
                    stop
                    warning
                    information
                
            
        
        
            
        
    


    
        
            
                
            
        
    


    
        
            
        
    



    
        
        
    


    
        
    


    
        
    


    
        
            column
            row
        
    


    
        
            
                
                
            
        
    



    
        
        
    



    
        
    
    
        
    
    
        
            
        
    
    
        
            
                none
                
                    
                        
                            print-range
                            filter
                            repeat-row
                            repeat-column
                        
                    
                
            
        
    


    
        
        
    



    
        
    
    
        
    
    
        
            
        
    


    
        
            
        
    


    
        
        
            
                
                
                
            
        
        
            
        
        
            
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                column
                row
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
    


    
        
        
    


    
        
    


    
        
    


    
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
            
                text
                number
                automatic
                
            
        
    


    
        
            
                ascending
                descending
            
        
    


    
        
        
            
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
        
            
                text
                number
                automatic
                
            
        
    


    
        
            
                ascending
                descending
            
        
    


    
        
        
            
        
    


    
        
    


    
        
        
    


    
        
    


    
        
            auto
            average
            count
            countnums
            max
            min
            product
            stdev
            stdevp
            sum
            var
            varp
            
        
    


    
        
        
            
            
            
        
    


    
        
            
        
    


    
        
            
                self
                cell-range
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                
                
            
        
    


    
        
            
                
                
            
        
    


    
        
        
    


        
        
    


        
        
    


        
        
    


    
            
            
        
    


    
        
            
                text
                number
            
        
    


    
        
            
        
    


    
        
        
            
                
                
                
                
                
            
        
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
                none
                row
                column
                both
            
        
    


    
            
            
        
    


    
            
            
        
    


        
        
    


    
            
            
        
    


    
            
            
        
    


    
            
            
        
    


    
        
        
            
        
    


        
        
    


    
        
        
    


        
        
    


    
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
            
        
        
            
        
        
            
        
    


        
        
    


    
            
            
                row
                column
                data
                hidden
            
        
        
            
                page
            
            
                
            
        
    


    
            
            
        
    


    
        
            
                auto
                average
                count
                countnums
                max
                min
                product
                stdev
                stdevp
                sum
                var
                varp
                
            
        
    


    
            
            
        
    


    
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
    


    
            
            
        
    


    
        
            
        
    


    
        
        
    


    
        
            auto
            average
            count
            countnums
            max
            min
            product
            stdev
            stdevp
            sum
            var
            varp
            
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
    


    
        
    


    
        
            from-top
            from-bottom
        
    


    
        
        
    


    
        
            
                data
            
            
                
            
        
        
            
                none
                manual
                name
            
        
    


    
        
            ascending
            descending
        
    


    
        
        
    


    
        
            tabular-layout
            outline-subtotals-top
            outline-subtotals-bottom
        
    


    
        
    


    
        
    


    
        
    


    
        
            
                named
            
            
                
            
        
        
            
                previous
                next
            
        
    


    
        
            none
            member-difference
            member-percentage
            member-percentage-difference
            running-total
            row-percentage
            column-percentage
            total-percentage
            index
        
    


    
        
        
            
        
    


    
        
    


    
        
            
                
                auto
            
        
        
            
                
                auto
            
        
    


    
        
            
                
                auto
            
        
        
            
                
                auto
            
        
    


    
        
    


    
        
            seconds
            minutes
            hours
            days
            months
            quarters
            years
        
    


    
        
        
            
        
    


    
        
    


    
        
    


    
        
    


    
        
        
    


        
        
            auto
            average
            count
            countnums
            max
            min
            product
            stdev
            stdevp
            sum
            var
            varp
            
        
    


        
        
    


        
        
    


    
        
            
                none
                row
                column
                both
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
            
                
                
                
                
            
        
    


    
        
            
        
    


    
        
        
        
        
            
        
        
            
        
    


    
        
            row
            column
            table
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
        
    


    
        
            
                
                
            
        
    


    
        
            
                
            
        
        
            
        
        
            
        
    


    
        
            
                
            
        
        
    


    
        
        
        
        
            
        
        
            
        
        
            
        
    


    
        
            row
            column
            table
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                
            
            
                
                
                    
                
            
        
    


    
        
        
    


    
        
    


    
        
    


    
        
        
    


    
        
            
        
        
            
                
            
            
                
            
        
    


    
        
        
        
        
        
            
        
        
            
        
    


    
        
        
    



    
        
        
    




    
        
            
        
        
            
        
    


    
        
    
    
        
    
    
        
    


    
        
    
    
        
    
    
        
    
    
        
    
    
        
    
    
        
    


    
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
    


    
        
        
        
        
            
        
        
            
        
        
    


    
        
        
    


    
        
            
                
            
        
        
    


    
        
    


    
        
            
                accepted
                rejected
                pending
            
        
    


    
        
             
        
    


    
        
        
        
            
        
    


    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
            
        
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
                always
                screen
                printer
                none
            
        
    


    
        
        
        
            
        
        
            
        
        
            
                
                
            
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
    


    
        
        
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
        
    


    
        
            
        
    


    
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
        
    


    
        
    
    
        
    


    
        
    
    
        
    


    
        
        
        
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
        
    


    
        
    


    
        
        
        
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
        
    


    
        
        
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
        
    


    
        
            false
        
        
            
                true
            
            
        
    


    
        
    


    
        
    


    
        
        
        
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
        
    


    
        
    


    
        
        
        
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
        
    


    
        
            
        
        
            
        
    


    
        
            
        
    


    
        
            
                full
                section
                cut
                arc
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
        
    


    
        
            
        
        
            
        
    


    
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
        
    


    
        
            
                standard
                lines
                line
                curve
            
        
    


    
        
            
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                
                
                    
                    
                        
                    
                
            
        
    


    
        
        
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
        
    


    
        
            
        
        
            
        
    


    
        
            
        
    


    
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
        
    


    
        
    
    
        
    


    
        
    
    
        
    


    
        
        
        
            
        
        
            
        
        
            
        
        
            
        
    


    
        
    


    
        
        
        
        
        
        
        
            
        
        
            
        
    


    
        
            
        
    


    
        
        
        
        
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
            
            
            
        
    


    
        
            
                
                    
                
            
            
                
                    
                
            
        
        
            
                
                    
                
            
            
                
                    
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    



    
        
            
                page
                frame
                paragraph
                char
                as-char
            
        
    


    
        
            
        
    


    
        
            
            
        
    


    
    
    
    
    
    
    


    
    


    
        
        
    


    
        
    


    
        
             
            
        
    
    
        
             
            
        
    


    
        
            
                top-left
                top
                top-right
                left
                center
                right
                bottom-left
                bottom-right
            
        
    


    
        
            auto
            left
            right
            up
            down
            horizontal
            vertical
        
    


    
        
    


    
        
    


    
        
        
        
        
        
        
        
            
                
                
                
                
                
                
                
            
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
                
                
            
        
    


    
    
        
            
                
                scale
                scale-min
            
        
    
    
        
            
                
                scale
                scale-min
            
        
    


    
        
            
        
    


    
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                
                
            
        
    
    
        
            
                
                
            
        
    


    
        
            
                
                
            
        
    
    
        
            
                
                
            
        
    


    
        
    


    
        
        
            
            
        
        
    


    
        
            
        
        
            
                
                    simple
                
            
        
        
            
                
                    embed
                
            
        
        
            
                
                    onLoad
                
            
        
    



    
        
    


    
        
            
        
    


    
        
        
            
            
            
        
    



    
        
        
            
            
        
    


    
        
            
        
    


    
        
    


    
        
        
            
        
        
            
        
    


    
        
    


    
        
    


    
        
    


    
        
            
        
    


    
        
        
        
            
        
    


    
        
    


    
        
        
    


    
        
    


    
        
    


    
        
        
    


    
        
            
        
    


    
        
        
        
        
        
    



    
        
        
        
        
        
    


    
        
    


    
        
        
    


    
        
    
    
        
            simple
        
    
    
        
            
                onRequest
            
        
    


    
        
            
        
    
    
        
            
                new
                replace
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                
                
                
            
        
    


    
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
    


    
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
    


    
        
        
            
        
        
            
        
        
            
        
        
            
        
        
        
        
            
        
        
            
        
        
            
        
    


    
        
            
        
    
    
        
            
                simple
            
        
    
    
        
            
        
    
    
        
            
                new
                replace
            
            
    


    
        
            
        
    


    
        
            
                nohref
            
        
    


    
        
        
        
        
        
        
        
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
    



    
        
        
        
        
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
                parallel
                perspective
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                flat
                phong
                gouraud
                draft
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
        
    


    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
        
        
        
        
    


    
        
            
        
    
    
        
            
        
    


    
        
        
        
        
        
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
        
        
        
        
        
    


    
        
        
        
        
        
        
        
        
    


    
        
        
        
        
        
        
            
        
        
            
        
        
            
        
        
            
        
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
            
        
        
            
        
    


    
        
            
        
    



    
        non-primitive
        
    


    
        
            
                
                
                
                
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                flat
                phong
                gouraud
                draft
            
        
    


    
        
            
                
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                
                
            
        
    


    
        
            
        
    


    
        
            
                parallel
                perspective
            
        
    


    
        
            
        
    



    


    
        
            
                
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                none
                segments
                rectangle
            
        
    


    
        
    


    
        
            
        
    


    
        
            
                normal
                path
                shape
            
        
    


    
        
            
                path
                shape
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        title
        outline
        subtitle
        text
        graphic
        object
        chart
        table
        orgchart
        page
        notes
        handout
        header
        footer
        date-time
        page-number
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                
                
            
        
    


    
        
        
        
        
        
        
    


    
        
        
            
        
        
            
                
                    simple
                
            
        
        
            
                
                    onRequest
                
            
        
        
            
                
                    new
                    replace
                
            
        
        
    


    
        
            
        
    


    
        
        
            
        
    


    
        
    


    
        
            
        
    


    
        none
        fade
        move
        stripes
        open
        close
        dissolve
        wavyline
        random
        lines
        laser
        appear
        hide
        move-short
        checkerboard
        rotate
        stretch
    


    
        
            
        
    


    
        none
        from-left
        from-top
        from-right
        from-bottom
        from-center
        from-upper-left
        from-upper-right
        from-lower-left
        from-lower-right
        to-left
        to-top
        to-right
        to-bottom
        to-upper-left
        to-upper-right
        to-lower-right
        to-lower-left
        path
        spiral-inward-left
        spiral-inward-right
        spiral-outward-left
        spiral-outward-right
        vertical
        horizontal
        to-center
        clockwise
        counter-clockwise
    


    
        
            
        
    


    
        slow
        medium
        fast
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
        
            
        
    


    
        
        
            
        
    


    
        
        
            
        
    


    
        
        
            
        
    


    
        
    


    
        
    


    
        
        
    


    
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
                default
                on-click
                with-previous
                after-previous
                timing-root
                main-sequence
                interactive-sequence
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                custom
                entrance
                exit
                emphasis
                motion-path
                ole-action
                media-call
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
            
        
    


    
        
    


    
        
            none
            previous-page
            next-page
            first-page
            last-page
            hide
            stop
            execute
            show
            verb
            fade-out
            sound
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
                simple
            
        
    
    
        
            
                embed
            
        
    
    
        
            
                onRequest
            
        
    


    
        
            
        
    


    
        
    


    
        
    


    
        
    


    
        
    


    
        
        
    


    
        
    


    
        
        
    


    
        
    


    
        
        
    


    
        
    


    
        
            fixed
            current-date
        
    


    
        
            
        
    


    
        
            
            
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                enabled
                disabled
            
        
    


    
        
            
                enabled
                disabled
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    


    
        
        
            
        
        
            
        
        
            
        
        
            
        
        
        
            
        
    


    
        
    


    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
            
        
    


    
        
            
        
    


    


    
        
            
        
    


    
        
        
            
        
    


    
        
        
            
        
    


    
        
        
    


    
        
            
                
                    start
                    end
                    top
                    bottom
                
            
            
                
                    
                        start
                        center
                        end
                    
                
            
        
        
            
                top-start
                bottom-start
                top-end
                bottom-end
            
        
        
    


    


    
        
            
                wide
                high
                balanced
            
        
        
            
                custom
            
            
                
            
        
        
    


    
        
            
        
    


    
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
    


    
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                none
                row
                column
                both
            
        
    


    
    


    
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
            
        
        
            
        
        
            
        
    


    
        
            x
            y
            z
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
            
                major
                minor
            
        
    


    
        
            
        
    


    
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
    
        
            
        
    
    


    
    
        
            
        
    
    


    
        
        
    


    
        
            
        
    


    
        
            
        
    



    
        
        
    


    
        
            
        
    


    
        
        
    


    
        
            
        
    


    
        
        
    


    
        
            
        
    


    
        
    


    
        
    


    
        
    


    
        
            
        
    


    
        
            
            
                
                    
                    
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
            
        
        
            
        
        
            
                
                
            
        
        
            
        
    


    
        
            
        
        
            
                simple
            
        
        
            
                onRequest
            
        
    


    
        
            
        
    


    
        
            
                get
                post
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                table
                query
                command
            
        
    


    
        
    


    
        
            
                
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    



    
        none
        current
        parent
    


    
        
            
        
    


    
        
            
        
    


    
        records
        current
        page
    


    
        
            
        
        
    


    
        
    


    
        
        
    


    


    
    
    
    
    
    
    
    
    
    
    


    
    
    


    
        
    
    
        
    


    
        
        
        
            
        
    


    
    
    
    
    
    
    
    
    
    
    


    
        
        
    


    
    
    
    
    
    
    
    


    
        
            
        
    


    
        
        
    


    
    
    
    
    
    
    
    
    


    
        
        
    


    
    
    
    
    
    
    
    
    
    
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
    


    
    
    
    
    
    
    
    
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
    


    
        
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
    
    
    
    
    


    
        
            
        
    


    
        
        
        
            
        
    


    
    
    
    
    
    
    
    
    
    
    
    
    
    
    


    
        
            
        
    


    
        
        
    


    


    
        
        
        
            
        
    


    
    
    
    
    
    
    
    
    
    
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
    
    
    


    
        
        
    


    
    
    
    
    
    
    
    
    
    
    
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
    
    
    
    
    
    
    
    
    


    
        
        
    


    
    
    
    
    
    
    
    
    
    


    
        unchecked
        checked
        unknown
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
    
    
    
    
    
    
    
    
    
    
    


    
        
        
    


    
    
    
    
    
    


    
        
        
    


    
    
    
    
    
    
    


    
        
        
    


    
    


    
        
        
        
            
        
    


    
    
    
    
    


    
        
        
            
        
    


    
    
    


    
        
            
        
    


    
        
        
    


    
    
    
    
    
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                horizontal
                vertical
            
        
    


    
        
        
    


    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        submit
        reset
        push
        url
    


    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
            
                flat
                3d
            
        
    


    
        
            
                center
            
        
        
            
                
                    start
                    end
                    top
                    bottom
                
            
            
                
                    
                        start
                        center
                        end
                    
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                table
                query
                sql
                sql-pass-through
                value-list
                table-fields
            
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
        
            void
        
    


    
        
        
    


    
        
            
                float
            
            
                
                    
                        
                    
                
            
        
        
            
                percentage
            
            
                
                    
                        
                    
                
            
        
        
            
                currency
            
            
                
                    
                        
                    
                    
                        
                            
                        
                    
                
            
        
        
            
                date
            
            
                
                    
                        
                    
                
            
        
        
            
                time
            
            
                
                    
                        
                    
                
            
        
        
            
                boolean
            
            
                
                    
                        
                    
                
            
        
        
            
                string
            
            
                
                    
                        
                    
                
            
        
        
            void
        
    


    
        
        
        
        
        
        
            
        
        
            
        
        
            
        
        
            
                
                
            
        
    


    
        
            
        
    


    
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
                1
                i
                I
                
                
            
        
        
            
                
                    a
                    A
                
            
            
        
        
    


    
        
            
        
    


    
        
        
        
            
        
    


    
        
            
                
                
            
        
    


    
        
        
    


    
        
    


    
        
    


    
        
            
        
        
            
                
            
            
                
                    simple
                
            
            
                
                    onRequest
                
            
        
    


    
        
    





    
        
            
                
            
            
            
                
                
            
        
    


    
        
        
    


    
        
    


    
        
    


    
        
    


    
        
    


    
        
            
        
    


    
        
        
    


    
        
        
    


    
        
            
        
    


    
        
            
                into-default-style-data-style
                into-english-number
                keep-text
            
        
    


    
        
        
        
        
        
        
        
    


    
        
        
        
        
        
    


    
        
        
        
        
        
        
        
    


    
        
            
        
    


    
        
            
        
    


    
           
            
                discrete
                linear
                paced
                spline
            
        
    


    
        
        
        
        
        
        
        
        
    


    
        
            
                rgb
                hsl
            
        
    


    
        
            
                clockwise
                counter-clockwise
            
        
    


    
        
        
        
        
        
        
    


    
        
            translate
            scale
            rotate
            skewX
            skewY 
        
    


    
        
        
        
        
        
        
    


    
        
    


    
        
            
        
    


    
        
            
                forward
                reverse
            
        
    


    
        
            
                forward
                reverse
            
        
    


    
        
            
                in
                out
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
           
            
                discrete
                linear
                paced
                spline
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                none
                sum
            
        
    


    
        
            
                replace
                sum
            
        
    


    
        
            
        
    


    
        
            
        
    



    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                first
                last
                all
                media
            
        
    


    
        
            
        
    
    
        
            
                
                indefinite
            
        
    


    
        
            
                remove
                freeze
                hold
                auto
                default
                transition
            
        
    


    
        
            
                remove
                freeze
                hold
                transition
                auto
                inherit
            
        
    


    
        
            
                never
                always
                whenNotActive
                default
            
        
    


    
        
            
                never
                always
                whenNotActive
                inherit
            
        
    


        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
        
            
        
    



   
   
   



   
   
   
   
   
   


    
        
        
        
        
            
        
    


    
        
        
        
        
        
            
        
    


    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
        
        
            
                
                
            
        
    


    
        
    


    
        
        
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
    


    
        
            
        
    


    
        
    


    
        
        
            
        
        
            
        
        
            
        
    


    
        
    


    
        
            
                all
                left
                right
                mirrored
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
            
            
                
            
        
        
            
            
                
            
        
        
            
        
        
            
        
        
            
        
        
            
        
    


    
        
    


    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
        
    


    
        
            
            
            
                
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                
            
        
        
            
                
            
            
                
            
            
                
            
        
    


    
        
            
        
    


    
        
    


    
        
    


    
        
    



    
        
    


    
        
        
        
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
            
        
        
            
        
        
            
        
        
            
        
        
            
            
                
                
            
            
                
                
            
        
    


    
        
    


    
        
    



    
        
    



    
        
    



    
        
    



    
        row
        column
    


    
        
        
    



    
        
        
    



    
        
        
    



    
        
        
    



    
        
        
    



    
        
        
    



    
        
        
    



    
        
        
    



    
        
        
    



    
        
    
    
        
            
        
    


    
        
        
            
        
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
                normal
                ultra-condensed
                extra-condensed
                condensed
                semi-condensed
                semi-expanded
                expanded
                extra-expanded
                ultra-expanded
            
        
    
    
        
            
        
    
    
        
    
    
        
            
        
    
    
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
        
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
    
    
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
        
    
        
            
        
    



    
        
            
                
                
            
        
    



    
        
        
            
        
    



    
        
            
        
        
    


    
        
            
        
        
    



    
        
    
    



    
        
    
    
        
            simple
        
    
    
        
            onRequest
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    



    
        
            
        
    


    
        
        
            
        
        
            
        
        
            
            
                
            
        
        
            
        
    



    
        
        
        
    


    
        
        
        
        
            
        
    


    
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
        
        
        
    


    
        
            
        
    


    
        
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
            
        
        
            
        
        
            
                
                    
                    
                        
                    
                
                
                    
                    
                        
                    
                
            
        
        
            
        
    



    
    
        
    


    
    
        
    


    
        
        
    


    
        
            
        
    
    
        
            
        
    


    
        
        
            
        
        
            
        
        
            
        
        
            
        
    


    
        
        
        
        
            
        
        
        
        
            
        
        
            
            
                
            
        
        
            
        
    



    
        
        
        
        
        
        
        
        
        
        
        
    


    
        
        
        
    


    
        
            
                short
                long
            
        
    


    
        
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                short
                long
            
        
    


    
        
        
        
    


    
        
            
                short
                long
            
        
    


    
        
        
        
    


    
        
            
                short
                long
            
        
    


    
        
        
        
    


    
        
            
                short
                long
            
        
    


    
        
        
    


    
        
        
        
    


    
        
            
                short
                long
            
        
    


    
        
        
        
        
            
        
        
        
        
            
        
        
            
            
                
            
        
        
            
        
    



    
        
        
        
        
    


    
        
            
        
    


    
        
        
    


    
        
            
                short
                long
            
        
    


    
        
        
    


    
        
            
                short
                long
            
        
    


    
        
        
    


    
        
            
                short
                long
            
        
    


    
        
            
        
    


    
        
    


    
        
        
            
        
        
            
        
        
            
            
                
            
        
        
            
        
    


    
        
    


    
        
        
            
        
        
            
        
        
            
            
                
            
        
        
            
        
    


    
        
    


    
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                fixed
                language
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                short
                medium
                long
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                gregorian
                gengou
                ROC
                hanja_yoil
                hanja
                hijri
                jewish
                buddhist
                
            
        
    


    
        
            text
        
        
            
        
    


    
        
            paragraph
        
        
            
        
        
            
        
    


    
        
            section
        
        
            
        
    


    
        
            ruby
        
        
            
        
    


    
        
        
            
        
    


    
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                left
                right
                inner
                outer
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                
            
        
        
    


    
        
    


    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
    
        
    


    
        
            
                document
                chapter
                page
            
        
    


    
        
            
                text
                page
                section
                document
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
        
    



    
        
            address
            annote
            author
            bibliography-type
            booktitle
            chapter
            custom1
            custom2
            custom3
            custom4
            custom5
            edition
            editor
            howpublished
            identifier
            institution
            isbn
            issn
            journal
            month
            note
            number
            organizations
            pages
            publisher
            report-type
            school
            series
            title
            url
            volume
            year
        
    
    
        
            
        
    


    
        
        
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
        
        
            
        
        
            
        
    


    
        
            
        
    


    
    


    
        
            
        
    


    
        
            
        
    


    
        
        
        
            
        
        
            
        
    


    
        
            
        
    


    
        
    


    


    
        
            
        
    


    
        
        
        
            
        
    


    
        
        
    


    
        
            
        
    


    
        
        
            
        
        
            
        
    


    
        
    


    
        
            
        
    


    
    


    
        
            
        
    


    
        
            
        
    


    
        
            table
        
        
            
        
    


    
        
            table-column
        
        
            
        
    


    
        
            table-row
        
        
            
        
    


    
        
            table-cell
        
        
            
        
        
            
        
        
            
        
    


    
        
            
                graphic
                presentation
            
        
        
            
        
        
            
        
        
            
        
    



    
        
    



    



    
    
    



    


    
        
            drawing-page
        
        
            
        
    



    
        
    



    



    
    
    


    
        
        
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        linear
        axial
        radial
        ellipsoid
        square
        rectangular
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
            
                
                    
                    
                                
            
        
        
            
                
                    
                    
                                
            
        
        
            
                
                    
                    
                                
            
        
        
            
                
                    
                    
                                
            
        
        
            
        
    



    
        
        
            
                
                    
                    
                                
            
        
        
            
                
                    
                    
                                
            
        
        
            
                
                    
                    
                                
            
        
        
            
                
                    
                    
                                
            
        
        
            
                
                    
                    
                                
            
        
        
            
        
    



    
        
            
                
                
            
        
        
            
                
            
        
        
            
                
            
        
    



    
        
            objectBoundingBox
        
    
    
        
            
        
    
    
        
            
                pad
                reflect
                repeat
            
        
    


    
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
            
        
    


    
        
            single
            double
            triple
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
        
            
        
        
            
                
                    simple
                
            
        
        
            
                
                    embed
                
            
        
        
            
                
                    onLoad
                
            
        
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
        
        
    


    
        
            
        
    
    
        
            
        
    


    
        
        
        
        
    


    
        
    


    
        
            
        
    


    
        
        
    


    
        
    


    
        
            
        
    


    
        
            
                rect
                round
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
        
            
                
            
        
        
            
        
    


    
        
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
            
                
                
            
        
        
    


    
        
            chart
        
        
            
        
        
            
        
        
            
        
        
            
        
    


    


    
        
    



    



    
    


    
        
            
        
    
    
        
            
        
    


    
        
    
    


    
        
            
                default
                
            
        
    


    
        
            
                portrait
                landscape
            
        
    


    
    
    


    


    


    


    


    


    


    


    
        
            
        
    


    
        
            
                
                    
                        headers
                        grid
                        annotations
                        objects
                        charts
                        drawings
                        formulas
                        zero-values
                    
                
            
        
    


    
        
            
                ttb
                ltr
            
        
    


    
        
            
                
                continue
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
                horizontal
                vertical
                both
                none
            
        
    


    
        
            
        
    


    


    



    
        
            
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
                left
                center
                right
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
                none
                line
                both
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    



    



        
        


    
        
            
        
    
    
        
            
        
    


    
    
    


    


    


    


    


    


    


    
        
            
        
    


    
        
    



    



    
    



    


    
        
            
        
    



    
        normal
        small-caps
    


    
        
            
                none
                lowercase
                uppercase
                capitalize
            
        
    


    
            
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                font-color
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                
                    
                    super
                    sub
                
                
                    
                
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    



    
        roman
        swiss
        modern
        decorative
        script
        system
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    



    
        fixed
        variable
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    



    
        [A-Za-z][A-Za-z0-9._\-]*
    


    
        
            
                
                
            
        
    
    
        
            
                
                
            
        
    
    
        
            
                
                
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
                latin
                asian
                complex
                ignore
            
        
    


    
        
            
                
                normal
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    



    
        normal
        italic
        oblique
    


    
        
            
            none
                embossed
                engraved
            
        
    


    
        
            
        
    



    
        none
        
        
    


    
        
            
        
    



    
        none
        single
        double
    


    
        
            
        
    



    
        none
        solid
        dotted
        dash
        long-dash
        dot-dash
        dot-dot-dash
        wave
    


    
        
            
        
    



    
        auto
        normal
        bold
        thin
        dash
        medium
        thick
        
        
        
    


    
        
            
                font-color
                
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    



    
        normal
        bold
        100
        200
        300
        400
        500
        600
        700
        800
        900
    


    
        
            
        
    



    
        continuous
        skip-white-space
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    


    
        
            
                none
                letters
                lines
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
                none
                
                    
                        none
                        accent
                        dot
                        circle
                        disc
                    
                    
                        above
                        below
                    
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                fixed
                line-height
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            true
        
        
            none
        
        
            
                condition
            
            
                none
            
        
        
    


    
        
    



    



    
    


    
        
            
                normal
                
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    



    
        
            
                start
                end
                left
                right
                center
                justify
            
        
    


    
        
            
                start
                center
                justify
            
        
    


    
        
            
        
    


    
        
            
                auto
                always
            
        
    


    
        
            
        
    


    
        
            
        
    


    



    
        
            
                
            
        
    



    
        
        
    


    
        
    


    
        
            
                
                    left
                    center
                    right
                
            
        
        
            
                char
            
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                font-color
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                auto
                page
            
        
    


    
        
            
                no-limit
                
            
        
    


    



    
        
            
            
        
    


    
        
            
                word
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


        
            
                
            
        
    

    



    
        
            
                
                
            
        
    
    
        
            
                
                
            
        
    


    
        
            
                
                
            
        
    


    
        
            
        
    


    



    
        
            
                
                
            
        
    
    
        
            
                
                
            
        
    


    



    
        
            
                
                
            
        
    


    



    
        
            
                auto
                column
                page
            
        
    
    
        
            
                auto
                column
                page
            
        
    


    



    
        
            
                transparent
                
            
        
    


    



    
        
            
            
                
                
                
            
        
    


    
        
            
                no-repeat
                repeat
                stretch
            
        
    


    
        
            
                left
                center
                right
                top
                bottom
                
                    
                    
                
                
                    
                    
                
            
        
    



    
        left
        center
        right
    


    
        top
        center
        bottom
    


    
        
            
        
    


    
        
            
        
    


    



    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    



    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    



    
        
        
        
    


    



    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    



    
        
            
        
    


    



    
        
            
                auto
                always
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                none
                ideograph-alpha
            
        
    


    
        
            
                simple
                hanging
            
        
    


    
        
            
                normal
                strict
            
        
    


    
        
            
                top
                middle
                bottom
                auto
                baseline
            
        
    


    



    
        
            
                lr-tb
                rl-tb
                tb-rl
                tb-lr
                lr
                rl
                tb
                page
            
        
    


    
        
            
        
    


    
        
            
        
    


    



    
        
                                            auto            
        
    


    
        
            
        
    


    
        
    



    



    
    



    


    
        
            
                above
                below
            
        
    


    
        
            
                left
                center
                right
                distribute-letter
                distribute-space
            
        
    


    
        
    



    



    
    


    


    


    


    



    
        
            
            
                
            
            
                
            
        
    


    
        
    


    
        
            
        
    


    
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    


    
        
            
                none
                solid
                dotted
                dashed
                dot-dashed
            
        
    


    
        
    


    
        
            
        
    


    
        
            
                top
                middle
                bottom
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    


    
        
    


    
        
    



    



    
    


    
        
            
        
    
    
        
            
        
    


    
        
            
                left
                center
                right
                margins
            
        
    


    


    


    


    


    


    


    


    


    


    
        
            
        
    


    
        
            
                collapsing
                separating
            
        
    


    


    
        
            
        
    


    
        
    



    



    
    



    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    


    
        
    



    



    
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    


    


    


    
        
            
                auto
                always
            
        
    


    
        
    



    



    
    


    
        
            
                top
                middle
                bottom
                automatic
            
            
    


    
        
            
                fix
                value-type
            
        
    


    



    
        
            
                ltr
                ttb
            
        
    


    
        
            
                auto
                0
            
        
    


    


    


    


    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    


    


    
        
            
                no-wrap
                wrap
            
        
    


    



    
        
            
        
    


    
        
            
                none
                bottom
                top
                center
            
        
    


    
        
            
                none
                hidden-and-protected
                
                    
                        
                            protected
                            formula-hidden
                        
                    
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
    



    



    
    



    


    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
    


    
        
            
                none
                dash
                solid
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                
                    0
                    1
                
                
            
        
    


    
        
            
                miter
                round
                bevel
                middle
                none
                inherit
            
        
    


    
        
            
                none
                solid
                bitmap
                gradient
                hatch
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                no-repeat
                repeat
                stretch
            
        
    


    
        
            
                
                
            
        
    
    
        
            
                
                
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
                top-left
                top
                top-right
                left
                center
                right
                bottom-left
                bottom
                bottom-right
            
        
    


    
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                nonzero
                evenodd
            
        
    


    
        
            
        
    


    
        
            
                none
                scroll
                alternate
                slide
            
        
    


    
        
            
                left
                right
                up
                down
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                top
                middle
                bottom
                justify
            
        
    


    
        
            
                left
                center
                right
                justify
            
        
    


    
        
            
                no-wrap
                wrap
            
        
    


    
        
    


    
        
            
                greyscale
                mono
                watermark
                standard
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                visible
                hidden
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                below
                above
            
        
    


    
        
            
        
    


    
        
            
                automatic
                left-outside
                inside
                right-outside
            
        
    
    
        
            
                automatic
                above
                below
                center
            
        
    


    
        
            
                automatic
                mm
                cm
                m
                km
                pt
                pc
                inch
                ft
                mi
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                straight-line
                angled-line
                angled-connector-line
            
        
    


    
        
            
                fixed
                free
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                horizontal
                vertical
                auto
            
        
    


    
        
            
                
                
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                correct
                attractive
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                enabled
                disabled
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                standard
                double-sided
            
        
    


    
        
            
                object
                flat
                sphere
            
        
    


    
        
            
                normal
                inverse
            
        
    


    
        
            
                object
                parallel
                sphere
            
        
    
    
        
            
                object
                parallel
                sphere
            
        
    


    
        
            
                luminance
                intensity
                color
            
        
    


    
        
            
                enabled
                disabled
            
        
    


    
        
            
                replace
                modulate
                blend
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
                visible
                hidden
            
        
    


    
    
        
            
                
                
            
        
    


    
        
            
                
                
            
        
    


    
        
            
                
                
            
        
    
    
        
            
                
                
            
        
    


    


    


    


    
        
            
        
    


    
        
            
                none
                
                    
                        
                            content
                            position
                            size
                        
                    
                
            
        
    


    
        
            
                left
                center
                right
                from-left
                inside
                outside
                from-inside
            
        
    
    
        
            
        
    


    
        
            
                    page
                page-content
                page-start-margin
                page-end-margin
                frame
                frame-content
                frame-start-margin
                frame-end-margin
                paragraph
                paragraph-content
                paragraph-start-margin
                paragraph-end-margin
                char
            
        
    


    



    
        
            
                top
                middle
                bottom
                from-top
                below
            
        
    
    
        
            
        
    


    



    
        
            
                page
                page-content
                frame
                frame-content
                paragraph
                paragraph-content
                char
                line
                baseline
                text
            
        
    


    


    


    


    


    


    


    


    


    
        
            
        
    


    
        
            
                none
                left
                right
                parallel
                dynamic
                run-through
                biggest
            
        
    


    
        
            
        
    


    
        
            
                no-limit
                
            
        
    


    
        
            
        
    


    
        
            
                full
                outside
            
        
    


    
        
            
                foreground
                background
            
        
    


    
        
            
        
    


    
        
            
                clip
                auto-create-new-frame
            
        
    


    
        
            
                none
                vertical
                
                
                    vertical
                    
                
                
                    
                    vertical
                
            
        
    



    
        horizontal
        horizontal-on-odd
        horizontal-on-even
    


    
        
            
            
        
    


    
        
            
                iterative
                once-concurrent
                once-successive
            
        
    


    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    



    
        ([0-9]+(\.[0-9]*)?|\.[0-9]+)(px)
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
    



    



    
    



    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            none
        
        
            automatic
        
        
            
                named-symbol
            
            
                
                    square
                    diamond
                    arrow-down
                    arrow-up
                    arrow-right
                    arrow-left
                    bow-tie
                    hourglass
                    circle
                    star
                    x
                    plus
                    asterisk
                    horizontal-bar
                    vertical-bar
                
            
        
        
            
                image
            
            
                
                    
                
            
        
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
                none
                cubic-spline
                b-spline
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                cuboid
                cylinder
                cone
                pyramid
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
        
    


    
        
            
        
    
    
        
            
        
    
    
        
            
        
    
    
        
            
                side-by-side
                stagger-even
                stagger-odd
            
        
    


    


    


    
        
            
                none
                value
                percentage
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                none
                variance
                standard-deviation
                percentage
                error-margin
                constant
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
        
    
    
        
            
        
    


    
        
            
                columns
                rows
            
        
    


    
        
            
                none
                linear
                logarithmic
                exponential
                power
            
        
    


    
        
            
                manual
                automatic
                semi-automatic
            
        
    


    
        
            
                none
                fade-from-left
                fade-from-top
                fade-from-right
                fade-from-bottom
                fade-from-upperleft
                fade-from-upperright
                fade-from-lowerleft
                fade-from-lowerright
                move-from-left
                move-from-top
                move-from-right
                move-from-bottom
                move-from-upperleft
                move-from-upperright
                move-from-lowerleft
                move-from-lowerright
                uncover-to-left
                uncover-to-top
                uncover-to-right    
                uncover-to-bottom
                uncover-to-upperleft
                uncover-to-upperright
                uncover-to-lowerleft
                uncover-to-lowerright
                fade-to-center
                fade-from-center
                vertical-stripes
                horizontal-stripes
                clockwise
                counterclockwise
                open-vertical
                open-horizontal
                close-vertical
                close-horizontal
                wavyline-from-left
                wavyline-from-top
                wavyline-from-right
                wavyline-from-bottom
                spiralin-left
                spiralin-right
                spiralout-left
                spiralout-right
                roll-from-top
                roll-from-left
                roll-from-right
                roll-from-bottom
                stretch-from-left
                stretch-from-top
                stretch-from-right
                stretch-from-bottom

                vertical-lines
                horizontal-lines
                dissolve
                random
                vertical-checkerboard
                horizontal-checkerboard
                interlocking-horizontal-left
                interlocking-horizontal-right
                interlocking-vertical-top
                interlocking-vertical-bottom
                fly-away
                open
                close
                melt
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                forward
                reverse
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
                visible
                hidden
            
        
    


    
        
    


    
        
            
                full
                border
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    
        
            
        
    


    


    


    


    


    


    


    


    


    


    


    


    


    


    


    
        true
        false
    


    
        
        
    


    
        
        
    


    


    
        [A-Za-z0-9]{1,8}
    


    
        [A-Za-z]{1,8}
    


    
        1
    


    
        -?([0-9]+(\.[0-9]*)?|\.[0-9]+)((cm)|(mm)|(in)|(pt)|(pc)|(px))

    


    
        ([0-9]+(\.[0-9]*)?|\.[0-9]+)((cm)|(mm)|(in)|(pt)|(pc)|(px))

    


    
        ([0-9]*[1-9][0-9]*(\.[0-9]*)?|0+\.[0-9]*[1-9][0-9]*|\.[0-9]*[1-9][0-9]*)((cm)|(mm)|(in)|(pt)|(pc)|(px))

    


    
        -?([0-9]+(\.[0-9]*)?|\.[0-9]+)%
    


    
        [0-9]+\*
    


    


    


    
        #[0-9a-fA-F]{6}
    


    


    
        
        
    


    
        
            
        
    


    


    
    
    



    
        _self
        _blank
        _parent
        _top
        
    



    
        float
        time
        date
        percentage
        currency
        boolean
        string
    



    
        -?[0-9]+,-?[0-9]+([ ]+-?[0-9]+,-?[0-9]+)*
    


    



    
        \([ ]*-?([0-9]+(\.[0-9]*)?|\.[0-9]+)([ ]+-?([0-9]+(\.[0-9]*)?|\.[0-9]+)){2}[ ]*\)

    



    
        [0-9a-zA-Z_]+:[0-9a-zA-Z._\-]+
    


    
        
            
            
        
    
    


    
        
            
            
                
            
        
    






© 2015 - 2024 Weber Informatics LLC | Privacy Policy