set(config) {
     _.extend(this, DEFAULTS, config);
 }

 const decorator = function (Target: any, propertyKey: string, propertyIndex) {
     const handler = getHandler(Target, propertyKey);
     const bodyConfig = handler.bodyConfig || {};
     _.extend(bodyConfig, {index: propertyIndex, factory: factory});
 };

	/**
	 * Creates a new token.
	 *
	 * @see POST /v1/tokens
	 * @param {Context} ctx Koa context
	 */
	public async create(ctx: Context) {

		// default type is "personal".
		ctx.request.body.type = ctx.request.body.type || 'personal';

		// check if the plan allows application token creation
		if (scope.has(ctx.request.body.scopes, Scope.ALL) && !ctx.state.user.planConfig.enableAppTokens) {
			throw new ApiError('Your current plan "%s" does not allow the creation of application tokens. Upgrade or contact an admin.', ctx.state.user.planConfig.id).status(401);
		}

		// tokenType == "jwt" means the token comes from a "fresh" login (not a
		// refresh token) from either user/password or oauth2.
		if (ctx.state.tokenType === 'jwt') {

			// in this case, the user is allowed to create login tokens without
			// additionally supplying the password.
			if (!scope.has(ctx.request.body.scopes, Scope.LOGIN) && !ctx.request.body.password) {
				throw new ApiError('You cannot create other tokens but login tokens without supplying a password, ' +
					'even when logged with a "short term" token.').warn().status(401);
			}
		} else {

			// if the token type is not "jwt" (but "jwt-refreshed" or "access-token"),
			// the user must provide a password.
			if (!ctx.request.body.password) {
				throw new ApiError('When logged with a "long term" token (either from a X-Token-Refresh header or ' +
					'from an access token), you must provide your password.').warn().status(401);
			}
		}

		// in any case, if a password is supplied, check it.
		if (ctx.request.body.password) {

			if (!ctx.state.user.passwordSet()) {
				throw new ApiError('First set a password under your profile before adding tokens.').status(400);
			}
			if (!ctx.state.user.authenticate(ctx.request.body.password)) {
				throw new ApiError('Wrong password.').warn().status(401);
			}
		}

		// for provider tokens, check additional permissions.
		let newToken: TokenDocument;
		if (ctx.request.body.type === 'provider') {
			const granted = await acl.isAllowed(ctx.state.user.id, 'tokens', 'provider-token');
			if (!granted) {
				throw new ApiError('Permission denied.').status(401);
			}
			newToken = new state.models.Token(extend(ctx.request.body, {
				label: sanitize(ctx.request.body.label),
				is_active: true,
				created_at: new Date(),
				expires_at: new Date(new Date().getTime() + 315360000000), // 10 years
				_created_by: ctx.state.user._id,
			}));

		} else {
			newToken = new state.models.Token(extend(ctx.request.body, {
				label: ctx.request.body.label || ctx.get('user-agent'),
				is_active: true,
				created_at: new Date(),
				expires_at: new Date(new Date().getTime() + 31536000000), // 1 year
				_created_by: ctx.state.user._id,
			}));
		}
		await newToken.save();

		logger.info(ctx.state, '[TokenApi.create] Token "%s" successfully created.', newToken.label);
		this.success(ctx, state.serializers.Token.detailed(ctx, newToken), 201);
	}

 private convertAggregatorToQueryObject(aggregatorDefinition: Aggregator, defaultInterval: string) {
     const convertedAggregator =
         this.samplingParameterConverter.convertSamplingParameters(_.cloneDeep(aggregatorDefinition));
     return _.extend({name: convertedAggregator.name},
         this.convertParameters(convertedAggregator, defaultInterval));
 }

 // return a new polyhedron with the given vertices
 withVertices(vertices: VertexArg[]) {
   _.extend(this.solidData, { vertices: vertices.map(normalizeVertex) });
   return this;
 }

  this.show = function(options) {
    if (openDrop) {
      openDrop.close();
      openDrop = null;
    }

    var scope = _.extend($rootScope.$new(true), options.model);
    var drop;

    var cleanUp = () => {
      setTimeout(() => {
        scope.$destroy();

        if (drop.tether) {
          drop.destroy();
        }

        if (options.onClose) {
          options.onClose();
        }
      });

      openDrop = null;
    };

    scope.dismiss = () => {
      drop.close();
    };

    var contentElement = document.createElement('div');
    contentElement.innerHTML = options.template;

    $compile(contentElement)(scope);

    $timeout(() => {
      drop = new Drop({
        target: options.element,
        content: contentElement,
        position: options.position,
        classes: options.classNames || 'drop-popover',
        openOn: options.openOn,
        hoverCloseDelay: 200,
        tetherOptions: {
          constraints: [{ to: 'scrollParent', attachment: 'together' }],
        },
      });

      drop.on('close', () => {
        cleanUp();
      });

      openDrop = drop;
      openDrop.open();
    }, 100);

    // return close function
    return function() {
      if (drop) {
        drop.close();
      }
    };
  };

 _.each(this.preBootModules, module => {
   _.extend(module, this.registerFunctions);
 });

