Monaco Editor

https://microsoft.github.io/monaco-editor
Admin
The Monaco Editor is the code editor that powers VS Code, offering features like IntelliSense,...
Tokens:50,138
Snippets:114
Trust Score:8.3
Update:10 months ago
Show doc for...
Tokens:
Raw
### Monarch Example - 'Hello World' in a Custom Language

Source: https://microsoft.github.io/monaco-editor/monarch

An example of a simple 'Hello World' program within a custom language defined for the Monarch editor. This demonstrates basic class, method, and console output syntax.

```javascript
// Type source code in your language here...
class MyClass {
@attribute
void main() {
Console.writeln( "Hello Monarch world ");
}
}
```

--------------------------------

### Initialize Monaco Editor with JavaScript

Source: https://microsoft.github.io/monaco-editor/playground

This snippet demonstrates the basic setup for creating a Monaco editor instance in JavaScript. It requires an HTML element to host the editor and specifies the initial content and language. The editor automatically adjusts its layout to fit the container.

```javascript
const value = /* set from `myEditor.getModel()`: */ `function hello() {
 alert('Hello world!');
}`;
// Hover on each property to see its docs!
const myEditor = monaco.editor.create(document.getElementById("container"), {
 value,
 language: "javascript",
 automaticLayout: true,
});
```

--------------------------------

### Sample Java Source Code Snippet

Source: https://microsoft.github.io/monaco-editor/monarch

This snippet provides a basic 'Hello, World!' program in Java. It defines a class `HelloWorld` with a `main` method that prints the string 'Hello, World' to the standard output. This is a common starting point for demonstrating Java syntax.

```java
public class HelloWorld {
   public static void main(String[] args) {
      System.out.println("Hello, World");
   }
}
```

--------------------------------

### Z3 SMT-LIB 2.0 Example with Array Operations

Source: https://microsoft.github.io/monaco-editor/monarch

This Z3 SMT-LIB 2.0 script demonstrates various array operations, including select, store, map, and default values. It showcases how to define sorts and functions related to arrays and uses push/pop for illustrating the state changes.

```smtlib
; This example illustrates different uses of the arrays
; supported in Z3.
; This includes Combinatory Array Logic (de Moura & Bjorner, FMCAD 2009).
;
(define-sort A () (Array Int Int))
(declare-fun x () Int)
(declare-fun y () Int)
(declare-fun z () Int)
(declare-fun a1 () A)
(declare-fun a2 () A)
(declare-fun a3 () A)
(push) ; illustrate select-store
(assert (= (select a1 x) x))
(assert (= (store a1 x y) a1))
(check-sat)
(get-model)
(assert (not (= x y)))
(check-sat)
(pop)
(define-fun all1_array () A ((as const A) 1))
(simplify (select all1_array x))
(define-sort IntSet () (Array Int Bool))
(declare-fun a () IntSet)
(declare-fun b () IntSet)
(declare-fun c () IntSet)
(push) ; illustrate map
(assert (not (= ((_ map and) a b) ((_ map not) ((_ map or) ((_ map not) b) ((_ map not) a))))))
(check-sat)
(pop)
(push)
(assert (and (select ((_ map and) a b) x) (not (select a x))))
(check-sat)
(pop)
(push)
(assert (and (select ((_ map or) a b) x) (not (select a x))))
(check-sat)
(get-model)
(assert (and (not (select b x))))
(check-sat)
;; unsat, so there is no model.
(pop)
(push) ; illustrate default
(assert (= (default a1) 1))
(assert (not (= a1 ((as const A) 1))))
(check-sat)
(get-model)
(assert (= (default a2) 1))
(assert (not (= a1 a2)))
(check-sat)
(get-model)
(pop)
(exit)

```

--------------------------------

### HTML structure for Monaco Editor

Source: https://microsoft.github.io/monaco-editor/playground

This HTML snippet provides the necessary structure to host the Monaco editor. A `div` element with a specific ID is required, and its dimensions should be set (e.g., using CSS) to ensure the editor is visible and functions correctly.

```html
<div id="container" style="height: 100%"></div>
```

--------------------------------

### Sample Source Code Snippet in an Unknown Language

Source: https://microsoft.github.io/monaco-editor/monarch

This is a sample source code snippet intended for use with the Monaco Editor. It defines a class with a main method and includes an example of printing to the console. The exact language is not specified, but it resembles a C-style syntax.

```plaintext
// Type source code in your language here...
class MyClass {
  @attribute
  void main() {
    Console.writeln( "Hello Monarch world
");
  }
}
```

--------------------------------

### Chalice Language: Channel and Class Definitions

Source: https://microsoft.github.io/monaco-editor/monarch

This C-like pseudocode defines a 'NumberStream' channel and a 'Sieve' class with methods for concurrent programming. The 'Counter' method sends numbers, 'Filter' filters multiples of a prime, and 'Start' orchestrates the process using channels and threads.

