RubyGems - erp_app - Versions diffs - 3.0.0 → 3.0.1 - Mend

erp_app 3.0.0 → 3.0.1

Files changed (909) hide show

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/compress.html ADDED Viewed

@@ -0,0 +1,169 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+  <head>
+    <title>CodeMirror: Compression Helper</title>
+    <link rel="stylesheet" type="text/css" href="css/docs.css"/>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+    <style type="text/css">
+    </style>
+  </head>
+  <body>
+<h1><span class="logo-braces">{ }</span> <a href="http://codemirror.net/">CodeMirror</a></h1>
+<pre class="grey">
+<img src="css/baboon.png" class="logo" alt="logo"/>/* Script compression
+   helper */
+</pre>
+    <p>The CodeMirror scripts, as distributed, are many, and full of
+    comments. To optimize page loading, it is recommended to
+    concatenate the scripts loaded in the CodeMirror frame, and
+    compress them. This page may be useful if you intend to do this:
+    it provides an interface to two different minifiers, <a
+    href="http://github.com/mishoo/UglifyJS/">UglifyJS</a> and
+    Google's <a href="http://closure-compiler.appspot.com/">Closure
+    compiler</a>, allowing you to easily feed them CodeMirror
+    scripts.</p>
+    <p>You will have to compress <code>codemirror.js</code>
+    separately, since that will be loaded into the top-level page from
+    which you use CodeMirror. Inside the frame, the
+    <code>parserfile</code> and <code>basefiles</code> options control
+    which files are loaded. If you combine the parser(s) you need with
+    the basefiles, you can set <code>basefiles</code> to point at your
+    compressed file, and leave <code>parserfiles</code> at
+    <code>[]</code>.</p>
+    <p>For example, you have a page that uses CodeMirror to edit some
+    JavaScript code. You could save a minimized version of
+    <code>codemirror.js</code> as <code>codemirror_min.js</code>, and
+    include that (with a <code>&lt;script></code> tag) in your page.
+    Next, you compress all the files under "In-frame base code", plus
+    <code>tokenizejavascript.js</code> and
+    <code>parsejavascript.js</code> into
+    <code>codemirror_base.js</code>, and load the editor like
+    this:</p>
+    <pre class="code">CodeMirror.fromTextArea("mytextarea", {
+  basefiles: ["js/codemirror_base.js"],
+  lineNumbers: true
+});</pre>
+    <p>Clicking the "Compress with UglifyJS" button will download the
+    compressed file. If you use Closure, that doesn't support direct
+    downloads, so the button will take you to a file containing the
+    compressed code. Copy-paste this into your script file. ("Save as"
+    for that page is broken on some browsers, so be careful).</p>
+    <form id="form" action="http://marijnhaverbeke.nl/uglifyjs" method="post">
+      <input type="hidden" id="download" name="download" value=""/>
+      <p>Version: <select id="version" onchange="setVersion(this);" class="field" style="padding: 1px">
+        <option value="http://codemirror.net/" selected>Development head</option>
+        <option value="http://marijnhaverbeke.nl/git/codemirror?a=blob_plain;hb=v0.93;f=">v0.93</option>
+        <option value="http://marijnhaverbeke.nl/git/codemirror?a=blob_plain;hb=v0.92;f=">v0.92</option>
+        <option value="http://marijnhaverbeke.nl/git/codemirror?a=blob_plain;hb=v0.91;f=">v0.91</option>
+        <option value="http://marijnhaverbeke.nl/git/codemirror?a=blob_plain;hb=v0.9;f=">v0.9</option>
+        <option value="http://marijnhaverbeke.nl/git/codemirror?a=blob_plain;hb=v0.8;f=">v0.8</option>
+        <option value="http://marijnhaverbeke.nl/git/codemirror?a=blob_plain;hb=v0.7;f=">v0.7</option>
+        <option value="http://marijnhaverbeke.nl/git/codemirror?a=blob_plain;hb=v0.67;f=">v0.67</option>
+      </select></p>
+      <p><input type="hidden" value="compiled_code" name="output_info" id="output"/>
+      <select multiple="multiple" name="code_url" style="width: 40em;" class="field" id="files">
+        <optgroup label="CodeMirror Library">
+          <option value="http://codemirror.net/js/codemirror.js">codemirror.js</option>
+        </optgroup>
+        <optgroup label="In-frame base files">
+          <option value="http://codemirror.net/js/util.js">util.js</option>
+          <option value="http://codemirror.net/js/stringstream.js">stringstream.js</option>
+          <option value="http://codemirror.net/js/select.js">select.js</option>
+          <option value="http://codemirror.net/js/undo.js">undo.js</option>
+          <option value="http://codemirror.net/js/editor.js">editor.js</option>
+          <option value="http://codemirror.net/js/tokenize.js">tokenize.js</option>
+        </optgroup>
+        <optgroup label="Parsers">
+          <option value="http://codemirror.net/js/tokenizejavascript.js">tokenizejavascript.js</option>
+          <option value="http://codemirror.net/js/parsejavascript.js">parsejavascript.js</option>
+          <option value="http://codemirror.net/js/parsexml.js">parsexml.js</option>
+          <option value="http://codemirror.net/js/parsecss.js">parsecss.js</option>
+          <option value="http://codemirror.net/js/parsesparql.js">parsesparql.js</option>
+          <option value="http://codemirror.net/js/parsehtmlmixed.js">parsehtmlmixed.js</option>
+          <option value="http://codemirror.net/js/parsedummy.js">parsedummy.js</option>
+        </optgroup>
+        <optgroup label="Contributed parsers">
+          <option value="http://codemirror.net/contrib/lua/js/parselua.js">parselua.js</option>
+          <option value="http://codemirror.net/contrib/python/js/parsepython.js">parsepython.js</option>
+          <option value="http://codemirror.net/contrib/php/js/tokenizephp.js">tokenizephp.js</option>
+          <option value="http://codemirror.net/contrib/php/js/parsephp.js">parsephp.js</option>
+          <option value="http://codemirror.net/contrib/php/js/parsephphtmlmixed.js">parsephphtmlmixed.js</option>
+          <option value="http://codemirror.net/contrib/csharp/js/tokenizecsharp.js">tokenizecsharp.js</option>
+          <option value="http://codemirror.net/contrib/csharp/js/parsecsharp.js">parsecsharp.js</option>
+          <option value="http://codemirror.net/contrib/sql/js/parsesql.js">parsesql.js</option>
+          <option value="http://codemirror.net/contrib/plsql/js/parseplsql.js">parseplsql.js</option>
+          <option value="http://codemirror.net/contrib/scheme/js/tokenizescheme.js">tokenizescheme.js</option>
+          <option value="http://codemirror.net/contrib/scheme/js/parsescheme.js">parsescheme.js</option>
+          <option value="http://codemirror.net/contrib/ometa/js/tokenizeometa.js">tokenizeometa.js</option>
+          <option value="http://codemirror.net/contrib/ometa/js/parseometa.js">parseometa.js</option>
+          <option value="http://codemirror.net/contrib/xquery/js/tokenizexquery.js">tokenizexquery.js</option>
+          <option value="http://codemirror.net/contrib/xquery/js/parsexquery.js">parsexquery.js</option>
+          <option value="http://svn.exoplatform.org/projects/gwt/trunk/exo-gwtframework-editor/src/main/resources/org/exoplatform/gwtframework/editor/public/codemirror/js/tokenizegroovy.js">tokenizegroovy.js</option>
+          <option value="http://svn.exoplatform.org/projects/gwt/trunk/exo-gwtframework-editor/src/main/resources/org/exoplatform/gwtframework/editor/public/codemirror/js/parsegroovy.js">parsegroovy.js</option>
+        </optgroup>
+      </select></p>
+      <p>
+        <button type="submit" onclick="uglify();">Compress</button> with <a href="http://github.com/mishoo/UglifyJS/">UglifyJS</a><br/>
+        <button type="submit" onclick="google();">Compress</button> with <a href="http://closure-compiler.appspot.com/home">Google Closure</a><br/>
+        <button type="submit" onclick="verify();">Check</button> for errors
+      </p>
+      <p>Custom code to add to the compressed file:<textarea name="js_code" style="width: 100%; height: 15em;" class="field"></textarea></p>
+    </form>
+    <script type="text/javascript" src="css/font.js"></script>
+    <script type="text/javascript">
+      function $(name) {return document.getElementById(name);}
+      function setVersion(ver) {
+        var urlprefix = ver.options[ver.selectedIndex].value;
+        console.log(urlprefix);
+        var select = $("files"), m;
+        for (var optgr = select.firstChild; optgr; optgr = optgr.nextSibling)
+          for (var opt = optgr.firstChild; opt; opt = opt.nextSibling) {
+            if (opt.nodeName != "OPTION")
+              continue;
+            else if (m = opt.value.match(/^http:\/\/codemirror.net\/(.*)$/))
+              opt.value = urlprefix + m[1];
+            else if (m = opt.value.match(/http:\/\/marijnhaverbeke.nl\/git\/codemirror\?a=blob_plain;hb=[^;]+;f=(.*)$/))
+              opt.value = urlprefix + m[1];
+          }
+      }
+      var download = $("download");
+      function verify() {
+        google();
+        $("output").value="warnings";
+      }
+      function google() {
+        $("output").value="compiled_code";
+        if (download.parentNode) download.parentNode.removeChild(download);
+        $("form").action = "http://closure-compiler.appspot.com/compile";
+      }
+      function uglify() {
+        var names = [], files = $("files");
+        for (var i = 0; i < files.options.length; i++) {
+          var opt = files.options[i];
+          if (opt.selected)
+            names.push(opt.text.match(/^(.*).js$/)[1]);
+        }
+        download.value = (names.join("-") || "codemirror") + ".js";
+        if (!download.parentNode) $("form").appendChild(download);
+        $("form").action = "http://marijnhaverbeke.nl/uglifyjs";
+      }
+    </script>
+  </body>
+</html>

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/csharp/css/csharpcolors.css ADDED Viewed

