const jwt = state.currentUser.jwt;
    .catch(err => console.error(err));
    .patch(`${baseUrl}/games/${gameId}/start`)
    .catch(err => console.error(err));
	}
});
	iconSets.push(newIconSet);
  type: FIRE_FLAME_SUCCESS
  "theme_color": "#000000",
		if (counters[j] % 1 < (increments[j] + 0.00001)) {
		}

    .then(_ => dispatch(joinGameSuccess()))
});
  'python.png',
const fireFlameSuccess = () => ({
  'c.png',
		for (int i = 0; i < stack.size(); ++i) {
  payload: games
}
	}
}
}
		newImg.className = "moving-icon";
 */
		System.out.println(peek());
export const placeBomb = (gameId, position, playerId) => (dispatch, getState) => {
  render() {
### 1.2.7;
const startGameSuccess = () => ({
    - `updated` the current line contains certain characters *(provided they are not part of a string)*;
- the (end of the) current line is part of a multi-line string;
    .set('Authorization', `Bearer ${jwt}`)
  const state = getState();
				if (b < 0) {
 
    .catch(err => console.error(err));
import {isExpired} from '../jwt';
			case "^":
        Vertex other = (Vertex) obj;
{
	for (let i = 0; i < 6; i++) {
        this.id = id;
        if (this == obj)

    .set('Authorization', `Bearer ${jwt}`)
            if (other.id != null)
		push(randomNumber.getRandomNumber(randomIndex));
  const jwt = state.currentUser.jwt;
- the next line starts with certain characters;
  request
}
		newIconSet.push(newA);
    @Override
  'javascript.png',
			if (currentSphereOrders[j] !== 6) {
  const jwt = state.currentUser.jwt;
  const state = getState();
    }
	}
				return aa - bb;
  request
    .set('Authorization', `Bearer ${jwt}`)
}
const spaceBetweenSheres = 0.07;
  }
 * https://github.com/vogellacompany/codeexamples-java/blob/master/de.vogella.algorithms.dijkstra/src/de/vogella/algorithms/dijkstra/model/Vertex.java
	// Push a random following the given archive onto the last slot of the stack
    .post(`${baseUrl}/games`)
  'photoshop.png',
  'rhino.png',

    }
	private int maxSize = 23;
  if (isExpired(jwt)) return dispatch(logout());
		sphereOrders[currentSphereOrders[j]].forEach(function(i) {
    .patch(`${baseUrl}/games/${gameId}/players`)
    .patch(`${baseUrl}/games/${gameId}`)
    - the next line starts with certain characters;
// the spheres follow after one another and then also some "randomness" to make the whole thing feel more organic.
			}
- Added `&` to characters that the next line should not start with to add a semicolon; <br>
public class IntegerStack {
				currentSphereOrders[j]++;				
 * A node of a network/graph.
export const startGame = (gameId) => (dispatch, getState) => {
- Fixed bug with detecting inline `{}` closures;
    {
- Fixed a bug where `//` comments without string-delimiting characters would not be recognised as comments; <br>
    - the current line ends with certain characters;
		try {
function move() {
So yes, the extension is approaching a level where you can basically Ctrl+A and run this command to intelligently place semicolons wherever needed in your JavaScript file! >^<
                return false;
  if (isExpired(jwt)) return dispatch(logout());
 * @author vogella: released under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Germany
  if (!state.currentUser) return null;
    .set('Authorization', `Bearer ${jwt}`)
	}
const hrefSet = ["https://www.facebook.com/jiri.swen", "", "", "https://nl.linkedin.com/in/jiriswen", "", ""];

  request
const currentSphereOrders = [0,1,2,3,4,5,6,0,1,2];
		newImg.src = icons[i].src;
### 1.1.0;
  if (isExpired(jwt)) return dispatch(logout());
const joinGameSuccess = () => ({
    .then(_ => dispatch(placeBombSuccess()))
  ],
  const jwt = state.currentUser.jwt;
    .set('Authorization', `Bearer ${jwt}`)
import VotingButtonsContainer from './VotingButtonsContainer';
![gif-1](readme-images/semicolon-spammer-1.gif)
        return id;
`;;;;;;;;` only has 1 feature: use a command (called `toggleSemicolons` // `Toggle Semicolons`) to add/remove semicolons to the ends of all currently selected lines (or the current line that the cursor is at);
const updateGames = games => ({
    public boolean equals(Object obj) {
    .then(_ => dispatch(updateGameSuccess()))
                                                     addDislike={this.props.addDislike} 
				return aa / bb;
});
This is the README of `;;;;;;;;`. :) <br>
		double bb = b;
  type: PLACE_BOMB_SUCCESS
  type: ADD_GAME,
			iconSets[j][i].style.transform = "translate(" + (svg[j].getPointAtLength(ownCounter * svgLengths[j]).x -15) * 0.10 + "vw, " + (svg[j].getPointAtLength(ownCounter * svgLengths[j]).y -15) * 0.08 + "vh)";
  payload: game
			k++;
  "display": "standalone",
    }
Will only remove if *all* selected lines already have a semicolon at the end;

        int result = 1;
  'net.png',
- the current line ends with a certain character (but does place when that character appears 2 times: e.g. ++/--);

Will not *remove* a semicolon if it's part of a comment / multi-line string;
}
  request
    .get(`${baseUrl}/games`)
  render() {
  "name": "Create React App Sample",
            return false;
			return -2147483648;
				}
  "background_color": "#ffffff"
  state = {  }
import VotingButtons from './VotingButtons';
		return null;
				return aa * bb;
- Made NextLineStartBad able to skip over comments and empty lines;
	for (let j = 0; j < iconSets.length; j++) {
  'indesign.png',
  type: UPDATE_GAME_SUCCESS
Make it so that most filters only work when working in a JS/TS/... file;
  'grasshopper.png',

			System.out.println("Stack underflow.");
});
                                                     profileId={this.props.profile ? this.props.profile.id : null} />}
	public IntegerStack() {}
  'nodejs.png',
	// Print all the numbers stored in memory in order
export const START_GAME_SUCCESS = 'START_GAME_SUCCESS';
		newImgContainer.appendChild(newA);
	// Print the last number in the stack (if available)
let newImgContainer = document.getElementById("new-icons");
// Constants to impact flow of spheres
- the current line starts with certain characters;
			}
	private List<Integer> stack = new ArrayList<Integer>(); // Even after realising that the class 'Stack' already exists, I chose to keep it as an ArrayList because it still works and this way I can demonstrate my understanding of the inner workings.
  'figma.png',
  }
    .post(`${baseUrl}/games/${gameId}/bombs`)
  const state = getState();
		newA = document.createElement("a");
export const PLACE_BOMB_SUCCESS = 'PLACE_BOMB_SUCCESS';
export const FIRE_FLAME_SUCCESS = 'FIRE_FLAME_SUCCESS';
  "start_url": ".",
    final private String id;
  if (isExpired(jwt)) return dispatch(logout());

export const UPDATE_GAME_SUCCESS = 'UPDATE_GAME_SUCCESS';
  const state = getState();
});
const placeBombSuccess = () => ({
        return name;

<br>
### 1.2.8;
### 1.0.0;
			return;
(Maybe add a feature for a different command to basically do `Ctrl+;` and `Ctrl+Enter` in the same command?)
### 1.2.6;
- Enabled closures starting at the next line of their prefix;
	private java.lang.Double operationAB(int a, int b, String operator) throws MathException { // java.lang.Double thing suggested by Nathan Hughes https://stackoverflow.com/questions/17221759/returning-null-in-a-method-whose-signature-says-return-int
	}
    }
 * 
Functions to turn such filters on/off / change which characters/words are affected by them;
  }
  const jwt = state.currentUser.jwt;
		randomIndex += 1;
        return true;
    </div> );
  'graphql.png',
