A. Matías Quezada amatiasq

## root-nginx.docker-compose.yml
version: '2'

services:
  nginx-proxy:
    image: nginxproxy/nginx-proxy
    ports:
      - 80:80
      - 443:443
    volumes:
      - vhost:/etc/nginx/vhost.d

## removeWithTransition.ts
function insertWithTransition(el: HTMLElement, activeClass = 'is-active') {
  el.classList.remove(activeClass);

  setTimeout(() => {
    el.classList.add(activeClass);
  }, 0);
}

function removeWithTransition(el: HTMLElement, activeClass = 'is-active') {
  const clone = el.cloneNode(true) as HTMLDivElement;

## html5-dnd.html
<!DOCTYPE html>
<html>
  <head>
    <title>Parcel Sandbox</title>
    <meta charset="UTF-8" />
  </head>

  <body>
    <div id="app">
      <div class="left">Left</div>

## 1-ExposedReferencesTable.cs
using System.Collections.Generic;
using UnityEngine;

public class ExposedReferencesTable : MonoBehaviour, IExposedPropertyTable
{
    public List<PropertyName> properties = new();
    public List<Object> references = new();

    public T Get<T>(ExposedReference<T> reference) where T : Object
    {

## odin.cs
class Example : MonoBehaviour {
  // Assets only
  [AssetsOnly]
  public GameObject SomePrefab;
  [AssetsOnly]
  public List<GameObject> OnlyPrefabs;

  // SceneObjectsOnly
  [SceneObjectsOnly]
  public GameObject SomeSceneObject;

## interface-segregation.cs
using System;

// Interface segregation

interface ISimulationReporter<TResult>
{
    event Action<TResult> OnComplete;
}

interface ISimulationRunner<TInput>

## netcode.test.ts
import { equal } from 'assert';
import { FIRST_FRAME } from './Netcode';
import { NetcodeClient } from './NetcodeClient';
import { NetcodeServer } from './NetcodeServer';

type UserId = 'a' | 'b';
type Input = 'RUN' | null;

interface Entity {
  x: number;

## ts-mockito.ts
import { mock, instance, when, verify, anything } from 'ts-mockito';

const  mockedFoo: Foo = mock(Foo);

// stub method before execution
when(mockedFoo.getBar(3)).thenReturn('three');

// Getting instance from mock
const foo: Foo = instance(mockedFoo);

## esm.ts
const extensions = {
  js: 'application/javascript',
  ts: 'application/typescript',
  jsx: 'text/jsx',
  tsx: 'text/tsx',
} as const;

type Extensions = typeof extensions;
type ValidExtension = keyof Extensions;
type ValidMediaType = Extensions[ValidExtension];

## concatRegexes.js
const createConcatenator = escape => (...regexes) => {
  const join = regexes
    .map(x => (x instanceof RegExp ? regexToString(x) : escape(x)))
    .join("");

  const flags = regexes
    .map(x => x instanceof RegExp && x.flags)
    .filter(Boolean)
    .join("");
	version: '2'

	services:
	nginx-proxy:
	image: nginxproxy/nginx-proxy
	ports:
	- 80:80
	- 443:443
	volumes:
	- vhost:/etc/nginx/vhost.d
	function insertWithTransition(el: HTMLElement, activeClass = 'is-active') {
	el.classList.remove(activeClass);

	setTimeout(() => {
	el.classList.add(activeClass);
	}, 0);
	}

	function removeWithTransition(el: HTMLElement, activeClass = 'is-active') {
	const clone = el.cloneNode(true) as HTMLDivElement;
	<!DOCTYPE html>
	<html>
	<head>
	<title>Parcel Sandbox</title>
	<meta charset="UTF-8" />
	</head>

	<body>
	<div id="app">
	<div class="left">Left</div>
	using System.Collections.Generic;
	using UnityEngine;

	public class ExposedReferencesTable : MonoBehaviour, IExposedPropertyTable
	{
	public List<PropertyName> properties = new();
	public List<Object> references = new();

	public T Get<T>(ExposedReference<T> reference) where T : Object
	{
	class Example : MonoBehaviour {
	// Assets only
	[AssetsOnly]
	public GameObject SomePrefab;
	[AssetsOnly]
	public List<GameObject> OnlyPrefabs;

	// SceneObjectsOnly
	[SceneObjectsOnly]
	public GameObject SomeSceneObject;
	using System;

	// Interface segregation

	interface ISimulationReporter<TResult>
	{
	event Action<TResult> OnComplete;
	}

	interface ISimulationRunner<TInput>
	import { equal } from 'assert';
	import { FIRST_FRAME } from './Netcode';
	import { NetcodeClient } from './NetcodeClient';
	import { NetcodeServer } from './NetcodeServer';

	type UserId = 'a' \| 'b';
	type Input = 'RUN' \| null;

	interface Entity {
	x: number;
	import { mock, instance, when, verify, anything } from 'ts-mockito';

	const mockedFoo: Foo = mock(Foo);

	// stub method before execution
	when(mockedFoo.getBar(3)).thenReturn('three');

	// Getting instance from mock
	const foo: Foo = instance(mockedFoo);
	const extensions = {
	js: 'application/javascript',
	ts: 'application/typescript',
	jsx: 'text/jsx',
	tsx: 'text/tsx',
	} as const;

	type Extensions = typeof extensions;
	type ValidExtension = keyof Extensions;
	type ValidMediaType = Extensions[ValidExtension];
	const createConcatenator = escape => (...regexes) => {
	const join = regexes
	.map(x => (x instanceof RegExp ? regexToString(x) : escape(x)))
	.join("");

	const flags = regexes
	.map(x => x instanceof RegExp && x.flags)
	.filter(Boolean)
	.join("");