/**
 * @param {number[][]} grid
 * @return {number}
 */
const orangesRotting = function(grid) {
  // 保存上一次的图形
  let lastGridString = grid.toString()

  if (lastGridString.indexOf(1) === -1) {
    return 0
  }

  let count = 0
  const xLen = grid.length
  const yLen = grid[0].length

  // 找出坏橘子存下来
  let laterRottedOranges = []
  for (let i = 0; i < grid.length; i++) {
    for (let j = 0; j < grid[i].length; j++) {
      if (grid[i][j] === 2) {
        laterRottedOranges.push([i, j])
      }
    }
  }

  while (true) {
    const tempRottedOranges = laterRottedOranges.slice(0)
    // 存储新的被感染的坏橘子
    laterRottedOranges = []
    for (let i = 0; i < tempRottedOranges.length; i++) {
      let x = tempRottedOranges[i][0]
      let y = tempRottedOranges[i][1]
      if (x > 0 && grid[x - 1][y] === 1) {
        laterRottedOranges.push([x - 1, y])
        grid[x - 1][y] = 2
      }
      if (x < xLen - 1 && grid[x + 1][y] === 1) {
        laterRottedOranges.push([x + 1, y])
        grid[x + 1][y] = 2
      }
      if (y > 0 && grid[x][y - 1] === 1) {
        laterRottedOranges.push([x, y - 1])
        grid[x][y - 1] = 2
      }
      if (y < yLen - 1 && grid[x][y + 1] === 1) {
        laterRottedOranges.push([x, y + 1])
        grid[x][y + 1] = 2
      }
    }
    // 比较是否相等
    const gridString = grid.toString()
    if (gridString !== lastGridString) {
      count++
      lastGridString = gridString
    } else {
      break
    }
  }
  // 看还有没有=1的
  if (lastGridString.indexOf(1) > -1) {
    return -1
  }

  return count
}

class MyStack {
  constructor() {
    this.stackData = []
    this.stackMin = []
  }

  push(newNum) {
    this.stackData.push(newNum)

    if (!this.stackMin.length) {
      this.stackMin.push(newNum)
    } else if (newNum <= this.getMin()) {
      this.stackMin.push(newNum)
    }
  }

  pop() {
    if (!this.stackMin.length) {
      throw new Error('Your stack is empty.')
    }

    const value = this.stackData.pop()
    if (value === this.getMin()) {
      this.stackMin.pop()
    }
    return value
  }

  getMin() {
    if (!this.stackMin.length) {
      throw new Error('Your stack is empty.')
    }
    return this.stackMin[this.stackMin.length - 1]
  }
}

const Ajv = require('ajv')
const ajv = new Ajv({allErrors: true})

// 这就是JSON-Schema
const schema = {
  properties: {
    foo: { type: 'string' },
    bar: { type: 'number', 'maximum': 3 }
  }
}

const validate = ajv.compile(schema)

test({foo: 'abc', bar: 2})
test({foo: 2, bar: 4})

function test(data) {
  // 校验JSON数据是否符合schema的定义
  const valid = validate(data)
  if (valid) {
    // 为true，校验通过
    console.log('Valid!')
  } else {
    // 不通过，打印出错误原因
    console.log('Invalid: ' + ajv.errorsText(validate.errors))
  }
}

setTimeout(() => {
  // TODO 调用jsBridge提供的方法
}, 600)

let timer = setInterval(() => {
  // 判断方法是否存在
  if (typeof window.jsBridgeAction === 'function') {
    clearInterval(timer)
    // TODO 做该做的事
  }
}, 50)

const readyPromise = (variableName, {
  rate = 50,
  timeout = 1500
} = {}) => {
  if (typeof variableName !== 'string') {
    throw new Error('The first argument should be a string')
  }

  let rateTimer, overTimer

  const _GLOBAL = new Function('return this')()

  const _clearTimer = () => {
    clearInterval(rateTimer)
    clearTimeout(overTimer)
  }

  return new Promise((resolve, reject) => {
    if (_GLOBAL[variableName]) {
      resolve()
      return
    }

    rateTimer = setInterval(() => {
      if (_GLOBAL[variableName]) {
        _clearTimer()
        resolve()
      }
    }, rate)

    overTimer = setTimeout(() => {
      _clearTimer()
      reject(new Error('timeout'))
    }, timeout)
  })
}

