SYMBOL INDEX (221 symbols across 8 files)

FILE: src/Application.js
  class ApplicationWidget (line 11) | class ApplicationWidget extends DocumentWidget {
    method constructor (line 16) | constructor(router) {
    method getURL (line 22) | getURL() {
    method handleEvent (line 28) | handleEvent(event) {
    method addListeners (line 69) | addListeners(document) {

FILE: src/Document.js
  class DocumentWidget (line 28) | class DocumentWidget extends Widget {
    method root (line 34) | static root(document) {
    method mount (line 45) | mount(root) {
    method fork (line 55) | fork(root) {
    method render (line 64) | render(state) {

FILE: src/Effect.js
  class None (line 11) | class None {
    method perform (line 12) | perform() {}
    method map (line 13) | map() {
  class Send (line 28) | class Send {
    method constructor (line 33) | constructor(message) {
    method perform (line 42) | perform(main) {
    method map (line 50) | map(tag) {
  class FX (line 58) | class FX {
    method constructor (line 64) | constructor(task, success, failure) {
    method execute (line 83) | async execute(main) {
    method perform (line 101) | perform(main) {
    method map (line 110) | map(tag) {
  class Batch (line 119) | class Batch {
    method constructor (line 124) | constructor(effects) {
    method perform (line 134) | perform(main) {
    method map (line 145) | map(tag) {
  class Tagged (line 160) | class Tagged {
    method constructor (line 165) | constructor(fx, tag) {
    method perform (line 184) | perform(main) {
    method link (line 192) | link(thread) {
    method unlink (line 198) | unlink(thread) {
    method linked (line 204) | linked(id) {
    method send (line 210) | send(message) {
    method map (line 218) | map(tag) {

FILE: src/Program.ts
  type Program (line 3) | interface Program<Message, State, View, Options> {
  type Router (line 9) | interface Router<Message> {
  type Application (line 14) | interface Application<Message, State, View, Options>
  type DocumentView (line 18) | interface DocumentView<T> {
  type RenderedDocument (line 23) | interface RenderedDocument<T> {

FILE: src/Task.ts
  type Phantom (line 1) | type Phantom<T> = T & { readonly kind: unique symbol }
  type ThreadID (line 3) | type ThreadID = Phantom<string>
  type Thread (line 5) | interface Thread {
  type Port (line 9) | interface Port<T> {
  type Main (line 13) | interface Main<message> extends Port<message> {
  type IO (line 19) | interface IO<T> {
  type Transaction (line 22) | type Transaction<message, state> = [state, IO<message>]
  type Sync (line 24) | interface Sync<T> {
  type Effect (line 28) | interface Effect<T> extends IO<T> {
  type AsyncResult (line 32) | interface AsyncResult<X, T> {
  type Task (line 36) | interface Task<X, T> {

FILE: src/VirtualDOM.d.ts
  type Doc (line 2) | interface Doc<T> {
  class Node (line 9) | class Node<T> {
  class Attribute (line 14) | class Attribute<T> {
  type Keyed (line 17) | type Keyed<T> = [string, T]
  type EventSource (line 24) | type EventSource<T> = Attribute<T> | Node<T>
  type EventNode (line 26) | type EventNode<E extends EventSource<unknown>> = E extends EventSource<i...
  type Decoder (line 76) | interface Decoder<In, Out> {
  type EncodedEvent (line 80) | type EncodedEvent =
  type DecodedEvent (line 87) | interface DecodedEvent<T> {
  type EventDecoder (line 93) | interface EventDecoder<T>
  class Delta (line 101) | class Delta {}

FILE: src/VirtualDOM.js
  constant TEXT (line 3) | const TEXT = "VirtualDOM.Text"
  constant NODE (line 4) | const NODE = "VirtualDOM.Node"
  constant KEYED_NODE (line 5) | const KEYED_NODE = "VirtualDOM.Keyed.Node"
  constant CUSTOM_NODE (line 6) | const CUSTOM_NODE = "VirtualDOM.Custom"
  constant CUSTOM_ELEMENT (line 7) | const CUSTOM_ELEMENT = "VirtualDOM.CustomElement"
  constant TAGGED_NODE (line 8) | const TAGGED_NODE = "VirtualDOM.Tagger"
  constant THUNK_NODE (line 9) | const THUNK_NODE = "VirtualDOM.Thunk"
  constant OP_REDRAW (line 11) | const OP_REDRAW = "VirtualDOM.OP.Redraw"
  constant OP_THUNK (line 12) | const OP_THUNK = "VirtualDOM.OP.Thunk"
  constant OP_TAGGER (line 13) | const OP_TAGGER = "VirtualDOM.OP.Tagger"
  constant OP_TEXT (line 14) | const OP_TEXT = "VirtualDOM.OP.Text"
  constant OP_FACTS (line 15) | const OP_FACTS = "VirtualDOM.OP.Facts"
  constant OP_CUSTOM (line 16) | const OP_CUSTOM = "VirtualDOM.OP.Custom"
  constant OP_REMOVE_LAST (line 17) | const OP_REMOVE_LAST = "VirtualDOM.OP.RemoveLast"
  constant OP_APPEND (line 18) | const OP_APPEND = "VirtualDOM.OP.Append"
  constant OP_REORDER (line 19) | const OP_REORDER = "VirtualDOM.OP.Reorder"
  constant OP_REMOVE (line 20) | const OP_REMOVE = "VirtualDOM.OP.Remove"
  constant OP_DELETE (line 21) | const OP_DELETE = "VirtualDOM.OP.Delete"
  constant OP_INSERT (line 22) | const OP_INSERT = "VirtualDOM.OP.Insert"
  constant OP_MOVE (line 23) | const OP_MOVE = "VirtualDOM.OP.Move"
  constant SETTING_EVENT (line 25) | const SETTING_EVENT = "VirtualDOM.Setting.Event"
  constant SETTING_STYLE (line 26) | const SETTING_STYLE = "VirtualDOM.Setting.Style"
  constant SETTING_PROPERTY (line 27) | const SETTING_PROPERTY = "VirtualDOM.Setting.Property"
  constant SETTING_ATTRIBUTE (line 28) | const SETTING_ATTRIBUTE = "VirtualDOM.Setting.Attribute"
  constant SETTING_ATTRIBUTE_NS (line 29) | const SETTING_ATTRIBUTE_NS = "VirtualDOM.Setting.AttributeNS"
  function appendChild (line 33) | function appendChild(parent, child) {
  class Text (line 50) | class Text {
    method constructor (line 51) | constructor(content) {
    method map (line 55) | map(tagger) {
    method toInnerHTML (line 58) | toInnerHTML() {
    method toOuterHTML (line 61) | toOuterHTML(indent) {
    method innerHTML (line 64) | get innerHTML() {
    method outerHTML (line 67) | get outerHTML() {
  class CustomElement (line 79) | class CustomElement {
    method constructor (line 80) | constructor(localName, elementConstructor, options, settings) {
    method map (line 88) | map(tagger) {
    method serializeSettings (line 91) | serializeSettings(key = "") {
    method toOuterHTML (line 94) | toOuterHTML(indent = "", key = "") {
    method toInnerHTML (line 97) | toInnerHTML(indent = "") {
    method outerHTML (line 100) | get outerHTML() {
    method innerHTML (line 103) | get innerHTML() {
  class Node (line 111) | class Node {
    method constructor (line 112) | constructor(localName, settings, children, namespace, descendantsCount) {
    method map (line 120) | map(tagger) {
    method toInnerHTML (line 123) | toInnerHTML(indent = "") {
    method serializeSettings (line 134) | serializeSettings(key) {
    method toOuterHTML (line 168) | toOuterHTML(indent = "", key = "") {
    method innerHTML (line 180) | get innerHTML() {
    method outerHTML (line 183) | get outerHTML() {
  class KeyedNode (line 218) | class KeyedNode {
    method constructor (line 219) | constructor(localName, facts, kids, namespace, descendantsCount) {
    method map (line 227) | map(tagger) {
    method serializeSettings (line 230) | serializeSettings(key = "") {
    method toOuterHTML (line 233) | toOuterHTML(indent = "", key = "") {
    method toInnerHTML (line 236) | toInnerHTML(indent = "") {
    method outerHTML (line 246) | get outerHTML() {
    method innerHTML (line 249) | get innerHTML() {
  class CustomNode (line 279) | class CustomNode {
    method constructor (line 280) | constructor(facts, model, render, diff) {
    method map (line 287) | map(tagger) {
    method serializeSettings (line 290) | serializeSettings(key = "") {
    method toOuterHTML (line 293) | toOuterHTML(indent = "", key = "") {
    method toInnerHTML (line 297) | toInnerHTML(indent = "") {
    method outerHTML (line 300) | get outerHTML() {
    method innerHTML (line 303) | get innerHTML() {
  class Doc (line 311) | class Doc {
    method constructor (line 312) | constructor(title, body) {
    method map (line 316) | map(tagger) {
    method toOuterHTML (line 319) | toOuterHTML(indent = "", key = "") {
    method toInnerHTML (line 323) | toInnerHTML(indent = "") {
    method outerHTML (line 332) | get outerHTML() {
    method innerHTML (line 335) | get innerHTML() {
  class TaggerNode (line 344) | class TaggerNode {
    method constructor (line 345) | constructor(tagger, node) {
    method map (line 351) | map(tagger) {
    method toOuterHTML (line 354) | toOuterHTML(indent = "", key = "") {
    method toInnerHTML (line 357) | toInnerHTML(indent = "") {
    method outerHTML (line 360) | get outerHTML() {
    method innerHTML (line 363) | get innerHTML() {
  class Thunk (line 372) | class Thunk {
    method constructor (line 373) | constructor(refs, thunk) {
    method map (line 379) | map(tagger) {
    method toNode (line 382) | toNode() {
    method toOuterHTML (line 392) | toOuterHTML(indent = "", key = "") {
    method toInnerHTML (line 395) | toInnerHTML(indent = "") {
    method outerHTML (line 399) | get outerHTML() {
    method innerHTML (line 402) | get innerHTML() {
  class VirtualDOMStyle (line 464) | class VirtualDOMStyle {
    method constructor (line 465) | constructor(key, value) {
    method map (line 470) | map(tag) {
  class VirtualDOMProperty (line 479) | class VirtualDOMProperty {
    method constructor (line 480) | constructor(key, value) {
    method map (line 485) | map(tag) {
  class VirtualDOMAttribute (line 494) | class VirtualDOMAttribute {
    method constructor (line 495) | constructor(key, value) {
    method map (line 500) | map(tag) {
  class VirtualDOMAttributeNS (line 507) | class VirtualDOMAttributeNS {
    method constructor (line 508) | constructor(namespace, key, value) {
    method map (line 513) | map(tag) {
  function noScript (line 523) | function noScript(localName) {
  function noOnOrFormAction (line 527) | function noOnOrFormAction(key) {
  function noInnerHtmlOrFormAction (line 531) | function noInnerHtmlOrFormAction(key) {
  function noJavaScriptUri__PROD (line 535) | function noJavaScriptUri__PROD(value) {
  function noJavaScriptUri__DEBUG (line 539) | function noJavaScriptUri__DEBUG(value) {
  function noJavaScriptOrHtmlUri__PROD (line 545) | function noJavaScriptOrHtmlUri__PROD(value) {
  function noJavaScriptOrHtmlUri__DEBUG (line 549) | function noJavaScriptOrHtmlUri__DEBUG(value) {
  class EventHandler (line 557) | class EventHandler {
    method constructor (line 558) | constructor(type, decoder, eventPhase, taggers) {
    method map (line 565) | map(tag) {
    method forwardEvent (line 569) | forwardEvent(event, eventTarget) {
    method equal (line 618) | equal(other) {
  function organizeFacts (line 630) | function organizeFacts(factList) {
  function addClass (line 688) | function addClass(object, key, newClass) {
  function render (line 695) | function render(doc, vNode, eventNode) {
  function applyFacts (line 800) | function applyFacts(domNode, eventNode, facts) {
  function applyStyles (line 845) | function applyStyles(domNode, styles) {
  function applyAttrs (line 855) | function applyAttrs(domNode, attrs) {
  function applyAttrsNS (line 866) | function applyAttrsNS(domNode, nsAttrs) {
  class EventRouter (line 880) | class EventRouter {
    method constructor (line 881) | constructor() {
    method handleEvent (line 886) | handleEvent(event) {
  function applyEvents (line 891) | function applyEvents(domNode, eventNode, events) {
  function diff (line 957) | function diff(x, y) {
  function pushPatch (line 963) | function pushPatch(patches, op, index, data) {
  function diffHelp (line 975) | function diffHelp(x, y, patches, index) {
  function pairwiseRefEqual (line 1102) | function pairwiseRefEqual(as, bs) {
  function diffNodes (line 1112) | function diffNodes(x, y, patches, index, diffKids) {
  function diffFacts (line 1131) | function diffFacts(x, y, category) {
  function diffKids (line 1194) | function diffKids(xParent, yParent, patches, index) {
  function diffKeyedKids (line 1226) | function diffKeyedKids(xParent, yParent, patches, rootIndex) {
  function insertNode (line 1371) | function insertNode(changes, localPatches, key, vnode, yIndex, inserts) {
  function removeNode (line 1409) | function removeNode(changes, localPatches, key, vnode, index) {
  function addDomNodes (line 1451) | function addDomNodes(domNode, vNode, patches, eventNode) {
  function addDomNodesHelp (line 1464) | function addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNod...
  function applyPatchesHelp (line 1563) | function applyPatchesHelp(rootDomNode, patches) {
  function applyPatch (line 1575) | function applyPatch(domNode, patch) {
  function applyPatchRedraw (line 1645) | function applyPatchRedraw(domNode, vNode, eventNode) {
  function applyPatchReorder (line 1660) | function applyPatchReorder(domNode, patch) {
  function applyPatchReorderEndInsertsHelp (line 1690) | function applyPatchReorderEndInsertsHelp(doc, endInserts, patch) {
  function virtualize (line 1709) | function virtualize(root) {
  function dekey (line 1756) | function dekey(keyedNode) {

FILE: src/Widget.js
  class MainThread (line 22) | class MainThread {
    method constructor (line 26) | constructor(root) {
    method send (line 45) | async send(message) {
    method sync (line 53) | sync(message) {
    method link (line 61) | link(thread) {
    method unlink (line 76) | unlink(thread) {
    method linked (line 91) | linked(threadID) {
  class Widget (line 108) | class Widget {
    method constructor (line 109) | constructor() {
    method version (line 123) | get version() {
    method fork (line 135) | static fork(self /*: Sync<a> */) /*: MainThread<a> */ {
    method sync (line 143) | sync(message) {
    method transact (line 150) | transact([state, fx] /*: Transaction<a, model> */) {
    method render (line 159) | render(_state) {}
    method mount (line 165) | mount(_root) {
    method toJSON (line 168) | toJSON() {
  class ElementWidget (line 182) | class ElementWidget extends Widget {
    method mount (line 187) | mount(root) {
    method render (line 194) | render(state) {