```pseudocode
// This example shows a use of a channel.  Properties of the messages
// passed along the channel, as well as permissions and channel credits,
// are specified in the channel's "where" clause.

channel NumberStream(x: int) where 2 <= x ==> credit(this);

class Sieve {
  method Counter(n: NumberStream, to: int)  // sends the plurals along n
    requires rd(n.mu) && credit(n,-1) && 0 <= to;
  {
    var i := 2;
    while (i < to)
      invariant rd(n.mu);
      invariant 2 <= i;
      invariant credit(n, -1)
    {
      send n(i);
      i := i + 1;
    }
    send n(-1);
  }

  method Filter(prime: int, r: NumberStream, s: NumberStream)
    requires 2 <= prime;
    requires rd(r.mu) && waitlevel << r.mu;
    requires rd(s.mu) && s.mu << r.mu && credit(r) && credit(s, -1);
  {
    receive x := r;
    while (2 <= x)
      invariant rd(r.mu) && rd(s.mu) && s << r && waitlevel << r.mu;
      invariant 2<= x ==> credit(r);
      invariant credit(s, -1);
    {
      if (x % prime != 0) {  // suppress multiples of prime
        send s(x);
      }
      receive x := r;

    }
    send s(-1);
  }

  method Start()
  {
    var ch := new NumberStream;
    fork Counter(ch, 101);
    var p: int;
    receive p := ch;
    while (2 <= p)
      invariant ch != null;
      invariant 2 <= p ==> credit(ch, 1);
      invariant rd*(ch.mu) && waitlevel << ch.mu;
    {
      // print p--it's a prime!
      var cp := new ChalicePrint;  call cp.Int(p);

      var n := new NumberStream between waitlevel and ch;
      fork Filter(p, ch, n);
      ch := n;
      receive p := ch;
    }
  }
}

external class ChalicePrint {
  method Int(x: int) { }
}

```

--------------------------------

### JavaScript Hello World Function

Source: https://microsoft.github.io/monaco-editor/playground_source=v0.55.1

A simple JavaScript function that displays an alert message 'Hello world!'. This is a basic example demonstrating function definition and alert usage in JavaScript.

```javascript
function hello() {
alert('Hello world!');
}
```

--------------------------------

### C# Ray, ISect, Surface, Camera, Light, and SceneObject Definitions

Source: https://microsoft.github.io/monaco-editor/monarch

Defines core classes for ray tracing: Ray (start and direction), ISect (intersection details), Surface (material properties like diffuse, specular, reflect, roughness), Camera (position, orientation), Light (position and color), and an abstract SceneObject with concrete Sphere implementation.

```csharp
class Ray {
    public Vector Start;
    public Vector Dir;
}

class ISect {
    public SceneObject Thing;
    public Ray Ray;
    public double Dist;
}

class Surface {
    public Func<Vector, Color> Diffuse;
    public Func<Vector, Color> Specular;
    public Func<Vector, double> Reflect;
    public double Roughness;
}

class Camera {
    public Vector Pos;
    public Vector Forward;
    public Vector Up;
    public Vector Right;

    public static Camera Create(Vector pos, Vector lookAt) {
        Vector forward = Vector.Norm(Vector.Minus(lookAt, pos));
        Vector down = new Vector(0, -1, 0);
        Vector right = Vector.Times(1.5, Vector.Norm(Vector.Cross(forward, down)));
        Vector up = Vector.Times(1.5, Vector.Norm(Vector.Cross(forward, right)));

        return new Camera() { Pos = pos, Forward = forward, Up = up, Right = right };
    }
}

class Light {
    public Vector Pos;
    public Color Color;
}

abstract class SceneObject {
    public Surface Surface;
    public abstract ISect Intersect(Ray ray);
    public abstract Vector Normal(Vector pos);
}

class Sphere : SceneObject {
    public Vector Center;
    public double Radius;

    public override ISect Intersect(Ray ray) {
        Vector eo = Vector.Minus(Center, ray.Start);
        double v = Vector.Dot(eo, ray.Dir);
        double dist;

```

--------------------------------

### Default Scene Definition (C#)

Source: https://microsoft.github.io/monaco-editor/monarch

Defines a sample scene for rendering, including geometric objects (Plane, Sphere) with specific positions, sizes, and surface properties, as well as multiple light sources with defined positions and colors, and a camera setup. This static property provides a default scene configuration.

```csharp
internal readonly Scene DefaultScene = 
            new Scene() { 
                    Things = new SceneObject[] { 
                                new Plane() { 
                                    Norm = Vector.Make(0,1,0), 
                                    Offset = 0, 
                                    Surface = Surfaces.CheckerBoard 
                                }, 
                                new Sphere() { 
                                    Center = Vector.Make(0,1,0), 
                                    Radius = 1, 
                                    Surface = Surfaces.Shiny 
                                }, 
                                new Sphere() { 
                                    Center = Vector.Make(-1,.5,1.5), 
                                    Radius = .5, 
                                    Surface = Surfaces.Shiny 
                                }}, 
                    Lights = new Light[] { 
                                new Light() { 
                                    Pos = Vector.Make(-2,2.5,0), 
                                    Color = Color.Make(.49,.07,.07) 
                                }, 
                                new Light() { 
                                    Pos = Vector.Make(1.5,2.5,1.5), 
                                    Color = Color.Make(.07,.07,.49) 
                                }, 
                                new Light() { 
                                    Pos = Vector.Make(1.5,2.5,-1.5), 
                                    Color = Color.Make(.07,.49,.071) 
                                }, 
                                new Light() { 
                                    Pos = Vector.Make(0,3.5,0), 
                                    Color = Color.Make(.21,.21,.35) 
                                }}, 
                    Camera = Camera.Create(Vector.Make(3,2,4), Vector.Make(-1,.5,0)) 
                };
```