import * as nunjucks from 'nunjucks';
import * as path from 'path';
import * as _ from 'lodash';

declare var hexo: HexoStatic;

var nunjucksDefaults: NunjucksOptions = {
    autoescape: false,
    watch: false,
};

if (typeof hexo.config.nunjucks == 'undefined') {
    hexo.config.nunjucks = {};
}

_.extend(hexo.config.nunjucks, nunjucksDefaults);

var renderer: HexoSyncRenderer = function (data, locals) {
    
    var templateDir = path.dirname(data.path);
    var env = nunjucks.configure(templateDir, hexo.config.nunjucks);
    
    return env.renderString(data.text, locals);  
}

hexo.extend.renderer.register('nunjucks', 'html', renderer, true);
hexo.extend.renderer.register('j2', 'html', renderer, true);

      it('should create local prebuild', co(function *() {
        const fundingAddress = 't2CgWUKFKRaKzPXQF2cooNFtVZR1gTM8xxM';
        const fundingRedeemScript = '522103dc94182103c93690c2bca3fe013c19c956b940645b11b0a752e0e56b156bf4e22103b5f4aa0348bf339400ed7e16c6e960a4a46a1ea4c4cbe21abf6d0403161dc4f22103706ff6b11a8d9e3d63a455788d5d96738929ca642f1f3d8f9acedb689e759f3753ae';

        const receiveAddress = 't2HPJLxLLXLbKkfQngpwhZCGKAhHuqyqPk4';
        const unspent = {
          id: '8047839532dcfec617661120e1baa0e3b9135662ac8e1f97561e500d430dccb1:0',
          address: fundingAddress,
          value: 300000000,
          valueString: '300000000',
          blockHeight: 999999999,
          date: '2018-05-20T01:44:13.713Z'
        };
        const [txHash, vout] = unspent.id.split(':');

        const txb = new bitGoUtxoLib.TransactionBuilder(testCoin.network);
        txb.addInput(txHash, parseInt(vout, 16), 0xffffffff);
        txb.addOutput(receiveAddress, unspent.value - 50000);

        const tx = txb.buildIncomplete();
        tx.coin = coin.type;
        tx.overwintered = 1;
        tx.versionGroupId = 0x03C48270;

        const prebuild = {
          txHex: tx.toHex(),
          txInfo: {
            unspents: [
              {
                chain: 1,
                index: 113,
                redeemScript: fundingRedeemScript,
                value: 300000000
              }
            ]
          }
        };

        const wallet = new Wallet(bitgo, testCoin, {});
        const halfSigned = yield wallet.signTransaction({
          txPrebuild: prebuild,
          prv: keychains[0].prv
        });
        const halfSignedTx = bitGoUtxoLib.Transaction.fromHex(halfSigned.txHex, testCoin.network);
        halfSignedTx.network.coin.should.equal('zec');
        halfSignedTx.version.should.equal(bitGoUtxoLib.Transaction.ZCASH_SAPLING_VERSION);
        halfSignedTx.versionGroupId.should.equal(2301567109);
        halfSignedTx.overwintered.should.equal(1);
        halfSignedTx.expiryHeight.should.equal(0);
        halfSigned.txHex.should.equal('0400008085202f8901b1cc0d430d501e56971f8eac625613b9e3a0bae120116617c6fedc329583478000000000b600473044022034c624b44051fd6d3cf665b6117a614c683c918f9b6087d65d7043479bb60c3402205eef0d7032c98902c56a4337c4de7feba44704786fa9d4968af1699e1eede5b80100004c69522103dc94182103c93690c2bca3fe013c19c956b940645b11b0a752e0e56b156bf4e22103b5f4aa0348bf339400ed7e16c6e960a4a46a1ea4c4cbe21abf6d0403161dc4f22103706ff6b11a8d9e3d63a455788d5d96738929ca642f1f3d8f9acedb689e759f3753aeffffffff01b0dfe0110000000017a91476dce7beb23d0e0d53edf5895716d4c80dce60938700000000000000000000000000000000000000');

        const halfSignedPrebuild = _.extend({}, prebuild, halfSigned);
        const fullySigned = yield wallet.signTransaction({
          txPrebuild: halfSignedPrebuild,
          prv: keychains[2].prv,
          isLastSignature: true
        });
        const fullySignedTx = bitGoUtxoLib.Transaction.fromHex(fullySigned.txHex, testCoin.network);
        fullySignedTx.network.coin.should.equal('zec');
        fullySignedTx.version.should.equal(bitGoUtxoLib.Transaction.ZCASH_SAPLING_VERSION);
        fullySignedTx.versionGroupId.should.equal(2301567109);
        fullySignedTx.overwintered.should.equal(1);
        fullySignedTx.expiryHeight.should.equal(0);
        fullySignedTx.getId().should.equal('d16b14e8312661ca7570f587b102610c35e97e87c0668349ea216f9b0173864d');

        fullySigned.txHex.should.equal('0400008085202f8901b1cc0d430d501e56971f8eac625613b9e3a0bae120116617c6fedc329583478000000000fc00473044022034c624b44051fd6d3cf665b6117a614c683c918f9b6087d65d7043479bb60c3402205eef0d7032c98902c56a4337c4de7feba44704786fa9d4968af1699e1eede5b801473044022052df70f6e0e40082382cea9ce4f76347c436f92f56523ca9a2198a45de5145fa0220782f43b17d9013c9a611a027ab139f45c45a0f0e942525aa3e6e63796df1918f014c69522103dc94182103c93690c2bca3fe013c19c956b940645b11b0a752e0e56b156bf4e22103b5f4aa0348bf339400ed7e16c6e960a4a46a1ea4c4cbe21abf6d0403161dc4f22103706ff6b11a8d9e3d63a455788d5d96738929ca642f1f3d8f9acedb689e759f3753aeffffffff01b0dfe0110000000017a91476dce7beb23d0e0d53edf5895716d4c80dce60938700000000000000000000000000000000000000');
      }));

 return Bluebird.map(browser.binary, (binary: string) => {
   return checkOneBrowser(extend({}, browser, { binary }))
 })

 (res: any) => {
     const remotes = _.zipObject(_.map(res, "key"), _.map(res, "value"));
     _.extend(translations, remotes);
     resolve(translations);
 },

 .then(function() {
   return self.recreateAndSignTransaction(_.extend(params, extendParams));
 });

  _influxRequest(method: string, url: string, data: any, options?: any) {
    const currentUrl = this.urls.shift();
    this.urls.push(currentUrl);

    const params: any = {};

    if (this.username) {
      params.u = this.username;
      params.p = this.password;
    }

    if (options && options.database) {
      params.db = options.database;
    } else if (this.database) {
      params.db = this.database;
    }

    if (method === 'GET') {
      _.extend(params, data);
      data = null;
    }

    const req: any = {
      method: method,
      url: currentUrl + url,
      params: params,
      data: data,
      precision: 'ms',
      inspect: { type: 'influxdb' },
      paramSerializer: this.serializeParams,
    };

    req.headers = req.headers || {};
    if (this.basicAuth || this.withCredentials) {
      req.withCredentials = true;
    }
    if (this.basicAuth) {
      req.headers.Authorization = this.basicAuth;
    }

    return this.backendSrv.datasourceRequest(req).then(
      result => {
        return result.data;
      },
      err => {
        if (err.status !== 0 || err.status >= 300) {
          if (err.data && err.data.error) {
            throw {
              message: 'InfluxDB Error: ' + err.data.error,
              data: err.data,
              config: err.config,
            };
          } else {
            throw {
              message: 'Network Error: ' + err.statusText + '(' + err.status + ')',
              data: err.data,
              config: err.config,
            };
          }
        }
      }
    );
  }

	/**
	 * Creates a new backglass.
	 *
	 * @see POST /v1/backglasses
	 * @see POST /v1/games/:gameId/backglasses
	 * @param {Context} ctx Koa context
	 */
	public async create(ctx: Context) {

		const now = new Date();

		const backglass = await state.models.Backglass.getInstance(ctx.state, extend(ctx.request.body, {
			_created_by: ctx.state.user._id,
			created_at: now,
		}));

		if (isArray(backglass.versions)) {
			backglass.versions.forEach(version => {
				if (!version.released_at) {
					version.released_at = now;
				}
			});

			// if this comes from /games/:gameId/backglasses, we already have a game id.
			if (ctx.params.gameId) {
				const game = await state.models.Game.findOne({ id: sanitize(ctx.params.gameId) }).exec();
				if (!game) {
					throw new ApiError('No such game with ID "%s".', ctx.params.gameId).status(404);
				}
				backglass._game = game._id;
			}

			// check for available rom
			if (backglass.versions[0] && !backglass._game) {
				let backglassFile;
				const file = await state.models.File.findById(backglass.versions[0]._file).exec();
				if (file && file.metadata && file.metadata.gamename) {
					backglassFile = file;
					const rom = await state.models.Rom.findOne({ id: file.metadata.gamename }).exec();
					if (rom) {
						logger.info(ctx.state, '[ctrl|backglass] Linking backglass to same game %s as rom "%s".', rom._game, backglassFile.metadata.gamename);
						backglass._game = rom._game;
					}
				}
			}
		}
		await backglass.save();
		logger.info(ctx.state, '[BackglassApi.create] Backglass "%s" successfully created.', backglass.id);
		await backglass.activateFiles();

		const populatedBackglass = await state.models.Backglass.findById(backglass._id)
			.populate({ path: '_game' })
			.populate({ path: 'authors._user' })
			.populate({ path: 'versions._file' })
			.populate({ path: '_created_by' })
			.exec();

		// invalidate cache
		await apiCache.invalidateCreatedBackglass(ctx.state, populatedBackglass);

		// event log
		await LogEventUtil.log(ctx, 'create_backglass', true, {
			backglass: state.serializers.Backglass.detailed(ctx, populatedBackglass),
			game: state.serializers.Game.reduced(ctx, populatedBackglass._game as GameDocument),
		}, {
			backglass: populatedBackglass._id,
			game: populatedBackglass._game._id,
		});

		// return object
		this.success(ctx, state.serializers.Backglass.detailed(ctx, populatedBackglass), 201);

		this.noAwait(async () => {
			// send moderation mail
			if (populatedBackglass.moderation.is_approved) {
				await mailer.backglassAutoApproved(ctx.state, ctx.state.user, populatedBackglass);
			} else {
				await mailer.backglassSubmitted(ctx.state, ctx.state.user, populatedBackglass);
			}
		});
	}