readyPromise('jsBridgeAction').then(() => {
  // TODO
}).catch(e => {
  console.error(e)
})

if (global._babelPolyfill) {
  throw new Error("only one instance of babel-polyfill is allowed");
}
global._babelPolyfill = true;

import "core-js/shim";
import "regenerator-runtime/runtime";

// Should be removed in the next major release:

import "core-js/fn/regexp/escape";

const DEFINE_PROPERTY = "defineProperty";
function define(O, key, value) {
  O[key] || Object[DEFINE_PROPERTY](O, key, {
    writable:     true,
    configurable: true,
    value:        value
  });
}

define(String.prototype, "padLeft", "".padStart);
define(String.prototype, "padRight", "".padEnd);

// eslint-disable-next-line max-len
"pop,reverse,shift,keys,values,entries,indexOf,every,some,forEach,map,filter,find,findIndex,includes,join,slice,concat,push,splice,unshift,sort,lastIndexOf,reduce,reduceRight,copyWithin,fill".split(",").forEach(function(key) {
  [][key] && define(Array, key, Function.call.bind([][key]));
});

export default {
  // builtins: {
  //   ...
  // },
  methods: {
    Array: {
      // ...
      includes: "array/includes",
      // ...
    },
    // ...
  }
}

const moduleName = getRuntimeModuleName(state.opts);
path.replaceWith(
  this.addDefaultImport(
    `${moduleName}/core-js/${methods[prop.name]}`,
    `${obj.name}$${prop.name}`,
  ),
);

module.exports = { "default": require("core-js/library/fn/array/includes"), __esModule: true };

const a = [1, 3]
// 类方法
console.log(Array.includes(a, 1))
// 实例方法
console.log(a.includes(1))

"use strict";

var _includes = require("babel-runtime/core-js/array/includes");

var _includes2 = _interopRequireDefault(_includes);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var a = [1, 3];

console.log((0, _includes2.default)(a, 1));

console.log(a.includes(1));

setTimeout(function() {
  console.log(1)
}, 0)
new Promise(function(resolve) {
  console.log(2)
  resolve()
}).then(function() {
  console.log(3)
})
console.log(4)

// 输出结果是 2 4 3 1

const nextTick = function (fn) {
  let p = Promise.resolve()
  p.then(fn).catch(err => {
    console.error(err)
  })
}

// 测试一下
setTimeout(function () {
  console.log(1)
}, 0)
console.log(2)
nextTick(function() {console.log(3)})
console.log(4)

// 结果是 2 4 3 1

const nextTick = function (fn) {
  var counter = 1
  var observer = new MutationObserver(fn) // 创建监听对象，并传入回调函数
  var textNode = document.createTextNode(counter) // 创建一个文本接点
  observer.observe(textNode, {
    characterData: true // 监听文本接点的字符变化
  })
  counter = (counter + 1) % 2
  textNode.data = counter // 改变文本接点的字符数据
}

// 需要在浏览器环境下测试
setTimeout(function () {
  console.log(1)
}, 0)
console.log(2)
nextTick(function() {console.log(3)})
console.log(4)

// 结果是 2 4 3 1

const nextTick = (function () {
  const callbacks = []
  let pending = false

  function nextTickHandler () {
    pending = false // 取消pending
    const copies = callbacks.slice(0) // copy执行队列
    callbacks.length = 0 // 清空执行队列
    for (let i = 0; i < copies.length; i++) {
      copies[i]()
    }
  }

  let p = Promise.resolve()
  let timerFunc = () => {
    p.then(nextTickHandler).catch(err => { console.error(err) })
  }

  return function queueNextTick (cb, ctx) {
    callbacks.push(() => {
      if (cb) {
        try {
          cb.call(ctx)
        } catch (e) {
          console.warn(`error in nextTick: "${e.toString()}"`, ctx)
        }
      }
    })
    if (!pending) {
      pending = true
      timerFunc()
    }
  }
})()