--------------------------------

### Spec# Chunker Class Example in C#

Source: https://microsoft.github.io/monaco-editor/monarch

Demonstrates Spec# features like method preconditions and object invariants. The 'Chunker' class is designed to return successive portions of a given string, with the core logic in the `NextChunk()` method.

```csharp
// This example shows many of the features of Spec#, including pre-
// and postcondition of methods and object invariants.  The basic
// idea in the example is to implement a "chunker", which returns
// successive portions of a given string.  The main work is done
// in the NextChunk() method.

// For a full demo showing this example, check out the "The Chunker"
// episode on Verification Corner
// (http://research.microsoft.com/verificationcorner)

public class Chunker
{
  string src;
  int ChunkSize;
  invariant 0 <= ChunkSize;
  int n;  // the number of characters returned so far
  invariant 0 <= n;

  public string NextChunk()
    ensures result.Length <= ChunkSize;
  {
    string s;
    if (n + ChunkSize <= src.Length) {
      s = src.Substring(n, ChunkSize);
    } else {
      s = src.Substring(n);
    }
    return s;
  }

  public Chunker(string source, int chunkSize)
  {
    src = source;
    ChunkSize = chunkSize;
    n = 0;
  }
}
```

--------------------------------

### Whitespace and Comment Syntax Highlighting (Monaco)

Source: https://microsoft.github.io/monaco-editor/monarch

Defines rules for parsing whitespace (spaces, tabs, newlines) and comments. It supports single-line comments starting with '#' and multi-line comments starting with '=begin'.

```json
whitespace: [
			[/[ 	
]+/, ''],
			[/^s*=begin/, 'comment', '@comment'],
			[/#.*$/, 'comment'],
		],
```

--------------------------------

### Quick Sort Partition Algorithm in Boogie-like Pseudocode

Source: https://microsoft.github.io/monaco-editor/monarch

This snippet implements the partition step of the Quick Sort algorithm using a pseudocode syntax similar to the Boogie verification language. It details the logic for selecting a pivot, rearranging array elements, and returning the pivot's final index. The code includes detailed preconditions, postconditions, and loop invariants for formal verification.

```pseudocode
// The partition step of Quick Sort picks a 'pivot' element from a specified subsection
// of a given integer array.  It then partially sorts the elements of the array so that
// elements smaller than the pivot end up to the left of the pivot and elements larger
// than the pivot end up to the right of the pivot.  Finally, the index of the pivot is
// returned.
// The procedure below always picks the first element of the subregion as the pivot.
// The specification of the procedure talks about the ordering of the elements, but
// does not say anything about keeping the multiset of elements the same.

var A: [int]int;
const N: int;

procedure Partition(l: int, r: int) returns (result: int)
  requires 0 <= l && l+2 <= r && r <= N;
  modifies A;
  ensures l <= result && result < r;
  ensures (forall k: int, j: int :: l <= k && k < result && result <= j && j < r  ==>  A[k] <= A[j]);
  ensures (forall k: int :: l <= k && k < result  ==>  A[k] <= old(A)[l]);
  ensures (forall k: int :: result <= k && k < r  ==>  old(A)[l] <= A[k]);
{
  var pv, i, j, tmp: int;

  pv := A[l];
  i := l;
  j := r-1;
  // swap A[l] and A[j]
  tmp := A[l];
  A[l] := A[j];
  A[j] := tmp;
  goto LoopHead;

  // The following loop iterates while 'i < j'.  In each iteration,
  // one of the three alternatives (A, B, or C) is chosen in such
  // a way that the assume statements will evaluate to true.
  LoopHead:
    // The following the assert statements give the loop invariant
    assert (forall k: int :: l <= k && k < i  ==>  A[k] <= pv);
    assert (forall k: int :: j <= k && k < r  ==>  pv <= A[k]);
    assert l <= i && i <= j && j < r;
    goto A, B, C, exit;

  A:
    assume i < j;
    assume A[i] <= pv;
    i := i + 1;
    goto LoopHead;

  B:
    assume i < j;
    assume pv <= A[j-1];
    j := j - 1;
    goto LoopHead;

  C:
    assume i < j;
    assume A[j-1] < pv && pv < A[i];
    // swap A[j-1] and A[i]
    tmp := A[i];
    A[i] := A[j-1];
    A[j-1] := tmp;
    assert A[i] < pv && pv < A[j-1];
    i := i + 1;
    j := j - 1;
    goto LoopHead;

  exit:
    assume i == j;
    result := i;
}

```

--------------------------------

### Scene Rendering Loop (C#)

Source: https://microsoft.github.io/monaco-editor/monarch

Orchestrates the ray tracing process by iterating through each pixel of the screen, casting a ray from the camera's position through the calculated point for that pixel, and tracing the ray to determine its color. It then sets the pixel color using the 'setPixel' function. Input is a Scene object; output is the rendered image.