export function addStyle(domElement, style) {
  assert(_.isElement(domElement), 'addStyle expects the first argument to be a DOM element');
  assert(_.isPlainObject(style), 'addStyle expects the second argument to be a hash');

  _.extend(domElement.style, style);
}

function render(url: string, imagePath: string, harPath: string, opts: any): Promise<number> {
    opts = _.extend(cliParser.defaultOpts, opts);

    var args: string[] = [];
    if (_.isString(opts.phantomArguments)) {
        args = opts.phantomArguments.split(' ');
    }

    if (!_.startsWith(url, 'http')) {
        url = 'http://' + url;
    }

    args = args.concat([
        path.join(__dirname, 'snap-sniff.js'),
        url,
        imagePath,
        harPath,
        opts.width,
        opts.height,
        opts.requestTimeout,
        opts.maxTimeout,
        opts.verbose,
        opts.fileType,
        opts.fileQuality,
        opts.cropWidth,
        opts.cropHeight,
        opts.cropOffsetLeft,
        opts.cropOffsetTop
    ]);

    let execOpts = {
        maxBuffer: Infinity
    };

    let killTimer: number;

    return new Promise<number>(function(resolve, reject) {
        let child: child_process.ChildProcess;
        try {
            child = child_process.spawn(phantomjs.path, args, {
                stdio: 'inherit'
            });
        } catch (err) {
            reject(err);
        }

        killTimer = setTimeout(function() {
            killPhantom(opts, child);
            reject(new Error('Browser process timeout'));
        }, opts.killTimeout);


        function errorHandler(err: any) {
            // Remove bound handlers after use
            child.removeListener('close', closeHandler);
            reject(err);
        }

        function closeHandler(exitCode: number) {
            child.removeListener('error', errorHandler);
            if (exitCode > 0) {
                if(exitCode === 10) {
                    reject(new Error(`Unable to load given url: ${url}`));
                } else {
                    reject(new Error(`Browser exited with error code ${exitCode}`));
                }
            } else {
                resolve(exitCode);
            }
        }

        child.once('error', errorHandler);
        child.once('close', closeHandler);
    }).then(function() {
        clearTimeout(killTimer);
        return 8; // TODO: FIXME
    }).catch(function(err) {
        console.log('Oops: ' + err);
        clearTimeout(killTimer);
    });
}