var _data = Object.create(null) // 这是我们实现的缓存对象（捂脸）
_data['foo'] = 123
_data['bar'] = 'hello kitty'
_data['author'] = {name: '歪闹', blog: 'http://iwhynot.me'}

function Cache () {
  this.size = 0
  this._data = Object.create(null)
}

var p = Cache.prototype
p.put = function (key, value) {
  var entry = this.get(key, true)
  if (!entry) {
    this.size++
  }
  this._data[key] = {
    key: key,
    value: value
  }
}

p.get = function (key, returnEntry) {
  var entry = this._data[key]
  if (entry === undefined) return
  return returnEntry ? entry : entry.value
}

function Cache (limit) {
  this.size = 0
  this.limit = limit
  this._keys = [] // 保存存储的数据key值
  this._data = Object.create(null)
}

var p = Cache.prototype
p.put = function (key, value) {
  var removed
  var entry = this.get(key, true)
  if (!entry) {
    if (this.size === this.limit) {
      removed = this.shift()
    }
    this._keys.push(key)
    this.size++
  }
  this._data[key] = {
    key: key,
    value: value
  }

  return removed
}

p.shift = function () {
  var head
  var key = this._keys.shift()
  if (key !== undefined) {
    delete this._data[key]
    this.size--
  }
  return head
}

p.get = function (key, returnEntry) {
  var entry = this._data[key]
  if (entry === undefined) return
  return returnEntry ? entry : entry.value
}

function Cache (limit) {
  this.size = 0
  this.limit = limit
  this.head = this.tail = undefined
  this._data = Object.create(null)
}

var p = Cache.prototype

p.put = function (key, value) {
  var removed

  var entry = this.get(key, true)
  if (!entry) {
    if (this.size === this.limit) {
      removed = this.shift()
    }
    entry = {
      key: key
    }
    if (this.tail) {
      this.tail.newer = entry
      entry.older = this.tail
    } else {
      this.head = entry
    }
    this._data[key] = entry
    this.tail = entry
    this.size++
  }
  entry.value = value

  return removed
}

p.shift = function () {
  var entry = this.head
  if (entry) {
    this.head = entry.newer
    this.head.older = undefined
    entry.newer = entry.older = undefined
    this._data[entry.key] = undefined
    this.size--
  }
  return entry
}

p.get = function (key, returnEntry) {
  var entry = this._data[key]
  if (entry === undefined) return
  if (entry === this.tail) {
    return returnEntry ? entry : entry.value
  }

  if (entry.newer) {
    if (entry === this.head) {
      this.head = entry.newer
    }
    entry.newer.older = entry.older
  }
  if (entry.older) {
    entry.older.newer = entry.newer
  }
  entry.newer = undefined
  entry.older = this.tail
  if (this.tail) {
    this.tail.newer = entry
  }
  this.tail = entry
  return returnEntry ? entry : entry.value
}

var obj = {
  aa: 1,
  bb: {
    xx: 0,
    oo: null,
    yy: 2,
    zz: {
      ww: 6
    }
  }
}

var getObjectValue = function (o, exp) {
// todo
}

getObjectValue(obj, 'aa') // 1
getObjectValue(obj, 'bb.xx') // 0
getObjectValue(obj, 'bb.zz.ww') // 6
getObjectValue(obj, 'bb.oo') //null
getObjectValue(obj, 'bb.oo.bar') // undefined  当获取一个不存在的属性值时

var getObjectValue = (function (undefined) {
  return function (o, exp) {
    if (o == null || typeof exp !== 'string') return

    var parts = exp.trim().split('.')
    var len = parts.length
    for (var i = 0; i < len; i++) {
      if (o[parts[i]] !== undefined) {
        if (o[parts[i]] === null) {
          return i < len - 1 ? undefined : null
        }
        o = o[parts[i]]
      } else {
        return
      }
    }
    return o
  }
})()

