diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..eedfdfd --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +/node_modules +/assets +.idea \ No newline at end of file diff --git a/README.md b/README.md index d89f1ab..e0724d7 100644 --- a/README.md +++ b/README.md @@ -1 +1,13 @@ -# js-minesweeper \ No newline at end of file +# js-minesweeper + +## Основные правила: + +* Для начала игры необходимо указать размер игрового поля и количество мин и нажать "Start"; +* Открытие ячейки осуществляется кликом левой кнопкой мыши; +* Установка/снятие флажка - правая кнопка мыши; +* Игра заканчивает в случае, если: + * Все ячейки с минами помечены фалжками, а все остальные ячейки открыты - победа; + * Открыта любая ячейка с миной - поражение. +* В случае победы результат (количество потраченных на игру секунд) фиксируется локалльно (localStorage), выводится таблица с результатами. +Текущий результат выделен серым цветом. + diff --git a/frontend/js/app.js b/frontend/js/app.js new file mode 100644 index 0000000..ae153ea --- /dev/null +++ b/frontend/js/app.js @@ -0,0 +1,7 @@ +'use strict'; + +let Game = require('./game'); + +let game = new Game({ + element: document.querySelector('[data-component="game"]') +}); \ No newline at end of file diff --git a/frontend/js/constants.js b/frontend/js/constants.js new file mode 100644 index 0000000..008b546 --- /dev/null +++ b/frontend/js/constants.js @@ -0,0 +1,39 @@ +'use strict'; + +exports.CellType = { + EMPTY: 0, + MINE: -1 +}; + +exports.GameState = { + START: 0, + WIN: 1, + LOST: 2 +}; + +exports.Default = { + COLUMNS: 9, + ROWS: 9, + MINES: 10, + MIN_ROWS: 9, + MAX_ROWS: 20, + MIN_COLUMNS: 9, + MAX_COLUMNS: 20, + MIN_MINES: 2, + MAX_MINES: 40 +}; + +exports.Selectors = { + ROWS_INPUT: '[name="rows"]', + COLUMNS_INPUT: '[name="columns"]', + MINES_INPUT: '[name="mines"]', + MINES_RANGE_TEXT: '[data-range="mines"]' +}; + +exports.Classes = { + EMPTY: 'cell-empty', + MINE: 'cell-mine', + NUMBER: 'cell-number', + MARKED: 'cell-marked', + HIGHLIGHT: 'cell-highlight' +}; \ No newline at end of file diff --git a/frontend/js/controls.js b/frontend/js/controls.js new file mode 100644 index 0000000..ddafcbd --- /dev/null +++ b/frontend/js/controls.js @@ -0,0 +1,184 @@ +'use strict'; + +let Dispatcher = require('./dispatcher'); +let Default = require('./constants').Default; +let Selectors = require('./constants').Selectors; +let controlsTemplate = require('../templates/controls-template.hbs'); + +/** + * Class representing the control panel + */ +class Controls extends Dispatcher { + /** + * Create controls + * @param options + */ + constructor(options) { + super(options); + + this._render(); + this._timer = options.timer; + this._timerEl = this._el.querySelector('[data-content="timer"]'); + this._addListeners(); + } + + /** + * Render controls from template + * @private + */ + _render() { + let defaultOptions = { + minRows: Default.MIN_ROWS, + maxRows: Default.MAX_ROWS, + minCols: Default.MIN_COLUMNS, + maxCols: Default.MAX_COLUMNS, + minMines: Default.MIN_MINES, + maxMines: Default.MAX_MINES, + rows: Default.ROWS, + cols: Default.COLUMNS, + mines: Default.MINES + }; + + this._el.innerHTML = controlsTemplate({ + options: defaultOptions + }); + + this._rowsInput = this._el.querySelector(Selectors.ROWS_INPUT); + this._columnsInput = this._el.querySelector(Selectors.COLUMNS_INPUT); + this._minesInput = this._el.querySelector(Selectors.MINES_INPUT); + this._minesRangeText = this._el.querySelector(Selectors.MINES_RANGE_TEXT); + } + + /** + * Add main listeners for click (start game), timer update, and options input change + * @private + */ + _addListeners() { + this._el.addEventListener('click', this._onClick.bind(this)); + this._el.addEventListener('change', this._onChange.bind(this)); + this._timer.addEventListener('timeUpdate', this._onTimerUpdate.bind(this)); + } + + /** + * 'Click' event handler + * @param {MouseEvent} event - click event + * @private + */ + _onClick(event) { + var startBtn = event.target.closest('[data-action="start"]'); + + if (!startBtn) { + return + } + this._triggerStart(); + } + + /** + * Implement start - dispatch 'start' event with current options + * @private + */ + _triggerStart() { + let options = this._getOptions(); + + this.dispatchEvent('start', options); + } + + /** + * 'Change' event hadler + * @param {Event} event - change event + * @private + */ + _onChange(event) { + let optionsForm = event.target.closest('[name="options-form"]'); + + if (!optionsForm) { + return; + } + + this._validateOptions(); + } + + /** + * Validate current options + * @private + */ + _validateOptions() { + let options = this._getOptions(); + //Check if input is not valid number + if (isNaN(options.columns)) { + options.columns = Default.MIN_COLUMNS; + } + if (isNaN(options.rows)) { + options.rows = Default.MIN_ROWS; + } + if (isNaN(options.mines)) { + options.rows = Default.MIN_MINES; + } + + options.rows = Math.max(Default.MIN_ROWS, Math.min(options.rows, Default.MAX_ROWS)); + options.columns = Math.max(Default.MIN_COLUMNS, Math.min(options.columns, Default.MAX_COLUMNS)); + + //Calculate mines max range + let maxMines = this._getMinesMaxRange(options.rows, options.columns); + options.mines = Math.max(Default.MIN_MINES, Math.min(options.mines, maxMines)); + //Set mines range + this._minesRangeText.textContent = `(${Default.MIN_MINES}-${maxMines})`; + this._minesInput.max = Default.MIN_MINES; + this._minesInput.max = maxMines; + + this._setOptions(options); + } + + /** + * Get options from DOM + * @returns {{rows: Number, columns: Number, mines: Number}} + * @private + */ + _getOptions() { + return { + rows: parseInt(this._rowsInput.value), + columns: parseInt(this._columnsInput.value), + mines: parseInt(this._minesInput.value) + } + } + + /** + * Set options to DOM + * @param options + * @private + */ + _setOptions(options) { + this._rowsInput.value = options.rows; + this._columnsInput.value = options.columns; + this._minesInput.value = options.mines; + } + + _getMinesMaxRange(rows, columns) { + return Math.round(rows * columns / 2); + } + + /** + * Render new timer value + * @param {CustomEvent} event + * @private + */ + _onTimerUpdate(event) { + let time = event.detail; + let min = Math.floor(time / 60); + let sec = time % 60; + + this._timerEl.textContent = `${this._twoDigits(min)}:${this._twoDigits(sec)}`; + } + + /** + * Convert n to two-digit string + * @param {Number} n + * @private + */ + _twoDigits(n) { + return ('0' + n).slice(-2); + } +} + + +module.exports = Controls; diff --git a/frontend/js/dispatcher.js b/frontend/js/dispatcher.js new file mode 100644 index 0000000..2200904 --- /dev/null +++ b/frontend/js/dispatcher.js @@ -0,0 +1,43 @@ +'use strict'; +/** + * Class representing the base event dispathcer + */ +class Dispatcher { + /** + * Crrate dispatcher + * @param options + */ + constructor(options) { + options = options || {}; + this._el = options.element || document.createElement('div'); + } + + /** + * Add event handler + * @param {string} type + * @param {function} handler + * @param {boolean} capture - use capture + */ + addEventListener(type, handler, capture) { + this._el.addEventListener(type, handler, capture); + } + + /** + * Dispatch custom event + * @param {string} type + * @param detail - event data + * @param {object} options + */ + dispatchEvent(type, detail, options) { + options = options || {}; + + if (detail != undefined) { + options.detail = detail; + } + + let event = new CustomEvent(type, options); + this._el.dispatchEvent(event); + } +} + +module.exports = Dispatcher; \ No newline at end of file diff --git a/frontend/js/fieldModel.js b/frontend/js/fieldModel.js new file mode 100644 index 0000000..f3297c0 --- /dev/null +++ b/frontend/js/fieldModel.js @@ -0,0 +1,110 @@ +'use strict'; + +let CellType = require('./constants').CellType; + +/** + * Class representing a game field + */ +class FieldModel { + /** + * Create a field + * @param options + */ + constructor(options) { + options = options || {}; + this.rows = options.rows || Default.ROWS; + this.columns = options.columns || Default.COLUMNS; + this.mines = options.mines || Default.MINES; + } + + /** + * Generate new field with mines, numbers and empty cells + */ + generate() { + let placedMines = 0; + + this._field = []; // start with empty array + for (let i = 0; i < this.rows; i++) { // generate empty rows + this._field[i] = []; + } + + // place mines at random position unit reach the number of mines + while (placedMines < this.mines) { + let rowIndex = Math.floor(Math.random() * this.rows); + let columnIndex = Math.floor(Math.random() * this.columns); + + if (this.getCellType(rowIndex, columnIndex) === CellType.MINE) { + continue; + } + + this._field[rowIndex][columnIndex] = CellType.MINE; + placedMines++; + } + + // place numbers in all mines neighbours cells + for (let i = 0; i < this.rows; i++) { + for (let j = 0; j < this.columns; j++) { + if (this.getCellType(i, j) === CellType.MINE) { + let mineNeighbours = this.getNeighbours(i, j); + + mineNeighbours.forEach(cellObj => { + if (cellObj.type !== CellType.MINE) { + this._field[cellObj.row][cellObj.column] = cellObj.type + 1; + } + }); + } + } + } + } + + /** + * Get only type for particular cell + * @param row + * @param column + * @returns {number} - cell type (see constants.Defaults) + */ + getCellType(row, column) { + return this._field[row][column] || CellType.EMPTY; + } + + /** + * Get cell object + * @param row + * @param column + * @returns {{column: number, row: number, type: number}} + */ + getCell(row, column) { + return { + column: column, + row: row, + type: this.getCellType(row, column) + } + } + + /** + * Get neighbours of particular cell + * @param row + * @param column + * @returns {Array} - array of neighbours + */ + getNeighbours(row, column) { + let neighbours = []; + let minCol = Math.max(0, column - 1); + let maxCol = Math.min(this.columns - 1, column + 1); + let minRow = Math.max(0, row - 1); + let maxRow = Math.min(this.rows - 1, row + 1); + + for (let i = minRow; i <= maxRow; i++) { + for (let j = minCol; j <= maxCol; j++) { + if (i === row && j === column) { + continue; + } + neighbours.push(this.getCell(i, j)); + } + } + + return neighbours; + } +} + +module.exports = FieldModel; \ No newline at end of file diff --git a/frontend/js/game.js b/frontend/js/game.js new file mode 100644 index 0000000..bff1fdc --- /dev/null +++ b/frontend/js/game.js @@ -0,0 +1,298 @@ +'use strict'; + +let GameModel = require('./gameModel.js'); +let Controls = require('./controls'); +let Modal = require('./modal'); +let CellType = require('./constants').CellType; +let Classes = require('./constants').Classes; +let GameState = require('./constants').GameState; +let Default = require('./constants').Default; +let Results = require('./results'); +let Timer = require('./timer'); + +let fieldTemplate = require('../templates/field-template.hbs'); +/** + * Class representing the main game manager + */ +class Game { + /** + * Create game controller + * @param options + */ + constructor(options) { + this._el = options.element; + this._fieldWrapper = this._el.querySelector('[data-component="field"]'); + + //Bind listeners + this._onFieldLeftClick = this._onFieldLeftClick.bind(this); + this._onFieldRightClick = this._onFieldRightClick.bind(this); + this._onMouseDown = this._onMouseDown.bind(this); + this._onMouseUp = this._onMouseUp.bind(this); + //Current click - collect data about simultaneous click + this._currentClick = {}; + + this._gameModel = new GameModel(); + this._gameModel.addEventListener('stateChange', this._onGameStateChange.bind(this)); + this._gameModel.addEventListener('cellOpen', this._onCellOpen.bind(this)); + this._gameModel.addEventListener('cellToggle', this._onCellToggle.bind(this)); + this._gameModel.addEventListener('cellHighlight', this._onCellHighlight.bind(this)); + this._gameModel.addEventListener('cellClearHighlight', this._onCellClearHighlight.bind(this)); + + this._timer = new Timer(); + + let controls = new Controls({ + element: this._el.querySelector('[data-component="controls"]'), + timer: this._timer + }); + controls.addEventListener('start', this._onStart.bind(this)); + + //Render default field + this.start({ + rows: Default.ROWS, + columns: Default.COLUMNS, + mines: Default.MINES + }); + } + + /** + * Start new game with provided options + * @param options + */ + start(options) { + this._renderField(options); + this._addListeners(); + this._gameModel.start(options); + this._firstClick = false; + this._timer.reset(); + } + + /** + * Handle start event from controls panel + * @param {CustomEvent} event + * @private + */ + _onStart(event) { + let options = event.detail; + + this.start(options); + } + + /** + * Render new game field + * @param options + * @private + */ + _renderField(options) { + this._fieldWrapper.innerHTML = fieldTemplate(options);//fieldHTML; + this._fieldEl = this._fieldWrapper.querySelector('table'); + } + + /** + * Add listeners to user interaction + * @private + */ + _addListeners() { + this._fieldEl.addEventListener('click', this._onFieldLeftClick); + this._fieldEl.addEventListener('contextmenu', this._onFieldRightClick); + this._fieldEl.addEventListener('mousedown', this._onMouseDown.bind(this)); + document.addEventListener('mouseup', this._onMouseUp.bind(this)); + } + + /** + * Remove listeners to prevent interaction when game is over + * @private + */ + _removeListeners() { + this._fieldEl.removeEventListener('click', this._onFieldLeftClick); + this._fieldEl.removeEventListener('contextmenu', this._onFieldRightClick); + this._fieldEl.removeEventListener('mousedown', this._onMouseDown.bind(this)); + document.removeEventListener('mouseup', this._onMouseUp.bind(this)); + } + + /** + * User clicks left mouse button + * @param {MouseEvent} event + * @private + */ + _onFieldLeftClick(event) { + let targetCell = this._getClickedCell(event); + + if (targetCell) { + this._checkFirstClick(); + this._gameModel.openCell(targetCell.parentNode.sectionRowIndex, targetCell.cellIndex); + } + } + + /** + * User clicks left mouse button + * @param {MouseEvent} event + * @private + */ + _onFieldRightClick(event) { + let targetCell = this._getClickedCell(event); + + if (targetCell) { + this._checkFirstClick(); + this._gameModel.markCell(targetCell.parentNode.sectionRowIndex, targetCell.cellIndex); + } + + event.preventDefault(); + } + + /** + * User presses mouse button + * @param event + * @private + */ + _onMouseDown(event) { + let targetCell = this._getClickedCell(event); + let currentCell = this._currentClick.cell; + + if (!targetCell || (currentCell && targetCell !== currentCell)) { + this._resetCurrentClick(); + return; + } + + this._currentClick.cell = targetCell; + switch (event.which) { + case 1: + this._currentClick.left = true; + break; + case 3: + this._currentClick.right = true; + break; + } + + if (this._currentClick.left && this._currentClick.right) { + this._gameModel.highlightCell(targetCell.parentNode.sectionRowIndex, targetCell.cellIndex); + } + } + + /** + * User releases mouse button + * @param event + * @private + */ + _onMouseUp(event) { + let targetCell = this._getClickedCell(event); + let currentCell = this._currentClick.cell; + let twoButtonsDown = this._currentClick.left && this._currentClick.right; + + if (targetCell && currentCell && targetCell == currentCell && twoButtonsDown) { + this._gameModel.openHighlighted(); + } + this._gameModel.clearHighlight(); + this._resetCurrentClick(); + } + + _resetCurrentClick() { + this._currentClick = {}; + } + /** + * Check if the click is the first for this new game + * @private + */ + _checkFirstClick() { + if (!this._firstClick) { + this._firstClick = true; + this._timer.start(); + } + } + + _getClickedCell(event) { + let target = event.target; + + return target.closest('td'); + } + + /** + * Handle cell opening and update the cell view state + * @param {CustomEvent} event + * @private + */ + _onCellOpen(event) { + let cell = event.detail; + let cellType = cell.type; + let cellEl = this._fieldEl.rows[cell.row].cells[cell.column]; + + switch (cellType) { + case CellType.EMPTY: + cellEl.classList.add(Classes.EMPTY); + break; + case CellType.MINE: + cellEl.classList.add(Classes.MINE); + break; + default: + cellEl.classList.add(Classes.NUMBER); + cellEl.innerHTML = cellType; + } + } + /** + * Handle cell toggling and update the cell view state (place/remove flag) + * @param {CustomEvent} event + * @private + */ + _onCellToggle(event) { + let cell = event.detail; + let cellEl = this._fieldEl.rows[cell.row].cells[cell.column]; + + cellEl.classList.toggle(Classes.MARKED); + } + /** + * Handle cell highlight (highlight neighbours when two buttons pressed on the cell with number) + * @param {CustomEvent} event + * @private + */ + _onCellHighlight(event) { + let cell = event.detail; + let cellEl = this._fieldEl.rows[cell.row].cells[cell.column]; + + cellEl.classList.add(Classes.HIGHLIGHT); + } + _onCellClearHighlight(event) { + let cell = event.detail; + let cellEl = this._fieldEl.rows[cell.row].cells[cell.column]; + + cellEl.classList.remove(Classes.HIGHLIGHT); + } + + _onGameStateChange(event) { + let state = event.detail; + + switch (state) { + case GameState.LOST: + case GameState.WIN: + this._end(state); + break; + } + } + + /** + * Game is over - show message, clear game data and remove listeners + * @param state + * @private + */ + _end(state) { + let isWin = (state === GameState.WIN); + + this._timer.stop(); + this._removeListeners(); + + let message = `You ${isWin ? 'WIN' : 'LOSE'}`; + let modal = new Modal({ + placeholder: this._el, + title: message + }); + + if (isWin) { + Results.save(this._timer.getValue()); + modal.setContent(Results.render()); + } + + modal.show(); + } +} + +module.exports = Game; + + diff --git a/frontend/js/gameModel.js b/frontend/js/gameModel.js new file mode 100644 index 0000000..8166f1a --- /dev/null +++ b/frontend/js/gameModel.js @@ -0,0 +1,201 @@ +'use strict'; + +let Dispatcher = require('./dispatcher'); +let FieldModel = require('./fieldModel'); +let GameState = require('./constants').GameState; +let CellType = require('./constants').CellType; + +const DELIMITER = '-'; +/** + * Class representing the game model + */ +class GameModel extends Dispatcher { + /** + * Create game model + * @param options + */ + constructor(options) { + super(options); + } + + /** + * Start new game with provideed oprions + * @param gameOptions + */ + start(gameOptions) { + this._openedCells = {}; //make object for easy access by index ('2-3'); + this._markedCells = {}; + this._highlightedCells = {}; + this._field = new FieldModel(gameOptions); + this._field.generate(); + this.setState(GameState.START); + } + + setState(state) { + //WIN and LOST - terminate states. Could only set state to START from them + if (state !== GameState.START && (this._state === GameState.WIN || this._state === GameState.LOST)) { + return; + } + + this._state = state; + this.dispatchEvent('stateChange', this._state); + //this._onStateChange(this._state); + } + + /** + * Mark cell (has mine/has no mine) + * @param row + * @param column + */ + markCell(row, column) { + if (this._openedCells[row + DELIMITER + column]) { + return; + } + + this._markedCells[row + DELIMITER + column] = !this._markedCells[row + DELIMITER + column]; + this.dispatchEvent('cellToggle', this._field.getCell(row, column)); + this._checkGameState(); + } + + /** + * Trt to pen cell and check its "content" + * @param row + * @param column + */ + openCell(row, column) { + let cell = this._checkAndOpenCell(row, column); + + if (!cell) { //cell was already opened + return; + } + switch (cell.type) { + case CellType.EMPTY: //Cell is empty - open all neighbours cells + let neighbours = this._field.getNeighbours(row, column); + neighbours.forEach((neighbourCell) => { //we don't have to check mine because empty neighbours are not mines + let neighbourRow = neighbourCell.row; + let neighbourColumn = neighbourCell.column; + + this.openCell(neighbourRow, neighbourColumn); + }); + break; + case CellType.MINE: // Cell has mine - game is over + this._openAll(); + this.setState(GameState.LOST); + break; + } + + this._checkGameState(); + } + + /** + * Hightlight all cells neighbours if the cell has number and it eual to number of marked neighbours + * @param row + * @param column + */ + highlightCell(row, column) { + let cellType = this._field.getCellType(row, column); + let cellIsOpened = this._openedCells[row + DELIMITER + column]; + if (!cellIsOpened && cellType > 0) { + return; + } + let neighbours = this._field.getNeighbours(row, column); + let markedNeighbours = neighbours.filter((neighbourCell) => { + return this._markedCells[neighbourCell.row + DELIMITER + neighbourCell.column]; + }).length; + + if (markedNeighbours !== cellType) { + return; + } + neighbours.forEach((neighbourCell) => { //we don't have to check mine because empty neighbours are not mines + let neighbourRow = neighbourCell.row; + let neighbourColumn = neighbourCell.column; + let neighbourIsOpened = this._openedCells[neighbourRow + DELIMITER + neighbourColumn]; + let neighbourIsMarked = this._markedCells[neighbourRow + DELIMITER + neighbourColumn]; + + if (!neighbourIsOpened && !neighbourIsMarked) { + this._highlightedCells[neighbourRow + DELIMITER + neighbourColumn] = true; + this.dispatchEvent('cellHighlight', neighbourCell); + } + }); + } + + /** + * Open all cell, that are currently highlighted (by pressing two buttons on mumber cell) + */ + openHighlighted() { + for (let i = 0; i < this._field.rows; i++) { + for (let j = 0; j < this._field.columns; j++) { + if (!this._highlightedCells[i + DELIMITER + j]) { + continue; + } + this.openCell(i, j); + } + } + } + + /** + * Clear highlight for all cells + */ + clearHighlight() { + for (let i = 0; i < this._field.rows; i++) { + for (let j = 0; j < this._field.columns; j++) { + if (!this._highlightedCells[i + DELIMITER + j]) { + continue; + } + let cell = this._field.getCell(i, j); + + this._highlightedCells[i + DELIMITER + j] = false; + this.dispatchEvent('cellClearHighlight', cell); + } + } + } + /** + * Open cell only it is available + * @param row + * @param column + * @param {boolean} force - open anyway (when game is over) + * @returns {*} + * @private + */ + _checkAndOpenCell(row, column, force) { + let cellOpened = this._openedCells[row + DELIMITER + column]; + let cellMarked = this._markedCells[row + DELIMITER + column]; + + if (!cellOpened && !cellMarked || force) { + let cell = this._field.getCell(row, column); + + this._openedCells[row + DELIMITER + column] = true; + this.dispatchEvent('cellOpen', cell); + + return cell; + } + return null; + } + + _checkGameState() { + //Get number of opened cells and number of cells with mines + let openedCells = Object.keys(this._openedCells).length; + let totalMines = this._field.mines; + let totalCells = this._field.rows * this._field.columns; + + // All "safe" cells are opened + if (openedCells + totalMines === totalCells) { + this._openAll(); + this.setState(GameState.WIN); + } + } + + /** + * Open all cells (when game is over) + * @private + */ + _openAll() { + for (let i = 0; i < this._field.rows; i++) { + for (let j = 0; j < this._field.columns; j++) { + this._checkAndOpenCell(i, j, true); + } + } + } +} + +module.exports = GameModel; \ No newline at end of file diff --git a/frontend/js/modal.js b/frontend/js/modal.js new file mode 100644 index 0000000..afec9ee --- /dev/null +++ b/frontend/js/modal.js @@ -0,0 +1,63 @@ +'use strict'; + +let modalTemplate = require('../templates/modal-template.hbs'); + +class Modal { + constructor(options) { + this._placeholder = options.placeholder; + this._options = options; + this._content = ''; + } + + show() { + //Lazy rendering + if (!this._el) { + this._render(); + } + if (!this._el.parentNode) { + this._placeholder.appendChild(this._el); + } + } + + hide() { + this._placeholder.removeChild(this._el); + } + + setContent(content) { + this._content = content; + } + + _render() { + this._el = document.createElement('div'); + //Append generated HTML to wrapper + this._el.innerHTML = modalTemplate({ + title: this._options.title, + content: this._content + }); + //Set delay for animation + setTimeout(()=>{ + this._el.querySelector('.modal').classList.remove('js-modal-hidden'); + },20); + this._el.addEventListener('click', this._onCloseClick.bind(this)); + this._el.addEventListener('contextmenu', this._onContextMenu.bind(this)); + + return this._el; + } + + _onCloseClick(event) { + let closeBtn = event.target.closest('[data-action="close"]'); + + if (closeBtn) { + this.hide(); + } + } + + /** + * Prevent context menu on modal + */ + _onContextMenu(event) { + event.preventDefault(); + } +} + +module.exports = Modal; \ No newline at end of file diff --git a/frontend/js/results.js b/frontend/js/results.js new file mode 100644 index 0000000..a5ed30e --- /dev/null +++ b/frontend/js/results.js @@ -0,0 +1,65 @@ +'use strict'; + +let resultsTemplate = require('../templates/results-template.hbs'); +/** + * Object representing the storage interface + */ +let Results = (function() { + let storageName = '_minesweeper_data_'; + + /** + * Get collected data for previous games from localStorage + * @private + */ + function _getFromStorage() { + let results = window.localStorage.getItem(storageName); + + return results ? JSON.parse(results) : []; + } + + /** + * Save new result (seconds) + * @param result + */ + function _save(result) { + let results = _getFromStorage(); + let resultToSave = { + time: result, + date: Date.now() + }; + + results.push(resultToSave); + window.localStorage.setItem(storageName, JSON.stringify(results)); + } + + /** + * Render current data from storage to simple table + * @returns {string} table HTML + */ + function _render() { + let results = _getFromStorage(); + let totalResults = results.length; + //Convert date from ms to local format + results.forEach(function(result, i) { + result.date = (new Date(result.date)).toLocaleDateString(); + if (i == totalResults -1) { //Mark result as current + result.current = true; + } + }); + //Range results + results.sort(function(a, b) { + return a.time - b.time; + }); + + return resultsTemplate({ + results: results + }); + } + + return { + save: _save, + render: _render + } +})(); + +module.exports = Results; diff --git a/frontend/js/timer.js b/frontend/js/timer.js new file mode 100644 index 0000000..934bbca --- /dev/null +++ b/frontend/js/timer.js @@ -0,0 +1,37 @@ +'use strict'; + +let Dispatcher = require('./dispatcher'); + +class Timer extends Dispatcher { + + start() { + this.startTime = Date.now(); + this.interval = setInterval(() => { + this.update(); + }, 1000); + this.update(); + } + + stop() { + if (this.interval) { + clearInterval(this.interval); + } + } + + reset() { + this.stop(); + this.startTime = Date.now(); + this.update(); + } + + update() { + this._current = Math.round((Date.now() - this.startTime) / 1000); + this.dispatchEvent('timeUpdate', this._current); + } + + getValue() { + return this._current; + } +} + +module.exports = Timer \ No newline at end of file diff --git a/frontend/templates/controls-template.hbs b/frontend/templates/controls-template.hbs new file mode 100644 index 0000000..e0be701 --- /dev/null +++ b/frontend/templates/controls-template.hbs @@ -0,0 +1,20 @@ +
+
+ + + +
+
+
+ 00:00 +
+
Start
\ No newline at end of file diff --git a/frontend/templates/field-template.hbs b/frontend/templates/field-template.hbs new file mode 100644 index 0000000..e6624df --- /dev/null +++ b/frontend/templates/field-template.hbs @@ -0,0 +1,9 @@ + + {{#loop rows}} + + {{#loop ../columns}} + + {{/loop}} + + {{/loop}} +
\ No newline at end of file diff --git a/frontend/templates/helpers/increment.js b/frontend/templates/helpers/increment.js new file mode 100644 index 0000000..2c20603 --- /dev/null +++ b/frontend/templates/helpers/increment.js @@ -0,0 +1,3 @@ +module.exports = function(value) { + return value + 1; +}; \ No newline at end of file diff --git a/frontend/templates/helpers/loop.js b/frontend/templates/helpers/loop.js new file mode 100644 index 0000000..d39a942 --- /dev/null +++ b/frontend/templates/helpers/loop.js @@ -0,0 +1,8 @@ +module.exports = function(count, options) { + var out = ""; + + while (count--) { + out+= options.fn(); + } + return out; +}; \ No newline at end of file diff --git a/frontend/templates/modal-template.hbs b/frontend/templates/modal-template.hbs new file mode 100644 index 0000000..074c58e --- /dev/null +++ b/frontend/templates/modal-template.hbs @@ -0,0 +1,7 @@ +
+
+

{{ title }}

+
{{{ content }}}
+
+
+
\ No newline at end of file diff --git a/frontend/templates/results-template.hbs b/frontend/templates/results-template.hbs new file mode 100644 index 0000000..03c169b --- /dev/null +++ b/frontend/templates/results-template.hbs @@ -0,0 +1,28 @@ +
+
+ + + + + + + + + + {{#each results}} + + + + + + {{/each}} + +
+
Rank
+ 		+
Result (sec)
+ 		+
Date
+
{{ increment @index }}{{ time }}{{ date }}
+
+
\ No newline at end of file diff --git a/package.json b/package.json new file mode 100644 index 0000000..8a57fbd --- /dev/null +++ b/package.json @@ -0,0 +1,30 @@ +{ + "name": "js-minesweeper", + "version": "1.0.0", + "description": "Minesweer game project for JS course (http://learn.javascript.ru)", + "main": "index.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/vfedoseev/js-minesweeper.git" + }, + "author": "v.fedoseev", + "license": "ISC", + "bugs": { + "url": "https://github.com/vfedoseev/js-minesweeper/issues" + }, + "homepage": "https://github.com/vfedoseev/js-minesweeper#readme", + "devDependencies": { + "babel-core": "^6.7.4", + "babel-loader": "^6.2.4", + "babel-plugin-transform-es2015-modules-commonjs": "^6.7.4", + "babel-plugin-transform-runtime": "^6.6.0", + "babel-preset-es2015": "^6.6.0", + "babel-runtime": "^6.6.1", + "handlebars": "^4.0.5", + "handlebars-loader": "^1.2.0", + "webpack": "^1.12.14" + } +} diff --git a/public/build.js b/public/build.js new file mode 100644 index 0000000..3e5429a --- /dev/null +++ b/public/build.js @@ -0,0 +1,2701 @@ +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].exports; +/******/ +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.loaded = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = "/public/"; +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var Game = __webpack_require__(1); + + var game = new Game({ + element: document.querySelector('[data-component="game"]') + }); + +/***/ }, +/* 1 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var GameModel = __webpack_require__(2); + var Controls = __webpack_require__(6); + var Modal = __webpack_require__(27); + var CellType = __webpack_require__(5).CellType; + var Classes = __webpack_require__(5).Classes; + var GameState = __webpack_require__(5).GameState; + var Default = __webpack_require__(5).Default; + var Results = __webpack_require__(29); + var Timer = __webpack_require__(32); + + var fieldTemplate = __webpack_require__(33); + /** + * Class representing the main game manager + */ + + var Game = function () { + /** + * Create game controller + * @param options + */ + + function Game(options) { + _classCallCheck(this, Game); + + this._el = options.element; + this._fieldWrapper = this._el.querySelector('[data-component="field"]'); + + //Bind listeners + this._onFieldLeftClick = this._onFieldLeftClick.bind(this); + this._onFieldRightClick = this._onFieldRightClick.bind(this); + this._onMouseDown = this._onMouseDown.bind(this); + this._onMouseUp = this._onMouseUp.bind(this); + //Current click - collect data about simultaneous click + this._currentClick = {}; + + this._gameModel = new GameModel(); + this._gameModel.addEventListener('stateChange', this._onGameStateChange.bind(this)); + this._gameModel.addEventListener('cellOpen', this._onCellOpen.bind(this)); + this._gameModel.addEventListener('cellToggle', this._onCellToggle.bind(this)); + this._gameModel.addEventListener('cellHighlight', this._onCellHighlight.bind(this)); + this._gameModel.addEventListener('cellClearHighlight', this._onCellClearHighlight.bind(this)); + + this._timer = new Timer(); + + var controls = new Controls({ + element: this._el.querySelector('[data-component="controls"]'), + timer: this._timer + }); + controls.addEventListener('start', this._onStart.bind(this)); + + //Render default field + this.start({ + rows: Default.ROWS, + columns: Default.COLUMNS, + mines: Default.MINES + }); + } + + /** + * Start new game with provided options + * @param options + */ + + + _createClass(Game, [{ + key: 'start', + value: function start(options) { + this._renderField(options); + this._addListeners(); + this._gameModel.start(options); + this._firstClick = false; + this._timer.reset(); + } + + /** + * Handle start event from controls panel + * @param {CustomEvent} event + * @private + */ + + }, { + key: '_onStart', + value: function _onStart(event) { + var options = event.detail; + + this.start(options); + } + + /** + * Render new game field + * @param options + * @private + */ + + }, { + key: '_renderField', + value: function _renderField(options) { + this._fieldWrapper.innerHTML = fieldTemplate(options); //fieldHTML; + this._fieldEl = this._fieldWrapper.querySelector('table'); + } + + /** + * Add listeners to user interaction + * @private + */ + + }, { + key: '_addListeners', + value: function _addListeners() { + this._fieldEl.addEventListener('click', this._onFieldLeftClick); + this._fieldEl.addEventListener('contextmenu', this._onFieldRightClick); + this._fieldEl.addEventListener('mousedown', this._onMouseDown.bind(this)); + document.addEventListener('mouseup', this._onMouseUp.bind(this)); + } + + /** + * Remove listeners to prevent interaction when game is over + * @private + */ + + }, { + key: '_removeListeners', + value: function _removeListeners() { + this._fieldEl.removeEventListener('click', this._onFieldLeftClick); + this._fieldEl.removeEventListener('contextmenu', this._onFieldRightClick); + this._fieldEl.removeEventListener('mousedown', this._onMouseDown.bind(this)); + document.removeEventListener('mouseup', this._onMouseUp.bind(this)); + } + + /** + * User clicks left mouse button + * @param {MouseEvent} event + * @private + */ + + }, { + key: '_onFieldLeftClick', + value: function _onFieldLeftClick(event) { + var targetCell = this._getClickedCell(event); + + if (targetCell) { + this._checkFirstClick(); + this._gameModel.openCell(targetCell.parentNode.sectionRowIndex, targetCell.cellIndex); + } + } + + /** + * User clicks left mouse button + * @param {MouseEvent} event + * @private + */ + + }, { + key: '_onFieldRightClick', + value: function _onFieldRightClick(event) { + var targetCell = this._getClickedCell(event); + + if (targetCell) { + this._checkFirstClick(); + this._gameModel.markCell(targetCell.parentNode.sectionRowIndex, targetCell.cellIndex); + } + + event.preventDefault(); + } + + /** + * User presses mouse button + * @param event + * @private + */ + + }, { + key: '_onMouseDown', + value: function _onMouseDown(event) { + var targetCell = this._getClickedCell(event); + var currentCell = this._currentClick.cell; + + if (!targetCell || currentCell && targetCell !== currentCell) { + this._resetCurrentClick(); + return; + } + + this._currentClick.cell = targetCell; + switch (event.which) { + case 1: + this._currentClick.left = true; + break; + case 3: + this._currentClick.right = true; + break; + } + + if (this._currentClick.left && this._currentClick.right) { + this._gameModel.highlightCell(targetCell.parentNode.sectionRowIndex, targetCell.cellIndex); + } + } + + /** + * User releases mouse button + * @param event + * @private + */ + + }, { + key: '_onMouseUp', + value: function _onMouseUp(event) { + var targetCell = this._getClickedCell(event); + var currentCell = this._currentClick.cell; + var twoButtonsDown = this._currentClick.left && this._currentClick.right; + + if (targetCell && currentCell && targetCell == currentCell && twoButtonsDown) { + this._gameModel.openHighlighted(); + } + this._gameModel.clearHighlight(); + this._resetCurrentClick(); + } + }, { + key: '_resetCurrentClick', + value: function _resetCurrentClick() { + this._currentClick = {}; + } + /** + * Check if the click is the first for this new game + * @private + */ + + }, { + key: '_checkFirstClick', + value: function _checkFirstClick() { + if (!this._firstClick) { + this._firstClick = true; + this._timer.start(); + } + } + }, { + key: '_getClickedCell', + value: function _getClickedCell(event) { + var target = event.target; + + return target.closest('td'); + } + + /** + * Handle cell opening and update the cell view state + * @param {CustomEvent} event + * @private + */ + + }, { + key: '_onCellOpen', + value: function _onCellOpen(event) { + var cell = event.detail; + var cellType = cell.type; + var cellEl = this._fieldEl.rows[cell.row].cells[cell.column]; + + switch (cellType) { + case CellType.EMPTY: + cellEl.classList.add(Classes.EMPTY); + break; + case CellType.MINE: + cellEl.classList.add(Classes.MINE); + break; + default: + cellEl.classList.add(Classes.NUMBER); + cellEl.innerHTML = cellType; + } + } + /** + * Handle cell toggling and update the cell view state (place/remove flag) + * @param {CustomEvent} event + * @private + */ + + }, { + key: '_onCellToggle', + value: function _onCellToggle(event) { + var cell = event.detail; + var cellEl = this._fieldEl.rows[cell.row].cells[cell.column]; + + cellEl.classList.toggle(Classes.MARKED); + } + /** + * Handle cell highlight (highlight neighbours when two buttons pressed on the cell with number) + * @param {CustomEvent} event + * @private + */ + + }, { + key: '_onCellHighlight', + value: function _onCellHighlight(event) { + var cell = event.detail; + var cellEl = this._fieldEl.rows[cell.row].cells[cell.column]; + + cellEl.classList.add(Classes.HIGHLIGHT); + } + }, { + key: '_onCellClearHighlight', + value: function _onCellClearHighlight(event) { + var cell = event.detail; + var cellEl = this._fieldEl.rows[cell.row].cells[cell.column]; + + cellEl.classList.remove(Classes.HIGHLIGHT); + } + }, { + key: '_onGameStateChange', + value: function _onGameStateChange(event) { + var state = event.detail; + + switch (state) { + case GameState.LOST: + case GameState.WIN: + this._end(state); + break; + } + } + + /** + * Game is over - show message, clear game data and remove listeners + * @param state + * @private + */ + + }, { + key: '_end', + value: function _end(state) { + var isWin = state === GameState.WIN; + + this._timer.stop(); + this._removeListeners(); + + var message = 'You ' + (isWin ? 'WIN' : 'LOSE'); + var modal = new Modal({ + placeholder: this._el, + title: message + }); + + if (isWin) { + Results.save(this._timer.getValue()); + modal.setContent(Results.render()); + } + + modal.show(); + } + }]); + + return Game; + }(); + + module.exports = Game; + +/***/ }, +/* 2 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + + function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var Dispatcher = __webpack_require__(3); + var FieldModel = __webpack_require__(4); + var GameState = __webpack_require__(5).GameState; + var CellType = __webpack_require__(5).CellType; + + var DELIMITER = '-'; + /** + * Class representing the game model + */ + + var GameModel = function (_Dispatcher) { + _inherits(GameModel, _Dispatcher); + + /** + * Create game model + * @param options + */ + + function GameModel(options) { + _classCallCheck(this, GameModel); + + return _possibleConstructorReturn(this, Object.getPrototypeOf(GameModel).call(this, options)); + } + + /** + * Start new game with provideed oprions + * @param gameOptions + */ + + + _createClass(GameModel, [{ + key: 'start', + value: function start(gameOptions) { + this._openedCells = {}; //make object for easy access by index ('2-3'); + this._markedCells = {}; + this._highlightedCells = {}; + this._field = new FieldModel(gameOptions); + this._field.generate(); + this.setState(GameState.START); + } + }, { + key: 'setState', + value: function setState(state) { + //WIN and LOST - terminate states. Could only set state to START from them + if (state !== GameState.START && (this._state === GameState.WIN || this._state === GameState.LOST)) { + return; + } + + this._state = state; + this.dispatchEvent('stateChange', this._state); + //this._onStateChange(this._state); + } + + /** + * Mark cell (has mine/has no mine) + * @param row + * @param column + */ + + }, { + key: 'markCell', + value: function markCell(row, column) { + if (this._openedCells[row + DELIMITER + column]) { + return; + } + + this._markedCells[row + DELIMITER + column] = !this._markedCells[row + DELIMITER + column]; + this.dispatchEvent('cellToggle', this._field.getCell(row, column)); + this._checkGameState(); + } + + /** + * Trt to pen cell and check its "content" + * @param row + * @param column + */ + + }, { + key: 'openCell', + value: function openCell(row, column) { + var _this2 = this; + + var cell = this._checkAndOpenCell(row, column); + + if (!cell) { + //cell was already opened + return; + } + switch (cell.type) { + case CellType.EMPTY: + //Cell is empty - open all neighbours cells + var neighbours = this._field.getNeighbours(row, column); + neighbours.forEach(function (neighbourCell) { + //we don't have to check mine because empty neighbours are not mines + var neighbourRow = neighbourCell.row; + var neighbourColumn = neighbourCell.column; + + _this2.openCell(neighbourRow, neighbourColumn); + }); + break; + case CellType.MINE: + // Cell has mine - game is over + this._openAll(); + this.setState(GameState.LOST); + break; + } + + this._checkGameState(); + } + + /** + * Hightlight all cells neighbours if the cell has number and it eual to number of marked neighbours + * @param row + * @param column + */ + + }, { + key: 'highlightCell', + value: function highlightCell(row, column) { + var _this3 = this; + + var cellType = this._field.getCellType(row, column); + var cellIsOpened = this._openedCells[row + DELIMITER + column]; + if (!cellIsOpened && cellType > 0) { + return; + } + var neighbours = this._field.getNeighbours(row, column); + var markedNeighbours = neighbours.filter(function (neighbourCell) { + return _this3._markedCells[neighbourCell.row + DELIMITER + neighbourCell.column]; + }).length; + + if (markedNeighbours !== cellType) { + return; + } + neighbours.forEach(function (neighbourCell) { + //we don't have to check mine because empty neighbours are not mines + var neighbourRow = neighbourCell.row; + var neighbourColumn = neighbourCell.column; + var neighbourIsOpened = _this3._openedCells[neighbourRow + DELIMITER + neighbourColumn]; + var neighbourIsMarked = _this3._markedCells[neighbourRow + DELIMITER + neighbourColumn]; + + if (!neighbourIsOpened && !neighbourIsMarked) { + _this3._highlightedCells[neighbourRow + DELIMITER + neighbourColumn] = true; + _this3.dispatchEvent('cellHighlight', neighbourCell); + } + }); + } + + /** + * Open all cell, that are currently highlighted (by pressing two buttons on mumber cell) + */ + + }, { + key: 'openHighlighted', + value: function openHighlighted() { + for (var i = 0; i < this._field.rows; i++) { + for (var j = 0; j < this._field.columns; j++) { + if (!this._highlightedCells[i + DELIMITER + j]) { + continue; + } + this.openCell(i, j); + } + } + } + + /** + * Clear highlight for all cells + */ + + }, { + key: 'clearHighlight', + value: function clearHighlight() { + for (var i = 0; i < this._field.rows; i++) { + for (var j = 0; j < this._field.columns; j++) { + if (!this._highlightedCells[i + DELIMITER + j]) { + continue; + } + var cell = this._field.getCell(i, j); + + this._highlightedCells[i + DELIMITER + j] = false; + this.dispatchEvent('cellClearHighlight', cell); + } + } + } + /** + * Open cell only it is available + * @param row + * @param column + * @param {boolean} force - open anyway (when game is over) + * @returns {*} + * @private + */ + + }, { + key: '_checkAndOpenCell', + value: function _checkAndOpenCell(row, column, force) { + var cellOpened = this._openedCells[row + DELIMITER + column]; + var cellMarked = this._markedCells[row + DELIMITER + column]; + + if (!cellOpened && !cellMarked || force) { + var cell = this._field.getCell(row, column); + + this._openedCells[row + DELIMITER + column] = true; + this.dispatchEvent('cellOpen', cell); + + return cell; + } + return null; + } + }, { + key: '_checkGameState', + value: function _checkGameState() { + //Get number of opened cells and number of cells with mines + var openedCells = Object.keys(this._openedCells).length; + var totalMines = this._field.mines; + var totalCells = this._field.rows * this._field.columns; + + // All "safe" cells are opened + if (openedCells + totalMines === totalCells) { + this._openAll(); + this.setState(GameState.WIN); + } + } + + /** + * Open all cells (when game is over) + * @private + */ + + }, { + key: '_openAll', + value: function _openAll() { + for (var i = 0; i < this._field.rows; i++) { + for (var j = 0; j < this._field.columns; j++) { + this._checkAndOpenCell(i, j, true); + } + } + } + }]); + + return GameModel; + }(Dispatcher); + + module.exports = GameModel; + +/***/ }, +/* 3 */ +/***/ function(module, exports) { + + 'use strict'; + /** + * Class representing the base event dispathcer + */ + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var Dispatcher = function () { + /** + * Crrate dispatcher + * @param options + */ + + function Dispatcher(options) { + _classCallCheck(this, Dispatcher); + + options = options || {}; + this._el = options.element || document.createElement('div'); + } + + /** + * Add event handler + * @param {string} type + * @param {function} handler + * @param {boolean} capture - use capture + */ + + + _createClass(Dispatcher, [{ + key: 'addEventListener', + value: function addEventListener(type, handler, capture) { + this._el.addEventListener(type, handler, capture); + } + + /** + * Dispatch custom event + * @param {string} type + * @param detail - event data + * @param {object} options + */ + + }, { + key: 'dispatchEvent', + value: function dispatchEvent(type, detail, options) { + options = options || {}; + + if (detail != undefined) { + options.detail = detail; + } + + var event = new CustomEvent(type, options); + this._el.dispatchEvent(event); + } + }]); + + return Dispatcher; + }(); + + module.exports = Dispatcher; + +/***/ }, +/* 4 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var CellType = __webpack_require__(5).CellType; + + /** + * Class representing a game field + */ + + var FieldModel = function () { + /** + * Create a field + * @param options + */ + + function FieldModel(options) { + _classCallCheck(this, FieldModel); + + options = options || {}; + this.rows = options.rows || Default.ROWS; + this.columns = options.columns || Default.COLUMNS; + this.mines = options.mines || Default.MINES; + } + + /** + * Generate new field with mines, numbers and empty cells + */ + + + _createClass(FieldModel, [{ + key: 'generate', + value: function generate() { + var _this = this; + + var placedMines = 0; + + this._field = []; // start with empty array + for (var i = 0; i < this.rows; i++) { + // generate empty rows + this._field[i] = []; + } + + // place mines at random position unit reach the number of mines + while (placedMines < this.mines) { + var rowIndex = Math.floor(Math.random() * this.rows); + var columnIndex = Math.floor(Math.random() * this.columns); + + if (this.getCellType(rowIndex, columnIndex) === CellType.MINE) { + continue; + } + + this._field[rowIndex][columnIndex] = CellType.MINE; + placedMines++; + } + + // place numbers in all mines neighbours cells + for (var _i = 0; _i < this.rows; _i++) { + for (var j = 0; j < this.columns; j++) { + if (this.getCellType(_i, j) === CellType.MINE) { + var mineNeighbours = this.getNeighbours(_i, j); + + mineNeighbours.forEach(function (cellObj) { + if (cellObj.type !== CellType.MINE) { + _this._field[cellObj.row][cellObj.column] = cellObj.type + 1; + } + }); + } + } + } + } + + /** + * Get only type for particular cell + * @param row + * @param column + * @returns {number} - cell type (see constants.Defaults) + */ + + }, { + key: 'getCellType', + value: function getCellType(row, column) { + return this._field[row][column] || CellType.EMPTY; + } + + /** + * Get cell object + * @param row + * @param column + * @returns {{column: number, row: number, type: number}} + */ + + }, { + key: 'getCell', + value: function getCell(row, column) { + return { + column: column, + row: row, + type: this.getCellType(row, column) + }; + } + + /** + * Get neighbours of particular cell + * @param row + * @param column + * @returns {Array} - array of neighbours + */ + + }, { + key: 'getNeighbours', + value: function getNeighbours(row, column) { + var neighbours = []; + var minCol = Math.max(0, column - 1); + var maxCol = Math.min(this.columns - 1, column + 1); + var minRow = Math.max(0, row - 1); + var maxRow = Math.min(this.rows - 1, row + 1); + + for (var i = minRow; i <= maxRow; i++) { + for (var j = minCol; j <= maxCol; j++) { + if (i === row && j === column) { + continue; + } + neighbours.push(this.getCell(i, j)); + } + } + + return neighbours; + } + }]); + + return FieldModel; + }(); + + module.exports = FieldModel; + +/***/ }, +/* 5 */ +/***/ function(module, exports) { + + 'use strict'; + + exports.CellType = { + EMPTY: 0, + MINE: -1 + }; + + exports.GameState = { + START: 0, + WIN: 1, + LOST: 2 + }; + + exports.Default = { + COLUMNS: 9, + ROWS: 9, + MINES: 10, + MIN_ROWS: 9, + MAX_ROWS: 20, + MIN_COLUMNS: 9, + MAX_COLUMNS: 20, + MIN_MINES: 2, + MAX_MINES: 40 + }; + + exports.Selectors = { + ROWS_INPUT: '[name="rows"]', + COLUMNS_INPUT: '[name="columns"]', + MINES_INPUT: '[name="mines"]', + MINES_RANGE_TEXT: '[data-range="mines"]' + }; + + exports.Classes = { + EMPTY: 'cell-empty', + MINE: 'cell-mine', + NUMBER: 'cell-number', + MARKED: 'cell-marked', + HIGHLIGHT: 'cell-highlight' + }; + +/***/ }, +/* 6 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + + function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var Dispatcher = __webpack_require__(3); + var Default = __webpack_require__(5).Default; + var Selectors = __webpack_require__(5).Selectors; + var controlsTemplate = __webpack_require__(7); + + /** + * Class representing the control panel + */ + + var Controls = function (_Dispatcher) { + _inherits(Controls, _Dispatcher); + + /** + * Create controls + * @param options + */ + + function Controls(options) { + _classCallCheck(this, Controls); + + var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Controls).call(this, options)); + + _this._render(); + _this._timer = options.timer; + _this._timerEl = _this._el.querySelector('[data-content="timer"]'); + _this._addListeners(); + return _this; + } + + /** + * Render controls from template + * @private + */ + + + _createClass(Controls, [{ + key: '_render', + value: function _render() { + var defaultOptions = { + minRows: Default.MIN_ROWS, + maxRows: Default.MAX_ROWS, + minCols: Default.MIN_COLUMNS, + maxCols: Default.MAX_COLUMNS, + minMines: Default.MIN_MINES, + maxMines: Default.MAX_MINES, + rows: Default.ROWS, + cols: Default.COLUMNS, + mines: Default.MINES + }; + + this._el.innerHTML = controlsTemplate({ + options: defaultOptions + }); + + this._rowsInput = this._el.querySelector(Selectors.ROWS_INPUT); + this._columnsInput = this._el.querySelector(Selectors.COLUMNS_INPUT); + this._minesInput = this._el.querySelector(Selectors.MINES_INPUT); + this._minesRangeText = this._el.querySelector(Selectors.MINES_RANGE_TEXT); + } + + /** + * Add main listeners for click (start game), timer update, and options input change + * @private + */ + + }, { + key: '_addListeners', + value: function _addListeners() { + this._el.addEventListener('click', this._onClick.bind(this)); + this._el.addEventListener('change', this._onChange.bind(this)); + this._timer.addEventListener('timeUpdate', this._onTimerUpdate.bind(this)); + } + + /** + * 'Click' event handler + * @param {MouseEvent} event - click event + * @private + */ + + }, { + key: '_onClick', + value: function _onClick(event) { + var startBtn = event.target.closest('[data-action="start"]'); + + if (!startBtn) { + return; + } + this._triggerStart(); + } + + /** + * Implement start - dispatch 'start' event with current options + * @private + */ + + }, { + key: '_triggerStart', + value: function _triggerStart() { + var options = this._getOptions(); + + this.dispatchEvent('start', options); + } + + /** + * 'Change' event hadler + * @param {Event} event - change event + * @private + */ + + }, { + key: '_onChange', + value: function _onChange(event) { + var optionsForm = event.target.closest('[name="options-form"]'); + + if (!optionsForm) { + return; + } + + this._validateOptions(); + } + + /** + * Validate current options + * @private + */ + + }, { + key: '_validateOptions', + value: function _validateOptions() { + var options = this._getOptions(); + //Check if input is not valid number + if (isNaN(options.columns)) { + options.columns = Default.MIN_COLUMNS; + } + if (isNaN(options.rows)) { + options.rows = Default.MIN_ROWS; + } + if (isNaN(options.mines)) { + options.rows = Default.MIN_MINES; + } + + options.rows = Math.max(Default.MIN_ROWS, Math.min(options.rows, Default.MAX_ROWS)); + options.columns = Math.max(Default.MIN_COLUMNS, Math.min(options.columns, Default.MAX_COLUMNS)); + + //Calculate mines max range + var maxMines = this._getMinesMaxRange(options.rows, options.columns); + options.mines = Math.max(Default.MIN_MINES, Math.min(options.mines, maxMines)); + //Set mines range + this._minesRangeText.textContent = '(' + Default.MIN_MINES + '-' + maxMines + ')'; + this._minesInput.max = Default.MIN_MINES; + this._minesInput.max = maxMines; + + this._setOptions(options); + } + + /** + * Get options from DOM + * @returns {{rows: Number, columns: Number, mines: Number}} + * @private + */ + + }, { + key: '_getOptions', + value: function _getOptions() { + return { + rows: parseInt(this._rowsInput.value), + columns: parseInt(this._columnsInput.value), + mines: parseInt(this._minesInput.value) + }; + } + + /** + * Set options to DOM + * @param options + * @private + */ + + }, { + key: '_setOptions', + value: function _setOptions(options) { + this._rowsInput.value = options.rows; + this._columnsInput.value = options.columns; + this._minesInput.value = options.mines; + } + }, { + key: '_getMinesMaxRange', + value: function _getMinesMaxRange(rows, columns) { + return Math.round(rows * columns / 2); + } + + /** + * Render new timer value + * @param {CustomEvent} event + * @private + */ + + }, { + key: '_onTimerUpdate', + value: function _onTimerUpdate(event) { + var time = event.detail; + var min = Math.floor(time / 60); + var sec = time % 60; + + this._timerEl.textContent = this._twoDigits(min) + ':' + this._twoDigits(sec); + } + + /** + * Convert n to two-digit string + * @param {Number} n + * @private + */ + + }, { + key: '_twoDigits', + value: function _twoDigits(n) { + return ('0' + n).slice(-2); + } + }]); + + return Controls; + }(Dispatcher); + + module.exports = Controls; + +/***/ }, +/* 7 */ +/***/ function(module, exports, __webpack_require__) { + + var Handlebars = __webpack_require__(8); + function __default(obj) { return obj && (obj.__esModule ? obj["default"] : obj); } + module.exports = (Handlebars["default"] || Handlebars).template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, alias1=container.lambda, alias2=container.escapeExpression; + + return "
\r\n
\r\n \r\n \r\n \r\n
\r\n
\r\n
\r\n 00:00\r\n
\r\n
Start
"; + },"useData":true}); + +/***/ }, +/* 8 */ +/***/ function(module, exports, __webpack_require__) { + + // Create a simple path alias to allow browserify to resolve + // the runtime on a supported path. + module.exports = __webpack_require__(9)['default']; + + +/***/ }, +/* 9 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + // istanbul ignore next + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + // istanbul ignore next + + function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } } + + var _handlebarsBase = __webpack_require__(10); + + var base = _interopRequireWildcard(_handlebarsBase); + + // Each of these augment the Handlebars object. No need to setup here. + // (This is done to easily share code between commonjs and browse envs) + + var _handlebarsSafeString = __webpack_require__(24); + + var _handlebarsSafeString2 = _interopRequireDefault(_handlebarsSafeString); + + var _handlebarsException = __webpack_require__(12); + + var _handlebarsException2 = _interopRequireDefault(_handlebarsException); + + var _handlebarsUtils = __webpack_require__(11); + + var Utils = _interopRequireWildcard(_handlebarsUtils); + + var _handlebarsRuntime = __webpack_require__(25); + + var runtime = _interopRequireWildcard(_handlebarsRuntime); + + var _handlebarsNoConflict = __webpack_require__(26); + + var _handlebarsNoConflict2 = _interopRequireDefault(_handlebarsNoConflict); + + // For compatibility and usage outside of module systems, make the Handlebars object a namespace + function create() { + var hb = new base.HandlebarsEnvironment(); + + Utils.extend(hb, base); + hb.SafeString = _handlebarsSafeString2['default']; + hb.Exception = _handlebarsException2['default']; + hb.Utils = Utils; + hb.escapeExpression = Utils.escapeExpression; + + hb.VM = runtime; + hb.template = function (spec) { + return runtime.template(spec, hb); + }; + + return hb; + } + + var inst = create(); + inst.create = create; + + _handlebarsNoConflict2['default'](inst); + + inst['default'] = inst; + + exports['default'] = inst; + module.exports = exports['default']; + //# sourceMappingURL=data:application/json;base64,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 + + +/***/ }, +/* 10 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + exports.HandlebarsEnvironment = HandlebarsEnvironment; + // istanbul ignore next + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _utils = __webpack_require__(11); + + var _exception = __webpack_require__(12); + + var _exception2 = _interopRequireDefault(_exception); + + var _helpers = __webpack_require__(13); + + var _decorators = __webpack_require__(21); + + var _logger = __webpack_require__(23); + + var _logger2 = _interopRequireDefault(_logger); + + var VERSION = '4.0.5'; + exports.VERSION = VERSION; + var COMPILER_REVISION = 7; + + exports.COMPILER_REVISION = COMPILER_REVISION; + var REVISION_CHANGES = { + 1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it + 2: '== 1.0.0-rc.3', + 3: '== 1.0.0-rc.4', + 4: '== 1.x.x', + 5: '== 2.0.0-alpha.x', + 6: '>= 2.0.0-beta.1', + 7: '>= 4.0.0' + }; + + exports.REVISION_CHANGES = REVISION_CHANGES; + var objectType = '[object Object]'; + + function HandlebarsEnvironment(helpers, partials, decorators) { + this.helpers = helpers || {}; + this.partials = partials || {}; + this.decorators = decorators || {}; + + _helpers.registerDefaultHelpers(this); + _decorators.registerDefaultDecorators(this); + } + + HandlebarsEnvironment.prototype = { + constructor: HandlebarsEnvironment, + + logger: _logger2['default'], + log: _logger2['default'].log, + + registerHelper: function registerHelper(name, fn) { + if (_utils.toString.call(name) === objectType) { + if (fn) { + throw new _exception2['default']('Arg not supported with multiple helpers'); + } + _utils.extend(this.helpers, name); + } else { + this.helpers[name] = fn; + } + }, + unregisterHelper: function unregisterHelper(name) { + delete this.helpers[name]; + }, + + registerPartial: function registerPartial(name, partial) { + if (_utils.toString.call(name) === objectType) { + _utils.extend(this.partials, name); + } else { + if (typeof partial === 'undefined') { + throw new _exception2['default']('Attempting to register a partial called "' + name + '" as undefined'); + } + this.partials[name] = partial; + } + }, + unregisterPartial: function unregisterPartial(name) { + delete this.partials[name]; + }, + + registerDecorator: function registerDecorator(name, fn) { + if (_utils.toString.call(name) === objectType) { + if (fn) { + throw new _exception2['default']('Arg not supported with multiple decorators'); + } + _utils.extend(this.decorators, name); + } else { + this.decorators[name] = fn; + } + }, + unregisterDecorator: function unregisterDecorator(name) { + delete this.decorators[name]; + } + }; + + var log = _logger2['default'].log; + + exports.log = log; + exports.createFrame = _utils.createFrame; + exports.logger = _logger2['default']; + //# sourceMappingURL=data:application/json;base64,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 + + +/***/ }, +/* 11 */ +/***/ function(module, exports) { + + 'use strict'; + + exports.__esModule = true; + exports.extend = extend; + exports.indexOf = indexOf; + exports.escapeExpression = escapeExpression; + exports.isEmpty = isEmpty; + exports.createFrame = createFrame; + exports.blockParams = blockParams; + exports.appendContextPath = appendContextPath; + var escape = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', + '`': '`', + '=': '=' + }; + + var badChars = /[&<>"'`=]/g, + possible = /[&<>"'`=]/; + + function escapeChar(chr) { + return escape[chr]; + } + + function extend(obj /* , ...source */) { + for (var i = 1; i < arguments.length; i++) { + for (var key in arguments[i]) { + if (Object.prototype.hasOwnProperty.call(arguments[i], key)) { + obj[key] = arguments[i][key]; + } + } + } + + return obj; + } + + var toString = Object.prototype.toString; + + exports.toString = toString; + // Sourced from lodash + // https://github.com/bestiejs/lodash/blob/master/LICENSE.txt + /* eslint-disable func-style */ + var isFunction = function isFunction(value) { + return typeof value === 'function'; + }; + // fallback for older versions of Chrome and Safari + /* istanbul ignore next */ + if (isFunction(/x/)) { + exports.isFunction = isFunction = function (value) { + return typeof value === 'function' && toString.call(value) === '[object Function]'; + }; + } + exports.isFunction = isFunction; + + /* eslint-enable func-style */ + + /* istanbul ignore next */ + var isArray = Array.isArray || function (value) { + return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false; + }; + + exports.isArray = isArray; + // Older IE versions do not directly support indexOf so we must implement our own, sadly. + + function indexOf(array, value) { + for (var i = 0, len = array.length; i < len; i++) { + if (array[i] === value) { + return i; + } + } + return -1; + } + + function escapeExpression(string) { + if (typeof string !== 'string') { + // don't escape SafeStrings, since they're already safe + if (string && string.toHTML) { + return string.toHTML(); + } else if (string == null) { + return ''; + } else if (!string) { + return string + ''; + } + + // Force a string conversion as this will be done by the append regardless and + // the regex test will do this transparently behind the scenes, causing issues if + // an object's to string has escaped characters in it. + string = '' + string; + } + + if (!possible.test(string)) { + return string; + } + return string.replace(badChars, escapeChar); + } + + function isEmpty(value) { + if (!value && value !== 0) { + return true; + } else if (isArray(value) && value.length === 0) { + return true; + } else { + return false; + } + } + + function createFrame(object) { + var frame = extend({}, object); + frame._parent = object; + return frame; + } + + function blockParams(params, ids) { + params.path = ids; + return params; + } + + function appendContextPath(contextPath, id) { + return (contextPath ? contextPath + '.' : '') + id; + } + //# sourceMappingURL=data:application/json;base64,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 + + +/***/ }, +/* 12 */ +/***/ function(module, exports) { + + 'use strict'; + + exports.__esModule = true; + + var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack']; + + function Exception(message, node) { + var loc = node && node.loc, + line = undefined, + column = undefined; + if (loc) { + line = loc.start.line; + column = loc.start.column; + + message += ' - ' + line + ':' + column; + } + + var tmp = Error.prototype.constructor.call(this, message); + + // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work. + for (var idx = 0; idx < errorProps.length; idx++) { + this[errorProps[idx]] = tmp[errorProps[idx]]; + } + + /* istanbul ignore else */ + if (Error.captureStackTrace) { + Error.captureStackTrace(this, Exception); + } + + if (loc) { + this.lineNumber = line; + this.column = column; + } + } + + Exception.prototype = new Error(); + + exports['default'] = Exception; + module.exports = exports['default']; + //# sourceMappingURL=data:application/json;base64,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 + + +/***/ }, +/* 13 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + exports.registerDefaultHelpers = registerDefaultHelpers; + // istanbul ignore next + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _helpersBlockHelperMissing = __webpack_require__(14); + + var _helpersBlockHelperMissing2 = _interopRequireDefault(_helpersBlockHelperMissing); + + var _helpersEach = __webpack_require__(15); + + var _helpersEach2 = _interopRequireDefault(_helpersEach); + + var _helpersHelperMissing = __webpack_require__(16); + + var _helpersHelperMissing2 = _interopRequireDefault(_helpersHelperMissing); + + var _helpersIf = __webpack_require__(17); + + var _helpersIf2 = _interopRequireDefault(_helpersIf); + + var _helpersLog = __webpack_require__(18); + + var _helpersLog2 = _interopRequireDefault(_helpersLog); + + var _helpersLookup = __webpack_require__(19); + + var _helpersLookup2 = _interopRequireDefault(_helpersLookup); + + var _helpersWith = __webpack_require__(20); + + var _helpersWith2 = _interopRequireDefault(_helpersWith); + + function registerDefaultHelpers(instance) { + _helpersBlockHelperMissing2['default'](instance); + _helpersEach2['default'](instance); + _helpersHelperMissing2['default'](instance); + _helpersIf2['default'](instance); + _helpersLog2['default'](instance); + _helpersLookup2['default'](instance); + _helpersWith2['default'](instance); + } + //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2hlbHBlcnMuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7eUNBQXVDLGdDQUFnQzs7OzsyQkFDOUMsZ0JBQWdCOzs7O29DQUNQLDBCQUEwQjs7Ozt5QkFDckMsY0FBYzs7OzswQkFDYixlQUFlOzs7OzZCQUNaLGtCQUFrQjs7OzsyQkFDcEIsZ0JBQWdCOzs7O0FBRWxDLFNBQVMsc0JBQXNCLENBQUMsUUFBUSxFQUFFO0FBQy9DLHlDQUEyQixRQUFRLENBQUMsQ0FBQztBQUNyQywyQkFBYSxRQUFRLENBQUMsQ0FBQztBQUN2QixvQ0FBc0IsUUFBUSxDQUFDLENBQUM7QUFDaEMseUJBQVcsUUFBUSxDQUFDLENBQUM7QUFDckIsMEJBQVksUUFBUSxDQUFDLENBQUM7QUFDdEIsNkJBQWUsUUFBUSxDQUFDLENBQUM7QUFDekIsMkJBQWEsUUFBUSxDQUFDLENBQUM7Q0FDeEIiLCJmaWxlIjoiaGVscGVycy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCByZWdpc3RlckJsb2NrSGVscGVyTWlzc2luZyBmcm9tICcuL2hlbHBlcnMvYmxvY2staGVscGVyLW1pc3NpbmcnO1xuaW1wb3J0IHJlZ2lzdGVyRWFjaCBmcm9tICcuL2hlbHBlcnMvZWFjaCc7XG5pbXBvcnQgcmVnaXN0ZXJIZWxwZXJNaXNzaW5nIGZyb20gJy4vaGVscGVycy9oZWxwZXItbWlzc2luZyc7XG5pbXBvcnQgcmVnaXN0ZXJJZiBmcm9tICcuL2hlbHBlcnMvaWYnO1xuaW1wb3J0IHJlZ2lzdGVyTG9nIGZyb20gJy4vaGVscGVycy9sb2cnO1xuaW1wb3J0IHJlZ2lzdGVyTG9va3VwIGZyb20gJy4vaGVscGVycy9sb29rdXAnO1xuaW1wb3J0IHJlZ2lzdGVyV2l0aCBmcm9tICcuL2hlbHBlcnMvd2l0aCc7XG5cbmV4cG9ydCBmdW5jdGlvbiByZWdpc3RlckRlZmF1bHRIZWxwZXJzKGluc3RhbmNlKSB7XG4gIHJlZ2lzdGVyQmxvY2tIZWxwZXJNaXNzaW5nKGluc3RhbmNlKTtcbiAgcmVnaXN0ZXJFYWNoKGluc3RhbmNlKTtcbiAgcmVnaXN0ZXJIZWxwZXJNaXNzaW5nKGluc3RhbmNlKTtcbiAgcmVnaXN0ZXJJZihpbnN0YW5jZSk7XG4gIHJlZ2lzdGVyTG9nKGluc3RhbmNlKTtcbiAgcmVnaXN0ZXJMb29rdXAoaW5zdGFuY2UpO1xuICByZWdpc3RlcldpdGgoaW5zdGFuY2UpO1xufVxuIl19 + + +/***/ }, +/* 14 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + var _utils = __webpack_require__(11); + + exports['default'] = function (instance) { + instance.registerHelper('blockHelperMissing', function (context, options) { + var inverse = options.inverse, + fn = options.fn; + + if (context === true) { + return fn(this); + } else if (context === false || context == null) { + return inverse(this); + } else if (_utils.isArray(context)) { + if (context.length > 0) { + if (options.ids) { + options.ids = [options.name]; + } + + return instance.helpers.each(context, options); + } else { + return inverse(this); + } + } else { + if (options.data && options.ids) { + var data = _utils.createFrame(options.data); + data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name); + options = { data: data }; + } + + return fn(context, options); + } + }); + }; + + module.exports = exports['default']; + //# sourceMappingURL=data:application/json;base64,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 + + +/***/ }, +/* 15 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + // istanbul ignore next + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _utils = __webpack_require__(11); + + var _exception = __webpack_require__(12); + + var _exception2 = _interopRequireDefault(_exception); + + exports['default'] = function (instance) { + instance.registerHelper('each', function (context, options) { + if (!options) { + throw new _exception2['default']('Must pass iterator to #each'); + } + + var fn = options.fn, + inverse = options.inverse, + i = 0, + ret = '', + data = undefined, + contextPath = undefined; + + if (options.data && options.ids) { + contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.'; + } + + if (_utils.isFunction(context)) { + context = context.call(this); + } + + if (options.data) { + data = _utils.createFrame(options.data); + } + + function execIteration(field, index, last) { + if (data) { + data.key = field; + data.index = index; + data.first = index === 0; + data.last = !!last; + + if (contextPath) { + data.contextPath = contextPath + field; + } + } + + ret = ret + fn(context[field], { + data: data, + blockParams: _utils.blockParams([context[field], field], [contextPath + field, null]) + }); + } + + if (context && typeof context === 'object') { + if (_utils.isArray(context)) { + for (var j = context.length; i < j; i++) { + if (i in context) { + execIteration(i, i, i === context.length - 1); + } + } + } else { + var priorKey = undefined; + + for (var key in context) { + if (context.hasOwnProperty(key)) { + // We're running the iterations one step out of sync so we can detect + // the last iteration without have to scan the object twice and create + // an itermediate keys array. + if (priorKey !== undefined) { + execIteration(priorKey, i - 1); + } + priorKey = key; + i++; + } + } + if (priorKey !== undefined) { + execIteration(priorKey, i - 1, true); + } + } + } + + if (i === 0) { + ret = inverse(this); + } + + return ret; + }); + }; + + module.exports = exports['default']; + //# sourceMappingURL=data:application/json;base64,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 + + +/***/ }, +/* 16 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + // istanbul ignore next + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _exception = __webpack_require__(12); + + var _exception2 = _interopRequireDefault(_exception); + + exports['default'] = function (instance) { + instance.registerHelper('helperMissing', function () /* [args, ]options */{ + if (arguments.length === 1) { + // A missing field in a {{foo}} construct. + return undefined; + } else { + // Someone is actually trying to call something, blow up. + throw new _exception2['default']('Missing helper: "' + arguments[arguments.length - 1].name + '"'); + } + }); + }; + + module.exports = exports['default']; + //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2hlbHBlcnMvaGVscGVyLW1pc3NpbmcuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozt5QkFBc0IsY0FBYzs7OztxQkFFckIsVUFBUyxRQUFRLEVBQUU7QUFDaEMsVUFBUSxDQUFDLGNBQWMsQ0FBQyxlQUFlLEVBQUUsaUNBQWdDO0FBQ3ZFLFFBQUksU0FBUyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7O0FBRTFCLGFBQU8sU0FBUyxDQUFDO0tBQ2xCLE1BQU07O0FBRUwsWUFBTSwyQkFBYyxtQkFBbUIsR0FBRyxTQUFTLENBQUMsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLEdBQUcsR0FBRyxDQUFDLENBQUM7S0FDdkY7R0FDRixDQUFDLENBQUM7Q0FDSiIsImZpbGUiOiJoZWxwZXItbWlzc2luZy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBFeGNlcHRpb24gZnJvbSAnLi4vZXhjZXB0aW9uJztcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24oaW5zdGFuY2UpIHtcbiAgaW5zdGFuY2UucmVnaXN0ZXJIZWxwZXIoJ2hlbHBlck1pc3NpbmcnLCBmdW5jdGlvbigvKiBbYXJncywgXW9wdGlvbnMgKi8pIHtcbiAgICBpZiAoYXJndW1lbnRzLmxlbmd0aCA9PT0gMSkge1xuICAgICAgLy8gQSBtaXNzaW5nIGZpZWxkIGluIGEge3tmb299fSBjb25zdHJ1Y3QuXG4gICAgICByZXR1cm4gdW5kZWZpbmVkO1xuICAgIH0gZWxzZSB7XG4gICAgICAvLyBTb21lb25lIGlzIGFjdHVhbGx5IHRyeWluZyB0byBjYWxsIHNvbWV0aGluZywgYmxvdyB1cC5cbiAgICAgIHRocm93IG5ldyBFeGNlcHRpb24oJ01pc3NpbmcgaGVscGVyOiBcIicgKyBhcmd1bWVudHNbYXJndW1lbnRzLmxlbmd0aCAtIDFdLm5hbWUgKyAnXCInKTtcbiAgICB9XG4gIH0pO1xufVxuIl19 + + +/***/ }, +/* 17 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + var _utils = __webpack_require__(11); + + exports['default'] = function (instance) { + instance.registerHelper('if', function (conditional, options) { + if (_utils.isFunction(conditional)) { + conditional = conditional.call(this); + } + + // Default behavior is to render the positive path if the value is truthy and not empty. + // The `includeZero` option may be set to treat the condtional as purely not empty based on the + // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative. + if (!options.hash.includeZero && !conditional || _utils.isEmpty(conditional)) { + return options.inverse(this); + } else { + return options.fn(this); + } + }); + + instance.registerHelper('unless', function (conditional, options) { + return instance.helpers['if'].call(this, conditional, { fn: options.inverse, inverse: options.fn, hash: options.hash }); + }); + }; + + module.exports = exports['default']; + //# sourceMappingURL=data:application/json;base64,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 + + +/***/ }, +/* 18 */ +/***/ function(module, exports) { + + 'use strict'; + + exports.__esModule = true; + + exports['default'] = function (instance) { + instance.registerHelper('log', function () /* message, options */{ + var args = [undefined], + options = arguments[arguments.length - 1]; + for (var i = 0; i < arguments.length - 1; i++) { + args.push(arguments[i]); + } + + var level = 1; + if (options.hash.level != null) { + level = options.hash.level; + } else if (options.data && options.data.level != null) { + level = options.data.level; + } + args[0] = level; + + instance.log.apply(instance, args); + }); + }; + + module.exports = exports['default']; + //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2hlbHBlcnMvbG9nLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQWUsVUFBUyxRQUFRLEVBQUU7QUFDaEMsVUFBUSxDQUFDLGNBQWMsQ0FBQyxLQUFLLEVBQUUsa0NBQWlDO0FBQzlELFFBQUksSUFBSSxHQUFHLENBQUMsU0FBUyxDQUFDO1FBQ2xCLE9BQU8sR0FBRyxTQUFTLENBQUMsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQztBQUM5QyxTQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUU7QUFDN0MsVUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztLQUN6Qjs7QUFFRCxRQUFJLEtBQUssR0FBRyxDQUFDLENBQUM7QUFDZCxRQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxJQUFJLElBQUksRUFBRTtBQUM5QixXQUFLLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUM7S0FDNUIsTUFBTSxJQUFJLE9BQU8sQ0FBQyxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLElBQUksSUFBSSxFQUFFO0FBQ3JELFdBQUssR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQztLQUM1QjtBQUNELFFBQUksQ0FBQyxDQUFDLENBQUMsR0FBRyxLQUFLLENBQUM7O0FBRWhCLFlBQVEsQ0FBQyxHQUFHLE1BQUEsQ0FBWixRQUFRLEVBQVMsSUFBSSxDQUFDLENBQUM7R0FDeEIsQ0FBQyxDQUFDO0NBQ0oiLCJmaWxlIjoibG9nLmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24oaW5zdGFuY2UpIHtcbiAgaW5zdGFuY2UucmVnaXN0ZXJIZWxwZXIoJ2xvZycsIGZ1bmN0aW9uKC8qIG1lc3NhZ2UsIG9wdGlvbnMgKi8pIHtcbiAgICBsZXQgYXJncyA9IFt1bmRlZmluZWRdLFxuICAgICAgICBvcHRpb25zID0gYXJndW1lbnRzW2FyZ3VtZW50cy5sZW5ndGggLSAxXTtcbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IGFyZ3VtZW50cy5sZW5ndGggLSAxOyBpKyspIHtcbiAgICAgIGFyZ3MucHVzaChhcmd1bWVudHNbaV0pO1xuICAgIH1cblxuICAgIGxldCBsZXZlbCA9IDE7XG4gICAgaWYgKG9wdGlvbnMuaGFzaC5sZXZlbCAhPSBudWxsKSB7XG4gICAgICBsZXZlbCA9IG9wdGlvbnMuaGFzaC5sZXZlbDtcbiAgICB9IGVsc2UgaWYgKG9wdGlvbnMuZGF0YSAmJiBvcHRpb25zLmRhdGEubGV2ZWwgIT0gbnVsbCkge1xuICAgICAgbGV2ZWwgPSBvcHRpb25zLmRhdGEubGV2ZWw7XG4gICAgfVxuICAgIGFyZ3NbMF0gPSBsZXZlbDtcblxuICAgIGluc3RhbmNlLmxvZyguLi4gYXJncyk7XG4gIH0pO1xufVxuIl19 + + +/***/ }, +/* 19 */ +/***/ function(module, exports) { + + 'use strict'; + + exports.__esModule = true; + + exports['default'] = function (instance) { + instance.registerHelper('lookup', function (obj, field) { + return obj && obj[field]; + }); + }; + + module.exports = exports['default']; + //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2hlbHBlcnMvbG9va3VwLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQWUsVUFBUyxRQUFRLEVBQUU7QUFDaEMsVUFBUSxDQUFDLGNBQWMsQ0FBQyxRQUFRLEVBQUUsVUFBUyxHQUFHLEVBQUUsS0FBSyxFQUFFO0FBQ3JELFdBQU8sR0FBRyxJQUFJLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztHQUMxQixDQUFDLENBQUM7Q0FDSiIsImZpbGUiOiJsb29rdXAuanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVmYXVsdCBmdW5jdGlvbihpbnN0YW5jZSkge1xuICBpbnN0YW5jZS5yZWdpc3RlckhlbHBlcignbG9va3VwJywgZnVuY3Rpb24ob2JqLCBmaWVsZCkge1xuICAgIHJldHVybiBvYmogJiYgb2JqW2ZpZWxkXTtcbiAgfSk7XG59XG4iXX0= + + +/***/ }, +/* 20 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + var _utils = __webpack_require__(11); + + exports['default'] = function (instance) { + instance.registerHelper('with', function (context, options) { + if (_utils.isFunction(context)) { + context = context.call(this); + } + + var fn = options.fn; + + if (!_utils.isEmpty(context)) { + var data = options.data; + if (options.data && options.ids) { + data = _utils.createFrame(options.data); + data.contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]); + } + + return fn(context, { + data: data, + blockParams: _utils.blockParams([context], [data && data.contextPath]) + }); + } else { + return options.inverse(this); + } + }); + }; + + module.exports = exports['default']; + //# sourceMappingURL=data:application/json;base64,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 + + +/***/ }, +/* 21 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + exports.registerDefaultDecorators = registerDefaultDecorators; + // istanbul ignore next + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _decoratorsInline = __webpack_require__(22); + + var _decoratorsInline2 = _interopRequireDefault(_decoratorsInline); + + function registerDefaultDecorators(instance) { + _decoratorsInline2['default'](instance); + } + //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2RlY29yYXRvcnMuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Z0NBQTJCLHFCQUFxQjs7OztBQUV6QyxTQUFTLHlCQUF5QixDQUFDLFFBQVEsRUFBRTtBQUNsRCxnQ0FBZSxRQUFRLENBQUMsQ0FBQztDQUMxQiIsImZpbGUiOiJkZWNvcmF0b3JzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHJlZ2lzdGVySW5saW5lIGZyb20gJy4vZGVjb3JhdG9ycy9pbmxpbmUnO1xuXG5leHBvcnQgZnVuY3Rpb24gcmVnaXN0ZXJEZWZhdWx0RGVjb3JhdG9ycyhpbnN0YW5jZSkge1xuICByZWdpc3RlcklubGluZShpbnN0YW5jZSk7XG59XG5cbiJdfQ== + + +/***/ }, +/* 22 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + var _utils = __webpack_require__(11); + + exports['default'] = function (instance) { + instance.registerDecorator('inline', function (fn, props, container, options) { + var ret = fn; + if (!props.partials) { + props.partials = {}; + ret = function (context, options) { + // Create a new partials stack frame prior to exec. + var original = container.partials; + container.partials = _utils.extend({}, original, props.partials); + var ret = fn(context, options); + container.partials = original; + return ret; + }; + } + + props.partials[options.args[0]] = options.fn; + + return ret; + }); + }; + + module.exports = exports['default']; + //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2RlY29yYXRvcnMvaW5saW5lLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQXFCLFVBQVU7O3FCQUVoQixVQUFTLFFBQVEsRUFBRTtBQUNoQyxVQUFRLENBQUMsaUJBQWlCLENBQUMsUUFBUSxFQUFFLFVBQVMsRUFBRSxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFO0FBQzNFLFFBQUksR0FBRyxHQUFHLEVBQUUsQ0FBQztBQUNiLFFBQUksQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFO0FBQ25CLFdBQUssQ0FBQyxRQUFRLEdBQUcsRUFBRSxDQUFDO0FBQ3BCLFNBQUcsR0FBRyxVQUFTLE9BQU8sRUFBRSxPQUFPLEVBQUU7O0FBRS9CLFlBQUksUUFBUSxHQUFHLFNBQVMsQ0FBQyxRQUFRLENBQUM7QUFDbEMsaUJBQVMsQ0FBQyxRQUFRLEdBQUcsY0FBTyxFQUFFLEVBQUUsUUFBUSxFQUFFLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQztBQUMxRCxZQUFJLEdBQUcsR0FBRyxFQUFFLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0FBQy9CLGlCQUFTLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztBQUM5QixlQUFPLEdBQUcsQ0FBQztPQUNaLENBQUM7S0FDSDs7QUFFRCxTQUFLLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxPQUFPLENBQUMsRUFBRSxDQUFDOztBQUU3QyxXQUFPLEdBQUcsQ0FBQztHQUNaLENBQUMsQ0FBQztDQUNKIiwiZmlsZSI6ImlubGluZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7ZXh0ZW5kfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uKGluc3RhbmNlKSB7XG4gIGluc3RhbmNlLnJlZ2lzdGVyRGVjb3JhdG9yKCdpbmxpbmUnLCBmdW5jdGlvbihmbiwgcHJvcHMsIGNvbnRhaW5lciwgb3B0aW9ucykge1xuICAgIGxldCByZXQgPSBmbjtcbiAgICBpZiAoIXByb3BzLnBhcnRpYWxzKSB7XG4gICAgICBwcm9wcy5wYXJ0aWFscyA9IHt9O1xuICAgICAgcmV0ID0gZnVuY3Rpb24oY29udGV4dCwgb3B0aW9ucykge1xuICAgICAgICAvLyBDcmVhdGUgYSBuZXcgcGFydGlhbHMgc3RhY2sgZnJhbWUgcHJpb3IgdG8gZXhlYy5cbiAgICAgICAgbGV0IG9yaWdpbmFsID0gY29udGFpbmVyLnBhcnRpYWxzO1xuICAgICAgICBjb250YWluZXIucGFydGlhbHMgPSBleHRlbmQoe30sIG9yaWdpbmFsLCBwcm9wcy5wYXJ0aWFscyk7XG4gICAgICAgIGxldCByZXQgPSBmbihjb250ZXh0LCBvcHRpb25zKTtcbiAgICAgICAgY29udGFpbmVyLnBhcnRpYWxzID0gb3JpZ2luYWw7XG4gICAgICAgIHJldHVybiByZXQ7XG4gICAgICB9O1xuICAgIH1cblxuICAgIHByb3BzLnBhcnRpYWxzW29wdGlvbnMuYXJnc1swXV0gPSBvcHRpb25zLmZuO1xuXG4gICAgcmV0dXJuIHJldDtcbiAgfSk7XG59XG4iXX0= + + +/***/ }, +/* 23 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + var _utils = __webpack_require__(11); + + var logger = { + methodMap: ['debug', 'info', 'warn', 'error'], + level: 'info', + + // Maps a given level value to the `methodMap` indexes above. + lookupLevel: function lookupLevel(level) { + if (typeof level === 'string') { + var levelMap = _utils.indexOf(logger.methodMap, level.toLowerCase()); + if (levelMap >= 0) { + level = levelMap; + } else { + level = parseInt(level, 10); + } + } + + return level; + }, + + // Can be overridden in the host environment + log: function log(level) { + level = logger.lookupLevel(level); + + if (typeof console !== 'undefined' && logger.lookupLevel(logger.level) <= level) { + var method = logger.methodMap[level]; + if (!console[method]) { + // eslint-disable-line no-console + method = 'log'; + } + + for (var _len = arguments.length, message = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + message[_key - 1] = arguments[_key]; + } + + console[method].apply(console, message); // eslint-disable-line no-console + } + } + }; + + exports['default'] = logger; + module.exports = exports['default']; + //# sourceMappingURL=data:application/json;base64,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 + + +/***/ }, +/* 24 */ +/***/ function(module, exports) { + + // Build out our basic SafeString type + 'use strict'; + + exports.__esModule = true; + function SafeString(string) { + this.string = string; + } + + SafeString.prototype.toString = SafeString.prototype.toHTML = function () { + return '' + this.string; + }; + + exports['default'] = SafeString; + module.exports = exports['default']; + //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL3NhZmUtc3RyaW5nLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFDQSxTQUFTLFVBQVUsQ0FBQyxNQUFNLEVBQUU7QUFDMUIsTUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7Q0FDdEI7O0FBRUQsVUFBVSxDQUFDLFNBQVMsQ0FBQyxRQUFRLEdBQUcsVUFBVSxDQUFDLFNBQVMsQ0FBQyxNQUFNLEdBQUcsWUFBVztBQUN2RSxTQUFPLEVBQUUsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDO0NBQ3pCLENBQUM7O3FCQUVhLFVBQVUiLCJmaWxlIjoic2FmZS1zdHJpbmcuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBCdWlsZCBvdXQgb3VyIGJhc2ljIFNhZmVTdHJpbmcgdHlwZVxuZnVuY3Rpb24gU2FmZVN0cmluZyhzdHJpbmcpIHtcbiAgdGhpcy5zdHJpbmcgPSBzdHJpbmc7XG59XG5cblNhZmVTdHJpbmcucHJvdG90eXBlLnRvU3RyaW5nID0gU2FmZVN0cmluZy5wcm90b3R5cGUudG9IVE1MID0gZnVuY3Rpb24oKSB7XG4gIHJldHVybiAnJyArIHRoaXMuc3RyaW5nO1xufTtcblxuZXhwb3J0IGRlZmF1bHQgU2FmZVN0cmluZztcbiJdfQ== + + +/***/ }, +/* 25 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + exports.checkRevision = checkRevision; + exports.template = template; + exports.wrapProgram = wrapProgram; + exports.resolvePartial = resolvePartial; + exports.invokePartial = invokePartial; + exports.noop = noop; + // istanbul ignore next + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + // istanbul ignore next + + function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } } + + var _utils = __webpack_require__(11); + + var Utils = _interopRequireWildcard(_utils); + + var _exception = __webpack_require__(12); + + var _exception2 = _interopRequireDefault(_exception); + + var _base = __webpack_require__(10); + + function checkRevision(compilerInfo) { + var compilerRevision = compilerInfo && compilerInfo[0] || 1, + currentRevision = _base.COMPILER_REVISION; + + if (compilerRevision !== currentRevision) { + if (compilerRevision < currentRevision) { + var runtimeVersions = _base.REVISION_CHANGES[currentRevision], + compilerVersions = _base.REVISION_CHANGES[compilerRevision]; + throw new _exception2['default']('Template was precompiled with an older version of Handlebars than the current runtime. ' + 'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').'); + } else { + // Use the embedded version info since the runtime doesn't know about this revision yet + throw new _exception2['default']('Template was precompiled with a newer version of Handlebars than the current runtime. ' + 'Please update your runtime to a newer version (' + compilerInfo[1] + ').'); + } + } + } + + function template(templateSpec, env) { + /* istanbul ignore next */ + if (!env) { + throw new _exception2['default']('No environment passed to template'); + } + if (!templateSpec || !templateSpec.main) { + throw new _exception2['default']('Unknown template object: ' + typeof templateSpec); + } + + templateSpec.main.decorator = templateSpec.main_d; + + // Note: Using env.VM references rather than local var references throughout this section to allow + // for external users to override these as psuedo-supported APIs. + env.VM.checkRevision(templateSpec.compiler); + + function invokePartialWrapper(partial, context, options) { + if (options.hash) { + context = Utils.extend({}, context, options.hash); + if (options.ids) { + options.ids[0] = true; + } + } + + partial = env.VM.resolvePartial.call(this, partial, context, options); + var result = env.VM.invokePartial.call(this, partial, context, options); + + if (result == null && env.compile) { + options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env); + result = options.partials[options.name](context, options); + } + if (result != null) { + if (options.indent) { + var lines = result.split('\n'); + for (var i = 0, l = lines.length; i < l; i++) { + if (!lines[i] && i + 1 === l) { + break; + } + + lines[i] = options.indent + lines[i]; + } + result = lines.join('\n'); + } + return result; + } else { + throw new _exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode'); + } + } + + // Just add water + var container = { + strict: function strict(obj, name) { + if (!(name in obj)) { + throw new _exception2['default']('"' + name + '" not defined in ' + obj); + } + return obj[name]; + }, + lookup: function lookup(depths, name) { + var len = depths.length; + for (var i = 0; i < len; i++) { + if (depths[i] && depths[i][name] != null) { + return depths[i][name]; + } + } + }, + lambda: function lambda(current, context) { + return typeof current === 'function' ? current.call(context) : current; + }, + + escapeExpression: Utils.escapeExpression, + invokePartial: invokePartialWrapper, + + fn: function fn(i) { + var ret = templateSpec[i]; + ret.decorator = templateSpec[i + '_d']; + return ret; + }, + + programs: [], + program: function program(i, data, declaredBlockParams, blockParams, depths) { + var programWrapper = this.programs[i], + fn = this.fn(i); + if (data || depths || blockParams || declaredBlockParams) { + programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths); + } else if (!programWrapper) { + programWrapper = this.programs[i] = wrapProgram(this, i, fn); + } + return programWrapper; + }, + + data: function data(value, depth) { + while (value && depth--) { + value = value._parent; + } + return value; + }, + merge: function merge(param, common) { + var obj = param || common; + + if (param && common && param !== common) { + obj = Utils.extend({}, common, param); + } + + return obj; + }, + + noop: env.VM.noop, + compilerInfo: templateSpec.compiler + }; + + function ret(context) { + var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; + + var data = options.data; + + ret._setup(options); + if (!options.partial && templateSpec.useData) { + data = initData(context, data); + } + var depths = undefined, + blockParams = templateSpec.useBlockParams ? [] : undefined; + if (templateSpec.useDepths) { + if (options.depths) { + depths = context !== options.depths[0] ? [context].concat(options.depths) : options.depths; + } else { + depths = [context]; + } + } + + function main(context /*, options*/) { + return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths); + } + main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams); + return main(context, options); + } + ret.isTop = true; + + ret._setup = function (options) { + if (!options.partial) { + container.helpers = container.merge(options.helpers, env.helpers); + + if (templateSpec.usePartial) { + container.partials = container.merge(options.partials, env.partials); + } + if (templateSpec.usePartial || templateSpec.useDecorators) { + container.decorators = container.merge(options.decorators, env.decorators); + } + } else { + container.helpers = options.helpers; + container.partials = options.partials; + container.decorators = options.decorators; + } + }; + + ret._child = function (i, data, blockParams, depths) { + if (templateSpec.useBlockParams && !blockParams) { + throw new _exception2['default']('must pass block params'); + } + if (templateSpec.useDepths && !depths) { + throw new _exception2['default']('must pass parent depths'); + } + + return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths); + }; + return ret; + } + + function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) { + function prog(context) { + var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; + + var currentDepths = depths; + if (depths && context !== depths[0]) { + currentDepths = [context].concat(depths); + } + + return fn(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), currentDepths); + } + + prog = executeDecorators(fn, prog, container, depths, data, blockParams); + + prog.program = i; + prog.depth = depths ? depths.length : 0; + prog.blockParams = declaredBlockParams || 0; + return prog; + } + + function resolvePartial(partial, context, options) { + if (!partial) { + if (options.name === '@partial-block') { + partial = options.data['partial-block']; + } else { + partial = options.partials[options.name]; + } + } else if (!partial.call && !options.name) { + // This is a dynamic partial that returned a string + options.name = partial; + partial = options.partials[partial]; + } + return partial; + } + + function invokePartial(partial, context, options) { + options.partial = true; + if (options.ids) { + options.data.contextPath = options.ids[0] || options.data.contextPath; + } + + var partialBlock = undefined; + if (options.fn && options.fn !== noop) { + options.data = _base.createFrame(options.data); + partialBlock = options.data['partial-block'] = options.fn; + + if (partialBlock.partials) { + options.partials = Utils.extend({}, options.partials, partialBlock.partials); + } + } + + if (partial === undefined && partialBlock) { + partial = partialBlock; + } + + if (partial === undefined) { + throw new _exception2['default']('The partial ' + options.name + ' could not be found'); + } else if (partial instanceof Function) { + return partial(context, options); + } + } + + function noop() { + return ''; + } + + function initData(context, data) { + if (!data || !('root' in data)) { + data = data ? _base.createFrame(data) : {}; + data.root = context; + } + return data; + } + + function executeDecorators(fn, prog, container, depths, data, blockParams) { + if (fn.decorator) { + var props = {}; + prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths); + Utils.extend(prog, props); + } + return prog; + } + //# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../lib/handlebars/runtime.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;qBAAuB,SAAS;;IAApB,KAAK;;yBACK,aAAa;;;;oBAC8B,QAAQ;;AAElE,SAAS,aAAa,CAAC,YAAY,EAAE;AAC1C,MAAM,gBAAgB,GAAG,YAAY,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC;MACvD,eAAe,0BAAoB,CAAC;;AAE1C,MAAI,gBAAgB,KAAK,eAAe,EAAE;AACxC,QAAI,gBAAgB,GAAG,eAAe,EAAE;AACtC,UAAM,eAAe,GAAG,uBAAiB,eAAe,CAAC;UACnD,gBAAgB,GAAG,uBAAiB,gBAAgB,CAAC,CAAC;AAC5D,YAAM,2BAAc,yFAAyF,GACvG,qDAAqD,GAAG,eAAe,GAAG,mDAAmD,GAAG,gBAAgB,GAAG,IAAI,CAAC,CAAC;KAChK,MAAM;;AAEL,YAAM,2BAAc,wFAAwF,GACtG,iDAAiD,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;KACnF;GACF;CACF;;AAEM,SAAS,QAAQ,CAAC,YAAY,EAAE,GAAG,EAAE;;AAE1C,MAAI,CAAC,GAAG,EAAE;AACR,UAAM,2BAAc,mCAAmC,CAAC,CAAC;GAC1D;AACD,MAAI,CAAC,YAAY,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE;AACvC,UAAM,2BAAc,2BAA2B,GAAG,OAAO,YAAY,CAAC,CAAC;GACxE;;AAED,cAAY,CAAC,IAAI,CAAC,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC;;;;AAIlD,KAAG,CAAC,EAAE,CAAC,aAAa,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;;AAE5C,WAAS,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE;AACvD,QAAI,OAAO,CAAC,IAAI,EAAE;AAChB,aAAO,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;AAClD,UAAI,OAAO,CAAC,GAAG,EAAE;AACf,eAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;OACvB;KACF;;AAED,WAAO,GAAG,GAAG,CAAC,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AACtE,QAAI,MAAM,GAAG,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;;AAExE,QAAI,MAAM,IAAI,IAAI,IAAI,GAAG,CAAC,OAAO,EAAE;AACjC,aAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC;AACzF,YAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;KAC3D;AACD,QAAI,MAAM,IAAI,IAAI,EAAE;AAClB,UAAI,OAAO,CAAC,MAAM,EAAE;AAClB,YAAI,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAC/B,aAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;AAC5C,cAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;AAC5B,kBAAM;WACP;;AAED,eAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;SACtC;AACD,cAAM,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;OAC3B;AACD,aAAO,MAAM,CAAC;KACf,MAAM;AACL,YAAM,2BAAc,cAAc,GAAG,OAAO,CAAC,IAAI,GAAG,0DAA0D,CAAC,CAAC;KACjH;GACF;;;AAGD,MAAI,SAAS,GAAG;AACd,UAAM,EAAE,gBAAS,GAAG,EAAE,IAAI,EAAE;AAC1B,UAAI,EAAE,IAAI,IAAI,GAAG,CAAA,AAAC,EAAE;AAClB,cAAM,2BAAc,GAAG,GAAG,IAAI,GAAG,mBAAmB,GAAG,GAAG,CAAC,CAAC;OAC7D;AACD,aAAO,GAAG,CAAC,IAAI,CAAC,CAAC;KAClB;AACD,UAAM,EAAE,gBAAS,MAAM,EAAE,IAAI,EAAE;AAC7B,UAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC;AAC1B,WAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;AAC5B,YAAI,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE;AACxC,iBAAO,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;SACxB;OACF;KACF;AACD,UAAM,EAAE,gBAAS,OAAO,EAAE,OAAO,EAAE;AACjC,aAAO,OAAO,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;KACxE;;AAED,oBAAgB,EAAE,KAAK,CAAC,gBAAgB;AACxC,iBAAa,EAAE,oBAAoB;;AAEnC,MAAE,EAAE,YAAS,CAAC,EAAE;AACd,UAAI,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;AAC1B,SAAG,CAAC,SAAS,GAAG,YAAY,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;AACvC,aAAO,GAAG,CAAC;KACZ;;AAED,YAAQ,EAAE,EAAE;AACZ,WAAO,EAAE,iBAAS,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,EAAE;AACnE,UAAI,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;UACjC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACpB,UAAI,IAAI,IAAI,MAAM,IAAI,WAAW,IAAI,mBAAmB,EAAE;AACxD,sBAAc,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;OAC3F,MAAM,IAAI,CAAC,cAAc,EAAE;AAC1B,sBAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;OAC9D;AACD,aAAO,cAAc,CAAC;KACvB;;AAED,QAAI,EAAE,cAAS,KAAK,EAAE,KAAK,EAAE;AAC3B,aAAO,KAAK,IAAI,KAAK,EAAE,EAAE;AACvB,aAAK,GAAG,KAAK,CAAC,OAAO,CAAC;OACvB;AACD,aAAO,KAAK,CAAC;KACd;AACD,SAAK,EAAE,eAAS,KAAK,EAAE,MAAM,EAAE;AAC7B,UAAI,GAAG,GAAG,KAAK,IAAI,MAAM,CAAC;;AAE1B,UAAI,KAAK,IAAI,MAAM,IAAK,KAAK,KAAK,MAAM,AAAC,EAAE;AACzC,WAAG,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;OACvC;;AAED,aAAO,GAAG,CAAC;KACZ;;AAED,QAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI;AACjB,gBAAY,EAAE,YAAY,CAAC,QAAQ;GACpC,CAAC;;AAEF,WAAS,GAAG,CAAC,OAAO,EAAgB;QAAd,OAAO,yDAAG,EAAE;;AAChC,QAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;;AAExB,OAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AACpB,QAAI,CAAC,OAAO,CAAC,OAAO,IAAI,YAAY,CAAC,OAAO,EAAE;AAC5C,UAAI,GAAG,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;KAChC;AACD,QAAI,MAAM,YAAA;QACN,WAAW,GAAG,YAAY,CAAC,cAAc,GAAG,EAAE,GAAG,SAAS,CAAC;AAC/D,QAAI,YAAY,CAAC,SAAS,EAAE;AAC1B,UAAI,OAAO,CAAC,MAAM,EAAE;AAClB,cAAM,GAAG,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;OAC5F,MAAM;AACL,cAAM,GAAG,CAAC,OAAO,CAAC,CAAC;OACpB;KACF;;AAED,aAAS,IAAI,CAAC,OAAO,gBAAe;AAClC,aAAO,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;KACrH;AACD,QAAI,GAAG,iBAAiB,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,MAAM,IAAI,EAAE,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;AACtG,WAAO,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;GAC/B;AACD,KAAG,CAAC,KAAK,GAAG,IAAI,CAAC;;AAEjB,KAAG,CAAC,MAAM,GAAG,UAAS,OAAO,EAAE;AAC7B,QAAI,CAAC,OAAO,CAAC,OAAO,EAAE;AACpB,eAAS,CAAC,OAAO,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;;AAElE,UAAI,YAAY,CAAC,UAAU,EAAE;AAC3B,iBAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC;OACtE;AACD,UAAI,YAAY,CAAC,UAAU,IAAI,YAAY,CAAC,aAAa,EAAE;AACzD,iBAAS,CAAC,UAAU,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;OAC5E;KACF,MAAM;AACL,eAAS,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;AACpC,eAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;AACtC,eAAS,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;KAC3C;GACF,CAAC;;AAEF,KAAG,CAAC,MAAM,GAAG,UAAS,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE;AAClD,QAAI,YAAY,CAAC,cAAc,IAAI,CAAC,WAAW,EAAE;AAC/C,YAAM,2BAAc,wBAAwB,CAAC,CAAC;KAC/C;AACD,QAAI,YAAY,CAAC,SAAS,IAAI,CAAC,MAAM,EAAE;AACrC,YAAM,2BAAc,yBAAyB,CAAC,CAAC;KAChD;;AAED,WAAO,WAAW,CAAC,SAAS,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;GACjF,CAAC;AACF,SAAO,GAAG,CAAC;CACZ;;AAEM,SAAS,WAAW,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,EAAE;AAC5F,WAAS,IAAI,CAAC,OAAO,EAAgB;QAAd,OAAO,yDAAG,EAAE;;AACjC,QAAI,aAAa,GAAG,MAAM,CAAC;AAC3B,QAAI,MAAM,IAAI,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE;AACnC,mBAAa,GAAG,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;KAC1C;;AAED,WAAO,EAAE,CAAC,SAAS,EACf,OAAO,EACP,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,QAAQ,EACrC,OAAO,CAAC,IAAI,IAAI,IAAI,EACpB,WAAW,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,EACxD,aAAa,CAAC,CAAC;GACpB;;AAED,MAAI,GAAG,iBAAiB,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;;AAEzE,MAAI,CAAC,OAAO,GAAG,CAAC,CAAC;AACjB,MAAI,CAAC,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;AACxC,MAAI,CAAC,WAAW,GAAG,mBAAmB,IAAI,CAAC,CAAC;AAC5C,SAAO,IAAI,CAAC;CACb;;AAEM,SAAS,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE;AACxD,MAAI,CAAC,OAAO,EAAE;AACZ,QAAI,OAAO,CAAC,IAAI,KAAK,gBAAgB,EAAE;AACrC,aAAO,GAAG,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;KACzC,MAAM;AACL,aAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;KAC1C;GACF,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE;;AAEzC,WAAO,CAAC,IAAI,GAAG,OAAO,CAAC;AACvB,WAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;GACrC;AACD,SAAO,OAAO,CAAC;CAChB;;AAEM,SAAS,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE;AACvD,SAAO,CAAC,OAAO,GAAG,IAAI,CAAC;AACvB,MAAI,OAAO,CAAC,GAAG,EAAE;AACf,WAAO,CAAC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC;GACvE;;AAED,MAAI,YAAY,YAAA,CAAC;AACjB,MAAI,OAAO,CAAC,EAAE,IAAI,OAAO,CAAC,EAAE,KAAK,IAAI,EAAE;AACrC,WAAO,CAAC,IAAI,GAAG,kBAAY,OAAO,CAAC,IAAI,CAAC,CAAC;AACzC,gBAAY,GAAG,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,OAAO,CAAC,EAAE,CAAC;;AAE1D,QAAI,YAAY,CAAC,QAAQ,EAAE;AACzB,aAAO,CAAC,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;KAC9E;GACF;;AAED,MAAI,OAAO,KAAK,SAAS,IAAI,YAAY,EAAE;AACzC,WAAO,GAAG,YAAY,CAAC;GACxB;;AAED,MAAI,OAAO,KAAK,SAAS,EAAE;AACzB,UAAM,2BAAc,cAAc,GAAG,OAAO,CAAC,IAAI,GAAG,qBAAqB,CAAC,CAAC;GAC5E,MAAM,IAAI,OAAO,YAAY,QAAQ,EAAE;AACtC,WAAO,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;GAClC;CACF;;AAEM,SAAS,IAAI,GAAG;AAAE,SAAO,EAAE,CAAC;CAAE;;AAErC,SAAS,QAAQ,CAAC,OAAO,EAAE,IAAI,EAAE;AAC/B,MAAI,CAAC,IAAI,IAAI,EAAE,MAAM,IAAI,IAAI,CAAA,AAAC,EAAE;AAC9B,QAAI,GAAG,IAAI,GAAG,kBAAY,IAAI,CAAC,GAAG,EAAE,CAAC;AACrC,QAAI,CAAC,IAAI,GAAG,OAAO,CAAC;GACrB;AACD,SAAO,IAAI,CAAC;CACb;;AAED,SAAS,iBAAiB,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE;AACzE,MAAI,EAAE,CAAC,SAAS,EAAE;AAChB,QAAI,KAAK,GAAG,EAAE,CAAC;AACf,QAAI,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;AAC5F,SAAK,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;GAC3B;AACD,SAAO,IAAI,CAAC;CACb","file":"runtime.js","sourcesContent":["import * as Utils from './utils';\nimport Exception from './exception';\nimport { COMPILER_REVISION, REVISION_CHANGES, createFrame } from './base';\n\nexport function checkRevision(compilerInfo) {\n  const compilerRevision = compilerInfo && compilerInfo[0] || 1,\n        currentRevision = COMPILER_REVISION;\n\n  if (compilerRevision !== currentRevision) {\n    if (compilerRevision < currentRevision) {\n      const runtimeVersions = REVISION_CHANGES[currentRevision],\n            compilerVersions = REVISION_CHANGES[compilerRevision];\n      throw new Exception('Template was precompiled with an older version of Handlebars than the current runtime. ' +\n            'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').');\n    } else {\n      // Use the embedded version info since the runtime doesn't know about this revision yet\n      throw new Exception('Template was precompiled with a newer version of Handlebars than the current runtime. ' +\n            'Please update your runtime to a newer version (' + compilerInfo[1] + ').');\n    }\n  }\n}\n\nexport function template(templateSpec, env) {\n  /* istanbul ignore next */\n  if (!env) {\n    throw new Exception('No environment passed to template');\n  }\n  if (!templateSpec || !templateSpec.main) {\n    throw new Exception('Unknown template object: ' + typeof templateSpec);\n  }\n\n  templateSpec.main.decorator = templateSpec.main_d;\n\n  // Note: Using env.VM references rather than local var references throughout this section to allow\n  // for external users to override these as psuedo-supported APIs.\n  env.VM.checkRevision(templateSpec.compiler);\n\n  function invokePartialWrapper(partial, context, options) {\n    if (options.hash) {\n      context = Utils.extend({}, context, options.hash);\n      if (options.ids) {\n        options.ids[0] = true;\n      }\n    }\n\n    partial = env.VM.resolvePartial.call(this, partial, context, options);\n    let result = env.VM.invokePartial.call(this, partial, context, options);\n\n    if (result == null && env.compile) {\n      options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);\n      result = options.partials[options.name](context, options);\n    }\n    if (result != null) {\n      if (options.indent) {\n        let lines = result.split('\\n');\n        for (let i = 0, l = lines.length; i < l; i++) {\n          if (!lines[i] && i + 1 === l) {\n            break;\n          }\n\n          lines[i] = options.indent + lines[i];\n        }\n        result = lines.join('\\n');\n      }\n      return result;\n    } else {\n      throw new Exception('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');\n    }\n  }\n\n  // Just add water\n  let container = {\n    strict: function(obj, name) {\n      if (!(name in obj)) {\n        throw new Exception('\"' + name + '\" not defined in ' + obj);\n      }\n      return obj[name];\n    },\n    lookup: function(depths, name) {\n      const len = depths.length;\n      for (let i = 0; i < len; i++) {\n        if (depths[i] && depths[i][name] != null) {\n          return depths[i][name];\n        }\n      }\n    },\n    lambda: function(current, context) {\n      return typeof current === 'function' ? current.call(context) : current;\n    },\n\n    escapeExpression: Utils.escapeExpression,\n    invokePartial: invokePartialWrapper,\n\n    fn: function(i) {\n      let ret = templateSpec[i];\n      ret.decorator = templateSpec[i + '_d'];\n      return ret;\n    },\n\n    programs: [],\n    program: function(i, data, declaredBlockParams, blockParams, depths) {\n      let programWrapper = this.programs[i],\n          fn = this.fn(i);\n      if (data || depths || blockParams || declaredBlockParams) {\n        programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);\n      } else if (!programWrapper) {\n        programWrapper = this.programs[i] = wrapProgram(this, i, fn);\n      }\n      return programWrapper;\n    },\n\n    data: function(value, depth) {\n      while (value && depth--) {\n        value = value._parent;\n      }\n      return value;\n    },\n    merge: function(param, common) {\n      let obj = param || common;\n\n      if (param && common && (param !== common)) {\n        obj = Utils.extend({}, common, param);\n      }\n\n      return obj;\n    },\n\n    noop: env.VM.noop,\n    compilerInfo: templateSpec.compiler\n  };\n\n  function ret(context, options = {}) {\n    let data = options.data;\n\n    ret._setup(options);\n    if (!options.partial && templateSpec.useData) {\n      data = initData(context, data);\n    }\n    let depths,\n        blockParams = templateSpec.useBlockParams ? [] : undefined;\n    if (templateSpec.useDepths) {\n      if (options.depths) {\n        depths = context !== options.depths[0] ? [context].concat(options.depths) : options.depths;\n      } else {\n        depths = [context];\n      }\n    }\n\n    function main(context/*, options*/) {\n      return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths);\n    }\n    main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams);\n    return main(context, options);\n  }\n  ret.isTop = true;\n\n  ret._setup = function(options) {\n    if (!options.partial) {\n      container.helpers = container.merge(options.helpers, env.helpers);\n\n      if (templateSpec.usePartial) {\n        container.partials = container.merge(options.partials, env.partials);\n      }\n      if (templateSpec.usePartial || templateSpec.useDecorators) {\n        container.decorators = container.merge(options.decorators, env.decorators);\n      }\n    } else {\n      container.helpers = options.helpers;\n      container.partials = options.partials;\n      container.decorators = options.decorators;\n    }\n  };\n\n  ret._child = function(i, data, blockParams, depths) {\n    if (templateSpec.useBlockParams && !blockParams) {\n      throw new Exception('must pass block params');\n    }\n    if (templateSpec.useDepths && !depths) {\n      throw new Exception('must pass parent depths');\n    }\n\n    return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);\n  };\n  return ret;\n}\n\nexport function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {\n  function prog(context, options = {}) {\n    let currentDepths = depths;\n    if (depths && context !== depths[0]) {\n      currentDepths = [context].concat(depths);\n    }\n\n    return fn(container,\n        context,\n        container.helpers, container.partials,\n        options.data || data,\n        blockParams && [options.blockParams].concat(blockParams),\n        currentDepths);\n  }\n\n  prog = executeDecorators(fn, prog, container, depths, data, blockParams);\n\n  prog.program = i;\n  prog.depth = depths ? depths.length : 0;\n  prog.blockParams = declaredBlockParams || 0;\n  return prog;\n}\n\nexport function resolvePartial(partial, context, options) {\n  if (!partial) {\n    if (options.name === '@partial-block') {\n      partial = options.data['partial-block'];\n    } else {\n      partial = options.partials[options.name];\n    }\n  } else if (!partial.call && !options.name) {\n    // This is a dynamic partial that returned a string\n    options.name = partial;\n    partial = options.partials[partial];\n  }\n  return partial;\n}\n\nexport function invokePartial(partial, context, options) {\n  options.partial = true;\n  if (options.ids) {\n    options.data.contextPath = options.ids[0] || options.data.contextPath;\n  }\n\n  let partialBlock;\n  if (options.fn && options.fn !== noop) {\n    options.data = createFrame(options.data);\n    partialBlock = options.data['partial-block'] = options.fn;\n\n    if (partialBlock.partials) {\n      options.partials = Utils.extend({}, options.partials, partialBlock.partials);\n    }\n  }\n\n  if (partial === undefined && partialBlock) {\n    partial = partialBlock;\n  }\n\n  if (partial === undefined) {\n    throw new Exception('The partial ' + options.name + ' could not be found');\n  } else if (partial instanceof Function) {\n    return partial(context, options);\n  }\n}\n\nexport function noop() { return ''; }\n\nfunction initData(context, data) {\n  if (!data || !('root' in data)) {\n    data = data ? createFrame(data) : {};\n    data.root = context;\n  }\n  return data;\n}\n\nfunction executeDecorators(fn, prog, container, depths, data, blockParams) {\n  if (fn.decorator) {\n    let props = {};\n    prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths);\n    Utils.extend(prog, props);\n  }\n  return prog;\n}\n"]} + + +/***/ }, +/* 26 */ +/***/ function(module, exports) { + + /* WEBPACK VAR INJECTION */(function(global) {/* global window */ + 'use strict'; + + exports.__esModule = true; + + exports['default'] = function (Handlebars) { + /* istanbul ignore next */ + var root = typeof global !== 'undefined' ? global : window, + $Handlebars = root.Handlebars; + /* istanbul ignore next */ + Handlebars.noConflict = function () { + if (root.Handlebars === Handlebars) { + root.Handlebars = $Handlebars; + } + return Handlebars; + }; + }; + + module.exports = exports['default']; + //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL25vLWNvbmZsaWN0LmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O3FCQUNlLFVBQVMsVUFBVSxFQUFFOztBQUVsQyxNQUFJLElBQUksR0FBRyxPQUFPLE1BQU0sS0FBSyxXQUFXLEdBQUcsTUFBTSxHQUFHLE1BQU07TUFDdEQsV0FBVyxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUM7O0FBRWxDLFlBQVUsQ0FBQyxVQUFVLEdBQUcsWUFBVztBQUNqQyxRQUFJLElBQUksQ0FBQyxVQUFVLEtBQUssVUFBVSxFQUFFO0FBQ2xDLFVBQUksQ0FBQyxVQUFVLEdBQUcsV0FBVyxDQUFDO0tBQy9CO0FBQ0QsV0FBTyxVQUFVLENBQUM7R0FDbkIsQ0FBQztDQUNIIiwiZmlsZSI6Im5vLWNvbmZsaWN0LmpzIiwic291cmNlc0NvbnRlbnQiOlsiLyogZ2xvYmFsIHdpbmRvdyAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24oSGFuZGxlYmFycykge1xuICAvKiBpc3RhbmJ1bCBpZ25vcmUgbmV4dCAqL1xuICBsZXQgcm9vdCA9IHR5cGVvZiBnbG9iYWwgIT09ICd1bmRlZmluZWQnID8gZ2xvYmFsIDogd2luZG93LFxuICAgICAgJEhhbmRsZWJhcnMgPSByb290LkhhbmRsZWJhcnM7XG4gIC8qIGlzdGFuYnVsIGlnbm9yZSBuZXh0ICovXG4gIEhhbmRsZWJhcnMubm9Db25mbGljdCA9IGZ1bmN0aW9uKCkge1xuICAgIGlmIChyb290LkhhbmRsZWJhcnMgPT09IEhhbmRsZWJhcnMpIHtcbiAgICAgIHJvb3QuSGFuZGxlYmFycyA9ICRIYW5kbGViYXJzO1xuICAgIH1cbiAgICByZXR1cm4gSGFuZGxlYmFycztcbiAgfTtcbn1cbiJdfQ== + + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) + +/***/ }, +/* 27 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var modalTemplate = __webpack_require__(28); + + var Modal = function () { + function Modal(options) { + _classCallCheck(this, Modal); + + this._placeholder = options.placeholder; + this._options = options; + this._content = ''; + } + + _createClass(Modal, [{ + key: 'show', + value: function show() { + //Lazy rendering + if (!this._el) { + this._render(); + } + if (!this._el.parentNode) { + this._placeholder.appendChild(this._el); + } + } + }, { + key: 'hide', + value: function hide() { + this._placeholder.removeChild(this._el); + } + }, { + key: 'setContent', + value: function setContent(content) { + this._content = content; + } + }, { + key: '_render', + value: function _render() { + var _this = this; + + this._el = document.createElement('div'); + //Append generated HTML to wrapper + this._el.innerHTML = modalTemplate({ + title: this._options.title, + content: this._content + }); + //Set delay for animation + setTimeout(function () { + _this._el.querySelector('.modal').classList.remove('js-modal-hidden'); + }, 20); + this._el.addEventListener('click', this._onCloseClick.bind(this)); + this._el.addEventListener('contextmenu', this._onContextMenu.bind(this)); + + return this._el; + } + }, { + key: '_onCloseClick', + value: function _onCloseClick(event) { + var closeBtn = event.target.closest('[data-action="close"]'); + + if (closeBtn) { + this.hide(); + } + } + + /** + * Prevent context menu on modal + */ + + }, { + key: '_onContextMenu', + value: function _onContextMenu(event) { + event.preventDefault(); + } + }]); + + return Modal; + }(); + + module.exports = Modal; + +/***/ }, +/* 28 */ +/***/ function(module, exports, __webpack_require__) { + + var Handlebars = __webpack_require__(8); + function __default(obj) { return obj && (obj.__esModule ? obj["default"] : obj); } + module.exports = (Handlebars["default"] || Handlebars).template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : {}, alias2=helpers.helperMissing, alias3="function"; + + return "
\r\n
\r\n

" + + container.escapeExpression(((helper = (helper = helpers.title || (depth0 != null ? depth0.title : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"title","hash":{},"data":data}) : helper))) + + "

\r\n
" + + ((stack1 = ((helper = (helper = helpers.content || (depth0 != null ? depth0.content : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"content","hash":{},"data":data}) : helper))) != null ? stack1 : "") + + "
\r\n
\r\n
\r\n
"; + },"useData":true}); + +/***/ }, +/* 29 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var resultsTemplate = __webpack_require__(30); + /** + * Object representing the storage interface + */ + var Results = function () { + var storageName = '_minesweeper_data_'; + + /** + * Get collected data for previous games from localStorage + * @private + */ + function _getFromStorage() { + var results = window.localStorage.getItem(storageName); + + return results ? JSON.parse(results) : []; + } + + /** + * Save new result (seconds) + * @param result + */ + function _save(result) { + var results = _getFromStorage(); + var resultToSave = { + time: result, + date: Date.now() + }; + + results.push(resultToSave); + window.localStorage.setItem(storageName, JSON.stringify(results)); + } + + /** + * Render current data from storage to simple table + * @returns {string} table HTML + */ + function _render() { + var results = _getFromStorage(); + var totalResults = results.length; + //Convert date from ms to local format + results.forEach(function (result, i) { + result.date = new Date(result.date).toLocaleDateString(); + if (i == totalResults - 1) { + //Mark result as current + result.current = true; + } + }); + //Range results + results.sort(function (a, b) { + return a.time - b.time; + }); + + return resultsTemplate({ + results: results + }); + } + + return { + save: _save, + render: _render + }; + }(); + + module.exports = Results; + +/***/ }, +/* 30 */ +/***/ function(module, exports, __webpack_require__) { + + var Handlebars = __webpack_require__(8); + function __default(obj) { return obj && (obj.__esModule ? obj["default"] : obj); } + module.exports = (Handlebars["default"] || Handlebars).template({"1":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : {}, alias2=container.escapeExpression, alias3=container.lambda; + + return " \r\n " + + alias2(__default(__webpack_require__(31)).call(alias1,(data && data.index),{"name":"increment","hash":{},"data":data})) + + "\r\n " + + alias2(alias3((depth0 != null ? depth0.time : depth0), depth0)) + + "\r\n " + + alias2(alias3((depth0 != null ? depth0.date : depth0), depth0)) + + "\r\n \r\n"; + },"2":function(container,depth0,helpers,partials,data) { + return "class=\"current\""; + },"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1; + + return "
\r\n
\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n" + + ((stack1 = helpers.each.call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.results : depth0),{"name":"each","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data})) != null ? stack1 : "") + + " \r\n
\r\n
Rank
\r\n 		\r\n
Result (sec)
\r\n 		\r\n
Date
\r\n
\r\n
\r\n
"; + },"useData":true}); + +/***/ }, +/* 31 */ +/***/ function(module, exports) { + + "use strict"; + + module.exports = function (value) { + return value + 1; + }; + +/***/ }, +/* 32 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + + function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var Dispatcher = __webpack_require__(3); + + var Timer = function (_Dispatcher) { + _inherits(Timer, _Dispatcher); + + function Timer() { + _classCallCheck(this, Timer); + + return _possibleConstructorReturn(this, Object.getPrototypeOf(Timer).apply(this, arguments)); + } + + _createClass(Timer, [{ + key: 'start', + value: function start() { + var _this2 = this; + + this.startTime = Date.now(); + this.interval = setInterval(function () { + _this2.update(); + }, 1000); + this.update(); + } + }, { + key: 'stop', + value: function stop() { + if (this.interval) { + clearInterval(this.interval); + } + } + }, { + key: 'reset', + value: function reset() { + this.stop(); + this.startTime = Date.now(); + this.update(); + } + }, { + key: 'update', + value: function update() { + this._current = Math.round((Date.now() - this.startTime) / 1000); + this.dispatchEvent('timeUpdate', this._current); + } + }, { + key: 'getValue', + value: function getValue() { + return this._current; + } + }]); + + return Timer; + }(Dispatcher); + + module.exports = Timer; + +/***/ }, +/* 33 */ +/***/ function(module, exports, __webpack_require__) { + + var Handlebars = __webpack_require__(8); + function __default(obj) { return obj && (obj.__esModule ? obj["default"] : obj); } + module.exports = (Handlebars["default"] || Handlebars).template({"1":function(container,depth0,helpers,partials,data,blockParams,depths) { + var stack1; + + return " \r\n" + + ((stack1 = __default(__webpack_require__(34)).call(depth0 != null ? depth0 : {},(depths[1] != null ? depths[1].columns : depths[1]),{"name":"loop","hash":{},"fn":container.program(2, data, 0, blockParams, depths),"inverse":container.noop,"data":data})) != null ? stack1 : "") + + " \r\n"; + },"2":function(container,depth0,helpers,partials,data) { + return " \r\n"; + },"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data,blockParams,depths) { + var stack1; + + return "\r\n" + + ((stack1 = __default(__webpack_require__(34)).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.rows : depth0),{"name":"loop","hash":{},"fn":container.program(1, data, 0, blockParams, depths),"inverse":container.noop,"data":data})) != null ? stack1 : "") + + "
"; + },"useData":true,"useDepths":true}); + +/***/ }, +/* 34 */ +/***/ function(module, exports) { + + "use strict"; + + module.exports = function (count, options) { + var out = ""; + + while (count--) { + out += options.fn(); + } + return out; + }; + +/***/ } +/******/ ]); +//# sourceMappingURL=build.js.map \ No newline at end of file diff --git a/public/build.js.map b/public/build.js.map new file mode 100644 index 0000000..841f236 --- /dev/null +++ b/public/build.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["webpack:///webpack/bootstrap 4ab3c8aa10e3332aec77","webpack:///./frontend/js/app.js","webpack:///./frontend/js/game.js","webpack:///./frontend/js/gameModel.js","webpack:///./frontend/js/dispatcher.js","webpack:///./frontend/js/fieldModel.js","webpack:///./frontend/js/constants.js","webpack:///./frontend/js/controls.js","webpack:///./frontend/templates/controls-template.hbs","webpack:///./~/handlebars/runtime.js","webpack:///./~/handlebars/dist/cjs/handlebars.runtime.js","webpack:///./~/handlebars/dist/cjs/handlebars/base.js","webpack:///./~/handlebars/dist/cjs/handlebars/utils.js","webpack:///./~/handlebars/dist/cjs/handlebars/exception.js","webpack:///./~/handlebars/dist/cjs/handlebars/helpers.js","webpack:///./~/handlebars/dist/cjs/handlebars/helpers/block-helper-missing.js","webpack:///./~/handlebars/dist/cjs/handlebars/helpers/each.js","webpack:///./~/handlebars/dist/cjs/handlebars/helpers/helper-missing.js","webpack:///./~/handlebars/dist/cjs/handlebars/helpers/if.js","webpack:///./~/handlebars/dist/cjs/handlebars/helpers/log.js","webpack:///./~/handlebars/dist/cjs/handlebars/helpers/lookup.js","webpack:///./~/handlebars/dist/cjs/handlebars/helpers/with.js","webpack:///./~/handlebars/dist/cjs/handlebars/decorators.js","webpack:///./~/handlebars/dist/cjs/handlebars/decorators/inline.js","webpack:///./~/handlebars/dist/cjs/handlebars/logger.js","webpack:///./~/handlebars/dist/cjs/handlebars/safe-string.js","webpack:///./~/handlebars/dist/cjs/handlebars/runtime.js","webpack:///./~/handlebars/dist/cjs/handlebars/no-conflict.js","webpack:///./frontend/js/modal.js","webpack:///./frontend/templates/modal-template.hbs","webpack:///./frontend/js/results.js","webpack:///./frontend/templates/results-template.hbs","webpack:///./frontend/templates/helpers/increment.js","webpack:///./frontend/js/timer.js","webpack:///./frontend/templates/field-template.hbs","webpack:///./frontend/templates/helpers/loop.js"],"names":[],"mappings":"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;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA,IAAG;AACH;AACA;AACA,IAAG;;AAEH;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA,IAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,4CAA2C;;;;;;;ACvG3C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAa;AACb,aAAY;AACZ,aAAY;AACZ,eAAc;AACd,eAAc;AACd,eAAc;AACd,eAAc;AACd;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,kBAAiB,sBAAsB;AACvC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,sCAAqC,SAAS;AAC9C;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA,MAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAG;AACH;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA,wBAAuB;AACvB;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,4CAA2C;;;;;;;AC3H3C;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA,oBAAmB,yBAAyB;AAC5C;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,4CAA2C;;;;;;;ACvC3C;;AAEA;AACA;AACA;;AAEA,uCAAsC,uCAAuC,kBAAkB;;AAE/F;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA2C;;;;;;;AC7C3C;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,MAAK;AACL;AACA,MAAK;AACL;AACA;AACA;AACA;;AAEA;AACA,QAAO;AACP;AACA;AACA,MAAK;AACL;AACA;AACA;AACA,oBAAmB;AACnB;;AAEA;AACA;AACA,IAAG;AACH;;AAEA;AACA,4CAA2C;;;;;;;ACtC3C;;AAEA;AACA;;AAEA,uCAAsC,uCAAuC,kBAAkB;;AAE/F;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,QAAO;AACP;;AAEA;AACA;AACA,qCAAoC,OAAO;AAC3C;AACA;AACA;AACA;AACA,QAAO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,IAAG;AACH;;AAEA;AACA,4CAA2C;;;;;;;AC7F3C;;AAEA;AACA;;AAEA,uCAAsC,uCAAuC,kBAAkB;;AAE/F;;AAEA;;AAEA;AACA;AACA;AACA,iCAAgC,KAAK;AACrC;AACA,MAAK;AACL;AACA;AACA;AACA,IAAG;AACH;;AAEA;AACA,4CAA2C;;;;;;;ACxB3C;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA,IAAG;;AAEH;AACA,4DAA2D,+DAA+D;AAC1H,IAAG;AACH;;AAEA;AACA,4CAA2C;;;;;;;AC5B3C;;AAEA;;AAEA;AACA;AACA;AACA;AACA,oBAAmB,0BAA0B;AAC7C;AACA;;AAEA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;;AAEA;AACA,IAAG;AACH;;AAEA;AACA,4CAA2C;;;;;;;ACzB3C;;AAEA;;AAEA;AACA;AACA;AACA,IAAG;AACH;;AAEA;AACA,4CAA2C;;;;;;;ACX3C;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,QAAO;AACP,MAAK;AACL;AACA;AACA,IAAG;AACH;;AAEA;AACA,4CAA2C;;;;;;;AChC3C;;AAEA;AACA;AACA;;AAEA,uCAAsC,uCAAuC,kBAAkB;;AAE/F;;AAEA;;AAEA;AACA;AACA;AACA,4CAA2C;;;;;;;ACf3C;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA6C;AAC7C;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,IAAG;AACH;;AAEA;AACA,4CAA2C;;;;;;;AC5B3C;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;;AAEA;AACA,IAAG;;AAEH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,4FAA2F,aAAa;AACxG;AACA;;AAEA,+CAA8C;AAC9C;AACA;AACA;;AAEA;AACA;AACA,4CAA2C;;;;;;;AC9C3C;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,4CAA2C;;;;;;;ACd3C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,uCAAsC,uCAAuC,kBAAkB;;AAE/F;;AAEA,wCAAuC,6BAA6B,YAAY,EAAE,OAAO,iBAAiB,mBAAmB,uBAAuB,4EAA4E,EAAE,EAAE,yBAAyB,eAAe,EAAE;;AAE9Q;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,gCAA+B;AAC/B;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAAyC,OAAO;AAChD;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA,sBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA,MAAK;;AAEL;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA,MAAK;;AAEL;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;;AAEA;AACA,8BAA6B;AAC7B;;AAEA;AACA,MAAK;;AAEL;AACA;AACA;;AAEA;AACA,2EAA0E;;AAE1E;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,2EAA0E;;AAE1E;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AAC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","file":"build.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/public/\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n/** WEBPACK FOOTER **\n ** webpack/bootstrap 4ab3c8aa10e3332aec77\n **/","'use strict';\r\n\r\nlet Game = require('./game');\r\n\r\nlet game = new Game({\r\n element: document.querySelector('[data-component=\"game\"]')\r\n});\n\n\n/** WEBPACK FOOTER **\n ** ./frontend/js/app.js\n **/","'use strict';\r\n\r\nlet GameModel = require('./gameModel.js');\r\nlet Controls = require('./controls');\r\nlet Modal = require('./modal');\r\nlet CellType = require('./constants').CellType;\r\nlet Classes = require('./constants').Classes;\r\nlet GameState = require('./constants').GameState;\r\nlet Default = require('./constants').Default;\r\nlet Results = require('./results');\r\nlet Timer = require('./timer');\r\n\r\nlet fieldTemplate = require('../templates/field-template.hbs');\r\n/**\r\n * Class representing the main game manager\r\n */\r\nclass Game {\r\n /**\r\n * Create game controller\r\n * @param options\r\n */\r\n constructor(options) {\r\n this._el = options.element;\r\n this._fieldWrapper = this._el.querySelector('[data-component=\"field\"]');\r\n\r\n //Bind listeners\r\n this._onFieldLeftClick = this._onFieldLeftClick.bind(this);\r\n this._onFieldRightClick = this._onFieldRightClick.bind(this);\r\n this._onMouseDown = this._onMouseDown.bind(this);\r\n this._onMouseUp = this._onMouseUp.bind(this);\r\n //Current click - collect data about simultaneous click\r\n this._currentClick = {};\r\n\r\n this._gameModel = new GameModel();\r\n this._gameModel.addEventListener('stateChange', this._onGameStateChange.bind(this));\r\n this._gameModel.addEventListener('cellOpen', this._onCellOpen.bind(this));\r\n this._gameModel.addEventListener('cellToggle', this._onCellToggle.bind(this));\r\n this._gameModel.addEventListener('cellHighlight', this._onCellHighlight.bind(this));\r\n this._gameModel.addEventListener('cellClearHighlight', this._onCellClearHighlight.bind(this));\r\n\r\n this._timer = new Timer();\r\n\r\n let controls = new Controls({\r\n element: this._el.querySelector('[data-component=\"controls\"]'),\r\n timer: this._timer\r\n });\r\n controls.addEventListener('start', this._onStart.bind(this));\r\n\r\n //Render default field\r\n this.start({\r\n rows: Default.ROWS,\r\n columns: Default.COLUMNS,\r\n mines: Default.MINES\r\n });\r\n }\r\n\r\n /**\r\n * Start new game with provided options\r\n * @param options\r\n */\r\n start(options) {\r\n this._renderField(options);\r\n this._addListeners();\r\n this._gameModel.start(options);\r\n this._firstClick = false;\r\n this._timer.reset();\r\n }\r\n\r\n /**\r\n * Handle start event from controls panel\r\n * @param {CustomEvent} event\r\n * @private\r\n */\r\n _onStart(event) {\r\n let options = event.detail;\r\n\r\n this.start(options);\r\n }\r\n\r\n /**\r\n * Render new game field\r\n * @param options\r\n * @private\r\n */\r\n _renderField(options) {\r\n this._fieldWrapper.innerHTML = fieldTemplate(options);//fieldHTML;\r\n this._fieldEl = this._fieldWrapper.querySelector('table');\r\n }\r\n\r\n /**\r\n * Add listeners to user interaction\r\n * @private\r\n */\r\n _addListeners() {\r\n this._fieldEl.addEventListener('click', this._onFieldLeftClick);\r\n this._fieldEl.addEventListener('contextmenu', this._onFieldRightClick);\r\n this._fieldEl.addEventListener('mousedown', this._onMouseDown.bind(this));\r\n document.addEventListener('mouseup', this._onMouseUp.bind(this));\r\n }\r\n\r\n /**\r\n * Remove listeners to prevent interaction when game is over\r\n * @private\r\n */\r\n _removeListeners() {\r\n this._fieldEl.removeEventListener('click', this._onFieldLeftClick);\r\n this._fieldEl.removeEventListener('contextmenu', this._onFieldRightClick);\r\n this._fieldEl.removeEventListener('mousedown', this._onMouseDown.bind(this));\r\n document.removeEventListener('mouseup', this._onMouseUp.bind(this));\r\n }\r\n\r\n /**\r\n * User clicks left mouse button\r\n * @param {MouseEvent} event\r\n * @private\r\n */\r\n _onFieldLeftClick(event) {\r\n let targetCell = this._getClickedCell(event);\r\n\r\n if (targetCell) {\r\n this._checkFirstClick();\r\n this._gameModel.openCell(targetCell.parentNode.sectionRowIndex, targetCell.cellIndex);\r\n }\r\n }\r\n\r\n /**\r\n * User clicks left mouse button\r\n * @param {MouseEvent} event\r\n * @private\r\n */\r\n _onFieldRightClick(event) {\r\n let targetCell = this._getClickedCell(event);\r\n\r\n if (targetCell) {\r\n this._checkFirstClick();\r\n this._gameModel.markCell(targetCell.parentNode.sectionRowIndex, targetCell.cellIndex);\r\n }\r\n\r\n event.preventDefault();\r\n }\r\n\r\n /**\r\n * User presses mouse button\r\n * @param event\r\n * @private\r\n */\r\n _onMouseDown(event) {\r\n let targetCell = this._getClickedCell(event);\r\n let currentCell = this._currentClick.cell;\r\n\r\n if (!targetCell || (currentCell && targetCell !== currentCell)) {\r\n this._resetCurrentClick();\r\n return;\r\n }\r\n\r\n this._currentClick.cell = targetCell;\r\n switch (event.which) {\r\n case 1:\r\n this._currentClick.left = true;\r\n break;\r\n case 3:\r\n this._currentClick.right = true;\r\n break;\r\n }\r\n\r\n if (this._currentClick.left && this._currentClick.right) {\r\n this._gameModel.highlightCell(targetCell.parentNode.sectionRowIndex, targetCell.cellIndex);\r\n }\r\n }\r\n\r\n /**\r\n * User releases mouse button\r\n * @param event\r\n * @private\r\n */\r\n _onMouseUp(event) {\r\n let targetCell = this._getClickedCell(event);\r\n let currentCell = this._currentClick.cell;\r\n let twoButtonsDown = this._currentClick.left && this._currentClick.right;\r\n\r\n if (targetCell && currentCell && targetCell == currentCell && twoButtonsDown) {\r\n this._gameModel.openHighlighted();\r\n }\r\n this._gameModel.clearHighlight();\r\n this._resetCurrentClick();\r\n }\r\n\r\n _resetCurrentClick() {\r\n this._currentClick = {};\r\n }\r\n /**\r\n * Check if the click is the first for this new game\r\n * @private\r\n */\r\n _checkFirstClick() {\r\n if (!this._firstClick) {\r\n this._firstClick = true;\r\n this._timer.start();\r\n }\r\n }\r\n\r\n _getClickedCell(event) {\r\n let target = event.target;\r\n\r\n return target.closest('td');\r\n }\r\n\r\n /**\r\n * Handle cell opening and update the cell view state\r\n * @param {CustomEvent} event\r\n * @private\r\n */\r\n _onCellOpen(event) {\r\n let cell = event.detail;\r\n let cellType = cell.type;\r\n let cellEl = this._fieldEl.rows[cell.row].cells[cell.column];\r\n\r\n switch (cellType) {\r\n case CellType.EMPTY:\r\n cellEl.classList.add(Classes.EMPTY);\r\n break;\r\n case CellType.MINE:\r\n cellEl.classList.add(Classes.MINE);\r\n break;\r\n default:\r\n cellEl.classList.add(Classes.NUMBER);\r\n cellEl.innerHTML = cellType;\r\n }\r\n }\r\n /**\r\n * Handle cell toggling and update the cell view state (place/remove flag)\r\n * @param {CustomEvent} event\r\n * @private\r\n */\r\n _onCellToggle(event) {\r\n let cell = event.detail;\r\n let cellEl = this._fieldEl.rows[cell.row].cells[cell.column];\r\n\r\n cellEl.classList.toggle(Classes.MARKED);\r\n }\r\n /**\r\n * Handle cell highlight (highlight neighbours when two buttons pressed on the cell with number)\r\n * @param {CustomEvent} event\r\n * @private\r\n */\r\n _onCellHighlight(event) {\r\n let cell = event.detail;\r\n let cellEl = this._fieldEl.rows[cell.row].cells[cell.column];\r\n\r\n cellEl.classList.add(Classes.HIGHLIGHT);\r\n }\r\n _onCellClearHighlight(event) {\r\n let cell = event.detail;\r\n let cellEl = this._fieldEl.rows[cell.row].cells[cell.column];\r\n\r\n cellEl.classList.remove(Classes.HIGHLIGHT);\r\n }\r\n\r\n _onGameStateChange(event) {\r\n let state = event.detail;\r\n\r\n switch (state) {\r\n case GameState.LOST:\r\n case GameState.WIN:\r\n this._end(state);\r\n break;\r\n }\r\n }\r\n\r\n /**\r\n * Game is over - show message, clear game data and remove listeners\r\n * @param state\r\n * @private\r\n */\r\n _end(state) {\r\n let isWin = (state === GameState.WIN);\r\n\r\n this._timer.stop();\r\n this._removeListeners();\r\n\r\n let message = `You ${isWin ? 'WIN' : 'LOSE'}`;\r\n let modal = new Modal({\r\n placeholder: this._el,\r\n title: message\r\n });\r\n\r\n if (isWin) {\r\n Results.save(this._timer.getValue());\r\n modal.setContent(Results.render());\r\n }\r\n\r\n modal.show();\r\n }\r\n}\r\n\r\nmodule.exports = Game;\r\n\r\n\r\n\n\n\n/** WEBPACK FOOTER **\n ** ./frontend/js/game.js\n **/","'use strict';\r\n\r\nlet Dispatcher = require('./dispatcher');\r\nlet FieldModel = require('./fieldModel');\r\nlet GameState = require('./constants').GameState;\r\nlet CellType = require('./constants').CellType;\r\n\r\nconst DELIMITER = '-';\r\n/**\r\n * Class representing the game model\r\n */\r\nclass GameModel extends Dispatcher {\r\n /**\r\n * Create game model\r\n * @param options\r\n */\r\n constructor(options) {\r\n super(options);\r\n }\r\n\r\n /**\r\n * Start new game with provideed oprions\r\n * @param gameOptions\r\n */\r\n start(gameOptions) {\r\n this._openedCells = {}; //make object for easy access by index ('2-3');\r\n this._markedCells = {};\r\n this._highlightedCells = {};\r\n this._field = new FieldModel(gameOptions);\r\n this._field.generate();\r\n this.setState(GameState.START);\r\n }\r\n\r\n setState(state) {\r\n //WIN and LOST - terminate states. Could only set state to START from them\r\n if (state !== GameState.START && (this._state === GameState.WIN || this._state === GameState.LOST)) {\r\n return;\r\n }\r\n\r\n this._state = state;\r\n this.dispatchEvent('stateChange', this._state);\r\n //this._onStateChange(this._state);\r\n }\r\n\r\n /**\r\n * Mark cell (has mine/has no mine)\r\n * @param row\r\n * @param column\r\n */\r\n markCell(row, column) {\r\n if (this._openedCells[row + DELIMITER + column]) {\r\n return;\r\n }\r\n\r\n this._markedCells[row + DELIMITER + column] = !this._markedCells[row + DELIMITER + column];\r\n this.dispatchEvent('cellToggle', this._field.getCell(row, column));\r\n this._checkGameState();\r\n }\r\n\r\n /**\r\n * Trt to pen cell and check its \"content\"\r\n * @param row\r\n * @param column\r\n */\r\n openCell(row, column) {\r\n let cell = this._checkAndOpenCell(row, column);\r\n\r\n if (!cell) { //cell was already opened\r\n return;\r\n }\r\n switch (cell.type) {\r\n case CellType.EMPTY: //Cell is empty - open all neighbours cells\r\n let neighbours = this._field.getNeighbours(row, column);\r\n neighbours.forEach((neighbourCell) => { //we don't have to check mine because empty neighbours are not mines\r\n let neighbourRow = neighbourCell.row;\r\n let neighbourColumn = neighbourCell.column;\r\n\r\n this.openCell(neighbourRow, neighbourColumn);\r\n });\r\n break;\r\n case CellType.MINE: // Cell has mine - game is over\r\n this._openAll();\r\n this.setState(GameState.LOST);\r\n break;\r\n }\r\n\r\n this._checkGameState();\r\n }\r\n\r\n /**\r\n * Hightlight all cells neighbours if the cell has number and it eual to number of marked neighbours\r\n * @param row\r\n * @param column\r\n */\r\n highlightCell(row, column) {\r\n let cellType = this._field.getCellType(row, column);\r\n let cellIsOpened = this._openedCells[row + DELIMITER + column];\r\n if (!cellIsOpened && cellType > 0) {\r\n return;\r\n }\r\n let neighbours = this._field.getNeighbours(row, column);\r\n let markedNeighbours = neighbours.filter((neighbourCell) => {\r\n return this._markedCells[neighbourCell.row + DELIMITER + neighbourCell.column];\r\n }).length;\r\n\r\n if (markedNeighbours !== cellType) {\r\n return;\r\n }\r\n neighbours.forEach((neighbourCell) => { //we don't have to check mine because empty neighbours are not mines\r\n let neighbourRow = neighbourCell.row;\r\n let neighbourColumn = neighbourCell.column;\r\n let neighbourIsOpened = this._openedCells[neighbourRow + DELIMITER + neighbourColumn];\r\n let neighbourIsMarked = this._markedCells[neighbourRow + DELIMITER + neighbourColumn];\r\n\r\n if (!neighbourIsOpened && !neighbourIsMarked) {\r\n this._highlightedCells[neighbourRow + DELIMITER + neighbourColumn] = true;\r\n this.dispatchEvent('cellHighlight', neighbourCell);\r\n }\r\n });\r\n }\r\n\r\n /**\r\n * Open all cell, that are currently highlighted (by pressing two buttons on mumber cell)\r\n */\r\n openHighlighted() {\r\n for (let i = 0; i < this._field.rows; i++) {\r\n for (let j = 0; j < this._field.columns; j++) {\r\n if (!this._highlightedCells[i + DELIMITER + j]) {\r\n continue;\r\n }\r\n this.openCell(i, j);\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * Clear highlight for all cells\r\n */\r\n clearHighlight() {\r\n for (let i = 0; i < this._field.rows; i++) {\r\n for (let j = 0; j < this._field.columns; j++) {\r\n if (!this._highlightedCells[i + DELIMITER + j]) {\r\n continue;\r\n }\r\n let cell = this._field.getCell(i, j);\r\n\r\n this._highlightedCells[i + DELIMITER + j] = false;\r\n this.dispatchEvent('cellClearHighlight', cell);\r\n }\r\n }\r\n }\r\n /**\r\n * Open cell only it is available\r\n * @param row\r\n * @param column\r\n * @param {boolean} force - open anyway (when game is over)\r\n * @returns {*}\r\n * @private\r\n */\r\n _checkAndOpenCell(row, column, force) {\r\n let cellOpened = this._openedCells[row + DELIMITER + column];\r\n let cellMarked = this._markedCells[row + DELIMITER + column];\r\n\r\n if (!cellOpened && !cellMarked || force) {\r\n let cell = this._field.getCell(row, column);\r\n\r\n this._openedCells[row + DELIMITER + column] = true;\r\n this.dispatchEvent('cellOpen', cell);\r\n\r\n return cell;\r\n }\r\n return null;\r\n }\r\n\r\n _checkGameState() {\r\n //Get number of opened cells and number of cells with mines\r\n let openedCells = Object.keys(this._openedCells).length;\r\n let totalMines = this._field.mines;\r\n let totalCells = this._field.rows * this._field.columns;\r\n\r\n // All \"safe\" cells are opened\r\n if (openedCells + totalMines === totalCells) {\r\n this._openAll();\r\n this.setState(GameState.WIN);\r\n }\r\n }\r\n\r\n /**\r\n * Open all cells (when game is over)\r\n * @private\r\n */\r\n _openAll() {\r\n for (let i = 0; i < this._field.rows; i++) {\r\n for (let j = 0; j < this._field.columns; j++) {\r\n this._checkAndOpenCell(i, j, true);\r\n }\r\n }\r\n }\r\n}\r\n\r\nmodule.exports = GameModel;\n\n\n/** WEBPACK FOOTER **\n ** ./frontend/js/gameModel.js\n **/","'use strict';\r\n/**\r\n * Class representing the base event dispathcer\r\n */\r\nclass Dispatcher {\r\n /**\r\n * Crrate dispatcher\r\n * @param options\r\n */\r\n constructor(options) {\r\n options = options || {};\r\n this._el = options.element || document.createElement('div');\r\n }\r\n\r\n /**\r\n * Add event handler\r\n * @param {string} type\r\n * @param {function} handler\r\n * @param {boolean} capture - use capture\r\n */\r\n addEventListener(type, handler, capture) {\r\n this._el.addEventListener(type, handler, capture);\r\n }\r\n\r\n /**\r\n * Dispatch custom event\r\n * @param {string} type\r\n * @param detail - event data\r\n * @param {object} options\r\n */\r\n dispatchEvent(type, detail, options) {\r\n options = options || {};\r\n\r\n if (detail != undefined) {\r\n options.detail = detail;\r\n }\r\n\r\n let event = new CustomEvent(type, options);\r\n this._el.dispatchEvent(event);\r\n }\r\n}\r\n\r\nmodule.exports = Dispatcher;\n\n\n/** WEBPACK FOOTER **\n ** ./frontend/js/dispatcher.js\n **/","'use strict';\r\n\r\nlet CellType = require('./constants').CellType;\r\n\r\n/**\r\n * Class representing a game field\r\n */\r\nclass FieldModel {\r\n /**\r\n * Create a field\r\n * @param options\r\n */\r\n constructor(options) {\r\n options = options || {};\r\n this.rows = options.rows || Default.ROWS;\r\n this.columns = options.columns || Default.COLUMNS;\r\n this.mines = options.mines || Default.MINES;\r\n }\r\n\r\n /**\r\n * Generate new field with mines, numbers and empty cells\r\n */\r\n generate() {\r\n let placedMines = 0;\r\n\r\n this._field = []; // start with empty array\r\n for (let i = 0; i < this.rows; i++) { // generate empty rows\r\n this._field[i] = [];\r\n }\r\n\r\n // place mines at random position unit reach the number of mines\r\n while (placedMines < this.mines) {\r\n let rowIndex = Math.floor(Math.random() * this.rows);\r\n let columnIndex = Math.floor(Math.random() * this.columns);\r\n\r\n if (this.getCellType(rowIndex, columnIndex) === CellType.MINE) {\r\n continue;\r\n }\r\n\r\n this._field[rowIndex][columnIndex] = CellType.MINE;\r\n placedMines++;\r\n }\r\n\r\n // place numbers in all mines neighbours cells\r\n for (let i = 0; i < this.rows; i++) {\r\n for (let j = 0; j < this.columns; j++) {\r\n if (this.getCellType(i, j) === CellType.MINE) {\r\n let mineNeighbours = this.getNeighbours(i, j);\r\n\r\n mineNeighbours.forEach(cellObj => {\r\n if (cellObj.type !== CellType.MINE) {\r\n this._field[cellObj.row][cellObj.column] = cellObj.type + 1;\r\n }\r\n });\r\n }\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * Get only type for particular cell\r\n * @param row\r\n * @param column\r\n * @returns {number} - cell type (see constants.Defaults)\r\n */\r\n getCellType(row, column) {\r\n return this._field[row][column] || CellType.EMPTY;\r\n }\r\n\r\n /**\r\n * Get cell object\r\n * @param row\r\n * @param column\r\n * @returns {{column: number, row: number, type: number}}\r\n */\r\n getCell(row, column) {\r\n return {\r\n column: column,\r\n row: row,\r\n type: this.getCellType(row, column)\r\n }\r\n }\r\n\r\n /**\r\n * Get neighbours of particular cell\r\n * @param row\r\n * @param column\r\n * @returns {Array} - array of neighbours\r\n */\r\n getNeighbours(row, column) {\r\n let neighbours = [];\r\n let minCol = Math.max(0, column - 1);\r\n let maxCol = Math.min(this.columns - 1, column + 1);\r\n let minRow = Math.max(0, row - 1);\r\n let maxRow = Math.min(this.rows - 1, row + 1);\r\n\r\n for (let i = minRow; i <= maxRow; i++) {\r\n for (let j = minCol; j <= maxCol; j++) {\r\n if (i === row && j === column) {\r\n continue;\r\n }\r\n neighbours.push(this.getCell(i, j));\r\n }\r\n }\r\n\r\n return neighbours;\r\n }\r\n}\r\n\r\nmodule.exports = FieldModel;\n\n\n/** WEBPACK FOOTER **\n ** ./frontend/js/fieldModel.js\n **/","'use strict';\r\n\r\nexports.CellType = {\r\n EMPTY: 0,\r\n MINE: -1\r\n};\r\n\r\nexports.GameState = {\r\n START: 0,\r\n WIN: 1,\r\n LOST: 2\r\n};\r\n\r\nexports.Default = {\r\n COLUMNS: 9,\r\n ROWS: 9,\r\n MINES: 10,\r\n MIN_ROWS: 9,\r\n MAX_ROWS: 20,\r\n MIN_COLUMNS: 9,\r\n MAX_COLUMNS: 20,\r\n MIN_MINES: 2,\r\n MAX_MINES: 40\r\n};\r\n\r\nexports.Selectors = {\r\n ROWS_INPUT: '[name=\"rows\"]',\r\n COLUMNS_INPUT: '[name=\"columns\"]',\r\n MINES_INPUT: '[name=\"mines\"]',\r\n MINES_RANGE_TEXT: '[data-range=\"mines\"]'\r\n};\r\n\r\nexports.Classes = {\r\n EMPTY: 'cell-empty',\r\n MINE: 'cell-mine',\r\n NUMBER: 'cell-number',\r\n MARKED: 'cell-marked',\r\n HIGHLIGHT: 'cell-highlight'\r\n};\n\n\n/** WEBPACK FOOTER **\n ** ./frontend/js/constants.js\n **/","'use strict';\r\n\r\nlet Dispatcher = require('./dispatcher');\r\nlet Default = require('./constants').Default;\r\nlet Selectors = require('./constants').Selectors;\r\nlet controlsTemplate = require('../templates/controls-template.hbs');\r\n\r\n/**\r\n * Class representing the control panel\r\n */\r\nclass Controls extends Dispatcher {\r\n /**\r\n * Create controls\r\n * @param options\r\n */\r\n constructor(options) {\r\n super(options);\r\n\r\n this._render();\r\n this._timer = options.timer;\r\n this._timerEl = this._el.querySelector('[data-content=\"timer\"]');\r\n this._addListeners();\r\n }\r\n\r\n /**\r\n * Render controls from template\r\n * @private\r\n */\r\n _render() {\r\n let defaultOptions = {\r\n minRows: Default.MIN_ROWS,\r\n maxRows: Default.MAX_ROWS,\r\n minCols: Default.MIN_COLUMNS,\r\n maxCols: Default.MAX_COLUMNS,\r\n minMines: Default.MIN_MINES,\r\n maxMines: Default.MAX_MINES,\r\n rows: Default.ROWS,\r\n cols: Default.COLUMNS,\r\n mines: Default.MINES\r\n };\r\n\r\n this._el.innerHTML = controlsTemplate({\r\n options: defaultOptions\r\n });\r\n\r\n this._rowsInput = this._el.querySelector(Selectors.ROWS_INPUT);\r\n this._columnsInput = this._el.querySelector(Selectors.COLUMNS_INPUT);\r\n this._minesInput = this._el.querySelector(Selectors.MINES_INPUT);\r\n this._minesRangeText = this._el.querySelector(Selectors.MINES_RANGE_TEXT);\r\n }\r\n\r\n /**\r\n * Add main listeners for click (start game), timer update, and options input change\r\n * @private\r\n */\r\n _addListeners() {\r\n this._el.addEventListener('click', this._onClick.bind(this));\r\n this._el.addEventListener('change', this._onChange.bind(this));\r\n this._timer.addEventListener('timeUpdate', this._onTimerUpdate.bind(this));\r\n }\r\n\r\n /**\r\n * 'Click' event handler\r\n * @param {MouseEvent} event - click event\r\n * @private\r\n */\r\n _onClick(event) {\r\n var startBtn = event.target.closest('[data-action=\"start\"]');\r\n\r\n if (!startBtn) {\r\n return\r\n }\r\n this._triggerStart();\r\n }\r\n\r\n /**\r\n * Implement start - dispatch 'start' event with current options\r\n * @private\r\n */\r\n _triggerStart() {\r\n let options = this._getOptions();\r\n\r\n this.dispatchEvent('start', options);\r\n }\r\n\r\n /**\r\n * 'Change' event hadler\r\n * @param {Event} event - change event\r\n * @private\r\n */\r\n _onChange(event) {\r\n let optionsForm = event.target.closest('[name=\"options-form\"]');\r\n\r\n if (!optionsForm) {\r\n return;\r\n }\r\n\r\n this._validateOptions();\r\n }\r\n\r\n /**\r\n * Validate current options\r\n * @private\r\n */\r\n _validateOptions() {\r\n let options = this._getOptions();\r\n //Check if input is not valid number\r\n if (isNaN(options.columns)) {\r\n options.columns = Default.MIN_COLUMNS;\r\n }\r\n if (isNaN(options.rows)) {\r\n options.rows = Default.MIN_ROWS;\r\n }\r\n if (isNaN(options.mines)) {\r\n options.rows = Default.MIN_MINES;\r\n }\r\n\r\n options.rows = Math.max(Default.MIN_ROWS, Math.min(options.rows, Default.MAX_ROWS));\r\n options.columns = Math.max(Default.MIN_COLUMNS, Math.min(options.columns, Default.MAX_COLUMNS));\r\n\r\n //Calculate mines max range\r\n let maxMines = this._getMinesMaxRange(options.rows, options.columns);\r\n options.mines = Math.max(Default.MIN_MINES, Math.min(options.mines, maxMines));\r\n //Set mines range\r\n this._minesRangeText.textContent = `(${Default.MIN_MINES}-${maxMines})`;\r\n this._minesInput.max = Default.MIN_MINES;\r\n this._minesInput.max = maxMines;\r\n\r\n this._setOptions(options);\r\n }\r\n\r\n /**\r\n * Get options from DOM\r\n * @returns {{rows: Number, columns: Number, mines: Number}}\r\n * @private\r\n */\r\n _getOptions() {\r\n return {\r\n rows: parseInt(this._rowsInput.value),\r\n columns: parseInt(this._columnsInput.value),\r\n mines: parseInt(this._minesInput.value)\r\n }\r\n }\r\n\r\n /**\r\n * Set options to DOM\r\n * @param options\r\n * @private\r\n */\r\n _setOptions(options) {\r\n this._rowsInput.value = options.rows;\r\n this._columnsInput.value = options.columns;\r\n this._minesInput.value = options.mines;\r\n }\r\n\r\n _getMinesMaxRange(rows, columns) {\r\n return Math.round(rows * columns / 2);\r\n }\r\n\r\n /**\r\n * Render new timer value\r\n * @param {CustomEvent} event\r\n * @private\r\n */\r\n _onTimerUpdate(event) {\r\n let time = event.detail;\r\n let min = Math.floor(time / 60);\r\n let sec = time % 60;\r\n\r\n this._timerEl.textContent = `${this._twoDigits(min)}:${this._twoDigits(sec)}`;\r\n }\r\n\r\n /**\r\n * Convert n to two-digit string\r\n * @param {Number} n\r\n * @private\r\n */\r\n _twoDigits(n) {\r\n return ('0' + n).slice(-2);\r\n }\r\n}\r\n\r\n\r\nmodule.exports = Controls;\r\n\n\n\n/** WEBPACK FOOTER **\n ** ./frontend/js/controls.js\n **/","var Handlebars = require(\"C:\\\\Users\\\\Vladimir\\\\Desktop\\\\JS-Course\\\\MineSweeper\\\\node_modules\\\\handlebars\\\\runtime.js\");\nfunction __default(obj) { return obj && (obj.__esModule ? obj[\"default\"] : obj); }\nmodule.exports = (Handlebars[\"default\"] || Handlebars).template({\"compiler\":[7,\">= 4.0.0\"],\"main\":function(container,depth0,helpers,partials,data) {\n var stack1, alias1=container.lambda, alias2=container.escapeExpression;\n\n return \"
\\r\\n
\\r\\n \\r\\n \\r\\n \\r\\n
\\r\\n
\\r\\n
\\r\\n 00:00\\r\\n
\\r\\n
Start
\";\n},\"useData\":true});\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./frontend/templates/controls-template.hbs\n ** module id = 7\n ** module chunks = 0\n **/","// Create a simple path alias to allow browserify to resolve\n// the runtime on a supported path.\nmodule.exports = require('./dist/cjs/handlebars.runtime')['default'];\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/runtime.js\n ** module id = 8\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\n// istanbul ignore next\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\n// istanbul ignore next\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }\n\nvar _handlebarsBase = require('./handlebars/base');\n\nvar base = _interopRequireWildcard(_handlebarsBase);\n\n// Each of these augment the Handlebars object. No need to setup here.\n// (This is done to easily share code between commonjs and browse envs)\n\nvar _handlebarsSafeString = require('./handlebars/safe-string');\n\nvar _handlebarsSafeString2 = _interopRequireDefault(_handlebarsSafeString);\n\nvar _handlebarsException = require('./handlebars/exception');\n\nvar _handlebarsException2 = _interopRequireDefault(_handlebarsException);\n\nvar _handlebarsUtils = require('./handlebars/utils');\n\nvar Utils = _interopRequireWildcard(_handlebarsUtils);\n\nvar _handlebarsRuntime = require('./handlebars/runtime');\n\nvar runtime = _interopRequireWildcard(_handlebarsRuntime);\n\nvar _handlebarsNoConflict = require('./handlebars/no-conflict');\n\nvar _handlebarsNoConflict2 = _interopRequireDefault(_handlebarsNoConflict);\n\n// For compatibility and usage outside of module systems, make the Handlebars object a namespace\nfunction create() {\n var hb = new base.HandlebarsEnvironment();\n\n Utils.extend(hb, base);\n hb.SafeString = _handlebarsSafeString2['default'];\n hb.Exception = _handlebarsException2['default'];\n hb.Utils = Utils;\n hb.escapeExpression = Utils.escapeExpression;\n\n hb.VM = runtime;\n hb.template = function (spec) {\n return runtime.template(spec, hb);\n };\n\n return hb;\n}\n\nvar inst = create();\ninst.create = create;\n\n_handlebarsNoConflict2['default'](inst);\n\ninst['default'] = inst;\n\nexports['default'] = inst;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;base64,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\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars.runtime.js\n ** module id = 9\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\nexports.HandlebarsEnvironment = HandlebarsEnvironment;\n// istanbul ignore next\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _utils = require('./utils');\n\nvar _exception = require('./exception');\n\nvar _exception2 = _interopRequireDefault(_exception);\n\nvar _helpers = require('./helpers');\n\nvar _decorators = require('./decorators');\n\nvar _logger = require('./logger');\n\nvar _logger2 = _interopRequireDefault(_logger);\n\nvar VERSION = '4.0.5';\nexports.VERSION = VERSION;\nvar COMPILER_REVISION = 7;\n\nexports.COMPILER_REVISION = COMPILER_REVISION;\nvar REVISION_CHANGES = {\n 1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it\n 2: '== 1.0.0-rc.3',\n 3: '== 1.0.0-rc.4',\n 4: '== 1.x.x',\n 5: '== 2.0.0-alpha.x',\n 6: '>= 2.0.0-beta.1',\n 7: '>= 4.0.0'\n};\n\nexports.REVISION_CHANGES = REVISION_CHANGES;\nvar objectType = '[object Object]';\n\nfunction HandlebarsEnvironment(helpers, partials, decorators) {\n this.helpers = helpers || {};\n this.partials = partials || {};\n this.decorators = decorators || {};\n\n _helpers.registerDefaultHelpers(this);\n _decorators.registerDefaultDecorators(this);\n}\n\nHandlebarsEnvironment.prototype = {\n constructor: HandlebarsEnvironment,\n\n logger: _logger2['default'],\n log: _logger2['default'].log,\n\n registerHelper: function registerHelper(name, fn) {\n if (_utils.toString.call(name) === objectType) {\n if (fn) {\n throw new _exception2['default']('Arg not supported with multiple helpers');\n }\n _utils.extend(this.helpers, name);\n } else {\n this.helpers[name] = fn;\n }\n },\n unregisterHelper: function unregisterHelper(name) {\n delete this.helpers[name];\n },\n\n registerPartial: function registerPartial(name, partial) {\n if (_utils.toString.call(name) === objectType) {\n _utils.extend(this.partials, name);\n } else {\n if (typeof partial === 'undefined') {\n throw new _exception2['default']('Attempting to register a partial called \"' + name + '\" as undefined');\n }\n this.partials[name] = partial;\n }\n },\n unregisterPartial: function unregisterPartial(name) {\n delete this.partials[name];\n },\n\n registerDecorator: function registerDecorator(name, fn) {\n if (_utils.toString.call(name) === objectType) {\n if (fn) {\n throw new _exception2['default']('Arg not supported with multiple decorators');\n }\n _utils.extend(this.decorators, name);\n } else {\n this.decorators[name] = fn;\n }\n },\n unregisterDecorator: function unregisterDecorator(name) {\n delete this.decorators[name];\n }\n};\n\nvar log = _logger2['default'].log;\n\nexports.log = log;\nexports.createFrame = _utils.createFrame;\nexports.logger = _logger2['default'];\n//# sourceMappingURL=data:application/json;base64,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\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/base.js\n ** module id = 10\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\nexports.extend = extend;\nexports.indexOf = indexOf;\nexports.escapeExpression = escapeExpression;\nexports.isEmpty = isEmpty;\nexports.createFrame = createFrame;\nexports.blockParams = blockParams;\nexports.appendContextPath = appendContextPath;\nvar escape = {\n '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"',\n \"'\": ''',\n '`': '`',\n '=': '='\n};\n\nvar badChars = /[&<>\"'`=]/g,\n possible = /[&<>\"'`=]/;\n\nfunction escapeChar(chr) {\n return escape[chr];\n}\n\nfunction extend(obj /* , ...source */) {\n for (var i = 1; i < arguments.length; i++) {\n for (var key in arguments[i]) {\n if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {\n obj[key] = arguments[i][key];\n }\n }\n }\n\n return obj;\n}\n\nvar toString = Object.prototype.toString;\n\nexports.toString = toString;\n// Sourced from lodash\n// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt\n/* eslint-disable func-style */\nvar isFunction = function isFunction(value) {\n return typeof value === 'function';\n};\n// fallback for older versions of Chrome and Safari\n/* istanbul ignore next */\nif (isFunction(/x/)) {\n exports.isFunction = isFunction = function (value) {\n return typeof value === 'function' && toString.call(value) === '[object Function]';\n };\n}\nexports.isFunction = isFunction;\n\n/* eslint-enable func-style */\n\n/* istanbul ignore next */\nvar isArray = Array.isArray || function (value) {\n return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false;\n};\n\nexports.isArray = isArray;\n// Older IE versions do not directly support indexOf so we must implement our own, sadly.\n\nfunction indexOf(array, value) {\n for (var i = 0, len = array.length; i < len; i++) {\n if (array[i] === value) {\n return i;\n }\n }\n return -1;\n}\n\nfunction escapeExpression(string) {\n if (typeof string !== 'string') {\n // don't escape SafeStrings, since they're already safe\n if (string && string.toHTML) {\n return string.toHTML();\n } else if (string == null) {\n return '';\n } else if (!string) {\n return string + '';\n }\n\n // Force a string conversion as this will be done by the append regardless and\n // the regex test will do this transparently behind the scenes, causing issues if\n // an object's to string has escaped characters in it.\n string = '' + string;\n }\n\n if (!possible.test(string)) {\n return string;\n }\n return string.replace(badChars, escapeChar);\n}\n\nfunction isEmpty(value) {\n if (!value && value !== 0) {\n return true;\n } else if (isArray(value) && value.length === 0) {\n return true;\n } else {\n return false;\n }\n}\n\nfunction createFrame(object) {\n var frame = extend({}, object);\n frame._parent = object;\n return frame;\n}\n\nfunction blockParams(params, ids) {\n params.path = ids;\n return params;\n}\n\nfunction appendContextPath(contextPath, id) {\n return (contextPath ? contextPath + '.' : '') + id;\n}\n//# sourceMappingURL=data:application/json;base64,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\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/utils.js\n ** module id = 11\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\n\nvar errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];\n\nfunction Exception(message, node) {\n var loc = node && node.loc,\n line = undefined,\n column = undefined;\n if (loc) {\n line = loc.start.line;\n column = loc.start.column;\n\n message += ' - ' + line + ':' + column;\n }\n\n var tmp = Error.prototype.constructor.call(this, message);\n\n // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.\n for (var idx = 0; idx < errorProps.length; idx++) {\n this[errorProps[idx]] = tmp[errorProps[idx]];\n }\n\n /* istanbul ignore else */\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, Exception);\n }\n\n if (loc) {\n this.lineNumber = line;\n this.column = column;\n }\n}\n\nException.prototype = new Error();\n\nexports['default'] = Exception;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;base64,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\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/exception.js\n ** module id = 12\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\nexports.registerDefaultHelpers = registerDefaultHelpers;\n// istanbul ignore next\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _helpersBlockHelperMissing = require('./helpers/block-helper-missing');\n\nvar _helpersBlockHelperMissing2 = _interopRequireDefault(_helpersBlockHelperMissing);\n\nvar _helpersEach = require('./helpers/each');\n\nvar _helpersEach2 = _interopRequireDefault(_helpersEach);\n\nvar _helpersHelperMissing = require('./helpers/helper-missing');\n\nvar _helpersHelperMissing2 = _interopRequireDefault(_helpersHelperMissing);\n\nvar _helpersIf = require('./helpers/if');\n\nvar _helpersIf2 = _interopRequireDefault(_helpersIf);\n\nvar _helpersLog = require('./helpers/log');\n\nvar _helpersLog2 = _interopRequireDefault(_helpersLog);\n\nvar _helpersLookup = require('./helpers/lookup');\n\nvar _helpersLookup2 = _interopRequireDefault(_helpersLookup);\n\nvar _helpersWith = require('./helpers/with');\n\nvar _helpersWith2 = _interopRequireDefault(_helpersWith);\n\nfunction registerDefaultHelpers(instance) {\n _helpersBlockHelperMissing2['default'](instance);\n _helpersEach2['default'](instance);\n _helpersHelperMissing2['default'](instance);\n _helpersIf2['default'](instance);\n _helpersLog2['default'](instance);\n _helpersLookup2['default'](instance);\n _helpersWith2['default'](instance);\n}\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2hlbHBlcnMuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7eUNBQXVDLGdDQUFnQzs7OzsyQkFDOUMsZ0JBQWdCOzs7O29DQUNQLDBCQUEwQjs7Ozt5QkFDckMsY0FBYzs7OzswQkFDYixlQUFlOzs7OzZCQUNaLGtCQUFrQjs7OzsyQkFDcEIsZ0JBQWdCOzs7O0FBRWxDLFNBQVMsc0JBQXNCLENBQUMsUUFBUSxFQUFFO0FBQy9DLHlDQUEyQixRQUFRLENBQUMsQ0FBQztBQUNyQywyQkFBYSxRQUFRLENBQUMsQ0FBQztBQUN2QixvQ0FBc0IsUUFBUSxDQUFDLENBQUM7QUFDaEMseUJBQVcsUUFBUSxDQUFDLENBQUM7QUFDckIsMEJBQVksUUFBUSxDQUFDLENBQUM7QUFDdEIsNkJBQWUsUUFBUSxDQUFDLENBQUM7QUFDekIsMkJBQWEsUUFBUSxDQUFDLENBQUM7Q0FDeEIiLCJmaWxlIjoiaGVscGVycy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCByZWdpc3RlckJsb2NrSGVscGVyTWlzc2luZyBmcm9tICcuL2hlbHBlcnMvYmxvY2staGVscGVyLW1pc3NpbmcnO1xuaW1wb3J0IHJlZ2lzdGVyRWFjaCBmcm9tICcuL2hlbHBlcnMvZWFjaCc7XG5pbXBvcnQgcmVnaXN0ZXJIZWxwZXJNaXNzaW5nIGZyb20gJy4vaGVscGVycy9oZWxwZXItbWlzc2luZyc7XG5pbXBvcnQgcmVnaXN0ZXJJZiBmcm9tICcuL2hlbHBlcnMvaWYnO1xuaW1wb3J0IHJlZ2lzdGVyTG9nIGZyb20gJy4vaGVscGVycy9sb2cnO1xuaW1wb3J0IHJlZ2lzdGVyTG9va3VwIGZyb20gJy4vaGVscGVycy9sb29rdXAnO1xuaW1wb3J0IHJlZ2lzdGVyV2l0aCBmcm9tICcuL2hlbHBlcnMvd2l0aCc7XG5cbmV4cG9ydCBmdW5jdGlvbiByZWdpc3RlckRlZmF1bHRIZWxwZXJzKGluc3RhbmNlKSB7XG4gIHJlZ2lzdGVyQmxvY2tIZWxwZXJNaXNzaW5nKGluc3RhbmNlKTtcbiAgcmVnaXN0ZXJFYWNoKGluc3RhbmNlKTtcbiAgcmVnaXN0ZXJIZWxwZXJNaXNzaW5nKGluc3RhbmNlKTtcbiAgcmVnaXN0ZXJJZihpbnN0YW5jZSk7XG4gIHJlZ2lzdGVyTG9nKGluc3RhbmNlKTtcbiAgcmVnaXN0ZXJMb29rdXAoaW5zdGFuY2UpO1xuICByZWdpc3RlcldpdGgoaW5zdGFuY2UpO1xufVxuIl19\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/helpers.js\n ** module id = 13\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\n\nvar _utils = require('../utils');\n\nexports['default'] = function (instance) {\n instance.registerHelper('blockHelperMissing', function (context, options) {\n var inverse = options.inverse,\n fn = options.fn;\n\n if (context === true) {\n return fn(this);\n } else if (context === false || context == null) {\n return inverse(this);\n } else if (_utils.isArray(context)) {\n if (context.length > 0) {\n if (options.ids) {\n options.ids = [options.name];\n }\n\n return instance.helpers.each(context, options);\n } else {\n return inverse(this);\n }\n } else {\n if (options.data && options.ids) {\n var data = _utils.createFrame(options.data);\n data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name);\n options = { data: data };\n }\n\n return fn(context, options);\n }\n });\n};\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;base64,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\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/helpers/block-helper-missing.js\n ** module id = 14\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\n// istanbul ignore next\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _utils = require('../utils');\n\nvar _exception = require('../exception');\n\nvar _exception2 = _interopRequireDefault(_exception);\n\nexports['default'] = function (instance) {\n instance.registerHelper('each', function (context, options) {\n if (!options) {\n throw new _exception2['default']('Must pass iterator to #each');\n }\n\n var fn = options.fn,\n inverse = options.inverse,\n i = 0,\n ret = '',\n data = undefined,\n contextPath = undefined;\n\n if (options.data && options.ids) {\n contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';\n }\n\n if (_utils.isFunction(context)) {\n context = context.call(this);\n }\n\n if (options.data) {\n data = _utils.createFrame(options.data);\n }\n\n function execIteration(field, index, last) {\n if (data) {\n data.key = field;\n data.index = index;\n data.first = index === 0;\n data.last = !!last;\n\n if (contextPath) {\n data.contextPath = contextPath + field;\n }\n }\n\n ret = ret + fn(context[field], {\n data: data,\n blockParams: _utils.blockParams([context[field], field], [contextPath + field, null])\n });\n }\n\n if (context && typeof context === 'object') {\n if (_utils.isArray(context)) {\n for (var j = context.length; i < j; i++) {\n if (i in context) {\n execIteration(i, i, i === context.length - 1);\n }\n }\n } else {\n var priorKey = undefined;\n\n for (var key in context) {\n if (context.hasOwnProperty(key)) {\n // We're running the iterations one step out of sync so we can detect\n // the last iteration without have to scan the object twice and create\n // an itermediate keys array.\n if (priorKey !== undefined) {\n execIteration(priorKey, i - 1);\n }\n priorKey = key;\n i++;\n }\n }\n if (priorKey !== undefined) {\n execIteration(priorKey, i - 1, true);\n }\n }\n }\n\n if (i === 0) {\n ret = inverse(this);\n }\n\n return ret;\n });\n};\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;base64,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\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/helpers/each.js\n ** module id = 15\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\n// istanbul ignore next\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _exception = require('../exception');\n\nvar _exception2 = _interopRequireDefault(_exception);\n\nexports['default'] = function (instance) {\n instance.registerHelper('helperMissing', function () /* [args, ]options */{\n if (arguments.length === 1) {\n // A missing field in a {{foo}} construct.\n return undefined;\n } else {\n // Someone is actually trying to call something, blow up.\n throw new _exception2['default']('Missing helper: \"' + arguments[arguments.length - 1].name + '\"');\n }\n });\n};\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2hlbHBlcnMvaGVscGVyLW1pc3NpbmcuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozt5QkFBc0IsY0FBYzs7OztxQkFFckIsVUFBUyxRQUFRLEVBQUU7QUFDaEMsVUFBUSxDQUFDLGNBQWMsQ0FBQyxlQUFlLEVBQUUsaUNBQWdDO0FBQ3ZFLFFBQUksU0FBUyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7O0FBRTFCLGFBQU8sU0FBUyxDQUFDO0tBQ2xCLE1BQU07O0FBRUwsWUFBTSwyQkFBYyxtQkFBbUIsR0FBRyxTQUFTLENBQUMsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLEdBQUcsR0FBRyxDQUFDLENBQUM7S0FDdkY7R0FDRixDQUFDLENBQUM7Q0FDSiIsImZpbGUiOiJoZWxwZXItbWlzc2luZy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBFeGNlcHRpb24gZnJvbSAnLi4vZXhjZXB0aW9uJztcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24oaW5zdGFuY2UpIHtcbiAgaW5zdGFuY2UucmVnaXN0ZXJIZWxwZXIoJ2hlbHBlck1pc3NpbmcnLCBmdW5jdGlvbigvKiBbYXJncywgXW9wdGlvbnMgKi8pIHtcbiAgICBpZiAoYXJndW1lbnRzLmxlbmd0aCA9PT0gMSkge1xuICAgICAgLy8gQSBtaXNzaW5nIGZpZWxkIGluIGEge3tmb299fSBjb25zdHJ1Y3QuXG4gICAgICByZXR1cm4gdW5kZWZpbmVkO1xuICAgIH0gZWxzZSB7XG4gICAgICAvLyBTb21lb25lIGlzIGFjdHVhbGx5IHRyeWluZyB0byBjYWxsIHNvbWV0aGluZywgYmxvdyB1cC5cbiAgICAgIHRocm93IG5ldyBFeGNlcHRpb24oJ01pc3NpbmcgaGVscGVyOiBcIicgKyBhcmd1bWVudHNbYXJndW1lbnRzLmxlbmd0aCAtIDFdLm5hbWUgKyAnXCInKTtcbiAgICB9XG4gIH0pO1xufVxuIl19\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/helpers/helper-missing.js\n ** module id = 16\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\n\nvar _utils = require('../utils');\n\nexports['default'] = function (instance) {\n instance.registerHelper('if', function (conditional, options) {\n if (_utils.isFunction(conditional)) {\n conditional = conditional.call(this);\n }\n\n // Default behavior is to render the positive path if the value is truthy and not empty.\n // The `includeZero` option may be set to treat the condtional as purely not empty based on the\n // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.\n if (!options.hash.includeZero && !conditional || _utils.isEmpty(conditional)) {\n return options.inverse(this);\n } else {\n return options.fn(this);\n }\n });\n\n instance.registerHelper('unless', function (conditional, options) {\n return instance.helpers['if'].call(this, conditional, { fn: options.inverse, inverse: options.fn, hash: options.hash });\n });\n};\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;base64,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\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/helpers/if.js\n ** module id = 17\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\n\nexports['default'] = function (instance) {\n instance.registerHelper('log', function () /* message, options */{\n var args = [undefined],\n options = arguments[arguments.length - 1];\n for (var i = 0; i < arguments.length - 1; i++) {\n args.push(arguments[i]);\n }\n\n var level = 1;\n if (options.hash.level != null) {\n level = options.hash.level;\n } else if (options.data && options.data.level != null) {\n level = options.data.level;\n }\n args[0] = level;\n\n instance.log.apply(instance, args);\n });\n};\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2hlbHBlcnMvbG9nLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQWUsVUFBUyxRQUFRLEVBQUU7QUFDaEMsVUFBUSxDQUFDLGNBQWMsQ0FBQyxLQUFLLEVBQUUsa0NBQWlDO0FBQzlELFFBQUksSUFBSSxHQUFHLENBQUMsU0FBUyxDQUFDO1FBQ2xCLE9BQU8sR0FBRyxTQUFTLENBQUMsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQztBQUM5QyxTQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUU7QUFDN0MsVUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztLQUN6Qjs7QUFFRCxRQUFJLEtBQUssR0FBRyxDQUFDLENBQUM7QUFDZCxRQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxJQUFJLElBQUksRUFBRTtBQUM5QixXQUFLLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUM7S0FDNUIsTUFBTSxJQUFJLE9BQU8sQ0FBQyxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLElBQUksSUFBSSxFQUFFO0FBQ3JELFdBQUssR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQztLQUM1QjtBQUNELFFBQUksQ0FBQyxDQUFDLENBQUMsR0FBRyxLQUFLLENBQUM7O0FBRWhCLFlBQVEsQ0FBQyxHQUFHLE1BQUEsQ0FBWixRQUFRLEVBQVMsSUFBSSxDQUFDLENBQUM7R0FDeEIsQ0FBQyxDQUFDO0NBQ0oiLCJmaWxlIjoibG9nLmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24oaW5zdGFuY2UpIHtcbiAgaW5zdGFuY2UucmVnaXN0ZXJIZWxwZXIoJ2xvZycsIGZ1bmN0aW9uKC8qIG1lc3NhZ2UsIG9wdGlvbnMgKi8pIHtcbiAgICBsZXQgYXJncyA9IFt1bmRlZmluZWRdLFxuICAgICAgICBvcHRpb25zID0gYXJndW1lbnRzW2FyZ3VtZW50cy5sZW5ndGggLSAxXTtcbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IGFyZ3VtZW50cy5sZW5ndGggLSAxOyBpKyspIHtcbiAgICAgIGFyZ3MucHVzaChhcmd1bWVudHNbaV0pO1xuICAgIH1cblxuICAgIGxldCBsZXZlbCA9IDE7XG4gICAgaWYgKG9wdGlvbnMuaGFzaC5sZXZlbCAhPSBudWxsKSB7XG4gICAgICBsZXZlbCA9IG9wdGlvbnMuaGFzaC5sZXZlbDtcbiAgICB9IGVsc2UgaWYgKG9wdGlvbnMuZGF0YSAmJiBvcHRpb25zLmRhdGEubGV2ZWwgIT0gbnVsbCkge1xuICAgICAgbGV2ZWwgPSBvcHRpb25zLmRhdGEubGV2ZWw7XG4gICAgfVxuICAgIGFyZ3NbMF0gPSBsZXZlbDtcblxuICAgIGluc3RhbmNlLmxvZyguLi4gYXJncyk7XG4gIH0pO1xufVxuIl19\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/helpers/log.js\n ** module id = 18\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\n\nexports['default'] = function (instance) {\n instance.registerHelper('lookup', function (obj, field) {\n return obj && obj[field];\n });\n};\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2hlbHBlcnMvbG9va3VwLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQWUsVUFBUyxRQUFRLEVBQUU7QUFDaEMsVUFBUSxDQUFDLGNBQWMsQ0FBQyxRQUFRLEVBQUUsVUFBUyxHQUFHLEVBQUUsS0FBSyxFQUFFO0FBQ3JELFdBQU8sR0FBRyxJQUFJLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztHQUMxQixDQUFDLENBQUM7Q0FDSiIsImZpbGUiOiJsb29rdXAuanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVmYXVsdCBmdW5jdGlvbihpbnN0YW5jZSkge1xuICBpbnN0YW5jZS5yZWdpc3RlckhlbHBlcignbG9va3VwJywgZnVuY3Rpb24ob2JqLCBmaWVsZCkge1xuICAgIHJldHVybiBvYmogJiYgb2JqW2ZpZWxkXTtcbiAgfSk7XG59XG4iXX0=\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/helpers/lookup.js\n ** module id = 19\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\n\nvar _utils = require('../utils');\n\nexports['default'] = function (instance) {\n instance.registerHelper('with', function (context, options) {\n if (_utils.isFunction(context)) {\n context = context.call(this);\n }\n\n var fn = options.fn;\n\n if (!_utils.isEmpty(context)) {\n var data = options.data;\n if (options.data && options.ids) {\n data = _utils.createFrame(options.data);\n data.contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]);\n }\n\n return fn(context, {\n data: data,\n blockParams: _utils.blockParams([context], [data && data.contextPath])\n });\n } else {\n return options.inverse(this);\n }\n });\n};\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;base64,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\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/helpers/with.js\n ** module id = 20\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\nexports.registerDefaultDecorators = registerDefaultDecorators;\n// istanbul ignore next\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _decoratorsInline = require('./decorators/inline');\n\nvar _decoratorsInline2 = _interopRequireDefault(_decoratorsInline);\n\nfunction registerDefaultDecorators(instance) {\n _decoratorsInline2['default'](instance);\n}\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2RlY29yYXRvcnMuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Z0NBQTJCLHFCQUFxQjs7OztBQUV6QyxTQUFTLHlCQUF5QixDQUFDLFFBQVEsRUFBRTtBQUNsRCxnQ0FBZSxRQUFRLENBQUMsQ0FBQztDQUMxQiIsImZpbGUiOiJkZWNvcmF0b3JzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHJlZ2lzdGVySW5saW5lIGZyb20gJy4vZGVjb3JhdG9ycy9pbmxpbmUnO1xuXG5leHBvcnQgZnVuY3Rpb24gcmVnaXN0ZXJEZWZhdWx0RGVjb3JhdG9ycyhpbnN0YW5jZSkge1xuICByZWdpc3RlcklubGluZShpbnN0YW5jZSk7XG59XG5cbiJdfQ==\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/decorators.js\n ** module id = 21\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\n\nvar _utils = require('../utils');\n\nexports['default'] = function (instance) {\n instance.registerDecorator('inline', function (fn, props, container, options) {\n var ret = fn;\n if (!props.partials) {\n props.partials = {};\n ret = function (context, options) {\n // Create a new partials stack frame prior to exec.\n var original = container.partials;\n container.partials = _utils.extend({}, original, props.partials);\n var ret = fn(context, options);\n container.partials = original;\n return ret;\n };\n }\n\n props.partials[options.args[0]] = options.fn;\n\n return ret;\n });\n};\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2RlY29yYXRvcnMvaW5saW5lLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQXFCLFVBQVU7O3FCQUVoQixVQUFTLFFBQVEsRUFBRTtBQUNoQyxVQUFRLENBQUMsaUJBQWlCLENBQUMsUUFBUSxFQUFFLFVBQVMsRUFBRSxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFO0FBQzNFLFFBQUksR0FBRyxHQUFHLEVBQUUsQ0FBQztBQUNiLFFBQUksQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFO0FBQ25CLFdBQUssQ0FBQyxRQUFRLEdBQUcsRUFBRSxDQUFDO0FBQ3BCLFNBQUcsR0FBRyxVQUFTLE9BQU8sRUFBRSxPQUFPLEVBQUU7O0FBRS9CLFlBQUksUUFBUSxHQUFHLFNBQVMsQ0FBQyxRQUFRLENBQUM7QUFDbEMsaUJBQVMsQ0FBQyxRQUFRLEdBQUcsY0FBTyxFQUFFLEVBQUUsUUFBUSxFQUFFLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQztBQUMxRCxZQUFJLEdBQUcsR0FBRyxFQUFFLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0FBQy9CLGlCQUFTLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztBQUM5QixlQUFPLEdBQUcsQ0FBQztPQUNaLENBQUM7S0FDSDs7QUFFRCxTQUFLLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxPQUFPLENBQUMsRUFBRSxDQUFDOztBQUU3QyxXQUFPLEdBQUcsQ0FBQztHQUNaLENBQUMsQ0FBQztDQUNKIiwiZmlsZSI6ImlubGluZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7ZXh0ZW5kfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uKGluc3RhbmNlKSB7XG4gIGluc3RhbmNlLnJlZ2lzdGVyRGVjb3JhdG9yKCdpbmxpbmUnLCBmdW5jdGlvbihmbiwgcHJvcHMsIGNvbnRhaW5lciwgb3B0aW9ucykge1xuICAgIGxldCByZXQgPSBmbjtcbiAgICBpZiAoIXByb3BzLnBhcnRpYWxzKSB7XG4gICAgICBwcm9wcy5wYXJ0aWFscyA9IHt9O1xuICAgICAgcmV0ID0gZnVuY3Rpb24oY29udGV4dCwgb3B0aW9ucykge1xuICAgICAgICAvLyBDcmVhdGUgYSBuZXcgcGFydGlhbHMgc3RhY2sgZnJhbWUgcHJpb3IgdG8gZXhlYy5cbiAgICAgICAgbGV0IG9yaWdpbmFsID0gY29udGFpbmVyLnBhcnRpYWxzO1xuICAgICAgICBjb250YWluZXIucGFydGlhbHMgPSBleHRlbmQoe30sIG9yaWdpbmFsLCBwcm9wcy5wYXJ0aWFscyk7XG4gICAgICAgIGxldCByZXQgPSBmbihjb250ZXh0LCBvcHRpb25zKTtcbiAgICAgICAgY29udGFpbmVyLnBhcnRpYWxzID0gb3JpZ2luYWw7XG4gICAgICAgIHJldHVybiByZXQ7XG4gICAgICB9O1xuICAgIH1cblxuICAgIHByb3BzLnBhcnRpYWxzW29wdGlvbnMuYXJnc1swXV0gPSBvcHRpb25zLmZuO1xuXG4gICAgcmV0dXJuIHJldDtcbiAgfSk7XG59XG4iXX0=\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/decorators/inline.js\n ** module id = 22\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\n\nvar _utils = require('./utils');\n\nvar logger = {\n methodMap: ['debug', 'info', 'warn', 'error'],\n level: 'info',\n\n // Maps a given level value to the `methodMap` indexes above.\n lookupLevel: function lookupLevel(level) {\n if (typeof level === 'string') {\n var levelMap = _utils.indexOf(logger.methodMap, level.toLowerCase());\n if (levelMap >= 0) {\n level = levelMap;\n } else {\n level = parseInt(level, 10);\n }\n }\n\n return level;\n },\n\n // Can be overridden in the host environment\n log: function log(level) {\n level = logger.lookupLevel(level);\n\n if (typeof console !== 'undefined' && logger.lookupLevel(logger.level) <= level) {\n var method = logger.methodMap[level];\n if (!console[method]) {\n // eslint-disable-line no-console\n method = 'log';\n }\n\n for (var _len = arguments.length, message = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n message[_key - 1] = arguments[_key];\n }\n\n console[method].apply(console, message); // eslint-disable-line no-console\n }\n }\n};\n\nexports['default'] = logger;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;base64,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\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/logger.js\n ** module id = 23\n ** module chunks = 0\n **/","// Build out our basic SafeString type\n'use strict';\n\nexports.__esModule = true;\nfunction SafeString(string) {\n this.string = string;\n}\n\nSafeString.prototype.toString = SafeString.prototype.toHTML = function () {\n return '' + this.string;\n};\n\nexports['default'] = SafeString;\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL3NhZmUtc3RyaW5nLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFDQSxTQUFTLFVBQVUsQ0FBQyxNQUFNLEVBQUU7QUFDMUIsTUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7Q0FDdEI7O0FBRUQsVUFBVSxDQUFDLFNBQVMsQ0FBQyxRQUFRLEdBQUcsVUFBVSxDQUFDLFNBQVMsQ0FBQyxNQUFNLEdBQUcsWUFBVztBQUN2RSxTQUFPLEVBQUUsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDO0NBQ3pCLENBQUM7O3FCQUVhLFVBQVUiLCJmaWxlIjoic2FmZS1zdHJpbmcuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBCdWlsZCBvdXQgb3VyIGJhc2ljIFNhZmVTdHJpbmcgdHlwZVxuZnVuY3Rpb24gU2FmZVN0cmluZyhzdHJpbmcpIHtcbiAgdGhpcy5zdHJpbmcgPSBzdHJpbmc7XG59XG5cblNhZmVTdHJpbmcucHJvdG90eXBlLnRvU3RyaW5nID0gU2FmZVN0cmluZy5wcm90b3R5cGUudG9IVE1MID0gZnVuY3Rpb24oKSB7XG4gIHJldHVybiAnJyArIHRoaXMuc3RyaW5nO1xufTtcblxuZXhwb3J0IGRlZmF1bHQgU2FmZVN0cmluZztcbiJdfQ==\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/safe-string.js\n ** module id = 24\n ** module chunks = 0\n **/","'use strict';\n\nexports.__esModule = true;\nexports.checkRevision = checkRevision;\nexports.template = template;\nexports.wrapProgram = wrapProgram;\nexports.resolvePartial = resolvePartial;\nexports.invokePartial = invokePartial;\nexports.noop = noop;\n// istanbul ignore next\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\n// istanbul ignore next\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }\n\nvar _utils = require('./utils');\n\nvar Utils = _interopRequireWildcard(_utils);\n\nvar _exception = require('./exception');\n\nvar _exception2 = _interopRequireDefault(_exception);\n\nvar _base = require('./base');\n\nfunction checkRevision(compilerInfo) {\n var compilerRevision = compilerInfo && compilerInfo[0] || 1,\n currentRevision = _base.COMPILER_REVISION;\n\n if (compilerRevision !== currentRevision) {\n if (compilerRevision < currentRevision) {\n var runtimeVersions = _base.REVISION_CHANGES[currentRevision],\n compilerVersions = _base.REVISION_CHANGES[compilerRevision];\n throw new _exception2['default']('Template was precompiled with an older version of Handlebars than the current runtime. ' + 'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').');\n } else {\n // Use the embedded version info since the runtime doesn't know about this revision yet\n throw new _exception2['default']('Template was precompiled with a newer version of Handlebars than the current runtime. ' + 'Please update your runtime to a newer version (' + compilerInfo[1] + ').');\n }\n }\n}\n\nfunction template(templateSpec, env) {\n /* istanbul ignore next */\n if (!env) {\n throw new _exception2['default']('No environment passed to template');\n }\n if (!templateSpec || !templateSpec.main) {\n throw new _exception2['default']('Unknown template object: ' + typeof templateSpec);\n }\n\n templateSpec.main.decorator = templateSpec.main_d;\n\n // Note: Using env.VM references rather than local var references throughout this section to allow\n // for external users to override these as psuedo-supported APIs.\n env.VM.checkRevision(templateSpec.compiler);\n\n function invokePartialWrapper(partial, context, options) {\n if (options.hash) {\n context = Utils.extend({}, context, options.hash);\n if (options.ids) {\n options.ids[0] = true;\n }\n }\n\n partial = env.VM.resolvePartial.call(this, partial, context, options);\n var result = env.VM.invokePartial.call(this, partial, context, options);\n\n if (result == null && env.compile) {\n options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);\n result = options.partials[options.name](context, options);\n }\n if (result != null) {\n if (options.indent) {\n var lines = result.split('\\n');\n for (var i = 0, l = lines.length; i < l; i++) {\n if (!lines[i] && i + 1 === l) {\n break;\n }\n\n lines[i] = options.indent + lines[i];\n }\n result = lines.join('\\n');\n }\n return result;\n } else {\n throw new _exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');\n }\n }\n\n // Just add water\n var container = {\n strict: function strict(obj, name) {\n if (!(name in obj)) {\n throw new _exception2['default']('\"' + name + '\" not defined in ' + obj);\n }\n return obj[name];\n },\n lookup: function lookup(depths, name) {\n var len = depths.length;\n for (var i = 0; i < len; i++) {\n if (depths[i] && depths[i][name] != null) {\n return depths[i][name];\n }\n }\n },\n lambda: function lambda(current, context) {\n return typeof current === 'function' ? current.call(context) : current;\n },\n\n escapeExpression: Utils.escapeExpression,\n invokePartial: invokePartialWrapper,\n\n fn: function fn(i) {\n var ret = templateSpec[i];\n ret.decorator = templateSpec[i + '_d'];\n return ret;\n },\n\n programs: [],\n program: function program(i, data, declaredBlockParams, blockParams, depths) {\n var programWrapper = this.programs[i],\n fn = this.fn(i);\n if (data || depths || blockParams || declaredBlockParams) {\n programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);\n } else if (!programWrapper) {\n programWrapper = this.programs[i] = wrapProgram(this, i, fn);\n }\n return programWrapper;\n },\n\n data: function data(value, depth) {\n while (value && depth--) {\n value = value._parent;\n }\n return value;\n },\n merge: function merge(param, common) {\n var obj = param || common;\n\n if (param && common && param !== common) {\n obj = Utils.extend({}, common, param);\n }\n\n return obj;\n },\n\n noop: env.VM.noop,\n compilerInfo: templateSpec.compiler\n };\n\n function ret(context) {\n var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\n var data = options.data;\n\n ret._setup(options);\n if (!options.partial && templateSpec.useData) {\n data = initData(context, data);\n }\n var depths = undefined,\n blockParams = templateSpec.useBlockParams ? [] : undefined;\n if (templateSpec.useDepths) {\n if (options.depths) {\n depths = context !== options.depths[0] ? [context].concat(options.depths) : options.depths;\n } else {\n depths = [context];\n }\n }\n\n function main(context /*, options*/) {\n return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths);\n }\n main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams);\n return main(context, options);\n }\n ret.isTop = true;\n\n ret._setup = function (options) {\n if (!options.partial) {\n container.helpers = container.merge(options.helpers, env.helpers);\n\n if (templateSpec.usePartial) {\n container.partials = container.merge(options.partials, env.partials);\n }\n if (templateSpec.usePartial || templateSpec.useDecorators) {\n container.decorators = container.merge(options.decorators, env.decorators);\n }\n } else {\n container.helpers = options.helpers;\n container.partials = options.partials;\n container.decorators = options.decorators;\n }\n };\n\n ret._child = function (i, data, blockParams, depths) {\n if (templateSpec.useBlockParams && !blockParams) {\n throw new _exception2['default']('must pass block params');\n }\n if (templateSpec.useDepths && !depths) {\n throw new _exception2['default']('must pass parent depths');\n }\n\n return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);\n };\n return ret;\n}\n\nfunction wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {\n function prog(context) {\n var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\n var currentDepths = depths;\n if (depths && context !== depths[0]) {\n currentDepths = [context].concat(depths);\n }\n\n return fn(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), currentDepths);\n }\n\n prog = executeDecorators(fn, prog, container, depths, data, blockParams);\n\n prog.program = i;\n prog.depth = depths ? depths.length : 0;\n prog.blockParams = declaredBlockParams || 0;\n return prog;\n}\n\nfunction resolvePartial(partial, context, options) {\n if (!partial) {\n if (options.name === '@partial-block') {\n partial = options.data['partial-block'];\n } else {\n partial = options.partials[options.name];\n }\n } else if (!partial.call && !options.name) {\n // This is a dynamic partial that returned a string\n options.name = partial;\n partial = options.partials[partial];\n }\n return partial;\n}\n\nfunction invokePartial(partial, context, options) {\n options.partial = true;\n if (options.ids) {\n options.data.contextPath = options.ids[0] || options.data.contextPath;\n }\n\n var partialBlock = undefined;\n if (options.fn && options.fn !== noop) {\n options.data = _base.createFrame(options.data);\n partialBlock = options.data['partial-block'] = options.fn;\n\n if (partialBlock.partials) {\n options.partials = Utils.extend({}, options.partials, partialBlock.partials);\n }\n }\n\n if (partial === undefined && partialBlock) {\n partial = partialBlock;\n }\n\n if (partial === undefined) {\n throw new _exception2['default']('The partial ' + options.name + ' could not be found');\n } else if (partial instanceof Function) {\n return partial(context, options);\n }\n}\n\nfunction noop() {\n return '';\n}\n\nfunction initData(context, data) {\n if (!data || !('root' in data)) {\n data = data ? _base.createFrame(data) : {};\n data.root = context;\n }\n return data;\n}\n\nfunction executeDecorators(fn, prog, container, depths, data, blockParams) {\n if (fn.decorator) {\n var props = {};\n prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths);\n Utils.extend(prog, props);\n }\n return prog;\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../lib/handlebars/runtime.js"],"names":[],"mappings":"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","file":"runtime.js","sourcesContent":["import * as Utils from './utils';\nimport Exception from './exception';\nimport { COMPILER_REVISION, REVISION_CHANGES, createFrame } from './base';\n\nexport function checkRevision(compilerInfo) {\n  const compilerRevision = compilerInfo && compilerInfo[0] || 1,\n        currentRevision = COMPILER_REVISION;\n\n  if (compilerRevision !== currentRevision) {\n    if (compilerRevision < currentRevision) {\n      const runtimeVersions = REVISION_CHANGES[currentRevision],\n            compilerVersions = REVISION_CHANGES[compilerRevision];\n      throw new Exception('Template was precompiled with an older version of Handlebars than the current runtime. ' +\n            'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').');\n    } else {\n      // Use the embedded version info since the runtime doesn't know about this revision yet\n      throw new Exception('Template was precompiled with a newer version of Handlebars than the current runtime. ' +\n            'Please update your runtime to a newer version (' + compilerInfo[1] + ').');\n    }\n  }\n}\n\nexport function template(templateSpec, env) {\n  /* istanbul ignore next */\n  if (!env) {\n    throw new Exception('No environment passed to template');\n  }\n  if (!templateSpec || !templateSpec.main) {\n    throw new Exception('Unknown template object: ' + typeof templateSpec);\n  }\n\n  templateSpec.main.decorator = templateSpec.main_d;\n\n  // Note: Using env.VM references rather than local var references throughout this section to allow\n  // for external users to override these as psuedo-supported APIs.\n  env.VM.checkRevision(templateSpec.compiler);\n\n  function invokePartialWrapper(partial, context, options) {\n    if (options.hash) {\n      context = Utils.extend({}, context, options.hash);\n      if (options.ids) {\n        options.ids[0] = true;\n      }\n    }\n\n    partial = env.VM.resolvePartial.call(this, partial, context, options);\n    let result = env.VM.invokePartial.call(this, partial, context, options);\n\n    if (result == null && env.compile) {\n      options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);\n      result = options.partials[options.name](context, options);\n    }\n    if (result != null) {\n      if (options.indent) {\n        let lines = result.split('\\n');\n        for (let i = 0, l = lines.length; i < l; i++) {\n          if (!lines[i] && i + 1 === l) {\n            break;\n          }\n\n          lines[i] = options.indent + lines[i];\n        }\n        result = lines.join('\\n');\n      }\n      return result;\n    } else {\n      throw new Exception('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');\n    }\n  }\n\n  // Just add water\n  let container = {\n    strict: function(obj, name) {\n      if (!(name in obj)) {\n        throw new Exception('\"' + name + '\" not defined in ' + obj);\n      }\n      return obj[name];\n    },\n    lookup: function(depths, name) {\n      const len = depths.length;\n      for (let i = 0; i < len; i++) {\n        if (depths[i] && depths[i][name] != null) {\n          return depths[i][name];\n        }\n      }\n    },\n    lambda: function(current, context) {\n      return typeof current === 'function' ? current.call(context) : current;\n    },\n\n    escapeExpression: Utils.escapeExpression,\n    invokePartial: invokePartialWrapper,\n\n    fn: function(i) {\n      let ret = templateSpec[i];\n      ret.decorator = templateSpec[i + '_d'];\n      return ret;\n    },\n\n    programs: [],\n    program: function(i, data, declaredBlockParams, blockParams, depths) {\n      let programWrapper = this.programs[i],\n          fn = this.fn(i);\n      if (data || depths || blockParams || declaredBlockParams) {\n        programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);\n      } else if (!programWrapper) {\n        programWrapper = this.programs[i] = wrapProgram(this, i, fn);\n      }\n      return programWrapper;\n    },\n\n    data: function(value, depth) {\n      while (value && depth--) {\n        value = value._parent;\n      }\n      return value;\n    },\n    merge: function(param, common) {\n      let obj = param || common;\n\n      if (param && common && (param !== common)) {\n        obj = Utils.extend({}, common, param);\n      }\n\n      return obj;\n    },\n\n    noop: env.VM.noop,\n    compilerInfo: templateSpec.compiler\n  };\n\n  function ret(context, options = {}) {\n    let data = options.data;\n\n    ret._setup(options);\n    if (!options.partial && templateSpec.useData) {\n      data = initData(context, data);\n    }\n    let depths,\n        blockParams = templateSpec.useBlockParams ? [] : undefined;\n    if (templateSpec.useDepths) {\n      if (options.depths) {\n        depths = context !== options.depths[0] ? [context].concat(options.depths) : options.depths;\n      } else {\n        depths = [context];\n      }\n    }\n\n    function main(context/*, options*/) {\n      return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths);\n    }\n    main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams);\n    return main(context, options);\n  }\n  ret.isTop = true;\n\n  ret._setup = function(options) {\n    if (!options.partial) {\n      container.helpers = container.merge(options.helpers, env.helpers);\n\n      if (templateSpec.usePartial) {\n        container.partials = container.merge(options.partials, env.partials);\n      }\n      if (templateSpec.usePartial || templateSpec.useDecorators) {\n        container.decorators = container.merge(options.decorators, env.decorators);\n      }\n    } else {\n      container.helpers = options.helpers;\n      container.partials = options.partials;\n      container.decorators = options.decorators;\n    }\n  };\n\n  ret._child = function(i, data, blockParams, depths) {\n    if (templateSpec.useBlockParams && !blockParams) {\n      throw new Exception('must pass block params');\n    }\n    if (templateSpec.useDepths && !depths) {\n      throw new Exception('must pass parent depths');\n    }\n\n    return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);\n  };\n  return ret;\n}\n\nexport function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {\n  function prog(context, options = {}) {\n    let currentDepths = depths;\n    if (depths && context !== depths[0]) {\n      currentDepths = [context].concat(depths);\n    }\n\n    return fn(container,\n        context,\n        container.helpers, container.partials,\n        options.data || data,\n        blockParams && [options.blockParams].concat(blockParams),\n        currentDepths);\n  }\n\n  prog = executeDecorators(fn, prog, container, depths, data, blockParams);\n\n  prog.program = i;\n  prog.depth = depths ? depths.length : 0;\n  prog.blockParams = declaredBlockParams || 0;\n  return prog;\n}\n\nexport function resolvePartial(partial, context, options) {\n  if (!partial) {\n    if (options.name === '@partial-block') {\n      partial = options.data['partial-block'];\n    } else {\n      partial = options.partials[options.name];\n    }\n  } else if (!partial.call && !options.name) {\n    // This is a dynamic partial that returned a string\n    options.name = partial;\n    partial = options.partials[partial];\n  }\n  return partial;\n}\n\nexport function invokePartial(partial, context, options) {\n  options.partial = true;\n  if (options.ids) {\n    options.data.contextPath = options.ids[0] || options.data.contextPath;\n  }\n\n  let partialBlock;\n  if (options.fn && options.fn !== noop) {\n    options.data = createFrame(options.data);\n    partialBlock = options.data['partial-block'] = options.fn;\n\n    if (partialBlock.partials) {\n      options.partials = Utils.extend({}, options.partials, partialBlock.partials);\n    }\n  }\n\n  if (partial === undefined && partialBlock) {\n    partial = partialBlock;\n  }\n\n  if (partial === undefined) {\n    throw new Exception('The partial ' + options.name + ' could not be found');\n  } else if (partial instanceof Function) {\n    return partial(context, options);\n  }\n}\n\nexport function noop() { return ''; }\n\nfunction initData(context, data) {\n  if (!data || !('root' in data)) {\n    data = data ? createFrame(data) : {};\n    data.root = context;\n  }\n  return data;\n}\n\nfunction executeDecorators(fn, prog, container, depths, data, blockParams) {\n  if (fn.decorator) {\n    let props = {};\n    prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths);\n    Utils.extend(prog, props);\n  }\n  return prog;\n}\n"]}\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/runtime.js\n ** module id = 25\n ** module chunks = 0\n **/","/* global window */\n'use strict';\n\nexports.__esModule = true;\n\nexports['default'] = function (Handlebars) {\n /* istanbul ignore next */\n var root = typeof global !== 'undefined' ? global : window,\n $Handlebars = root.Handlebars;\n /* istanbul ignore next */\n Handlebars.noConflict = function () {\n if (root.Handlebars === Handlebars) {\n root.Handlebars = $Handlebars;\n }\n return Handlebars;\n };\n};\n\nmodule.exports = exports['default'];\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL25vLWNvbmZsaWN0LmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O3FCQUNlLFVBQVMsVUFBVSxFQUFFOztBQUVsQyxNQUFJLElBQUksR0FBRyxPQUFPLE1BQU0sS0FBSyxXQUFXLEdBQUcsTUFBTSxHQUFHLE1BQU07TUFDdEQsV0FBVyxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUM7O0FBRWxDLFlBQVUsQ0FBQyxVQUFVLEdBQUcsWUFBVztBQUNqQyxRQUFJLElBQUksQ0FBQyxVQUFVLEtBQUssVUFBVSxFQUFFO0FBQ2xDLFVBQUksQ0FBQyxVQUFVLEdBQUcsV0FBVyxDQUFDO0tBQy9CO0FBQ0QsV0FBTyxVQUFVLENBQUM7R0FDbkIsQ0FBQztDQUNIIiwiZmlsZSI6Im5vLWNvbmZsaWN0LmpzIiwic291cmNlc0NvbnRlbnQiOlsiLyogZ2xvYmFsIHdpbmRvdyAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24oSGFuZGxlYmFycykge1xuICAvKiBpc3RhbmJ1bCBpZ25vcmUgbmV4dCAqL1xuICBsZXQgcm9vdCA9IHR5cGVvZiBnbG9iYWwgIT09ICd1bmRlZmluZWQnID8gZ2xvYmFsIDogd2luZG93LFxuICAgICAgJEhhbmRsZWJhcnMgPSByb290LkhhbmRsZWJhcnM7XG4gIC8qIGlzdGFuYnVsIGlnbm9yZSBuZXh0ICovXG4gIEhhbmRsZWJhcnMubm9Db25mbGljdCA9IGZ1bmN0aW9uKCkge1xuICAgIGlmIChyb290LkhhbmRsZWJhcnMgPT09IEhhbmRsZWJhcnMpIHtcbiAgICAgIHJvb3QuSGFuZGxlYmFycyA9ICRIYW5kbGViYXJzO1xuICAgIH1cbiAgICByZXR1cm4gSGFuZGxlYmFycztcbiAgfTtcbn1cbiJdfQ==\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/handlebars/dist/cjs/handlebars/no-conflict.js\n ** module id = 26\n ** module chunks = 0\n **/","'use strict';\r\n\r\nlet modalTemplate = require('../templates/modal-template.hbs');\r\n\r\nclass Modal {\r\n constructor(options) {\r\n this._placeholder = options.placeholder;\r\n this._options = options;\r\n this._content = '';\r\n }\r\n\r\n show() {\r\n //Lazy rendering\r\n if (!this._el) {\r\n this._render();\r\n }\r\n if (!this._el.parentNode) {\r\n this._placeholder.appendChild(this._el);\r\n }\r\n }\r\n\r\n hide() {\r\n this._placeholder.removeChild(this._el);\r\n }\r\n\r\n setContent(content) {\r\n this._content = content;\r\n }\r\n\r\n _render() {\r\n this._el = document.createElement('div');\r\n //Append generated HTML to wrapper\r\n this._el.innerHTML = modalTemplate({\r\n title: this._options.title,\r\n content: this._content\r\n });\r\n //Set delay for animation\r\n setTimeout(()=>{\r\n this._el.querySelector('.modal').classList.remove('js-modal-hidden');\r\n },20);\r\n this._el.addEventListener('click', this._onCloseClick.bind(this));\r\n this._el.addEventListener('contextmenu', this._onContextMenu.bind(this));\r\n\r\n return this._el;\r\n }\r\n\r\n _onCloseClick(event) {\r\n let closeBtn = event.target.closest('[data-action=\"close\"]');\r\n\r\n if (closeBtn) {\r\n this.hide();\r\n }\r\n }\r\n\r\n /**\r\n * Prevent context menu on modal\r\n */\r\n _onContextMenu(event) {\r\n event.preventDefault();\r\n }\r\n}\r\n\r\nmodule.exports = Modal;\n\n\n/** WEBPACK FOOTER **\n ** ./frontend/js/modal.js\n **/","var Handlebars = require(\"C:\\\\Users\\\\Vladimir\\\\Desktop\\\\JS-Course\\\\MineSweeper\\\\node_modules\\\\handlebars\\\\runtime.js\");\nfunction __default(obj) { return obj && (obj.__esModule ? obj[\"default\"] : obj); }\nmodule.exports = (Handlebars[\"default\"] || Handlebars).template({\"compiler\":[7,\">= 4.0.0\"],\"main\":function(container,depth0,helpers,partials,data) {\n var stack1, helper, alias1=depth0 != null ? depth0 : {}, alias2=helpers.helperMissing, alias3=\"function\";\n\n return \"
\\r\\n
\\r\\n

\"\n + container.escapeExpression(((helper = (helper = helpers.title || (depth0 != null ? depth0.title : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{\"name\":\"title\",\"hash\":{},\"data\":data}) : helper)))\n + \"

\\r\\n
\"\n + ((stack1 = ((helper = (helper = helpers.content || (depth0 != null ? depth0.content : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{\"name\":\"content\",\"hash\":{},\"data\":data}) : helper))) != null ? stack1 : \"\")\n + \"
\\r\\n
\\r\\n
\\r\\n
\";\n},\"useData\":true});\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./frontend/templates/modal-template.hbs\n ** module id = 28\n ** module chunks = 0\n **/","'use strict';\r\n\r\nlet resultsTemplate = require('../templates/results-template.hbs');\r\n/**\r\n * Object representing the storage interface\r\n */\r\nlet Results = (function() {\r\n let storageName = '_minesweeper_data_';\r\n\r\n /**\r\n * Get collected data for previous games from localStorage\r\n * @private\r\n */\r\n function _getFromStorage() {\r\n let results = window.localStorage.getItem(storageName);\r\n\r\n return results ? JSON.parse(results) : [];\r\n }\r\n\r\n /**\r\n * Save new result (seconds)\r\n * @param result\r\n */\r\n function _save(result) {\r\n let results = _getFromStorage();\r\n let resultToSave = {\r\n time: result,\r\n date: Date.now()\r\n };\r\n\r\n results.push(resultToSave);\r\n window.localStorage.setItem(storageName, JSON.stringify(results));\r\n }\r\n\r\n /**\r\n * Render current data from storage to simple table\r\n * @returns {string} table HTML\r\n */\r\n function _render() {\r\n let results = _getFromStorage();\r\n let totalResults = results.length;\r\n //Convert date from ms to local format\r\n results.forEach(function(result, i) {\r\n result.date = (new Date(result.date)).toLocaleDateString();\r\n if (i == totalResults -1) { //Mark result as current\r\n result.current = true;\r\n }\r\n });\r\n //Range results\r\n results.sort(function(a, b) {\r\n return a.time - b.time;\r\n });\r\n\r\n return resultsTemplate({\r\n results: results\r\n });\r\n }\r\n\r\n return {\r\n save: _save,\r\n render: _render\r\n }\r\n})();\r\n\r\nmodule.exports = Results;\r\n\n\n\n/** WEBPACK FOOTER **\n ** ./frontend/js/results.js\n **/","var Handlebars = require(\"C:\\\\Users\\\\Vladimir\\\\Desktop\\\\JS-Course\\\\MineSweeper\\\\node_modules\\\\handlebars\\\\runtime.js\");\nfunction __default(obj) { return obj && (obj.__esModule ? obj[\"default\"] : obj); }\nmodule.exports = (Handlebars[\"default\"] || Handlebars).template({\"1\":function(container,depth0,helpers,partials,data) {\n var stack1, alias1=depth0 != null ? depth0 : {}, alias2=container.escapeExpression, alias3=container.lambda;\n\n return \" \\r\\n \"\n + alias2(__default(require(\"C:\\\\Users\\\\Vladimir\\\\Desktop\\\\JS-Course\\\\MineSweeper/frontend/templates/helpers\\\\increment.js\")).call(alias1,(data && data.index),{\"name\":\"increment\",\"hash\":{},\"data\":data}))\n + \"\\r\\n \"\n + alias2(alias3((depth0 != null ? depth0.time : depth0), depth0))\n + \"\\r\\n \"\n + alias2(alias3((depth0 != null ? depth0.date : depth0), depth0))\n + \"\\r\\n \\r\\n\";\n},\"2\":function(container,depth0,helpers,partials,data) {\n return \"class=\\\"current\\\"\";\n},\"compiler\":[7,\">= 4.0.0\"],\"main\":function(container,depth0,helpers,partials,data) {\n var stack1;\n\n return \"
\\r\\n
\\r\\n \\r\\n \\r\\n \\r\\n \\r\\n \\r\\n \\r\\n \\r\\n \\r\\n \\r\\n\"\n + ((stack1 = helpers.each.call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.results : depth0),{\"name\":\"each\",\"hash\":{},\"fn\":container.program(1, data, 0),\"inverse\":container.noop,\"data\":data})) != null ? stack1 : \"\")\n + \" \\r\\n
\\r\\n
Rank
\\r\\n 		\\r\\n
Result (sec)
\\r\\n 		\\r\\n
Date
\\r\\n
\\r\\n
\\r\\n
\";\n},\"useData\":true});\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./frontend/templates/results-template.hbs\n ** module id = 30\n ** module chunks = 0\n **/","module.exports = function(value) {\r\n return value + 1;\r\n};\n\n\n/** WEBPACK FOOTER **\n ** ./frontend/templates/helpers/increment.js\n **/","'use strict';\r\n\r\nlet Dispatcher = require('./dispatcher');\r\n\r\nclass Timer extends Dispatcher {\r\n\r\n start() {\r\n this.startTime = Date.now();\r\n this.interval = setInterval(() => {\r\n this.update();\r\n }, 1000);\r\n this.update();\r\n }\r\n\r\n stop() {\r\n if (this.interval) {\r\n clearInterval(this.interval);\r\n }\r\n }\r\n\r\n reset() {\r\n this.stop();\r\n this.startTime = Date.now();\r\n this.update();\r\n }\r\n\r\n update() {\r\n this._current = Math.round((Date.now() - this.startTime) / 1000);\r\n this.dispatchEvent('timeUpdate', this._current);\r\n }\r\n\r\n getValue() {\r\n return this._current;\r\n }\r\n}\r\n\r\nmodule.exports = Timer\n\n\n/** WEBPACK FOOTER **\n ** ./frontend/js/timer.js\n **/","var Handlebars = require(\"C:\\\\Users\\\\Vladimir\\\\Desktop\\\\JS-Course\\\\MineSweeper\\\\node_modules\\\\handlebars\\\\runtime.js\");\nfunction __default(obj) { return obj && (obj.__esModule ? obj[\"default\"] : obj); }\nmodule.exports = (Handlebars[\"default\"] || Handlebars).template({\"1\":function(container,depth0,helpers,partials,data,blockParams,depths) {\n var stack1;\n\n return \" \\r\\n\"\n + ((stack1 = __default(require(\"C:\\\\Users\\\\Vladimir\\\\Desktop\\\\JS-Course\\\\MineSweeper/frontend/templates/helpers\\\\loop.js\")).call(depth0 != null ? depth0 : {},(depths[1] != null ? depths[1].columns : depths[1]),{\"name\":\"loop\",\"hash\":{},\"fn\":container.program(2, data, 0, blockParams, depths),\"inverse\":container.noop,\"data\":data})) != null ? stack1 : \"\")\n + \" \\r\\n\";\n},\"2\":function(container,depth0,helpers,partials,data) {\n return \" \\r\\n\";\n},\"compiler\":[7,\">= 4.0.0\"],\"main\":function(container,depth0,helpers,partials,data,blockParams,depths) {\n var stack1;\n\n return \"\\r\\n\"\n + ((stack1 = __default(require(\"C:\\\\Users\\\\Vladimir\\\\Desktop\\\\JS-Course\\\\MineSweeper/frontend/templates/helpers\\\\loop.js\")).call(depth0 != null ? depth0 : {},(depth0 != null ? depth0.rows : depth0),{\"name\":\"loop\",\"hash\":{},\"fn\":container.program(1, data, 0, blockParams, depths),\"inverse\":container.noop,\"data\":data})) != null ? stack1 : \"\")\n + \"
\";\n},\"useData\":true,\"useDepths\":true});\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./frontend/templates/field-template.hbs\n ** module id = 33\n ** module chunks = 0\n **/","module.exports = function(count, options) {\r\n var out = \"\";\r\n\r\n while (count--) {\r\n out+= options.fn();\r\n }\r\n return out;\r\n};\n\n\n/** WEBPACK FOOTER **\n ** ./frontend/templates/helpers/loop.js\n **/"],"sourceRoot":""} \ No newline at end of file diff --git a/public/index.html b/public/index.html new file mode 100644 index 0000000..9c530cb --- /dev/null +++ b/public/index.html @@ -0,0 +1,22 @@ + + + + + MineSweeper + + + + +
+
+
+ +
+
+ +
+ +
+
+ + \ No newline at end of file diff --git a/public/style/flag.png b/public/style/flag.png new file mode 100644 index 0000000..62c9042 Binary files /dev/null and b/public/style/flag.png differ diff --git a/public/style/mine.png b/public/style/mine.png new file mode 100644 index 0000000..26db299 Binary files /dev/null and b/public/style/mine.png differ diff --git a/public/style/style.css b/public/style/style.css new file mode 100644 index 0000000..65585e6 --- /dev/null +++ b/public/style/style.css @@ -0,0 +1,248 @@ +* { + box-sizing: border-box; +} + +html, body { + margin: 0; + padding: 0; + width: 100%; + + font: 14px Arial, Helvetica, sans-serif; + color: #333; +} +.wrapper { + display: block; + text-align: center; +} +.game-wrapper { + position: relative; + display: inline-block; + background: #2D95BF; + border: 3px solid #2D95BF; + text-align: left; +} + +.controls-wrapper { + position: relative; + padding: 10px; + color: #f8f8f8; + text-shadow: 0 -1px 1px rgba(0,0,0,0.4); +} + +.controls-wrapper::after { + display: table; + content: ''; + clear: both; +} +.controls-col { + display: inline-block; + vertical-align: middle; + width: 49%; +} + +.controls-col-right { + text-align: right; +} + +.controls-element { + position: relative; + margin: 0; + display: block; + padding-left: 90px; + line-height: 25px; +} +.control-name { + position: absolute; + width: 90px; + left: 0; + top: 0; + font-size: 12px; +} +.control-input { + width: 50px; + padding: 3px 5px; + background: #f8f8f8; + border: 1px solid #eee; +} + +.start-btn { + position: absolute; + left: 60%; + top: 50%; + padding: 5px 10px; + border-radius: 3px; + transform: translate(-50%,-50%); + background: #F15A5A; + color: #fff; + box-shadow: 1px 1px 1px rgba(0,0,0,0.5); + font-size: 20px; + font-weight: bold; + cursor: pointer; +} +/* Timer */ +.timer { + line-height: 24px; + font-size: 24px; +} +/* Game field styles */ +.field { + padding: 0; + margin: 0; + border-collapse: collapse; + font-weight: bold; +} + +.cell { + position: relative; + padding: 3px; + margin: 0; + width: 40px; + height: 40px; + background: #ccc center center no-repeat; + box-shadow: inset 0 0 1px 1px rgba(64,64,64,0.2); + text-align: center; + cursor: pointer; +} + +.cell::before { + position: absolute; + content: ' '; + top: 0; + left: 0; + width: 100%; + height: 100%; + box-sizing: border-box; + + border: 2px solid #eee; + border-right-color: #aaa; + border-bottom-color: #aaa; +} + +.cell:hover::before { + border-top-color: #aaa; + border-left-color: #aaa; + border-right-color: #eee; + border-bottom-color: #eee; +} + +.cell-marked { + background-image: url(flag.png); +} +.cell-mine { + background-image: url(mine.png); +} + +.cell-marked.cell-number, +.cell-marked.cell-empty { + vertical-align: bottom; + text-align: right; + background-color: #F15A5A; +} +.cell-marked.cell-mine { + background-color: #4EBA6F; +} + +.cell-number::before, +.cell-mine::before, +.cell-empty::before { + display: none; +} + +.cell-highlight::before { + background-color: #999; +} + +.cell-marked:hover::before { + border-top-color: #eee; + border-left-color: #eee; + border-right-color: #aaa; + border-bottom-color: #aaa; +} + +/* Modal */ +.modal-overlay { + position: absolute; + top: 0; + left: 0; + right: 0; + bottom: 0; + background: rgba(0,0,0,0.5); +} + +.modal-inner { + position: absolute; + width: 300px; + max-height: 200px; + padding: 10px; + left: 50%; + top: 50%; + margin-top: 0; + transform: translate(-50%, -50%); + border-radius: 5px; + background: #eee; + opacity: 1; + box-shadow: 0 0 3px 3px rgba(0,0,0,0.2); + transition: all .3s ease-out; +} + +.modal-title { + margin: 0; + font-size: 24px; + text-align: center; +} +.modal-content { + padding: 0; + margin: 0; +} +.modal-close { + position: absolute; + width: 20px; + height: 20px; + top: 5px; + right: 5px; + border-radius: 5px; + font-size: 20px; + line-height: 20px; + text-align: center; + background: #F15A5A; +} +.modal-close::before { + color: #fff; + content: '\00d7'; +} + +.js-modal-hidden .modal-inner { + margin-top: 10px; + opacity: 0; +} + +/* Fixed table */ +.fixed-container { + position: relative; + padding-top: 30px; + height: 150px; + width: 100%; + overflow: hidden; +} +.fixed-container-inner { + height: 100%; + overflow-x: hidden; + overflow-y: auto; +} +.table-fixed { + width: 100%; + border: none; +} +.th-fixed-inner { + position: absolute; + top: 0; + line-height: 30px; +} +.table-fixed tr.current { + background: #bbb; +} +.table-fixed td { + width: 30%; +} + + diff --git a/webpack.config.js b/webpack.config.js new file mode 100644 index 0000000..200dd33 --- /dev/null +++ b/webpack.config.js @@ -0,0 +1,29 @@ +module.exports = { + entry: './frontend/js/app', + output: { + path: __dirname + '/public', + filename: 'build.js', + publicPath: '/public/' + }, + + watch: true, + + devtool: 'source-map', + + module: { + loaders: [ + { + test: /\.js$/, + exclude: /node_modules/, + loader: 'babel', + query: { + presets: ['es2015'] + } + }, + { + test: /\.hbs/, + loader: 'handlebars?helperDirs[]=' + __dirname +'/frontend/templates/helpers' + } + ] + } +} \ No newline at end of file