@@ -0,0 +1,60 @@
+html {
+  cursor: text;
+}
+.editbox {
+  margin: .4em;
+  padding: 0;
+  font-family: monospace;
+  font-size: 10pt;
+  color: black;
+}
+pre.code, .editbox {
+  color: #666666;
+}
+.editbox p {
+  margin: 0;
+}
+span.csharp-punctuation {
+  color: green;
+}
+span.csharp-operator {
+  color: purple;
+}
+span.csharp-keyword {
+  color: blue;
+}
+span.csharp-atom {
+  color: brown;
+}
+span.csharp-variable {
+  color: black;
+}
+span.csharp-variabledef {
+  color: #0000FF;
+}
+span.csharp-localvariable {
+  color: #004499;
+}
+span.csharp-property {
+  color: black;
+}
+span.csharp-comment {
+  color: green;
+}
+span.csharp-string {
+  color: red;
+}

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/csharp/index.html ADDED Viewed

@@ -0,0 +1,61 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <script src="../../js/codemirror.js" type="text/javascript"></script>
+    <title>CodeMirror: C# demonstration</title>
+    <link rel="stylesheet" type="text/css" href="../../css/docs.css"/>
+  </head>
+  <body style="padding: 20px;">
+<p>Demonstration of <a href="../../index.html">CodeMirror</a>'s C# highlighter.</p>
+<p>Written by <a href="http://skilltesting.com/">Boris Gaber and Christopher Buchino</a> (<a
+href="http://skilltesting.com/codemirror-parser-license/">license</a>).</p>
+<div style="border-top: 1px solid black; border-bottom: 1px solid black;">
+<textarea id="code" cols="120" rows="50">
+using System;
+namespace Example
+{
+    /// &lt;summary>
+    /// Represents a person employed at the company
+    /// &lt;/summary>
+    public class Employee : Person
+    {
+        #region Properties
+        /// &lt;summary>
+        /// Gets or sets the first name.
+        /// &lt;/summary>
+        /// &lt;value>The first name.&lt;/value>
+        public string FirstName { get; set; }
+        #endregion
+        /// &lt;summary>
+        /// Calculates the salary.
+        /// &lt;/summary>
+        /// &lt;param name="grade">The grade.&lt;/param>
+        /// &lt;returns>&lt;/returns>
+        public decimal CalculateSalary(int grade)
+        {
+            if (grade > 10)
+                return 1000;
+            return 500;
+        }
+    }
+}
+</textarea>
+</div>
+<script type="text/javascript">
+  var editor = CodeMirror.fromTextArea('code', {
+    parserfile: ["../contrib/csharp/js/tokenizecsharp.js", "../contrib/csharp/js/parsecsharp.js"],
+    stylesheet: "css/csharpcolors.css",
+    path: "../../js/",
+    height: "500px"
+  });
+</script>
+</body>
+</html>

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/csharp/js/parsecsharp.js ADDED Viewed