export function ComponentEventHandler(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    target['__eventHandlers'] = target['__eventHandlers'] ? _.extend([], target['__eventHandlers']) : [];
    target['__eventHandlers'].push(propertyKey);
}

 const results = _.map(targetList, targetStr => {
   return _.extend({ target: targetStr }, run(sourceStr, targetStr));
 });

 return this.backendSrv.post(`/api/dashboards/import`, installCmd).then(res => {
   this.$rootScope.appEvent('alert-success', ['Dashboard Imported', dash.title]);
   _.extend(dash, res);
 });

Dispatcher.prototype =  _.extend({}, Dispatcher.prototype, {

  /**
   * Register a Store's callback so that it may be invoked by an action.
   * @param {function} callback The callback to be registered.
   * @return {number} The index of the callback within the _callbacks array.
   */
  register: function(callback) {
    _callbacks.push(callback);
    return _callbacks.length - 1; // index
  },

  /**
   * dispatch
   * @param  {object} payload The data from the action.
   */
  dispatch: function(payload) {
    _callbacks.forEach(function(callback) {
      _addPromise(callback, payload);
    });
    Promise.all(_promises).then(_clearPromises);
  },

  /**
   * Allows a store to wait for the registered callbacks of other stores
   * to get invoked before its own does.
   * This function is not used by this TodoMVC example application, but
   * it is very useful in a larger, more complex application.
   *
   * Example usage where StoreB waits for StoreA:
   *
   *   const StoreA =  _.extend({}, EventEmitter.prototype, {
   *     // other methods omitted
   *
   *     dispatchIndex: Dispatcher.register(function(payload) {
   *       // switch statement with lots of cases
   *     })
   *   }
   *
   *   const StoreB =  _.extend({}, EventEmitter.prototype, {
   *     // other methods omitted
   *
   *     dispatchIndex: Dispatcher.register(function(payload) {
   *       switch(payload.action.actionType) {
   *
   *         case MyConstants.FOO_ACTION:
   *           Dispatcher.waitFor([StoreA.dispatchIndex], function() {
   *             // Do stuff only after StoreA's callback returns.
   *           });
   *       }
   *     })
   *   }
   *
   * It should be noted that if StoreB waits for StoreA, and StoreA waits for
   * StoreB, a circular dependency will occur, but no error will be thrown.
   * A more robust Dispatcher would issue a warning in this scenario.
   */
  waitFor: function(/*array*/ promiseIndexes, /*function*/ callback) {
    const selectedPromises = _promises.filter(function(/*object*/ _, /*number*/ j) {
      return promiseIndexes.indexOf(j) !== -1;
    });
    Promise.all(selectedPromises).then(callback);
  }

});