Make the thing intelligent about `<>` closures;
		return stack.get(stack.size() - 1);

    public String getName() {
    - the (end of the) current line is part of a multi-line string;
			stack.set(stack.size() - 2, fit32Bit(operationAB(stack.get(stack.size() - 2), stack.get(stack.size() - 1), operator)));
- The closures for `<>` aren't properly detected because of arrow syntax and less than / greater than;
  type: JOIN_GAME_SUCCESS
            return true;
## Planned Features;
- the current line is empty;
		newA.href = hrefSet[i];
- Added following features:

- Initial release of `;;;;;;;;`;
    public Vertex(String id, String name) {
        this.name = name;
    - the (end of the) current line is part of a `()`/`[]`/`<>` closure;
	// Makes numbers that are too small/large stay at the maximum/minimum of 32-bits
- Added following feature:
  'html.png',
		}
  
	let newIconSet = []
	}
export const fireFlame = (gameId, position, facing) => (dispatch, getState) => {
  - Will not *remove* a semicolon if it's part of a comment / multi-line string;
		if (number > 2147483647) {
  request
  request
import React, { Component } from 'react';
- Updated object recognition to also detect a comma in front of the closure;
import ProfileCardContainer from './ProfileCardContainer';
		}

import java.util.*;
  request
        return name;
const addGame = game => ({
			stack.remove(stack.size() - 1);
- Fixed game-breaking bug crashing the extension when running it in global scope;
});
	// Carry out an operation possible in SRPN on two integers, taking care of exceptions in the process
		}