@@ -0,0 +1,329 @@
+/* Parse function for JavaScript. Makes use of the tokenizer from
+ * tokenizecsharp.js. Note that your parsers do not have to be
+ * this complicated -- if you don't want to recognize local variables,
+ * in many languages it is enough to just look for braces, semicolons,
+ * parentheses, etc, and know when you are inside a string or comment.
+ *
+ * See manual.html for more info about the parser interface.
+ */
+var JSParser = Editor.Parser = (function() {
+  // Token types that can be considered to be atoms.
+  var atomicTypes = {"atom": true, "number": true, "variable": true, "string": true, "regexp": true};
+  // Setting that can be used to have JSON data indent properly.
+  var json = false;
+  // Constructor for the lexical context objects.
+  function CSharpLexical(indented, column, type, align, prev, info) {
+    // indentation at start of this line
+    this.indented = indented;
+    // column at which this scope was opened
+    this.column = column;
+    // type of scope ('vardef', 'stat' (statement), 'form' (special form), '[', '{', or '(')
+    this.type = type;
+    // '[', '{', or '(' blocks that have any text after their opening
+    // character are said to be 'aligned' -- any lines below are
+    // indented all the way to the opening character.
+    if (align != null)
+      this.align = align;
+    // Parent scope, if any.
+    this.prev = prev;
+    this.info = info;
+  }
+  // CSharp indentation rules.
+  function indentCSharp(lexical) {
+    return function(firstChars) {
+      var firstChar = firstChars && firstChars.charAt(0), type = lexical.type;
+      var closing = firstChar == type;
+      if (type == "vardef")
+        return lexical.indented + 4;
+      else if (type == "form" && firstChar == "{")
+        return lexical.indented;
+      else if (type == "stat" || type == "form")
+        return lexical.indented + indentUnit;
+      else if (lexical.info == "switch" && !closing)
+        return lexical.indented + (/^(?:case|default)\b/.test(firstChars) ? indentUnit : 2 * indentUnit);
+      else if (lexical.align)
+        return lexical.column - (closing ? 1 : 0);
+      else
+        return lexical.indented + (closing ? 0 : indentUnit);
+    };
+  }
+  // The parser-iterator-producing function itself.
+  function parseCSharp(input, basecolumn) {
+    // Wrap the input in a token stream
+    var tokens = tokenizeCSharp(input);
+    // The parser state. cc is a stack of actions that have to be
+    // performed to finish the current statement. For example we might
+    // know that we still need to find a closing parenthesis and a
+    // semicolon. Actions at the end of the stack go first. It is
+    // initialized with an infinitely looping action that consumes
+    // whole statements.
+    var cc = [statements];
+    // The lexical scope, used mostly for indentation.
+    var lexical = new CSharpLexical((basecolumn || 0) - indentUnit, 0, "block", false);
+    // Current column, and the indentation at the start of the current
+    // line. Used to create lexical scope objects.
+    var column = 0;
+    var indented = 0;
+    // Variables which are used by the mark, cont, and pass functions
+    // below to communicate with the driver loop in the 'next'
+    // function.
+    var consume, marked;
+    // The iterator object.
+    var parser = {next: next, copy: copy};
+    function next(){
+      // Start by performing any 'lexical' actions (adjusting the
+      // lexical variable), or the operations below will be working
+      // with the wrong lexical state.
+      while(cc[cc.length - 1].lex)
+        cc.pop()();
+      // Fetch a token.
+      var token = tokens.next();
+      // Adjust column and indented.
+      if (token.type == "whitespace" && column == 0)
+        indented = token.value.length;
+      column += token.value.length;
+      if (token.content == "\n"){
+        indented = column = 0;
+        // If the lexical scope's align property is still undefined at
+        // the end of the line, it is an un-aligned scope.
+        if (!("align" in lexical))
+          lexical.align = false;
+        // Newline tokens get an indentation function associated with
+        // them.
+        token.indentation = indentCSharp(lexical);
+      }
+      // No more processing for meaningless tokens.
+      if (token.type == "whitespace" || token.type == "comment")
+        return token;
+      // When a meaningful token is found and the lexical scope's
+      // align is undefined, it is an aligned scope.
+      if (!("align" in lexical))
+        lexical.align = true;
+      // Execute actions until one 'consumes' the token and we can
+      // return it.
+      while(true) {
+        consume = marked = false;
+        // Take and execute the topmost action.
+        cc.pop()(token.type, token.content);
+        if (consume){
+          // Marked is used to change the style of the current token.
+          if (marked)
+            token.style = marked;
+          return token;
+        }
+      }
+    }
+    // This makes a copy of the parser state. It stores all the
+    // stateful variables in a closure, and returns a function that
+    // will restore them when called with a new input stream. Note
+    // that the cc array has to be copied, because it is contantly
+    // being modified. Lexical objects are not mutated, and context
+    // objects are not mutated in a harmful way, so they can be shared
+    // between runs of the parser.
+    function copy(){
+      var _lexical = lexical, _cc = cc.concat([]), _tokenState = tokens.state;
+      return function copyParser(input){
+        lexical = _lexical;
+        cc = _cc.concat([]); // copies the array
+        column = indented = 0;
+        tokens = tokenizeCSharp(input, _tokenState);
+        return parser;
+      };
+    }
+    // Helper function for pushing a number of actions onto the cc
+    // stack in reverse order.
+    function push(fs){
+      for (var i = fs.length - 1; i >= 0; i--)
+        cc.push(fs[i]);
+    }
+    // cont and pass are used by the action functions to add other
+    // actions to the stack. cont will cause the current token to be
+    // consumed, pass will leave it for the next action.
+    function cont(){
+      push(arguments);
+      consume = true;
+    }
+    function pass(){
+      push(arguments);
+      consume = false;
+    }
+    // Used to change the style of the current token.
+    function mark(style){
+      marked = style;
+    }
+    // Push a new lexical context of the given type.
+    function pushlex(type, info) {
+      var result = function(){
+        lexical = new CSharpLexical(indented, column, type, null, lexical, info)
+      };
+      result.lex = true;
+      return result;
+    }
+    // Pop off the current lexical context.
+    function poplex(){
+      lexical = lexical.prev;
+    }
+    poplex.lex = true;
+    // The 'lex' flag on these actions is used by the 'next' function
+    // to know they can (and have to) be ran before moving on to the
+    // next token.
+    // Creates an action that discards tokens until it finds one of
+    // the given type.
+    function expect(wanted){
+      return function expecting(type){
+        if (type == wanted) cont();
+        else cont(arguments.callee);
+      };
+    }
+    // Looks for a statement, and then calls itself.
+    function statements(type){
+      return pass(statement, statements);
+    }
+    // Dispatches various types of statements based on the type of the
+    // current token.
+    function statement(type){
+      if (type == "var") cont(pushlex("vardef"), vardef1, expect(";"), poplex);
+      else if (type == "keyword a") cont(pushlex("form"), expression, statement, poplex);
+      else if (type == "keyword b") cont(pushlex("form"), statement, poplex);
+      else if (type == "{" && json) cont(pushlex("}"), commasep(objprop, "}"), poplex);
+      else if (type == "{") cont(pushlex("}"), block, poplex);
+      else if (type == "function") cont(functiondef);
+      else if (type == "for") cont(pushlex("form"), expect("("), pushlex(")"), forspec1, expect(")"), poplex, statement, poplex);
+      else if (type == "variable") cont(pushlex("stat"), maybelabel);
+      else if (type == "switch") cont(pushlex("form"), expression, pushlex("}", "switch"), expect("{"), block, poplex, poplex);
+      else if (type == "case") cont(expression, expect(":"));
+      else if (type == "default") cont(expect(":"));
+      else if (type == "catch") cont(pushlex("form"), expect("("), funarg, expect(")"), statement, poplex);
+      else if (type == "class") cont(classdef);
+      else if (type == "keyword d") cont(statement);
+      else pass(pushlex("stat"), expression, expect(";"), poplex);
+    }
+    // Dispatch expression types.
+    function expression(type){
+      if (atomicTypes.hasOwnProperty(type)) cont(maybeoperator);
+      else if (type == "function") cont(functiondef);
+      else if (type == "keyword c") cont(expression);
+      else if (type == "(") cont(pushlex(")"), expression, expect(")"), poplex, maybeoperator);
+      else if (type == "operator") cont(expression);
+      else if (type == "[") cont(pushlex("]"), commasep(expression, "]"), poplex, maybeoperator);
+      else if (type == "{") cont(pushlex("}"), commasep(objprop, "}"), poplex, maybeoperator);
+    }
+    // Called for places where operators, function calls, or
+    // subscripts are valid. Will skip on to the next action if none
+    // is found.
+    function maybeoperator(type){
+      if (type == "operator") cont(expression);
+      else if (type == "(") cont(pushlex(")"), expression, commasep(expression, ")"), poplex, maybeoperator);
+      else if (type == ".") cont(property, maybeoperator);
+      else if (type == "[") cont(pushlex("]"), expression, expect("]"), poplex, maybeoperator);
+    }
+    // When a statement starts with a variable name, it might be a
+    // label. If no colon follows, it's a regular statement.
+    function maybelabel(type){
+      if (type == ":") cont(poplex, statement);
+      else if (type == "(") cont(commasep(funarg, ")"), poplex, statement); // method definition
+      else if (type == "{") cont(poplex, pushlex("}"), block, poplex); // property definition
+      else pass(maybeoperator, expect(";"), poplex);
+    }
+    // Property names need to have their style adjusted -- the
+    // tokenizer thinks they are variables.
+    function property(type){
+      if (type == "variable") {mark("csharp-property"); cont();}
+    }
+    // This parses a property and its value in an object literal.
+    function objprop(type){
+      if (type == "variable") mark("csharp-property");
+      if (atomicTypes.hasOwnProperty(type)) cont(expect(":"), expression);
+    }
+    // Parses a comma-separated list of the things that are recognized
+    // by the 'what' argument.
+    function commasep(what, end){
+      function proceed(type) {
+        if (type == ",") cont(what, proceed);
+        else if (type == end) cont();
+        else cont(expect(end));
+      };
+      return function commaSeparated(type) {
+        if (type == end) cont();
+        else pass(what, proceed);
+      };
+    }
+    // Look for statements until a closing brace is found.
+    function block(type){
+      if (type == "}") cont();
+      else pass(statement, block);
+    }
+    // Variable definitions are split into two actions -- 1 looks for
+    // a name or the end of the definition, 2 looks for an '=' sign or
+    // a comma.
+    function vardef1(type, value){
+      if (type == "variable"){cont(vardef2);}
+      else cont();
+    }
+    function vardef2(type, value){
+      if (value == "=") cont(expression, vardef2);
+      else if (type == ",") cont(vardef1);
+    }
+    // For loops.
+    function forspec1(type){
+      if (type == "var") cont(vardef1, forspec2);
+      else if (type == "keyword d") cont(vardef1, forspec2);
+      else if (type == ";") pass(forspec2);
+      else if (type == "variable") cont(formaybein);
+      else pass(forspec2);
+    }
+    function formaybein(type, value){
+      if (value == "in") cont(expression);
+      else cont(maybeoperator, forspec2);
+    }
+    function forspec2(type, value){
+      if (type == ";") cont(forspec3);
+      else if (value == "in") cont(expression);
+      else cont(expression, expect(";"), forspec3);
+    }
+    function forspec3(type) {
+      if (type == ")") pass();
+      else cont(expression);
+    }
+    // A function definition creates a new context, and the variables
+    // in its argument list have to be added to this context.
+    function functiondef(type, value){
+      if (type == "variable") cont(functiondef);
+      else if (type == "(") cont(commasep(funarg, ")"), statement);
+    }
+    function funarg(type, value){
+      if (type == "variable"){cont();}
+    }
+    function classdef(type) {
+        if (type == "variable") cont(classdef, statement);
+        else if (type == ":") cont(classdef, statement);
+    }
+    return parser;
+  }
+  return {
+    make: parseCSharp,
+    electricChars: "{}:",
+    configure: function(obj) {
+      if (obj.json != null) json = obj.json;
+    }
+  };
+})();