https://github.com/titaniumbones/org-lms

A simple Emacs mode for marking papers with Org.
https://github.com/titaniumbones/org-lms

Last synced: about 7 hours ago
JSON representation

A simple Emacs mode for marking papers with Org.

• Host: GitHub
• URL: https://github.com/titaniumbones/org-lms
• Owner: titaniumbones
• Created: 2015-07-18T18:59:25.000Z (about 9 years ago)
• Default Branch: master
• Last Pushed: 2021-09-03T13:31:32.000Z (about 3 years ago)
• Last Synced: 2023-03-12T07:57:03.592Z (over 1 year ago)
• Language: HTML
• Size: 529 KB
• Stars: 23
• Watchers: 5
• Forks: 5
• Open Issues: 37
• Metadata Files:
  • Readme: README.org

Awesome Lists containing this project

README

        
#+TITLE: Org-Mode Marking & Integrations for the Canvas LMS

* Intro

This repository includes *generic functions for interacting with the Canvas LMS* as well as *instructions for a highly individualized and specific grading setup.* Where possible I have tried to distinguish between the two but there are still places where I have not adequately separated them.  

Also, this package is fairly unstable due to the low quality of the code :-/. Expect API's to continue to change.

* Installation

This package  is developed with emacs 27.0.50 and org-mode from git; there's no guarantee it will work with other versions, sorry :-(. 