Checking to what extent this works for TypeScript? (Though I think it should mostly be working already because of the intelligent closure detection!)

	public IntegerStack(int size) {
In this, the 'certain characters' are defined in the file `filterInfo.ts` in the extension files;
- Made closure detection more intelligent to skip commented / string areas;
    .post(`${baseUrl}/games/${gameId}/players`)
public class Vertex { ////from http://www.vogella.com/tutorials/JavaAlgorithmsDijkstra/article.html#copyright-and-license
		else {
			System.out.println("Stack overflow.");
    .catch(err => console.error(err));    
//Class roughly inspired by 'stack' explanation in lecture 4
  'redux.png',
		});
	public void operation(String operator) {
- Fixed bug with most `()` closures being ignored;
					throw new MathException("Divide by 0.");
  'csharp.png',
Because everyone (or at least me) loves using semicolons over... *not* using them... and I'm of course referring to JavaScript, which is what this extension was originally built for. <br>
// Each set also cycles through a series of "orders of the spheres" for every time they start their animation.
	public void printStack() { // 'd' command in calculator
- Fixed a bug where closures were improperly detected by removing the detecting of `<>` closures;
import * as request from 'superagent';
const sphereOrders = [[3,5,2,1,4,0],[0,1,2,3,4,5],[1,4,0,2,5,3],[5,4,1,2,0,3],[1,2,4,3,0,5],[2,5,4,1,0,3],[3,4,0,5,2,1]]
		else {
}
  handleLike = () => {
 * @see {@link DijkstraAlgorithm.java}
// Every set of 6 spheres has its own counter which increases more rapidly for shorter paths 
    - the current line is part of a `{}` closure that is an object;
export const UPDATE_GAME = 'UPDATE_GAME';
}
}
 * @see {@link Edge.java}
- the current line is part of a `{}` closure that is an object;
}
const svgLengths = [];
	svgLengths.push(svg[j].getTotalLength());
export default VotingButtonsContainer;
    .then(result => dispatch(addGame(result.body)))
    }

![gif-2](readme-images/semicolon-spammer-2.gif)
Built-in `Ctrl+;` shortcut;
- the current line ends with certain characters;
  const state = getState();
