From 8d23a029c57be92a7aed0f18d9fcf1c931c1038e Mon Sep 17 00:00:00 2001
From: Sébastien Dailly <sebastien@dailly.me>
Date: Mon, 7 Feb 2022 16:40:45 +0100
Subject: Reformat

---
 editor/prosemirror/prosemirror.ml | 580 +++++++++++++++++---------------------
 1 file changed, 265 insertions(+), 315 deletions(-)

(limited to 'editor/prosemirror/prosemirror.ml')

diff --git a/editor/prosemirror/prosemirror.ml b/editor/prosemirror/prosemirror.ml
index c44d090..4d75f4c 100755
--- a/editor/prosemirror/prosemirror.ml
+++ b/editor/prosemirror/prosemirror.ml
@@ -5,435 +5,385 @@ type t = Jv.t
 
 type t' = t
 
-let v
-  : unit -> t
-  = fun () ->
-    Jv.get Jv.global "PM"
+let v : unit -> t = fun () -> Jv.get Jv.global "PM"
 
 module O = Bindings.TypedObject
 
 module Model = struct
-
   include Bindings.Model
 
   module Fragment = struct
-
     (** https://prosemirror.net/docs/ref/#model.Fragment^fromArray *)
-    let from_array
-      : t -> node Js.t Js.js_array Js.t -> fragment Js.t
-      = fun t elements ->
-        let model = Jv.get t "model" in
-        let class_ = Jv.get model "Fragment" in
-        Jv.call (Jv.Id.to_jv class_ ) "fromArray" [|Jv.Id.to_jv elements |]
-        |> Jv.Id.of_jv
-
+    let from_array : t -> node Js.t Js.js_array Js.t -> fragment Js.t =
+     fun t elements ->
+      let model = Jv.get t "model" in
+      let class_ = Jv.get model "Fragment" in
+      Jv.call (Jv.Id.to_jv class_) "fromArray" [| Jv.Id.to_jv elements |]
+      |> Jv.Id.of_jv
   end
 
   module Mark = struct
+    let _set_from : t -> 'a Js.t -> mark Js.t =
+     fun t element ->
+      let model = Jv.get t "model" in
+      let class_ = Jv.get model "Mark" in
+      Jv.call (Jv.Id.to_jv class_) "setFrom" [| Jv.Id.to_jv element |]
+      |> Jv.Id.of_jv
+
 
-    let _set_from
-      : t -> 'a Js.t -> mark Js.t
-      = fun t element ->
-        let model = Jv.get t "model" in
-        let class_ = Jv.get model "Mark" in
-        Jv.call (Jv.Id.to_jv class_ ) "setFrom" [|Jv.Id.to_jv element |]
-        |> Jv.Id.of_jv
+    let set_from_mark : t -> mark Js.t -> mark Js.t = _set_from
+  end
 
+  module DOMParser = struct
+    type parser = Jv.t
 
-    let set_from_mark
-      : t -> mark Js.t -> mark Js.t
-      = _set_from
+    let from_schema : t -> schema Js.t -> parser =
+     fun t schema ->
+      let model = Jv.get t "model" in
+      let parser = Jv.get model "DOMParser" in
+      Jv.call (Jv.Id.to_jv parser) "fromSchema" [| Jv.Id.to_jv schema |]
 
 
+    let parse : parser -> El.t -> node Js.t =
+     fun dom_parser el ->
+      Jv.call dom_parser "parse" [| Jv.Id.to_jv el |] |> Jv.Id.of_jv
   end
 
-  module DOMParser = struct
+  let schema_spec :
+         node_spec Bindings.ordered_map Js.t
+      -> mark_spec Bindings.ordered_map Js.t option
+      -> string option
+      -> schema_spec Js.t =
+   fun nodes marks_opt topNode_opt ->
+    let marks = Jv.of_option ~none:Jv.null Jv.Id.to_jv marks_opt
+    and topNode = Jv.of_option ~none:Jv.null Jv.of_string topNode_opt in
+    Jv.obj
+      [| ("nodes", Jv.Id.to_jv nodes); ("marks", marks); ("topNode", topNode) |]
+    |> Jv.Id.of_jv
 
 
-    type parser = Jv.t
+  let schema : t -> schema_spec Js.t -> schema Js.t =
+   fun t spec ->
+    let model = Jv.get t "model" in
+    Jv.new' (Jv.get model "Schema") [| Jv.Id.to_jv spec |] |> Jv.Id.of_jv
 
-    let from_schema
-      : t -> schema Js.t -> parser
-      = fun t schema ->
-        let model = Jv.get t "model" in
-        let parser = Jv.get model "DOMParser" in
-        Jv.call (Jv.Id.to_jv parser) "fromSchema" [|Jv.Id.to_jv schema|]
 
-    let parse
-      : parser -> El.t -> node Js.t
-      = fun dom_parser el ->
-        Jv.call dom_parser "parse" [|Jv.Id.to_jv el|]
-        |> Jv.Id.of_jv
+  let empty_fragment : t -> fragment Js.t =
+   fun t ->
+    let model = Jv.get t "model" in
+    let fragment = Jv.get model "Fragment" in
+    Jv.get fragment "empty" |> Jv.Id.of_jv
 
-  end
 
-  let schema_spec:
-    node_spec Bindings.ordered_map Js.t
-    -> mark_spec Bindings.ordered_map Js.t option
-    -> string option
-    -> schema_spec Js.t
-    = fun nodes marks_opt topNode_opt ->
-      let marks = Jv.of_option ~none:Jv.null Jv.Id.to_jv marks_opt
-      and topNode = Jv.of_option ~none:Jv.null Jv.of_string topNode_opt in
-      Jv.obj
-        [| "nodes", (Jv.Id.to_jv nodes)
-         ; "marks", marks
-         ; "topNode", topNode
-        |]
-      |> Jv.Id.of_jv
+  module Dom_output_spec = struct
+    let v :
+        ?attrs:< .. > -> string -> domOutputSpec Js.t list -> domOutputSpec Js.t
+        =
+     fun ?attrs name elems ->
+      let elems =
+        match attrs with
+        | None -> elems
+        | Some v -> Jv.Id.(of_jv @@ to_jv @@ v) :: elems
+      in
 
+      let elems = (Jv.Id.of_jv @@ Jv.of_string name) :: elems in
+      Jv.of_list Jv.Id.to_jv elems |> Jv.Id.to_jv |> Jv.Id.of_jv
 
-  let schema
-    : t -> schema_spec Js.t -> schema Js.t
-    = fun t spec ->
-      let model = Jv.get t "model" in
-      Jv.new' (Jv.get model "Schema") [| Jv.Id.to_jv spec |]
-      |> Jv.Id.of_jv
 
+    let hole : domOutputSpec Js.t = 0 |> Jv.Id.to_jv |> Jv.Id.of_jv
 
-  let empty_fragment
-    : t -> fragment Js.t
-    = fun t ->
-      let model = Jv.get t "model" in
-      let fragment = Jv.get model "Fragment" in
-      Jv.get fragment "empty"
-      |> Jv.Id.of_jv
+    let of_ : 'a -> domOutputSpec Js.t =
+     fun elem -> elem |> Jv.Id.to_jv |> Jv.Id.of_jv
 
-  module Dom_output_spec = struct
 
-    let v
-      : ?attrs:< .. > -> string -> domOutputSpec Js.t list -> domOutputSpec Js.t
-      = fun ?attrs name elems ->
-
-        let elems = match attrs with
-          | None -> elems
-          | Some v -> Jv.Id.(of_jv @@ to_jv @@ v)::elems in
-
-        let elems = (Jv.Id.of_jv @@ Jv.of_string name)::elems in
-        (Jv.of_list Jv.Id.to_jv elems)
-        |> Jv.Id.to_jv
-        |> Jv.Id.of_jv
-
-    let hole
-      : domOutputSpec Js.t
-      = 0
-        |> Jv.Id.to_jv
-        |> Jv.Id.of_jv
-
-    let of_
-      : 'a -> domOutputSpec Js.t
-      = fun elem ->
-        elem
-        |> Jv.Id.to_jv
-        |> Jv.Id.of_jv
-
-    let of_el
-      : Brr.El.t -> domOutputSpec Js.t
-      = of_
-
-    let of_jstr
-      : Jstr.t -> domOutputSpec Js.t
-      = of_
-
-    let of_obj
-      : < dom: node Js.t Js.readonly_prop ; contentDOM : node Js.t Js.opt Js.readonly_prop > Js.t -> domOutputSpec Js.t
-      = of_
-  end
+    let of_el : Brr.El.t -> domOutputSpec Js.t = of_
 
-  module ParseRule = struct
+    let of_jstr : Jstr.t -> domOutputSpec Js.t = of_
 
-    let tag
-      : Jstr.t -> parse_rule Js.t
-      = fun name ->
-        Jv.obj [| "tag", Jv.of_jstr name |]
-        |> Jv.Id.of_jv
+    let of_obj :
+           < dom : node Js.t Js.readonly_prop
+           ; contentDOM : node Js.t Js.opt Js.readonly_prop >
+           Js.t
+        -> domOutputSpec Js.t =
+      of_
+  end
 
+  module ParseRule = struct
+    let tag : Jstr.t -> parse_rule Js.t =
+     fun name -> Jv.obj [| ("tag", Jv.of_jstr name) |] |> Jv.Id.of_jv
   end
 end
 
 module State = struct
-
   include Bindings.State
 
-  let configuration_prop
-    : unit -> configuration_prop Js.t
-    = fun () -> Js.Unsafe.obj [||]
+  let configuration_prop : unit -> configuration_prop Js.t =
+   fun () -> Js.Unsafe.obj [||]
 
-  let creation_prop
-    : unit -> creation_prop Js.t
-    = fun () -> Js.Unsafe.obj [||]
 
-  let create
-    : t -> creation_prop Js.t -> editor_state Js.t
-    = fun t props ->
-      let state = Jv.get t "state" in
-      let editor_state = Jv.get state "EditorState" in
-      Jv.call editor_state "create" [|Jv.Id.to_jv props|]
-      |> Jv.Id.of_jv
+  let creation_prop : unit -> creation_prop Js.t = fun () -> Js.Unsafe.obj [||]
 
-  let fromJSON
-    : t -> configuration_prop Js.t -> Brr.Json.t -> editor_state Js.t
-    = fun t config json ->
-      let state = Jv.get t "state" in
-      let editor_state = Jv.get state "EditorState" in
-      Jv.call editor_state "fromJSON" [|Jv.Id.to_jv config ; json |]
-      |> Jv.Id.of_jv
+  let create : t -> creation_prop Js.t -> editor_state Js.t =
+   fun t props ->
+    let state = Jv.get t "state" in
+    let editor_state = Jv.get state "EditorState" in
+    Jv.call editor_state "create" [| Jv.Id.to_jv props |] |> Jv.Id.of_jv
 
-  let selection_from
-    : selection Js.t -> Model.resolved_pos Js.t
-    = fun selection ->
-      Jv.Id.(of_jv @@ Jv.get (to_jv selection) "$from")
-
-  let selection_to
-    : selection Js.t -> Model.resolved_pos Js.t
-    = fun selection ->
-      Jv.Id.(of_jv @@ Jv.get (to_jv selection) "$to")
-
-  let node_selection
-    : t -> Model.resolved_pos Js.t -> node_selection Js.t
-    = fun t pos ->
-      let state = Jv.get t "state" in
-      Jv.new' (Jv.get state "NodeSelection") [| Jv.Id.to_jv pos |]
-      |> Jv.Id.of_jv
 
-  let is_selectable
-    : t -> Model.node Js.t -> bool Js.t
-    = fun t node ->
-      let selection = Jv.get (Jv.get t "state") "NodeSelection" in
-      Jv.call selection "isSelectable" [|Jv.Id.to_jv node|]
-      |> Jv.Id.of_jv
+  let fromJSON : t -> configuration_prop Js.t -> Brr.Json.t -> editor_state Js.t
+      =
+   fun t config json ->
+    let state = Jv.get t "state" in
+    let editor_state = Jv.get state "EditorState" in
+    Jv.call editor_state "fromJSON" [| Jv.Id.to_jv config; json |]
+    |> Jv.Id.of_jv
 
-  let selection_at_start
-    : t-> Model.node Js.t -> selection Js.t
-    = fun t node ->
-      let selection = Jv.get (Jv.get t "state") "NodeSelection" in
-      Jv.call selection "atStart" [|Jv.Id.to_jv node|]
-      |> Jv.Id.of_jv
 
+  let selection_from : selection Js.t -> Model.resolved_pos Js.t =
+   fun selection -> Jv.Id.(of_jv @@ Jv.get (to_jv selection) "$from")
 
-  let create_node_selection
-    : t -> Model.node Js.t -> int -> node_selection Js.t
-    = fun t doc number ->
-      let state = Jv.get t "state" in
-      Jv.call (Jv.get state "NodeSelection") "create" Jv.Id.[|to_jv doc; Jv.of_int number|]
-      |> Jv.Id.of_jv
 
-  let create_text_selection
-    : t -> Model.node Js.t -> int -> node_selection Js.t
-    = fun t doc number ->
-      let state = Jv.get t "state" in
-      Jv.call (Jv.get state "TextSelection") "create" Jv.Id.[|to_jv doc; Jv.of_int number|]
-      |> Jv.Id.of_jv
+  let selection_to : selection Js.t -> Model.resolved_pos Js.t =
+   fun selection -> Jv.Id.(of_jv @@ Jv.get (to_jv selection) "$to")
+
+
+  let node_selection : t -> Model.resolved_pos Js.t -> node_selection Js.t =
+   fun t pos ->
+    let state = Jv.get t "state" in
+    Jv.new' (Jv.get state "NodeSelection") [| Jv.Id.to_jv pos |] |> Jv.Id.of_jv
+
+
+  let is_selectable : t -> Model.node Js.t -> bool Js.t =
+   fun t node ->
+    let selection = Jv.get (Jv.get t "state") "NodeSelection" in
+    Jv.call selection "isSelectable" [| Jv.Id.to_jv node |] |> Jv.Id.of_jv
+
+
+  let selection_at_start : t -> Model.node Js.t -> selection Js.t =
+   fun t node ->
+    let selection = Jv.get (Jv.get t "state") "NodeSelection" in
+    Jv.call selection "atStart" [| Jv.Id.to_jv node |] |> Jv.Id.of_jv
+
+
+  let create_node_selection : t -> Model.node Js.t -> int -> node_selection Js.t
+      =
+   fun t doc number ->
+    let state = Jv.get t "state" in
+    Jv.call
+      (Jv.get state "NodeSelection")
+      "create"
+      Jv.Id.[| to_jv doc; Jv.of_int number |]
+    |> Jv.Id.of_jv
+
+
+  let create_text_selection : t -> Model.node Js.t -> int -> node_selection Js.t
+      =
+   fun t doc number ->
+    let state = Jv.get t "state" in
+    Jv.call
+      (Jv.get state "TextSelection")
+      "create"
+      Jv.Id.[| to_jv doc; Jv.of_int number |]
+    |> Jv.Id.of_jv
+
+
+  let cursor : selection Js.t -> Model.resolved_pos Js.t Js.opt =
+   fun selection -> Jv.Id.(of_jv @@ Jv.get (to_jv selection) "$cursor")
 
-  let cursor
-    : selection Js.t -> Model.resolved_pos Js.t Js.opt
-    = fun selection ->
-      Jv.Id.(of_jv @@ Jv.get (to_jv selection) "$cursor")
 
-  let create_str_meta_data
-    : Jstr.t -> 'a meta_data Js.t
-    = Obj.magic
+  let create_str_meta_data : Jstr.t -> 'a meta_data Js.t = Obj.magic
 end
 
 (* Editor view *)
 
 module View = struct
-
   module EditorProps = struct
     type t = Jv.t
   end
 
   include Bindings.View
-  let direct_editor_props
-    : unit -> direct_editor_props Js.t
-    = fun () -> Js.Unsafe.obj [||]
-
-  let editor_view
-    : t -> El.t -> direct_editor_props Js.t -> editor_view Js.t
-    = fun t node props ->
-      Jv.new' (Jv.get (Jv.get t "view") "EditorView") [|Jv.Id.to_jv node ; Jv.Id.to_jv props|]
-      |> Jv.Id.of_jv
 
+  let direct_editor_props : unit -> direct_editor_props Js.t =
+   fun () -> Js.Unsafe.obj [||]
+
+
+  let editor_view : t -> El.t -> direct_editor_props Js.t -> editor_view Js.t =
+   fun t node props ->
+    Jv.new'
+      (Jv.get (Jv.get t "view") "EditorView")
+      [| Jv.Id.to_jv node; Jv.Id.to_jv props |]
+    |> Jv.Id.of_jv
 end
 
 module Transform = struct
-
   include Bindings.Transform
 
-  let offset
-    : t -> int -> step_map Js.t
-    = fun t n ->
-      let stepmap = Jv.get (Jv.get t "transform") "StepMap" in
-      Jv.call stepmap "offset" [|Jv.Id.to_jv n|]
-      |> Jv.Id.of_jv
-
-  let insertPoint
-    : t -> Model.node Js.t -> pos:int -> Model.node_type Js.t -> int Js.opt
-    = fun t node ~pos node_t ->
-      let transform = Jv.get t "transform" in
-      Jv.call transform "insertPoint" Jv.Id.[|to_jv node ; to_jv pos; to_jv node_t|]
-      |> Jv.Id.of_jv
-
+  let offset : t -> int -> step_map Js.t =
+   fun t n ->
+    let stepmap = Jv.get (Jv.get t "transform") "StepMap" in
+    Jv.call stepmap "offset" [| Jv.Id.to_jv n |] |> Jv.Id.of_jv
+
+
+  let insertPoint :
+      t -> Model.node Js.t -> pos:int -> Model.node_type Js.t -> int Js.opt =
+   fun t node ~pos node_t ->
+    let transform = Jv.get t "transform" in
+    Jv.call
+      transform
+      "insertPoint"
+      Jv.Id.[| to_jv node; to_jv pos; to_jv node_t |]
+    |> Jv.Id.of_jv
 end
 
 module Commands = struct
-
   type t = State.editor_state Js.t -> State.dispatch Js.opt -> bool Js.t
 
-  let baseKeymap
-    : t' -> (string * t) array
-    = fun t ->
-      Jv.get (Jv.get t "commands") "baseKeymap"
-      |> Jv.Id.of_jv
+  let baseKeymap : t' -> (string * t) array =
+   fun t -> Jv.get (Jv.get t "commands") "baseKeymap" |> Jv.Id.of_jv
 
-  let set_block_type
-    : t' -> Model.node_type Js.t -> < .. > Js.t Js.opt -> t
-    = fun t node props ->
-      Jv.call (Jv.get t "commands") "setBlockType" Jv.Id.[| to_jv node ; to_jv props |]
-      |> Jv.Id.of_jv
 
-  let toggle_mark
-    : t' -> Model.mark_type Js.t -> < .. > Js.t Js.opt -> t
-    = fun t mark props ->
-      Jv.call (Jv.get t "commands") "toggleMark" Jv.Id.[| to_jv mark ; to_jv props |]
-      |> Jv.Id.of_jv
+  let set_block_type : t' -> Model.node_type Js.t -> < .. > Js.t Js.opt -> t =
+   fun t node props ->
+    Jv.call
+      (Jv.get t "commands")
+      "setBlockType"
+      Jv.Id.[| to_jv node; to_jv props |]
+    |> Jv.Id.of_jv
 
 
+  let toggle_mark : t' -> Model.mark_type Js.t -> < .. > Js.t Js.opt -> t =
+   fun t mark props ->
+    Jv.call
+      (Jv.get t "commands")
+      "toggleMark"
+      Jv.Id.[| to_jv mark; to_jv props |]
+    |> Jv.Id.of_jv
 end
 
-
 module History = struct
-
   include Bindings.History
 
-  let history_prop
-    : unit -> history_prop Js.t
-    = fun () -> Js.Unsafe.obj [||]
+  let history_prop : unit -> history_prop Js.t = fun () -> Js.Unsafe.obj [||]
 
-  let history
-    : t -> history_prop Js.t -> State.plugin Js.t
-    = fun t props ->
-      Jv.call (Jv.get t "history") "history" [|Jv.Id.to_jv props|]
-      |> Jv.Id.of_jv
+  let history : t -> history_prop Js.t -> State.plugin Js.t =
+   fun t props ->
+    Jv.call (Jv.get t "history") "history" [| Jv.Id.to_jv props |]
+    |> Jv.Id.of_jv
 
-  let undo
-    : t -> Commands.t
-    = fun t state fn ->
-      Jv.call (Jv.get t "history") "undo" [|Jv.Id.to_jv state; Jv.repr fn|]
-      |> Jv.Id.of_jv
 
-  let redo
-    : t -> Commands.t
-    = fun t state fn ->
-      Jv.call (Jv.get t "history") "redo" [|Jv.Id.to_jv state; Jv.repr fn|]
-      |> Jv.Id.of_jv
-end
+  let undo : t -> Commands.t =
+   fun t state fn ->
+    Jv.call (Jv.get t "history") "undo" [| Jv.Id.to_jv state; Jv.repr fn |]
+    |> Jv.Id.of_jv
 
-module Keymap = struct
 
-  let keymap
-    : t -> (string * Commands.t) array -> State.plugin Js.t
-    = fun t props ->
-      let props = Jv.obj @@ Array.map (fun (id, f) -> (id, Jv.repr f)) props in
-      Jv.call (Jv.get t "keymap") "keymap" [|props|]
-      |> Jv.Id.of_jv
+  let redo : t -> Commands.t =
+   fun t state fn ->
+    Jv.call (Jv.get t "history") "redo" [| Jv.Id.to_jv state; Jv.repr fn |]
+    |> Jv.Id.of_jv
+end
 
+module Keymap = struct
+  let keymap : t -> (string * Commands.t) array -> State.plugin Js.t =
+   fun t props ->
+    let props = Jv.obj @@ Array.map (fun (id, f) -> (id, Jv.repr f)) props in
+    Jv.call (Jv.get t "keymap") "keymap" [| props |] |> Jv.Id.of_jv
 end
 
 module InputRule = struct
-
   type input_rule
 
-  let create
-    : t -> Js.regExp Js.t -> fn:(State.editor_state Js.t -> Jstr.t Js.js_array Js.t -> from:int -> to_:int -> State.transaction Js.t Js.opt) Js.callback -> input_rule Js.t
-    = fun t match' ~fn ->
-      Jv.new' (Jv.get (Jv.get t "inputrules") "InputRule") [|Jv.Id.to_jv match' ; Jv.Id.to_jv fn|]
-      |> Jv.Id.of_jv
-
-  let to_plugin
-    : t -> input_rule Js.t Js.js_array Js.t -> State.plugin Js.t
-    = fun t rules ->
-      let obj = Jv.obj [|("rules", Jv.Id.to_jv rules)|] in
-      Jv.call (Jv.get t "inputrules") "inputRules" [| obj |]
-      |> Jv.Id.of_jv
-
+  (** Create a new inputRule. 
+
+  The callback is called with the following elements :
+      - the editor state
+      - the elements matched by the regex
+      - starting position 
+      - ending position
+
+  and shall return a transaction if any modifications are applied. *)
+  let create :
+         t
+      -> Js.regExp Js.t
+      -> fn:
+           (   State.editor_state Js.t
+            -> Jstr.t Js.js_array Js.t
+            -> from:int
+            -> to_:int
+            -> State.transaction Js.t Js.opt )
+           Js.callback
+      -> input_rule Js.t =
+   fun t match' ~fn ->
+    Jv.new'
+      (Jv.get (Jv.get t "inputrules") "InputRule")
+      [| Jv.Id.to_jv match'; Jv.Id.to_jv fn |]
+    |> Jv.Id.of_jv
+
+
+  let to_plugin : t -> input_rule Js.t Js.js_array Js.t -> State.plugin Js.t =
+   fun t rules ->
+    let obj = Jv.obj [| ("rules", Jv.Id.to_jv rules) |] in
+    Jv.call (Jv.get t "inputrules") "inputRules" [| obj |] |> Jv.Id.of_jv
 end
 
 module SchemaBasic = struct
-
   include Bindings.SchemaBasic
 
-  let schema
-    : t -> Model.schema Js.t
-    = fun t ->
-      Jv.get (Jv.get t "schema_basic") "schema"
-      |> Jv.Id.of_jv
+  let schema : t -> Model.schema Js.t =
+   fun t -> Jv.get (Jv.get t "schema_basic") "schema" |> Jv.Id.of_jv
 
-  let nodes
-    : t -> nodes Js.t
-    = fun t ->
-      Jv.get (Jv.get t "schema_basic") "nodes"
-      |> Jv.Id.of_jv
 
+  let nodes : t -> nodes Js.t =
+   fun t -> Jv.get (Jv.get t "schema_basic") "nodes" |> Jv.Id.of_jv
 end
 
 module SchemaList = struct
-
-  let add_list_nodes
-    : t -> Model.node_spec Bindings.ordered_map Js.t -> Jstr.t -> Jstr.t option -> Model.node_spec Bindings.ordered_map Js.t
-    = fun t nodes item_content list_group_opt ->
-      let schema_list = Jv.get t "schema_list" in
-
-      let list_group = Jv.of_option ~none:Jv.null Jv.of_jstr list_group_opt in
-
-      Jv.call schema_list "addListNodes"
-        [|Jv.Id.to_jv nodes
-         ; Jv.of_jstr item_content
-         ; list_group |]
-      |> Jv.Id.of_jv
-
+  let add_list_nodes :
+         t
+      -> Model.node_spec Bindings.ordered_map Js.t
+      -> Jstr.t
+      -> Jstr.t option
+      -> Model.node_spec Bindings.ordered_map Js.t =
+   fun t nodes item_content list_group_opt ->
+    let schema_list = Jv.get t "schema_list" in
+
+    let list_group = Jv.of_option ~none:Jv.null Jv.of_jstr list_group_opt in
+
+    Jv.call
+      schema_list
+      "addListNodes"
+      [| Jv.Id.to_jv nodes; Jv.of_jstr item_content; list_group |]
+    |> Jv.Id.of_jv
 end
 
 module Menu = struct
-
   include Bindings.Menu
 
-  let menuItemSpec
-    : unit -> menuItemSpec Js.t
-    = fun () -> Js.Unsafe.obj [||]
-
-  let menu_item
-    : t -> menuItemSpec Js.t -> menuItem Js.t
-    = fun t spec ->
-      let menu = Jv.get t "menu" in
-      Jv.new' (Jv.get menu "MenuItem") [| Jv.Id.to_jv spec |]
-      |> Jv.Id.of_jv
+  let menuItemSpec : unit -> menuItemSpec Js.t = fun () -> Js.Unsafe.obj [||]
 
+  let menu_item : t -> menuItemSpec Js.t -> menuItem Js.t =
+   fun t spec ->
+    let menu = Jv.get t "menu" in
+    Jv.new' (Jv.get menu "MenuItem") [| Jv.Id.to_jv spec |] |> Jv.Id.of_jv
 end
 
 (* Example Setup *)
 
 module Example = struct
-
   include Bindings.Example
 
-  let options
-    : Model.schema Js.t -> options Js.t
-    = fun schema ->
-      Jv.obj [|("schema", Jv.Id.to_jv schema)|]
-      |> Jv.Id.of_jv
+  let options : Model.schema Js.t -> options Js.t =
+   fun schema -> Jv.obj [| ("schema", Jv.Id.to_jv schema) |] |> Jv.Id.of_jv
 
-  let example_setup
-    : t -> options Js.t -> State.plugin Js.t Js.js_array Js.t
-    = fun t options ->
-      let setup = Jv.get t "example_setup" in
-      Jv.call setup "exampleSetup" [|Jv.Id.to_jv options|]
-      |> Jv.Id.of_jv
 
-  let buildMenuItems
-    : t -> Model.schema Js.t -> menuItems Js.t
-    = fun t schema ->
-      let setup = Jv.get t "example_setup" in
-      Jv.call setup "buildMenuItems" [|Jv.Id.to_jv schema|]
-      |> Jv.Id.of_jv
+  let example_setup : t -> options Js.t -> State.plugin Js.t Js.js_array Js.t =
+   fun t options ->
+    let setup = Jv.get t "example_setup" in
+    Jv.call setup "exampleSetup" [| Jv.Id.to_jv options |] |> Jv.Id.of_jv
+
+
+  let buildMenuItems : t -> Model.schema Js.t -> menuItems Js.t =
+   fun t schema ->
+    let setup = Jv.get t "example_setup" in
+    Jv.call setup "buildMenuItems" [| Jv.Id.to_jv schema |] |> Jv.Id.of_jv
 end
-- 
cgit v1.2.3