"devDependencies": {
    "css-loader": "^0.23.1",
    "extract-text-webpack-plugin": "^1.0.1",
    "file-loader": "^0.8.5",
    "glob": "^7.0.0",
    "html-loader": "^0.4.3",
    "html-webpack-plugin": "^2.9.0",
    "jquery": "^1.12.0",
    "less": "^2.6.0",
    "less-loader": "^2.2.2",
    "style-loader": "^0.13.0",
    "url-loader": "^0.5.7",
    "webpack": "^1.12.13",
    "webpack-dev-server": "^1.14.1"
}

var path = require('path');
var glob = require('glob');
var webpack = require('webpack');
var ExtractTextPlugin = require('extract-text-webpack-plugin');
var HtmlWebpackPlugin = require('html-webpack-plugin');
var CommonsChunkPlugin = webpack.optimize.CommonsChunkPlugin;
var UglifyJsPlugin = webpack.optimize.UglifyJsPlugin;

const debug = process.env.NODE_ENV !== 'production';

var entries = getEntry('src/scripts/page/**/*.js', 'src/scripts/page/');
var chunks = Object.keys(entries);

var config = {
entry: entries,
output: {
path: path.join(__dirname, 'public'),
publicPath: '/static/',
filename: 'scripts/[name].js',
chunkFilename: 'scripts/[id].chunk.js'
},
module: {
loaders: [ //加载器
{
test: /\.css$/,
loader: ExtractTextPlugin.extract('style', 'css')
}, {
test: /\.less$/,
loader: ExtractTextPlugin.extract('css!less')
}, {
test: /\.html$/,
loader: "html"
}, {
test: /\.(woff|woff2|ttf|eot|svg)(\?v=[0-9]\.[0-9]\.[0-9])?$/,
loader: 'file-loader?name=fonts/[name].[ext]'
}, {
test: /\.(png|jpe?g|gif)$/,
loader: 'url-loader?limit=8192&name=imgs/[name]-[hash].[ext]'
}
]
},
plugins: [
new webpack.ProvidePlugin({ //加载jq
$: 'jquery'
}),
new CommonsChunkPlugin({
name: 'vendors', // 将公共模块提取，生成名为`vendors`的chunk
chunks: chunks,
minChunks: chunks.length // 提取所有entry共同依赖的模块
}),
new ExtractTextPlugin('styles/[name].css'), //单独使用link标签加载css并设置路径，相对于output配置中的publickPath
debug ? function() {} : new UglifyJsPlugin({ //压缩代码
compress: {
warnings: false
},
except: ['$super', '$', 'exports', 'require'] //排除关键字
}),
new webpack.HotModuleReplacementPlugin() //热加载
],
devServer: {
publicPath:'http://localhost:8080/static/',
proxy: {
"*": "http://localhost:54999"
},
inline: true,
hot: true
}
};


var pages = Object.keys(getEntry('src/views/**/*.html', 'src/views/'));
pages.forEach(function(pathname) {
var conf = {
filename: '../views/' + pathname + '.html', //生成的html存放路径，相对于path
template: 'src/views/' + pathname + '.html', //html模板路径
inject: false,//js插入的位置，true/'head'/'body'/false
minify: { //压缩HTML文件
removeComments: true, //移除HTML中的注释
collapseWhitespace: false //删除空白符与换行符
}
};
if (pathname in config.entry) {
conf.inject = 'body';
conf.chunks = ['vendors', pathname];
conf.hash = true;
}
config.plugins.push(new HtmlWebpackPlugin(conf));
});


module.exports = config;

function getEntry(globPath, pathDir) {
var files = glob.sync(globPath);
var entries = {},
entry, dirname, basename, pathname, extname;

for (var i = 0; i < files.length; i++) {
entry = files[i];
dirname = path.dirname(entry);
extname = path.extname(entry);
basename = path.basename(entry, extname);
pathname = path.join(dirname, basename);
pathname = pathDir ? pathname.replace(new RegExp('^' + pathDir), '') : pathname;
entries[pathname] = './' + entry;
}
return entries;
}