```csharp
internal void Render(Scene scene) {
            for (int y = 0; y < screenHeight; y++)
            {
                for (int x = 0; x < screenWidth; x++)
                {
                    Color color = TraceRay(new Ray() { Start = scene.Camera.Pos, Dir = GetPoint(x, y, scene.Camera) }, scene, 0);
                    setPixel(x, y, color.ToDrawingColor());
                }
            }
        }
```

--------------------------------

### Multi-line Comment Syntax Highlighting (Monaco)

Source: https://microsoft.github.io/monaco-editor/monarch

Handles the highlighting of multi-line comments that start with '=begin'. It continues highlighting until it encounters the closing '=end' (though '=end' is not explicitly shown in this snippet, it's implied by the context of comment handling).

```json
comment: [
			[/[^=]+/, 'comment'],
			[/^s*=begin/, 'comment.invalid'],    // nested comment
		],
```

--------------------------------

### Ray Tracing Shading and Reflection Logic (C#)

Source: https://microsoft.github.io/monaco-editor/monarch

Implements core ray tracing logic including shading, calculating natural and reflection colors, and handling recursion depth. It takes scene objects, positions, normals, directions, and scene information as input, returning a Color. Dependencies include Vector, Color, SceneObject, Ray, and Scene classes.

```csharp
private Color GetReflectionColor(SceneObject thing, Vector pos, Vector norm, Vector rd, Scene scene, int depth) {
            return Color.Times(thing.Surface.Reflect(pos), TraceRay(new Ray() { Start = pos, Dir = rd }, scene, depth + 1));
        }

        private Color Shade(ISect isect, Scene scene, int depth) {
            var d = isect.Ray.Dir;
            var pos = Vector.Plus(Vector.Times(isect.Dist, isect.Ray.Dir), isect.Ray.Start);
            var normal = isect.Thing.Normal(pos);
            var reflectDir = Vector.Minus(d, Vector.Times(2 * Vector.Dot(normal, d), normal));
            Color ret = Color.DefaultColor;
            ret = Color.Plus(ret, GetNaturalColor(isect.Thing, pos, normal, reflectDir, scene));
            if (depth >= MaxDepth) {
                return Color.Plus(ret, Color.Make(.5, .5, .5));
            }
            return Color.Plus(ret, GetReflectionColor(isect.Thing, Vector.Plus(pos, Vector.Times(.001, reflectDir)), normal, reflectDir, scene, depth));
        }
```

--------------------------------

### Monaco Editor - Basic Tokenization Rules

Source: https://microsoft.github.io/monaco-editor/monarch

This snippet defines basic tokenization rules for keywords, identifiers, and namespaces. It uses a state machine approach with 'next' to transition between states, enabling context-aware parsing.

```json
{
  "tokenColors": [
    {
      "scope": "keyword",
      "settings": {
        "foreground": "#C586C0"
      }
    },
    {
      "scope": "identifier",
      "settings": {
        "foreground": "#DCDCAA"
      }
    },
    {
      "scope": "identifier.namespace",
      "settings": {
        "foreground": "#4EC9B0"
      }
    }
  ],
  "tokenizer": {
    "root": [
      [ /\b(struct|type|cotype|rectype|module|as|import)\b/, "keyword", "@type" ],
      [ /@default/, "keyword" ]
    ],
    "@builtins": "identifier.predefined",
    "@default": "identifier"
  }
}
```

--------------------------------

### Monaco Editor Tokenizer: Bracket Handling

Source: https://microsoft.github.io/monaco-editor/monarch

Demonstrates how to use the '@brackets' token class for bracket matching and auto-indentation. It shows how to associate bracket pairs and how the editor uses this information.

```json
[
  /[{}()[]]/,
  '@brackets'
]

[
  /[{}()[]]/,
  {
    "token": '@brackets',
    "bracket": '@open'
  }
]
```

--------------------------------

### Monaco Editor: Tokenizing Keywords and Identifiers

Source: https://microsoft.github.io/monaco-editor/monarch

This snippet defines rules for tokenizing keywords, built-in types, and identifiers based on patterns. It handles different cases for declarations at the start of a line versus modifiers later in the line, using states like 'dodecl' and 'modifier' to manage context.

```javascript
		// We distinguish a declaration that comes first on a line, versus declarations further on a line (which are most likey modifiers)
		[/^(s*)([a-z_]w*[!?=]?)/, ['white',
				{
					cases: {
						'for|until|while': { token: 'keyword.$2', next: '@dodecl.$2' },
						'@declarations': { token: 'keyword.$2', next: '@root.$2' },
						'end': { token: 'keyword.$S2', next: '@pop' },
						'@keywords': 'keyword',
						'@builtins': 'predefined',
						'@default': 'identifier'
					}
				}]],
			[/[a-z_]w*[!?=]?/,
				{
					cases: {
						'if|unless|while|until': { token: 'keyword.$0x', next: '@modifier.$0x' },
						'for': { token: 'keyword.$2', next: '@dodecl.$2' },
						'@linedecls': { token: 'keyword.$0', next: '@root.$0' },
						'end': { token: 'keyword.$S2', next: '@pop' },
						'@keywords': 'keyword',
						'@builtins': 'predefined',
						'@default': 'identifier'
					}
				}],

			[/[A-Z][w]*[!?=]?/, 'constructor.identifier'],     // constant
			[/$[w]*/, 'global.constant'],               // global
			[/@[w]*/, 'namespace.instance.identifier'], // instance
			[/@@[w]*/, 'namespace.class.identifier'],    // class

```

--------------------------------

### C# 4.0 Ray Tracer Implementation

Source: https://microsoft.github.io/monaco-editor/monarch

A C# implementation of a basic ray tracer, demonstrating scene intersection tests and ray tracing for rendering. This code includes classes for rays, scenes, objects, lights, and color, along with methods for calculating intersections and shading.

```csharp
// CSharp 4.0 ray-tracer sample by Luke Hoban
using System.Drawing;
using System.Linq;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Windows.Forms;

namespace RayTracer {
    public class RayTracer {

        private int screenWidth;
        private int screenHeight;
        private const int MaxDepth = 5;

        public Action<int, int, System.Drawing.Color> setPixel;

        public RayTracer(int screenWidth, int screenHeight, Action<int,int, System.Drawing.Color> setPixel) {
            this.screenWidth = screenWidth;
            this.screenHeight = screenHeight;
            this.setPixel = setPixel;
        }

        private IEnumerable<ISect> Intersections(Ray ray, Scene scene) {
            return scene.Things
                        .Select(obj => obj.Intersect(ray))
                        .Where(inter => inter != null)
                        .OrderBy(inter => inter.Dist);
        }

        private double TestRay(Ray ray, Scene scene) {
            var isects = Intersections(ray, scene);
            ISect isect = isects.FirstOrDefault();
            if (isect == null)
                return 0;
            return isect.Dist;
        }

        private Color TraceRay(Ray ray, Scene scene, int depth) {
            var isects = Intersections(ray, scene);
            ISect isect = isects.FirstOrDefault();
            if (isect == null)
                return Color.Background;
            return Shade(isect, scene, depth);
        }

        private Color GetNaturalColor(SceneObject thing, Vector pos, Vector norm, Vector rd, Scene scene) {
            Color ret = Color.Make(0, 0, 0);
            foreach (Light light in scene.Lights) {
                Vector ldis = Vector.Minus(light.Pos, pos);
                Vector livec = Vector.Norm(ldis);
                double neatIsect = TestRay(new Ray() { Start = pos, Dir = livec }, scene);
                bool isInShadow = !((neatIsect > Vector.Mag(ldis)) || (neatIsect == 0));
                if (!isInShadow) {
                    double illum = Vector.Dot(livec, norm);
                    Color lcolor = illum > 0 ? Color.Times(illum, light.Color) : Color.Make(0, 0, 0);
                    double specular = Vector.Dot(livec, Vector.Norm(rd));

```

--------------------------------

### C# Color Class for RGB Color Representation

Source: https://microsoft.github.io/monaco-editor/monarch

Implements a Color class to represent RGB values with R, G, and B components. Provides static methods for color creation, scalar and component-wise multiplication, addition, and subtraction. Includes helper methods for legalizing color values and converting to System.Drawing.Color.

```csharp
public class Color {
    public double R;
    public double G;
    public double B;

    public Color(double r, double g, double b) { R = r; G = g; B = b; }
    public Color(string str) {
        string[] nums = str.Split(',');
        if (nums.Length != 3) throw new ArgumentException();
        R = double.Parse(nums[0]);
        G = double.Parse(nums[1]);
        B = double.Parse(nums[2]);
    }

    public static Color Make(double r, double g, double b) { return new Color(r, g, b); }

    public static Color Times(double n, Color v) {
        return new Color(n * v.R, n * v.G, n * v.B);
    }
    public static Color Times(Color v1, Color v2) {
        return new Color(v1.R * v2.R, v1.G * v2.G,v1.B * v2.B);
    }

    public static Color Plus(Color v1, Color v2) {
        return new Color(v1.R + v2.R, v1.G + v2.G,v1.B + v2.B);
    }
    public static Color Minus(Color v1, Color v2) {
        return new Color(v1.R - v2.R, v1.G - v2.G,v1.B - v2.B);
    }

    public static readonly Color Background = Make(0, 0, 0);
    public static readonly Color DefaultColor = Make(0, 0, 0);

    public double Legalize(double d) {
        return d > 1 ? 1 : d;
    }

    internal System.Drawing.Color ToDrawingColor() {
        return System.Drawing.Color.FromArgb((int)(Legalize(R) * 255), (int)(Legalize(G) * 255), (int)(Legalize(B) * 255));
    }

}
```

--------------------------------

### Spec# Language Keywords and Verification Terms

Source: https://microsoft.github.io/monaco-editor/monarch

Lists keywords and specific verification-related terms used in the Spec# language. This includes standard C# keywords alongside Spec# extensions for assertions and contracts.

```javascript
{
  keywords: [
    'extern', 'alias', 'using', 'bool', 'decimal', 'sbyte', 'byte', 'short',
    'ushort', 'int', 'uint', 'long', 'ulong', 'char', 'float', 'double',
    'object', 'dynamic', 'string', 'assembly', 'module', 'is', 'as', 'ref',
    'out', 'this', 'base', 'new', 'typeof', 'void', 'checked', 'unchecked',
    'default', 'delegate', 'var', 'const', 'if', 'else', 'switch', 'case',
    'while', 'do', 'for', 'foreach', 'in', 'break', 'continue', 'goto',
    'return', 'throw', 'try', 'catch', 'finally', 'lock', 'yield', 'from',
    'let', 'where', 'join', 'on', 'equals', 'into', 'orderby', 'ascending',
    'descending', 'select', 'group', 'by', 'namespace', 'partial', 'class',
    'field', 'event', 'method', 'param', 'property', 'public', 'protected',
    'internal', 'private', 'abstract', 'sealed', 'static', 'struct', 'readonly',
    'volatile', 'virtual', 'override', 'params', 'get', 'set', 'add', 'remove',
    'operator', 'true', 'false', 'implicit', 'explicit', 'interface', 'enum',
    'null',
    '=/:',
    'expose', 'assert', 'assume',
    'additive', 'model', 'throws',
    'forall', 'exists', 'unique', 'count', 'max', 'min', 'product', 'sum',
    'result'
  ],

  verifyKeywords: [
    'requires','ensures','invariant','free'
  ]
}
```

--------------------------------

### C# Ray Tracing Scene and Form Implementation

Source: https://microsoft.github.io/monaco-editor/monarch

This C# code defines classes for ray tracing, including Sphere, Plane, Scene, and the main RayTracerForm. It handles scene intersection, normal calculation, and rendering using a Bitmap and PictureBox.

```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Drawing;
using System.Windows.Forms;

public class Vector {
    public double X, Y, Z;

    public Vector(double x, double y, double z) { X = x; Y = y; Z = z; }

    public static Vector Minus(Vector a, Vector b) { return new Vector(a.X - b.X, a.Y - b.Y, a.Z - b.Z); }
    public static double Dot(Vector a, Vector b) { return a.X * b.X + a.Y * b.Y + a.Z * b.Z; }
    public static Vector Norm(Vector a) { double l = Math.Sqrt(Dot(a, a)); return new Vector(a.X / l, a.Y / l, a.Z / l); }
    public static Vector Times(Vector a, double s) { return new Vector(a.X * s, a.Y * s, a.Z * s); }
}

public class Ray {
    public Vector Start, Dir;
    public Ray(Vector start, Vector dir) { Start = start; Dir = dir; }
}

public class ISect {
    public SceneObject Thing;
    public Ray Ray;
    public double Dist;
}

public abstract class SceneObject {
    public abstract ISect Intersect(Ray ray);
    public abstract Vector Normal(Vector pos);
}

class Sphere : SceneObject {
    public Vector Center;
    public double Radius;

    public override ISect Intersect(Ray ray) {
        Vector eo = Vector.Minus(Center, ray.Start);
        double v = Vector.Dot(eo, ray.Dir);
        double dist = 0;

        if (v < 0) {
            dist = 0;
        }
        else {
            double disc = Math.Pow(Radius,2) - (Vector.Dot(eo, eo) - Math.Pow(v,2));
            dist = disc < 0 ? 0 : v - Math.Sqrt(disc);
        }
        if (dist == 0) return null;
        return new ISect() {
            Thing = this,
            Ray = ray,
            Dist = dist};
    }

    public override Vector Normal(Vector pos) {
        return Vector.Norm(Vector.Minus(pos, Center));
    }
}

class Plane : SceneObject {
    public Vector Norm;
    public double Offset;

    public override ISect Intersect(Ray ray) {
        double denom = Vector.Dot(Norm, ray.Dir);
        if (denom > 0) return null;
        return new ISect() {
            Thing = this,
            Ray = ray,
            Dist = (Vector.Dot(Norm, ray.Start) + Offset) / (-denom)};
    }

    public override Vector Normal(Vector pos) {
        return Norm;
    }
}

class Scene {
    public SceneObject[] Things;
    public Light[] Lights;
    public Camera Camera;

    public IEnumerable<ISect> Intersect(Ray r) {
        return from thing in Things
               select thing.Intersect(r);
    }
}

public delegate void Action<T,U,V>(T t, U u, V v);

public partial class RayTracerForm : Form
{
    Bitmap bitmap;
    PictureBox pictureBox;
    const int width = 600;
    const int height = 600;

    public RayTracerForm()
    {
        bitmap = new Bitmap(width,height);

        pictureBox = new PictureBox();
        pictureBox.Dock = DockStyle.Fill;
        pictureBox.SizeMode = PictureBoxSizeMode.StretchImage;
        pictureBox.Image = bitmap;

        ClientSize = new System.Drawing.Size(width, height + 24);
        Controls.Add(pictureBox);
        Text = "Ray Tracer";
        Load += RayTracerForm_Load;

        Show();
    }

    private void RayTracerForm_Load(object sender, EventArgs e)
    {
        this.Show();
        RayTracer rayTracer = new RayTracer(width, height, (int x, int y, System.Drawing.Color color) =>
                                                           {
                                                               bitmap.SetPixel(x, y, color);
                                                               if (x == 0) pictureBox.Refresh();
                                                           });
        rayTracer.Render(rayTracer.DefaultScene);
        pictureBox.Invalidate();

    }

    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();

        Application.Run(new RayTracerForm());
    }
}

```

--------------------------------

### Monaco Editor Tokenizer: Advanced State Management

Source: https://microsoft.github.io/monaco-editor/monarch

Covers advanced state management attributes like 'switchTo' for changing state without altering the stack, and 'goBack' for rewinding the input stream during tokenization.

```json
{
  "token": "identifier",
  "switchTo": "@newState"
}

{
  "token": "comment",
  "goBack": 2
}
```

--------------------------------

### Solve Sudoku with Z3 in Python

Source: https://microsoft.github.io/monaco-editor/monarch

This Python code defines a Sudoku instance using zeros for empty cells and then uses the Z3 solver to find a solution. It defines the constraints for the Sudoku board and prints the solved matrix if a solution is found. The code assumes the existence of a `print_matrix` function and Z3's `Solver`, `X`, `sat`, and `model` objects.

```python
instance = ((0,0,0,0,9,4,0,3,0),
            (0,0,0,5,1,0,0,0,7),
            (0,8,9,0,0,0,0,4,0),
            (0,0,0,0,0,0,2,0,8),
            (0,6,0,2,0,1,0,5,0),
            (1,0,2,0,0,0,0,0,0),
            (0,7,0,0,0,0,5,2,0),
            (9,0,0,0,6,5,0,0,0),
            (0,4,0,9,7,0,0,0,0))

instance_c = [ If(instance[i][j] == 0,
                  True,
                  X[i][j] == instance[i][j])
               for i in range(9) for j in range(9) ]

s = Solver()
s.add(sudoku_c + instance_c)
if s.check() == sat:
    m = s.model()
    r = [ [ m.evaluate(X[i][j]) for j in range(9) ]
          for i in range(9) ]
    print_matrix(r)
else:
    print "failed to solve"
```

--------------------------------

### Garcia-Wachs Algorithm Implementation in Koka

Source: https://microsoft.github.io/monaco-editor/monarch

This code implements the Garcia-Wachs algorithm for building trees from weighted lists. It defines types for trees and non-empty lists, along with functions for mapping, zipping, inserting, extracting, balancing, marking depths, and building the final tree structure. The implementation highlights Koka's ability to infer purity from code with observable side-effects.

```koka
module garcia-wachs

//----------------------------------------------------
// Trees
//----------------------------------------------------
public type tree<a> {
  con Leaf(value :a)
  con Node(left :tree<a>, right :tree<a>)
}

fun show( t : tree<char> ) : string
{
  match(t) {
    Leaf(c) -> Core.show(c)
    Node(l,r) -> "Node(" + show(l) + "," + show(r) + ")"
  }
}


//----------------------------------------------------
// Non empty lists
//----------------------------------------------------
public type list1<a> {
  Cons1( head : a, tail : list<a> )
}


fun map( xs, f ) {
  val Cons1(y,ys) = xs
  return Cons1(f(y), Core.map(ys,f))
}

fun zip( xs :list1<a>, ys :list1<b> ) : list1<(a,b)> {
  Cons1( (xs.head, ys.head), Core.zip(xs.tail, ys.tail))
}



//----------------------------------------------------
// Phase 1
// note: koka cannot yet prove that the mutual recursive
// functions "insert" and "extract" always terminate :-(
//----------------------------------------------------

fun insert( after : list<(tree<a>,int)>, t : (tree<a>,int), before : list<(tree<a>,int)> ) : div tree<a>
{
  match(before) {
    Nil -> extract( [], Cons1(t,after) )
    Cons(x,xs) -> {
      if (x.snd < t.snd) then return insert( Cons(x,after), t, xs )
      match(xs) {
        Nil        -> extract( [], Cons1(x,Cons(t,after)) )
        Cons(y,ys) -> extract( ys, Cons1(y,Cons(x,Cons(t,after))))
      }
    }
  }
}

fun extract( before : list<(tree<a>,int)>, after : list1<(tree<a>,int)> ) : div tree<a>
{
  val Cons1((t1,w1) as x, xs ) = after
  match(xs) {
    Nil -> t1
    Cons((t2,w2) as y, ys) -> match(ys) {
      Nil -> insert( [], (Node(t1,t2), w1+w2), before )
      Cons((_,w3),_zs) ->
        if (w1 <= w3)
         then insert(ys, (Node(t1,t2), w1+w2), before)
         else extract(Cons(x,before), Cons1(y,ys))
    }
  }
}



fun balance( xs : list1<(tree<a>,int)> ) : div tree<a>
{
  extract( [], xs )
}

fun mark( depth :int, t :tree<(a,ref<h,int>)> ) : <write<h>> ()
{
  match(t) {
    Leaf((_,d)) -> d := depth
    Node(l,r)   -> { mark(depth+1,l); mark(depth+1,r) }
  }
}


fun build( depth :int, xs :list1<(a,ref<h,int>)> ) : <read<h>,div> (tree<a>,list<(a,ref<h,int>)>)
{
  if (!xs.head.snd == depth) return (Leaf(xs.head.fst), xs.tail)

  l = build(depth+1, xs)
  match(l.snd) {
    Nil -> (l.fst, Nil)
    Cons(y,ys) -> {
      r = build(depth+1, Cons1(y,ys))
      (Node(l.fst,r.fst), r.snd)
    }
  }
}

public function garciawachs( xs : list1<(a,int)> ) : div tree<a>
{
  refs   = xs.map(fst).map( fun(x) { (x, ref(0)) } )
  wleafs = zip( refs.map(Leaf), xs.map(snd) )

  tree = balance(wleafs)
  mark(0,tree)
  build(0,refs).fst
}

public function main() {
  wlist = Cons1(('a',3), [('b',2),('c',1),('d',4),('e',5)])
  tree  = wlist.garciawachs()
  tree.show.print()
}

```

--------------------------------

### Tkinter Calculator Build Method and Key Definitions

Source: https://microsoft.github.io/monaco-editor/monarch

Implements the 'buildCalculator' method to construct the calculator's UI layout. It defines constants for key types and colors, and a nested list 'keys' containing tuples that describe each button's label, function, color, and type.

```python
    def buildCalculator(self):
        FUN   = 1            # Designates a Function
        KEY   = 0            # Designates a Key
        KC1   = 'gray30'     # Dark Keys
        KC2   = 'gray50'     # Light Keys
        KC3   = 'steelblue1' # Light Blue Key
        KC4   = 'steelblue'  # Dark Blue Key
        keys = [
            [('2nd',  '',     '',  KC3, FUN, 'second'),  # Row 1
             ('Mode', 'Quit', '',  KC1, FUN, 'mode'),
             ('Del',  'Ins',  '',  KC1, FUN, 'delete'),
             ('Alpha','Lock', '',  KC2, FUN, 'alpha'),
             ('Stat', 'List', '',  KC1, FUN, 'stat')],
            [('Math', 'Test', 'A', KC1, FUN, 'math'),    # Row 2
             ('Mtrx', 'Angle','B', KC1, FUN, 'matrix'),
             ('Prgm', 'Draw', 'C', KC1, FUN, 'program'),
             ('Vars', 'YVars','',  KC1, FUN, 'vars'),
             ('Clr',  '',     '',  KC1, FUN, 'clear')],
            [('X-1',  'Abs',  'D', KC1, FUN, 'X1'),      # Row 3
             ('Sin',  'Sin-1','E', KC1, FUN, 'sin'),
             ('Cos',  'Cos-1','F', KC1, FUN, 'cos'),
             ('Tan',  'Tan-1','G', KC1, FUN, 'tan'),
             ('^',    'PI',   'H', KC1, FUN, 'up')],
            [('X2',   'Root', 'I', KC1, FUN, 'X2'),      # Row 4
             (',',    'EE',   'J', KC1, KEY, ','),
             ('(',    '{',    'K', KC1, KEY, '('),
             (')',    '}',    'L', KC1, KEY, ')'),
             ('/',    '',     'M', KC4, KEY, '/')],
            [('Log',  '10x',  'N', KC1, FUN, 'log'),     # Row 5
             ('7',    'Un-1', 'O', KC2, KEY, '7'),
             ('8',    'Vn-1', 'P', KC2, KEY, '8'),
```

--------------------------------

### Monaco Editor API Overview

Source: https://microsoft.github.io/monaco-editor/docs

Provides an overview of the Monaco Editor API, including its available namespaces, enumerations, classes, interfaces, type aliases, and functions.

```APIDOC
## Monaco Editor API

### Index

This section provides an index of the available API components.

### Namespaces

*   `css`
*   `editor`
*   `html`
*   `json`
*   `languages`
*   `lsp`
*   `typescript`
*   `worker`

### Enumerations

*   `KeyCode`
*   `MarkerSeverity`
*   `MarkerTag`
*   `SelectionDirection`

### Classes

*   `CancellationTokenSource`
*   `Emitter`
*   `KeyMod`
*   `Position`
*   `Range`
*   `Selection`
*   `Token`
*   `Uri`

### Interfaces

*   `CancellationToken`
*   `Environment`
*   `IDisposable`
*   `IEvent`
*   `IKeyboardEvent`
*   `IMarkdownString`
*   `IMouseEvent`
*   `IPosition`
*   `IRange`
*   `IScrollEvent`
*   `ISelection`
*   `ITrustedTypePolicy`
*   `ITrustedTypePolicyOptions`
*   `IWebWorkerOptions`
*   `MarkdownStringTrustedOptions`
*   `UriComponents`

### Type Aliases

*   `Thenable`

### Functions

*   `createWebWorker`
```

--------------------------------

### HTML Tag Brace Matching with Dynamic Token Classes

Source: https://microsoft.github.io/monaco-editor/monarch

Demonstrates brace matching for HTML opening and closing tags. It dynamically generates token classes based on the tag name captured in a group, ensuring that closing tags only match their specific opening tags.

```javascript
tokenizer: {
  root: {
    /<(w+)(>?)/, { token: 'tag-$1', bracket: '@open'  }
    , /</(w+)s*>/, { token: 'tag-$1', bracket: '@close' }
  },
}
```
Tokens:
Raw