Maybe support for JSX? (For the time being, to make it work you can put your JSX in parentheses (`()`), and close your 'JS in JSX' (`{}`) elements on the line they were opened or start them on a new line);
    }
		}
	private RandomCNumbersArchive randomNumber = new RandomCNumbersArchive();
		switch (operator) {
  handleDislike = () => {
      {this.props.profile && <VotingButtonsContainer addLike={this.props.addLike} 
		newImg = document.createElement("img");
	public void peekPrint() {
    this.props.addLike(this.props.profileId);
			let ownCounter = (counters[j] - spaceBetweenSheres * k - 0.1 * j - 0.5 * (j % 2)) % 1;
	requestAnimationFrame(move); // A function calling itself 60 times per second, yeah that's definitely a good idea
		let k = 0;
# Semicolon-Spammer README;
		if (stack.size() < 2) {
    .set('Authorization', `Bearer ${jwt}`)
		}
			stack.add(fit32Bit(newNumber));
		}
		}
import React, { Component } from 'react'
const speed = 2;
    .then(_ => dispatch(startGameSuccess()))
	public int peek() {
## Features;
### 1.2.9;
  }
let svg = canvas.getElementsByTagName("path");
  'git.png',
    .catch(err => console.error(err));    
		double aa = a; // Integers are first casted into doubles so that the calculation going 'out of the bounds of 32-bit' can be handled
    public String getId() {
const counters = [2,2,2,2,2,2,2,2,2,2];
    .send({ board })
## Release Notes;
		catch (MathException e) {
    @Override
    .catch(err => console.error(err));
		}
  'sketchup.png',
    .set('Authorization', `Bearer ${jwt}`)
    }

    .send({ position, facing })
			System.out.println(stack.get(i));
  if (isExpired(jwt)) return dispatch(logout());
  const state = getState();
        return result;
		if (stack.size() < maxSize) {
## Known Issues;
  'sql.png',
			case "+":
    - the current line ends with a `}` of a closure that is not an object;
				}

    final private String name;
		if (stack.isEmpty()) {
Will eventually make this editable; <br>
    .then(_ => dispatch(updateGameSuccess()))
	}
 * @see {@link Graph.java}
  const jwt = state.currentUser.jwt;
export const UPDATE_GAMES = 'UPDATE_GAMES';
  const jwt = state.currentUser.jwt;
export const createGame = () => (dispatch, getState) => {
  'react.png',
    .catch(err => console.error(err));
    .then(result => dispatch(updateGames(result.body)))
- All the closure detecting has made the semicolon placing sometimes slightly too slow for my preference (esp. with larger quantities/documents);

  'unreal.png'
- the (end of the) current line is part of a `()`/`[]` closure;
		}
let canvas = document.getElementById("icon-jumble");
export const getGames = () => (dispatch, getState) => {
}
// lengths of the SVG curves and the corresponding amount to increment their counters with
		newA.appendChild(newImg);
    - the current line is empty;
				currentSphereOrders[j] = 0;
				return aa + bb;
    public String toString() {
}
	private int randomIndex = 0;
			maxSize = size;
		newA.target = "_blank";
    .set('Authorization', `Bearer ${jwt}`)
      <ProfileCardContainer profile={this.props.profile} match={this.props.match} />
  const jwt = state.currentUser.jwt;

	}
		else if (number < -2147483647) {
requestAnimationFrame(move);
  'ruby.png',
export const joinGame = (gameId) => (dispatch, getState) => {
  const state = getState();
	public void push(double newNumber) {
			case "-":
    .send({ position, playerId })
			return;
/**
  'sass.png',
	private int fit32Bit(double number) {

export const updateCurrentPlayerPosition = (gameId, position, facing) => (dispatch, getState) => {
					throw new MathException("Negative power.");
    .then(_ => dispatch(fireFlameSuccess()))
			case "*":
}
      "src": "favicon.ico",
		counters[j] += increments[j];
- the current line ends with a `}` of a closure that is not an object;
## Demo;
 * @release 30/08/2010
// Preparatory work: lots of copies of the social media spheres are created and put in a 2D array for 
			else {
			return;
		}

		}
    .send({ position, facing })
import {baseUrl} from '../constants';
class VotingButtonsContainer extends Component {

### 1.1.1;
    - the current line ends with a certain character (but does place when that character appears 2 times: e.g. ++/--);
        final int prime = 31;
}
- Added some valid characters and words to the filterInfo;
			case "/":
    return ( <VotingButtons handleLike={this.handleLike} handleDislike={this.handleDislike} /> );
  - Will not place a semicolon when:
				return Math.pow(aa, bb);
  'illustrator.png',
// (because it's the percentage of the total length), and within every set a delay is applied to make
	}
});
import {logout} from './users';
	// Push a number onto the last slot of the stack
];
    this.props.addDislike(this.props.profileId);
const updateGameSuccess = () => ({
	// Return the last number in the stack
  if (isExpired(jwt)) return dispatch(logout());
for (let j = 0; j < svg.length; j++) {
			case "%":
            return false;
 * @see {@link DijkstraOperations.java}
        result = prime * result + ((id == null) ? 0 : id.hashCode());

export const ADD_GAME = 'ADD_GAME';
    - the current line contains certain characters;
  'typescript.png',
    return ( <div>
    public int hashCode() {
let icons = document.getElementsByClassName("icon");
  "short_name": "React App",
  'java.png',
  if (isExpired(jwt)) return dispatch(logout());
    - the current line starts with certain characters;
- the current line contains certain characters (provided they are not part of a string);
      "sizes": "64x64 32x32 24x24 16x16",
    .catch(err => console.error(err));
	}
export const JOIN_GAME_SUCCESS = 'JOIN_GAME_SUCCESS';
  type: UPDATE_GAMES,
  request
Will *not* place a semicolon when:
        } else if (!id.equals(other.id))
class ProfileBrowser extends Component {
            return false;
### 1.2.3;
const increments = [];
        if (getClass() != obj.getClass())
// the animation-action that's about to follow, and also an array of all the 
  - Will *not* place a semicolon when:
	public void pushRandom() {
		}
  const state = getState();
export default [
    .post(`${baseUrl}/games/${gameId}/flames`)
const iconSets = [];
(Which is why for the time being they have been removed;)
- the (end of the) current line is part of a comment;
			System.out.println("Stack empty.");
### 1.2.0;
  "icons": [
      "type": "image/x-icon"
	// Apply submitted operator to the last 2 items on the stack
	}
			return (int) number;
			return;
		if (stack.size() < maxSize) {
	increments.push(1 / svgLengths[j] * speed);
### 1.2.5;
  type: START_GAME_SUCCESS
- Made it work for multi-line decorators; <br>
}
		newA.style.position = "absolute";
        if (id == null) {
    @Override
  if (isExpired(jwt)) return dispatch(logout());
        if (obj == null)
				return aa % bb;
- Added following features:

				if (b == 0) {

    - the (end of the) current line is part of a comment;
export default ProfileBrowser;
export const updateGame = (gameId, board) => (dispatch, getState) => {
			return 2147483647;
  'css.png',
shining effectsunraysfloating head

ABOUT

landscape 1awards-cupfuture-buildinghobby-heap
jiri soul containerjiri soul pupils
octopus-treespiral-towertechnology-forest
bookbookbookbookbookbookbookbookbookbookbook
contact-details
osu! db manipulator