"devDependencies": {
"css-loader": "^0.23.1",
"extract-text-webpack-plugin": "^1.0.1",
"file-loader": "^0.8.5",
"html-loader": "^0.4.3",
"html-webpack-plugin": "^2.9.0",
"jquery": "^1.12.0",
"less": "^2.6.0",
"less-loader": "^2.2.2",
"style-loader": "^0.13.0",
"url-loader": "^0.5.7",
"webpack": "^1.12.13",
"webpack-dev-server": "^1.14.1"
}

//引入css
require("../../css/lib/reset.css");
require("../../css/common/global.css");
require("../../css/common/grid.css");
require("../../css/page/index.less");


$('.g-bd').append('<p class="text">这是由js生成的一句话。</p>');

//引入css
require("../../css/lib/reset.css");
require("../../css/common/global.css");
require("../../css/common/grid.css");
require("../../css/page/about.less");

$('#about').html('这是一个关于webpack构建工程的栗子');

//引入css
require("../../css/lib/reset.css");
require("../../css/common/global.css");
require("../../css/common/grid.css");
require("../../css/page/list.less");


var html = '';
for(var i=0;i<5;i++){
html += '<li>列表'+(i+1)+'</li>';
}

$('#list').html(html);

var path = require('path');
var webpack = require('webpack');
/*
extract-text-webpack-plugin插件，
有了它就可以将你的样式提取到单独的css文件里，
妈妈再也不用担心样式会被打包到js文件里了。
 */
var ExtractTextPlugin = require('extract-text-webpack-plugin');
/*
html-webpack-plugin插件，重中之重，webpack中生成HTML的插件，
具体可以去这里查看https://www.npmjs.com/package/html-webpack-plugin
 */
var HtmlWebpackPlugin = require('html-webpack-plugin');

