@harmoniclabs/monaco-editor 0.52.0

package/website/src/website/data/home-samples/sample.cameligo.txt

@@ -0,0 +1,17 @@
+type storage = int
+type parameter =
+  Increment of int
+| Decrement of int
+| Reset
+type return = operation list * storage
+// Two entrypoints
+let add (store, delta : storage * int) : storage = store + delta
+let sub (store, delta : storage * int) : storage = store - delta
+(* Main access point that dispatches to the entrypoints according to
+   the smart contract parameter. *)
+let main (action, store : parameter * storage) : return =
+ ([] : operation list),    // No operations
+ (match action with
+   Increment (n) -> add (store, n)
+ | Decrement (n) -> sub (store, n)
+ | Reset         -> 0)

package/website/src/website/data/home-samples/sample.clojure.txt

@@ -0,0 +1,54 @@
+(ns game-of-life
+  "Conway's Game of Life, based on the work of
+  Christophe Grand (http://clj-me.cgrand.net/2011/08/19/conways-game-of-life)
+  and Laurent Petit (https://gist.github.com/1200343).")
+
+;;; Core game of life's algorithm functions
+
+(defn neighbors
+  "Given a cell's coordinates `[x y]`, returns the coordinates of its
+  neighbors."
+  [[x y]]
+  (for [dx [-1 0 1]
+        dy (if (zero? dx)
+             [-1 1]
+             [-1 0 1])]
+    [(+ dx x) (+ dy y)]))
+
+(defn step
+  "Given a set of living `cells`, computes the new set of living cells."
+  [cells]
+  (set (for [[cell n] (frequencies (mapcat neighbors cells))
+             :when (or (= n 3)
+                       (and (= n 2)
+                            (cells cell)))]
+         cell)))
+
+;;; Utility methods for displaying game on a text terminal
+
+(defn print-grid
+  "Prints a `grid` of `w` columns and `h` rows, on *out*, representing a
+  step in the game."
+  [grid w h]
+  (doseq [x (range (inc w))
+          y (range (inc h))]
+    (when (= y 0) (println))
+    (print (if (grid [x y])
+             "[X]"
+             " . "))))
+
+(defn print-grids
+  "Prints a sequence of `grids` of `w` columns and `h` rows on *out*,
+  representing several steps."
+  [grids w h]
+  (doseq [grid grids]
+    (print-grid grid w h)
+    (println)))
+
+;;; Launches an example grid
+
+(def grid
+  "`grid` represents the initial set of living cells"
+  #{[2 1] [2 2] [2 3]})
+
+(print-grids (take 3 (iterate step grid)) 5 5)

package/website/src/website/data/home-samples/sample.coffeescript.txt

@@ -0,0 +1,28 @@
+"""
+A CoffeeScript sample.
+"""
+
+class Vehicle
+  constructor: (@name) =>
+  
+  drive: () =>
+    alert "Conducting #{@name}"
+
+class Car extends Vehicle
+  drive: () =>
+    alert "Driving #{@name}"
+
+c = new Car "Brandie"
+
+while notAtDestination()
+  c.drive()
+
+raceVehicles = (new Car for i in [1..100])
+
+startRace = (vehicles) -> [vehicle.drive() for vehicle in vehicles]
+
+fancyRegExp = ///
+	(\d+)	# numbers
+	(\w*)	# letters
+	$		# the end
+///

package/website/src/website/data/home-samples/sample.cpp.txt

@@ -0,0 +1,246 @@
+#include "pch.h"
+#include "Direct3DBase.h"
+
+using namespace Microsoft::WRL;
+using namespace Windows::UI::Core;
+using namespace Windows::Foundation;
+
+// Constructor.
+Direct3DBase::Direct3DBase()
+{
+}
+
+// Initialize the Direct3D resources required to run.
+void Direct3DBase::Initialize(CoreWindow^ window)
+{
+    m_window = window;
+    
+    CreateDeviceResources();
+    CreateWindowSizeDependentResources();
+}
+
+// These are the resources that depend on the device.
+void Direct3DBase::CreateDeviceResources()
+{
+    // This flag adds support for surfaces with a different color channel ordering than the API default.
+    // It is recommended usage, and is required for compatibility with Direct2D.
+    UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
+
+#if defined(_DEBUG)
+    // If the project is in a debug build, enable debugging via SDK Layers with this flag.
+    creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
+#endif
+
+    // This array defines the set of DirectX hardware feature levels this app will support.
+    // Note the ordering should be preserved.
+    // Don't forget to declare your application's minimum required feature level in its
+    // description.  All applications are assumed to support 9.1 unless otherwise stated.
+    D3D_FEATURE_LEVEL featureLevels[] = 
+    {
+        D3D_FEATURE_LEVEL_11_1,
+        D3D_FEATURE_LEVEL_11_0,
+        D3D_FEATURE_LEVEL_10_1,
+        D3D_FEATURE_LEVEL_10_0,
+        D3D_FEATURE_LEVEL_9_3,
+        D3D_FEATURE_LEVEL_9_2,
+        D3D_FEATURE_LEVEL_9_1
+    };
+
+    // Create the DX11 API device object, and get a corresponding context.
+    ComPtr<ID3D11Device> device;
+    ComPtr<ID3D11DeviceContext> context;
+    DX::ThrowIfFailed(
+        D3D11CreateDevice(
+            nullptr,                    // specify null to use the default adapter
+            D3D_DRIVER_TYPE_HARDWARE,
+            nullptr,                    // leave as nullptr unless software device
+            creationFlags,              // optionally set debug and Direct2D compatibility flags
+            featureLevels,              // list of feature levels this app can support
+            ARRAYSIZE(featureLevels),   // number of entries in above list
+            D3D11_SDK_VERSION,          // always set this to D3D11_SDK_VERSION
+            &device,                    // returns the Direct3D device created
+            &m_featureLevel,            // returns feature level of device created
+            &context                    // returns the device immediate context
+            )
+        );
+
+    // Get the DirectX11.1 device by QI off the DirectX11 one.
+    DX::ThrowIfFailed(
+        device.As(&m_d3dDevice)
+        );
+
+    // And get the corresponding device context in the same way.
+    DX::ThrowIfFailed(
+        context.As(&m_d3dContext)
+        );
+}
+
+// Allocate all memory resources that change on a window SizeChanged event.
+void Direct3DBase::CreateWindowSizeDependentResources()
+{ 
+    // Store the window bounds so the next time we get a SizeChanged event we can
+    // avoid rebuilding everything if the size is identical.
+    m_windowBounds = m_window->Bounds;
+
+    // If the swap chain already exists, resize it.
+    if(m_swapChain != nullptr)
+    {
+        DX::ThrowIfFailed(
+            m_swapChain->ResizeBuffers(2, 0, 0, DXGI_FORMAT_B8G8R8A8_UNORM, 0)
+            );
+    }
+    // Otherwise, create a new one.
+    else
+    {
+        // Create a descriptor for the swap chain.
+        DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
+        swapChainDesc.Width = 0;                                     // use automatic sizing
+        swapChainDesc.Height = 0;
+        swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;           // this is the most common swapchain format
+        swapChainDesc.Stereo = false; 
+        swapChainDesc.SampleDesc.Count = 1;                          // don't use multi-sampling
+        swapChainDesc.SampleDesc.Quality = 0;
+        swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+        swapChainDesc.BufferCount = 2;                               // use two buffers to enable flip effect
+        swapChainDesc.Scaling = DXGI_SCALING_NONE;
+        swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // we recommend using this swap effect for all applications
+        swapChainDesc.Flags = 0;
+
+        // Once the desired swap chain description is configured, it must be created on the same adapter as our D3D Device
+
+        // First, retrieve the underlying DXGI Device from the D3D Device
+        ComPtr<IDXGIDevice1>  dxgiDevice;
+        DX::ThrowIfFailed(
+            m_d3dDevice.As(&dxgiDevice)
+            );
+
+        // Identify the physical adapter (GPU or card) this device is running on.
+        ComPtr<IDXGIAdapter> dxgiAdapter;
+        DX::ThrowIfFailed(
+            dxgiDevice->GetAdapter(&dxgiAdapter)
+            );
+
+        // And obtain the factory object that created it.
+        ComPtr<IDXGIFactory2> dxgiFactory;
+        DX::ThrowIfFailed(
+            dxgiAdapter->GetParent(
+                __uuidof(IDXGIFactory2), 
+                &dxgiFactory
+                )
+            );
+
+		Windows::UI::Core::CoreWindow^ p = m_window.Get();
+
+        // Create a swap chain for this window from the DXGI factory.
+        DX::ThrowIfFailed(
+            dxgiFactory->CreateSwapChainForCoreWindow(
+                m_d3dDevice.Get(),
+                reinterpret_cast<IUnknown*>(p),
+                &swapChainDesc,
+                nullptr,    // allow on all displays
+                &m_swapChain
+                )
+            );
+            
+        // Ensure that DXGI does not queue more than one frame at a time. This both reduces 
+        // latency and ensures that the application will only render after each VSync, minimizing 
+        // power consumption.
+        DX::ThrowIfFailed(
+            dxgiDevice->SetMaximumFrameLatency(1)
+            );
+    }
+    
+    // Obtain the backbuffer for this window which will be the final 3D rendertarget.
+    ComPtr<ID3D11Texture2D> backBuffer;
+    DX::ThrowIfFailed(
+        m_swapChain->GetBuffer(
+            0,
+            __uuidof(ID3D11Texture2D),
+            &backBuffer
+            )
+        );
+
+    // Create a view interface on the rendertarget to use on bind.
+    DX::ThrowIfFailed(
+        m_d3dDevice->CreateRenderTargetView(
+            backBuffer.Get(),
+            nullptr,
+            &m_renderTargetView
+            )
+        );
+
+    // Cache the rendertarget dimensions in our helper class for convenient use.
+    D3D11_TEXTURE2D_DESC backBufferDesc;
+    backBuffer->GetDesc(&backBufferDesc);
+    m_renderTargetSize.Width  = static_cast<float>(backBufferDesc.Width);
+    m_renderTargetSize.Height = static_cast<float>(backBufferDesc.Height);
+
+    // Create a descriptor for the depth/stencil buffer.
+    CD3D11_TEXTURE2D_DESC depthStencilDesc(
+        DXGI_FORMAT_D24_UNORM_S8_UINT, 
+        backBufferDesc.Width,
+        backBufferDesc.Height,
+        1,
+        1,
+        D3D11_BIND_DEPTH_STENCIL);
+
+    // Allocate a 2-D surface as the depth/stencil buffer.
+    ComPtr<ID3D11Texture2D> depthStencil;
+    DX::ThrowIfFailed(
+        m_d3dDevice->CreateTexture2D(
+            &depthStencilDesc,
+            nullptr,
+            &depthStencil
+            )
+        );
+
+    // Create a DepthStencil view on this surface to use on bind.
+    DX::ThrowIfFailed(
+        m_d3dDevice->CreateDepthStencilView(
+            depthStencil.Get(),
+            &CD3D11_DEPTH_STENCIL_VIEW_DESC(D3D11_DSV_DIMENSION_TEXTURE2D),
+            &m_depthStencilView
+            )
+        );
+
+    // Create a viewport descriptor of the full window size.
+    CD3D11_VIEWPORT viewPort(
+        0.0f,
+        0.0f,
+        static_cast<float>(backBufferDesc.Width),
+        static_cast<float>(backBufferDesc.Height)
+        );
+        
+    // Set the current viewport using the descriptor.
+    m_d3dContext->RSSetViewports(1, &viewPort);
+}
+
+void Direct3DBase::UpdateForWindowSizeChange()
+{
+    if (m_window->Bounds.Width  != m_windowBounds.Width ||
+        m_window->Bounds.Height != m_windowBounds.Height)
+    {
+        m_renderTargetView = nullptr;
+        m_depthStencilView = nullptr;
+        CreateWindowSizeDependentResources();
+    }
+}
+
+void Direct3DBase::Present()
+{
+    // The first argument instructs DXGI to block until VSync, putting the application
+    // to sleep until the next VSync. This ensures we don't waste any cycles rendering
+    // frames that will never be displayed to the screen.
+    HRESULT hr = m_swapChain->Present(1, 0);
+
+    // If the device was removed either by a disconnect or a driver upgrade, we 
+    // must completely reinitialize the renderer.
+    if (hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET)
+    {
+        Initialize(m_window.Get());
+    }
+    else
+    {
+        DX::ThrowIfFailed(hr);
+    }
+}

package/website/src/website/data/home-samples/sample.csharp.txt

@@ -0,0 +1,38 @@
+/*
+* C# Program to Display All the Prime Numbers Between 1 to 100
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace VS
+{
+	class Program
+	{
+		static void Main(string[] args)
+		{
+			bool isPrime = true;
+			Console.WriteLine("Prime Numbers : ");
+			for (int i = 2; i <= 100; i++)
+			{
+				for (int j = 2; j <= 100; j++)
+				{
+					if (i != j && i % j == 0)
+					{
+						isPrime = false;
+						break;
+					}
+				}
+				
+				if (isPrime)
+				{
+					Console.Write("\t" +i);
+				}
+				isPrime = true;
+			}
+			Console.ReadKey();
+		}
+	}
+}

package/website/src/website/data/home-samples/sample.csp.txt

@@ -0,0 +1 @@
+Content-Security-Policy: default-src 'self'; img-src *; media-src media1.com media2.com; script-src userscripts.example.com