@codingame/monaco-editor-wrapper 3.4.1 → 3.5.0

package/dist/ocaml2.js

@@ -1,903 +1,114 @@
-var name = "OCaml";
-var scopeName = "source.ocaml";
-var fileTypes = [
-	"ml",
-	"eliom",
-	".ocamlinit"
-];
-var patterns = [
-	{
-		include: "#directives"
-	},
-	{
-		include: "#comments"
-	},
-	{
-		include: "#strings"
-	},
-	{
-		include: "#characters"
-	},
-	{
-		include: "#attributes"
-	},
-	{
-		include: "#extensions"
-	},
+var autoClosingPairs = [
 	{
-		include: "#modules"
+		open: "{",
+		close: "}"
 	},
 	{
-		include: "#bindings"
+		open: "[",
+		close: "]"
 	},
 	{
-		include: "#operators"
+		open: "(",
+		close: ")"
 	},
 	{
-		include: "#keywords"
-	},
-	{
-		include: "#literals"
+		open: "\"",
+		close: "\"",
+		notIn: [
+			"string"
+		]
 	},
 	{
-		include: "#types"
+		open: "(*",
+		close: "*",
+		notIn: [
+			"string"
+		]
 	},
 	{
-		include: "#identifiers"
+		open: "[|",
+		close: "|",
+		notIn: [
+			"string"
+		]
 	}
 ];
-var repository = {
-	directives: {
-		patterns: [
-			{
-				comment: "line number directive",
-				begin: "^[[:space:]]*(#)[[:space:]]*([[:digit:]]+)",
-				end: "$",
-				beginCaptures: {
-					"1": {
-						name: "keyword.other.ocaml"
-					},
-					"2": {
-						name: "constant.numeric.decimal.integer.ocaml"
-					}
-				},
-				contentName: "comment.line.directive.ocaml"
-			},
-			{
-				comment: "toplevel directives",
-				patterns: [
-					{
-						comment: "general, loading codes",
-						begin: "^[[:space:]]*(#)[[:space:]]*(help|quit|cd|directory|remove_directory|load_rec|load|use|mod_use)",
-						end: "$",
-						beginCaptures: {
-							"1": {
-								name: "keyword.other.ocaml"
-							},
-							"2": {
-								name: "keyword.other.ocaml"
-							}
-						},
-						patterns: [
-							{
-								include: "#strings"
-							}
-						]
-					},
-					{
-						comment: "environment queries",
-						begin: "^[[:space:]]*(#)[[:space:]]*(show_class_type|show_class|show_exception|show_module_type|show_module|show_type|show_val|show)",
-						end: "$",
-						beginCaptures: {
-							"1": {
-								name: "keyword.other.ocaml"
-							},
-							"2": {
-								name: "keyword.other.ocaml"
-							}
-						},
-						patterns: [
-							{
-								include: "#types"
-							},
-							{
-								include: "#identifiers"
-							}
-						]
-					},
-					{
-						comment: "pretty-printing, tracing",
-						begin: "^[[:space:]]*(#)[[:space:]]*(install_printer|print_depth|print_length|remove_printer|trace|untrace_all|untrace)",
-						end: "$",
-						beginCaptures: {
-							"1": {
-								name: "keyword.other.ocaml"
-							},
-							"2": {
-								name: "keyword.other.ocaml"
-							}
-						},
-						patterns: [
-							{
-								include: "#literals"
-							},
-							{
-								include: "#identifiers"
-							}
-						]
-					},
-					{
-						comment: "compiler options",
-						begin: "^[[:space:]]*(#)[[:space:]]*(labels|ppx|principal|rectypes|warn_error|warnings)",
-						end: "$",
-						beginCaptures: {
-							"1": {
-								name: "keyword.other.ocaml"
-							},
-							"2": {
-								name: "keyword.other.ocaml"
-							}
-						},
-						patterns: [
-							{
-								include: "#strings"
-							},
-							{
-								include: "#literals"
-							}
-						]
-					}
-				]
-			},
-			{
-				comment: "topfind directives",
-				begin: "^[[:space:]]*(#)[[:space:]]*(require|list|camlp4o|camlp4r|predicates|thread)",
-				end: "$",
-				beginCaptures: {
-					"1": {
-						name: "keyword.other.ocaml"
-					},
-					"2": {
-						name: "keyword.other.ocaml"
-					}
-				},
-				patterns: [
-					{
-						include: "#strings"
-					}
-				]
-			},
-			{
-				comment: "cppo directives",
-				begin: "^[[:space:]]*(#)[[:space:]]*(define|undef|ifdef|ifndef|if|else|elif|endif|include|warning|error|ext|endext)",
-				end: "$",
-				beginCaptures: {
-					"1": {
-						name: "keyword.other.ocaml"
-					},
-					"2": {
-						name: "keyword.other.ocaml"
-					}
-				},
-				patterns: [
-					{
-						name: "keyword.other.ocaml",
-						match: "\\b(defined)\\b"
-					},
-					{
-						name: "keyword.other.ocaml",
-						match: "\\\\"
-					},
-					{
-						include: "#comments"
-					},
-					{
-						include: "#strings"
-					},
-					{
-						include: "#characters"
-					},
-					{
-						include: "#keywords"
-					},
-					{
-						include: "#operators"
-					},
-					{
-						include: "#literals"
-					},
-					{
-						include: "#types"
-					},
-					{
-						include: "#identifiers"
-					}
-				]
-			}
-		]
-	},
-	comments: {
-		patterns: [
-			{
-				comment: "empty comment",
-				name: "comment.block.ocaml",
-				match: "\\(\\*\\*\\)"
-			},
-			{
-				comment: "ocamldoc comment",
-				name: "comment.doc.ocaml",
-				begin: "\\(\\*\\*",
-				end: "\\*\\)",
-				patterns: [
-					{
-						include: "source.ocaml.ocamldoc#markup"
-					},
-					{
-						include: "#strings-in-comments"
-					},
-					{
-						include: "#comments"
-					}
-				]
-			},
-			{
-				comment: "Cinaps comment",
-				begin: "\\(\\*\\$",
-				end: "\\*\\)",
-				beginCaptures: [
-					{
-						name: "comment.cinaps.ocaml"
-					}
-				],
-				endCaptures: [
-					{
-						name: "comment.cinaps.ocaml"
-					}
-				],
-				patterns: [
-					{
-						include: "$self"
-					}
-				]
-			},
-			{
-				comment: "block comment",
-				name: "comment.block.ocaml",
-				begin: "\\(\\*",
-				end: "\\*\\)",
-				patterns: [
-					{
-						include: "#strings-in-comments"
-					},
-					{
-						include: "#comments"
-					}
-				]
-			}
-		]
-	},
-	"strings-in-comments": {
-		patterns: [
-			{
-				comment: "char literal",
-				match: "'(\\\\)?.'"
-			},
-			{
-				comment: "string literal",
-				begin: "\"",
-				end: "\"",
-				patterns: [
-					{
-						match: "\\\\\\\\"
-					},
-					{
-						match: "\\\\\""
-					}
-				]
-			},
-			{
-				comment: "quoted string literal",
-				begin: "\\{[[:lower:]_]*\\|",
-				end: "\\|[[:lower:]_]*\\}"
-			}
-		]
-	},
-	strings: {
-		patterns: [
-			{
-				comment: "quoted string literal",
-				name: "string.quoted.braced.ocaml",
-				begin: "\\{(%%?[[:alpha:]_][[:word:]']*(\\.[[:alpha:]_][[:word:]']*)*[[:space:]]*)?[[:lower:]_]*\\|",
-				end: "\\|[[:lower:]_]*\\}",
-				beginCaptures: {
-					"1": {
-						name: "keyword.other.extension.ocaml"
-					}
-				}
-			},
-			{
-				comment: "string literal",
-				name: "string.quoted.double.ocaml",
-				begin: "\"",
-				end: "\"",
-				patterns: [
-					{
-						comment: "escaped newline",
-						name: "constant.character.escape.ocaml",
-						match: "\\\\$"
-					},
-					{
-						comment: "escaped backslash",
-						name: "constant.character.escape.ocaml",
-						match: "\\\\\\\\"
-					},
-					{
-						comment: "escaped quote or whitespace",
-						name: "constant.character.escape.ocaml",
-						match: "\\\\[\"'ntbr ]"
-					},
-					{
-						comment: "character from decimal ASCII code",
-						name: "constant.character.escape.ocaml",
-						match: "\\\\[[:digit:]]{3}"
-					},
-					{
-						comment: "character from hexadecimal ASCII code",
-						name: "constant.character.escape.ocaml",
-						match: "\\\\x[[:xdigit:]]{2}"
-					},
-					{
-						comment: "character from octal ASCII code",
-						name: "constant.character.escape.ocaml",
-						match: "\\\\o[0-3][0-7]{2}"
-					},
-					{
-						comment: "unicode character escape sequence",
-						name: "constant.character.escape.ocaml",
-						match: "\\\\u\\{[[:xdigit:]]{1,6}\\}"
-					},
-					{
-						comment: "printf format string",
-						name: "constant.character.printf.ocaml",
-						match: "%[-0+ #]*([[:digit:]]+|\\*)?(.([[:digit:]]+|\\*))?[lLn]?[diunlLNxXosScCfFeEgGhHBbat!%@,]"
-					},
-					{
-						comment: "unknown escape sequence",
-						name: "invalid.illegal.unknown-escape.ocaml",
-						match: "\\\\."
-					}
-				]
-			}
-		]
-	},
-	characters: {
-		patterns: [
-			{
-				comment: "character literal from escaped backslash",
-				name: "string.quoted.single.ocaml",
-				match: "'(\\\\\\\\)'",
-				captures: {
-					"1": {
-						name: "constant.character.escape.ocaml"
-					}
-				}
-			},
-			{
-				comment: "character literal from escaped quote or whitespace",
-				name: "string.quoted.single.ocaml",
-				match: "'(\\\\[\"'ntbr ])'",
-				captures: {
-					"1": {
-						name: "constant.character.escape.ocaml"
-					}
-				}
-			},
-			{
-				comment: "character literal from decimal ASCII code",
-				name: "string.quoted.single.ocaml",
-				match: "'(\\\\[[:digit:]]{3})'",
-				captures: {
-					"1": {
-						name: "constant.character.escape.ocaml"
-					}
-				}
-			},
-			{
-				comment: "character literal from hexadecimal ASCII code",
-				name: "string.quoted.single.ocaml",
-				match: "'(\\\\x[[:xdigit:]]{2})'",
-				captures: {
-					"1": {
-						name: "constant.character.escape.ocaml"
-					}
-				}
-			},
-			{
-				comment: "character literal from octal ASCII code",
-				name: "string.quoted.single.ocaml",
-				match: "'(\\\\o[0-3][0-7]{2})'",
-				captures: {
-					"1": {
-						name: "constant.character.escape.ocaml"
-					}
-				}
-			},
-			{
-				comment: "character literal from unknown escape sequence",
-				name: "string.quoted.single.ocaml",
-				match: "'(\\\\.)'",
-				captures: {
-					"1": {
-						name: "invalid.illegal.unknown-escape.ocaml"
-					}
-				}
-			},
-			{
-				comment: "character literal",
-				name: "string.quoted.single.ocaml",
-				match: "'.'"
-			}
-		]
-	},
-	attributes: {
-		begin: "\\[(@|@@|@@@)[[:space:]]*([[:alpha:]_]+(\\.[[:word:]']+)*)",
-		end: "\\]",
-		beginCaptures: {
-			"1": {
-				name: "keyword.operator.attribute.ocaml"
-			},
-			"2": {
-				name: "keyword.other.attribute.ocaml",
-				patterns: [
-					{
-						name: "keyword.other.ocaml punctuation.other.period punctuation.separator.period",
-						match: "\\."
-					}
-				]
-			}
-		},
-		patterns: [
-			{
-				include: "$self"
-			}
-		]
-	},
-	extensions: {
-		begin: "\\[(%|%%)[[:space:]]*([[:alpha:]_]+(\\.[[:word:]']+)*)",
-		end: "\\]",
-		beginCaptures: {
-			"1": {
-				name: "keyword.operator.extension.ocaml"
-			},
-			"2": {
-				name: "keyword.other.extension.ocaml",
-				patterns: [
-					{
-						name: "keyword.other.ocaml punctuation.other.period punctuation.separator.period",
-						match: "\\."
-					}
-				]
-			}
-		},
-		patterns: [
-			{
-				include: "$self"
-			}
-		]
-	},
-	modules: {
-		patterns: [
-			{
-				begin: "\\b(sig)\\b",
-				end: "\\b(end)\\b",
-				beginCaptures: [
-					{
-						name: "keyword.other.ocaml"
-					}
-				],
-				endCaptures: [
-					{
-						name: "keyword.other.ocaml"
-					}
-				],
-				patterns: [
-					{
-						include: "source.ocaml.interface"
-					}
-				]
-			},
-			{
-				begin: "\\b(struct)\\b",
-				end: "\\b(end)\\b",
-				beginCaptures: [
-					{
-						name: "keyword.other.ocaml"
-					}
-				],
-				endCaptures: [
-					{
-						name: "keyword.other.ocaml"
-					}
-				],
-				patterns: [
-					{
-						include: "$self"
-					}
-				]
-			}
-		]
-	},
-	bindings: {
-		patterns: [
-			{
-				comment: "for loop",
-				match: "\\b(for)[[:space:]]+([[:lower:]_][[:word:]']*)",
-				captures: {
-					"1": {
-						name: "keyword.ocaml"
-					},
-					"2": {
-						name: "entity.name.function.binding.ocaml"
-					}
-				}
-			},
-			{
-				comment: "local open/exception/module",
-				match: "\\b(let)[[:space:]]+(open|exception|module)\\b(?!')",
-				captures: {
-					"1": {
-						name: "keyword.ocaml"
-					},
-					"2": {
-						name: "keyword.ocaml"
-					}
-				}
-			},
-			{
-				comment: "let expression",
-				match: "\\b(let)[[:space:]]+(?!lazy\\b(?!'))(rec[[:space:]]+)?(?!rec\\b(?!'))([[:lower:]_][[:word:]']*)(?![[:word:]'])[[:space:]]*(?!,|::|[[:space:]])",
-				captures: {
-					"1": {
-						name: "keyword.ocaml"
-					},
-					"2": {
-						name: "keyword.ocaml"
-					},
-					"3": {
-						name: "entity.name.function.binding.ocaml"
-					}
-				}
-			},
-			{
-				comment: "using binding operators",
-				match: "\\b(let|and)([$&*+\\-/=>@^|<][!?$&*+\\-/=>@^|%:]*)[[:space:]]*(?!lazy\\b(?!'))([[:lower:]_][[:word:]']*)(?![[:word:]'])[[:space:]]*(?!,|::|[[:space:]])",
-				captures: {
-					"1": {
-						name: "keyword.ocaml"
-					},
-					"2": {
-						name: "keyword.ocaml"
-					},
-					"3": {
-						name: "entity.name.function.binding.ocaml"
-					}
-				}
-			},
-			{
-				comment: "first class module packing",
-				match: "\\([[:space:]]*(val)[[:space:]]+([[:lower:]_][[:word:]']*)",
-				captures: {
-					"1": {
-						name: "keyword.ocaml"
-					},
-					"2": {
-						patterns: [
-							{
-								include: "$self"
-							}
-						]
-					}
-				}
-			},
-			{
-				comment: "locally abstract types",
-				match: "(?:\\(|(:))[[:space:]]*(type)((?:[[:space:]]+[[:lower:]_][[:word:]']*)+)",
-				captures: {
-					"1": {
-						name: "keyword.other.ocaml punctuation.other.colon punctuation.colon"
-					},
-					"2": {
-						name: "keyword.ocaml"
-					},
-					"3": {
-						name: "entity.name.function.binding.ocaml"
-					}
-				}
-			},
-			{
-				comment: "optional labeled argument with type",
-				begin: "(\\?)\\([[:space:]]*([[:lower:]_][[:word:]']*)",
-				beginCaptures: {
-					"1": {
-						name: "variable.parameter.optional.ocaml"
-					},
-					"2": {
-						name: "variable.parameter.optional.ocaml"
-					}
-				},
-				end: "\\)",
-				patterns: [
-					{
-						include: "$self"
-					}
-				]
-			},
-			{
-				comment: "labeled argument with type",
-				begin: "(~)\\([[:space:]]*([[:lower:]_][[:word:]']*)",
-				beginCaptures: {
-					"1": {
-						name: "variable.parameter.labeled.ocaml"
-					},
-					"2": {
-						name: "variable.parameter.labeled.ocaml"
-					}
-				},
-				end: "\\)",
-				patterns: [
-					{
-						include: "$self"
-					}
-				]
-			},
-			{
-				include: "source.ocaml.interface#bindings"
-			}
-		]
-	},
-	operators: {
-		patterns: [
-			{
-				comment: "binding operator",
-				name: "keyword.ocaml",
-				match: "\\b(let|and)[$&*+\\-/=>@^|<][!?$&*+\\-/=>@^|%:]*"
-			},
-			{
-				comment: "infix symbol",
-				name: "keyword.operator.ocaml",
-				match: "[$&*+\\-/=>@^%<][~!?$&*+\\-/=>@^|%<:.]*"
-			},
-			{
-				comment: "infix symbol that begins with vertical bar",
-				name: "keyword.operator.ocaml",
-				match: "\\|[~!?$&*+\\-/=>@^|%<:.]+"
-			},
-			{
-				comment: "vertical bar",
-				name: "keyword.other.ocaml",
-				match: "(?<!\\[)(\\|)(?!\\])"
-			},
-			{
-				comment: "infix symbol",
-				name: "keyword.operator.ocaml",
-				match: "#[~!?$&*+\\-/=>@^|%<:.]+"
-			},
-			{
-				comment: "prefix symbol",
-				name: "keyword.operator.ocaml",
-				match: "![~!?$&*+\\-/=>@^|%<:.]*"
-			},
-			{
-				comment: "prefix symbol",
-				name: "keyword.operator.ocaml",
-				match: "[?~][~!?$&*+\\-/=>@^|%<:.]+"
-			},
-			{
-				comment: "named operator",
-				name: "keyword.operator.ocaml",
-				match: "\\b(or|mod|land|lor|lxor|lsl|lsr|asr)\\b"
-			},
-			{
-				comment: "method invocation",
-				name: "keyword.other.ocaml",
-				match: "#"
-			},
-			{
-				comment: "type annotation",
-				name: "keyword.other.ocaml punctuation.other.colon punctuation.colon",
-				match: ":"
-			},
-			{
-				comment: "field accessor",
-				name: "keyword.other.ocaml punctuation.other.period punctuation.separator.period",
-				match: "\\."
-			},
-			{
-				comment: "semicolon separator",
-				name: "keyword.other.ocaml punctuation.separator.terminator punctuation.separator.semicolon",
-				match: ";"
-			},
-			{
-				comment: "comma separator",
-				name: "keyword.other.ocaml punctuation.comma punctuation.separator.comma",
-				match: ","
-			}
-		]
-	},
-	keywords: {
-		patterns: [
-			{
-				comment: "reserved ocaml keyword",
-				name: "keyword.other.ocaml",
-				match: "\\b(and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|match|method|module|mutable|new|nonrec|object|of|open|private|rec|sig|struct|then|to|try|type|val|virtual|when|while|with)\\b(?!')"
-			}
-		]
-	},
-	literals: {
-		patterns: [
-			{
-				comment: "boolean literal",
-				name: "constant.language.boolean.ocaml",
-				match: "\\b(true|false)\\b"
-			},
-			{
-				comment: "floating point decimal literal with exponent",
-				name: "constant.numeric.decimal.float.ocaml",
-				match: "\\b([[:digit:]][[:digit:]_]*(\\.[[:digit:]_]*)?[eE][+-]?[[:digit:]][[:digit:]_]*[g-zG-Z]?)\\b"
-			},
-			{
-				comment: "floating point decimal literal",
-				name: "constant.numeric.decimal.float.ocaml",
-				match: "\\b([[:digit:]][[:digit:]_]*)(\\.[[:digit:]_]*[g-zG-Z]?\\b|\\.)"
-			},
-			{
-				comment: "floating point hexadecimal literal with exponent part",
-				name: "constant.numeric.hexadecimal.float.ocaml",
-				match: "\\b((0x|0X)[[:xdigit:]][[:xdigit:]_]*(\\.[[:xdigit:]_]*)?[pP][+-]?[[:digit:]][[:digit:]_]*[g-zG-Z]?)\\b"
-			},
-			{
-				comment: "floating point hexadecimal literal",
-				name: "constant.numeric.hexadecimal.float.ocaml",
-				match: "\\b((0x|0X)[[:xdigit:]][[:xdigit:]_]*)(\\.[[:xdigit:]_]*[g-zG-Z]?\\b|\\.)"
-			},
-			{
-				comment: "decimal integer literal",
-				name: "constant.numeric.decimal.integer.ocaml",
-				match: "\\b([[:digit:]][[:digit:]_]*[lLng-zG-Z]?)\\b"
-			},
-			{
-				comment: "hexadecimal integer literal",
-				name: "constant.numeric.hexadecimal.integer.ocaml",
-				match: "\\b((0x|0X)[[:xdigit:]][[:xdigit:]_]*[lLng-zG-Z]?)\\b"
-			},
-			{
-				comment: "octal integer literal",
-				name: "constant.numeric.octal.integer.ocaml",
-				match: "\\b((0o|0O)[0-7][0-7_]*[lLng-zG-Z]?)\\b"
-			},
-			{
-				comment: "binary integer literal",
-				name: "constant.numeric.binary.integer.ocaml",
-				match: "\\b((0b|0B)[0-1][0-1_]*[lLng-zG-Z]?)\\b"
-			},
-			{
-				comment: "unit literal",
-				name: "constant.language.unit.ocaml",
-				match: "\\(\\)"
-			},
-			{
-				comment: "parentheses",
-				begin: "\\(",
-				end: "\\)",
-				patterns: [
-					{
-						include: "$self"
-					}
-				]
-			},
-			{
-				comment: "empty array",
-				name: "constant.language.array.ocaml",
-				match: "\\[\\|\\|\\]"
-			},
-			{
-				comment: "array",
-				begin: "\\[\\|",
-				end: "\\|\\]",
-				patterns: [
-					{
-						include: "$self"
-					}
-				]
-			},
-			{
-				comment: "empty list",
-				name: "constant.language.list.ocaml",
-				match: "\\[\\]"
-			},
-			{
-				comment: "list",
-				begin: "\\[",
-				end: "]",
-				patterns: [
-					{
-						include: "$self"
-					}
-				]
-			},
-			{
-				comment: "braces",
-				begin: "\\{",
-				end: "\\}",
-				patterns: [
-					{
-						include: "$self"
-					}
-				]
-			}
-		]
-	},
-	types: {
-		patterns: [
-			{
-				comment: "type parameter",
-				name: "storage.type.ocaml",
-				match: "'[[:alpha:]][[:word:]']*\\b|'_\\b"
-			},
-			{
-				comment: "weak type parameter",
-				name: "storage.type.weak.ocaml",
-				match: "'_[[:alpha:]][[:word:]']*\\b"
-			},
-			{
-				comment: "builtin type",
-				name: "support.type.ocaml",
-				match: "\\b(unit|bool|int|int32|int64|nativeint|float|char|bytes|string)\\b"
-			}
-		]
+var brackets = [
+	[
+		"{",
+		"}"
+	],
+	[
+		"[",
+		"]"
+	],
+	[
+		"(",
+		")"
+	],
+	[
+		"[|",
+		"|]"
+	]
+];
+var comments = {
+	blockComment: [
+		"(*",
+		"*)"
+	]
+};
+var surroundingPairs = [
+	[
+		"{",
+		"}"
+	],
+	[
+		"[",
+		"]"
+	],
+	[
+		"(",
+		")"
+	],
+	[
+		"'",
+		"'"
+	],
+	[
+		"\"",
+		"\""
+	]
+];
+var indentationRules = {
+	decreaseIndentPattern: "^\\s*(end|done|with|in|else)\\b|^\\s*;;",
+	increaseIndentPattern: "\\b(begin|object)\\s*$|\\blet [a-zA-Z0-9_-]+( [^ ]+)* =\\s*$|method!?[ \\t]+.*=[ \\t]*$|->[ \\t]*$|\\b(for|while)(_lwt)?[ \\t]+.*[ \\t]+do[ \\t]*$|(\\btry(_lwt)?$|\\bif\\s+.*\\sthen$|\\belse|[:=]\\s*sig|=\\s*struct)\\s*$",
+	indentNextLinePattern: "(?!\\bif.*then.*(else.*|(;|[ \\t]in)[ \\t]*$))\\bif|\\bthen[ \\t]*$|\\belse[ \\t]*$$"
+};
+var onEnterRules = [
+	{
+		beforeText: "\\(\\*\\*",
+		afterText: "\\*\\)",
+		action: {
+			indent: "none",
+			appendText: "    "
+		}
 	},
-	identifiers: {
-		patterns: [
-			{
-				comment: "wildcard underscore",
-				name: "constant.language.ocaml",
-				match: "\\b_\\b"
-			},
-			{
-				comment: "capital identifier for constructor, exception, or module",
-				name: "constant.language.capital-identifier.ocaml",
-				match: "\\b[[:upper:]][[:word:]']*('|\\b)"
-			},
-			{
-				comment: "lowercase identifier",
-				name: "source.ocaml",
-				match: "\\b[[:lower:]_][[:word:]']*('|\\b)"
-			},
-			{
-				comment: "polymorphic variant tag",
-				name: "constant.language.polymorphic-variant.ocaml",
-				match: "\\`[[:alpha:]][[:word:]']*\\b"
-			},
-			{
-				comment: "empty list (can be used as a constructor)",
-				name: "constant.language.list.ocaml",
-				match: "\\[\\]"
-			}
-		]
+	{
+		beforeText: "\\(\\*",
+		afterText: "\\*\\)",
+		action: {
+			indent: "none",
+			appendText: "   "
+		}
 	}
-};
-var information_for_contributors = [
-	"This file has been converted from https://github.com/ocamllabs/vscode-ocaml-platform/blob/master/",
-	"If you want to provide a fix or improvement, please create a pull request against the original repository.",
-	"Once accepted there, we are happy to receive an update request."
 ];
 var ocaml = {
-	name: name,
-	scopeName: scopeName,
-	fileTypes: fileTypes,
-	patterns: patterns,
-	repository: repository,
-	information_for_contributors: information_for_contributors
+	autoClosingPairs: autoClosingPairs,
+	brackets: brackets,
+	comments: comments,
+	surroundingPairs: surroundingPairs,
+	indentationRules: indentationRules,
+	onEnterRules: onEnterRules
 };
 
-export { ocaml as default, fileTypes, information_for_contributors, name, patterns, repository, scopeName };
+export { autoClosingPairs, brackets, comments, ocaml as default, indentationRules, onEnterRules, surroundingPairs };