module.exports = {
entry: { //配置入口文件，有几个写几个
index: './src/js/page/index.js',
list: './src/js/page/list.js',
about: './src/js/page/about.js',
},
output: { 
path: path.join(__dirname, 'dist'), //输出目录的配置，模板、样式、脚本、图片等资源的路径配置都相对于它
publicPath: '/dist/',//模板、样式、脚本、图片等资源对应的server上的路径
filename: 'js/[name].js',//每个页面对应的主js的生成配置
chunkFilename: 'js/[id].chunk.js'   //chunk生成的配置
},
module: {
loaders: [ //加载器，关于各个加载器的参数配置，可自行搜索之。
{
test: /\.css$/,
//配置css的抽取器、加载器。'-loader'可以省去
loader: ExtractTextPlugin.extract('style-loader', 'css-loader') 
}, {
test: /\.less$/,
//配置less的抽取器、加载器。中间!有必要解释一下，
//根据从右到左的顺序依次调用less、css加载器，前一个的输出是后一个的输入
//你也可以开发自己的loader哟。有关loader的写法可自行谷歌之。
loader: ExtractTextPlugin.extract('css!less')
}, {
//html模板加载器，可以处理引用的静态资源，默认配置参数attrs=img:src，处理图片的src引用的资源
//比如你配置，attrs=img:src img:data-src就可以一并处理data-src引用的资源了，就像下面这样
test: /\.html$/,
loader: "html?attrs=img:src img:data-src"
}, {
//文件加载器，处理文件静态资源
test: /\.(woff|woff2|ttf|eot|svg)(\?v=[0-9]\.[0-9]\.[0-9])?$/,
loader: 'file-loader?name=./fonts/[name].[ext]'
}, {
//图片加载器，雷同file-loader，更适合图片，可以将较小的图片转成base64，减少http请求
//如下配置，将小于8192byte的图片转成base64码
test: /\.(png|jpg|gif)$/,
loader: 'url-loader?limit=8192&name=./img/[hash].[ext]'
}
]
},
plugins: [
new webpack.ProvidePlugin({ //加载jq
$: 'jquery'
}),
new webpack.optimize.CommonsChunkPlugin({
name: 'vendors', // 将公共模块提取，生成名为`vendors`的chunk
chunks: ['index','list','about'], //提取哪些模块共有的部分
minChunks: 3 // 提取至少3个模块共有的部分
}),
new ExtractTextPlugin('css/[name].css'), //单独使用link标签加载css并设置路径，相对于output配置中的publickPath

//HtmlWebpackPlugin，模板生成相关的配置，每个对于一个页面的配置，有几个写几个
new HtmlWebpackPlugin({ //根据模板插入css/js等生成最终HTML
favicon: './src/img/favicon.ico', //favicon路径，通过webpack引入同时可以生成hash值
filename: './view/index.html', //生成的html存放路径，相对于path
template: './src/view/index.html', //html模板路径
inject: 'body', //js插入的位置，true/'head'/'body'/false
hash: true, //为静态资源生成hash值
chunks: ['vendors', 'index'],//需要引入的chunk，不配置就会引入所有页面的资源
minify: { //压缩HTML文件
removeComments: true, //移除HTML中的注释
collapseWhitespace: false //删除空白符与换行符
}
}),
new HtmlWebpackPlugin({ //根据模板插入css/js等生成最终HTML
favicon: './src/img/favicon.ico', //favicon路径，通过webpack引入同时可以生成hash值
filename: './view/list.html', //生成的html存放路径，相对于path
template: './src/view/list.html', //html模板路径
inject: true, //js插入的位置，true/'head'/'body'/false
hash: true, //为静态资源生成hash值
chunks: ['vendors', 'list'],//需要引入的chunk，不配置就会引入所有页面的资源
minify: { //压缩HTML文件
removeComments: true, //移除HTML中的注释
collapseWhitespace: false //删除空白符与换行符
}
}),
new HtmlWebpackPlugin({ //根据模板插入css/js等生成最终HTML
favicon: './src/img/favicon.ico', //favicon路径，通过webpack引入同时可以生成hash值
filename: './view/about.html', //生成的html存放路径，相对于path
template: './src/view/about.html', //html模板路径
inject: true, //js插入的位置，true/'head'/'body'/false
hash: true, //为静态资源生成hash值
chunks: ['vendors', 'about'],//需要引入的chunk，不配置就会引入所有页面的资源
minify: { //压缩HTML文件
removeComments: true, //移除HTML中的注释
collapseWhitespace: false //删除空白符与换行符
}
}),

new webpack.HotModuleReplacementPlugin() //热加载
],
//使用webpack-dev-server，提高开发效率
devServer: {
contentBase: './',
host: 'localhost',
port: 9090, //默认8080
inline: true, //可以监控js变化
hot: true, //热启动
}
};

var o = JSON.parse('{"a":1,"b":2}');
console.log(o);
//Object {a: 1, b: 2}

var text = '{"a":1,"_b":2,"t":1455591901242}';
var data = JSON.parse(text, function(name, value){
//移除掉所有属性名以下划线开头的属性
if(name[0] == '_') return;
//如果属性名是t，并且值为整数，则转换为Date
if(name == 't' && /^-?\d+$/.test(value))
return new Date(value);
//否则，原样返回
return value;
});

var s = JSON.stringify({a:1,b:2});
console.log(s);//{"a":1,"b":2}

Object.prototype.toJSON = function(){
return 'hehe';
}
var s = JSON.stringify({a:1,b:2});
console.log(s);//"hehe"

var o = {
a: 1,
b: 2,
t: /\d+/
};

//指定要序列化的字段
var text = JSON.stringify(o, ['a','b']);
console.log(text); //{"a":1,"b":2}

//指定replacer函数，使RegExp得以序列化
var text2 = JSON.stringify(o, function(key, value){
console.log(typeof value);
if(value.constructor === RegExp){

return value.toString();
}
return value;
});
console.log(text2); //{"a":1,"b":2,"t":"\\d+"}
//或使用toJSON实现同样的替换
RegExp.prototype.toJSON = function(){return this.toString();}

var t = JSON.stringify({a:1,b:2},null,4);
console.log(t);
//string
//{
//    "a": 1,
//    "b": 2
//}

function cloneObject(o){ 
return JSON.parse(JSON.stringify(o));
}