It also depends on [[https://github.com/tkf/emacs-request][request.el]] and [[https://github.com/org-mime/org-mime][org-mime]], both of which can be downloaded from MELPA. ~Request.el~ in particular has changed a lot in the last little while (mid-2019) so the MELPA version is required. 

As of <2019-09-30 Mon> dash, ts, and let-alist are also all dependencies. 

I personally use ~password-store~ to manage my oauth token and userid, and I recommend that method for others as well. 

Once you have the dependencies, then simply  

- clone this repository

- add the directory to your load-path

- require org-lms

This is my use-package declaration; you'll have to adjust the path of course:

#+begin_src emacs-lisp

(use-package org-lms

:load-path "/home/matt/src/org-grading"

:pin manual

:after (org password-store ts dash let-alist)

:commands (org-lms-setup org-lms-get-courseid)

:config 

;; nothing yet

)

#+end_src

* Usage

** The Canvas API

Canvas has a rich [[https://canvas.instructure.com/doc/api][RESTful API]], which accepts and returns JSON representations of many kinds of course-related objects, including students, assignments, announcements, and pages.  A basic function, ~org-lms-canvas-request~, uses Emacs's built-in [[https://www.google.com/search?client=firefox-b-ab&q=emacs+json.el][JSON.el]] and the powerful [[https://github.com/tkf/emacs-request][request.el]] library to standardize the formats of requests and responses.  Then, for each supported API endpoint, ~org-lms~ has a set of convenience functions:

- one or more *getters* for retrieving data from Canvas, usually named ~org-lms-get-*~

- one or more *setters* for posting or modifying data to Canvas, usually named ~org-lms-post-*~

- one or more *transformers* for modidying the data provided by canvas into a form that's useful for local use. Some of these may become less necessary as I adapt my local schema to come into closer alignment with Canvas, but there will always be extra information that Canvas cannot easily store (Github ID's, nicknames, etc.).

At present, this package provides only a very limited set of functions related to these categories: 

- *courses*

- *students*

- *assignments*

- *announcements*

In order to use them, you'll first need to set the following variables:

- ~org-lms-baseurl~, a system-wide variablethat represents your institution's Canvas API URL

- ~org-lms-token~, your [[https://community.canvaslms.com/docs/DOC-10806-4214724194][secret API token]], which you can acces svia the Canvas web interface (follow the link for details)

- ~ORG_LMS_COURSEID~, set either as a file-wide keyword or a headline-level org property. You can use ~org-lms-get-courses~ to retrieve all the course objects and their ~:id~ properties.

- other ID's for individual students, assignments, submissions, announcements, etc; the higher-level functions here will retrieve those values and store them in headline-level properties.  

*** Note on GraphQL API <2019-09-30 Mon>

Canvas also has a GraphQL API which is dramatically more efficient than the RESTful API. I would like to ocnvert som portions of this oce to use that API, but that will take a while.  See [[https://github.com/titaniumbones/Org-Marking-Mode/issues/27][the Github Issue in this repo]] for more details.  

** Initial Setup 

Create a course-specific directory containing your org-mode source files.  In each file, add the ~#+ORG_LMS_COURSEID:~ value specific to your course. This will have to be set each year, since the course ids will change.

Write your announcements and assignments as org-mode subtrees, and then post them to canvas with the appropriate convenience functions.  Hopefully the most important information from the API response will then be recorded in the headlines. 

See [[./Grading-template.org]] for some examples.

** Posting the Syllabus

Follow the instructions above, navigate to your syllabus document, and simply ~M-x org-lms-post-syllabus~. If everything's working properly, the syllabus should appear on the front page of your Canvas site.

This function assumes he syllabus lives in its own file. 

  

** Posting Announcements

I've added a method to export subtrees as HTML announcements.  This saves me having to compose in the web interface (finally!).  Just call ~org-lms-headline-to-announcement~ from the right subtree (sorry, it won't traverse up the tree like ~ox-hugo's~ "dwim" scope -- haven't programmed that yet!). A successful post will set the ~ORG_LMS_ANNOUNCEMENT_ID~ property, and the next time you call from this subtree, the existing announcement will be updated (that is, no new announcement will be posted). Also, the ~ORLG_LMS_ANNOUNCEMENT_URL~ property will be set, and a new browser tab will open up with the announcement page. 

** Creating and Updating Pages

*Pages* are pretty easy to create from subtrees; just execute ~org-lms-post-page~ from a subtree and its content will be uploaded as HTML to your Canvas site. 

** STARTED Assignments and Marking

Marking is the bulk of the work associated with an LMS and the most complex part of the workflow this package is designed for.  These instructions may not be up to date and may also be somewhat idiosyncratic.  

See ~Grading-template.org~  and ~Assignments.org~ for an example of how to set up assignments.  The functions defined here expect each assignment to be a subtree. They will look for a number of headline properties and file-wide keyword values before making the API call:

*** Posting Assignments to the LMS

In order to use this system, assignments need to be *created as org-mode headlines* and *posted to the LMS via =org-lms=*. Otherwise the metadata that =org-lms= relies on for retrieving student work won't be present. If you have another workflow, you might want to modify some of the existing functions. 

Assuming you keep all your assignments in a file =Assignments.org= in the root directory of your course repo, do the following:

- add a keyword line =#+ORG_LMS_COURSEID: XXXX= somewhere in your org file (I prefer the top). You can easily get the course ID just by inspecting the URL of your course, or by using the =org-lms-WHATISITAGAIN= function

- In each assignment headline, you'll want to set a number of properties. This is somewhat tedious, so I recommend creating a template and modifying later: 

#+begin_src 

:DUE_AT: 2018-11-23

:GRADING_TYPE: letter_grade

:OL_PUBLISH:  t

:ASSIGNMENT_TYPE: canvas

:ASSIGNMENT_WEIGHT: 0.10

:CANVAS_SUBMISSION_TYPES: (online_upload)

:PUBLISH:  t

:GRADING_STANDARD_ID: 458

#+end_src

Let's go through these one by one.  They are a little repetitive and should probably be rationalized.

- *DUE_AT* sets a due date. Right now, the *time* component is hard-coded to be 11:59PM EST on that date.  This should be fixed!

- *GRADING_TYPE* is required ify ou want to use letter grades.

- If using letter grades, then *GRSADING_STANDARD* may also be necessary

- *OL_PUBLISH* is nil by default, though maybe that should be changed

- *CANVAS_SUBMISSION_TYPES* is a list object and *must* be set if you intend to ocllect student work via Canvas.

- *ASSIGNMENT_TYPE* should be set to `canvas` unless you are collecting work some other way

- Canvas also requires that an *ASSIGNMENT_WEIGHT* be set, or it won't record marks properly.

- *OL_DIRECTORY* is the directory in which to collect student work. It defaults to a downcased, whitespace-free transformation of the assignment name (that is, the headline content) and will later be created in the main Grading directory if it doesn't exist (see below). 

Once you've set the metadata, go ahead and write the assignment.  If you include a subheading tagged `rubric` then that subheading will be used later by =org-lms= when constructing grading headlines (see the next section).

When you're done, post your work to Canvas with =org-lms-parse-assignment= (misleading name, should be changed!), and, importantly, *parse the assignments file with =org-lms-save-assignment-map=*. This will create an emacs-lisp file whose sole contents are an alist containing a representation of the assignment

*** Retrieving Student Work

I generally use a file called =Comments.org= and keep it in a directory =Grading= which I exclude from the main git repo for my course (obvious reasons). This file also needs to have certain metadata set:

- courseid with =#+ORG_LMS_COURSEID: NUMBER=

- location of assignments *org* file with =+#ORG_LMS_ASSIGNMENTS: PATH= (*Note: this is a *change* from earlier practice, and =org-lms-setup= will no longer work if you do this!)

- the variable =org-lms-merged-students= should also be set.  This is a little baroque and should be streamlined; the name derives from my perhaps idiosyncratic practice of maintaining a student list that includes both /nicknames/ and /github ids/ for students. Right now, the easiest way to generate this list involves creating a file =students.csv= and running =(org-lms-merge-student-lists)= to sync the existing csv and the current list of students (which will change every time someone adds or drops the class).  

- run ~org-lms-setup-grading~ to generate a table of assignments. You can then manually click the "create headlines" field

*** Ideal Workflow

- [X] Write assignment(s) in ~Assignments.org~ (see template)

- [X] generate an ~assignments.el~ file from the WIM contents of ~Assignments.org~, and ideally

- [X] automaticlaly write to this file every time I upload an assignment

- [X] inside the grading template,

  - [X] having set the location of ~assignments.el~ as a file-level keyword variable,

  - [X] read its contents and

  - [X] use them to generate headlines.  

So, this is roughly finished. Now just need to add a few more keywords to make everything run smmmoooooottthh as butter. 

 

*** The Assignments Object

Each local assignment has as its cdr a plist which will be used to construct the grading document & to handle a variety of grading-related tasks. Here is the initial structure of an assignment: 

#+begin_src emacs-lisp

(test .

                  (:name "Test Assignment"

                         :directory "response-paper-1"

                         :weight 0.10

                         :grade-type "letter"

                         :submission-type "canvas"

                         :rubric-list ("Organization" "Clarity of Argument"

                                       "Grammar and Spelling" "Grade"

                                       "See Attached Paper for further Comments")

                         ))

#+end_src

- :name :: used both to construct the headline for the assignment, and to associate the local assignment with a Canvas assignment object

- :directory :: local storage of student work

- :weight :: used in constructing final grades (not implemented)

- :grade-type :: one of "letter", "number", or "passfail" -- but not yet implemented properly

- :submission-type :: one of "email" "github", or "canvas". Should be used in the future for handling (a) attachment of student files and (b) return of student works. Right now there's no canvas implementation.

- :rubric-list ::  This is what I started with -- My grading rubrics are all definition lists, with comments entered at the end of the list entry. 

Run ~org-lms-merge-assignments~ to add a few extra properties from an associated Canvas assignment. I'm not yet able to automate the creation of these assignments, though that should be possible.    

*** Creating Assignments

There is now preliminary support for uploading assignments to a course. This is very much a work in progress.

*** Collecting Student work

I have two existing systems for marking student work:

- students email me their papers or submit via Dropbox. I collect the papers in a single directory.

- Students submit work via Github Classroom. I bulk-clone their repos and mark via PR comments

+It would be nice to replace the first of these with a system for downloading papers directly from Canvas.  I'm working on that right now.+  This is now *implemented!* Use ~org-lms-get-canvas-attachments~ to getthese. Now I need to hook it up to ~org-lms-make-headinges~.  

*** Creating Grading Trees

Running ~(org-lms-make-headings assignment-name)~ will generate org heading trees with the following structure:

- Assignment Name

  - Student Name 1

  - Student Name 2

  - etc

Each headline will have a number of properties set to make marking easier. Existing student papers will be attached to the grading subtree and can be quickly opened with ~C-c C-a o~. I find the workflow very quick and easy.  I have libreoffice configured with a few shortcuts for commonly used editing markup (checkmarks, smileyfaces, paragraph marks, and expansion shortcuts for "wrong word" and "awkward"). PDFs are much slower for me to mark, as neither pdf-view nor evince has really excellent text annotation UI. TThis may be a limitation of the PDF annotation standards. For github repos, the PR interface is quite rich for code; for text work it's a little bit clumsier, but I don't have a solution for that yet.  

*** Using Agenda to rapidly filter grading trees

The org agenda is a powerful tool for sorting and filtering headlines. Since each student assignment is a headline, we can mis-use the agenda to rapidly navigate to specific places in a comments file.  So, for instance, to find all trees with a grade of "0" enter the following:

~C-c a < m GRADE="0"~

This will open the agenda, searching only the current buffer for matches, matching the property "GRADE" with value "0"

It should be possible to add this to ~org-agenda-custom-commands~, but I'm having trouble with this right now.

Also having trouble matching with "|" ("or").

Once created, the agenda can be [[https://orgmode.org/manual/Filtering_002flimiting-agenda-items.html][filtered]], e.g., search for a partiular student using ~=~ and then entering a substring of the student's name

Unfortunately I'm not very adept right now with the agenda but maybe this wil lget easier!!

*** Returning student work

Right now I run ~org-lms-mail-all~ to mail out all subtrees marked with a ~READY~ org-todo state. This is generally *fairly* reliable, though sometimes there are issues with the message queue.  

*NEW*: I have written ~org-lms-put-single-submission-from-headline~ which half-works and is ready for testing. 

* Known issues

** HTML Entities

The canvas API does not accept all HTML5 semantically-named entities.

#+begin_src emacs-lisp

(let ((entities (json-read-file "/home/matt/entities.json")))

entities)

#+end_src

#+RESULTS:

| Á                          | (codepoints . [193])         | (characters . Á)  |

| &Aacute                           | (codepoints . [193])         | (characters . Á)  |

| á                          | (codepoints . [225])         | (characters . á)  |

| &aacute                           | (codepoints . [225])         | (characters . á)  |

| &Abreve;                          | (codepoints . [258])         | (characters . Ă)  |

| &abreve;                          | (codepoints . [259])         | (characters . ă)  |

| &ac;                              | (codepoints . [8766])        | (characters . ∾)  |

| &acd;                             | (codepoints . [8767])        | (characters . ∿)  |

| &acE;                             | (codepoints . [8766 819])    | (characters . ∾̳)  |

| Â                           | (codepoints . [194])         | (characters . Â)  |

| &Acirc                            | (codepoints . [194])         | (characters . Â)  |

| â                           | (codepoints . [226])         | (characters . â)  |

| &acirc                            | (codepoints . [226])         | (characters . â)  |

| ´                           | (codepoints . [180])         | (characters . ´)  |

| &acute                            | (codepoints . [180])         | (characters . ´)  |

| &Acy;                             | (codepoints . [1040])        | (characters . А)  |

| &acy;                             | (codepoints . [1072])        | (characters . а)  |

| Æ                           | (codepoints . [198])         | (characters . Æ)  |

| &AElig                            | (codepoints . [198])         | (characters . Æ)  |

| æ                           | (codepoints . [230])         | (characters . æ)  |

| &aelig                            | (codepoints . [230])         | (characters . æ)  |

| &af;                              | (codepoints . [8289])        | (characters . ⁡)   |

| &Afr;                             | (codepoints . [120068])      | (characters . 𝔄)  |

| &afr;                             | (codepoints . [120094])      | (characters . 𝔞)  |

| À                          | (codepoints . [192])         | (characters . À)  |

| &Agrave                           | (codepoints . [192])         | (characters . À)  |

| à                          | (codepoints . [224])         | (characters . à)  |

| &agrave                           | (codepoints . [224])         | (characters . à)  |

| ℵ                         | (codepoints . [8501])        | (characters . ℵ)  |

| &aleph;                           | (codepoints . [8501])        | (characters . ℵ)  |

| Α                           | (codepoints . [913])         | (characters . Α)  |

| α                           | (codepoints . [945])         | (characters . α)  |

| &Amacr;                           | (codepoints . [256])         | (characters . Ā)  |

| &amacr;                           | (codepoints . [257])         | (characters . ā)  |

| &amalg;                           | (codepoints . [10815])       | (characters . ⨿)  |

| &                             | (codepoints . [38])          | (characters . &)  |

| &amp                              | (codepoints . [38])          | (characters . &)  |

| &AMP;                             | (codepoints . [38])          | (characters . &)  |

| &AMP                              | (codepoints . [38])          | (characters . &)  |

| &andand;                          | (codepoints . [10837])       | (characters . ⩕)  |

| &And;                             | (codepoints . [10835])       | (characters . ⩓)  |

| ∧                             | (codepoints . [8743])        | (characters . ∧)  |

| &andd;                            | (codepoints . [10844])       | (characters . ⩜)  |

| &andslope;                        | (codepoints . [10840])       | (characters . ⩘)  |

| &andv;                            | (codepoints . [10842])       | (characters . ⩚)  |

| ∠                             | (codepoints . [8736])        | (characters . ∠)  |

| &ange;                            | (codepoints . [10660])       | (characters . ⦤)  |

| &angle;                           | (codepoints . [8736])        | (characters . ∠)  |

| &angmsdaa;                        | (codepoints . [10664])       | (characters . ⦨)  |

| &angmsdab;                        | (codepoints . [10665])       | (characters . ⦩)  |

| &angmsdac;                        | (codepoints . [10666])       | (characters . ⦪)  |

| &angmsdad;                        | (codepoints . [10667])       | (characters . ⦫)  |

| &angmsdae;                        | (codepoints . [10668])       | (characters . ⦬)  |

| &angmsdaf;                        | (codepoints . [10669])       | (characters . ⦭)  |

| &angmsdag;                        | (codepoints . [10670])       | (characters . ⦮)  |

| &angmsdah;                        | (codepoints . [10671])       | (characters . ⦯)  |

| &angmsd;                          | (codepoints . [8737])        | (characters . ∡)  |

| &angrt;                           | (codepoints . [8735])        | (characters . ∟)  |

| &angrtvb;                         | (codepoints . [8894])        | (characters . ⊾)  |

| &angrtvbd;                        | (codepoints . [10653])       | (characters . ⦝)  |

| &angsph;                          | (codepoints . [8738])        | (characters . ∢)  |

| &angst;                           | (codepoints . [197])         | (characters . Å)  |

| &angzarr;                         | (codepoints . [9084])        | (characters . ⍼)  |

| &Aogon;                           | (codepoints . [260])         | (characters . Ą)  |

| &aogon;                           | (codepoints . [261])         | (characters . ą)  |

| &Aopf;                            | (codepoints . [120120])      | (characters . 𝔸)  |

| &aopf;                            | (codepoints . [120146])      | (characters . 𝕒)  |

| &apacir;                          | (codepoints . [10863])       | (characters . ⩯)  |

| &ap;                              | (codepoints . [8776])        | (characters . ≈)  |

| &apE;                             | (codepoints . [10864])       | (characters . ⩰)  |

| &ape;                             | (codepoints . [8778])        | (characters . ≊)  |

| &apid;                            | (codepoints . [8779])        | (characters . ≋)  |

| '                            | (codepoints . [39])          | (characters . ')  |

| &ApplyFunction;                   | (codepoints . [8289])        | (characters . ⁡)   |

| &approx;                          | (codepoints . [8776])        | (characters . ≈)  |

| &approxeq;                        | (codepoints . [8778])        | (characters . ≊)  |

| Å                           | (codepoints . [197])         | (characters . Å)  |

| &Aring                            | (codepoints . [197])         | (characters . Å)  |

| å                           | (codepoints . [229])         | (characters . å)  |

| &aring                            | (codepoints . [229])         | (characters . å)  |

| &Ascr;                            | (codepoints . [119964])      | (characters . 𝒜)  |

| &ascr;                            | (codepoints . [119990])      | (characters . 𝒶)  |

| &Assign;                          | (codepoints . [8788])        | (characters . ≔)  |

| &ast;                             | (codepoints . [42])          | (characters . *)  |

| ≈                           | (codepoints . [8776])        | (characters . ≈)  |

| &asympeq;                         | (codepoints . [8781])        | (characters . ≍)  |

| Ã                          | (codepoints . [195])         | (characters . Ã)  |

| &Atilde                           | (codepoints . [195])         | (characters . Ã)  |

| ã                          | (codepoints . [227])         | (characters . ã)  |

| &atilde                           | (codepoints . [227])         | (characters . ã)  |

| Ä                            | (codepoints . [196])         | (characters . Ä)  |

| &Auml                             | (codepoints . [196])         | (characters . Ä)  |

| ä                            | (codepoints . [228])         | (characters . ä)  |

| &auml                             | (codepoints . [228])         | (characters . ä)  |

| &awconint;                        | (codepoints . [8755])        | (characters . ∳)  |

| &awint;                           | (codepoints . [10769])       | (characters . ⨑)  |

| &backcong;                        | (codepoints . [8780])        | (characters . ≌)  |

| &backepsilon;                     | (codepoints . [1014])        | (characters . ϶)  |

| &backprime;                       | (codepoints . [8245])        | (characters . ‵)  |

| &backsim;                         | (codepoints . [8765])        | (characters . ∽)  |

| &backsimeq;                       | (codepoints . [8909])        | (characters . ⋍)  |

| &Backslash;                       | (codepoints . [8726])        | (characters . ∖)  |

| &Barv;                            | (codepoints . [10983])       | (characters . ⫧)  |

| &barvee;                          | (codepoints . [8893])        | (characters . ⊽)  |

| &barwed;                          | (codepoints . [8965])        | (characters . ⌅)  |

| &Barwed;                          | (codepoints . [8966])        | (characters . ⌆)  |

| &barwedge;                        | (codepoints . [8965])        | (characters . ⌅)  |

| &bbrk;                            | (codepoints . [9141])        | (characters . ⎵)  |

| &bbrktbrk;                        | (codepoints . [9142])        | (characters . ⎶)  |

| &bcong;                           | (codepoints . [8780])        | (characters . ≌)  |

| &Bcy;                             | (codepoints . [1041])        | (characters . Б)  |

| &bcy;                             | (codepoints . [1073])        | (characters . б)  |

| „                           | (codepoints . [8222])        | (characters . „)  |

| &becaus;                          | (codepoints . [8757])        | (characters . ∵)  |

| &because;                         | (codepoints . [8757])        | (characters . ∵)  |

| &Because;                         | (codepoints . [8757])        | (characters . ∵)  |

| &bemptyv;                         | (codepoints . [10672])       | (characters . ⦰)  |

| &bepsi;                           | (codepoints . [1014])        | (characters . ϶)  |

| &bernou;                          | (codepoints . [8492])        | (characters . ℬ)  |

| &Bernoullis;                      | (codepoints . [8492])        | (characters . ℬ)  |

| Β                            | (codepoints . [914])         | (characters . Β)  |

| β                            | (codepoints . [946])         | (characters . β)  |

| &beth;                            | (codepoints . [8502])        | (characters . ℶ)  |

| &between;                         | (codepoints . [8812])        | (characters . ≬)  |

| &Bfr;                             | (codepoints . [120069])      | (characters . 𝔅)  |

| &bfr;                             | (codepoints . [120095])      | (characters . 𝔟)  |

| &bigcap;                          | (codepoints . [8898])        | (characters . ⋂)  |

| &bigcirc;                         | (codepoints . [9711])        | (characters . ◯)  |

| &bigcup;                          | (codepoints . [8899])        | (characters . ⋃)  |

| &bigodot;                         | (codepoints . [10752])       | (characters . ⨀)  |

| &bigoplus;                        | (codepoints . [10753])       | (characters . ⨁)  |

| &bigotimes;                       | (codepoints . [10754])       | (characters . ⨂)  |

| &bigsqcup;                        | (codepoints . [10758])       | (characters . ⨆)  |

| &bigstar;                         | (codepoints . [9733])        | (characters . ★)  |

| &bigtriangledown;                 | (codepoints . [9661])        | (characters . ▽)  |

| &bigtriangleup;                   | (codepoints . [9651])        | (characters . △)  |

| &biguplus;                        | (codepoints . [10756])       | (characters . ⨄)  |

| &bigvee;                          | (codepoints . [8897])        | (characters . ⋁)  |

| &bigwedge;                        | (codepoints . [8896])        | (characters . ⋀)  |

| &bkarow;                          | (codepoints . [10509])       | (characters . ⤍)  |

| &blacklozenge;                    | (codepoints . [10731])       | (characters . ⧫)  |

| &blacksquare;                     | (codepoints . [9642])        | (characters . ▪)  |

| &blacktriangle;                   | (codepoints . [9652])        | (characters . ▴)  |

| &blacktriangledown;               | (codepoints . [9662])        | (characters . ▾)  |

| &blacktriangleleft;               | (codepoints . [9666])        | (characters . ◂)  |

| &blacktriangleright;              | (codepoints . [9656])        | (characters . ▸)  |

| &blank;                           | (codepoints . [9251])        | (characters . ␣)  |

| &blk12;                           | (codepoints . [9618])        | (characters . ▒)  |

| &blk14;                           | (codepoints . [9617])        | (characters . ░)  |

| &blk34;                           | (codepoints . [9619])        | (characters . ▓)  |

| &block;                           | (codepoints . [9608])        | (characters . █)  |

| &bne;                             | (codepoints . [61 8421])     | (characters . =⃥)  |

| &bnequiv;                         | (codepoints . [8801 8421])   | (characters . ≡⃥)  |

| &bNot;                            | (codepoints . [10989])       | (characters . ⫭)  |

| &bnot;                            | (codepoints . [8976])        | (characters . ⌐)  |

| &Bopf;                            | (codepoints . [120121])      | (characters . 𝔹)  |

| &bopf;                            | (codepoints . [120147])      | (characters . 𝕓)  |

| &bot;                             | (codepoints . [8869])        | (characters . ⊥)  |

| &bottom;                          | (codepoints . [8869])        | (characters . ⊥)  |

| &bowtie;                          | (codepoints . [8904])        | (characters . ⋈)  |

| &boxbox;                          | (codepoints . [10697])       | (characters . ⧉)  |

| &boxdl;                           | (codepoints . [9488])        | (characters . ┐)  |

| &boxdL;                           | (codepoints . [9557])        | (characters . ╕)  |

| &boxDl;                           | (codepoints . [9558])        | (characters . ╖)  |

| &boxDL;                           | (codepoints . [9559])        | (characters . ╗)  |

| &boxdr;                           | (codepoints . [9484])        | (characters . ┌)  |

| &boxdR;                           | (codepoints . [9554])        | (characters . ╒)  |

| &boxDr;                           | (codepoints . [9555])        | (characters . ╓)  |

| &boxDR;                           | (codepoints . [9556])        | (characters . ╔)  |

| &boxh;                            | (codepoints . [9472])        | (characters . ─)  |

| &boxH;                            | (codepoints . [9552])        | (characters . ═)  |

| &boxhd;                           | (codepoints . [9516])        | (characters . ┬)  |

| &boxHd;                           | (codepoints . [9572])        | (characters . ╤)  |

| &boxhD;                           | (codepoints . [9573])        | (characters . ╥)  |

| &boxHD;                           | (codepoints . [9574])        | (characters . ╦)  |

| &boxhu;                           | (codepoints . [9524])        | (characters . ┴)  |

| &boxHu;                           | (codepoints . [9575])        | (characters . ╧)  |

| &boxhU;                           | (codepoints . [9576])        | (characters . ╨)  |

| &boxHU;                           | (codepoints . [9577])        | (characters . ╩)  |

| &boxminus;                        | (codepoints . [8863])        | (characters . ⊟)  |

| &boxplus;                         | (codepoints . [8862])        | (characters . ⊞)  |

| &boxtimes;                        | (codepoints . [8864])        | (characters . ⊠)  |

| &boxul;                           | (codepoints . [9496])        | (characters . ┘)  |

| &boxuL;                           | (codepoints . [9563])        | (characters . ╛)  |

| &boxUl;                           | (codepoints . [9564])        | (characters . ╜)  |

| &boxUL;                           | (codepoints . [9565])        | (characters . ╝)  |

| &boxur;                           | (codepoints . [9492])        | (characters . └)  |

| &boxuR;                           | (codepoints . [9560])        | (characters . ╘)  |

| &boxUr;                           | (codepoints . [9561])        | (characters . ╙)  |

| &boxUR;                           | (codepoints . [9562])        | (characters . ╚)  |

| &boxv;                            | (codepoints . [9474])        | (characters . │)  |

| &boxV;                            | (codepoints . [9553])        | (characters . ║)  |

| &boxvh;                           | (codepoints . [9532])        | (characters . ┼)  |

| &boxvH;                           | (codepoints . [9578])        | (characters . ╪)  |

| &boxVh;                           | (codepoints . [9579])        | (characters . ╫)  |

| &boxVH;                           | (codepoints . [9580])        | (characters . ╬)  |

| &boxvl;                           | (codepoints . [9508])        | (characters . ┤)  |

| &boxvL;                           | (codepoints . [9569])        | (characters . ╡)  |

| &boxVl;                           | (codepoints . [9570])        | (characters . ╢)  |

| &boxVL;                           | (codepoints . [9571])        | (characters . ╣)  |

| &boxvr;                           | (codepoints . [9500])        | (characters . ├)  |

| &boxvR;                           | (codepoints . [9566])        | (characters . ╞)  |

| &boxVr;                           | (codepoints . [9567])        | (characters . ╟)  |

| &boxVR;                           | (codepoints . [9568])        | (characters . ╠)  |

| &bprime;                          | (codepoints . [8245])        | (characters . ‵)  |

| &breve;                           | (codepoints . [728])         | (characters . ˘)  |

| &Breve;                           | (codepoints . [728])         | (characters . ˘)  |

| ¦                          | (codepoints . [166])         | (characters . ¦)  |

| &brvbar                           | (codepoints . [166])         | (characters . ¦)  |

| &bscr;                            | (codepoints . [119991])      | (characters . 𝒷)  |

| &Bscr;                            | (codepoints . [8492])        | (characters . ℬ)  |

| &bsemi;                           | (codepoints . [8271])        | (characters . ⁏)  |

| &bsim;                            | (codepoints . [8765])        | (characters . ∽)  |

| &bsime;                           | (codepoints . [8909])        | (characters . ⋍)  |

| &bsolb;                           | (codepoints . [10693])       | (characters . ⧅)  |

| &bsol;                            | (codepoints . [92])          | (characters . \)  |

| &bsolhsub;                        | (codepoints . [10184])       | (characters . ⟈)  |

| •                            | (codepoints . [8226])        | (characters . •)  |

| &bullet;                          | (codepoints . [8226])        | (characters . •)  |

| &bump;                            | (codepoints . [8782])        | (characters . ≎)  |

| &bumpE;                           | (codepoints . [10926])       | (characters . ⪮)  |

| &bumpe;                           | (codepoints . [8783])        | (characters . ≏)  |

| &Bumpeq;                          | (codepoints . [8782])        | (characters . ≎)  |

| &bumpeq;                          | (codepoints . [8783])        | (characters . ≏)  |

| &Cacute;                          | (codepoints . [262])         | (characters . Ć)  |

| &cacute;                          | (codepoints . [263])         | (characters . ć)  |

| &capand;                          | (codepoints . [10820])       | (characters . ⩄)  |

| &capbrcup;                        | (codepoints . [10825])       | (characters . ⩉)  |

| &capcap;                          | (codepoints . [10827])       | (characters . ⩋)  |

| ∩                             | (codepoints . [8745])        | (characters . ∩)  |

| &Cap;                             | (codepoints . [8914])        | (characters . ⋒)  |

| &capcup;                          | (codepoints . [10823])       | (characters . ⩇)  |

| &capdot;                          | (codepoints . [10816])       | (characters . ⩀)  |

| &CapitalDifferentialD;            | (codepoints . [8517])        | (characters . ⅅ)  |

| &caps;                            | (codepoints . [8745 65024])  | (characters . ∩︀)  |

| &caret;                           | (codepoints . [8257])        | (characters . ⁁)  |

| &caron;                           | (codepoints . [711])         | (characters . ˇ)  |

| &Cayleys;                         | (codepoints . [8493])        | (characters . ℭ)  |

| &ccaps;                           | (codepoints . [10829])       | (characters . ⩍)  |

| &Ccaron;                          | (codepoints . [268])         | (characters . Č)  |

| &ccaron;                          | (codepoints . [269])         | (characters . č)  |

| Ç                          | (codepoints . [199])         | (characters . Ç)  |

| &Ccedil                           | (codepoints . [199])         | (characters . Ç)  |

| ç                          | (codepoints . [231])         | (characters . ç)  |

| &ccedil                           | (codepoints . [231])         | (characters . ç)  |

| &Ccirc;                           | (codepoints . [264])         | (characters . Ĉ)  |

| &ccirc;                           | (codepoints . [265])         | (characters . ĉ)  |

| &Cconint;                         | (codepoints . [8752])        | (characters . ∰)  |

| &ccups;                           | (codepoints . [10828])       | (characters . ⩌)  |

| &ccupssm;                         | (codepoints . [10832])       | (characters . ⩐)  |

| &Cdot;                            | (codepoints . [266])         | (characters . Ċ)  |

| &cdot;                            | (codepoints . [267])         | (characters . ċ)  |

| ¸                           | (codepoints . [184])         | (characters . ¸)  |

| &cedil                            | (codepoints . [184])         | (characters . ¸)  |

| &Cedilla;                         | (codepoints . [184])         | (characters . ¸)  |

| &cemptyv;                         | (codepoints . [10674])       | (characters . ⦲)  |

| ¢                            | (codepoints . [162])         | (characters . ¢)  |

| &cent                             | (codepoints . [162])         | (characters . ¢)  |

| &centerdot;                       | (codepoints . [183])         | (characters . ·)  |

| &CenterDot;                       | (codepoints . [183])         | (characters . ·)  |

| &cfr;                             | (codepoints . [120096])      | (characters . 𝔠)  |

| &Cfr;                             | (codepoints . [8493])        | (characters . ℭ)  |

| &CHcy;                            | (codepoints . [1063])        | (characters . Ч)  |

| &chcy;                            | (codepoints . [1095])        | (characters . ч)  |

| &check;                           | (codepoints . [10003])       | (characters . ✓)  |

| &checkmark;                       | (codepoints . [10003])       | (characters . ✓)  |

| Χ                             | (codepoints . [935])         | (characters . Χ)  |

| χ                             | (codepoints . [967])         | (characters . χ)  |

| ˆ                            | (codepoints . [710])         | (characters . ˆ)  |

| &circeq;                          | (codepoints . [8791])        | (characters . ≗)  |

| &circlearrowleft;                 | (codepoints . [8634])        | (characters . ↺)  |

| &circlearrowright;                | (codepoints . [8635])        | (characters . ↻)  |

| &circledast;                      | (codepoints . [8859])        | (characters . ⊛)  |

| &circledcirc;                     | (codepoints . [8858])        | (characters . ⊚)  |

| &circleddash;                     | (codepoints . [8861])        | (characters . ⊝)  |

| &CircleDot;                       | (codepoints . [8857])        | (characters . ⊙)  |

| &circledR;                        | (codepoints . [174])         | (characters . ®)  |

| &circledS;                        | (codepoints . [9416])        | (characters . Ⓢ)  |

| &CircleMinus;                     | (codepoints . [8854])        | (characters . ⊖)  |

| &CirclePlus;                      | (codepoints . [8853])        | (characters . ⊕)  |

| &CircleTimes;                     | (codepoints . [8855])        | (characters . ⊗)  |

| &cir;                             | (codepoints . [9675])        | (characters . ○)  |

| &cirE;                            | (codepoints . [10691])       | (characters . ⧃)  |

| &cire;                            | (codepoints . [8791])        | (characters . ≗)  |

| &cirfnint;                        | (codepoints . [10768])       | (characters . ⨐)  |

| &cirmid;                          | (codepoints . [10991])       | (characters . ⫯)  |

| &cirscir;                         | (codepoints . [10690])       | (characters . ⧂)  |

| &ClockwiseContourIntegral;        | (codepoints . [8754])        | (characters . ∲)  |

| &CloseCurlyDoubleQuote;           | (codepoints . [8221])        | (characters . ”)  |

| &CloseCurlyQuote;                 | (codepoints . [8217])        | (characters . ’)  |

| ♣                           | (codepoints . [9827])        | (characters . ♣)  |

| &clubsuit;                        | (codepoints . [9827])        | (characters . ♣)  |

| &colon;                           | (codepoints . [58])          | (characters . :)  |

| &Colon;                           | (codepoints . [8759])        | (characters . ∷)  |

| &Colone;                          | (codepoints . [10868])       | (characters . ⩴)  |

| &colone;                          | (codepoints . [8788])        | (characters . ≔)  |

| &coloneq;                         | (codepoints . [8788])        | (characters . ≔)  |

| &comma;                           | (codepoints . [44])          | (characters . ,)  |

| &commat;                          | (codepoints . [64])          | (characters . @)  |

| &comp;                            | (codepoints . [8705])        | (characters . ∁)  |

| &compfn;                          | (codepoints . [8728])        | (characters . ∘)  |

| &complement;                      | (codepoints . [8705])        | (characters . ∁)  |

| &complexes;                       | (codepoints . [8450])        | (characters . ℂ)  |

| ≅                            | (codepoints . [8773])        | (characters . ≅)  |

| &congdot;                         | (codepoints . [10861])       | (characters . ⩭)  |

| &Congruent;                       | (codepoints . [8801])        | (characters . ≡)  |

| &conint;                          | (codepoints . [8750])        | (characters . ∮)  |

| &Conint;                          | (codepoints . [8751])        | (characters . ∯)  |

| &ContourIntegral;                 | (codepoints . [8750])        | (characters . ∮)  |

| &copf;                            | (codepoints . [120148])      | (characters . 𝕔)  |

| &Copf;                            | (codepoints . [8450])        | (characters . ℂ)  |

| &coprod;                          | (codepoints . [8720])        | (characters . ∐)  |

| &Coproduct;                       | (codepoints . [8720])        | (characters . ∐)  |

| ©                            | (codepoints . [169])         | (characters . ©)  |

| &copy                             | (codepoints . [169])         | (characters . ©)  |

| &COPY;                            | (codepoints . [169])         | (characters . ©)  |

| &COPY                             | (codepoints . [169])         | (characters . ©)  |

| &copysr;                          | (codepoints . [8471])        | (characters . ℗)  |

| &CounterClockwiseContourIntegral; | (codepoints . [8755])        | (characters . ∳)  |

| ↵                           | (codepoints . [8629])        | (characters . ↵)  |

| &cross;                           | (codepoints . [10007])       | (characters . ✗)  |

| &Cross;                           | (codepoints . [10799])       | (characters . ⨯)  |

| &Cscr;                            | (codepoints . [119966])      | (characters . 𝒞)  |

| &cscr;                            | (codepoints . [119992])      | (characters . 𝒸)  |

| &csub;                            | (codepoints . [10959])       | (characters . ⫏)  |

| &csube;                           | (codepoints . [10961])       | (characters . ⫑)  |

| &csup;                            | (codepoints . [10960])       | (characters . ⫐)  |

| &csupe;                           | (codepoints . [10962])       | (characters . ⫒)  |

| &ctdot;                           | (codepoints . [8943])        | (characters . ⋯)  |

| &cudarrl;                         | (codepoints . [10552])       | (characters . ⤸)  |

| &cudarrr;                         | (codepoints . [10549])       | (characters . ⤵)  |

| &cuepr;                           | (codepoints . [8926])        | (characters . ⋞)  |

| &cuesc;                           | (codepoints . [8927])        | (characters . ⋟)  |

| &cularr;                          | (codepoints . [8630])        | (characters . ↶)  |

| &cularrp;                         | (codepoints . [10557])       | (characters . ⤽)  |

| &cupbrcap;                        | (codepoints . [10824])       | (characters . ⩈)  |

| &cupcap;                          | (codepoints . [10822])       | (characters . ⩆)  |

| &CupCap;                          | (codepoints . [8781])        | (characters . ≍)  |

| ∪                             | (codepoints . [8746])        | (characters . ∪)  |

| &Cup;                             | (codepoints . [8915])        | (characters . ⋓)  |

| &cupcup;                          | (codepoints . [10826])       | (characters . ⩊)  |

| &cupdot;                          | (codepoints . [8845])        | (characters . ⊍)  |

| &cupor;                           | (codepoints . [10821])       | (characters . ⩅)  |

| &cups;                            | (codepoints . [8746 65024])  | (characters . ∪︀)  |

| &curarr;                          | (codepoints . [8631])        | (characters . ↷)  |

| &curarrm;                         | (codepoints . [10556])       | (characters . ⤼)  |

| &curlyeqprec;                     | (codepoints . [8926])        | (characters . ⋞)  |

| &curlyeqsucc;                     | (codepoints . [8927])        | (characters . ⋟)  |

| &curlyvee;                        | (codepoints . [8910])        | (characters . ⋎)  |

| &curlywedge;                      | (codepoints . [8911])        | (characters . ⋏)  |

| ¤                          | (codepoints . [164])         | (characters . ¤)  |

| &curren                           | (codepoints . [164])         | (characters . ¤)  |

| &curvearrowleft;                  | (codepoints . [8630])        | (characters . ↶)  |

| &curvearrowright;                 | (codepoints . [8631])        | (characters . ↷)  |

| &cuvee;                           | (codepoints . [8910])        | (characters . ⋎)  |

| &cuwed;                           | (codepoints . [8911])        | (characters . ⋏)  |

| &cwconint;                        | (codepoints . [8754])        | (characters . ∲)  |

| &cwint;                           | (codepoints . [8753])        | (characters . ∱)  |

| &cylcty;                          | (codepoints . [9005])        | (characters . ⌭)  |

| †                          | (codepoints . [8224])        | (characters . †)  |

| ‡                          | (codepoints . [8225])        | (characters . ‡)  |

| &daleth;                          | (codepoints . [8504])        | (characters . ℸ)  |

| ↓                            | (codepoints . [8595])        | (characters . ↓)  |

| &Darr;                            | (codepoints . [8609])        | (characters . ↡)  |

| ⇓                            | (codepoints . [8659])        | (characters . ⇓)  |

| &dash;                            | (codepoints . [8208])        | (characters . ‐)  |

| &Dashv;                           | (codepoints . [10980])       | (characters . ⫤)  |

| &dashv;                           | (codepoints . [8867])        | (characters . ⊣)  |

| &dbkarow;                         | (codepoints . [10511])       | (characters . ⤏)  |

| &dblac;                           | (codepoints . [733])         | (characters . ˝)  |

| &Dcaron;                          | (codepoints . [270])         | (characters . Ď)  |

| &dcaron;                          | (codepoints . [271])         | (characters . ď)  |

| &Dcy;                             | (codepoints . [1044])        | (characters . Д)  |

| &dcy;                             | (codepoints . [1076])        | (characters . д)  |

| &ddagger;                         | (codepoints . [8225])        | (characters . ‡)  |

| &ddarr;                           | (codepoints . [8650])        | (characters . ⇊)  |

| &DD;                              | (codepoints . [8517])        | (characters . ⅅ)  |

| &dd;                              | (codepoints . [8518])        | (characters . ⅆ)  |

| &DDotrahd;                        | (codepoints . [10513])       | (characters . ⤑)  |

| &ddotseq;                         | (codepoints . [10871])       | (characters . ⩷)  |

| °                             | (codepoints . [176])         | (characters . °)  |

| &deg                              | (codepoints . [176])         | (characters . °)  |

| &Del;                             | (codepoints . [8711])        | (characters . ∇)  |

| Δ                           | (codepoints . [916])         | (characters . Δ)  |

| δ                           | (codepoints . [948])         | (characters . δ)  |

| &demptyv;                         | (codepoints . [10673])       | (characters . ⦱)  |

| &dfisht;                          | (codepoints . [10623])       | (characters . ⥿)  |

| &Dfr;                             | (codepoints . [120071])      | (characters . 𝔇)  |

| &dfr;                             | (codepoints . [120097])      | (characters . 𝔡)  |

| &dHar;                            | (codepoints . [10597])       | (characters . ⥥)  |

| &dharl;                           | (codepoints . [8643])        | (characters . ⇃)  |

| &dharr;                           | (codepoints . [8642])        | (characters . ⇂)  |

| &DiacriticalAcute;                | (codepoints . [180])         | (characters . ´)  |

| &DiacriticalDot;                  | (codepoints . [729])         | (characters . ˙)  |

| &DiacriticalDoubleAcute;          | (codepoints . [733])         | (characters . ˝)  |

| &DiacriticalGrave;                | (codepoints . [96])          | (characters . `)  |

| &DiacriticalTilde;                | (codepoints . [732])         | (characters . ˜)  |

| &diam;                            | (codepoints . [8900])        | (characters . ⋄)  |

| &diamond;                         | (codepoints . [8900])        | (characters . ⋄)  |

| &Diamond;                         | (codepoints . [8900])        | (characters . ⋄)  |

| &diamondsuit;                     | (codepoints . [9830])        | (characters . ♦)  |

| ♦                           | (codepoints . [9830])        | (characters . ♦)  |

| &die;                             | (codepoints . [168])         | (characters . ¨)  |

| &DifferentialD;                   | (codepoints . [8518])        | (characters . ⅆ)  |

| &digamma;                         | (codepoints . [989])         | (characters . ϝ)  |

| &disin;                           | (codepoints . [8946])        | (characters . ⋲)  |

| &div;                             | (codepoints . [247])         | (characters . ÷)  |

| ÷                          | (codepoints . [247])         | (characters . ÷)  |

| &divide                           | (codepoints . [247])         | (characters . ÷)  |

| &divideontimes;                   | (codepoints . [8903])        | (characters . ⋇)  |

| &divonx;                          | (codepoints . [8903])        | (characters . ⋇)  |

| &DJcy;                            | (codepoints . [1026])        | (characters . Ђ)  |

| &djcy;                            | (codepoints . [1106])        | (characters . ђ)  |

| &dlcorn;                          | (codepoints . [8990])        | (characters . ⌞)  |

| &dlcrop;                          | (codepoints . [8973])        | (characters . ⌍)  |

| &dollar;                          | (codepoints . [36])          | (characters . $)  |

| &Dopf;                            | (codepoints . [120123])      | (characters . 𝔻)  |

| &dopf;                            | (codepoints . [120149])      | (characters . 𝕕)  |

| &Dot;                             | (codepoints . [168])         | (characters . ¨)  |

| &dot;                             | (codepoints . [729])         | (characters . ˙)  |

| &DotDot;                          | (codepoints . [8412])        | (characters . ⃜)   |

| &doteq;                           | (codepoints . [8784])        | (characters . ≐)  |

| &doteqdot;                        | (codepoints . [8785])        | (characters . ≑)  |

| &DotEqual;                        | (codepoints . [8784])        | (characters . ≐)  |

| &dotminus;                        | (codepoints . [8760])        | (characters . ∸)  |

| &dotplus;                         | (codepoints . [8724])        | (characters . ∔)  |

| &dotsquare;                       | (codepoints . [8865])        | (characters . ⊡)  |

| &doublebarwedge;                  | (codepoints . [8966])        | (characters . ⌆)  |

| &DoubleContourIntegral;           | (codepoints . [8751])        | (characters . ∯)  |

| &DoubleDot;                       | (codepoints . [168])         | (characters . ¨)  |

| &DoubleDownArrow;                 | (codepoints . [8659])        | (characters . ⇓)  |

| &DoubleLeftArrow;                 | (codepoints . [8656])        | (characters . ⇐)  |

| &DoubleLeftRightArrow;            | (codepoints . [8660])        | (characters . ⇔)  |

| &DoubleLeftTee;                   | (codepoints . [10980])       | (characters . ⫤)  |

| &DoubleLongLeftArrow;             | (codepoints . [10232])       | (characters . ⟸)  |

| &DoubleLongLeftRightArrow;        | (codepoints . [10234])       | (characters . ⟺)  |

| &DoubleLongRightArrow;            | (codepoints . [10233])       | (characters . ⟹)  |

| &DoubleRightArrow;                | (codepoints . [8658])        | (characters . ⇒)  |

| &DoubleRightTee;                  | (codepoints . [8872])        | (characters . ⊨)  |

| &DoubleUpArrow;                   | (codepoints . [8657])        | (characters . ⇑)  |

| &DoubleUpDownArrow;               | (codepoints . [8661])        | (characters . ⇕)  |

| &DoubleVerticalBar;               | (codepoints . [8741])        | (characters . ∥)  |

| &DownArrowBar;                    | (codepoints . [10515])       | (characters . ⤓)  |

| &downarrow;                       | (codepoints . [8595])        | (characters . ↓)  |

| &DownArrow;                       | (codepoints . [8595])        | (characters . ↓)  |

| &Downarrow;                       | (codepoints . [8659])        | (characters . ⇓)  |

| &DownArrowUpArrow;                | (codepoints . [8693])        | (characters . ⇵)  |

| &DownBreve;                       | (codepoints . [785])         | (characters . ̑)   |

| &downdownarrows;                  | (codepoints . [8650])        | (characters . ⇊)  |

| &downharpoonleft;                 | (codepoints . [8643])        | (characters . ⇃)  |

| &downharpoonright;                | (codepoints . [8642])        | (characters . ⇂)  |

| &DownLeftRightVector;             | (codepoints . [10576])       | (characters . ⥐)  |

| &DownLeftTeeVector;               | (codepoints . [10590])       | (characters . ⥞)  |

| &DownLeftVectorBar;               | (codepoints . [10582])       | (characters . ⥖)  |

| &DownLeftVector;                  | (codepoints . [8637])        | (characters . ↽)  |

| &DownRightTeeVector;              | (codepoints . [10591])       | (characters . ⥟)  |

| &DownRightVectorBar;              | (codepoints . [10583])       | (characters . ⥗)  |

| &DownRightVector;                 | (codepoints . [8641])        | (characters . ⇁)  |

| &DownTeeArrow;                    | (codepoints . [8615])        | (characters . ↧)  |

| &DownTee;                         | (codepoints . [8868])        | (characters . ⊤)  |

| &drbkarow;                        | (codepoints . [10512])       | (characters . ⤐)  |

| &drcorn;                          | (codepoints . [8991])        | (characters . ⌟)  |

| &drcrop;                          | (codepoints . [8972])        | (characters . ⌌)  |

| &Dscr;                            | (codepoints . [119967])      | (characters . 𝒟)  |

| &dscr;                            | (codepoints . [119993])      | (characters . 𝒹)  |

| &DScy;                            | (codepoints . [1029])        | (characters . Ѕ)  |

| &dscy;                            | (codepoints . [1109])        | (characters . ѕ)  |

| &dsol;                            | (codepoints . [10742])       | (characters . ⧶)  |

| &Dstrok;                          | (codepoints . [272])         | (characters . Đ)  |

| &dstrok;                          | (codepoints . [273])         | (characters . đ)  |

| &dtdot;                           | (codepoints . [8945])        | (characters . ⋱)  |

| &dtri;                            | (codepoints . [9663])        | (characters . ▿)  |

| &dtrif;                           | (codepoints . [9662])        | (characters . ▾)  |

| &duarr;                           | (codepoints . [8693])        | (characters . ⇵)  |

| &duhar;                           | (codepoints . [10607])       | (characters . ⥯)  |

| &dwangle;                         | (codepoints . [10662])       | (characters . ⦦)  |

| &DZcy;                            | (codepoints . [1039])        | (characters . Џ)  |

| &dzcy;                            | (codepoints . [1119])        | (characters . џ)  |

| &dzigrarr;                        | (codepoints . [10239])       | (characters . ⟿)  |

| É                          | (codepoints . [201])         | (characters . É)  |

| &Eacute                           | (codepoints . [201])         | (characters . É)  |

| é                          | (codepoints . [233])         | (characters . é)  |

| &eacute                           | (codepoints . [233])         | (characters . é)  |

| &easter;                          | (codepoints . [10862])       | (characters . ⩮)  |

| &Ecaron;                          | (codepoints . [282])         | (characters . Ě)  |

| &ecaron;                          | (codepoints . [283])         | (characters . ě)  |

| Ê                           | (codepoints . [202])         | (characters . Ê)  |

| &Ecirc                            | (codepoints . [202])         | (characters . Ê)  |

| ê                           | (codepoints . [234])         | (characters . ê)  |

| &ecirc                            | (codepoints . [234])         | (characters . ê)  |

| &ecir;                            | (codepoints . [8790])        | (characters . ≖)  |

| &ecolon;                          | (codepoints . [8789])        | (characters . ≕)  |

| &Ecy;                             | (codepoints . [1069])        | (characters . Э)  |

| &ecy;                             | (codepoints . [1101])        | (characters . э)  |

| &eDDot;                           | (codepoints . [10871])       | (characters . ⩷)  |

| &Edot;                            | (codepoints . [278])         | (characters . Ė)  |

| &edot;                            | (codepoints . [279])         | (characters . ė)  |

| &eDot;                            | (codepoints . [8785])        | (characters . ≑)  |

| &ee;                              | (codepoints . [8519])        | (characters . ⅇ)  |

| &efDot;                           | (codepoints . [8786])        | (characters . ≒)  |

| &Efr;                             | (codepoints . [120072])      | (characters . 𝔈)  |

| &efr;                             | (codepoints . [120098])      | (characters . 𝔢)  |

| &eg;                              | (codepoints . [10906])       | (characters . ⪚)  |

| È                          | (codepoints . [200])         | (characters . È)  |

| &Egrave                           | (codepoints . [200])         | (characters . È)  |

| è                          | (codepoints . [232])         | (characters . è)  |

| &egrave                           | (codepoints . [232])         | (characters . è)  |

| &egs;                             | (codepoints . [10902])       | (characters . ⪖)  |

| &egsdot;                          | (codepoints . [10904])       | (characters . ⪘)  |

| &el;                              | (codepoints . [10905])       | (characters . ⪙)  |

| &Element;                         | (codepoints . [8712])        | (characters . ∈)  |

| &elinters;                        | (codepoints . [9191])        | (characters . ⏧)  |

| &ell;                             | (codepoints . [8467])        | (characters . ℓ)  |

| &els;                             | (codepoints . [10901])       | (characters . ⪕)  |

| &elsdot;                          | (codepoints . [10903])       | (characters . ⪗)  |

| &Emacr;                           | (codepoints . [274])         | (characters . Ē)  |

| &emacr;                           | (codepoints . [275])         | (characters . ē)  |

| ∅                           | (codepoints . [8709])        | (characters . ∅)  |

| &emptyset;                        | (codepoints . [8709])        | (characters . ∅)  |

| &EmptySmallSquare;                | (codepoints . [9723])        | (characters . ◻)  |

| &emptyv;                          | (codepoints . [8709])        | (characters . ∅)  |

| &EmptyVerySmallSquare;            | (codepoints . [9643])        | (characters . ▫)  |

| &emsp13;                          | (codepoints . [8196])        | (characters .  )  |

| &emsp14;                          | (codepoints . [8197])        | (characters .  )  |

|                              | (codepoints . [8195])        | (characters .  )  |

| &ENG;                             | (codepoints . [330])         | (characters . Ŋ)  |

| &eng;                             | (codepoints . [331])         | (characters . ŋ)  |

|                              | (codepoints . [8194])        | (characters .  )  |

| &Eogon;                           | (codepoints . [280])         | (characters . Ę)  |

| &eogon;                           | (codepoints . [281])         | (characters . ę)  |

| &Eopf;                            | (codepoints . [120124])      | (characters . 𝔼)  |

| &eopf;                            | (codepoints . [120150])      | (characters . 𝕖)  |

| &epar;                            | (codepoints . [8917])        | (characters . ⋕)  |

| &eparsl;                          | (codepoints . [10723])       | (characters . ⧣)  |

| &eplus;                           | (codepoints . [10865])       | (characters . ⩱)  |

| &epsi;                            | (codepoints . [949])         | (characters . ε)  |

| Ε                         | (codepoints . [917])         | (characters . Ε)  |

| ε                         | (codepoints . [949])         | (characters . ε)  |

| &epsiv;                           | (codepoints . [1013])        | (characters . ϵ)  |

| &eqcirc;                          | (codepoints . [8790])        | (characters . ≖)  |

| &eqcolon;                         | (codepoints . [8789])        | (characters . ≕)  |

| &eqsim;                           | (codepoints . [8770])        | (characters . ≂)  |

| &eqslantgtr;                      | (codepoints . [10902])       | (characters . ⪖)  |

| &eqslantless;                     | (codepoints . [10901])       | (characters . ⪕)  |

| &Equal;                           | (codepoints . [10869])       | (characters . ⩵)  |

| &equals;                          | (codepoints . [61])          | (characters . =)  |

| &EqualTilde;                      | (codepoints . [8770])        | (characters . ≂)  |

| &equest;                          | (codepoints . [8799])        | (characters . ≟)  |

| &Equilibrium;                     | (codepoints . [8652])        | (characters . ⇌)  |

| ≡                           | (codepoints . [8801])        | (characters . ≡)  |

| &equivDD;                         | (codepoints . [10872])       | (characters . ⩸)  |

| &eqvparsl;                        | (codepoints . [10725])       | (characters . ⧥)  |

| &erarr;                           | (codepoints . [10609])       | (characters . ⥱)  |

| &erDot;                           | (codepoints . [8787])        | (characters . ≓)  |

| &escr;                            | (codepoints . [8495])        | (characters . ℯ)  |

| &Escr;                            | (codepoints . [8496])        | (characters . ℰ)  |

| &esdot;                           | (codepoints . [8784])        | (characters . ≐)  |

| &Esim;                            | (codepoints . [10867])       | (characters . ⩳)  |

| &esim;                            | (codepoints . [8770])        | (characters . ≂)  |

| Η                             | (codepoints . [919])         | (characters . Η)  |

| η                             | (codepoints . [951])         | (characters . η)  |

| Ð                             | (codepoints . [208])         | (characters . Ð)  |

| &ETH                              | (codepoints . [208])         | (characters . Ð)  |

| ð                             | (codepoints . [240])         | (characters . ð)  |

| &eth                              | (codepoints . [240])         | (characters . ð)  |

| Ë                            | (codepoints . [203])         | (characters . Ë)  |

| &Euml                             | (codepoints . [203])         | (characters . Ë)  |

| ë                            | (codepoints . [235])         | (characters . ë)  |

| &euml                             | (codepoints . [235])         | (characters . ë)  |

| €                            | (codepoints . [8364])        | (characters . €)  |

| &excl;                            | (codepoints . [33])          | (characters . !)  |

| ∃                           | (codepoints . [8707])        | (characters . ∃)  |

| &Exists;                          | (codepoints . [8707])        | (characters . ∃)  |

| &expectation;                     | (codepoints . [8496])        | (characters . ℰ)  |

| &exponentiale;                    | (codepoints . [8519])        | (characters . ⅇ)  |

| &ExponentialE;                    | (codepoints . [8519])        | (characters . ⅇ)  |

| &fallingdotseq;                   | (codepoints . [8786])        | (characters . ≒)  |

| &Fcy;                             | (codepoints . [1060])        | (characters . Ф)  |

| &fcy;                             | (codepoints . [1092])        | (characters . ф)  |

| &female;                          | (codepoints . [9792])        | (characters . ♀)  |

| &ffilig;                          | (codepoints . [64259])       | (characters . ffi)  |

| &fflig;                           | (codepoints . [64256])       | (characters . ff)  |

| &ffllig;                          | (codepoints . [64260])       | (characters . ffl)  |

| &Ffr;                             | (codepoints . [120073])      | (characters . 𝔉)  |

| &ffr;                             | (codepoints . [120099])      | (characters . 𝔣)  |

| &filig;                           | (codepoints . [64257])       | (characters . fi)  |

| &FilledSmallSquare;               | (codepoints . [9724])        | (characters . ◼)  |

| &FilledVerySmallSquare;           | (codepoints . [9642])        | (characters . ▪)  |

| &fjlig;                           | (codepoints . [102 106])     | (characters . fj) |

| &flat;                            | (codepoints . [9837])        | (characters . ♭)  |

| &fllig;                           | (codepoints . [64258])       | (characters . fl)  |

| &fltns;                           | (codepoints . [9649])        | (characters . ▱)  |

| ƒ                            | (codepoints . [402])         | (characters . ƒ)  |

| &Fopf;                            | (codepoints . [120125])      | (characters . 𝔽)  |

| &fopf;                            | (codepoints . [120151])      | (characters . 𝕗)  |

| ∀                          | (codepoints . [8704])        | (characters . ∀)  |

| &ForAll;                          | (codepoints . [8704])        | (characters . ∀)  |

| &fork;                            | (codepoints . [8916])        | (characters . ⋔)  |

| &forkv;                           | (codepoints . [10969])       | (characters . ⫙)  |

| &Fouriertrf;                      | (codepoints . [8497])        | (characters . ℱ)  |

| &fpartint;                        | (codepoints . [10765])       | (characters . ⨍)  |

| ½                          | (codepoints . [189])         | (characters . ½)  |

| &frac12                           | (codepoints . [189])         | (characters . ½)  |

| &frac13;                          | (codepoints . [8531])        | (characters . ⅓)  |

| ¼                          | (codepoints . [188])         | (characters . ¼)  |

| &frac14                           | (codepoints . [188])         | (characters . ¼)  |

| &frac15;                          | (codepoints . [8533])        | (characters . ⅕)  |

| &frac16;                          | (codepoints . [8537])        | (characters . ⅙)  |

| &frac18;                          | (codepoints . [8539])        | (characters . ⅛)  |

| &frac23;                          | (codepoints . [8532])        | (characters . ⅔)  |

| &frac25;                          | (codepoints . [8534])        | (characters . ⅖)  |

| ¾                          | (codepoints . [190])         | (characters . ¾)  |

| &frac34                           | (codepoints . [190])         | (characters . ¾)  |

| &frac35;                          | (codepoints . [8535])        | (characters . ⅗)  |

| &frac38;                          | (codepoints . [8540])        | (characters . ⅜)  |

| &frac45;                          | (codepoints . [8536])        | (characters . ⅘)  |

| &frac56;                          | (codepoints . [8538])        | (characters . ⅚)  |

| &frac58;                          | (codepoints . [8541])        | (characters . ⅝)  |

| &frac78;                          | (codepoints . [8542])        | (characters . ⅞)  |

| ⁄                           | (codepoints . [8260])        | (characters . ⁄)  |

| &frown;                           | (codepoints . [8994])        | (characters . ⌢)  |

| &fscr;                            | (codepoints . [119995])      | (characters . 𝒻)  |

| &Fscr;                            | (codepoints . [8497])        | (characters . ℱ)  |

| &gacute;                          | (codepoints . [501])         | (characters . ǵ)  |

| Γ                           | (codepoints . [915])         | (characters . Γ)  |

| γ                           | (codepoints . [947])         | (characters . γ)  |

| &Gammad;                          | (codepoints . [988])         | (characters . Ϝ)  |

| &gammad;                          | (codepoints . [989])         | (characters . ϝ)  |

| &gap;                             | (codepoints . [10886])       | (characters . ⪆)  |

| &Gbreve;                          | (codepoints . [286])         | (characters . Ğ)  |

| &gbreve;                          | (codepoints . [287])         | (characters . ğ)  |

| &Gcedil;                          | (codepoints . [290])         | (characters . Ģ)  |

| &Gcirc;                           | (codepoints . [284])         | (characters . Ĝ)  |

| &gcirc;                           | (codepoints . [285])         | (characters . ĝ)  |

| &Gcy;                             | (codepoints . [1043])        | (characters . Г)  |

| &gcy;                             | (codepoints . [1075])        | (characters . г)  |

| &Gdot;                            | (codepoints . [288])         | (characters . Ġ)  |

| &gdot;                            | (codepoints . [289])         | (characters . ġ)  |

| ≥                              | (codepoints . [8805])        | (characters . ≥)  |

| &gE;                              | (codepoints . [8807])        | (characters . ≧)  |

| &gEl;                             | (codepoints . [10892])       | (characters . ⪌)  |

| &gel;                             | (codepoints . [8923])        | (characters . ⋛)  |

| &geq;                             | (codepoints . [8805])        | (characters . ≥)  |

| &geqq;                            | (codepoints . [8807])        | (characters . ≧)  |

| &geqslant;                        | (codepoints . [10878])       | (characters . ⩾)  |

| &gescc;                           | (codepoints . [10921])       | (characters . ⪩)  |

| &ges;                             | (codepoints . [10878])       | (characters . ⩾)  |

| &gesdot;                          | (codepoints . [10880])       | (characters . ⪀)  |

| &gesdoto;                         | (codepoints . [10882])       | (characters . ⪂)  |

| &gesdotol;                        | (codepoints . [10884])       | (characters . ⪄)  |

| &gesl;                            | (codepoints . [8923 65024])  | (characters . ⋛︀)  |

| &gesles;                          | (codepoints . [10900])       | (characters . ⪔)  |

| &Gfr;                             | (codepoints . [120074])      | (characters . 𝔊)  |

| &gfr;                             | (codepoints . [120100])      | (characters . 𝔤)  |

| &gg;                              | (codepoints . [8811])        | (characters . ≫)  |

| &Gg;                              | (codepoints . [8921])        | (characters . ⋙)  |

| &ggg;                             | (codepoints . [8921])        | (characters . ⋙)  |

| &gimel;                           | (codepoints . [8503])        | (characters . ℷ)  |

| &GJcy;                            | (codepoints . [1027])        | (characters . Ѓ)  |

| &gjcy;                            | (codepoints . [1107])        | (characters . ѓ)  |

| &gla;                             | (codepoints . [10917])       | (characters . ⪥)  |

| &gl;                              | (codepoints . [8823])        | (characters . ≷)  |

| &glE;                             | (codepoints . [10898])       | (characters . ⪒)  |

| &glj;                             | (codepoints . [10916])       | (characters . ⪤)  |

| &gnap;                            | (codepoints . [10890])       | (characters . ⪊)  |

| &gnapprox;                        | (codepoints . [10890])       | (characters . ⪊)  |

| &gne;                             | (codepoints . [10888])       | (characters . ⪈)  |

| &gnE;                             | (codepoints . [8809])        | (characters . ≩)  |

| &gneq;                            | (codepoints . [10888])       | (characters . ⪈)  |

| &gneqq;                           | (codepoints . [8809])        | (characters . ≩)  |

| &gnsim;                           | (codepoints . [8935])        | (characters . ⋧)  |

| &Gopf;                            | (codepoints . [120126])      | (characters . 𝔾)  |

| &gopf;                            | (codepoints . [120152])      | (characters . 𝕘)  |

| &grave;                           | (codepoints . [96])          | (characters . `)  |

| &GreaterEqual;                    | (codepoints . [8805])        | (characters . ≥)  |

| &GreaterEqualLess;                | (codepoints . [8923])        | (characters . ⋛)  |

| &GreaterFullEqual;                | (codepoints . [8807])        | (characters . ≧)  |

| &GreaterGreater;                  | (codepoints . [10914])       | (characters . ⪢)  |

| &GreaterLess;                     | (codepoints . [8823])        | (characters . ≷)  |

| &GreaterSlantEqual;               | (codepoints . [10878])       | (characters . ⩾)  |

| &GreaterTilde;                    | (codepoints . [8819])        | (characters . ≳)  |

| &Gscr;                            | (codepoints . [119970])      | (characters . 𝒢)  |

| &gscr;                            | (codepoints . [8458])        | (characters . ℊ)  |

| &gsim;                            | (codepoints . [8819])        | (characters . ≳)  |

| &gsime;                           | (codepoints . [10894])       | (characters . ⪎)  |

| &gsiml;                           | (codepoints . [10896])       | (characters . ⪐)  |

| &gtcc;                            | (codepoints . [10919])       | (characters . ⪧)  |

| &gtcir;                           | (codepoints . [10874])       | (characters . ⩺)  |

| >                              | (codepoints . [62])          | (characters . >)  |

| &gt                               | (codepoints . [62])          | (characters . >)  |

| &GT;                              | (codepoints . [62])          | (characters . >)  |

| &GT                               | (codepoints . [62])          | (characters . >)  |

| &Gt;                              | (codepoints . [8811])        | (characters . ≫)  |

| &gtdot;                           | (codepoints . [8919])        | (characters . ⋗)  |

| &gtlPar;                          | (codepoints . [10645])       | (characters . ⦕)  |

| &gtquest;                         | (codepoints . [10876])       | (characters . ⩼)  |

| &gtrapprox;                       | (codepoints . [10886])       | (characters . ⪆)  |

| &gtrarr;                          | (codepoints . [10616])       | (characters . ⥸)  |

| &gtrdot;                          | (codepoints . [8919])        | (characters . ⋗)  |

| &gtreqless;                       | (codepoints . [8923])        | (characters . ⋛)  |

| &gtreqqless;                      | (codepoints . [10892])       | (characters . ⪌)  |

| &gtrless;                         | (codepoints . [8823])        | (characters . ≷)  |

| &gtrsim;                          | (codepoints . [8819])        | (characters . ≳)  |

| &gvertneqq;                       | (codepoints . [8809 65024])  | (characters . ≩︀)  |

| &gvnE;                            | (codepoints . [8809 65024])  | (characters . ≩︀)  |

| &Hacek;                           | (codepoints . [711])         | (characters . ˇ)  |

| &hairsp;                          | (codepoints . [8202])        | (characters .  )  |

| &half;                            | (codepoints . [189])         | (characters . ½)  |

| &hamilt;                          | (codepoints . [8459])        | (characters . ℋ)  |

| &HARDcy;                          | (codepoints . [1066])        | (characters . Ъ)  |

| &hardcy;                          | (codepoints . [1098])        | (characters . ъ)  |

| &harrcir;                         | (codepoints . [10568])       | (characters . ⥈)  |

| ↔                            | (codepoints . [8596])        | (characters . ↔)  |

| ⇔                            | (codepoints . [8660])        | (characters . ⇔)  |

| &harrw;                           | (codepoints . [8621])        | (characters . ↭)  |

| &Hat;                             | (codepoints . [94])          | (characters . ^)  |

| &hbar;                            | (codepoints . [8463])        | (characters . ℏ)  |

| &Hcirc;                           | (codepoints . [292])         | (characters . Ĥ)  |

| &hcirc;                           | (codepoints . [293])         | (characters . ĥ)  |

| ♥                          | (codepoints . [9829])        | (characters . ♥)  |

| &heartsuit;                       | (codepoints . [9829])        | (characters . ♥)  |

| …                          | (codepoints . [8230])        | (characters . …)  |

| &hercon;                          | (codepoints . [8889])        | (characters . ⊹)  |

| &hfr;                             | (codepoints . [120101])      | (characters . 𝔥)  |

| &Hfr;                             | (codepoints . [8460])        | (characters . ℌ)  |

| &HilbertSpace;                    | (codepoints . [8459])        | (characters . ℋ)  |

| &hksearow;                        | (codepoints . [10533])       | (characters . ⤥)  |

| &hkswarow;                        | (codepoints . [10534])       | (characters . ⤦)  |

| &hoarr;                           | (codepoints . [8703])        | (characters . ⇿)  |

| &homtht;                          | (codepoints . [8763])        | (characters . ∻)  |

| &hookleftarrow;                   | (codepoints . [8617])        | (characters . ↩)  |

| &hookrightarrow;                  | (codepoints . [8618])        | (characters . ↪)  |

| &hopf;                            | (codepoints . [120153])      | (characters . 𝕙)  |

| &Hopf;                            | (codepoints . [8461])        | (characters . ℍ)  |

| &horbar;                          | (codepoints . [8213])        | (characters . ―)  |

| &HorizontalLine;                  | (codepoints . [9472])        | (characters . ─)  |

| &hscr;                            | (codepoints . [119997])      | (characters . 𝒽)  |

| &Hscr;                            | (codepoints . [8459])        | (characters . ℋ)  |

| &hslash;                          | (codepoints . [8463])        | (characters . ℏ)  |

| &Hstrok;                          | (codepoints . [294])         | (characters . Ħ)  |

| &hstrok;                          | (codepoints . [295])         | (characters . ħ)  |

| &HumpDownHump;                    | (codepoints . [8782])        | (characters . ≎)  |

| &HumpEqual;                       | (codepoints . [8783])        | (characters . ≏)  |

| &hybull;                          | (codepoints . [8259])        | (characters . ⁃)  |

| &hyphen;                          | (codepoints . [8208])        | (characters . ‐)  |

| Í                          | (codepoints . [205])         | (characters . Í)  |

| &Iacute                           | (codepoints . [205])         | (characters . Í)  |

| í                          | (codepoints . [237])         | (characters . í)  |

| &iacute                           | (codepoints . [237])         | (characters . í)  |

| &ic;                              | (codepoints . [8291])        | (characters . ⁣)   |

| Î                           | (codepoints . [206])         | (characters . Î)  |

| &Icirc                            | (codepoints . [206])         | (characters . Î)  |

| î                           | (codepoints . [238])         | (characters . î)  |

| &icirc                            | (codepoints . [238])         | (characters . î)  |

| &Icy;                             | (codepoints . [1048])        | (characters . И)  |

| &icy;                             | (codepoints . [1080])        | (characters . и)  |

| &Idot;                            | (codepoints . [304])         | (characters . İ)  |

| &IEcy;                            | (codepoints . [1045])        | (characters . Е)  |

| &iecy;                            | (codepoints . [1077])        | (characters . е)  |

| ¡                           | (codepoints . [161])         | (characters . ¡)  |

| &iexcl                            | (codepoints . [161])         | (characters . ¡)  |

| &iff;                             | (codepoints . [8660])        | (characters . ⇔)  |

| &ifr;                             | (codepoints . [120102])      | (characters . 𝔦)  |

| &Ifr;                             | (codepoints . [8465])        | (characters . ℑ)  |

| Ì                          | (codepoints . [204])         | (characters . Ì)  |

| &Igrave                           | (codepoints . [204])         | (characters . Ì)  |

| ì                          | (codepoints . [236])         | (characters . ì)  |

| &igrave                           | (codepoints . [236])         | (characters . ì)  |

| &ii;                              | (codepoints . [8520])        | (characters . ⅈ)  |

| &iiiint;                          | (codepoints . [10764])       | (characters . ⨌)  |

| &iiint;                           | (codepoints . [8749])        | (characters . ∭)  |

| &iinfin;                          | (codepoints . [10716])       | (characters . ⧜)  |

| &iiota;                           | (codepoints . [8489])        | (characters . ℩)  |

| &IJlig;                           | (codepoints . [306])         | (characters . IJ)  |

| &ijlig;                           | (codepoints . [307])         | (characters . ij)  |

| &Imacr;                           | (codepoints . [298])         | (characters . Ī)  |

| &imacr;                           | (codepoints . [299])         | (characters . ī)  |

| ℑ                           | (codepoints . [8465])        | (characters . ℑ)  |

| &ImaginaryI;                      | (codepoints . [8520])        | (characters . ⅈ)  |

| &imagline;                        | (codepoints . [8464])        | (characters . ℐ)  |

| &imagpart;                        | (codepoints . [8465])        | (characters . ℑ)  |

| &imath;                           | (codepoints . [305])         | (characters . ı)  |

| &Im;                              | (codepoints . [8465])        | (characters . ℑ)  |

| &imof;                            | (codepoints . [8887])        | (characters . ⊷)  |

| &imped;                           | (codepoints . [437])         | (characters . Ƶ)  |

| &Implies;                         | (codepoints . [8658])        | (characters . ⇒)  |

| &incare;                          | (codepoints . [8453])        | (characters . ℅)  |

| &in;                              | (codepoints . [8712])        | (characters . ∈)  |

| ∞                           | (codepoints . [8734])        | (characters . ∞)  |

| &infintie;                        | (codepoints . [10717])       | (characters . ⧝)  |

| &inodot;                          | (codepoints . [305])         | (characters . ı)  |

| &intcal;                          | (codepoints . [8890])        | (characters . ⊺)  |

| ∫                             | (codepoints . [8747])        | (characters . ∫)  |

| &Int;                             | (codepoints . [8748])        | (characters . ∬)  |

| &integers;                        | (codepoints . [8484])        | (characters . ℤ)  |

| &Integral;                        | (codepoints . [8747])        | (characters . ∫)  |

| &intercal;                        | (codepoints . [8890])        | (characters . ⊺)  |

| &Intersection;                    | (codepoints . [8898])        | (characters . ⋂)  |

| &intlarhk;                        | (codepoints . [10775])       | (characters . ⨗)  |

| &intprod;                         | (codepoints . [10812])       | (characters . ⨼)  |

| &InvisibleComma;                  | (codepoints . [8291])        | (characters . ⁣)   |

| &InvisibleTimes;                  | (codepoints . [8290])        | (characters . ⁢)   |

| &IOcy;                            | (codepoints . [1025])        | (characters . Ё)  |

| &iocy;                            | (codepoints . [1105])        | (characters . ё)  |

| &Iogon;                           | (codepoints . [302])         | (characters . Į)  |

| &iogon;                           | (codepoints . [303])         | (characters . į)  |

| &Iopf;                            | (codepoints . [120128])      | (characters . 𝕀)  |

| &iopf;                            | (codepoints . [120154])      | (characters . 𝕚)  |

| Ι                            | (codepoints . [921])         | (characters . Ι)  |

| ι                            | (codepoints . [953])         | (characters . ι)  |

| &iprod;                           | (codepoints . [10812])       | (characters . ⨼)  |

| ¿                          | (codepoints . [191])         | (characters . ¿)  |

| &iquest                           | (codepoints . [191])         | (characters . ¿)  |

| &iscr;                            | (codepoints . [119998])      | (characters . 𝒾)  |

| &Iscr;                            | (codepoints . [8464])        | (characters . ℐ)  |

| ∈                            | (codepoints . [8712])        | (characters . ∈)  |

| &isindot;                         | (codepoints . [8949])        | (characters . ⋵)  |

| &isinE;                           | (codepoints . [8953])        | (characters . ⋹)  |

| &isins;                           | (codepoints . [8948])        | (characters . ⋴)  |

| &isinsv;                          | (codepoints . [8947])        | (characters . ⋳)  |

| &isinv;                           | (codepoints . [8712])        | (characters . ∈)  |

| &it;                              | (codepoints . [8290])        | (characters . ⁢)   |

| &Itilde;                          | (codepoints . [296])         | (characters . Ĩ)  |

| &itilde;                          | (codepoints . [297])         | (characters . ĩ)  |

| &Iukcy;                           | (codepoints . [1030])        | (characters . І)  |

| &iukcy;                           | (codepoints . [1110])        | (characters . і)  |

| Ï                            | (codepoints . [207])         | (characters . Ï)  |

| &Iuml                             | (codepoints . [207])         | (characters . Ï)  |

| ï                            | (codepoints . [239])         | (characters . ï)  |

| &iuml                             | (codepoints . [239])         | (characters . ï)  |

| &Jcirc;                           | (codepoints . [308])         | (characters . Ĵ)  |

| &jcirc;                           | (codepoints . [309])         | (characters . ĵ)  |

| &Jcy;                             | (codepoints . [1049])        | (characters . Й)  |

| &jcy;                             | (codepoints . [1081])        | (characters . й)  |

| &Jfr;                             | (codepoints . [120077])      | (characters . 𝔍)  |

| &jfr;                             | (codepoints . [120103])      | (characters . 𝔧)  |

| &jmath;                           | (codepoints . [567])         | (characters . ȷ)  |

| &Jopf;                            | (codepoints . [120129])      | (characters . 𝕁)  |

| &jopf;                            | (codepoints . [120155])      | (characters . 𝕛)  |

| &Jscr;                            | (codepoints . [119973])      | (characters . 𝒥)  |

| &jscr;                            | (codepoints . [119999])      | (characters . 𝒿)  |

| &Jsercy;                          | (codepoints . [1032])        | (characters . Ј)  |

| &jsercy;                          | (codepoints . [1112])        | (characters . ј)  |

| &Jukcy;                           | (codepoints . [1028])        | (characters . Є)  |

| &jukcy;                           | (codepoints . [1108])        | (characters . є)  |

| Κ                           | (codepoints . [922])         | (characters . Κ)  |

| κ                           | (codepoints . [954])         | (characters . κ)  |

| &kappav;                          | (codepoints . [1008])        | (characters . ϰ)  |

| &Kcedil;                          | (codepoints . [310])         | (characters . Ķ)  |

| &kcedil;                          | (codepoints . [311])         | (characters . ķ)  |

| &Kcy;                             | (codepoints . [1050])        | (characters . К)  |

| &kcy;                             | (codepoints . [1082])        | (characters . к)  |

| &Kfr;                             | (codepoints . [120078])      | (characters . 𝔎)  |

| &kfr;                             | (codepoints . [120104])      | (characters . 𝔨)  |

| &kgreen;                          | (codepoints . [312])         | (characters . ĸ)  |

| &KHcy;                            | (codepoints . [1061])        | (characters . Х)  |

| &khcy;                            | (codepoints . [1093])        | (characters . х)  |

| &KJcy;                            | (codepoints . [1036])        | (characters . Ќ)  |

| &kjcy;                            | (codepoints . [1116])        | (characters . ќ)  |

| &Kopf;                            | (codepoints . [120130])      | (characters . 𝕂)  |

| &kopf;                            | (codepoints . [120156])      | (characters . 𝕜)  |

| &Kscr;                            | (codepoints . [119974])      | (characters . 𝒦)  |

| &kscr;                            | (codepoints . [120000])      | (characters . 𝓀)  |

| &lAarr;                           | (codepoints . [8666])        | (characters . ⇚)  |

| &Lacute;                          | (codepoints . [313])         | (characters . Ĺ)  |

| &lacute;                          | (codepoints . [314])         | (characters . ĺ)  |

| &laemptyv;                        | (codepoints . [10676])       | (characters . ⦴)  |

| &lagran;                          | (codepoints . [8466])        | (characters . ℒ)  |

| Λ                          | (codepoints . [923])         | (characters . Λ)  |

| λ                          | (codepoints . [955])         | (characters . λ)  |

| 〈                            | (codepoints . [10216])       | (characters . ⟨)  |

| &Lang;                            | (codepoints . [10218])       | (characters . ⟪)  |

| &langd;                           | (codepoints . [10641])       | (characters . ⦑)  |

| &langle;                          | (codepoints . [10216])       | (characters . ⟨)  |

| &lap;                             | (codepoints . [10885])       | (characters . ⪅)  |

| &Laplacetrf;                      | (codepoints . [8466])        | (characters . ℒ)  |

| «                           | (codepoints . [171])         | (characters . «)  |

| &laquo                            | (codepoints . [171])         | (characters . «)  |

| &larrb;                           | (codepoints . [8676])        | (characters . ⇤)  |

| &larrbfs;                         | (codepoints . [10527])       | (characters . ⤟)  |

| ←                            | (codepoints . [8592])        | (characters . ←)  |

| &Larr;                            | (codepoints . [8606])        | (characters . ↞)  |

| ⇐                            | (codepoints . [8656])        | (characters . ⇐)  |

| &larrfs;                          | (codepoints . [10525])       | (characters . ⤝)  |

| &larrhk;                          | (codepoints . [8617])        | (characters . ↩)  |

| &larrlp;                          | (codepoints . [8619])        | (characters . ↫)  |

| &larrpl;                          | (codepoints . [10553])       | (characters . ⤹)  |

| &larrsim;                         | (codepoints . [10611])       | (characters . ⥳)  |

| &larrtl;                          | (codepoints . [8610])        | (characters . ↢)  |

| &latail;                          | (codepoints . [10521])       | (characters . ⤙)  |

| &lAtail;                          | (codepoints . [10523])       | (characters . ⤛)  |

| &lat;                             | (codepoints . [10923])       | (characters . ⪫)  |

| &late;                            | (codepoints . [10925])       | (characters . ⪭)  |

| &lates;                           | (codepoints . [10925 65024]) | (characters . ⪭︀)  |

| &lbarr;                           | (codepoints . [10508])       | (characters . ⤌)  |

| &lBarr;                           | (codepoints . [10510])       | (characters . ⤎)  |

| &lbbrk;                           | (codepoints . [10098])       | (characters . ❲)  |

| &lbrace;                          | (codepoints . [123])         | (characters . {)  |

| &lbrack;                          | (codepoints . [91])          | (characters . [)  |

| &lbrke;                           | (codepoints . [10635])       | (characters . ⦋)  |

| &lbrksld;                         | (codepoints . [10639])       | (characters . ⦏)  |

| &lbrkslu;                         | (codepoints . [10637])       | (characters . ⦍)  |

| &Lcaron;                          | (codepoints . [317])         | (characters . Ľ)  |

| &lcaron;                          | (codepoints . [318])         | (characters . ľ)  |

| &Lcedil;                          | (codepoints . [315])         | (characters . Ļ)  |

| &lcedil;                          | (codepoints . [316])         | (characters . ļ)  |

| ⌈                           | (codepoints . [8968])        | (characters . ⌈)  |

| &lcub;                            | (codepoints . [123])         | (characters . {)  |

| &Lcy;                             | (codepoints . [1051])        | (characters . Л)  |

| &lcy;                             | (codepoints . [1083])        | (characters . л)  |

| &ldca;                            | (codepoints . [10550])       | (characters . ⤶)  |

| “                           | (codepoints . [8220])        | (characters . “)  |

| &ldquor;                          | (codepoints . [8222])        | (characters . „)  |

| &ldrdhar;                         | (codepoints . [10599])       | (characters . ⥧)  |

| &ldrushar;                        | (codepoints . [10571])       | (characters . ⥋)  |

| &ldsh;                            | (codepoints . [8626])        | (characters . ↲)  |

| ≤                              | (codepoints . [8804])        | (characters . ≤)  |

| &lE;                              | (codepoints . [8806])        | (characters . ≦)  |

| &LeftAngleBracket;                | (codepoints . [10216])       | (characters . ⟨)  |

| &LeftArrowBar;                    | (codepoints . [8676])        | (characters . ⇤)  |

| &leftarrow;                       | (codepoints . [8592])        | (characters . ←)  |

| &LeftArrow;                       | (codepoints . [8592])        | (characters . ←)  |

| &Leftarrow;                       | (codepoints . [8656])        | (characters . ⇐)  |

| &LeftArrowRightArrow;             | (codepoints . [8646])        | (characters . ⇆)  |

| &leftarrowtail;                   | (codepoints . [8610])        | (characters . ↢)  |

| &LeftCeiling;                     | (codepoints . [8968])        | (characters . ⌈)  |

| &LeftDoubleBracket;               | (codepoints . [10214])       | (characters . ⟦)  |

| &LeftDownTeeVector;               | (codepoints . [10593])       | (characters . ⥡)  |

| &LeftDownVectorBar;               | (codepoints . [10585])       | (characters . ⥙)  |

| &LeftDownVector;                  | (codepoints . [8643])        | (characters . ⇃)  |

| &LeftFloor;                       | (codepoints . [8970])        | (characters . ⌊)  |

| &leftharpoondown;                 | (codepoints . [8637])        | (characters . ↽)  |

| &leftharpoonup;                   | (codepoints . [8636])        | (characters . ↼)  |

| &leftleftarrows;                  | (codepoints . [8647])        | (characters . ⇇)  |

| &leftrightarrow;                  | (codepoints . [8596])        | (characters . ↔)  |

| &LeftRightArrow;                  | (codepoints . [8596])        | (characters . ↔)  |

| &Leftrightarrow;                  | (codepoints . [8660])        | (characters . ⇔)  |

| &leftrightarrows;                 | (codepoints . [8646])        | (characters . ⇆)  |

| &leftrightharpoons;               | (codepoints . [8651])        | (characters . ⇋)  |

| &leftrightsquigarrow;             | (codepoints . [8621])        | (characters . ↭)  |

| &LeftRightVector;                 | (codepoints . [10574])       | (characters . ⥎)  |

| &LeftTeeArrow;                    | (codepoints . [8612])        | (characters . ↤)  |

| &LeftTee;                         | (codepoints . [8867])        | (characters . ⊣)  |

| &LeftTeeVector;                   | (codepoints . [10586])       | (characters . ⥚)  |

| &leftthreetimes;                  | (codepoints . [8907])        | (characters . ⋋)  |

| &LeftTriangleBar;                 | (codepoints . [10703])       | (characters . ⧏)  |

| &LeftTriangle;                    | (codepoints . [8882])        | (characters . ⊲)  |

| &LeftTriangleEqual;               | (codepoints . [8884])        | (characters . ⊴)  |

| &LeftUpDownVector;                | (codepoints . [10577])       | (characters . ⥑)  |

| &LeftUpTeeVector;                 | (codepoints . [10592])       | (characters . ⥠)  |

| &LeftUpVectorBar;                 | (codepoints . [10584])       | (characters . ⥘)  |

| &LeftUpVector;                    | (codepoints . [8639])        | (characters . ↿)  |

| &LeftVectorBar;                   | (codepoints . [10578])       | (characters . ⥒)  |

| &LeftVector;                      | (codepoints . [8636])        | (characters . ↼)  |

| &lEg;                             | (codepoints . [10891])       | (characters . ⪋)  |

| &leg;                             | (codepoints . [8922])        | (characters . ⋚)  |

| &leq;                             | (codepoints . [8804])        | (characters . ≤)  |

| &leqq;                            | (codepoints . [8806])        | (characters . ≦)  |

| &leqslant;                        | (codepoints . [10877])       | (characters . ⩽)  |

| &lescc;                           | (codepoints . [10920])       | (characters . ⪨)  |

| &les;                             | (codepoints . [10877])       | (characters . ⩽)  |

| &lesdot;                          | (codepoints . [10879])       | (characters . ⩿)  |

| &lesdoto;                         | (codepoints . [10881])       | (characters . ⪁)  |

| &lesdotor;                        | (codepoints . [10883])       | (characters . ⪃)  |

| &lesg;                            | (codepoints . [8922 65024])  | (characters . ⋚︀)  |

| &lesges;                          | (codepoints . [10899])       | (characters . ⪓)  |

| &lessapprox;                      | (codepoints . [10885])       | (characters . ⪅)  |

| &lessdot;                         | (codepoints . [8918])        | (characters . ⋖)  |

| &lesseqgtr;                       | (codepoints . [8922])        | (characters . ⋚)  |

| &lesseqqgtr;                      | (codepoints . [10891])       | (characters . ⪋)  |

| &LessEqualGreater;                | (codepoints . [8922])        | (characters . ⋚)  |

| &LessFullEqual;                   | (codepoints . [8806])        | (characters . ≦)  |

| &LessGreater;                     | (codepoints . [8822])        | (characters . ≶)  |

| &lessgtr;                         | (codepoints . [8822])        | (characters . ≶)  |

| &LessLess;                        | (codepoints . [10913])       | (characters . ⪡)  |

| &lesssim;                         | (codepoints . [8818])        | (characters . ≲)  |

| &LessSlantEqual;                  | (codepoints . [10877])       | (characters . ⩽)  |

| &LessTilde;                       | (codepoints . [8818])        | (characters . ≲)  |

| &lfisht;                          | (codepoints . [10620])       | (characters . ⥼)  |

| ⌊                          | (codepoints . [8970])        | (characters . ⌊)  |

| &Lfr;                             | (codepoints . [120079])      | (characters . 𝔏)  |

| &lfr;                             | (codepoints . [120105])      | (characters . 𝔩)  |

| &lg;                              | (codepoints . [8822])        | (characters . ≶)  |

| &lgE;                             | (codepoints . [10897])       | (characters . ⪑)  |

| &lHar;                            | (codepoints . [10594])       | (characters . ⥢)  |

| &lhard;                           | (codepoints . [8637])        | (characters . ↽)  |

| &lharu;                           | (codepoints . [8636])        | (characters . ↼)  |

| &lharul;                          | (codepoints . [10602])       | (characters . ⥪)  |

| &lhblk;                           | (codepoints . [9604])        | (characters . ▄)  |

| &LJcy;                            | (codepoints . [1033])        | (characters . Љ)  |

| &ljcy;                            | (codepoints . [1113])        | (characters . љ)  |

| &llarr;                           | (codepoints . [8647])        | (characters . ⇇)  |

| &ll;                              | (codepoints . [8810])        | (characters . ≪)  |

| &Ll;                              | (codepoints . [8920])        | (characters . ⋘)  |

| &llcorner;                        | (codepoints . [8990])        | (characters . ⌞)  |

| &Lleftarrow;                      | (codepoints . [8666])        | (characters . ⇚)  |

| &llhard;                          | (codepoints . [10603])       | (characters . ⥫)  |

| &lltri;                           | (codepoints . [9722])        | (characters . ◺)  |

| &Lmidot;                          | (codepoints . [319])         | (characters . Ŀ)  |

| &lmidot;                          | (codepoints . [320])         | (characters . ŀ)  |

| &lmoustache;                      | (codepoints . [9136])        | (characters . ⎰)  |

| &lmoust;                          | (codepoints . [9136])        | (characters . ⎰)  |

| &lnap;                            | (codepoints . [10889])       | (characters . ⪉)  |

| &lnapprox;                        | (codepoints . [10889])       | (characters . ⪉)  |

| &lne;                             | (codepoints . [10887])       | (characters . ⪇)  |

| &lnE;                             | (codepoints . [8808])        | (characters . ≨)  |

| &lneq;                            | (codepoints . [10887])       | (characters . ⪇)  |

| &lneqq;                           | (codepoints . [8808])        | (characters . ≨)  |

| &lnsim;                           | (codepoints . [8934])        | (characters . ⋦)  |

| &loang;                           | (codepoints . [10220])       | (characters . ⟬)  |

| &loarr;                           | (codepoints . [8701])        | (characters . ⇽)  |

| &lobrk;                           | (codepoints . [10214])       | (characters . ⟦)  |

| &longleftarrow;                   | (codepoints . [10229])       | (characters . ⟵)  |

| &LongLeftArrow;                   | (codepoints . [10229])       | (characters . ⟵)  |

| &Longleftarrow;                   | (codepoints . [10232])       | (characters . ⟸)  |

| &longleftrightarrow;              | (codepoints . [10231])       | (characters . ⟷)  |

| &LongLeftRightArrow;              | (codepoints . [10231])       | (characters . ⟷)  |

| &Longleftrightarrow;              | (codepoints . [10234])       | (characters . ⟺)  |

| &longmapsto;                      | (codepoints . [10236])       | (characters . ⟼)  |

| &longrightarrow;                  | (codepoints . [10230])       | (characters . ⟶)  |

| &LongRightArrow;                  | (codepoints . [10230])       | (characters . ⟶)  |

| &Longrightarrow;                  | (codepoints . [10233])       | (characters . ⟹)  |

| &looparrowleft;                   | (codepoints . [8619])        | (characters . ↫)  |

| &looparrowright;                  | (codepoints . [8620])        | (characters . ↬)  |

| &lopar;                           | (codepoints . [10629])       | (characters . ⦅)  |

| &Lopf;                            | (codepoints . [120131])      | (characters . 𝕃)  |

| &lopf;                            | (codepoints . [120157])      | (characters . 𝕝)  |

| &loplus;                          | (codepoints . [10797])       | (characters . ⨭)  |

| &lotimes;                         | (codepoints . [10804])       | (characters . ⨴)  |

| ∗                          | (codepoints . [8727])        | (characters . ∗)  |

| &lowbar;                          | (codepoints . [95])          | (characters . _)  |

| &LowerLeftArrow;                  | (codepoints . [8601])        | (characters . ↙)  |

| &LowerRightArrow;                 | (codepoints . [8600])        | (characters . ↘)  |

| ◊                             | (codepoints . [9674])        | (characters . ◊)  |

| &lozenge;                         | (codepoints . [9674])        | (characters . ◊)  |

| &lozf;                            | (codepoints . [10731])       | (characters . ⧫)  |

| &lpar;                            | (codepoints . [40])          | (characters . ()  |

| &lparlt;                          | (codepoints . [10643])       | (characters . ⦓)  |

| &lrarr;                           | (codepoints . [8646])        | (characters . ⇆)  |

| &lrcorner;                        | (codepoints . [8991])        | (characters . ⌟)  |

| &lrhar;                           | (codepoints . [8651])        | (characters . ⇋)  |

| &lrhard;                          | (codepoints . [10605])       | (characters . ⥭)  |

| ‎                             | (codepoints . [8206])        | (characters . ‎)   |

| &lrtri;                           | (codepoints . [8895])        | (characters . ⊿)  |

| ‹                          | (codepoints . [8249])        | (characters . ‹)  |

| &lscr;                            | (codepoints . [120001])      | (characters . 𝓁)  |

| &Lscr;                            | (codepoints . [8466])        | (characters . ℒ)  |

| &lsh;                             | (codepoints . [8624])        | (characters . ↰)  |

| &Lsh;                             | (codepoints . [8624])        | (characters . ↰)  |

| &lsim;                            | (codepoints . [8818])        | (characters . ≲)  |

| &lsime;                           | (codepoints . [10893])       | (characters . ⪍)  |

| &lsimg;                           | (codepoints . [10895])       | (characters . ⪏)  |

| &lsqb;                            | (codepoints . [91])          | (characters . [)  |

| ‘                           | (codepoints . [8216])        | (characters . ‘)  |

| &lsquor;                          | (codepoints . [8218])        | (characters . ‚)  |

| &Lstrok;                          | (codepoints . [321])         | (characters . Ł)  |

| &lstrok;                          | (codepoints . [322])         | (characters . ł)  |

| &ltcc;                            | (codepoints . [10918])       | (characters . ⪦)  |

| &ltcir;                           | (codepoints . [10873])       | (characters . ⩹)  |

| <                              | (codepoints . [60])          | (characters . <)  |

| &lt                               | (codepoints . [60])          | (characters . <)  |

| &LT;                              | (codepoints . [60])          | (characters . <)  |

| &LT                               | (codepoints . [60])          | (characters . <)  |

| &Lt;                              | (codepoints . [8810])        | (characters . ≪)  |

| &ltdot;                           | (codepoints . [8918])        | (characters . ⋖)  |

| &lthree;                          | (codepoints . [8907])        | (characters . ⋋)  |

| &ltimes;                          | (codepoints . [8905])        | (characters . ⋉)  |

| &ltlarr;                          | (codepoints . [10614])       | (characters . ⥶)  |

| &ltquest;                         | (codepoints . [10875])       | (characters . ⩻)  |

| &ltri;                            | (codepoints . [9667])        | (characters . ◃)  |

| &ltrie;                           | (codepoints . [8884])        | (characters . ⊴)  |

| &ltrif;                           | (codepoints . [9666])        | (characters . ◂)  |

| &ltrPar;                          | (codepoints . [10646])       | (characters . ⦖)  |

| &lurdshar;                        | (codepoints . [10570])       | (characters . ⥊)  |

| &luruhar;                         | (codepoints . [10598])       | (characters . ⥦)  |

| &lvertneqq;                       | (codepoints . [8808 65024])  | (characters . ≨︀)  |

| &lvnE;                            | (codepoints . [8808 65024])  | (characters . ≨︀)  |

| ¯                            | (codepoints . [175])         | (characters . ¯)  |

| &macr                             | (codepoints . [175])         | (characters . ¯)  |

| &male;                            | (codepoints . [9794])        | (characters . ♂)  |

| &malt;                            | (codepoints . [10016])       | (characters . ✠)  |

| &maltese;                         | (codepoints . [10016])       | (characters . ✠)  |

| &Map;                             | (codepoints . [10501])       | (characters . ⤅)  |

| &map;                             | (codepoints . [8614])        | (characters . ↦)  |

| &mapsto;                          | (codepoints . [8614])        | (characters . ↦)  |

| &mapstodown;                      | (codepoints . [8615])        | (characters . ↧)  |

| &mapstoleft;                      | (codepoints . [8612])        | (characters . ↤)  |

| &mapstoup;                        | (codepoints . [8613])        | (characters . ↥)  |

| &marker;                          | (codepoints . [9646])        | (characters . ▮)  |

| &mcomma;                          | (codepoints . [10793])       | (characters . ⨩)  |

| &Mcy;                             | (codepoints . [1052])        | (characters . М)  |

| &mcy;                             | (codepoints . [1084])        | (characters . м)  |

| —                           | (codepoints . [8212])        | (characters . —)  |

| &mDDot;                           | (codepoints . [8762])        | (characters . ∺)  |

| &measuredangle;                   | (codepoints . [8737])        | (characters . ∡)  |

| &MediumSpace;                     | (codepoints . [8287])        | (characters .  )  |

| &Mellintrf;                       | (codepoints . [8499])        | (characters . ℳ)  |

| &Mfr;                             | (codepoints . [120080])      | (characters . 𝔐)  |

| &mfr;                             | (codepoints . [120106])      | (characters . 𝔪)  |

| &mho;                             | (codepoints . [8487])        | (characters . ℧)  |

| µ                           | (codepoints . [181])         | (characters . µ)  |

| &micro                            | (codepoints . [181])         | (characters . µ)  |

| &midast;                          | (codepoints . [42])          | (characters . *)  |

| &midcir;                          | (codepoints . [10992])       | (characters . ⫰)  |

| &mid;                             | (codepoints . [8739])        | (characters . ∣)  |

| ·                          | (codepoints . [183])         | (characters . ·)  |

| &middot                           | (codepoints . [183])         | (characters . ·)  |

| &minusb;                          | (codepoints . [8863])        | (characters . ⊟)  |

| −                           | (codepoints . [8722])        | (characters . −)  |

| &minusd;                          | (codepoints . [8760])        | (characters . ∸)  |

| &minusdu;                         | (codepoints . [10794])       | (characters . ⨪)  |

| &MinusPlus;                       | (codepoints . [8723])        | (characters . ∓)  |

| &mlcp;                            | (codepoints . [10971])       | (characters . ⫛)  |

| &mldr;                            | (codepoints . [8230])        | (characters . …)  |

| &mnplus;                          | (codepoints . [8723])        | (characters . ∓)  |

| &models;                          | (codepoints . [8871])        | (characters . ⊧)  |

| &Mopf;                            | (codepoints . [120132])      | (characters . 𝕄)  |

| &mopf;                            | (codepoints . [120158])      | (characters . 𝕞)  |

| &mp;                              | (codepoints . [8723])        | (characters . ∓)  |

| &mscr;                            | (codepoints . [120002])      | (characters . 𝓂)  |

| &Mscr;                            | (codepoints . [8499])        | (characters . ℳ)  |

| &mstpos;                          | (codepoints . [8766])        | (characters . ∾)  |

| Μ                              | (codepoints . [924])         | (characters . Μ)  |

| μ                              | (codepoints . [956])         | (characters . μ)  |

| &multimap;                        | (codepoints . [8888])        | (characters . ⊸)  |

| &mumap;                           | (codepoints . [8888])        | (characters . ⊸)  |

| ∇                           | (codepoints . [8711])        | (characters . ∇)  |

| &Nacute;                          | (codepoints . [323])         | (characters . Ń)  |

| &nacute;                          | (codepoints . [324])         | (characters . ń)  |

| &nang;                            | (codepoints . [8736 8402])   | (characters . ∠⃒)  |

| &nap;                             | (codepoints . [8777])        | (characters . ≉)  |

| &napE;                            | (codepoints . [10864 824])   | (characters . ⩰̸)  |

| &napid;                           | (codepoints . [8779 824])    | (characters . ≋̸)  |

| &napos;                           | (codepoints . [329])         | (characters . ʼn)  |

| &napprox;                         | (codepoints . [8777])        | (characters . ≉)  |

| &natural;                         | (codepoints . [9838])        | (characters . ♮)  |

| &naturals;                        | (codepoints . [8469])        | (characters . ℕ)  |

| &natur;                           | (codepoints . [9838])        | (characters . ♮)  |

|                              | (codepoints . [160])         | (characters .  )  |

| &nbsp                             | (codepoints . [160])         | (characters .  )  |

| &nbump;                           | (codepoints . [8782 824])    | (characters . ≎̸)  |

| &nbumpe;                          | (codepoints . [8783 824])    | (characters . ≏̸)  |

| &ncap;                            | (codepoints . [10819])       | (characters . ⩃)  |

| &Ncaron;                          | (codepoints . [327])         | (characters . Ň)  |

| &ncaron;                          | (codepoints . [328])         | (characters . ň)  |

| &Ncedil;                          | (codepoints . [325])         | (characters . Ņ)  |

| &ncedil;                          | (codepoints . [326])         | (characters . ņ)  |

| &ncong;                           | (codepoints . [8775])        | (characters . ≇)  |

| &ncongdot;                        | (codepoints . [10861 824])   | (characters . ⩭̸)  |

| &ncup;                            | (codepoints . [10818])       | (characters . ⩂)  |

| &Ncy;                             | (codepoints . [1053])        | (characters . Н)  |

| &ncy;                             | (codepoints . [1085])        | (characters . н)  |

| –                           | (codepoints . [8211])        | (characters . –)  |

| &nearhk;                          | (codepoints . [10532])       | (characters . ⤤)  |

| &nearr;                           | (codepoints . [8599])        | (characters . ↗)  |

| &neArr;                           | (codepoints . [8663])        | (characters . ⇗)  |

| &nearrow;                         | (codepoints . [8599])        | (characters . ↗)  |

| ≠                              | (codepoints . [8800])        | (characters . ≠)  |

| &nedot;                           | (codepoints . [8784 824])    | (characters . ≐̸)  |

| &NegativeMediumSpace;             | (codepoints . [8203])        | (characters . ​)   |

| &NegativeThickSpace;              | (codepoints . [8203])        | (characters . ​)   |

| &NegativeThinSpace;               | (codepoints . [8203])        | (characters . ​)   |

| &NegativeVeryThinSpace;           | (codepoints . [8203])        | (characters . ​)   |

| &nequiv;                          | (codepoints . [8802])        | (characters . ≢)  |

| &nesear;                          | (codepoints . [10536])       | (characters . ⤨)  |

| &nesim;                           | (codepoints . [8770 824])    | (characters . ≂̸)  |

| &NestedGreaterGreater;            | (codepoints . [8811])        | (characters . ≫)  |

| &NestedLessLess;                  | (codepoints . [8810])        | (characters . ≪)  |

| &NewLine;                         | (codepoints . [10])          | (characters .     |

* Development

I'm experimenting with using literate programming and ~org-babel-tangle~ as my main development modality. It's convenient to navigate the various parts of the code, etc.  But it may be hard to submit PR's etc. 

* COMMENT old cruft to delete later 

It's also possible to store some data structures either as JSON files or ~.el~ files which can be accessed later on by some of the helper functions.  

- first you will need to define ~org-lms-baseurl~, which is the URL from which all Canvas API calls will be built.  This will look something like ~https://my.university.canvas.system/api/v1/~.

- Then you'll create and store an oauth token; you can get this by navigating to ~Account~ \rarr ~Settings~ \rarr ~New Access Token~ in the Canvas API. Don't store it in version-control! I am using [[https://www.passwordstore.org/][pass]] and [[https://git.zx2c4.com/password-store/about/][password-store]] but I'm not sure it's a great solution.

- You will need to define a list of courses, each of which is a simple alist with a symbol as ~car~ and plist of course properties as ~cdr~. ~org-lms~ also lets you define your assignments locally and allows you to maintain a CSV file with additional student information (e.g., nicknames and github handles). See [[./students.csv]] for the expected format. *I'm trying to move away from this format but having a little difficulty!*

- In a given page, *set the current course* with ~org-lms-course~ and set up the properties with ~org-lms-setup~. This will generate a table with links to some of the other functions. 

So, for instance, here is my tst setup:

#+begin_src emacs-lisp

    (setq org-lms-baseurl "https://q.utoronto.ca/api/v1/")

    (setq org-lms-token (password-store-get "q.utoronto.ca"))

    (setq org-lms-courses

          '(

            (wildwater .

                       (:shortname "Wild Waters"

                                   :coursenum "NEW271"

                                   :semester "20189"

                                   ))))

    (setq org-lms-course (org-lms-infer-course (alist-get 'wildwater  org-lms-courses)))

      (setq org-lms-local-assignments

          '(

            (darwin .

                    (:name "Response Paper 1"

                           :directory "response-paper-1"

                           :weight 0.10

                           :grade-type "letter"

                           :submisison-type "email"

                           :rubric-list ("Organization" "Clarity of Argument"

                                         "Grammar and Spelling" "Grade"

                                         "See Attached Paper for further Comments")

                           ))

            (test .

                  (:name "Test Assignment"

                         :directory "response-paper-1"

                         :weight 0.10

                         :grade-type "letter"

                         :submisison-type "canvas"

                         :rubric-list ("Organization" "Clarity of Argument"

                                       "Grammar and Spelling" "Grade"

                                       "See Attached Paper for further Comments")

                         ))))

    (org-lms-setup)

#+end_src

** Development

These are mostly some random notes about things I did during development

*** Building a usable course object in lisp

Thesewre my first experiments making a lisp data structure. It's a bit ugly.

#+begin_src emacs-lisp

  (let*

      ((students (org-lms~parse-plist-csv-file "./students.csv"))

      (darwin

        '((name . "Response Paper 1" )

          (directory . "response-paper-1")

          (weight . 0.10)

          (type . "letter")

          (rubric-list . ("Organization" "Clarity of Argument"

                           "Grammar and Spelling" "Grade"

                           "See Attached Paper for further Comments"))))

          (atitle (alist-get 'name darwin))

          (rubric-list (alist-get 'rubric-list darwin))

          (value "")

       )

    ;;(prin1 rubric-list)

    (setq fakevar (dolist (item  rubric-list value)

      ;;(prin1 item)

     ;;(setq value "hello")

(message "value is %s" value)

      (setq value (concat value (format "- %s \n" item)))))

(message "%s" fakevar)

value

       ;; (dolist (item rubric-list)

       ;; (message "%s" item))

     

     (org-lms-make-headings darwin students)

  )

#+end_src

#+RESULTS:

: - Organization 

: - Clarity of Argument 

: - Grammar and Spelling 

: - Grade 

: - See Attached Paper for further Comments 

* Plans (see issues in GH as well)

** STARTED Integrate with Canvas API

The Canvas API is described [[https://canvas.instructure.com/doc/api/file.object_ids.html][in the offocial docs]], which lives in a different form [[https://canvas.instructure.com/doc/api/live#!/courses.json/list_users_in_course_search_users_get_6][here]]. Here is a [[https://community.canvaslms.com/groups/canvas-developers/blog/2016/09/11/api-testing-postman][tutorial on using Postman to test canvas lms]], and an [[https://community.canvaslms.com/docs/DOC-14390-canvas-apis-getting-started-the-practical-ins-and-outs-gotchas-tips-and-tricks][official Getting Started guide]]. Here's a similar resouce [[https://canvas.instructure.com/courses/785215/pages/getting-started-with-the-api][organized as a course]]. Examples in these docs mostly use cURL. Instead we are using [[https://tkf.github.io/emacs-request/manual.html][request.el]] ([[https://github.com/tkf/emacs-request][github]]) and [[https://jakemccrary.com/blog/2014/07/04/using-emacs-to-explore-an-http-api/][restclient]]  ([[https://github.com/pashky/restclient.el][github]]) (where appropriate) for inspecting api requests. [[https://emacs.stackexchange.com/questions/2427/how-to-test-rest-api-with-emacs][helpful stackexchange intor to restclient]]. [[https://vxlabs.com/tag/request-el/][some advanced org-mode restclient shit]] to aspire to.

  I have had a hell of a time parsing api results; important to always set ~json-key-type~, ~json-object-type~, and ~json-array-type~ before invoking ~json-read~. In request this has to be done in the parser declaration which is a pain. Otherwise lists end up as vectors, which sucks b/c I don't knw how to use vectors in lisp!

Anyway, some progress being made in sample code in [[./Grading-template.org]], but still have abunch of progress to make on this front!!  

In case I forget, you [[https://community.canvaslms.com/docs/DOC-10806-4214724194][gneerate oauth tkens in the settings pane on quercus]]. 

** ACTION elimate remaining cruft

There's still some shitty junk in here 

** ACTION write tests

THis is abig one -- not sure how to do this!!

** DONE Set a "docroot" property i n the parent to make it eadier to find papers in the directory 

also makes it easier to give the directory w/ student papers & the headline different names

** ACTION generate tables that can be fed back into canvas

this would e nice!

** STARTED add in letter/numbber grade conversion

a little bit difficult

** DONE make it easier to make a template

generating assignments is too finicky right now. I'd like to be able to do it form the Assignments page (!!)

** ACTION Add some CSS

WOuld be nice if the marks were a bit easier to read in email clients

** WON'T DO Write a script to grab user.csv

and move it to the right place. But this in each repo or maybe just run from repo. 

** ACTION Make default messages for github assignments more comprehensible

Shouldn't be so har.d Also add all comments PRs if you can. 

Hig