text
stringlengths 2
1.05M
|
|---|
function notFound(req, res, next) {
res.status(404);
const error = new Error(`🔍 - Not Found - ${req.originalUrl}`);
next(error);
}
/* eslint-disable no-unused-vars */
function errorHandler(err, req, res, next) {
/* eslint-enable no-unused-vars */
const statusCode = res.statusCode !== 200 ? res.statusCode : 500;
res.status(statusCode);
res.json({
message: err.message,
stack: process.env.NODE_ENV === 'production' ? '🥞' : err.stack,
error: err.errors,
});
}
module.exports = {
notFound,
errorHandler,
};
|
const trafficPoints = [{ "geometry": { "type": "Point", "coordinates": [106.63530472117604, 29.492206977571094] } }, { "geometry": { "type": "Point", "coordinates": [106.52269934244785, 29.58809593781511] } }, { "geometry": { "type": "Point", "coordinates": [106.43942554342905, 29.53975383774449] } }, { "geometry": { "type": "Point", "coordinates": [106.57297524216452, 29.518737307835487] } }, { "geometry": { "type": "Point", "coordinates": [106.51614332087844, 29.585594590840433] } }, { "geometry": { "type": "Point", "coordinates": [106.55029941925932, 29.58689018167771] } }, { "geometry": { "type": "Point", "coordinates": [106.48366801708396, 29.503062626877846] } }, { "geometry": { "type": "Point", "coordinates": [106.46590638367111, 29.516937278640835] } }, { "geometry": { "type": "Point", "coordinates": [106.53891601576233, 29.60745093405695] } }, { "geometry": { "type": "Point", "coordinates": [106.56270133840407, 29.567579892108352] } }, { "geometry": { "type": "Point", "coordinates": [106.63112327076672, 29.72071071817028] } }, { "geometry": { "type": "Point", "coordinates": [106.62138267635399, 29.70285584594539] } }, { "geometry": { "type": "Point", "coordinates": [106.56834729857965, 29.641338018934743] } }, { "geometry": { "type": "Point", "coordinates": [106.54001160372799, 29.56480501633349] } }, { "geometry": { "type": "Point", "coordinates": [106.64035361593135, 29.657656042446007] } }, { "geometry": { "type": "Point", "coordinates": [106.47418367206683, 29.564086020369373] } }, { "geometry": { "type": "Point", "coordinates": [106.55035076306181, 29.586892508436133] } }, { "geometry": { "type": "Point", "coordinates": [106.46500852179328, 29.556067235379857] } }, { "geometry": { "type": "Point", "coordinates": [106.49071127000185, 29.5840574384477] } }, { "geometry": { "type": "Point", "coordinates": [106.5215461901369, 29.571828791095985] } }, { "geometry": { "type": "Point", "coordinates": [106.45265181125045, 29.546842069000366] } }, { "geometry": { "type": "Point", "coordinates": [106.63192118674729, 29.735647370920393] } }, { "geometry": { "type": "Point", "coordinates": [106.5568187502709, 29.60509909563788] } }, { "geometry": { "type": "Point", "coordinates": [106.52938210390454, 29.591863620191884] } }, { "geometry": { "type": "Point", "coordinates": [106.5637278362639, 29.635678561836855] } }, { "geometry": { "type": "Point", "coordinates": [106.64460609216452, 29.76536815783548] } }, { "geometry": { "type": "Point", "coordinates": [106.52655310910603, 29.578202545419252] } }, { "geometry": { "type": "Point", "coordinates": [106.54746017439665, 29.623253490067622] } }, { "geometry": { "type": "Point", "coordinates": [106.55933441673028, 29.5507351203959] } }, { "geometry": { "type": "Point", "coordinates": [106.52850625235611, 29.58879227296282] } }, { "geometry": { "type": "Point", "coordinates": [106.61555931149077, 29.69145298333802] } }, { "geometry": { "type": "Point", "coordinates": [106.55422059106333, 29.628982656734284] } }, { "geometry": { "type": "Point", "coordinates": [106.55523032107894, 29.61698036301842] } }, { "geometry": { "type": "Point", "coordinates": [106.57197575050583, 29.588032270389153] } }, { "geometry": { "type": "Point", "coordinates": [106.54086408197728, 29.60059385065909] } }, { "geometry": { "type": "Point", "coordinates": [106.55117178452274, 29.452779869854798] } }, { "geometry": { "type": "Point", "coordinates": [106.53986734178852, 29.606115422899187] } }, { "geometry": { "type": "Point", "coordinates": [106.62698019526442, 29.708723301033636] } }, { "geometry": { "type": "Point", "coordinates": [106.63452164514084, 29.492532951989364] } }, { "geometry": { "type": "Point", "coordinates": [106.62278101786949, 29.495278458336635] } }, { "geometry": { "type": "Point", "coordinates": [106.54742662939867, 29.62372611830248] } }, { "geometry": { "type": "Point", "coordinates": [106.52472513038666, 29.583886442913897] } }, { "geometry": { "type": "Point", "coordinates": [106.5093518525488, 29.514057523970987] } }, { "geometry": { "type": "Point", "coordinates": [106.54427356420017, 29.55030620461596] } }, { "geometry": { "type": "Point", "coordinates": [106.56235425728407, 29.56567094594835] } }, { "geometry": { "type": "Point", "coordinates": [106.54090313216452, 29.60116519783548] } }, { "geometry": { "type": "Point", "coordinates": [106.61876811153634, 29.702054913078197] } }, { "geometry": { "type": "Point", "coordinates": [106.62714767439665, 29.70890974006762] } }, { "geometry": { "type": "Point", "coordinates": [106.63057987892726, 29.724447706065863] } }, { "geometry": { "type": "Point", "coordinates": [106.51514542899434, 29.55149747624859] } }, { "geometry": { "type": "Point", "coordinates": [106.59802371216452, 29.675285777835477] } }, { "geometry": { "type": "Point", "coordinates": [106.61569884147816, 29.691931781445483] } }, { "geometry": { "type": "Point", "coordinates": [106.53511012909806, 29.590919126392272] } }, { "geometry": { "type": "Point", "coordinates": [106.54128750949577, 29.601494552182174] } }, { "geometry": { "type": "Point", "coordinates": [106.54157607216452, 29.56133813783548] } }, { "geometry": { "type": "Point", "coordinates": [106.55199175975271, 29.586579990741857] } }, { "geometry": { "type": "Point", "coordinates": [106.52933869716497, 29.59203996007138] } }, { "geometry": { "type": "Point", "coordinates": [106.56693046995034, 29.526767670066214] } }, { "geometry": { "type": "Point", "coordinates": [106.54464926513586, 29.55045697933357] } }, { "geometry": { "type": "Point", "coordinates": [106.52616045056547, 29.56906363056547] } }, { "geometry": { "type": "Point", "coordinates": [106.50313182722951, 29.585739230918154] } }, { "geometry": { "type": "Point", "coordinates": [106.6239823488495, 29.705386075779266] } }, { "geometry": { "type": "Point", "coordinates": [106.5903366000432, 29.588667114521044] } }, { "geometry": { "type": "Point", "coordinates": [106.60484463393671, 29.680833952021096] } }, { "geometry": { "type": "Point", "coordinates": [106.56356880016074, 29.564648792667434] } }, { "geometry": { "type": "Point", "coordinates": [106.52276586953793, 29.58792530014897] } }, { "geometry": { "type": "Point", "coordinates": [106.47010913054945, 29.562699779935333] } }, { "geometry": { "type": "Point", "coordinates": [106.54230443511564, 29.554464920348003] } }, { "geometry": { "type": "Point", "coordinates": [106.5402570720275, 29.603681469341055] } }, { "geometry": { "type": "Point", "coordinates": [106.5489375, 29.62349307340095] } }, { "geometry": { "type": "Point", "coordinates": [106.5221665, 29.571993073400954] } }, { "geometry": { "type": "Point", "coordinates": [106.55629977122125, 29.630446591749077] } }, { "geometry": { "type": "Point", "coordinates": [106.5082752516216, 29.506486956561826] } }, { "geometry": { "type": "Point", "coordinates": [106.56263675680407, 29.56722469330835] } }, { "geometry": { "type": "Point", "coordinates": [106.59508754462765, 29.661137502525484] } }, { "geometry": { "type": "Point", "coordinates": [106.53530787027454, 29.590869691098156] } }, { "geometry": { "type": "Point", "coordinates": [106.51145960791213, 29.515181660164753] } }, { "geometry": { "type": "Point", "coordinates": [106.54338855716452, 29.555150622835487] } }, { "geometry": { "type": "Point", "coordinates": [106.51351741674415, 29.51904326119628] } }, { "geometry": { "type": "Point", "coordinates": [106.52271597498077, 29.588053276448203] } }, { "geometry": { "type": "Point", "coordinates": [106.56833583617966, 29.641353302134746] } }, { "geometry": { "type": "Point", "coordinates": [106.44751474966974, 29.563887550832234] } }, { "geometry": { "type": "Point", "coordinates": [106.56908982697662, 29.609602544576823] } }, { "geometry": { "type": "Point", "coordinates": [106.60341672216451, 29.546178787835476] } }, { "geometry": { "type": "Point", "coordinates": [106.55803174556547, 29.585192335565473] } }, { "geometry": { "type": "Point", "coordinates": [106.54086348384428, 29.559794359229514] } }, { "geometry": { "type": "Point", "coordinates": [106.4385952542591, 29.521574008338604] } }, { "geometry": { "type": "Point", "coordinates": [106.53943343021392, 29.607160251780776] } }, { "geometry": { "type": "Point", "coordinates": [106.5774776246061, 29.642763091090814] } }, { "geometry": { "type": "Point", "coordinates": [106.50770823565672, 29.522770114957822] } }, { "geometry": { "type": "Point", "coordinates": [106.52436253235742, 29.471019171910644] } }]
export default trafficPoints;
|
const state = {
config: {
mobile: false,
sidebar: true
},
authed: true,
menus: [{
name: '页面',
icon: 'edge',
children: [{
name: '测试页面1',
url: '/demo1'
}, {
name: '测试页面2',
url: '/demo2'
}]
}],
tabs: [{
name: '首页',
closable: false,
route: 'home'
}]
}
export default state
|
{"frequencies":[261.6255653006,274.70684356563,294.32876096318,305.22982618403,327.03195662575,343.38355445704,366.27579142084,392.4383479509,412.06026534844,436.04260883433,457.84473927605,490.54793493862,523.2511306012],"description":"Petr Parizek, 12-tone septimal tuning, 2002."}
|
export default {
menu: ["Introduction", "Recipes", "Components"],
codeSandbox: false,
themeConfig: {
showPlaygroundEditor: true,
},
}
|
// Download the Node helper library from twilio.com/docs/node/install
// These consts are your accountSid and authToken from https://www.twilio.com/console
// To set up environmental variables, see http://twil.io/secure
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const authToken = process.env.TWILIO_AUTH_TOKEN;
const client = require('twilio')(accountSid, authToken);
client.sip
.domains('SD32a3c49700934481addd5ce1659f04d2')
.ipAccessControlListMappings('AL95a47094615fe05b7c17e62a7877836c')
.remove()
.then(data => {
console.log('Sid AL95a47094615fe05b7c17e62a7877836c deleted successfully.');
})
.catch(err => {
console.log(err.status);
throw err.message;
});
|
var Gpio = require('onoff').Gpio;
var ip = require('ip');
var LED1 = new Gpio(23, 'out');
var LED2 = new Gpio(24, 'out');
var LED3 = new Gpio(25, 'out');
var stepPin = new Gpio(16, 'out');
var stepPin1 = new Gpio(3, 'out');
var stepPin2 = new Gpio(2, 'out');
var dirPin = new Gpio(20, 'out');
var EnPin = new Gpio(21, 'out');
var EnPin1 = new Gpio(4, 'out');
var EnPin2 = new Gpio(17, 'out');
var EnPin3 = new Gpio(27, 'out');
var Arriba = new Gpio(5, 'in', 'both');
var Abajo = new Gpio(6, 'in', 'both');
var FC0 = new Gpio(12, 'in', 'both');
var FC01 = new Gpio(22, 'in', 'both');
var FC02 = new Gpio(10, 'in', 'both');
var FC03 = new Gpio(9, 'in', 'both');
var FC1 = new Gpio(13, 'in', 'both');
var FC2 = new Gpio(19, 'in', 'both');
var FC3 = new Gpio(26, 'in', 'both');
var pulso;
var pulso1;
var pulso2;
var IO;
var nivel = 0;
function dpslog(req, res) {
console.log(req.query);
console.log("req init app");
res.status(200).send({
estado: "OK",
ip: ip.address()
});
}
function socketSend(io) {
IO = io;
}
function initAbajo() {
setArriba();
setTimeout(() => {
stop();
setTimeout(() => {
setAbajo();
}, 1000);
}, 3000);
}
var estados = {
FC0P: 0,
FC01P: 0,
FC02P: 0,
FC03P: 0,
FC1P: 0,
FC2P: 0,
FC3P: 0,
btnA: 0,
btnB: 0
}
function setAbajo() {
estados = {
FC0P: 0,
FC01P: 0,
FC02P: 0,
FC03P: 0,
FC1P: 1,
FC2P: 1,
FC3P: 1,
btnA: 1,
btnB: 1
}
dirPin.writeSync(1);
console.log('buscando Abajo');
IO.emit("messages", "buscando Abajo");
EnPin.writeSync(0);
EnPin1.writeSync(0);
EnPin2.writeSync(0);
EnPin3.writeSync(0);
pulso = setInterval(_ => stepPin.writeSync(stepPin.readSync() ^ 1), 1);
pulso1 = setInterval(_ => stepPin1.writeSync(stepPin1.readSync() ^ 1), 1);
pulso2 = setInterval(_ => stepPin2.writeSync(stepPin2.readSync() ^ 1), 1);
}
function setArriba() {
estados = {
FC0P: 1,
FC01P: 1,
FC02P: 1,
FC03P: 1,
FC1P: 1,
FC2P: 1,
FC3P: 1,
btnA: 1,
btnB: 1
}
if (nivel == 0) {
estados.FC1P = 0;
}
if (nivel == 1) {
estados.FC2P = 0;
}
if (nivel == 2) {
estados.FC3P = 0;
}
dirPin.writeSync(0);
console.log('buscando Arriba');
IO.emit("messages", "buscando Arriba");
EnPin.writeSync(0);
EnPin1.writeSync(0);
EnPin2.writeSync(0);
EnPin3.writeSync(0);
pulso = setInterval(_ => stepPin.writeSync(stepPin.readSync() ^ 1), 1);
pulso1 = setInterval(_ => stepPin1.writeSync(stepPin1.readSync() ^ 1), 1);
pulso2 = setInterval(_ => stepPin2.writeSync(stepPin2.readSync() ^ 1), 1);
}
function leds(led1, led2, led3) {
LED1.writeSync(led1);
LED2.writeSync(led2);
LED3.writeSync(led3);
}
function eventStopAll() {
if (estados.FC0P == 1 && estados.FC01P == 1 && estados.FC02P == 1 && estados.FC03P == 1) {
console.log('Paro todos los motores');
leds(0, 0, 0);
clearInterval(pulso);
clearInterval(pulso1);
clearInterval(pulso2);
EnPin.writeSync(0);
EnPin1.writeSync(0);
EnPin2.writeSync(0);
EnPin3.writeSync(0);
nivel = 0;
estados = {
FC0P: 1,
FC01P: 1,
FC02P: 1,
FC03P: 1,
FC1P: 1,
FC2P: 1,
FC3P: 1,
btnA: 0,
btnB: 1
}
}
}
function stop() {
clearInterval(pulso);
clearInterval(pulso1);
clearInterval(pulso2);
EnPin.writeSync(0);
EnPin1.writeSync(0);
EnPin2.writeSync(0);
EnPin3.writeSync(0);
estados = {
FC0P: 1,
FC01P: 1,
FC02P: 1,
FC03P: 1,
FC1P: 1,
FC2P: 1,
FC3P: 1,
btnA: 1,
btnB: 1
}
if (nivel == 3) {
estados.btnB = 0;
} else {
estados.btnA = 0;
estados.btnB = 0;
}
}
Arriba.watch(function (err, value) {
if (err) {
console.error('There was an error', err);
return;
}
if (value == 0 && estados.btnA == 0) {
setArriba();
}
});
Abajo.watch(function (err, value) {
if (err) {
console.error('There was an error', err);
return;
}
if (value == 0 && estados.btnB == 0) {
setAbajo();
}
});
FC1.watch(function (err, value) {
if (err) {
console.error('There was an error', err);
return;
}
if (value == 0 && estados.FC1P == 0) {
nivel = 1;
console.log('FC1');
IO.emit("messages", "nivel1");
stop();
leds(1, 0, 0);
}
});
FC2.watch(function (err, value) {
if (err) {
console.error('There was an error', err);
return;
}
if (value == 0 && estados.FC2P == 0) {
nivel = 2;
console.log('FC2');
IO.emit("messages", "nivel2");
stop();
leds(0, 1, 0);
}
});
FC3.watch(function (err, value) {
if (err) {
console.error('There was an error', err);
return;
}
if (value == 0 && estados.FC3P == 0) {
nivel = 3;
console.log('FC3');
IO.emit("messages", "nivel3");
stop();
leds(0, 1, 0);
}
});
FC0.watch(function (err, value) {
if (err) {
console.error('There was an error', err);
return;
}
if (value == 0 && estados.FC0P == 0) {
estados.FC0P = 1;
console.log('FC0');
console.log('stop motor1');
IO.emit("messages", "nivel0");
EnPin.writeSync(1);
eventStopAll();
}
});
FC01.watch(function (err, value) {
if (err) {
console.error('There was an error', err);
return;
}
if (value == 0 && estados.FC01P == 0) {
estados.FC01P = 1;
console.log('FC01');
console.log('stop motor2');
IO.emit("messages", "nivel0");
EnPin1.writeSync(1);
eventStopAll();
}
});
FC02.watch(function (err, value) {
if (err) {
console.error('There was an error', err);
return;
}
if (value == 0 && estados.FC02P == 0) {
estados.FC02P = 1;
console.log('FC02');
console.log('stop motor3');
IO.emit("messages", "nivel0");
EnPin2.writeSync(1);
eventStopAll();
}
});
FC03.watch(function (err, value) {
if (err) {
console.error('There was an error', err);
return;
}
if (value == 0 && estados.FC03P == 0) {
estados.FC03P = 1;
console.log('FC03');
console.log('stop motor4');
IO.emit("messages", "nivel0");
EnPin3.writeSync(1);
eventStopAll();
}
});
process.on('SIGINT', _ => {
LED1.unexport();
LED2.unexport();
LED3.unexport();
stepPin.unexport();
stepPin1.unexport();
stepPin2.unexport();
EnPin.unexport();
EnPin1.unexport();
EnPin2.unexport();
EnPin3.unexport();
dirPin.unexport();
FC0.unexport();
FC01.unexport();
FC02.unexport();
FC03.unexport();
FC1.unexport();
FC2.unexport();
FC3.unexport();
});
module.exports = {
dpslog,
socketSend,
initAbajo
}
|
const callSpy = require('./lib/callSpy');
describe('any.lessThanOrEqualTo', () => {
const shared = {};
beforeEach(() => {
shared.spy = callSpy(8);
shared.spy2 = callSpy(9);
});
it('should confirm', () => {
expect(shared.spy).toHaveBeenCalledWith(any.lessThanOrEqualTo(9));
expect(shared.spy2).toHaveBeenCalledWith(any.lessThanOrEqualTo(9));
});
});
|
(window.webpackJsonp=window.webpackJsonp||[]).push([[30],{433:function(t,n,e){"use strict";e.r(n);var o=e(44),s=Object(o.a)({},(function(){var t=this.$createElement,n=this._self._c||t;return n("ContentSlotsDistributor",{attrs:{"slot-key":this.$parent.slotKey}},[n("p",[this._v("Documentation coming soon.")])])}),[],!1,null,null,null);n.default=s.exports}}]);
|
'use strict';
module.exports = (req, res) => {
res.status(404).json({
status: 404,
message: 'Page Not Found',
});
};
|
const createError = require('http-errors');
const express = require('express');
const mongoose = require('mongoose');
const bobyParser = require('body-parser');
const cookieParser = require('cookie-parser')
const qrcode = require('qrcode');
const path = require('path');
let UserContoller = require('./User/UserController.js')
//const dotenv = require('dotenv');
//dotenv.config();
// import from models
const app = express();
let db = require('./Controller/db.js');
app.engine('pug', require('pug').__express)
app.set('view engine','pug');
app.set('views','./views');
app.use(bobyParser.json());
app.use(bobyParser.urlencoded({ extended: false }));
app.use(cookieParser());
// loading the Get page
/*
app.get('/',(req, res)=>{
User.find((err, data)=>{
if(err) {console.log(err);}
else{
if(data!=''){
let temp = [];
for(let i=0; i<data.length; i++){
let name = {data: data[i].name};
temp.push(name);
let phone = {data:data[i].phone};
temp.push(phone);
}
qrcode.toDataURL(temp, {errorCorrectionLevel: 'H'}, (err, url)=>{
console.log(url);
res.render('qrcode', {data:url});
})
}else{res.render('qrcode', {data:''});}
}
});
});
*/
// loading the post page
app.use('/', UserContoller);
// catch 404 and forward to error handler
app.use((req, res, next)=>{
next(createError(404));
});
// error handler
app.use((err, req, res, next)=>{
// set locals, only providing error in development
res.locals.message = err.message;
res.locals.error = req.app.get('env') === 'development' ? err : {};
// render the error page
res.status(err.status || 500);
res.render('error');
});
module.exports = app;
//Assign port
const PORT = process.env.PORT || 3000;
app.listen(PORT,()=>console.log(`Server is Starting on htpp://localhost:${PORT}`));
|
var utils = require("@/common/utils");
var _const = require("@/common/const");
var uikit = require("./uikit");
var apiHelper = require("./apis");
var channel = require("./channel");
var profile = require("@/app/tools/profile");
var eventListener = require("@/app/tools/eventListener");
var loading = require("./uikit/loading");
var getToHost = require("@/app/common/transfer");
var commonConfig = require("@/common/config");
var dom;
var starsUl;
var resolvedBtn;
var commentDom;
var tagContainer;
var dialog;
var starList;
var session;
var invite;
var score;
var evaluationDegreeId;
var isSingleTag;
var resolvedDom;
var resolveTip;
var resolvedId = 1;
var _initOnce = _.once(_init);
var evaluateType; // 评价方式
var sessionResolved;// 问题解决评价
var fiveStarState;//默认五星评价
var defaultScore;
var defaultEvaluationDegreeId;
module.exports = {
init: init,
show: show,
};
function _init(){
// 自定义主题色
var config = commonConfig.getConfig();
var themeName = config.ui.themeName;
if(themeName && themeName.indexOf("theme_custom") > -1){
var arr = themeName.split("theme_custom");
var color = arr[1];
}
loading.show("satisfaction");
//默认五星评价的开关
apiHelper.getDefaultFiveStarEnable()
.then(function(resp){
fiveStarState = resp;
});
apiHelper.getSatisfactionTipWord().then(function(tipWord){
dom = sessionResolved ? utils.createElementFromHTML([
"<div class=\"wrapper\">",
"<div class=\"resolveCon\"><span class=\"title\">" + resolveTip + "</span>",
"<div><span class=\"resolve-btn selected bg-color resolved\" data-num = \"1\"><i class=\"icon-resolved\"></i><span>" + __("evaluation.resolved") + "</span></span>",
"<span class=\"resolve-btn unresolved\" data-num = \"2\"><i class=\"icon-unresolved\"></i><span>" + __("evaluation.unsolved") + "</span></span></div></div>",
"<span class=\"title\">" + tipWord + "</span>",
"<ul></ul>",
"<div class=\"tag-container\"></div>",
"<textarea spellcheck=\"false\" placeholder=\"" + __("evaluation.review") + "\"></textarea>",
"</div>"
].join(""))
:
utils.createElementFromHTML([
"<div class=\"wrapper\">",
"<span class=\"title\">" + tipWord + "</span>",
"<ul></ul>",
"<div class=\"tag-container\"></div>",
"<textarea spellcheck=\"false\" placeholder=\"" + __("evaluation.review") + "\"></textarea>",
"</div>"
].join(""));
starsUl = dom.querySelector("ul");
commentDom = dom.querySelector("textarea");
tagContainer = dom.querySelector(".tag-container");
resolvedBtn = dom.querySelectorAll(".resolve-btn");
resolvedDom = dom.querySelector(".resolved");
utils.live(".resolve-btn", "click", function(){
utils.removeClass(resolvedBtn, "selected bg-color");
utils.addClass(this, "selected bg-color");
if(color){
$(".resolve-btn").css("cssText","background-color: #fff !important");
$(".theme_custom").find(".bg-color").css("cssText","background-color: " + color + " !important");
}
resolvedId = this.dataset.num;
if(fiveStarState){
if(resolvedId == 1){
utils.addClass(starList, "sel");
score = defaultScore;
evaluationDegreeId = defaultEvaluationDegreeId;
}
else{
utils.removeClass(starList, "sel");
score = false;
}
}
});
utils.live("li", "click", function(){
var level = +this.getAttribute("data-level");
evaluationDegreeId = this.getAttribute("data-evaluate-id");
score = this.getAttribute("data-score");
isSingleTag = this.getAttribute("data-isSingleTag");
level && _.each(starList, function(elem, i){
utils.toggleClass(elem, "sel", i < level);
});
evaluationDegreeId && _createLabel(evaluationDegreeId);
}, starsUl);
utils.live("span.tag", "click", function(){
var selectedTagNodeList = tagContainer.querySelectorAll(".selected");
if(isSingleTag == "true"){
utils.removeClass(selectedTagNodeList, "selected");
utils.toggleClass(this, "selected");
}
else{
utils.toggleClass(this, "selected");
}
}, tagContainer);
dialog = uikit.createDialog({
contentDom: dom,
className: "satisfaction"
}).addButton({
confirmText: __("common.submit"),
confirm: _confirm,
});
loading.hide("satisfaction");
dialog.show();
// 火狐浏览器 _setSatisfaction时找不到starsUl，所以必须先执行完init
_setSatisfaction();
// 自定义主题色
color && $(".theme_custom").find(".bg-color").css("cssText","background-color: " + color + " !important");
});
}
function _clear(){
commentDom.blur();
commentDom.value = "";
score = null;
// clear stars
utils.removeClass(starList, "sel");
// clear label
tagContainer.innerHTML = "";
// clear resolvedBtn
utils.removeClass(resolvedBtn, "selected bg-color");
utils.addClass(resolvedDom, "selected bg-color");
resolvedId = 1;
}
function _sendSatisfaction(score, content, session, invite, appraiseTags, resolutionParam, evaluationDegreeId){
var data = {
ext: {
weichat: {
ctrlType: "enquiry",
ctrlArgs: {
// 后端类型要求，inviteId必须传数字
inviteId: invite || 0,
serviceSessionId: session || profile.currentOfficialAccount.sessionId || "",
detail: content,
summary: score,
appraiseTags: appraiseTags,
resolutionParam: resolutionParam,
evaluationDegreeId: evaluationDegreeId,
// 评价方式，由前端传入：visitor - 访客主动评价; agent - 坐席邀请; system - 强制邀请,访客点击关闭窗口或会话结束
evaluateWay: evaluateType
}
}
}
};
if(!sessionResolved){
delete data.ext.weichat.ctrlArgs.resolutionParam;
}
channel.sendText("", data);
}
function _setSatisfaction(){
apiHelper.getEvaluationDegrees().then(function(entities){
var labelID;
var lastScore;
var lastEvaluationDegreeId;
starsUl.innerHTML = _.chain(entities)
.sortBy("level")
.map(function(elem, index){
// stat level 1-based
var level = index + 1;
var name = elem.name;
var id = elem.id;
var score = elem.score;
var isSingleTag = elem.isSingleTag;
labelID = id;
lastScore = score;
lastEvaluationDegreeId = id;
return "<li data-level=\"" + level
+ "\" title=\"" + name
+ "\" data-evaluate-id=\"" + id
+ "\" data-score=\"" + score
+ "\" data-isSingleTag=\"" + isSingleTag
+ "\">H</li>";
})
.value()
.join("");
starList = starsUl.querySelectorAll("li");
defaultScore = lastScore;
defaultEvaluationDegreeId = lastEvaluationDegreeId;
if(fiveStarState){
if(resolvedId == 1){
utils.addClass(starList, "sel");
//创建评价标签
_createLabel(labelID);
score = defaultScore;
evaluationDegreeId = defaultEvaluationDegreeId;
}
else{
utils.removeClass(starList, "sel");
score = false;
}
}
});
}
function _createLabel(evaluateId){
apiHelper.getAppraiseTags(evaluateId).then(function(entities){
tagContainer.innerHTML = _.map(entities, function(elem){
var name = elem.name;
var id = elem.id;
return "<span data-label-id = \"" + id + "\" class=\"tag\">" + name + "</span>";
}).join("");
utils.removeClass(tagContainer, "hide");
});
}
function _confirm(){
var selectedTagNodeList = tagContainer.querySelectorAll(".selected");
var tagNodeList = tagContainer.querySelectorAll(".tag");
var content = commentDom.value;
var appraiseTags = _.map(selectedTagNodeList, function(elem){
return {
id: elem.getAttribute("data-label-id"),
name: elem.innerText
};
});
var resolutionParam = [{
id: resolvedId,
name: resolvedId == 1 ? "已解决" : "未解决",
score: resolvedId,
resolutionParamTags: []
}];
// 必须选择星级
if(!score){
uikit.tip(__("evaluation.select_level_please"));
// 防止对话框关闭
return false;
}
// 若有标签则至少选择一个
else if(tagNodeList.length > 0 && selectedTagNodeList.length === 0){
uikit.tip(__("evaluation.select_tag_please"));
// 防止对话框关闭
return false;
}
// 判断评价是否超时
apiHelper.getEvaluateVerify(profile.currentOfficialAccount.sessionId)
.then(function(resp){
if(resp.status == "OK"){
_sendSatisfaction(score, content, session, invite, appraiseTags, resolutionParam, evaluationDegreeId);
uikit.showSuccess(__("evaluation.submit_success"));
getToHost.send({ event: _const.EVENTS.EVALUATIONSUBMIT });
// 强制评价点击确定关闭会话框
setTimeout(function(){
// 关闭会话
if(evaluateType === "system" && profile.grayList.visitorLeave){
// 取消轮询接口
eventListener.trigger(_const.SYSTEM_EVENT.CHAT_CLOSED);
profile.currentOfficialAccount.sessionId && apiHelper.closeChatDialog({ serviceSessionId: profile.currentOfficialAccount.sessionId });
getToHost.send({ event: _const.EVENTS.CLOSE });
}
}, 2000);
_clear();
}
else{
if(resp.errorCode == "WEBIM_338"){
uikit.tip(__("evaluation.WEBIM_338"));
}else{
uikit.tip(__("evaluation.WEBIM_OTHER"));
}
}
});
}
function show(inviteId, serviceSessionId, evaluateWay){
apiHelper.getEvaluteSolveWord().then(function(tip){
resolveTip = tip;
});
apiHelper.getServiceSessionResolved()
.then(function(resp){
sessionResolved = resp;
_initOnce();
});
session = serviceSessionId;
invite = inviteId;
evaluateType = evaluateWay;
_setDefaultScore();
dialog && dialog.show();
}
function _setDefaultScore(){
if(!starsUl){
return false;
}
_setSatisfaction();
}
function init(){
eventListener.add(
_const.SYSTEM_EVENT.SATISFACTION_EVALUATION_MESSAGE_RECEIVED,
function(officialAccount, inviteId, serviceSessionId){
if(officialAccount !== profile.currentOfficialAccount) return;
show(inviteId, serviceSessionId, "system");
}
);
}
|
import {createStore} from 'redux';
import reducer from './reducer'
const store = createStore(reducer);
export default store;
|
$(document).ready(function () {
// Getting jQuery references to the post body, title, form, and author select
// var bodyInput = $("#body");
var saveButton = $('#saveButton');
// Adding an event listener for when the form is submitted
$(saveButton).on('click', function(event){
event.preventDefault();
var titleInput = $('#title');
var descriptionInput = $('#description');
var urlInput = $('#link');
console.log(titleInput, descriptionInput, urlInput);
// Constructing a newPost object to hand to the database
var newPost = {
title: titleInput.val().trim(),
description: descriptionInput.val().trim(),
url: urlInput.val().trim()
}
// If we're updating a post run updatePost to update a post
// Otherwise run submitPost to create a whole new post
submitPost(newPost);
});
// Gets the part of the url that comes after the "?" (which we have if we're updating a post)
// A function for handling what happens when the form to create a new post is submitted
/*function handleButtonClick (event) {
event.preventDefault()
console.log(titleInput, descriptionInput, urlInput)
// Constructing a newPost object to hand to the database
var newPost = {
title: titleInput.val().trim(),
description: descriptionInput.val().trim(),
url: urlInput.val().trim()
}
// If we're updating a post run updatePost to update a post
// Otherwise run submitPost to create a whole new post
submitPost(newPost)
}*/
// Submits a new post and brings user to blog page upon completion
function submitPost (data) {
$.post('/api/data', data, function () {});
}
})
|
import install from '../install';
import component from './ScopedNotifications.vue';
export default install(component);
|
import React from 'react';
import { Link } from 'react-router-dom';
import { ChevronRight } from './ChevronRight';
export const StyledLinkRight = (props) => {
return (
<Link className="btn btn-block btn-primary mb-0 right-align-cell" to={props.to} >
{props.children} <ChevronRight/>
</Link>
);
}
|
/*
* OpenAPI Petstore
* This is a sample server Petstore server. For this sample, you can use the api key \"special-key\" to test the authorization filters
*
* OpenAPI spec version: 1.0.0
*
* NOTE: This class is auto generated by OpenAPI Generator.
* https://github.com/OpenAPITools/openapi-generator
*
* OpenAPI generator version: 4.3.0-SNAPSHOT
*/
import http from "k6/http";
import { group, check, sleep } from "k6";
const BASE_URL = "http://petstore.swagger.io/v2";
// Sleep duration between successive requests.
// You might want to edit the value of this variable or remove calls to the sleep function on the script.
const SLEEP_DURATION = 0.1;
// Global variables should be initialized.
let apiKey = "TODO_EDIT_THE_API_KEY";
export default function() {
group("/pet", () => {
let url = BASE_URL + `/pet`;
// Request No. 1
// TODO: edit the parameters of the request body.
let body = {"id": "long", "category": {"id": "long", "name": "string"}, "name": "string", "photoUrls": "list", "tags": [{"id": "long", "name": "string"}], "status": "string"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.put(url, body, params);
sleep(SLEEP_DURATION);
// Request No. 2
// TODO: edit the parameters of the request body.
body = {"id": "long", "category": {"id": "long", "name": "string"}, "name": "string", "photoUrls": "list", "tags": [{"id": "long", "name": "string"}], "status": "string"};
params = {headers: {"Content-Type": "application/json"}};
request = http.post(url, body, params);
sleep(SLEEP_DURATION);
});
group("/pet/findByStatus", () => {
let status = "TODO_EDIT_THE_STATUS";
let url = BASE_URL + `/pet/findByStatus?status=${status}`;
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/pet/findByTags", () => {
let tags = "TODO_EDIT_THE_TAGS";
let url = BASE_URL + `/pet/findByTags?tags=${tags}`;
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/pet/{petId}", () => {
let petId = "TODO_EDIT_THE_PETID";
let url = BASE_URL + `/pet/${petId}`;
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
// Request No. 2
// TODO: edit the parameters of the request body.
body = {"name": "string", "status": "string"};
params = {headers: {"Content-Type": "application/x-www-form-urlencoded"}};
request = http.post(url, body, params);
sleep(SLEEP_DURATION);
// Request No. 3
params = {headers: {"api_key": `${apiKey}`}};
request = http.delete(url, params);
sleep(SLEEP_DURATION);
});
group("/pet/{petId}/uploadImage", () => {
let petId = "TODO_EDIT_THE_PETID";
let url = BASE_URL + `/pet/${petId}/uploadImage`;
// Request No. 1
// TODO: edit the parameters of the request body.
let body = {"additionalMetadata": "string", "file": http.file(open("/path/to/file.bin", "b"), "test.bin")};
let params = {headers: {"Content-Type": "multipart/form-data", "Accept": "application/json"}};
let request = http.post(url, body, params);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/store/inventory", () => {
let url = BASE_URL + `/store/inventory`;
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/store/order", () => {
let url = BASE_URL + `/store/order`;
// Request No. 1
// TODO: edit the parameters of the request body.
let body = {"id": "long", "petId": "long", "quantity": "integer", "shipDate": "date", "status": "string", "complete": "boolean"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, body, params);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/store/order/{orderId}", () => {
let orderId = "TODO_EDIT_THE_ORDERID";
let url = BASE_URL + `/store/order/${orderId}`;
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
// Request No. 2
request = http.delete(url);
sleep(SLEEP_DURATION);
});
group("/user", () => {
let url = BASE_URL + `/user`;
// Request No. 1
// TODO: edit the parameters of the request body.
let body = {"id": "long", "username": "string", "firstName": "string", "lastName": "string", "email": "string", "password": "string", "phone": "string", "userStatus": "integer"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, body, params);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/user/createWithArray", () => {
let url = BASE_URL + `/user/createWithArray`;
// Request No. 1
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, params);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/user/createWithList", () => {
let url = BASE_URL + `/user/createWithList`;
// Request No. 1
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, params);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/user/login", () => {
let password = "TODO_EDIT_THE_PASSWORD";
let username = "TODO_EDIT_THE_USERNAME";
let url = BASE_URL + `/user/login?username=${username}&password=${password}`;
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/user/logout", () => {
let url = BASE_URL + `/user/logout`;
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/user/{username}", () => {
let username = "TODO_EDIT_THE_USERNAME";
let url = BASE_URL + `/user/${username}`;
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
// Request No. 2
// TODO: edit the parameters of the request body.
body = {"id": "long", "username": "string", "firstName": "string", "lastName": "string", "email": "string", "password": "string", "phone": "string", "userStatus": "integer"};
params = {headers: {"Content-Type": "application/json"}};
request = http.put(url, body, params);
sleep(SLEEP_DURATION);
// Request No. 3
request = http.delete(url);
sleep(SLEEP_DURATION);
});
}
|
const express = require('express');
const Romcal = require('romcal');
const { France_Fr } = require('@romcal/calendar.france');
/**
* Initialize the Express.js server.
* @type {*|Express}
*/
const app = express();
/**
* Wire an index HTML page to the URL root of this server.
*/
app.get('/', (req, res) => {
res.sendFile(`${__dirname}/public/index.html`);
});
/**
* Example that output data of the General Roman calendar, and all its defined locales.
* The year is optional (taking the current year by default).
*/
app.get('/romcal/general-roman/:locale/:year?', async (req, res) => {
const locale = req.params['locale'].toLowerCase();
const localeIndex = Romcal.LOCALE_KEYS.indexOf(locale);
// Check if the provided locale exists in the `general_roman` calendar. If no, return a 404 error.
if (localeIndex === -1) {
const code = 404;
return res.status(code).send({ code, message: "The provided locale doesn't exists" });
}
// Load dynamically the localized General Roman Calendar
const module = await require(`@romcal/calendar.general-roman/cjs/${locale}.js`);
const localeVarName = Romcal.LOCALE_VAR_NAMES[localeIndex];
const localizedCalendar = module[`GeneralRoman_${localeVarName}`];
// Initialize a romcal object with the General Roman Calendar data.
const romcalGeneralRoman = new Romcal({ localizedCalendar });
try {
// Generate a liturgical calendar with the provided locale and year.
const year = req.params['year'];
const data = await romcalGeneralRoman.generateCalendar(year);
// Finally, send the computed data.
res.json(data);
} catch (e) {
// If romcal return an error, we must manage and display it through Express.
const code = 500;
res.status(code).send({ code, message: e.message });
}
});
/**
* Simple example with only 1 supported calendar and locale by the REST API:
* the calendar of France and the `fr` locale.
*/
const romcalFranceFr = new Romcal({ localizedCalendar: France_Fr });
app.get('/romcal/france/fr/:year?', async (req, res) => {
const year = req.params['year'];
try {
const data = await romcalFranceFr.generateCalendar(year);
res.json(data);
} catch (e) {
// If romcal return an error, we must manage and display it through Express.
const code = 500;
res.status(code).send({ code, message: e.message });
}
});
/**
* Run the server.
*/
app.listen(3000, () => {
console.log('Romcal server listening on port 3000');
console.log('url: http://127.0.0.1:3000');
});
|
AmCharts.translations[ "export" ][ "pl" ] = {
"fallback.save.text": "Naciśnij CTRL + C by skopiować dane do schowka.",
"fallback.save.image": "Prawy przycisk myszy -> Zapisz obrazek jako... by zapisać obrazek.",
"capturing.delayed.menu.label": "{{duration}}",
"capturing.delayed.menu.title": "Kliknij by anulować",
"menu.label.print": "Drukuj",
"menu.label.undo": "Cofnij",
"menu.label.redo": "Przywróć",
"menu.label.cancel": "Anuluj",
"menu.label.save.image": "Pobierz jako ...",
"menu.label.save.data": "Zapisz jako ...",
"menu.label.draw": "Rysuj ...",
"menu.label.draw.change": "Zmień ...",
"menu.label.draw.add": "Dodaj ...",
"menu.label.draw.shapes": "Kształt ...",
"menu.label.draw.colors": "Kolor ...",
"menu.label.draw.widths": "Rozmiar ...",
"menu.label.draw.opacities": "Przeźroczystość ...",
"menu.label.draw.text": "Tekst",
"menu.label.draw.modes": "Tryb ...",
"menu.label.draw.modes.pencil": "Ołówek",
"menu.label.draw.modes.line": "Linia",
"menu.label.draw.modes.arrow": "Strzałka",
"label.saved.from": "Ocalić od: "
}
|
const { BotkitConversation } = require( 'botkit' );
module.exports = function( controller ) {
const convo = new BotkitConversation( 'color_chat', controller );
convo.say( 'This is a Botkit conversation sample.' );
convo.ask(
'What is your favorite Color?',
async( answer, convo, bot ) => {},
'stated_color'
);
convo.say( `Cool, I like {{ vars.stated_color }} too!` );
controller.addDialog( convo );
controller.hears( 'color', 'message,direct_message', async( bot, message ) => {
await bot.beginDialog( 'color_chat' );
});
controller.commandHelp.push( { command: 'color', text: 'Pick a favorite color, please (Botkit conversations)' } );
}
|
define([ 'config/namespaces' ], function ( namespaces ) {
'use strict';
return function ( descriptor, parentNode ) {
// if the element has an xmlns attribute, use that
if ( descriptor.a && descriptor.a.xmlns ) {
return descriptor.a.xmlns;
}
// otherwise, use the svg namespace if this is an svg element, or inherit namespace from parent
return ( descriptor.e === 'svg' ? namespaces.svg : parentNode.namespaceURI || namespaces.html );
};
});
|
var net = require('net');
var servers = {};
var defaultPort = 3002;
exports.start = function (port) {
port = port || defaultPort;
key = 'port' + port;
servers[key] = net.createServer(function (conn) {
console.log("Server: connected");
conn.on("data", function (data) {
if (data.length == 1 && data[0] == 0xef) {
console.log("Server: abridgedFlag detected");
} else {
console.log("Server: echo data of length %s:", data.length);
console.log(data);
conn.write(data);
}
})
});
servers[key].listen(port, function () {
console.log("TCP Server bound on port %s\n", port);
});
return port;
};
exports.shutdown = function (port) {
port = port || defaultPort;
key = 'port' + port;
servers[key].close();
console.log('TCP Server %s shutdown.', port);
};
|
// https://github.com/uxitten/polyfill/blob/master/string.polyfill.js
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart
if (!String.prototype.padStart) {
String.prototype.padStart = function padStart(targetLength,padString) {
targetLength = targetLength>>0; //truncate if number or convert non-number to 0;
padString = String((typeof padString !== 'undefined' ? padString : ' '));
if (this.length > targetLength) {
return String(this);
}
else {
targetLength = targetLength-this.length;
if (targetLength > padString.length) {
padString += padString.repeat(targetLength/padString.length); //append to original to ensure we are longer than needed
}
return padString.slice(0,targetLength) + String(this);
}
};
}
|
/* SVN FILE: $Id: jamal.js 18 2007-06-13 09:07:32Z teemow $ */
/**
* To quote Dave Cardwell:
* Built on the shoulders of giants:
* * John Resig - http://jquery.com/
*
* Jamal : Javascript MVC Assembly Layout <http://jamal-mvc.com/>
* Copyright (c) 2007, Timo Derstappen <http://teemow.com/>
*
* Licensed under The MIT License
* Redistributions of files must retain the above copyright notice.
*
* @filesource
* @copyright Copyright (c) 2007, Timo Derstappen
* @link
* @package jamal
* @subpackage jamal.modal
* @since Jamal v 0.4
* @version $Revision$
* @modifiedby $LastChangedBy$
* @lastmodified $Date$
* @license http://www.opensource.org/licenses/mit-license.php The MIT License
*/
/**
* Jamal modal component
*
* This component offers a modal dialog for jamal applications. eg. if your
* session timed out you can display a modal login form
*
* @public
* @name jamal
* @cat modal
*/
jamal.fn.extend({
/**
* Create a modal dialog
*
* @example jamal.modal('<h1>message</h1>');
*
* @private
* @name modal
* @type jamal
* @param String content Content that will be displayed in the modal window
* @cat modal
*/
modal: function(content) {
if (content) {
if (!jamal.modal.active) {
// deactivate screen
jQuery('body').css('overflow', 'hidden');
if (jQuery.browser.msie) {
jQuery('select').hide();
}
jQuery('#wrapper')
.prepend('<div id="jamal_overlay"></div>')
.prepend('<div id="jamal_modal"><div class="jamal_size">'+content+'</div></div>');
jQuery('#jamal_overlay')
.css({'background-color': '#000',
'position': 'absolute',
'width': '4000px',
'height': '4000px',
'float': 'left',
'margin-left': '-1500px',
'top': '0',
'left': '0',
'z-index': '80',
'filter': 'alpha(opacity=50)',
'-moz-opacity': '.50',
'opacity': '.50'});
jQuery('#jamal_size').css('position', 'relative');
jQuery('#jamal_modal')
.css({'position': 'absolute',
'background-color': '#fff',
'border': '4px solid #ccc',
'width': '380px',
'height': '305px',
'padding': '10px',
'z-index': '900'});
jamal.modal.active = true;
} else {
jQuery('div.jamal_size').html(content);
}
jamal.modal.resize();
return true;
} else {
return false;
}
}
});
jamal.fn.extend(jamal.fn.modal, {
/**
* Flag for modal dialog
*
* @public
* @property
* @name jamal.modal.active
* @type Boolean
* @cat modal
*/
active: false,
/**
* Resize the current modal dialog
*
* @example jamal.modal.resize();
*
* @private
* @name resize
* @type jamal
* @cat modal
*/
resize: function() {
// width
jQuery('#jamal_modal').css('width', jQuery('div.jamal_size').width()+'px');
var body = jQuery('#wrapper').width();
var modal = jQuery('#jamal_modal').width();
jQuery('#jamal_modal').css('margin-left', (body/2-modal/2)+'px');
// height
jQuery('#jamal_modal').css('height', jQuery('div.jamal_size').height()+'px');
if (jQuery.browser.msie) {
var offset = document.documentElement.scrollTop;
body = document.documentElement.clientHeight;
} else {
var offset = window.pageYOffset;
body = window.innerHeight;
}
modal = jQuery('#jamal_modal').height();
jQuery('#jamal_modal').css('margin-top', (offset + body/2 - modal/2) +'px');
},
/**
* Close the current dialog
*
* @example jamal.close();
*
* @private
* @name close
* @type jamal
* @cat modal
*/
close: function() {
if (jamal.modal.active) {
jQuery('#jamal_modal').fadeOut('slow');
jQuery('#jamal_overlay').remove();
jQuery('body').css('overflow', 'auto');
if (jQuery.browser.msie) {
jQuery('select').show();
}
jamal.modal.active = false;
}
}
});
|
/*
Copyright (c) 2003-2019, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
*/
CKEDITOR.plugins.setLang( 'image2', 'tr', {
alt: 'Alternatif Yazı',
btnUpload: 'Sunucuya Yolla',
captioned: 'Başlıklı resim',
captionPlaceholder: 'Başlık',
infoTab: 'Resim Bilgisi',
lockRatio: 'Oranı Kilitle',
menu: 'Resim Özellikleri',
pathName: 'Resim',
pathNameCaption: 'başlık',
resetSize: 'Boyutu Başa Döndür',
resizer: 'Boyutlandırmak için, tıklayın ve sürükleyin',
title: 'Resim Özellikleri',
uploadTab: 'Karşıya Yükle',
urlMissing: 'Resmin URL kaynağı bulunamadı.',
altMissing: 'Alternatif yazı eksik.'
} );
|
import { createState } from "stateUtils"
import {
selectSubject,
selectProperty,
selectValue,
selectFullSubject,
resourceHasChangesSinceLastSave,
selectResourceUriMap,
selectResourceGroup,
} from "selectors/resources"
describe("selectSubject()", () => {
it("returns null when no match", () => {
const state = createState()
expect(selectSubject(state, "abc123")).toBeNull()
})
it("returns subject", () => {
const state = createState({ hasResourceWithNestedResource: true })
expect(selectSubject(state, "ljAblGiBW")).toBeSubject("ljAblGiBW")
})
})
describe("selectProperty()", () => {
it("returns null when no match", () => {
const state = createState()
expect(selectProperty(state, "abc123")).toBeNull()
})
it("returns property", () => {
const state = createState({ hasResourceWithNestedResource: true })
expect(selectProperty(state, "v1o90QO1Qx")).toBeProperty("v1o90QO1Qx")
})
})
describe("selectValue()", () => {
it("returns null when no match", () => {
const state = createState()
expect(selectValue(state, "abc123")).toBeNull()
})
it("returns value", () => {
const state = createState({ hasResourceWithNestedResource: true })
const value = selectValue(state, "VDOeQCnFA8")
expect(value).toBeValue("VDOeQCnFA8")
})
it("adds langLabel to value", () => {
const state = createState({ hasResourceWithLiteral: true })
const value = selectValue(state, "CxGx7WMh2")
expect(value).toBeValue("CxGx7WMh2")
expect(value.langLabel).toEqual("English")
})
})
describe("selectFullSubject()", () => {
it("returns null when no match", () => {
const state = createState()
expect(selectFullSubject(state, "abc123")).toBeNull()
})
it("returns subject and all descendants", () => {
const state = createState({ hasResourceWithNestedResource: true })
const subject = selectFullSubject(state, "ljAblGiBW")
expect(subject).toBeSubject("ljAblGiBW")
expect(subject.properties).toHaveLength(1)
const property = subject.properties[0]
expect(property).toBeProperty("v1o90QO1Qx")
expect(property.values).toHaveLength(1)
const value = property.values[0]
expect(value).toBeValue("VDOeQCnFA8")
const nestedSubject = value.valueSubject
expect(nestedSubject).toBeSubject("XPb8jaPWo")
expect(nestedSubject.properties).toHaveLength(1)
const nestedProperty = nestedSubject.properties[0]
expect(nestedProperty).toBeProperty("7caLbfwwle")
expect(nestedProperty.values).toHaveLength(1)
const nestedValue = nestedProperty.values[0]
expect(nestedValue).toBeValue("pRJ0lO_mT-")
})
})
describe("resourceHasChangesSinceLastSave", () => {
it("returns changed for currentResource if key not provided", () => {
const state = createState({ hasResourceWithNestedResource: true })
state.entities.subjects.ljAblGiBW.changed = true
expect(resourceHasChangesSinceLastSave(state)).toBe(true)
})
it("returns changed for provided resource", () => {
const state = createState({ hasResourceWithNestedResource: true })
state.entities.subjects.ljAblGiBW.changed = true
expect(resourceHasChangesSinceLastSave(state, "ljAblGiBW")).toBe(true)
})
})
describe("selectResourceUriMap", () => {
it("returns map of URIs to keys", () => {
const state = createState({ hasTwoLiteralResources: true })
state.entities.subjects.t9zVwg2zO.uri =
"http://localhost:3000/resource/f383bfff-5364-47a3-a081-8c9e2d79f43f"
state.entities.subjects.u0aWxh3a1.uri =
"http://localhost:3000/resource/g493bfff-5364-47a3-a081-8c9e2d79f5fg"
expect(selectResourceUriMap(state)).toEqual({
"http://localhost:3000/resource/f383bfff-5364-47a3-a081-8c9e2d79f43f":
"t9zVwg2zO",
"http://localhost:3000/resource/g493bfff-5364-47a3-a081-8c9e2d79f5fg":
"u0aWxh3a1",
})
})
})
describe("selectResourceGroup", () => {
it("returns groups", () => {
const state = createState({ hasResourceWithNestedResource: true })
expect(selectResourceGroup(state, "ljAblGiBW")).toEqual({
group: "stanford",
editGroups: ["cornell"],
})
})
})
|
var rsvp = require('rsvp');
var fs = require('fs-extra');
var path = require('path');
var cheerio = require('cheerio');
var markdown = require('markdown-it')('commonmark').enable('table');;
var moment = require('moment');
var childProcess = require("child_process");
var schemaValidator = require("z-schema");
var chalk = require('chalk');
var spawnArgs = require('spawn-args');
var cliSpinner = require('cli-spinner').Spinner;
var imageSizeOf = require('image-size');
//Allow CommonMark links that use other protocols, such as file:///
//The markdown-it implementation is more restrictive than the CommonMark spec
//See https://github.com/markdown-it/markdown-it/issues/108
markdown.validateLink = function () { return true; }
/**
* DocGen class
*/
function DocGen (process)
{
var mainProcess = process;
var version = '2.1.3';
var wkhtmltopdfVersion = 'wkhtmltopdf 0.12.2.1 (with patched qt)'; //output from wkhtmltopdf -V
var options;
var templates = {};
var meta = {};
var pages = {};
var sortedPages = {};
this.getVersion = function () {
return version;
}
this.setOptions = function (userOptions) {
options = userOptions;
//all user-specified paths must be normalized
if (options.input) {
options.input = path.normalize(options.input+'/');
}
if (options.output) {
options.output = path.normalize(options.output+'/');
}
//wkhtmltopdf path does not need a trailing slash
if (options.wkhtmltopdfPath && options.wkhtmltopdfPath !== '') {
options.wkhtmltopdfPath = path.normalize(options.wkhtmltopdfPath);
}
}
/*
copy the example source files (template) to any directory, when scaffold command is invoked
*/
this.scaffold = function () {
console.log(chalk.green('Creating scaffold template directory'));
copyDirSync(__dirname+'/example', options.output);
}
this.run = function () {
console.log(chalk.green.bold('DocGen version '+version));
//delete and recreate the output directory
remakeDirSync(options.output);
loadTemplates();
}
/*
read any file (async)
*/
var readFile = function (path) {
return new rsvp.Promise(function (resolve, reject) {
fs.readFile (path, 'utf8', function (error, data) {
if (error) {
console.log(chalk.red('Error reading file: '+path));
reject(error);
} else {
data = data.replace(/^\uFEFF/, ''); //remove the BOM (byte-order-mark) from UTF-8 files, if present
resolve(data);
}
});
});
}
/*
write any file (async)
*/
var writeFile = function (path, data) {
return new rsvp.Promise(function (resolve, reject) {
fs.writeFile(path, data, function (error) {
if (error) {
console.log(chalk.red('Error writing file: '+path));
reject(error);
} else {
resolve(true);
}
});
});
}
/*
copy any directory (sync)
*/
var copyDirSync = function (source, destination) {
try {
fs.copySync(source, destination);
} catch (error) {
console.log(chalk.red('Error copying directory: '+source+' to '+destination));
if (options.verbose === true) {
console.log(chalk.red(error));
mainProcess.exit(1);
}
}
}
/*
remake a directory (sync) ... remove and then mkdir in one operation
*/
var remakeDirSync = function (path) {
try {
fs.removeSync(path);
fs.mkdirpSync(path);
} catch (error) {
console.log(chalk.red('Error recreating directory: '+path));
if (options.verbose === true) {
console.log(chalk.red(error));
mainProcess.exit(1);
}
}
}
/*
remove any directory (sync)
*/
var removeDirSync = function (path) {
try {
fs.removeSync(path);
} catch (error) {
console.log(chalk.red('Error removing directory: '+path));
if (options.verbose === true) {
console.log(chalk.red(error));
mainProcess.exit(1);
}
}
}
/*
load all HTML template files
*/
var loadTemplates = function () {
console.log(chalk.green('Loading templates'));
var files = {
main: readFile(__dirname+'/templates/main.html'),
redirect: readFile(__dirname+'/templates/redirect.html'),
webCover: readFile(__dirname+'/templates/webCover.html'),
pdfCover: readFile(__dirname+'/templates/pdfCover.html'),
pdfHeader: readFile(__dirname+'/templates/pdfHeader.html'),
pdfFooter: readFile(__dirname+'/templates/pdfFooter.html'),
};
rsvp.hash(files).then(function(files) {
for (var key in files) {
if (files.hasOwnProperty(key)) {
var file = files[key];
var dom = cheerio.load(file);
templates[key] = dom;
}
}
loadMeta();
}).catch(function(error) {
console.log(chalk.red('Error loading templates'));
if (options.verbose === true) {
console.log(chalk.red(error));
}
mainProcess.exit(1);
});
}
/*
JSON schema validation
*/
var schemas = {
"parameters" : {
title: "DocGen Parameters Schema",
type: "object",
required: [
"title",
"name",
"version",
"date",
"organization",
"author",
"owner",
"contributors",
"website",
"module",
"id",
"summary",
"marking",
"legalese"
],
properties: {
title: { type: "string" },
name: { type: "string" },
version: { type: "string" },
date: { type: "string" },
organization: {
type : "object",
required: [ "name", "url"],
properties: {
name: { type: "string" },
url: { type: "string" },
}
},
author: {
type : "object",
required: [ "name", "url"],
properties: {
name: { type: "string" },
url: { type: "string" },
}
},
owner: {
type : "object",
required: [ "name", "url"],
properties: {
name: { type: "string" },
url: { type: "string" },
}
},
contributors: {
type : "array",
items: { oneOf: [ {
type: "object",
required: [ "name", "url"],
properties: {
name: { type: "string" },
url: { type: "string" },
}
}]}
},
website: {
type : "object",
required: [ "name", "url"],
properties: {
name: { type: "string" },
url: { type: "string" },
}
},
backlink: {
type : "object",
required: [ "name", "url"],
properties: {
name: { type: "string" },
url: { type: "string" },
}
},
module: { type: "string" },
id: { type: "string" },
summary: { type: "string" },
marking: { type: "string" },
legalese: { type: "string" },
}
},
"contents" : {
title: "DocGen Table of Contents Schema",
type : "array",
items: { oneOf: [ {
type: "object",
required: [ "heading", "column", "pages"],
properties: {
name: { type: "string" },
column: { type: "integer", minimum: 1, maximum: 4 },
pages: {
type : "array",
items: { oneOf: [ {
type: "object",
required: [ "title", "source"],
properties: {
title: { type: "string" },
source: { type: "string" },
html: { type: "boolean" },
}
}]}
},
}
}]}
}
};
var validateJSON = function (key, data) {
var schema = schemas[key];
var validator = new schemaValidator();
var valid = validator.validate(data, schema);
if (!valid) {
console.log(chalk.red('Error parsing required file: '+key+'.json (failed schema validation)'));
if (options.verbose === true) {
console.log(chalk.red(validator.getLastError()));
}
}
return valid;
}
/*
load all metadata files (JSON)
*/
var loadMeta = function () {
console.log(chalk.green('Loading required JSON metadata files'));
var files = {
parameters: readFile(options.input+'/parameters.json'),
contents: readFile(options.input+'/contents.json'),
};
rsvp.hash(files).then(function(files) {
for(var key in files) {
if (files.hasOwnProperty(key)) { //ignore prototype
try {
var file = JSON.parse(files[key]);
if (validateJSON(key, file)) {
meta[key] = file;
} else {
mainProcess.exit(1);
}
} catch (error) {
console.log(chalk.red('Error parsing required file: '+key+'.json (invalid JSON)'));
if (options.verbose === true) {
console.log(chalk.red(error));
}
mainProcess.exit(1);
}
}
}
//add the release notes to the contents list
// var extra = {
// heading: 'Extra',
// column: 5,
// pages: [
// { title: 'Release notes', source: 'release-notes.txt' }
// ]
// };
// meta.contents.push(extra);
loadMarkdown();
}).catch(function(error) {
console.log(chalk.red('Error loading required JSON metadata files'));
if (options.verbose === true) {
console.log(chalk.red(error));
}
mainProcess.exit(1);
});
}
/*
load all markdown files (source)
*/
var loadMarkdown = function () {
console.log(chalk.green('Loading source files'));
var keys = [];
var files = [];
meta.contents.forEach( function (section) {
section.pages.forEach( function (page) {
keys.push(page);
files.push(options.input+'/'+page.source);
});
});
//add the release notes page
keys.push('ownership');
files.push(options.input+'/release-notes.txt');
rsvp.all(files.map(readFile)).then(function (files) {
files.forEach( function (page, index) {
try{
var key = keys[index];
if (key.html === true) { //allow raw HTML input pages
pages[key.source] = page;
} else { //otherwise parse input from Markdown into HTML
var html = markdown.render(page);
pages[key.source] = html;
}
} catch (error) {
console.log(chalk.red('Error parsing Markdown file: '+file.source));
if (options.verbose === true) {
console.log(chalk.red(error));
}
mainProcess.exit(1);
}
});
process();
}).catch(function(error) {
console.log(chalk.red('Error loading source files'));
if (options.verbose === true) {
console.log(chalk.red(error));
}
mainProcess.exit(1);
});
}
var sortPages = function () {
//sort the contents by heading
var headings = {1: [], 2: [], 3: [], 4: [], 5: []};
meta.contents.forEach( function (section) {
if (headings.hasOwnProperty(section.column)) {
headings[section.column].push(section);
}
});
sortedPages = headings;
}
/*
build the HTML for the table of contents
*/
var webToc = function () {
sortPages();
var pdfName = meta.parameters.name.toLowerCase()+'.pdf';
var $ = templates.main;
var html = [], i = -1;
html[++i] = '<ul class="section-items list-unstyled nav flex-column pb-3">';
//build the contents HTML
for (var key in sortedPages) {
if (sortedPages.hasOwnProperty(key)) {
// if (key != 5) { //skip the extra column
sortedPages[key].forEach( function (section) {
html[++i] = '<li class="nav-item section-title"><a class="nav-link" href="">'+section.heading+'</a></li>';
section.pages.forEach( function (page) {
var name = page.source.substr(0, page.source.lastIndexOf('.'));
var path = name+'.html';
html[++i] = '<li class="nav-item"><a href="'+path+'">'+page.title+'</a></li>';
});
html[++i] = '</li>';
});
// }
}
}
//fixed-width column at end
// html[++i] = '<li class="nav-item section-title"><a class="nav-link" href="ownership.html">Ownership</a></li>'
// html[++i] = '<li class="nav-item section-title"><a class="nav-link" href="release-notes.html">Release Notes</a></li>'
if (options.pdf) {
html[++i] = '<button class="w-icon-button" onclick="window.location=\''+pdfName+'\';">';
html[++i] = '<span class="w-icon" data-name="document"></span>';
html[++i] = '<span>PDF copy</span>';
html[++i] = '</button>';
}
html[++i] = '</ul>';
$('#docs-nav').html(html.join(''));
templates.main = $;
}
/*
insert the parameters into all templates
*/
var insertParameters = function () {
//------------------------------------------------------------------------------------------------------
//logo dimensions
var hasLogo = false;
var logoWidth = 0;
var logoHeight = 0;
try {
var logo = imageSizeOf(options.input+'/files/images/logo.png');
logoWidth = logo.width;
logoHeight = logo.height;
hasLogo = true;
} catch (error) {
//do nothing. If logo file cannot be read, logo is simply not shown
}
//------------------------------------------------------------------------------------------------------
//the homepage is the first link in the first heading
var homelink = meta.contents[0].pages[0];
var homelink = homelink.source.substr(0, homelink.source.lastIndexOf('.'))+'.html';
var date = moment().format('DD/MM/YYYY');
var time = moment().format('HH:mm:ss');
var year = moment().format('YYYY');
var attribution = 'Created by DocGen '+version+' on '+date+' at '+time+'.';
var releaseVersion = meta.parameters.version;
if (options.setVersion !== false) {
releaseVersion = options.setVersion;
}
var releaseDate = meta.parameters.date;
if (options.setReleaseDate !== false) {
releaseDate = options.setReleaseDate;
}
var author = '';
if (meta.parameters.author.url !== '') {
author += '<a href="'+meta.parameters.author.url+'">'+meta.parameters.author.name+'</a>';
} else {
author += meta.parameters.author.name;
}
var owner = '';
if (meta.parameters.owner.url !== '') {
owner += '<a href="'+meta.parameters.owner.url+'">'+meta.parameters.owner.name+'</a>';
} else {
owner += meta.parameters.owner.name;
}
var organization = '';
if (meta.parameters.organization.url !== '') {
organization += '<a href="'+meta.parameters.organization.url+'">'+meta.parameters.organization.name+'</a>';
} else {
organization += meta.parameters.organization.name;
}
var website = '';
if (meta.parameters.website.url !== '') {
website += '<a href="'+meta.parameters.website.url+'">'+meta.parameters.website.name+'</a>';
} else {
website += meta.parameters.website.name;
}
var backlink = '';
if (meta.parameters.backlink.url !== '') {
backlink += '<a href="'+meta.parameters.backlink.url+'">'+meta.parameters.backlink.name+'</a>';
} else {
backlink += meta.parameters.backlink.name;
}
var contributors = '';
meta.parameters.contributors.forEach (function (contributor) {
if (contributor.url !== '') {
contributors += '<a href="'+contributor.url+'">'+contributor.name+'</a>, ';
} else {
contributors += contributor.name+', ';
}
});
contributors = contributors.replace(/,\s*$/, ""); //remove trailing commas
var copyright = '© '+year+' '+organization;
var webTitle = meta.parameters.title
var webFooter = 'Version '+releaseVersion+' released on '+releaseDate+'.';
for (var key in templates) {
if (templates.hasOwnProperty(key)) {
$ = templates[key];
//logo
if (hasLogo === true) {
var logoUrl = 'files/images/logo.png';
$('#dg-logo').css('background-image', 'url(' + logoUrl + ')');
$('#dg-logo').css('height', logoHeight+'px');
$('#dg-logo').css('line-height', logoHeight+'px');
$('#dg-logo').css('padding-left', (logoWidth+25)+'px');
} else {
$('#dg-logo').css('padding-left', '0');
}
//parameters
$('title').text(meta.parameters.title);
$('#dg-homelink').attr('href', homelink);
$('#dg-title').text(meta.parameters.title);
$('#dg-owner').html(owner);
$('#dg-version').text(releaseVersion);
$('#dg-web-title-version').text('('+releaseVersion+')');
$('#dg-release-date').text(releaseDate);
$('#dg-web-footer').text(webFooter);
$('#dg-author').html(author);
$('#dg-contributors').html(contributors);
$('#dg-module').text(meta.parameters.module);
$('#dg-id').html(meta.parameters.id);
$('#dg-website').html(website);
$('#dg-backlink').html(backlink);
$('#dg-summary').text(meta.parameters.summary);
$('#dg-copyright').html(copyright);
$('#dg-marking').text(meta.parameters.marking);
$('#dg-legalese').text(meta.parameters.legalese);
$('#dg-attribution').text(attribution);
}
}
if (options.mathKatex === true) {
$ = templates.main;
//support for KaTeX (bundled with DocGen)
$('head').append('<link rel="stylesheet" href="require/katex/katex.min.css" type="text/css">');
$('head').append('<script type="text/javascript" src="require/katex/katex.min.js"></script>');
$('head').append('<script type="text/javascript" src="require/katexInjector.js"></script>');
}
if (options.mathMathjax === true) {
//support for MathJax (only supported via CDN due to very large size)
//MathJax configuration is the same as used by math.stackexchange.com
//Note - wkhtmlpdf //cdn urls - see https://github.com/wkhtmltopdf/wkhtmltopdf/issues/1634
$('head').append('<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML-full"></script>');
}
}
/*
process each input into an output
*/
var process = function () {
console.log(chalk.green('Generating the static web content'));
webToc();
insertParameters();
meta.contents.forEach( function (section) {
section.pages.forEach( function (page) {
var $ = cheerio.load(templates.main.html()); //clone
var key = page.source;
var content = pages[key];
//add relevant container
if (page.html === true) { //raw HTML pages should not be confined to the fixed width
$('#dg-content').html('<div id="dg-innerContent"></div>');
} else { //Markdown pages should be confined to the fixed width
$('#dg-content').html('<div class="w-fixed-width"><div id="dg-innerContent"></div></div>');
}
$('#dg-innerContent').html(content);
//------------------------------------------------------------------------------------------------------
//insert permalinks for every page heading
//when pageToc is enabled, also insert a page-level table of contents
var html = [], i = -1;
var headings = $('h1, h2, h3, h4, h5, h6');
if (headings.length > 0) {
html[++i] = '<ul class="dg-pageToc">';
}
headings.each(function( index ) {
var label = $(this).text();
var anchor = label.toLowerCase().replace(/\s+/g, "-");
$(this).attr('id', anchor);
html[++i] = '<li><a href="#'+anchor+'">'+label+'</a></li>';
});
if (headings.length > 0) {
html[++i] = '</ul>';
}
if (options.pageToc === true && page.html !== true) {
$('#dg-innerContent').prepend(html.join(''));
}
//------------------------------------------------------------------------------------------------------
//prepend the auto heading (which makes the PDF table of contents match the web TOC)
$('#dg-innerContent').prepend('<h1 id="dg-autoTitle">'+page.title+'</h1>');
if (page.html === true) {
$('#dg-autoTitle').addClass('dg-hiddenTitle');
}
//------------------------------------------------------------------------------------------------------
//apply the w-table class
$('table:not(.unstyled)').addClass('w-table w-fixed w-stripe');
//------------------------------------------------------------------------------------------------------
pages[key] = $;
});
});
//add web ownership page
var $ = cheerio.load(templates.main.html()); //clone
$('#dg-content').html('<div class="w-fixed-width"><div id="dg-innerContent"></div></div>');
$('#dg-innerContent').html(templates.webCover.html());
templates.webCover = $;
writePages();
}
/*
write each html page
*/
var writePages = function () {
console.log(chalk.green('Writing the web page files'));
var promises = {};
meta.contents.forEach( function (section) {
section.pages.forEach( function (page) {
var key = page.source;
var name = key.substr(0, page.source.lastIndexOf('.'));
var path = options.output+name+'.html';
var html = pages[key].html();
promises[key] = writeFile(path, html);
});
});
//add extra files
promises['ownership'] = writeFile(options.output+'ownership.html', templates.webCover.html());
if (options.pdf === true) {
var pdfTempDir = options.output+'temp/';
fs.mkdirsSync(pdfTempDir);
promises['docgenPdfCover'] = writeFile(pdfTempDir+'pdfCover.html', templates.pdfCover.html());
promises['docgenPdfHeader'] = writeFile(pdfTempDir+'pdfHeader.html', templates.pdfHeader.html());
promises['docgenPdfFooter'] = writeFile(pdfTempDir+'pdfFooter.html', templates.pdfFooter.html());
}
rsvp.hash(promises).then(function (files) {
copyDirSync(__dirname+'/require', options.output+'require'); //CSS, JavaScript
copyDirSync(options.input+'/files', options.output+'files'); //user-attached files and images
if (options.mathKatex === true) {
copyDirSync(__dirname+'/optional/katex', options.output+'require/katex');
}
checkPdfVersion();
}).catch(function(error) {
console.log(chalk.red('Error writing the web page files'));
if (options.verbose === true) {
console.log(chalk.red(error));
}
mainProcess.exit(1);
});
}
/*
wkthmltopdf options
*/
var pdfOptions = [
' --zoom 1.0',
' --image-quality 100',
' --print-media-type',
' --orientation portrait',
' --page-size A4',
' --margin-top 25',
' --margin-right 15',
' --margin-bottom 16',
' --margin-left 15',
' --header-spacing 5',
' --footer-spacing 5',
' --no-stop-slow-scripts',
];
var getPdfArguments = function () {
var pdfName = meta.parameters.name.toLowerCase()+'.pdf';
pdfOptions.push(' --javascript-delay '+options.pdfDelay); //code syntax highlight in wkhtmltopdf 0.12.2.1 fails without a delay (but why doesn't --no-stop-slow-scripts work?)
pdfOptions.push(' --user-style-sheet '+__dirname+'/pdf-stylesheet.css');
pdfOptions.push(' --header-html '+options.output+'temp/pdfHeader.html');
pdfOptions.push(' --footer-html '+options.output+'temp/pdfFooter.html');
pdfOptions.push(' cover '+options.output+'temp/pdfCover.html');
pdfOptions.push(' toc --xsl-style-sheet '+__dirname+'/pdf-contents.xsl');
var allPages = '';
for (var key in sortedPages) {
if (sortedPages.hasOwnProperty(key)) {
sortedPages[key].forEach( function (section) {
section.pages.forEach( function (page) {
var key = page.source;
var name = key.substr(0, page.source.lastIndexOf('.'));
var path = options.output+name+'.html';
allPages += ' '+path;
});
});
}
}
var args = pdfOptions.join('');
args += allPages;
args += ' '+options.output+pdfName;
return spawnArgs(args);
}
var checkPdfVersion = function () {
if (options.pdf === true) {
//first check that wkhtmltopdf is installed
childProcess.exec(options.wkhtmltopdfPath+' -V', function (error, stdout, stderr) {
if (error) {
console.log(chalk.red('Unable to call wkhtmltopdf. Is it installed and in path? See http://wkhtmltopdf.org'));
if (options.verbose === true) {
console.log(chalk.red(error));
}
mainProcess.exit(1);
} else {
//warn if the version of wkhtmltopdf is not an expected version
var actualWkhtmltopdfVersion = stdout.trim();
if (actualWkhtmltopdfVersion !== wkhtmltopdfVersion) {
var warning = 'Warning: unexpected version of wkhtmltopdf, which may work but is not tested or supported';
var expectedVersion = ' expected version: '+wkhtmltopdfVersion;
var detectedVersion = ' detected version: '+actualWkhtmltopdfVersion;
console.log(chalk.yellow(warning));
console.log(chalk.yellow(expectedVersion));
console.log(chalk.yellow(detectedVersion));
}
generatePdf();
}
});
} else {
cleanUp();
}
}
/*
call wkhtmltopdf as an external executable
*/
var generatePdf = function () {
console.log(chalk.green('Creating the PDF copy (may take some time)'));
var args = getPdfArguments();
var wkhtmltopdf = childProcess.spawn(options.wkhtmltopdfPath, args);
var spinner = new cliSpinner(chalk.green(' Processing... %s'));
spinner.setSpinnerString('|/-\\');
wkhtmltopdf.on('error', function (error) {
console.log(chalk.red('Error calling wkhtmltopdf to generate the PDF'));
if (options.verbose === true) {
console.log(chalk.red(error));
}
});
if (options.verbose !== true) {
spinner.start(); //only show spinner when verbose is off (otherwise show raw wkhtmltopdf output)
} else {
//pipe the output from wkhtmltopdf back to stdout
//however, wkhtmltpdf outputs to stderr, not stdout. See:
//https://github.com/wkhtmltopdf/wkhtmltopdf/issues/1980
wkhtmltopdf.stderr.pipe(mainProcess.stdout);
}
wkhtmltopdf.stdout.on('data', function (data) {
//do nothing
});
wkhtmltopdf.stderr.on('data', function (data) {
//do nothing
});
wkhtmltopdf.on('close', function (code) {
if (options.verbose !== true) {
spinner.stop();
console.log(''); //newline after spinner stops
}
if (code !== 0) {
var warning = 'wkhtmltopdf exited with a warning or error: try the -v option for details';
console.log(chalk.yellow(warning));
}
cleanUp();
});
}
var createRedirect = function () {
if (options.redirect) {
var parent = options.output.replace(/\/$/, ""); //trim any trailing slash
parent = parent.split(path.sep).slice(-1).pop(); //get name of final directory in the path
var homepage = meta.contents[0].pages[0];
var homepage = homepage.source.substr(0, homepage.source.lastIndexOf('.'))+'.html';
var redirectLink = parent+'/'+homepage;
$ = templates.redirect;
$('a').attr('href', redirectLink);
$('meta[http-equiv=REFRESH]').attr('content', '0;url='+redirectLink);
var file = options.output+'../'+'index.html';
try {
fs.outputFileSync(file, $.html(), 'utf-8');
} catch (error) {
console.log(chalk.red('Error writing redirect file: '+file));
if (options.verbose === true) {
console.log(chalk.red(error));
}
//don't exit because redirect error is not a fatal error
}
}
}
/*
cleanup
*/
var cleanUp = function () {
createRedirect();
//remove temp files
if (options.pdf === true) {
removeDirSync(options.output+'temp');
}
console.log(chalk.green.bold('Done!'));
}
}
module.exports = DocGen;
|
let { HoribaPentra60Parser } = require('./../horiba-pentra-60-parser');
let parser = new HoribaPentra60Parser();
let results = parser.parse(`
1H|\^&|||ABX|||||||P|E1394-97|20060210061533
2P|1
3O|1|17033680|761|^^^DIF|||||||||||||||||||||F
4R|1|^^^WBC^804-5|10.1|10)/mm)||H||W
5C|1|I|Alarm_WBC^LMNE+|I
6C|2|I|EOSINOPHILIA|I
7R|2|^^^LYM#^731-0|3.51|||||W
0R|3|^^^LYM%^736-9|34.7|||||W
1R|4|^^^MON#^742-7|0.22|||||W
2R|5|^^^MON%^744-3|2.2|||||W
3R|6|^^^NEU#^751-8|5.43|||||W
4R|7|^^^NEU%^770-8|53.7|||||W
5R|8|^^^EOS#^711-2|0.95|||HH||W
6R|9|^^^EOS%^713-8|9.4|||||W
7R|10|^^^BAS#^704-7|0.00|||||W
0R|11|^^^BAS%^706-2|0.0|||||W
1R|12|^^^RBC^789-9|5.14|102/mm)||||F
2C|1|I|HYPOCHROMIA|I
3R|13|^^^HGB^717-9|13.8|g/dl||||F
4R|14|^^^HCT^4544-3|44.0|%||||F
5R|15|^^^MCV^787-2|86|5m)||||F
6R|16|^^^MCH^785-6|26.8|pg||L||F
7R|17|^^^MCHC^786-4|31.4|g/dl||LL||F
0R|18|^^^RDW^788-0|11.5|%||||F
1R|19|^^^PLT^777-3|355|10)/mm)||||F
2R|20|^^^MPV^776-5|8.3|5m)||||F
3L|1|N
`);
console.log(results);
|
initSidebarItems({"attr":[["wasmtime",""]]});
|
var check = require('../util/regex-check')
module.exports = check(/[#-'*+\--9=?A-Z^-~]/)
|
// THIS FILE IS AUTO GENERATED
var GenIcon = require('../lib').GenIcon
module.exports.RiBook3Line = function RiBook3Line (props) {
return GenIcon({"tag":"svg","attr":{"viewBox":"0 0 24 24"},"child":[{"tag":"g","attr":{},"child":[{"tag":"path","attr":{"fill":"none","d":"M0 0h24v24H0z"}},{"tag":"path","attr":{"d":"M21 4H7a2 2 0 1 0 0 4h14v13a1 1 0 0 1-1 1H7a4 4 0 0 1-4-4V6a4 4 0 0 1 4-4h13a1 1 0 0 1 1 1v1zM5 18a2 2 0 0 0 2 2h12V10H7a3.982 3.982 0 0 1-2-.535V18zM20 7H7a1 1 0 1 1 0-2h13v2z"}}]}]})(props);
};
|
import { render, screen, waitFor } from '@testing-library/react';
import userEvent from '@testing-library/user-event'
import SelectizeBox from './selectizeBox';
test('clicking the entity dropdown displays list of options', async () => {
const testArray = [
{label:'testLabel_1', key: 'testKey_1'},
{label:'testLabel_2', key: 'testKey_2'},
{label:'testLabel_3', key: 'testKey_3'}
];
render(<SelectizeBox onEntityChange={_=>{}}
onRSetChange={_=>{}}
entitySelected={null}
entityOptions={testArray}
rSetSelected={null}
rSetOptions={[]} />);
userEvent.hover(screen.getByLabelText('Entity:'));
userEvent.click(screen.getByLabelText('Entity:'));
await waitFor(()=>screen.getByText('testLabel_1'));
testArray.forEach(item => expect(screen.getByText(item.label)).toBeTruthy());
});
test('clicking the relationship set dropdown displays list of options', async () => {
const testArray = [
{label:'testLabel_1', key: 'testKey_1'},
{label:'testLabel_2', key: 'testKey_2'},
{label:'testLabel_3', key: 'testKey_3'}
];
render(<SelectizeBox onEntityChange={_=>{}}
onRSetChange={_=>{}}
entitySelected={null}
entityOptions={[]}
rSetSelected={null}
rSetOptions={testArray} />);
userEvent.hover(screen.getByLabelText('Relationship Set:'));
userEvent.click(screen.getByLabelText('Relationship Set:'));
await waitFor(()=>screen.getByText('testLabel_1'));
testArray.forEach(item => expect(screen.getByText(item.label)).toBeTruthy());
});
test('clicking an entity dropdown option invokes state change', async () => {
const testArray = [
{label:'testLabel_1', key: 'testKey_1'},
{label:'testLabel_2', key: 'testKey_2'},
{label:'testLabel_3', key: 'testKey_3'}
];
const testChange = jest.fn();
render(<SelectizeBox onEntityChange={testChange}
onRSetChange={_=>{}}
entitySelected={null}
entityOptions={testArray}
rSetSelected={null}
rSetOptions={[]} />);
userEvent.hover(screen.getByLabelText('Entity:'));
userEvent.click(screen.getByLabelText('Entity:'));
await waitFor(()=>screen.getByText('testLabel_1'));
userEvent.hover(screen.getByText('testLabel_1'));
userEvent.click(screen.getByText('testLabel_1'));
expect(testChange).toBeCalled();
});
test('clicking an relationship set dropdown option invokes state change', async () => {
const testArray = [
{label:'testLabel_1', key: 'testKey_1'},
{label:'testLabel_2', key: 'testKey_2'},
{label:'testLabel_3', key: 'testKey_3'}
];
const testChange = jest.fn();
render(<SelectizeBox onEntityChange={_=>{}}
onRSetChange={testChange}
entitySelected={null}
entityOptions={[]}
rSetSelected={null}
rSetOptions={testArray} />);
userEvent.hover(screen.getByLabelText('Relationship Set:'));
userEvent.click(screen.getByLabelText('Relationship Set:'));
await waitFor(()=>screen.getByText('testLabel_1'));
userEvent.hover(screen.getByText('testLabel_1'));
userEvent.click(screen.getByText('testLabel_1'));
expect(testChange).toBeCalled();
});
test('render the label of a selected entity', () => {
const testArray = [
{label:'testLabel_1', key: 'testKey_1'},
{label:'testLabel_2', key: 'testKey_2'},
{label:'testLabel_3', key: 'testKey_3'}
];
const testLabel = testArray[0];
render(<SelectizeBox onEntityChange={_=>{}}
onRSetChange={_=>{}}
entitySelected={testLabel}
entityOptions={testArray}
rSetSelected={null}
rSetOptions={[]} />);
expect(()=>screen.getByText('testLabel_1')).not.toThrow();
expect(()=>screen.getByText('testLabel_2')).toThrow();
expect(()=>screen.getByText('testLabel_3')).toThrow();
});
test('render the label of a selected relationship set', () => {
const testArray = [
{label:'testLabel_1', key: 'testKey_1'},
{label:'testLabel_2', key: 'testKey_2'},
{label:'testLabel_3', key: 'testKey_3'}
];
const testLabel = testArray[0];
render(<SelectizeBox onEntityChange={_=>{}}
onRSetChange={_=>{}}
entitySelected={null}
entityOptions={[]}
rSetSelected={testLabel}
rSetOptions={testArray} />);
expect(()=>screen.getByText('testLabel_1')).not.toThrow();
expect(()=>screen.getByText('testLabel_2')).toThrow();
expect(()=>screen.getByText('testLabel_3')).toThrow();
});
|
const { MessageButton, MessageEmbed } = require("discord.js");
const { coletorICCmd } = require("../../utilidades/coletores");
module.exports = {
//* Infomações do comando
emoji: "💔",
nome: "divorciar",
sinonimos: [],
descricao: "Divorcie da pessoa que está casada",
exemplos: [
{ comando: "divorciar", texto: "Divorciar-se do seu cônjuge" },
],
args: "",
opcoes: [],
canalVoz: false,
contaPrimaria: false,
apenasServidor: true,
apenasDono: false,
nsfw: false,
permissoes: {
usuario: [],
bot: ["SEND_MESSAGES"]
},
cooldown: 1,
suporteBarra: true,
testando: false,
//* Comando
async executar(iCmd) {
// Define o relacionamento da pessoa caso nao tenha
client.relacionamentos.ensure(`${iCmd.user.id}`, {
usuario: iCmd.user.username,
conjugeId: null,
conjugeNome: null,
dataCasamento: null,
amantes: [],
});
let usuRelacao = client.relacionamentos.get(iCmd.user.id);
if (!usuRelacao.conjugeId) {
return client.responder(
iCmd,
"bloqueado",
"Você não está casado com ninguém",
"Se você já esqueceu disso, provavelmente não ta indo muito bem as coisas..."
);
}
let conjugeRelacao = client.relacionamentos.get(usuRelacao.conjugeId);
if (!conjugeRelacao.conjugeId || conjugeRelacao.conjugeId !== iCmd.user.id) {
return client.responder(
iCmd,
"erro",
"Ocorreu um erro desconhecido",
"Uhm como que isso aconteceu?"
);
}
const conjugeUsu = await iCmd.guild.members.fetch(usuRelacao.conjugeId);
const divorciar = new MessageButton()
.setCustomId("divorciar")
.setLabel("Divorciar")
.setDisabled(false)
.setStyle("DANGER");
const cancelar = new MessageButton()
.setCustomId("cancelar")
.setLabel("Cancelar")
.setDisabled(false)
.setStyle("PRIMARY");
let botoes = [divorciar, cancelar];
//* Divorcio!
const Embed = new MessageEmbed()
.setColor(client.defs.corEmbed.carregando)
.setTitle("💔 Divorcio!")
.setDescription(
`Você tem certeza que quer se divorciar de ${conjugeUsu?.toString() || conjugeRelacao.usuario}?`
)
.setFooter({
text: "Escolha clicando nos botões",
iconURL: iCmd.user.displayAvatarURL({ dynamic: true, size: 32 })
});
const resposta = await iCmd.reply({
content: null,
embeds: [Embed],
components: [{ type: "ACTION_ROW", components: botoes }],
fetchReply: true
}).catch();
//* Respostas para cada botão apertado
const respostas = {
async divorciar(iBtn) {
usuRelacao = client.relacionamentos.get(iCmd.user.id);
conjugeRelacao = client.relacionamentos.get(usuRelacao.conjugeId);
// Confirmar novamente para não ter erro
if (!usuRelacao.conjugeId) throw new Error("Usuário já está divorciado");
if (!conjugeRelacao.conjugeId) throw new Error("Conjuge já está divorciado");
//* Divorciar
client.relacionamentos.set(iCmd.user.id, null, "conjugeId");
client.relacionamentos.set(usuRelacao.conjugeId, null, "conjugeId");
client.relacionamentos.set(iCmd.user.id, null, "conjugeNome");
client.relacionamentos.set(usuRelacao.conjugeId, null, "conjugeNome");
client.relacionamentos.set(iCmd.user.id, null, "dataCasamento");
client.relacionamentos.set(usuRelacao.conjugeId, null, "dataCasamento");
Embed
.setColor(client.defs.corEmbed.nao)
.setTitle("💔 Ainda há muito peixe no mar")
.setDescription(
`${iCmd.user.toString()} divorciou-se de ${conjugeUsu?.toString() || conjugeRelacao.usuario}`
)
.setFooter(null);
await iBtn.update({ embeds: [Embed] });
client.log(
"info",
`${iCmd.user.username} divorciou-se de ${conjugeUsu?.username || conjugeRelacao.usuario}`
);
return true;
},
async cancelar(iBtn) {
Embed
.setColor(client.defs.corEmbed.normal)
.setTitle("💍 Essa foi por pouco")
.setDescription(
`${iCmd.user.toString()} cancelou o divorcio com`
+ ` ${conjugeUsu?.toString() || conjugeRelacao.usuario}`
)
.setFooter(null);
await iBtn.update({ embeds: [Embed] });
client.log(
"info",
`${iCmd.user.username} cancelou o divorcio com`
+ ` ${conjugeUsu?.username || conjugeRelacao.usuario}`
);
return true;
}
};
//* Coletor de interações
const filtro = (iBtn) => iBtn.user.id !== iCmd.user.id;
coletorICCmd(iCmd, resposta, respostas, filtro);
}
};
|
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-48605964-29', 'auto');
ga('set', 'anonymizeIp', true);
ga('set', 'forceSSL', true);
ga('send', 'pageview');
|
// 云函数入口文件
const cloud = require('wx-server-sdk')
cloud.init()
const db = cloud.database()
// 云函数入口函数
exports.main = async (event, context) => {
// var googsid = event.goodsid
try {
return await db.collection('goodsInfo').doc(event.goodsid).update({
data:{
exist:false
},
success(res){
console.log("[transaction][更新商品状态] 成功：",res);
},fail(err){
console.err("[transaction][更新商品状态] 失败：",err);
}
})
} catch (e) {
console.log(e)
}
}
|
sap.ui.define([
'./BaseController',
'../model/formatter'
], function (BaseController, formatter) {
"use strict";
return BaseController.extend("project.frotasapp.controller.ImportantLinks", {
formatter: formatter,
onInit: function () {
},
});
});
|
import reducer, {
EDIT_TAG_START,
EDIT_TAG_ERROR,
EDIT_TAG,
TAG_EDITED,
tagEdited,
editTag,
} from '../../../src/tags/reducers/tagEdit';
describe('tagEditReducer', () => {
describe('reducer', () => {
it('returns loading on EDIT_TAG_START', () => {
expect(reducer({}, { type: EDIT_TAG_START })).toEqual({
editing: true,
error: false,
});
});
it('returns error on EDIT_TAG_ERROR', () => {
expect(reducer({}, { type: EDIT_TAG_ERROR })).toEqual({
editing: false,
error: true,
});
});
it('returns tag names on EDIT_TAG', () => {
expect(reducer({}, { type: EDIT_TAG, oldName: 'foo', newName: 'bar' })).toEqual({
editing: false,
error: false,
oldName: 'foo',
newName: 'bar',
});
});
});
describe('tagEdited', () => {
it('returns action based on provided params', () =>
expect(tagEdited('foo', 'bar', '#ff0000')).toEqual({
type: TAG_EDITED,
oldName: 'foo',
newName: 'bar',
color: '#ff0000',
}));
});
describe('editTag', () => {
const createApiClientMock = (result) => ({
editTag: jest.fn(() => result),
});
const colorGenerator = {
setColorForKey: jest.fn(),
};
const dispatch = jest.fn();
const getState = () => ({});
afterEach(() => {
colorGenerator.setColorForKey.mockReset();
dispatch.mockReset();
});
it('calls API on success', async () => {
const oldName = 'foo';
const newName = 'bar';
const color = '#ff0000';
const apiClientMock = createApiClientMock(Promise.resolve());
const dispatchable = editTag(() => apiClientMock, colorGenerator)(oldName, newName, color);
await dispatchable(dispatch, getState);
expect(apiClientMock.editTag).toHaveBeenCalledTimes(1);
expect(apiClientMock.editTag).toHaveBeenCalledWith(oldName, newName);
expect(colorGenerator.setColorForKey).toHaveBeenCalledTimes(1);
expect(colorGenerator.setColorForKey).toHaveBeenCalledWith(newName, color);
expect(dispatch).toHaveBeenCalledTimes(2);
expect(dispatch).toHaveBeenNthCalledWith(1, { type: EDIT_TAG_START });
expect(dispatch).toHaveBeenNthCalledWith(2, { type: EDIT_TAG, oldName, newName });
});
it('throws on error', async () => {
const error = 'Error';
const oldName = 'foo';
const newName = 'bar';
const color = '#ff0000';
const apiClientMock = createApiClientMock(Promise.reject(error));
const dispatchable = editTag(() => apiClientMock, colorGenerator)(oldName, newName, color);
try {
await dispatchable(dispatch, getState);
} catch (e) {
expect(e).toEqual(error);
}
expect(apiClientMock.editTag).toHaveBeenCalledTimes(1);
expect(apiClientMock.editTag).toHaveBeenCalledWith(oldName, newName);
expect(colorGenerator.setColorForKey).not.toHaveBeenCalled();
expect(dispatch).toHaveBeenCalledTimes(2);
expect(dispatch).toHaveBeenNthCalledWith(1, { type: EDIT_TAG_START });
expect(dispatch).toHaveBeenNthCalledWith(2, { type: EDIT_TAG_ERROR });
});
});
});
|
const webpack = require('webpack');
const conf = require('./gulp.conf');
const path = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin');
const FailPlugin = require('webpack-fail-plugin');
const autoprefixer = require('autoprefixer');
module.exports = {
module: {
loaders: [
{
test: /\.json$/,
loaders: [
'json-loader'
]
},
{
test: /\.js$/,
exclude: /node_modules/,
loader: 'eslint-loader',
enforce: 'pre'
},
{
test: /\.(css|styl|stylus)$/,
loaders: [
'style-loader',
'css-loader',
'stylus-loader',
'postcss-loader'
]
},
{
test: /\.js$/,
exclude: /node_modules/,
loaders: [
'ng-annotate-loader'
]
},
{
test: /\.html$/,
loaders: [
'html-loader'
]
}
]
},
plugins: [
new webpack.optimize.OccurrenceOrderPlugin(),
new webpack.NoEmitOnErrorsPlugin(),
FailPlugin,
new HtmlWebpackPlugin({
template: conf.path.src('index.html')
}),
new webpack.LoaderOptionsPlugin({
options: {
postcss: () => [autoprefixer]
},
debug: true
})
],
devtool: 'source-map',
output: {
path: path.join(process.cwd(), conf.paths.tmp),
filename: 'index.js'
},
entry: `./${conf.path.src('index')}`
};
|
const login = require("../../../collections/login");
const providers = require("../../../collections/providers");
const constants = require("../../../config/constants");
const common = require("../../../utility/common");
const logs = require("../../../utility/logs");
const query = require("../../../config/query");
const elementHandler = require("../../../utility/elementHandler");
const checkSuccess = require("../../../schemaValidate/check.success");
const typeSuccess = require("../../../schemaValidate/type.success");
const accessTypeSuccess = require("../../../schemaValidate/accesstype.success");
const createProSuccess = require("../../../schemaValidate/create.success");
const workerSuccess = require("../../../schemaValidate/worker.success");
const loggingSuccess = require("../../../schemaValidate/logging.success");
const addContext = require("mochawesome/addContext");
beforeEach(function (done) {
const token = common.searchOfEnv("login", "login", "token");
login.check()
.end((err, res) => {
if (res.statusCode !== 200)
logs.getApiResponse(res);
elementHandler.responseExpect(res.body, res.statusCode, 200, res.res.statusMessage, constants.STATUS_TEXT_OK, res.ok);
elementHandler.toBeEqual(res.body.email_verified, constants.email_verified);
elementHandler.schemaValidate(res.body, checkSuccess);
elementHandler.toBeEqual(res.body.token, token);
done();
});
});
const accessType = "DockerHub Token";
describe("Create Docker Hub provider test case", () => {
it("GET /provider/types", function (done) {
providers.types("?id=25")
.end((err, res) => {
if (res.statusCode !== 200)
logs.getApiResponse(res);
elementHandler.responseExpect(res.body, res.statusCode, 200, res.res.statusMessage, constants.STATUS_TEXT_OK, res.ok);
elementHandler.schemaValidate(res.body, typeSuccess);
for (const obj of res.body) {
if (obj.name === constants.DOCKER) {
elementHandler.toBeTrue(obj.enabled);
elementHandler.toBeEqual(obj.name, constants.DOCKER);
//set provider type id and name in the env variable
common.readOrWriteJsonFile("provider", "provider_type", "id", obj.id);
common.readOrWriteJsonFile("provider", "provider_type", "name", obj.name);
console.log("Docker Hub provider type id and name: ", [obj.id, obj.name]);
addContext(this, "Docker Hub provider type id and name: " + [obj.id, obj.name]);
}
}
done();
});
});
it("GET /provider/access_types", function (done) {
const provider_type_id = "?provider_type_id=" + common.searchOfEnv("provider", "provider_type", "id");
providers.accessType(provider_type_id)
.end((err, res) => {
if (res.statusCode !== 200)
logs.getApiResponse(res);
elementHandler.responseExpect(res.body, res.statusCode, 200, res.res.statusMessage, constants.STATUS_TEXT_OK, res.ok);
elementHandler.schemaValidate(res.body, accessTypeSuccess);
for (const obj of res.body) {
if (obj.name === accessType) {
elementHandler.toBeEqual(obj.name, accessType);
//set access type id and name in env variable
common.readOrWriteJsonFile("provider", "access_type", "id", obj.id);
common.readOrWriteJsonFile("provider", "access_type", "name", obj.name);
console.log("Docker Hub access type id and name: ", [obj.id, obj.name]);
addContext(this, "Docker Hub access type id and name: " + [obj.id, obj.name]);
}
}
done();
});
});
it("POST /provider", function (done) {
const param = {
"name": "docker-" + common.getRandomString(2),
"password": process.env.docker_hub_token,
"url": process.env.docker_hub_url,
"user_name": process.env.docker_hub_user,
}
providers.create()
.send(param)
.end((err, res) => {
if (res.statusCode !== 200)
logs.postApiResponse(res);
if (common.isEmpty(res.body)) {
console.log("response body: ", res.body);
elementHandler.responseExpect(res.body, res.statusCode, 200, res.res.statusMessage, constants.STATUS_TEXT_OK, res.ok);
} else {
elementHandler.responseExpect(res.body, res.statusCode, 200, res.res.statusMessage, constants.STATUS_TEXT_OK, res.ok);
elementHandler.schemaValidate(res.body, createProSuccess);
// create provider id and name set in env file
common.readOrWriteJsonFile("provider", "provider_details", "id", res.body.id);
common.readOrWriteJsonFile("provider", "provider_details", "name", res.body.name);
console.log("Docker Hub create provider id and name: ", [res.body.id, res.body.name]);
addContext(this, "Docker Hub create provider id and name: " + [res.body.id, res.body.name]);
}
done();
});
});
describe('Sync provider test case', () => {
it('POST / provider/sync', function (done) {
providers.sync()
.end((err, res) => {
if (res.statusCode !== 200)
logs.postApiResponse(res);
elementHandler.responseExpect(res.body, res.statusCode, 200, res.res.statusMessage, constants.STATUS_TEXT_OK, res.ok);
elementHandler.toBeEqual(res.body.message, 'published');
console.log('Sync provider: ', [res.body.message]);
addContext(this, 'Sync provider: ' + res.body.message);
done();
});
});
});
describe('Sync logs provider test case', () => {
it('GET / worker_requests', function () {
const pro_id = common.searchOfEnv('provider', 'provider_details', 'id');
return providers.worker(query.worker + pro_id)
.then((res) => {
if (res.statusCode !== 200)
logs.getApiResponse(res);
elementHandler.responseExpect(res.body, res.statusCode, 200, res.res.statusMessage, constants.STATUS_TEXT_OK, res.ok);
elementHandler.schemaValidate(res.body, workerSuccess);
for (var i = 0; i < res.body.length; i++) {
if (i === 0) {
list = res.body[i];
elementHandler.toBeEqual(list.provider_id, pro_id);
common.readOrWriteJsonFile('provider', 'worker_requests', 'logs_id', list.id)
return;
}
}
});
});
it('GET / worker_request', function (done) {
const log_id = common.searchOfEnv('provider', 'worker_requests', 'logs_id');
providers.worker('/' + log_id)
.end((err, res) => {
if (res.statusCode !== 200)
logs.getApiResponse(res);
elementHandler.responseExpect(res.body, res.statusCode, 200, res.res.statusMessage, constants.STATUS_TEXT_OK, res.ok);
if (res.body.id === log_id) {
elementHandler.toBeEqual(res.body.id, log_id);
console.log('Worker requests id: ', [res.body.id]);
addContext(this, 'Worker requests id: ' + res.body.id);
}
done();
});
});
it('GET / logging', function (done) {
const log_id = common.searchOfEnv('provider', 'worker_requests', 'logs_id');
providers.logging(log_id)
.end((err, res) => {
if (res.statusCode !== 200)
logs.getApiResponse(res);
elementHandler.responseExpect(res.body, res.statusCode, 200, res.res.statusMessage, constants.STATUS_TEXT_OK, res.ok);
elementHandler.schemaValidate(res.body, loggingSuccess);
common.tryDelay(5000);
for (const obj of res.body) {
if (obj.id === log_id) {
elementHandler.toBeEqual(obj.id, log_id);
console.log('Logging id and status: ', [obj.id, obj.status]);
addContext(this, 'Logging id and status: ' + [obj.id, obj.status]);
}
}
done();
});
});
});
});
|
import React,{Component} from "react";
import { Link } from "react-router-dom";
import "./style.css";
import DropDown from "../DropDown";
import Navheadings from "../Navheadings"
class Navbar extends Component{
render(){
return(
<nav className="navbar navbar-expand-lg navbar-dark navbg">
{this.props.id === "1" ?
<div className="collapse navbar-collapse" id="navbarSupportedContent">
<ul className="navbar-nav mr-auto">
<Navheadings href={"/entertainment/"+this.props.id} heading="Entertainment"></Navheadings>
<Navheadings href={"/safety/"+this.props.id} heading="Health"></Navheadings>
<li className="nav-item dropdown">
<DropDown id={this.props.id}><a className="navbar-brand dropdown-toggle" href="#" id="dropdownMenuLink" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Videos</a></DropDown>
</li>
</ul>
<form className="form-inline my-2 my-lg-0">
<Link to="/login"><button className="btn btn-outline-light mr-sm-2" type="submit">Sign In</button></Link>
<Link to="/signup"><button className="btn btn-outline-light my-2 my-sm-0" type="submit">Sign Up</button></Link>
</form>
</div>
: <div className="collapse navbar-collapse" id="navbarSupportedContent">
<ul className="navbar-nav mr-auto">
<Navheadings href={"/entertainment/"+this.props.id} heading="Entertainment"></Navheadings>
<Navheadings href={"/safety/"+this.props.id} heading="Health"></Navheadings>
<Navheadings href={"/scheduler/"+this.props.id} heading="Scheduler"></Navheadings>
<Navheadings href={"/tracker/"+this.props.id} heading="Tracker"></Navheadings>
<li className="nav-item dropdown">
<DropDown id={this.props.id}><a className="navbar-brand dropdown-toggle" href="#" id="dropdownMenuLink" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Videos</a></DropDown>
</li>
</ul>
<form className="form-inline my-2 my-lg-0">
<Link to="/"><button className="btn btn-outline-light mr-sm-2" type="submit">Logout</button></Link>
</form>
</div>}
</nav>
);
}
}
export default Navbar;
|
import React, { useEffect, useState } from 'react';
import Input from './Input';
import Radio from './Radio';
import DropDown from './DropDown';
import { generatorArrayDays, generatorArrayMonths, generatorArrayYears } from '../initialize/generator';
const AR_GENDER = [
{
"className": "input__radio circle__radio",
"value": "male",
"label": "Nam",
"id": "male",
"name": "gender"
},
{
"className": "input__radio circle__radio",
"value": "female",
"label": "Nữ",
"id": "female",
"name": "gender"
}
]
const AR_ROLE = [
{
"className": "input__radio career__radio",
"value": "owner",
"label": "Chủ nhà thuốc",
"id": "owner",
"name": "role"
},
{
"className": "input__radio career__radio",
"value": "staff",
"label": "Nhân viên bán thuốc",
"id": "staff",
"name": "role"
}
]
function RadioList({ fnc, checkedVal, array }) {
let list = array.map((val, index) => {
return (
<Radio key={index} fnc={fnc} checked={checkedVal === val.value} className={val.className} id={val.id} label={val.label} val={val.value} name={val.name} />
)
})
return list;
}
const TabRegister = ({
register,
setRole,
setGender,
setFullname,
setPhone,
setBirthDay,
setBirthMonth,
setBirthYear,
submit,
loading
}) => {
const [isError, setError] = useState(false);
const { fullname, phone, gender, role, birthday, error } = register;
const day = { text: birthday.day === "" ? "Ngày" : birthday.day, value: birthday.day };
const month = { text: birthday.month === "" ? "Tháng" : birthday.month, value: birthday.month };
const year = { text: birthday.year === "" ? "Năm" : birthday.year, value: birthday.year };
const classLoading = loading ? "load-screen active" : "load-screen";
useEffect(() => {
let timeout;
if (isError && !loading) {
timeout = setTimeout(() => {
setError(false);
clearTimeout(timeout)
}, 2000);
}
return function cleanup(){ // unsubscribe when componentWillUnmount
/**/
clearTimeout(timeout);
}
}, [register, loading]);
const submitFn = () => {
submit(register);
if (!isError) {
setError(true);
}
}
return (
<article className="registration__holder register active content__article">
<p className="reminder">
NẾU BẠN ĐÃ TẠO TÀI KHOẢN,<br /> VUI LÒNG BẤM <span className="reminder--login" id="reminder-login">ĐĂNG NHẬP.</span>
</p>
<div className="inline__block career">
<span>Bạn là</span>
<RadioList fnc={setRole} checkedVal={role} array={AR_ROLE} />
</div>
<div className="inline__block gender">
<RadioList fnc={setGender} checkedVal={gender} array={AR_GENDER} />
</div>
<div className="block fullname">
<p className="field__label">HỌ VÀ TÊN <span className="asterisk">*</span></p>
<Input className="field__input" fnc={setFullname} val={fullname} placeholder="" />
</div>
<div className="block dob">
<p className="field__label">NGÀY/THÁNG/NĂM SINH<span className="asterisk">*</span></p>
<div className="dob__day dropdown">
<DropDown array={generatorArrayDays()} onClick={setBirthDay} value={day} />
</div>
<div className="dob__month dropdown">
<DropDown array={generatorArrayMonths()} onClick={setBirthMonth} value={month} />
</div>
<div className="dob__year dropdown">
<DropDown array={generatorArrayYears()} onClick={setBirthYear} value={year} />
</div>
</div>
<div className="block fullname">
<p className="field__label">SỐ ĐIỆN THOẠI <span className="asterisk">*</span></p>
<Input className="field__input" fnc={setPhone} val={phone} placeholder="" />
</div>
<p className="error__message" style={{ "opacity": isError ? "1" : 0 }}>{error ? error : " "}</p>
<button className="submit__button green__button submit__button--register" id="register-button" onClick={ submitFn }>
<p className="core">TIẾP TỤC</p>
</button>
<div className={classLoading}>
<div className="load-circle active"></div>
</div>
</article>
);
}
export default TabRegister;
|
import ZIndexBook from "../../../world/z-indices.js";
import Constants from "../../../constants.js";
const SCALE = Constants.WorldCanvasScale
const TOP_DISTANCE = Constants.WorldUIScreenMargin;
const TEXT_SCALE = 4 * SCALE;
const TEXT_COLOR = "white";
const TEXT_BACKGROUND = "black";
const TEXT_PADDING = 2;
const TRANSITION_TIME = 500;
const CENTER_TRANSITION_TIME = 1000;
const OFFSCREEN_DISTANCE_FACTOR = 12;
const CENTERED_DISTANCE_FACTOR = 2;
const LETTER_SPACING = 0;
const WORD_SPACING = 2;
const {TextSprite} = Eleven;
const labelBase = {
color: TEXT_COLOR,
backgroundColor: TEXT_BACKGROUND,
backgroundPadding: TEXT_PADDING,
scale: TEXT_SCALE,
wordSpacing: WORD_SPACING,
letterSpacing: LETTER_SPACING,
absolutePositioning: true
};
const getLabel = (world,lines,centered,getYOffset) => {
labelBase.lines = lines;
const label = new TextSprite(labelBase);
const ID = world.dispatchRenderer.addFinalize((context,size,time)=>{
const yOffset = getYOffset(time) * size.height;
if(centered) {
label.render(context,Math.floor(size.halfWidth),Math.floor(size.halfHeight) + yOffset);
} else {
label.render(context,size.halfWidth,label.halfHeight + TOP_DISTANCE + yOffset);
}
},ZIndexBook.ObjectiveLabel);
return ID;
};
function ObjectiveText(world) {
let activeID = null;
let showingCentered = false;
let showStart = null;
let closeStart = null;
let closeCallback = null;
const sendCloseCallback = async () => {
if(closeCallback) closeCallback();
};
const getDistanceFactor = () => {
return showingCentered ? CENTERED_DISTANCE_FACTOR : OFFSCREEN_DISTANCE_FACTOR;
};
const getTransitionTime = () => {
return showingCentered ? CENTER_TRANSITION_TIME : TRANSITION_TIME;
};
const getYOffset = time => {
if(showStart !== null) {
let t = (time.now - showStart) / getTransitionTime();
if(t < 0) {
t = 0;
} else if(t > 1) {
showStart = null;
return 0;
}
const factor = getDistanceFactor();
return -(1-t) / factor;
} else if(closeStart !== null) {
let t = (time.now - closeStart) / getTransitionTime();
const factor = getDistanceFactor();
if(t < 0) {
t = 0;
} else if(t > 1) {
sendCloseCallback();
return -1 / factor;
}
return -t / factor;
}
return 0;
};
this.show = (lines,centered,instant) => {
if(closeStart !== null) return;
if(activeID !== null) {
world.dispatchRenderer.removeFinalize(activeID);
activeID = null;
} else {
showingCentered = Boolean(centered);
if(instant) {
showStart = null;
} else {
showStart = performance.now();
}
}
activeID = getLabel(world,lines,showingCentered,getYOffset);
};
this.close = async () => {
await new Promise(resolve => {
closeStart = performance.now();
closeCallback = resolve;
});
world.dispatchRenderer.removeFinalize(activeID);
closeStart = null;
activeID = null;
this.status = null;
};
Object.defineProperties(this,{
text: {
set: value => {
if(!Array.isArray(value)) {
value = [value];
}
this.show(value,false);
},
enumerable: true
},
});
this.status = null;
this.set = (text,status) => {
this.text = text;
if(status) this.status = status;
};
Object.seal(this);
}
export default ObjectiveText;
|
import React from "react";
import HeroSection from "../../HeroSection";
import {
contactObjFour,
contactObjOne,
contactObjThree,
contactObjTwo,
} from "./ContactData";
function Contact() {
return (
<div>
<HeroSection {...contactObjOne} />
<HeroSection {...contactObjTwo} /> <HeroSection {...contactObjThree} />
<HeroSection {...contactObjFour} />
</div>
);
}
export default Contact;
|
// Compiled from this: https://github.com/metalshark/grunt-html5compare/blob/master/tasks/lib/html5compare.litcoffee
// Note that this code is presumably under the LGPL license.
'use strict';
const jsdom = require('jsdom').jsdom;
function compare(orig, comp) {
var compDOM, origDOM;
origDOM = jsdom(orig);
compDOM = jsdom(comp);
trimWhitespace(origDOM);
trimWhitespace(compDOM);
return compareElements(origDOM, compDOM);
}
function trimWhitespace(dom) {
var childNode, i, j, k, len, len1, len2, ref, ref1, results, whitespaceChildren;
if (dom.innerHTML) {
dom.innerHTML = dom.innerHTML.replace(/^[\n\r\s\t]+|[\n\r\s\t]+$/gm, '');
}
whitespaceChildren = [];
if (dom.hasChildNodes()) {
ref = dom.childNodes;
for (i = 0, len = ref.length; i < len; i++) {
childNode = ref[i];
if (childNode.nodeName === '#text') {
if (childNode.textContent.match(/^[\n\r\s\t]+$/gm)) {
whitespaceChildren.push(childNode);
}
}
}
}
for (j = 0, len1 = whitespaceChildren.length; j < len1; j++) {
childNode = whitespaceChildren[j];
dom.removeChild(childNode);
}
if (dom.hasChildNodes()) {
ref1 = dom.childNodes;
results = [];
for (k = 0, len2 = ref1.length; k < len2; k++) {
childNode = ref1[k];
results.push(trimWhitespace(childNode));
}
return results;
}
}
function trimTextWhitespace(text) {
text = text.replace(/[\n\r\s\t]/gm, ' ');
text = text.replace(/[\s][\s]+/g, ' ');
text = text.replace(/^[\s]+|[\s]+$/g, '');
return text;
}
function drawTreeView(parent, node, state, indent) {
var childNode, classes, i, len, ref;
if (state == null) {
state = {
text: ''
};
}
if (indent == null) {
indent = '';
}
if (parent.nodeName === '#text') {
state.text += indent + trimTextWhitespace(parent.nodeValue);
} else {
state.text += indent + parent.nodeName;
if (parent != null) {
if (parent.id != null) {
state.text += '#' + parent.id;
}
if (parent.className != null) {
classes = parent.className.split(/[\s,]+/).sort().join('.');
if (classes) {
state.text += '.' + classes;
}
}
}
}
state.text += '\n';
if (parent === node) {
return state.text;
}
indent += '-';
ref = parent.childNodes;
for (i = 0, len = ref.length; i < len; i++) {
childNode = ref[i];
if (drawTreeView(childNode, node, state, indent)) {
return state.text;
}
}
return false;
}
function throwError(parent, node, text) {
var treeview;
treeview = drawTreeView(parent, node);
throw new Error(text + '\n' + treeview);
}
function compareElements(orig, comp, parent) {
var attr, compAttrNames, compChildrenNames, compNames, compText, compValue, i, index, j, k, l, len,
len1, len2, len3, len4, len5, m, n, node, origAttrNames, origChildNode, origChildrenNames,
origNames, origText, ref, ref1, ref2, ref3, ref4, ref5;
if (parent == null) {
parent = orig;
}
if (orig.nodeName !== comp.nodeName) {
throwError(parent, orig, 'nodeNames do not match: ' + orig.nodeName + ' != ' + comp.nodeName);
}
if (orig.attributes) {
if (orig.attributes.length !== comp.attributes.length) {
origAttrNames = [];
compAttrNames = [];
ref = orig.attributes;
for (i = 0, len = ref.length; i < len; i++) {
attr = ref[i];
origAttrNames.push(attr.name);
origNames = origAttrNames.join(', ');
}
ref1 = comp.attributes;
for (j = 0, len1 = ref1.length; j < len1; j++) {
attr = ref1[j];
compAttrNames.push(attr.name);
compNames = compAttrNames.join(', ');
}
throwError(parent, orig, 'attribute lengths do not match: (' + origNames + ') != (' +
compNames + ')');
}
ref2 = orig.attributes;
for (k = 0, len2 = ref2.length; k < len2; k++) {
attr = ref2[k];
compValue = comp.getAttribute(attr.name);
if (attr.name === attr.value) {
attr.value = '';
}
if (attr.name === compValue) {
compValue = '';
}
if (attr.name === 'class') {
attr.value = attr.value.split(/[\s,]+/).sort().join(' ');
if (compValue) {
compValue = compValue.split(/[\s,]+/).sort().join(' ');
} else {
compValue = [];
}
}
if (attr.value !== compValue) {
throwError(parent, orig, 'attribute values do not match: "' + attr.value + '" != "' +
compValue + '"');
}
}
}
if (orig.hasChildNodes()) {
if (orig.childNodes.length !== comp.childNodes.length) {
origChildrenNames = [];
compChildrenNames = [];
ref3 = orig.childNodes;
for (l = 0, len3 = ref3.length; l < len3; l++) {
node = ref3[l];
origChildrenNames.push(node.nodeName);
origNames = origChildrenNames.join(', ');
}
ref4 = comp.childNodes;
for (m = 0, len4 = ref4.length; m < len4; m++) {
node = ref4[m];
compChildrenNames.push(node.nodeName);
compNames = compChildrenNames.join(', ');
}
throwError(parent, orig, 'child lengths do not match: (' + origNames + ') != (' + compNames +
')');
}
ref5 = orig.childNodes;
for (index = n = 0, len5 = ref5.length; n < len5; index = ++n) {
origChildNode = ref5[index];
compareElements(origChildNode, comp.childNodes[index], parent);
}
}
if (orig.nodeName === '#text') {
origText = trimTextWhitespace(orig.textContent);
compText = trimTextWhitespace(comp.textContent);
if (origText !== compText) {
return throwError(parent, orig, 'content differs "' + origText + '" != "' + compText + '"');
}
}
}
module.exports = function (chai, utils) {
utils.addMethod(chai.Assertion.prototype, 'htmlEqual', function (expected) {
const obj = this._obj;
let error = '';
try {
compare(obj, expected);
} catch (e) {
error = e.message;
}
this.assert(obj && !error,
'expected HTML of #{act} to equal #{exp}: ' + error,
'expected HTML of #{act} to not equal #{exp}.',
expected,
obj);
});
const assert = chai.assert;
assert.htmlEqual = function (val, exp, msg) {
new chai.Assertion(val, msg).to.be.htmlEqual(exp);
};
assert.notHtmlEqual = function (val, exp, msg) {
new chai.Assertion(val, msg).to.not.be.htmlEqual(exp);
};
};
|
exports.id = 'split';
exports.title = 'Split';
exports.group = 'Common';
exports.version = '1.1.1';
exports.color = '#656D78';
exports.input = true;
exports.output = 1;
exports.options = {};
exports.author = 'Jiří Travěnec';
exports.icon = 'code-fork';
exports.readme = `# Split
This component iterates over the received data and sends every item separately.`;
exports.install = function(instance) {
instance.on('data', function (response) {
var data = response.data;
if (data instanceof Array) {
for (var i = 0; i < data.length; i++) {
if (data[i] != null) {
var msg = instance.make(data[i], 0);
msg.repository = response.repository;
instance.send2(msg);
}
}
}
});
};
|
import styled from 'styled-components/native';
import { Headline, Paragraph } from 'react-native-paper';
export const Container = styled.View`
flex: 1;
background: #F6F5F5;
`;
export const HeadLogo = styled.Image`
align-self: center;
margin: 10px 0px;
`;
export const HeadLogoContainer = styled.View`
height: 80px;
justify-content: center;
align-items: center;
width: 100%;
`;
export const Title = styled(Headline)`
color: #2D0C57;
font-size: 30px;
font-weight: bold;
`;
export const TitleContainer = styled.View`
padding-left: 20px;
`;
export const ShowPlacesContainer = styled.TouchableOpacity`
align-self: center;
margin-top: 10px;
margin-bottom: 10px;
`;
export const ShowPlacesText = styled(Paragraph)`
color: #3BC365;
font-size: 17px;
`;
export const Head = styled.View`
flex-direction: row;
`;
export const HeadButtonContainer = styled.View`
position: absolute;
justify-content: center;
align-items: center;
height: 100%;
`;
|
/*!
* LetsBlog
* XTemplate wrapper
* Released under MIT license
*/
var fs = require('fs'),
Path = require('path'),
env = require('../config').env || 'development',
XTemplate;
try {
XTemplate = require('xtemplate');
} catch (e) {
console.error('xtpl depends on xtemplate, please install xtemplate xtpl both');
}
var globalConfig = {
cache: env === 'production',
catchError: env !== 'production',
encoding: 'utf-8',
XTemplate: XTemplate
};
var fileCache = { }, instanceCache = { }, fnCache = { };
function normalizeSlash(path) {
if (path.indexOf('\\') !== -1) {
path = path.replace(/\\/g, '/');
}
return path;
}
function endsWith(str, suffix) {
var ind = str.length - suffix.length;
return ind >= 0 && str.indexOf(suffix, ind) === ind;
}
function mix(r, s) {
for (var p in s) {
r[p] = s[p];
}
return r;
}
function compile(root, tpl, path, callback) {
var fn;
try {
fn = root.compile(tpl, path);
} catch (e) {
return callback(e);
}
callback(null, fn);
}
function getTplFn(root, path, config, callback) {
var cache = config.cache;
if (cache && fnCache[path]) {
return callback(0, fnCache[path]);
}
readFile(path, config, function(error, tpl) {
if (error) {
callback(error);
} else {
compile(root, tpl, path, function(err, fn) {
if (err) {
callback(err);
} else {
if (cache) {
fnCache[path] = fn;
}
callback(null, fn);
}
});
}
});
}
function getInstance(config) {
var cache = config.cache, path = config.name, cached;
if (cache && (cached = instanceCache[path])) {
return cached;
}
var instance = new globalConfig.XTemplate(config);
if (cache) {
instanceCache[path] = instance;
}
return instance;
}
function readFileSync(path) {
var content, error;
try {
content = fs.readFileSync(path);
} catch (e) {
error = e;
}
return {
content: content,
error: error
};
}
function readFile(path, config, callback) {
var cache = config.cache, cached;
if (cache && (cached = fileCache[path])) {
return callback(null, cached);
}
var encoding = config.encoding,
ret = readFileSync(path),
content = ret.content,
error = ret.error;
if (content) {
if ( Buffer.isEncoding(encoding) ) {
content = content.toString(encoding);
} else {
error = 'encoding: ' + encoding + ', npm install iconv-lite, please!';
}
if (!error && cache) {
fileCache[path] = content;
}
}
callback(error, content);
}
var loader = {
load: function(tpl, callback) {
var template = tpl.root,
path = tpl.name,
rootConfig = template.config,
extname = rootConfig.extname,
pathExtName;
if (endsWith(path, extname)) {
pathExtName = extname;
} else {
pathExtName = Path.extname(path);
if (!pathExtName) {
pathExtName = extname;
path += pathExtName;
}
}
if (pathExtName !== extname) {
readFile(path, rootConfig, callback);
} else {
getTplFn(template, path, rootConfig, callback);
}
}
};
function renderFile(path, options, callback) {
if (typeof options === 'function') {
callback = options;
options = { };
}
render(path, options, {
cache: options.cache,
commands: options.commands,
encoding: options.settings && options.settings['view encoding']
}, callback);
}
function getOption(options, name) {
return options[name] === undefined ? globalConfig[name] : options[name];
}
function render(path, data, options, callback) {
options = options || { };
var extname;
if (options.extname) {
extname = options.extname.charAt(0) === '.' ?
options.extname :
'.' + options.extname;
} else {
extname = Path.extname(path);
}
path = normalizeSlash(path);
var engine = getInstance({
name: path,
extname: extname,
loader: loader,
strict: getOption(options, 'strict'),
catchError: getOption(options, 'catchError'),
cache: getOption(options, 'cache'),
encoding: getOption(options, 'encoding')
});
// runtime commands
engine.render(data, {commands: options.commands}, function(e, content) {
if (e) {
callback(e);
return;
}
callback(e, content);
});
}
/**
* load xtemplate from file on nodejs
* @singleton
*/
module.exports = {
config: function(options) {
if (!options) {
return globalConfig;
} else {
mix(globalConfig, options);
}
},
__express: renderFile,
render: render,
renderFile: renderFile,
readFile: function(path, config, callback) {
var extname = config.extname;
if (!endsWith(path, extname)) {
path += extname;
}
readFile(path, config, callback);
},
getCaches: function() {
return {
instance: instanceCache,
file: fileCache,
fn: fnCache
};
},
getCache: function(path) {
return {
instance: instanceCache[path],
file: fileCache[path],
fn: fnCache[path]
};
},
clearCache: function(path) {
delete instanceCache[path];
delete fileCache[path];
delete fnCache[path];
}
};
Object.defineProperties(module.exports, {
XTemplate: {
get: function() {
return globalConfig.XTemplate;
}
}
});
|
"use strict";
/**
* (例)
* 文字列 `name` の前に `Hello`を足して返す関数。
*/
function greeting(name) {
return "Hello," + name + "さん";
}
console.log(greeting("田中")); // Hello,田中さん
/**
* (問題 1)
* 数値 `a` と `b` を 乗算(掛け算)して返す関数を定義しよう。
* 関数名 `multiplied`
*/
/**
* (問題 2)
* `document.write()` を使って
* HTMLに 引数 `message` を表示させる関数を定義しよう
*/
|
var xrfdc__sinit_8c =
[
[ "XRFdc_GetDeviceNameByDeviceId", "xrfdc__sinit_8c.html#ga3b6aecbcc131129fb569f90b76afa28c", null ],
[ "XRFdc_LookupConfig", "xrfdc__sinit_8c.html#ga80407a3a6737440fa38fc79eee240ad2", null ]
];
|
console.log('+ + + plugins/mapbox... ')
import Vue from 'vue';
import {
MglMap,
MglMarker,
MglPopup,
MglGeolocateControl,
MglNavigationControl,
MglScaleControl,
MglGeojsonLayer,
} from 'vue-mapbox';
import Mapbox from 'mapbox-gl';
Vue.component('MglMap', MglMap);
Vue.component('MglMarker', MglMarker);
Vue.component('MglPopup', MglPopup);
Vue.component('MglGeolocateControl', MglGeolocateControl);
Vue.component('MglNavigationControl', MglNavigationControl);
Vue.component('MglScaleControl', MglScaleControl);
Vue.component('MglGeojsonLayer', MglGeojsonLayer);
Vue.prototype.$mapbox = Mapbox;
import axios from 'axios'
// - - - SOURCES - - - //
// GEOJSON DATA
export function getStyleJSON (styleURL) {
console.log("+ + + getStyleJSON ... styleURL : ", styleURL)
// fetch(styleURL)
// .then(response => {
// console.log("+ + + getStyleJSON / FETCH / response : ", response)
// }
// )
// .then(response => response.json() )
let head = {
headers: {
// 'Access-Control-Allow-Origin': '*',
// 'accept' : 'application/json',
// 'credentials': false
}
}
axios.get(styleURL, head)
.then( (response) => {
console.log("+ + + getStyleJSON / AXIOS / response : ", response);
})
.catch( (error) => {
console.log("+ + + getStyleJSON / AXIOS / error : ", error)
} )
}
// GEOJSON SOURCE
export function createGeoJSONSource (geoJSON, vars) {
console.log("+ + + createGeoJSONSource ... ")
let geoJsonSource = {
// id : 'clusterLayer',
type : 'geojson',
data : geoJSON,
cluster : vars.isCluster,
clusterMaxZoom : vars.clusterMaxZoom,
clusterRadius : vars.clusterRadius,
}
return geoJsonSource
}
// - - - LAYERS - - - //
// GEOJSON LAYERS - CLUSTER CIRCLES
export function createClusterCirclesLayer (sourceId, vars, layerId="clusters") {
let layerConfig = {
id : layerId,
type : "circle",
source : sourceId,
filter : ["has", "point_count"],
paint : {
// Use step expressions (https://docs.mapbox.com/mapbox-gl-js/style-spec/#expressions-step)
// with three steps to implement three types of circles:
// * Blue, 20px circles when point count is less than 100
// * Yellow, 30px circles when point count is between 100 and 750
// * Pink, 40px circles when point count is greater than or equal to 750
"circle-stroke-width": vars.circle_stroke_width,
"circle-stroke-color": vars.circle_stroke_color,
// "circle-color": [
// "step",
// ["get", "point_count"],
// // "#51bbd6",
// // 100, "#f1f075",
// // 750,"#f28cb1"
// "#a174ac",
// 100, "#90689a",
// 250, "#805c89",
// 500, "#705178",
// 750, "#503a56",
// ],
"circle-color": [
"step",
["get", "point_count"],
vars.circle_color,
100, vars.circle_color_100,
250, vars.circle_color_250,
500, vars.circle_color_500,
750, vars.circle_color_750
],
// "circle-radius": [
// "step",
// ["get", "point_count"],
// 20,
// 100, 20,
// 250, 30,
// 500, 40,
// 750, 50
// ],
"circle-radius": [
"step",
["get", "point_count"],
vars.circle_radius,
100, vars.circle_radius_100,
250, vars.circle_radius_250,
500, vars.circle_radius_500,
750, vars.circle_radius_750
]
},
layout : {
visibility : vars.is_default_visible ? 'visible' : 'none',
}
}
return layerConfig
}
// GEOJSON LAYERS - CLUSTER COUNTS
export function createClusterCountLayer (sourceId, vars, layerId="cluster-counts") {
let layerConfig = {
id: layerId,
type: "symbol",
source: sourceId,
filter: ["has", "point_count"],
layout: {
'visibility': vars.is_default_visible ? 'visible' : 'none',
"text-field": "{point_count_abbreviated}",
"text-font": ["Open Sans Bold"], // OK
// "text-font": ["Open Sans Regular"], // OK
// "text-font": ["Roboto Regular"], // not working
"text-size": vars.text_size
},
paint: {
"text-color": vars.text_color
},
}
return layerConfig
}
// GEOJSON LAYERS - UNCLUSTERED CIRCLES
export function createClusterUnclusteredLayer (sourceId, vars, layerId="unclustered-point") {
let layerConfig = {
id: layerId,
type: "circle",
source: sourceId,
filter: ["!", ["has", "point_count"]],
paint: {
"circle-color": vars.circle_color,
"circle-radius": vars.circle_radius,
"circle-stroke-color": vars.circle_stroke_color,
"circle-stroke-width": vars.circle_stroke_width,
},
layout : {
'visibility': vars.is_default_visible ? 'visible' : 'none',
}
}
return layerConfig
}
// GEOJSON LAYERS - ALL POINTS CIRCLES
export function createAllPoints (sourceId, vars, layerId="all-points") {
var layerConfig = {
"id": layerId,
"type": "circle",
"source": sourceId,
"filter": ["==", "$type", "Point"],
"paint": {
"circle-stroke-width": [
"interpolate",
["linear"],
["zoom"],
9, 0,
vars.max_zoom, 1
],
"circle-stroke-color": vars.circle_stroke_color,
"circle-color": vars.circle_color,
"circle-opacity": vars.circle_opacity,
"circle-radius": [
"interpolate",
["linear"],
["zoom"],
vars.min_zoom, vars.radius_min,
vars.max_zoom, vars.radius_max
],
},
"layout" : {
'visibility': vars.is_default_visible ? 'visible' : 'none',
}
}
return layerConfig
}
// GEOJSON LAYERS - HEATMAP
export function createHeatmapLayer (sourceId, vars, layerId="heatmap-layer") {
// cf : https://docs.mapbox.com/help/tutorials/make-a-heatmap-with-mapbox-gl-js/
let layerConfig = {
id : layerId,
type : "heatmap",
source : sourceId,
maxzoom : vars.max_zoom,
paint : {
// Increase the heatmap weight based on frequency and property magnitude
"heatmap-weight": [
"interpolate",
["linear"],
["get", vars.prop_weight],
0, 0,
0.1, 1
],
// Increase the heatmap color weight weight by zoom level
// heatmap-intensity is a multiplier on top of heatmap-weight
"heatmap-intensity": [
"interpolate",
["linear"],
["zoom"],
0, 0.1,
vars.max_zoom, 1.5
],
// Color ramp for heatmap. Domain is 0 (low) to 1 (high).
// Begin color ramp at 0-stop with a 0-transparancy color
// to create a blur-like effect.
"heatmap-color": [
"interpolate",
["linear"],
["heatmap-density"],
0, "rgba(33,102,172,0)",
0.2, "rgb(103,169,207)",
0.4, "rgb(209,229,240)",
0.6, "rgb(253,219,199)",
0.8, "rgb(239,138,98)",
1, "rgb(178,24,43)"
],
// Adjust the heatmap radius by zoom level
"heatmap-radius": [
"interpolate",
["linear"],
["zoom"],
vars.radius_min, vars.radius_max,
vars.max_zoom, 100
],
// Transition from heatmap to circle layer by zoom level
"heatmap-opacity": [
"interpolate",
["linear"],
["zoom"],
6, 0.7,
vars.max_zoom, 0.1
],
},
layout : {
'visibility': vars.is_default_visible ? 'visible' : 'none',
}
}
return layerConfig
}
// GEOJSON LAYERS - CHOROPLETH
// cf : https://docs.mapbox.com/mapbox-gl-js/example/data-join/
// cf :
export function createChoroplethLayer(sourceId, vars, layerId="choropleth") {
let layerConfig = {
id : layerId,
type : "fill",
source : sourceId,
maxzoom: vars.max_zoom,
minzoom: vars.min_zoom,
// "source-layer": sourceId,
paint: {
// cf : https://docs.mapbox.com/mapbox-gl-js/style-spec/#layer-paint
"fill-color" : vars.fill_color,
// 'fill-color': [
// 'interpolate',
// ['linear'],
// ['get', vars.agregated_data_field ],
// 0, vars.fill_color,
// 1, '#EED322',
// 3, '#E6B71E',
// 5, '#DA9C20',
// 10, '#CA8323',
// 20, '#B86B25',
// 30, '#A25626',
// 40, '#8B4225',
// 50, '#723122'
// ],
"fill-opacity" : vars.fill_opacity, // 0.5,
"fill-outline-color" : vars.fill_outline_color, // "rgb(256,256,256)",
},
layout : {
'visibility': vars.is_default_visible ? 'visible' : 'none',
}
}
return layerConfig
}
// mapbox actions
|
/**
* Copyright IBM Corp. 2019, 2020
*
* This source code is licensed under the Apache-2.0 license found in the
* LICENSE file in the root directory of this source tree.
*
* Code generated by @carbon/icon-build-helpers. DO NOT EDIT.
*/
import { _ as _objectWithoutProperties, I as Icon, a as _extends } from '../../Icon-63ed8f4f.js';
import '@carbon/icon-helpers';
import 'prop-types';
import React from 'react';
var _ref2 =
/*#__PURE__*/
/*#__PURE__*/
React.createElement("path", {
d: "M16,30A14,14,0,1,1,30,16,14.0158,14.0158,0,0,1,16,30ZM16,4A12,12,0,1,0,28,16,12.0137,12.0137,0,0,0,16,4Z"
});
var _ref3 =
/*#__PURE__*/
/*#__PURE__*/
React.createElement("path", {
d: "M15 7H17V14H15zM7 15H14V17H7zM15 18H17V25H15zM18 15H25V17H18z"
});
var WatsonHealth3DCursorAlt24 = /*#__PURE__*/React.forwardRef(function WatsonHealth3DCursorAlt24(_ref, ref) {
var children = _ref.children,
rest = _objectWithoutProperties(_ref, ["children"]);
return /*#__PURE__*/React.createElement(Icon, _extends({
width: 24,
height: 24,
viewBox: "0 0 32 32",
xmlns: "http://www.w3.org/2000/svg",
fill: "currentColor",
ref: ref
}, rest), _ref2, _ref3, children);
});
export default WatsonHealth3DCursorAlt24;
|
var searchData=
[
['profiler',['Profiler',['../class_utility_1_1_profiler.html',1,'Utility']]],
['protocol',['Protocol',['../class_p_l_e_n2_1_1_protocol.html',1,'PLEN2']]]
];
|
export default [
{ freq: 32, type: 'lowshelf', label: '32' },
{ freq: 64, type: 'peaking', label: '64' },
{ freq: 125, type: 'peaking', label: '125' },
{ freq: 250, type: 'peaking', label: '250' },
{ freq: 500, type: 'peaking', label: '500' },
{ freq: 1000, type: 'peaking', label: '1K' },
{ freq: 2000, type: 'peaking', label: '2K' },
{ freq: 4000, type: 'peaking', label: '4K' },
{ freq: 8000, type: 'peaking', label: '8K' },
{ freq: 16000, type: 'highshelf', label: '16K' },
];
|
const router = require('express').Router();
const withAuth = require('../../utils/auth');
const { Post } = require('../../models');
// Allows user to create a post
router.post('/', withAuth, async (req, res) => {
const body = req.body
try {
const newPost = await Post.create({ ...body, user_id: req.session.userId})
res.json(newPost)
} catch (err) {
res.status(500).json(err)
}
})
// Handles specific posts
router.put('/:id', withAuth, async (req, res) => {
try {
const [affectedRows] = await Post.update(req.body, {
where: {
id: req.params.id
}
})
if (affectedRows < 0){
res.status(200).end()
} else {
res.status(404).end()
}
} catch (err) {
res.status(500).json(err)
}
})
// Handles deleting a post by a user
router.delete('/:id', withAuth, async (req, res) => {
try {
const [affectedRows] = Post.destroy({
where: {
id: req.params.id
}
})
if (affectedRows > 0){
res.status(200).end()
} else {
res.status(404).end()
}
} catch (err) {
res.status(500).json(err)
}
})
module.exports = router
|
const express = require('express');
const expressServer = express();
const httpServer = require('http').Server(expressServer);
const io = require('socket.io')(httpServer);
httpServer.listen(1191, '0.0.0.0', function () {
console.log("listening");
});
expressServer.use(express.static('frontend'));
function clamp(value, min, max) {
if (value < min) return min;
if (value > max) return max;
return value;
}
class Vector {
constructor(x, y) {
this.x = x || 0;
this.y = y || 0;
}
add(x, y) {
return new Vector(this.x + x, this.y + y);
}
}
class Client {
constructor(socket) {
this.id = socket.id;
this.socket = socket;
this.location = new Vector(0, 0);
this.sharingScreen = false;
}
send(type, data) {
this.socket.emit(type, data);
}
toDto() {
return {
id: this.id,
location: this.location,
sharingScreen: this.sharingScreen
};
}
}
class Room {
constructor(id) {
this.roomId = id;
this.width = 3000;
this.height = 3000;
this.clients = {};
}
addClient(id, socket) {
const client = new Client(socket);
this.clients[id] = client;
client.send('init', {
roomId: this.roomId,
id: id,
width: this.width,
height: this.height,
clients: this.clientsDto()
});
this.moveClient(client, this.randomLocation());
socket.on('clientTeleport', data => {
this.moveClient(client, new Vector(data.x, data.y));
});
socket.on('clientScreenshare', ({sharingScreen}) => {
client.sharingScreen = sharingScreen;
this.broadcastUpdate(client);
});
socket.on('relayCandidate', ({to, connectionId, candidate}) => {
const toClient = this.clients[to];
if (toClient) toClient.send('relayCandidate', {
from: id,
candidate: candidate,
connectionId: connectionId
});
});
socket.on('video-offer', (message) => {
const {from, to, connectionId, description} = message;
const toClient = this.clients[to];
if (toClient) toClient.send('video-offer', message);
});
socket.on('video-answer', (message) => {
const {from, to, connectionId, description} = message;
const toClient = this.clients[to];
if (toClient) toClient.send('video-answer', message);
});
}
removeClient(id) {
delete this.clients[id];
this.broadcast('removeClient', id);
}
moveClient(client, location) {
location.x = clamp(location.x, 0, this.width);
location.y = clamp(location.y, 0, this.height);
client.location = location;
this.broadcastUpdate(client);
}
broadcastUpdate(client) {
this.broadcast('updateClient', client.toDto());
}
broadcast(type, data) {
Object.values(this.clients).forEach(client => client.send(type, data));
}
randomLocation() {
return new Vector(Math.random() * this.width, Math.random() * 700);
}
clientsDto() {
return Object.values(this.clients).map(client => client.toDto());
}
}
const rooms = {};
function getRoomId(str) {
const defaultRoomId = 'default';
try {
return new URL(str).searchParams.get('roomId') || defaultRoomId;
} catch (e) {
console.error(e);
return defaultRoomId;
}
}
function getRoom(id) {
let room = rooms[id];
if (!room) {
room = new Room(id);
rooms[id] = room;
}
return room;
}
function cleanupRoom(room) {
if (Object.keys(room.clients).length === 0) {
delete rooms[room.roomId];
}
}
io.on('connection', function (socket) {
const roomId = getRoomId(socket.handshake.headers.referer);
const room = getRoom(roomId);
console.log(`Connection ${socket.id} to room '${roomId}', total in room: ${Object.keys(room.clients).length + 1}`);
room.addClient(socket.id, socket);
socket.on('disconnect', function () {
room.removeClient(socket.id);
console.log(`Disconnect ${socket.id} from room '${roomId}', total in room: ${Object.keys(room.clients).length}`);
cleanupRoom(room);
});
});
|
/*global define*/
'use strict';
define(['angular', 'app'], function (angular, app) {
return app.controller("InventoryController", ['$scope', '$routeParams', function($scope, $routeParams) {
$scope.id = $routeParams.id;
}]);
});
|
import reducer from './auth';
import { } from '../actions/actionsTypes';
describe('auth reducer', () => {
it('should return the initial state', () => {
expect(reducer(undefined, {})).toEqual({
token: null,
userId: null,
error: null,
loading: false,
authRedirectPath: '/',
})
})
})
|
!function(e,o,n,t){"use strict";o=void 0!==o&&o.Math==Math?o:"undefined"!=typeof self&&self.Math==Math?self:Function("return this")(),e.fn.embed=function(n){var t,r=e(this),a=r.selector||"",i=(new Date).getTime(),c=[],l=arguments[0],d="string"==typeof l,u=[].slice.call(arguments,1);return r.each(function(){var s,m=e.isPlainObject(n)?e.extend(!0,{},e.fn.embed.settings,n):e.extend({},e.fn.embed.settings),p=m.selector,f=m.className,h=m.sources,b=m.error,v=m.metadata,g=m.namespace,y=m.templates,w="."+g,P="module-"+g,C=(e(o),e(this)),E=C.find(p.placeholder),U=C.find(p.icon),j=C.find(p.embed),S=this,T=C.data(P);s={initialize:function(){s.debug("Initializing embed"),s.determine.autoplay(),s.create(),s.bind.events(),s.instantiate()},instantiate:function(){s.verbose("Storing instance of module",s),T=s,C.data(P,s)},destroy:function(){s.verbose("Destroying previous instance of embed"),s.reset(),C.removeData(P).off(w)},refresh:function(){s.verbose("Refreshing selector cache"),E=C.find(p.placeholder),U=C.find(p.icon),j=C.find(p.embed)},bind:{events:function(){s.has.placeholder()&&(s.debug("Adding placeholder events"),C.on("click"+w,p.placeholder,s.createAndShow).on("click"+w,p.icon,s.createAndShow))}},create:function(){s.get.placeholder()?s.createPlaceholder():s.createAndShow()},createPlaceholder:function(e){var o=s.get.icon(),n=s.get.url();s.generate.embed(n);e=e||s.get.placeholder(),C.html(y.placeholder(e,o)),s.debug("Creating placeholder for embed",e,o)},createEmbed:function(o){s.refresh(),o=o||s.get.url(),j=e("<div/>").addClass(f.embed).html(s.generate.embed(o)).appendTo(C),m.onCreate.call(S,o),s.debug("Creating embed object",j)},changeEmbed:function(e){j.html(s.generate.embed(e))},createAndShow:function(){s.createEmbed(),s.show()},change:function(e,o,n){s.debug("Changing video to ",e,o,n),C.data(v.source,e).data(v.id,o),n?C.data(v.url,n):C.removeData(v.url),s.has.embed()?s.changeEmbed():s.create()},reset:function(){s.debug("Clearing embed and showing placeholder"),s.remove.active(),s.remove.embed(),s.showPlaceholder(),m.onReset.call(S)},show:function(){s.debug("Showing embed"),s.set.active(),m.onDisplay.call(S)},hide:function(){s.debug("Hiding embed"),s.showPlaceholder()},showPlaceholder:function(){s.debug("Showing placeholder image"),s.remove.active(),m.onPlaceholderDisplay.call(S)},get:{id:function(){return m.id||C.data(v.id)},placeholder:function(){return m.placeholder||C.data(v.placeholder)},icon:function(){return m.icon?m.icon:void 0!==C.data(v.icon)?C.data(v.icon):s.determine.icon()},source:function(e){return m.source?m.source:void 0!==C.data(v.source)?C.data(v.source):s.determine.source()},type:function(){var e=s.get.source();return void 0!==h[e]&&h[e].type},url:function(){return m.url?m.url:void 0!==C.data(v.url)?C.data(v.url):s.determine.url()}},determine:{autoplay:function(){s.should.autoplay()&&(m.autoplay=!0)},source:function(o){var n=!1;return o=o||s.get.url(),o&&e.each(h,function(e,t){if(-1!==o.search(t.domain))return n=e,!1}),n},icon:function(){var e=s.get.source();return void 0!==h[e]&&h[e].icon},url:function(){var e,o=m.id||C.data(v.id),n=m.source||C.data(v.source);return e=void 0!==h[n]&&h[n].url.replace("{id}",o),e&&C.data(v.url,e),e}},set:{active:function(){C.addClass(f.active)}},remove:{active:function(){C.removeClass(f.active)},embed:function(){j.empty()}},encode:{parameters:function(e){var o,n=[];for(o in e)n.push(encodeURIComponent(o)+"="+encodeURIComponent(e[o]));return n.join("&")}},generate:{embed:function(e){s.debug("Generating embed html");var o,n,t=s.get.source();return e=s.get.url(e),e?(n=s.generate.parameters(t),o=y.iframe(e,n)):s.error(b.noURL,C),o},parameters:function(o,n){var t=h[o]&&void 0!==h[o].parameters?h[o].parameters(m):{};return n=n||m.parameters,n&&(t=e.extend({},t,n)),t=m.onEmbed(t),s.encode.parameters(t)}},has:{embed:function(){return j.length>0},placeholder:function(){return m.placeholder||C.data(v.placeholder)}},should:{autoplay:function(){return"auto"===m.autoplay?m.placeholder||void 0!==C.data(v.placeholder):m.autoplay}},is:{video:function(){return"video"==s.get.type()}},setting:function(o,n){if(s.debug("Changing setting",o,n),e.isPlainObject(o))e.extend(!0,m,o);else{if(void 0===n)return m[o];e.isPlainObject(m[o])?e.extend(!0,m[o],n):m[o]=n}},internal:function(o,n){if(e.isPlainObject(o))e.extend(!0,s,o);else{if(void 0===n)return s[o];s[o]=n}},debug:function(){!m.silent&&m.debug&&(m.performance?s.performance.log(arguments):(s.debug=Function.prototype.bind.call(console.info,console,m.name+":"),s.debug.apply(console,arguments)))},verbose:function(){!m.silent&&m.verbose&&m.debug&&(m.performance?s.performance.log(arguments):(s.verbose=Function.prototype.bind.call(console.info,console,m.name+":"),s.verbose.apply(console,arguments)))},error:function(){m.silent||(s.error=Function.prototype.bind.call(console.error,console,m.name+":"),s.error.apply(console,arguments))},performance:{log:function(e){var o,n,t;m.performance&&(o=(new Date).getTime(),t=i||o,n=o-t,i=o,c.push({Name:e[0],Arguments:[].slice.call(e,1)||"",Element:S,"Execution Time":n})),clearTimeout(s.performance.timer),s.performance.timer=setTimeout(s.performance.display,500)},display:function(){var o=m.name+":",n=0;i=!1,clearTimeout(s.performance.timer),e.each(c,function(e,o){n+=o["Execution Time"]}),o+=" "+n+"ms",a&&(o+=" '"+a+"'"),r.length>1&&(o+=" ("+r.length+")"),(void 0!==console.group||void 0!==console.table)&&c.length>0&&(console.groupCollapsed(o),console.table?console.table(c):e.each(c,function(e,o){console.log(o.Name+": "+o["Execution Time"]+"ms")}),console.groupEnd()),c=[]}},invoke:function(o,n,r){var a,i,c,l=T;return n=n||u,r=S||r,"string"==typeof o&&void 0!==l&&(o=o.split(/[\. ]/),a=o.length-1,e.each(o,function(n,t){var r=n!=a?t+o[n+1].charAt(0).toUpperCase()+o[n+1].slice(1):o;if(e.isPlainObject(l[r])&&n!=a)l=l[r];else{if(void 0!==l[r])return i=l[r],!1;if(!e.isPlainObject(l[t])||n==a)return void 0!==l[t]?(i=l[t],!1):(s.error(b.method,o),!1);l=l[t]}})),e.isFunction(i)?c=i.apply(r,n):void 0!==i&&(c=i),e.isArray(t)?t.push(c):void 0!==t?t=[t,c]:void 0!==c&&(t=c),i}},d?(void 0===T&&s.initialize(),s.invoke(l)):(void 0!==T&&T.invoke("destroy"),s.initialize())}),void 0!==t?t:this},e.fn.embed.settings={name:"Embed",namespace:"embed",silent:!1,debug:!1,verbose:!1,performance:!0,icon:!1,source:!1,url:!1,id:!1,autoplay:"auto",color:"#444444",hd:!0,brandedUI:!1,parameters:!1,onDisplay:function(){},onPlaceholderDisplay:function(){},onReset:function(){},onCreate:function(e){},onEmbed:function(e){return e},metadata:{id:"id",icon:"icon",placeholder:"placeholder",source:"source",url:"url"},error:{noURL:"No URL specified",method:"The method you called is not defined"},className:{active:"active",embed:"embed"},selector:{embed:".embed",placeholder:".placeholder",icon:".icon"},sources:{youtube:{name:"youtube",type:"video",icon:"video play",domain:"youtube.com",url:"//www.youtube.com/embed/{id}",parameters:function(e){return{autohide:!e.brandedUI,autoplay:e.autoplay,color:e.color||void 0,hq:e.hd,jsapi:e.api,modestbranding:!e.brandedUI}}},vimeo:{name:"vimeo",type:"video",icon:"video play",domain:"vimeo.com",url:"//player.vimeo.com/video/{id}",parameters:function(e){return{api:e.api,autoplay:e.autoplay,byline:e.brandedUI,color:e.color||void 0,portrait:e.brandedUI,title:e.brandedUI}}}},templates:{iframe:function(e,o){var n=e;return o&&(n+="?"+o),'<iframe src="'+n+'" width="100%" height="100%" frameborder="0" scrolling="no" webkitAllowFullScreen mozallowfullscreen allowFullScreen></iframe>'},placeholder:function(e,o){var n="";return o&&(n+='<i class="'+o+' icon"></i>'),e&&(n+='<img class="placeholder" src="'+e+'">'),n}},api:!1,onPause:function(){},onPlay:function(){},onStop:function(){}}}(jQuery,window,document);
|
/* peters.js
*/
var agencia = window.agencia || {};
agencia.viajes = (function() {
var base_url = "http://localhost:8888/agencia/";
return {
obtener_form_contacto: function(){
$(document).ready(function() {
$('#contenido').load(base_url+'/index.php/contacto/obtenerFormulario');
});
},
agregar_item: function(){
$(document).on('click', '#ordenar-platillo', function(e) {
$.ajax({
type : 'POST',
dataType: 'text',
data: $('#form-item').serialize(),
url: base_url+'index.php/carrito/agregar',
success : function(response){
//alert(response.nombre);
//$('#myTab a:last').tab('show');
//$('#det-pedido').tab('show');
//$('#detalle-pedido').load(base_url+'index.php/menu/verPedido');
},
error: function (request, status, error) {
alert(request.responseText);
alert('Error');
}
});
//$('#detalle-pedido').tab('show');
//$('.nav-tabs a[href="#detalle-pedido"]').tab('show');
//e.preventDefault();
});
},
validar_formulario: function() {
$(document).ready(function() {
$('.form-validacion').bootstrapValidator({
message: 'This value is not valid',
errors: {
require: 'Este valor es requerido',
match: 'Does not match',
minlength: 'Not long enough',
},
feedbackIcons: {
valid: 'glyphicon glyphicon-ok',
invalid: 'glyphicon glyphicon-remove',
validating: 'glyphicon glyphicon-refresh',
}
});
});
},
formato_tabla: function() {
$(document).ready(function() {
$('.tbl-datatable').DataTable({
pagingType: "bootstrapPager",
pagerSettings: {
searchOnEnter: true
},language: {
"sProcessing": "Procesando...",
"sLengthMenu": "Mostrar _MENU_ registros",
"sZeroRecords": "No se encontraron resultados",
"sEmptyTable": "Ningún dato disponible en esta tabla",
"sInfo": "Mostrando registros del _START_ al _END_ de un total de _TOTAL_ registros",
"sInfoEmpty": "Mostrando registros del 0 al 0 de un total de 0 registros",
"sInfoFiltered": "(filtrado de un total de _MAX_ registros)",
"sInfoPostFix": "",
"sSearch": "Buscar:",
"sUrl": "",
"sInfoThousands": ",",
"sLoadingRecords": "Cargando...",
"oPaginate": {
"sFirst": "Primero",
"sLast": "Último",
"sNext": "Siguiente",
"sPrevious": "Anterior"
},
"oAria": {
"sSortAscending": ": Activar para ordenar la columna de manera ascendente",
"sSortDescending": ": Activar para ordenar la columna de manera descendente"
}
}
});
});
},
}
})();
|
'use strict'
var userConfs;
// pass the settings here
// userConfs = {
// images : ['image1.jpg','image2.jpg','image3.jpg','image4.jpg','image5.jpg'],
// slideInterval : 3000,
// startSlideInterval : 1000,
// folderPath : 'images/'
// }
// userConfs = {
// images : ['image6.jpg','image2.jpg','image7.jpg','image8.jpg','image5.jpg'],
// slideInterval : 2000,
// startSlideInterval : 5000,
// folderPath : 'images/'
// }
|
import ManageContentButton from './ManageContentButton';
export default ManageContentButton;
|
'use strict';
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
//! annyang
//! version : 2.6.0
//! author : Tal Ater @TalAter
//! license : MIT
//! https://www.TalAter.com/annyang/
(function (root, factory) {
'use strict';
if (typeof define === 'function' && define.amd) {
// AMD + global
define([], function () {
return root.annyang = factory(root);
});
} else if ((typeof module === 'undefined' ? 'undefined' : _typeof(module)) === 'object' && module.exports) {
// CommonJS
module.exports = factory(root);
} else {
// Browser globals
root.annyang = factory(root);
}
})(typeof window !== 'undefined' ? window : undefined, function (root, undefined) {
'use strict';
/**
* # Quick Tutorial, Intro and Demos
*
* The quickest way to get started is to visit the [annyang homepage](https://www.talater.com/annyang/).
*
* For a more in-depth look at annyang, read on.
*
* # API Reference
*/
var annyang;
// Get the SpeechRecognition object, while handling browser prefixes
var SpeechRecognition = root.SpeechRecognition || root.webkitSpeechRecognition || root.mozSpeechRecognition || root.msSpeechRecognition || root.oSpeechRecognition;
// Check browser support
// This is done as early as possible, to make it as fast as possible for unsupported browsers
if (!SpeechRecognition) {
return null;
}
var commandsList = [];
var recognition;
var callbacks = { start: [], error: [], end: [], soundstart: [], result: [], resultMatch: [], resultNoMatch: [], errorNetwork: [], errorPermissionBlocked: [], errorPermissionDenied: [] };
var autoRestart;
var lastStartedAt = 0;
var autoRestartCount = 0;
var debugState = true;
var debugStyle = 'font-weight: bold; color: #f00;';
var pauseListening = false;
var _isListening = false;
// The command matching code is a modified version of Backbone.Router by Jeremy Ashkenas, under the MIT license.
var optionalParam = /\s*\((.*?)\)\s*/g;
var optionalRegex = /(\(\?:[^)]+\))\?/g;
var namedParam = /(\(\?)?:\w+/g;
var splatParam = /\*\w+/g;
var escapeRegExp = /[\-{}\[\]+?.,\\\^$|#]/g;
var commandToRegExp = function commandToRegExp(command) {
command = command.replace(escapeRegExp, '\\$&').replace(optionalParam, '(?:$1)?').replace(namedParam, function (match, optional) {
return optional ? match : '([^\\s]+)';
}).replace(splatParam, '(.*?)').replace(optionalRegex, '\\s*$1?\\s*');
return new RegExp('^' + command + '$', 'i');
};
// This method receives an array of callbacks to iterate over, and invokes each of them
var invokeCallbacks = function invokeCallbacks(callbacks) {
for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
args[_key - 1] = arguments[_key];
}
callbacks.forEach(function (callback) {
callback.callback.apply(callback.context, args);
});
};
var isInitialized = function isInitialized() {
return recognition !== undefined;
};
// method for logging in developer console when debug mode is on
var logMessage = function logMessage(text, extraParameters) {
if (text.indexOf('%c') === -1 && !extraParameters) {
console.log(text);
} else {
console.log(text, extraParameters || debugStyle);
}
};
var initIfNeeded = function initIfNeeded() {
if (!isInitialized()) {
annyang.init({}, false);
}
};
var registerCommand = function registerCommand(command, callback, originalPhrase) {
commandsList.push({ command: command, callback: callback, originalPhrase: originalPhrase });
if (debugState) {
logMessage('Command successfully loaded: %c' + originalPhrase, debugStyle);
}
};
var parseResults = function parseResults(results) {
invokeCallbacks(callbacks.result, results);
var commandText;
// go over each of the 5 results and alternative results received (we've set maxAlternatives to 5 above)
for (var i = 0; i < results.length; i++) {
// the text recognized
commandText = results[i].trim();
if (debugState) {
logMessage('Speech recognized: %c' + commandText, debugStyle);
}
// try and match recognized text to one of the commands on the list
for (var j = 0, l = commandsList.length; j < l; j++) {
var currentCommand = commandsList[j];
var result = currentCommand.command.exec(commandText);
if (result) {
var parameters = result.slice(1);
if (debugState) {
logMessage('command matched: %c' + currentCommand.originalPhrase, debugStyle);
if (parameters.length) {
logMessage('with parameters', parameters);
}
}
// execute the matched command
currentCommand.callback.apply(this, parameters);
invokeCallbacks(callbacks.resultMatch, commandText, currentCommand.originalPhrase, results);
return;
}
}
}
invokeCallbacks(callbacks.resultNoMatch, results);
};
annyang = {
/**
* Initialize annyang with a list of commands to recognize.
*
* #### Examples:
* ````javascript
* var commands = {'hello :name': helloFunction};
* var commands2 = {'hi': helloFunction};
*
* // initialize annyang, overwriting any previously added commands
* annyang.init(commands, true);
* // adds an additional command without removing the previous commands
* annyang.init(commands2, false);
* ````
* As of v1.1.0 it is no longer required to call init(). Just start() listening whenever you want, and addCommands() whenever, and as often as you like.
*
* @param {Object} commands - Commands that annyang should listen to
* @param {boolean} [resetCommands=true] - Remove all commands before initializing?
* @method init
* @deprecated
* @see [Commands Object](#commands-object)
*/
init: function init(commands) {
var resetCommands = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
// Abort previous instances of recognition already running
if (recognition && recognition.abort) {
recognition.abort();
}
// initiate SpeechRecognition
recognition = new SpeechRecognition();
// Set the max number of alternative transcripts to try and match with a command
recognition.maxAlternatives = 5;
// In HTTPS, turn off continuous mode for faster results.
// In HTTP, turn on continuous mode for much slower results, but no repeating security notices
recognition.continuous = root.location.protocol === 'http:';
// Sets the language to the default 'en-US'. This can be changed with annyang.setLanguage()
recognition.lang = 'en-US';
recognition.onstart = function () {
_isListening = true;
invokeCallbacks(callbacks.start);
};
recognition.onsoundstart = function () {
invokeCallbacks(callbacks.soundstart);
};
recognition.onerror = function (event) {
invokeCallbacks(callbacks.error, event);
switch (event.error) {
case 'network':
invokeCallbacks(callbacks.errorNetwork, event);
break;
case 'not-allowed':
case 'service-not-allowed':
// if permission to use the mic is denied, turn off auto-restart
autoRestart = false;
// determine if permission was denied by user or automatically.
if (new Date().getTime() - lastStartedAt < 200) {
invokeCallbacks(callbacks.errorPermissionBlocked, event);
} else {
invokeCallbacks(callbacks.errorPermissionDenied, event);
}
break;
}
};
recognition.onend = function () {
_isListening = false;
invokeCallbacks(callbacks.end);
// annyang will auto restart if it is closed automatically and not by user action.
if (autoRestart) {
// play nicely with the browser, and never restart annyang automatically more than once per second
var timeSinceLastStart = new Date().getTime() - lastStartedAt;
autoRestartCount += 1;
if (autoRestartCount % 10 === 0) {
if (debugState) {
logMessage('Speech Recognition is repeatedly stopping and starting. See http://is.gd/annyang_restarts for tips.');
}
}
if (timeSinceLastStart < 1000) {
setTimeout(function () {
annyang.start({ paused: pauseListening });
}, 1000 - timeSinceLastStart);
} else {
annyang.start({ paused: pauseListening });
}
}
};
recognition.onresult = function (event) {
if (pauseListening) {
if (debugState) {
logMessage('Speech heard, but annyang is paused');
}
return false;
}
// Map the results to an array
var SpeechRecognitionResult = event.results[event.resultIndex];
var results = [];
for (var k = 0; k < SpeechRecognitionResult.length; k++) {
results[k] = SpeechRecognitionResult[k].transcript;
}
parseResults(results);
};
// build commands list
if (resetCommands) {
commandsList = [];
}
if (commands.length) {
this.addCommands(commands);
}
},
/**
* Start listening.
* It's a good idea to call this after adding some commands first, but not mandatory.
*
* Receives an optional options object which supports the following options:
*
* - `autoRestart` (boolean, default: true) Should annyang restart itself if it is closed indirectly, because of silence or window conflicts?
* - `continuous` (boolean) Allow forcing continuous mode on or off. Annyang is pretty smart about this, so only set this if you know what you're doing.
* - `paused` (boolean, default: true) Start annyang in paused mode.
*
* #### Examples:
* ````javascript
* // Start listening, don't restart automatically
* annyang.start({ autoRestart: false });
* // Start listening, don't restart automatically, stop recognition after first phrase recognized
* annyang.start({ autoRestart: false, continuous: false });
* ````
* @param {Object} [options] - Optional options.
* @method start
*/
start: function start(options) {
initIfNeeded();
options = options || {};
if (options.paused !== undefined) {
pauseListening = !!options.paused;
} else {
pauseListening = false;
}
if (options.autoRestart !== undefined) {
autoRestart = !!options.autoRestart;
} else {
autoRestart = true;
}
if (options.continuous !== undefined) {
recognition.continuous = !!options.continuous;
}
lastStartedAt = new Date().getTime();
try {
recognition.start();
} catch (e) {
if (debugState) {
logMessage(e.message);
}
}
},
/**
* Stop listening, and turn off mic.
*
* Alternatively, to only temporarily pause annyang responding to commands without stopping the SpeechRecognition engine or closing the mic, use pause() instead.
* @see [pause()](#pause)
*
* @method abort
*/
abort: function abort() {
autoRestart = false;
autoRestartCount = 0;
if (isInitialized()) {
recognition.abort();
}
},
/**
* Pause listening. annyang will stop responding to commands (until the resume or start methods are called), without turning off the browser's SpeechRecognition engine or the mic.
*
* Alternatively, to stop the SpeechRecognition engine and close the mic, use abort() instead.
* @see [abort()](#abort)
*
* @method pause
*/
pause: function pause() {
pauseListening = true;
},
/**
* Resumes listening and restores command callback execution when a result matches.
* If SpeechRecognition was aborted (stopped), start it.
*
* @method resume
*/
resume: function resume() {
annyang.start();
},
/**
* Turn on output of debug messages to the console. Ugly, but super-handy!
*
* @param {boolean} [newState=true] - Turn on/off debug messages
* @method debug
*/
debug: function debug() {
var newState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
debugState = !!newState;
},
/**
* Set the language the user will speak in. If this method is not called, defaults to 'en-US'.
*
* @param {String} language - The language (locale)
* @method setLanguage
* @see [Languages](https://github.com/TalAter/annyang/blob/master/docs/FAQ.md#what-languages-are-supported)
*/
setLanguage: function setLanguage(language) {
initIfNeeded();
recognition.lang = language;
},
/**
* Add commands that annyang will respond to. Similar in syntax to init(), but doesn't remove existing commands.
*
* #### Examples:
* ````javascript
* var commands = {'hello :name': helloFunction, 'howdy': helloFunction};
* var commands2 = {'hi': helloFunction};
*
* annyang.addCommands(commands);
* annyang.addCommands(commands2);
* // annyang will now listen to all three commands
* ````
*
* @param {Object} commands - Commands that annyang should listen to
* @method addCommands
* @see [Commands Object](#commands-object)
*/
addCommands: function addCommands(commands) {
var cb;
initIfNeeded();
for (var phrase in commands) {
if (commands.hasOwnProperty(phrase)) {
cb = root[commands[phrase]] || commands[phrase];
if (typeof cb === 'function') {
// convert command to regex then register the command
registerCommand(commandToRegExp(phrase), cb, phrase);
} else if ((typeof cb === 'undefined' ? 'undefined' : _typeof(cb)) === 'object' && cb.regexp instanceof RegExp) {
// register the command
registerCommand(new RegExp(cb.regexp.source, 'i'), cb.callback, phrase);
} else {
if (debugState) {
logMessage('Can not register command: %c' + phrase, debugStyle);
}
continue;
}
}
}
},
/**
* Remove existing commands. Called with a single phrase, array of phrases, or methodically. Pass no params to remove all commands.
*
* #### Examples:
* ````javascript
* var commands = {'hello': helloFunction, 'howdy': helloFunction, 'hi': helloFunction};
*
* // Remove all existing commands
* annyang.removeCommands();
*
* // Add some commands
* annyang.addCommands(commands);
*
* // Don't respond to hello
* annyang.removeCommands('hello');
*
* // Don't respond to howdy or hi
* annyang.removeCommands(['howdy', 'hi']);
* ````
* @param {String|Array|Undefined} [commandsToRemove] - Commands to remove
* @method removeCommands
*/
removeCommands: function removeCommands(commandsToRemove) {
if (commandsToRemove === undefined) {
commandsList = [];
} else {
commandsToRemove = Array.isArray(commandsToRemove) ? commandsToRemove : [commandsToRemove];
commandsList = commandsList.filter(function (command) {
for (var i = 0; i < commandsToRemove.length; i++) {
if (commandsToRemove[i] === command.originalPhrase) {
return false;
}
}
return true;
});
}
},
/**
* Add a callback function to be called in case one of the following events happens:
*
* * `start` - Fired as soon as the browser's Speech Recognition engine starts listening
* * `soundstart` - Fired as soon as any sound (possibly speech) has been detected.
* This will fire once per Speech Recognition starting. See https://is.gd/annyang_sound_start
* * `error` - Fired when the browser's Speech Recogntion engine returns an error, this generic error callback will be followed by more accurate error callbacks (both will fire if both are defined)
* Callback function will be called with the error event as the first argument
* * `errorNetwork` - Fired when Speech Recognition fails because of a network error
* Callback function will be called with the error event as the first argument
* * `errorPermissionBlocked` - Fired when the browser blocks the permission request to use Speech Recognition.
* Callback function will be called with the error event as the first argument
* * `errorPermissionDenied` - Fired when the user blocks the permission request to use Speech Recognition.
* Callback function will be called with the error event as the first argument
* * `end` - Fired when the browser's Speech Recognition engine stops
* * `result` - Fired as soon as some speech was identified. This generic callback will be followed by either the `resultMatch` or `resultNoMatch` callbacks.
* Callback functions for to this event will be called with an array of possible phrases the user said as the first argument
* * `resultMatch` - Fired when annyang was able to match between what the user said and a registered command
* Callback functions for this event will be called with three arguments in the following order:
* * The phrase the user said that matched a command
* * The command that was matched
* * An array of possible alternative phrases the user might have said
* * `resultNoMatch` - Fired when what the user said didn't match any of the registered commands.
* Callback functions for this event will be called with an array of possible phrases the user might've said as the first argument
*
* #### Examples:
* ````javascript
* annyang.addCallback('error', function() {
* $('.myErrorText').text('There was an error!');
* });
*
* annyang.addCallback('resultMatch', function(userSaid, commandText, phrases) {
* console.log(userSaid); // sample output: 'hello'
* console.log(commandText); // sample output: 'hello (there)'
* console.log(phrases); // sample output: ['hello', 'halo', 'yellow', 'polo', 'hello kitty']
* });
*
* // pass local context to a global function called notConnected
* annyang.addCallback('errorNetwork', notConnected, this);
* ````
* @param {String} type - Name of event that will trigger this callback
* @param {Function} callback - The function to call when event is triggered
* @param {Object} [context] - Optional context for the callback function
* @method addCallback
*/
addCallback: function addCallback(type, callback, context) {
var cb = root[callback] || callback;
if (typeof cb === 'function' && callbacks[type] !== undefined) {
callbacks[type].push({ callback: cb, context: context || this });
}
},
/**
* Remove callbacks from events.
*
* - Pass an event name and a callback command to remove that callback command from that event type.
* - Pass just an event name to remove all callback commands from that event type.
* - Pass undefined as event name and a callback command to remove that callback command from all event types.
* - Pass no params to remove all callback commands from all event types.
*
* #### Examples:
* ````javascript
* annyang.addCallback('start', myFunction1);
* annyang.addCallback('start', myFunction2);
* annyang.addCallback('end', myFunction1);
* annyang.addCallback('end', myFunction2);
*
* // Remove all callbacks from all events:
* annyang.removeCallback();
*
* // Remove all callbacks attached to end event:
* annyang.removeCallback('end');
*
* // Remove myFunction2 from being called on start:
* annyang.removeCallback('start', myFunction2);
*
* // Remove myFunction1 from being called on all events:
* annyang.removeCallback(undefined, myFunction1);
* ````
*
* @param type Name of event type to remove callback from
* @param callback The callback function to remove
* @returns undefined
* @method removeCallback
*/
removeCallback: function removeCallback(type, callback) {
var compareWithCallbackParameter = function compareWithCallbackParameter(cb) {
return cb.callback !== callback;
};
// Go over each callback type in callbacks store object
for (var callbackType in callbacks) {
if (callbacks.hasOwnProperty(callbackType)) {
// if this is the type user asked to delete, or he asked to delete all, go ahead.
if (type === undefined || type === callbackType) {
// If user asked to delete all callbacks in this type or all types
if (callback === undefined) {
callbacks[callbackType] = [];
} else {
// Remove all matching callbacks
callbacks[callbackType] = callbacks[callbackType].filter(compareWithCallbackParameter);
}
}
}
}
},
/**
* Returns true if speech recognition is currently on.
* Returns false if speech recognition is off or annyang is paused.
*
* @return boolean true = SpeechRecognition is on and annyang is listening
* @method isListening
*/
isListening: function isListening() {
return _isListening && !pauseListening;
},
/**
* Returns the instance of the browser's SpeechRecognition object used by annyang.
* Useful in case you want direct access to the browser's Speech Recognition engine.
*
* @returns SpeechRecognition The browser's Speech Recognizer currently used by annyang
* @method getSpeechRecognizer
*/
getSpeechRecognizer: function getSpeechRecognizer() {
return recognition;
},
/**
* Simulate speech being recognized. This will trigger the same events and behavior as when the Speech Recognition
* detects speech.
*
* Can accept either a string containing a single sentence, or an array containing multiple sentences to be checked
* in order until one of them matches a command (similar to the way Speech Recognition Alternatives are parsed)
*
* #### Examples:
* ````javascript
* annyang.trigger('Time for some thrilling heroics');
* annyang.trigger(
* ['Time for some thrilling heroics', 'Time for some thrilling aerobics']
* );
* ````
*
* @param string|array sentences A sentence as a string or an array of strings of possible sentences
* @returns undefined
* @method trigger
*/
trigger: function trigger(sentences) {
if (!annyang.isListening()) {
if (debugState) {
if (!_isListening) {
logMessage('Cannot trigger while annyang is aborted');
} else {
logMessage('Speech heard, but annyang is paused');
}
}
return;
}
if (!Array.isArray(sentences)) {
sentences = [sentences];
}
parseResults(sentences);
}
};
return annyang;
});
/**
* # Good to Know
*
* ## Commands Object
*
* Both the [init()]() and addCommands() methods receive a `commands` object.
*
* annyang understands commands with `named variables`, `splats`, and `optional words`.
*
* * Use `named variables` for one word arguments in your command.
* * Use `splats` to capture multi-word text at the end of your command (greedy).
* * Use `optional words` or phrases to define a part of the command as optional.
*
* #### Examples:
* ````html
* <script>
* var commands = {
* // annyang will capture anything after a splat (*) and pass it to the function.
* // e.g. saying "Show me Batman and Robin" will call showFlickr('Batman and Robin');
* 'show me *tag': showFlickr,
*
* // A named variable is a one word variable, that can fit anywhere in your command.
* // e.g. saying "calculate October stats" will call calculateStats('October');
* 'calculate :month stats': calculateStats,
*
* // By defining a part of the following command as optional, annyang will respond
* // to both: "say hello to my little friend" as well as "say hello friend"
* 'say hello (to my little) friend': greeting
* };
*
* var showFlickr = function(tag) {
* var url = 'http://api.flickr.com/services/rest/?tags='+tag;
* $.getJSON(url);
* }
*
* var calculateStats = function(month) {
* $('#stats').text('Statistics for '+month);
* }
*
* var greeting = function() {
* $('#greeting').text('Hello!');
* }
* </script>
* ````
*
* ### Using Regular Expressions in commands
* For advanced commands, you can pass a regular expression object, instead of
* a simple string command.
*
* This is done by passing an object containing two properties: `regexp`, and
* `callback` instead of the function.
*
* #### Examples:
* ````javascript
* var calculateFunction = function(month) { console.log(month); }
* var commands = {
* // This example will accept any word as the "month"
* 'calculate :month stats': calculateFunction,
* // This example will only accept months which are at the start of a quarter
* 'calculate :quarter stats': {'regexp': /^calculate (January|April|July|October) stats$/, 'callback': calculateFunction}
* }
````
*
*/
|
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var ImageSchema = new Schema({
nome: String,
insercao: Date,
base64: String
})
module.exports = mongoose.model('Imagem', ImageSchema, 'imagems');
|
vizmap = [
{selector: "node", css: {
"shape": "ellipse",
"text-valign":"center",
"text-halign":"center",
"content": "data(label)",
"border-width": "3px",
"background-color": "#FFFFFF",
"border-color":"black",
"width": "80px",
"height": "80px",
"font-size":"24px"}},
{selector: 'node[carrier="ATT"]', css: {
"border-color": "red",
}},
{selector: 'node[carrier="CellularOne"]', css: {
"border-color": "orange",
}},
{selector: 'node[carrier="Nextel"]', css: {
"border-color": "Green"
}},
{selector: 'node[carrier="Sprint"]', css: {
"border-color": "purple"
}},
{selector: 'node[carrier="US Cellular"]', css: {
"border-color": "magenta"
}},
{selector: 'node[carrier="Verizon Wireless"]', css: {
"border-color": "blue"
}},
{selector:"node:selected", css: {
"text-valign":"center",
"text-halign":"center",
"border-color": "black",
"content": "data(id)",
"border-width": "3px",
"overlay-opacity": 0.2,
"overlay-color": "gray"
}},
{selector:"edge", css: {
'line-color': "rgb(50,50,50)",
'target-arrow-color': 'rgb(50,50,50)',
'target-arrow-shape': 'triangle',
"width": "1px",
'curve-style': 'bezier',
'haystack-radius': 0.1
}},
{"selector": "edge:selected", css: {
"overlay-opacity": 0.2,
"overlay-color": "gray",
"width": "2px",
}},
];
|
module.exports = {
extends: ['plugin:lodash-fp/recommended'],
plugins: ['lodash-fp'],
rules: {
'lodash-fp/use-fp': 0,
},
}
|
import lazyLoading from './lazyLoading'
export default {
name: '课程组合管理',
path: '/combination',
meta: {
icon: 'fa-building-o',
expanded: false
},
component: lazyLoading('combination', true),
children: [
{
name: '课程组合列表',
path: 'list',
component: lazyLoading('combination/List')
},
{
name: '课程组合列表',
path: 'list/:page',
hide: true,
component: lazyLoading('combination/List')
},
{
name: '添加课程组合',
path: 'add',
component: lazyLoading('combination/Edit')
},
{
name: '编辑课程组合',
path: 'edit/:id',
hide: true,
component: lazyLoading('combination/Edit')
},
{
name: '课程组合详情',
path: 'detail/:id',
hide: true,
component: lazyLoading('combination/Detail')
}
]
}
|
const HtmlWebpackPlugin = require("html-webpack-plugin");
const { CleanWebpackPlugin } = require("clean-webpack-plugin");
const MiniCssExtractPlugin = require("mini-css-extract-plugin");
const path = require("path");
const basePath = __dirname;
module.exports = {
context: path.join(basePath, "src"),
resolve: {
extensions: [".js", ".jsx"],
},
devtool: "eval-source-map",
entry: {
app: ["./index.jsx"],
appStyles: ["./mystyles.scss"],
vendorStyles: ["../node_modules/bootstrap/dist/css/bootstrap.css"],
},
output: {
filename: "[name].[chunkhash].js",
path: path.resolve(process.cwd(), "dist"),
publicPath: "/",
},
module: {
rules: [
{
test: /\.jsx?$/,
exclude: /node_modules/,
loader: "babel-loader",
},
{
test: /\.scss$/,
exclude: /node_modules/,
use: [
{
loader: MiniCssExtractPlugin.loader,
},
{
loader: "css-loader",
options: {
import: false,
modules: {
exportLocalsConvention: "camelCase",
localIdentName: "[path][name]__[local]--[hash:base64:5]",
localIdentContext: path.resolve(__dirname, "src"),
localIdentHashPrefix: "my-custom-hash",
},
},
},
{
loader: "sass-loader",
options: {
implementation: require("sass"),
},
},
],
},
{
test: /\.css$/,
use: [MiniCssExtractPlugin.loader, "css-loader"],
},
{
test: /\.(png|jpg)$/,
type: "asset/resource",
},
{
test: /\.html$/,
loader: "html-loader",
},
],
},
plugins: [
new CleanWebpackPlugin(),
//Generate index.html in /dist => https://github.com/ampedandwired/html-webpack-plugin
new HtmlWebpackPlugin({
filename: "index.html", //Name of file in ./dist/
template: "index.html", //Name of template in ./src
}),
new MiniCssExtractPlugin({
filename: "[name].css",
chunkFilename: "[id].css",
}),
],
};
|
/**
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
*/
import { BidiModule } from '@angular/cdk/bidi';
import { PlatformModule } from '@angular/cdk/platform';
import { CommonModule } from '@angular/common';
import { NgModule } from '@angular/core';
import { NzOutletModule } from 'ng-zorro-antd/core/outlet';
import { NzIconModule } from 'ng-zorro-antd/icon';
import { NzAutosizeDirective } from './autosize.directive';
import { NzInputGroupSlotComponent } from './input-group-slot.component';
import { NzInputGroupComponent, NzInputGroupWhitSuffixOrPrefixDirective } from './input-group.component';
import { NzInputDirective } from './input.directive';
import { NzTextareaCountComponent } from './textarea-count.component';
export class NzInputModule {
}
NzInputModule.decorators = [
{ type: NgModule, args: [{
declarations: [
NzTextareaCountComponent,
NzInputDirective,
NzInputGroupComponent,
NzAutosizeDirective,
NzInputGroupSlotComponent,
NzInputGroupWhitSuffixOrPrefixDirective
],
exports: [
NzTextareaCountComponent,
NzInputDirective,
NzInputGroupComponent,
NzAutosizeDirective,
NzInputGroupWhitSuffixOrPrefixDirective
],
imports: [BidiModule, CommonModule, NzIconModule, PlatformModule, NzOutletModule]
},] }
];
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vY29tcG9uZW50cy9pbnB1dC9pbnB1dC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUgsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDM0QsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRWxELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQzNELE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ3pFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSx1Q0FBdUMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3pHLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3JELE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBb0J0RSxNQUFNLE9BQU8sYUFBYTs7O1lBbEJ6QixRQUFRLFNBQUM7Z0JBQ1IsWUFBWSxFQUFFO29CQUNaLHdCQUF3QjtvQkFDeEIsZ0JBQWdCO29CQUNoQixxQkFBcUI7b0JBQ3JCLG1CQUFtQjtvQkFDbkIseUJBQXlCO29CQUN6Qix1Q0FBdUM7aUJBQ3hDO2dCQUNELE9BQU8sRUFBRTtvQkFDUCx3QkFBd0I7b0JBQ3hCLGdCQUFnQjtvQkFDaEIscUJBQXFCO29CQUNyQixtQkFBbUI7b0JBQ25CLHVDQUF1QztpQkFDeEM7Z0JBQ0QsT0FBTyxFQUFFLENBQUMsVUFBVSxFQUFFLFlBQVksRUFBRSxZQUFZLEVBQUUsY0FBYyxFQUFFLGNBQWMsQ0FBQzthQUNsRiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9naXRodWIuY29tL05HLVpPUlJPL25nLXpvcnJvLWFudGQvYmxvYi9tYXN0ZXIvTElDRU5TRVxuICovXG5cbmltcG9ydCB7IEJpZGlNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jZGsvYmlkaSc7XG5pbXBvcnQgeyBQbGF0Zm9ybU1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9wbGF0Zm9ybSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgTnpPdXRsZXRNb2R1bGUgfSBmcm9tICduZy16b3Jyby1hbnRkL2NvcmUvb3V0bGV0JztcbmltcG9ydCB7IE56SWNvbk1vZHVsZSB9IGZyb20gJ25nLXpvcnJvLWFudGQvaWNvbic7XG5cbmltcG9ydCB7IE56QXV0b3NpemVEaXJlY3RpdmUgfSBmcm9tICcuL2F1dG9zaXplLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBOeklucHV0R3JvdXBTbG90Q29tcG9uZW50IH0gZnJvbSAnLi9pbnB1dC1ncm91cC1zbG90LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBOeklucHV0R3JvdXBDb21wb25lbnQsIE56SW5wdXRHcm91cFdoaXRTdWZmaXhPclByZWZpeERpcmVjdGl2ZSB9IGZyb20gJy4vaW5wdXQtZ3JvdXAuY29tcG9uZW50JztcbmltcG9ydCB7IE56SW5wdXREaXJlY3RpdmUgfSBmcm9tICcuL2lucHV0LmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBOelRleHRhcmVhQ291bnRDb21wb25lbnQgfSBmcm9tICcuL3RleHRhcmVhLWNvdW50LmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1xuICAgIE56VGV4dGFyZWFDb3VudENvbXBvbmVudCxcbiAgICBOeklucHV0RGlyZWN0aXZlLFxuICAgIE56SW5wdXRHcm91cENvbXBvbmVudCxcbiAgICBOekF1dG9zaXplRGlyZWN0aXZlLFxuICAgIE56SW5wdXRHcm91cFNsb3RDb21wb25lbnQsXG4gICAgTnpJbnB1dEdyb3VwV2hpdFN1ZmZpeE9yUHJlZml4RGlyZWN0aXZlXG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBOelRleHRhcmVhQ291bnRDb21wb25lbnQsXG4gICAgTnpJbnB1dERpcmVjdGl2ZSxcbiAgICBOeklucHV0R3JvdXBDb21wb25lbnQsXG4gICAgTnpBdXRvc2l6ZURpcmVjdGl2ZSxcbiAgICBOeklucHV0R3JvdXBXaGl0U3VmZml4T3JQcmVmaXhEaXJlY3RpdmVcbiAgXSxcbiAgaW1wb3J0czogW0JpZGlNb2R1bGUsIENvbW1vbk1vZHVsZSwgTnpJY29uTW9kdWxlLCBQbGF0Zm9ybU1vZHVsZSwgTnpPdXRsZXRNb2R1bGVdXG59KVxuZXhwb3J0IGNsYXNzIE56SW5wdXRNb2R1bGUge31cbiJdfQ==
|
const DrawCard = require('../../drawcard.js');
class SaltWife extends DrawCard {
setupCardAbilities(ability) {
this.action({
title: 'Sacrifice Salt Wife',
phase: 'challenge',
cost: ability.costs.sacrificeSelf(),
target: {
activePromptTitle: 'Select a character',
cardCondition: card => card.location === 'play area' && card.getType() === 'character'
},
handler: context => {
this.untilEndOfPhase(ability => ({
match: context.target,
effect: ability.effects.cannotBeDeclaredAsDefender()
}));
this.game.addMessage('{0} sacrifices {1} to make {2} unable to be declared as a defender',
context.player, this, context.target);
}
});
}
}
SaltWife.code = '07027';
module.exports = SaltWife;
|
const axios = require("axios");
const SCKEY = process.env.SCKEY;
axios.defaults.headers.common.cookie = process.env.COOKIE;
const checkIn = async () => {
return axios({
method: 'post',
url: 'https://glados.rocks/api/user/checkin',
data: {
token: "glados_network"
}
})
}
const status = async () => {
return axios({
method: 'get',
url: 'https://glados.rocks/api/user/status'
})
}
const server = (checkInMessage, leftDays) => {
return axios({
method: 'get',
url: `https://sctapi.ftqq.com/${SCKEY}.send`,
params: {
title: `${leftDays}天后到期，${checkInMessage}`
}
})
}
const GLaDOSCheckIn = async () => {
const checkInMessage = (await checkIn())?.data?.message;
const leftDays = parseInt((await status())?.data?.data?.leftDays);
console.log(leftDays, checkInMessage);
console.log(1);
if (SCKEY) {
server(checkInMessage, leftDays);
}
}
GLaDOSCheckIn();
|
class SearchUtility {
GetObjects(obj, key, val = "") {
var objects = [];
for (var i in obj) {
if (!obj.hasOwnProperty(i)) continue;
if (typeof obj[i] === "object") {
objects = objects.concat(this.GetObjects(obj[i], key, val));
} else
// if key matches and value matches or if key matches and value is not passed (eliminating the case where key matches but passed value does not)
if ((i === key && obj[i] === val) || (i === key && val === "")) {
objects.push(obj);
} else if (obj[i] === val && key === "") {
// only add if the object is not already in the array
if (objects.lastIndexOf(obj) === -1) {
objects.push(obj);
}
}
}
return objects;
}
GetSimilarObjects(obj, key, val = "", filter = () => true) {
var objects = [];
for (var i in obj) {
if (!obj.hasOwnProperty(i)) continue;
if (typeof obj[i] === "object") {
objects = objects.concat(this.GetSimilarObjects(obj[i], key, val, filter));
} else if ((i === key && obj[i].toLowerCase().indexOf(val.toLowerCase()) > -1) || (i === key && val === "")) {
if (filter(obj.textRaw || obj)) objects.push(obj);
} else if (obj[i] === val && key === "") {
// only add if the object is not already in the array
if (objects.lastIndexOf(obj) === -1 && filter(filter(obj.textRaw || obj))) {
objects.push(obj);
}
}
}
return objects;
}
GetValues(obj, key) {
var objects = [];
for (var i in obj) {
if (!obj.hasOwnProperty(i)) continue;
if (typeof obj[i] === "object") {
objects = objects.concat(this.GetValues(obj[i], key));
} else if (i === key) {
objects.push(obj[i]);
}
}
return objects;
}
GetKeys(obj, val) {
var objects = [];
for (var i in obj) {
if (!obj.hasOwnProperty(i)) continue;
if (typeof obj[i] === "object") {
objects = objects.concat(this.GetKeys(obj[i], val));
} else if (obj[i] === val) {
objects.push(i);
}
}
return objects;
}
}
module.exports = new SearchUtility();
|
import React from 'react';
const Social = () => {
return (
<div data-test="component-social">
<h3>Social Component</h3>
</div>
)
}
export default Social;
|
// When the window has finished loading create our google map below
google.maps.event.addDomListener(window, 'load', init);
function init() {
// Basic options for a simple Google Map
// For more options see: https://developers.google.com/maps/documentation/javascript/reference#MapOptions
var mapOptions = {
// How zoomed in you want the map to start at (always required)
zoom: 14,
// The latitude and longitude to center the map (always required)
center: new google.maps.LatLng(33.4465154, -86.7318209), // New York
// How you would like to style the map.
// This is where you would paste any style found on Snazzy Maps.
styles: []
};
// Get the HTML DOM element that will contain your map
// We are using a div with id="gMap" seen below in the <body>
var mapElement = document.getElementById('gMap');
var map = new google.maps.Map(mapElement, mapOptions);
// Let's also add a marker while we're at it
marker = new google.maps.Marker({
map:map,
draggable:true,
animation: google.maps.Animation.DROP,
position: new google.maps.LatLng(33.4465154, -86.7318209),
// Change those co-ordinates to yours, to change your location with given location.
icon: '' // null = default icon
});
}
|
import http from 'k6/http';
import { check, sleep } from 'k6';
export let options = {
stages: [
{ duration: '10s', target: 100 },
{ duration: '20s', target: 100 },
{ duration: '5s', target: 0 },
],
thresholds: {
http_req_duration: ['p(99)<1000'],
},
};
const BASE_URL = 'http://keepbang-alb-975163363.ap-northeast-2.elb.amazonaws.com/lines/1';
const request = JSON.stringify({
name: "testName",
color: "red darken-4"
});
const params = {
headers: {
'Content-Type': 'application/json',
},
};
export default function () {
let mainResponse = http.put(`${BASE_URL}`, request, params);
check(mainResponse, {
'line update': response => response.status === 200
});
sleep(1);
};
|
import assert from 'assert'
export default function (state) {
const { document, selection } = state
const texts = document.getTexts()
const first = texts.first()
const range = selection.merge({
anchorKey: first.key,
anchorOffset: first.length - 1,
focusKey: first.key,
focusOffset: first.length
})
const next = state
.transform()
.select(range)
.toggleMark('bold')
.apply()
assert.deepEqual(next.selection.toJS(), range.toJS())
return next
}
|
import React, {PureComponent, Fragment} from 'react';
import {connect} from 'dva';
import {
Row,
Col,
Card,
Form,
Button,
Modal,
Table,
notification,
Icon,
message
} from 'antd';
import PageHeaderWrapper from '@/components/PageHeaderWrapper';
import moment from 'moment'
import styles from './company.less';
/* eslint react/no-multi-comp:0 */
@Form.create()
@connect(({company, loading}) => ({
company,
loading: loading.models.company,
}))
class ManDetail extends PureComponent {
state = {
url: null,
showVisible: false,
recordData:[],
usertext:{},
headUrl:undefined,
signUrl:undefined,
photoUrl:undefined,
};
columns = [
{
title: '文件名称',
dataIndex: 'recordname',
render: val => {
//取文件名
var pattern = /\.{1}[a-z]{1,}$/;
if (pattern.exec(val) !== null) {
return <span>{val.slice(0, pattern.exec(val).index)}</span>;
} else {
return <span>{val}</span>;
}
}
},
{
title: '上传日期',
dataIndex: 'recorddate',
render: val => <span>{
moment(val).format('YYYY-MM-DD')
}</span>
},
{
title: '文件类型',
dataIndex: 'filetype',
},
{
title: '操作',
render: (text, record) => (
<Fragment>
<a onClick={() => this.previewItem(text, record)}>查看</a>
</Fragment>
),
},
];
componentDidMount() {
const {dispatch} = this.props;
const certcode = sessionStorage.getItem('mandetail_certcode');
const nameC = sessionStorage.getItem('mandetail_namc');
dispatch({
type: 'company/getManRecord',
payload: {
nameC,
certCode: certcode,
},
callback:(response) =>{
if (response.code === 200) {
this.setState({recordData: response.data});
}
}
});
dispatch({
type: 'company/getUserByCertCodeAndName',
payload: {
nameC,
certCode: certcode,
},
callback:(response) =>{
if (response.code === 200) {
const usertext = response.data;
this.setState({usertext });
if( usertext.signurl!==null){
dispatch({
type: 'company/getUrl',
payload:{
url : usertext.signurl,
},
callback:(response1)=>{
if(response1.code === 200){
this.setState({signUrl:response1.data});
}
}
});
}
if( usertext.authorizeurl!==null){
dispatch({
type: 'company/getUrl',
payload:{
url : usertext.authorizeurl,
},
callback:(response2)=>{
if(response2.code === 200){
this.setState({headUrl:response2.data});
}
}
});
}
if( usertext.photourl!==null){
dispatch({
type: 'company/getUrl',
payload:{
url : usertext.photourl,
},
callback:(response3)=>{
if(response3.code === 200){
this.setState({photoUrl:response3.data});
}
}
});
}
}
}
});
}
previewItem = text => {
const {dispatch} = this.props;
dispatch({
type: 'company/getUrl',
payload: {
url:text.osspath
},
callback: (response) => {
if (response.code === 400) {
notification.open({
message: '打开失败',
description: response.data,
});
} else {
const url = response.data;
this.setState({url});
this.setState({showVisible: true});
//window.open(url);
}
}
});
};
back = () => {
window.close();
};
showCancel = () => {
this.setState({showVisible: false});
};
render() {
const {
loading,
} = this.props;
// state 方法
const { url, showVisible, recordData,usertext,signUrl,headUrl,photoUrl} = this.state
const reprotText = {
nameC:usertext.nameC,
};
return (
<PageHeaderWrapper text={reprotText}>
<Card bordered={false} size="small">
<Row>
<Col span={22} />
<Col span={2}>
<Button type="primary" style={{ marginLeft: 8 ,paddingLeft:0,paddingRight:15}} onClick={this.back}>
<Icon style={{paddingLeft:5}} type="close" />关闭
</Button>
</Col>
</Row>
<Row style={{paddingLeft:200,paddingRight:200,paddingTop:10,paddingBottom:10}}>
<Col span={24}>
<table width="100%" border={1}>
<tr>
<td width="15%" style={{backgroundColor: '#FAFAFA', 'textAlign': 'center', 'padding': '10px'}}>姓名</td>
<td width="20%" style={{ 'textAlign': 'center', 'padding': '10px'}}>{usertext.nameC}</td>
<td width="15%" style={{ backgroundColor: '#FAFAFA','textAlign': 'center', 'padding': '10px'}}> 性别</td>
<td width="20%" style={{ 'textAlign': 'center', 'padding': '10px'}}> {usertext.sex}</td>
<td width="30%" rowSpan="5" colSpan="2" style={{ 'textAlign': 'center', 'padding': '10px'}}>
{(photoUrl===''||photoUrl===null||photoUrl===undefined)?[<div style={{marginTop:20,marginLeft:20}}>暂无图片</div>]:[<img style={{marginTop:20}} src={photoUrl} height="200" />]}
</td>
</tr>
<tr>
<td width="15%" style={{ backgroundColor: '#FAFAFA','textAlign': 'center', 'padding': '10px'}}> 文化程度</td>
<td width="20%" style={{ 'textAlign': 'center', 'padding': '10px'}}> {usertext.education}</td>
<td width="15%" style={{ backgroundColor: '#FAFAFA','textAlign': 'center', 'padding': '10px'}}> 专业</td>
<td width="20%" style={{ 'textAlign': 'center', 'padding': '10px'}}> {usertext.major}</td>
</tr>
<tr>
<td width="15%" style={{backgroundColor: '#FAFAFA', 'textAlign': 'center', 'padding': '10px'}}>部门</td>
<td width="20%" style={{ 'textAlign': 'center', 'padding': '10px'}}>{usertext.section}</td>
<td width="15%" style={{ backgroundColor: '#FAFAFA','textAlign': 'center', 'padding': '10px'}}> 出生日期</td>
<td width="20%" style={{ 'textAlign': 'center', 'padding': '10px'}}> {usertext.birthday!=null?moment(usertext.birthday).format('YYYY-MM-DD'):""}</td>
</tr>
<tr>
<td width="15%" style={{backgroundColor: '#FAFAFA', 'textAlign': 'center', 'padding': '10px'}}>职务</td>
<td width="20%" style={{ 'textAlign': 'center', 'padding': '10px'}}>{usertext.workduty}</td>
<td width="15%" style={{ backgroundColor: '#FAFAFA','textAlign': 'center', 'padding': '10px'}}> 任职日期</td>
<td width="20%" style={{ 'textAlign': 'center', 'padding': '10px'}}> {usertext.enterdate!=null?moment(usertext.enterdate).format('YYYY-MM-DD'):""}</td>
</tr>
<tr>
<td width="15%" style={{ backgroundColor: '#FAFAFA','textAlign': 'center', 'padding': '10px'}}>工作年限</td>
<td width="20%" style={{ 'textAlign': 'center', 'padding': '10px'}}>{usertext.workyears}</td>
<td width="15%" style={{ backgroundColor: '#FAFAFA','textAlign': 'center', 'paddiddng': '10px'}}>身份证号</td>
<td width="20%" style={{ 'textAlign': 'center', 'padding': '10px'}}>{usertext.idcard}</td>
</tr>
<tr>
<td width="15%" style={{ backgroundColor: '#FAFAFA','textAlign': 'center', 'padding': '10px'}}>住址</td>
<td width="20%" style={{ 'textAlign': 'center', 'padding': '10px'}}>{usertext.place}</td>
<td width="15%" style={{ backgroundColor: '#FAFAFA','textAlign': 'center', 'padding': '10px'}}> 手机号</td>
<td width="20%" style={{ 'textAlign': 'center', 'padding': '10px'}}> {usertext.tel}</td>
<td width="12%" style={{ backgroundColor: '#FAFAFA','textAlign': 'center', 'padding': '10px'}}> 授权签字</td>
<td width="8%" style={{ 'textAlign': 'center', 'padding': '10px'}}> {usertext.isauthorize}</td>
</tr>
<tr>
<td width="15%" height={150} colSpan="1" style={{backgroundColor: '#FAFAFA', 'textAlign': 'center', 'padding': '10px'}}>手写签名</td>
<td width="15%" height={150} colSpan="5" style={{ 'textAlign': 'center', 'padding': '10px'}}>
{(signUrl===''||signUrl===null||signUrl===undefined)?[<div style={{marginTop:20,marginLeft:20}}>暂无图片</div>]:[<img style={{marginTop:20,marginBottom:20}} src={signUrl} height="80" />]}
</td>
</tr>
<tr>
<td width="15%" height={200} colSpan="1" style={{ backgroundColor: '#FAFAFA','textAlign': 'center', 'padding': '10px'}}>授权图片</td>
<td width="15%" height={200} colSpan="5" style={{ 'textAlign': 'center', 'padding': '10px'}}>
{(headUrl===''||headUrl===null||headUrl===undefined)?[<div style={{marginTop:20,marginLeft:20}}>暂无图片</div>]:[<img style={{marginTop:20,marginBottom:20}} src={headUrl} height="150" />]}
</td>
</tr>
<tr>
<td width="15%" height={150} colSpan="1" style={{ backgroundColor: '#FAFAFA','textAlign': 'center', 'padding': '10px'}}>个人文件</td>
<td width="15%" colSpan="5" style={{ 'textAlign': 'center', 'padding': '10px'}}>
<div className={styles.tableList}>
<Table
size="middle"
loading={loading}
dataSource={recordData}
columns={this.columns}
rowKey="recordname"
pagination={false}
// showHeader={false}
/>
</div>
</td>
</tr>
</table>
</Col>
</Row>
</Card>
<Modal
title="记录详情"
visible={showVisible}
onCancel={this.showCancel}
footer={null}
width={800}
style={{top: 10}}
>
<embed src={url} width="700" height="700" type="application/pdf" />
</Modal>
</PageHeaderWrapper>
);
}
}
export default ManDetail;
|
/* eslint import/no-extraneous-dependencies: ['error', {'devDependencies': true}] */
import autoExternal from 'rollup-plugin-auto-external';
import babel from '@rollup/plugin-babel';
export default {
input: 'src/index.js',
plugins: [
autoExternal(),
babel({
babelrc: false,
exclude: ['./node_modules/**'],
presets: [['@form8ion', {targets: {node: '10'}, modules: false}]]
})
],
external: 'spdx-license-list/simple',
output: [
{file: 'lib/index.cjs.js', format: 'cjs', sourcemap: true},
{file: 'lib/index.es.js', format: 'es', sourcemap: true}
]
};
|
"use strict";
jest.autoMockOff();
const defineTest = require("jscodeshift/dist/testUtils").defineTest;
describe("lodash get to optional chaining", () => {
describe("basic happy case scenario", () => {
defineTest(__dirname, "transform");
});
describe("flags", () => {
describe("skipTemplateStrings", () => {
defineTest(
__dirname,
"transform",
{ skipTemplateStrings: true },
"skipTemplateStrings"
);
});
describe("skipVariables", () => {
defineTest(
__dirname,
"transform",
{ skipVariables: true },
"skipVariables"
);
});
describe("typescript", () => {
defineTest(
__dirname,
"transform",
null,
"typescript",
{ parser: "ts" },
{ parser: "ts" }
);
});
});
describe("mangle nested object checks", () => {
defineTest(__dirname, "transform", null, "nestedObjects");
});
describe("import from lodash/fp", () => {
defineTest(__dirname, "transform", null, "lodashFP");
});
});
|
define({
_widgetLabel: 'يعرض التنقل',
tabStyle: 'النقر فوق النمط',
navBtnStyle: 'نمط زر التنقل'
});
|
const DEFAULT_LIMIT = 9999
module.exports = {
DEFAULT_LIMIT,
}
|
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.
import {connect} from 'react-redux';
import {getTheme} from 'mattermost-redux/selectors/entities/preferences';
import SafeAreaView from './safe_area_view';
function mapStateToProps(state) {
return {
theme: getTheme(state),
};
}
export default connect(mapStateToProps)(SafeAreaView);
|
CustomTabBar = function(settings) {
var tabBarItems = [];
var tabCurrent = 0;
var resetTabs = function() {
for(var i = 0; i < tabBarItems.length; i++) {
tabBarItems[i].image = tabBarItems[i].backgroundImage;
}
};
var assignClick = function(tabItem) {
tabItem.addEventListener('click', function(e) {
// Just fetching the 'i' variable from the loop
var pos = e.source.pos;
if (tabCurrent == pos) {
// Change back to root window, like the native tab action.
return false;
}
// Switch to the tab associated with the image pressed
settings.tabBar.tabs[pos].active = true;
tabCurrent = pos;
// Reset all the tab images
resetTabs();
// Set the current tab as selected
tabBarItems[pos].image = settings.imagePath + settings.items[pos].selected;
});
};
// Create the container for our tab items
var customTabBar = Ti.UI.createWindow({
height: settings.height,
bottom: 0
});
for(var i = 0; i < settings.items.length; i++) {
// Go through each item and create an imageView
tabBarItems[i] = Titanium.UI.createImageView({
// background is the default image
backgroundImage: settings.imagePath + settings.items[i].image,
width: settings.width,
height: settings.height,
left: settings.width * i
});
// Pass the item number (used later for changing tabs)
tabBarItems[i].pos = i;
assignClick(tabBarItems[i]);
// Add to the container window
customTabBar.add(tabBarItems[i]);
}
// Display the container and it's items
customTabBar.open();
// Set the first item as current :)
resetTabs();
tabBarItems[0].image = settings.imagePath + settings.items[0].selected;
return {
hide: function() { customTabBar.hide(); },
show: function() { customTabBar.show(); },
back: function(_tabIndex) {
resetTabs();
tabBarItems[_tabIndex].image = settings.imagePath + settings.items[_tabIndex].selected;
tabCurrent = _tabIndex;
}
};
};
|
export const xCircle24 = "M16.45 7.257L12.207 11.5l4.243 4.243-.707.707-4.243-4.243-4.243 4.243-.707-.707 4.243-4.243L6.55 7.257l.707-.707 4.243 4.243 4.243-4.243zM22 11.5A10.5 10.5 0 1 1 11.5 1 10.497 10.497 0 0 1 22 11.5zm-.9 0a9.6 9.6 0 1 0-9.6 9.6 9.61 9.61 0 0 0 9.6-9.6z";
|
/*!
* Bootstrap-select v1.5.4 (http://silviomoreto.github.io/bootstrap-select/)
*
* Copyright 2013-2014 bootstrap-select
* Licensed under MIT (https://github.com/silviomoreto/bootstrap-select/blob/master/LICENSE)
*/
(function ($) {
$.fn.selectpicker.defaults = {
noneSelectedText: 'Nessuna selezione',
noneResultsText: 'Nessun risultato',
countSelectedText: 'Selezionati {0} di {1}',
maxOptionsText: ['Limite raggiunto ({n} {var} max)', 'Limite del gruppo raggiunto ({n} {var} max)', ['elementi', 'elemento']],
multipleSeparator: ', '
};
}(jQuery));
|
{"name_test123":"0xCB2467bdF1e73c4DE1b6e78961097a48f623ED1E","address_0xa296B84E2846Bf0fDD5CF57650B568B1bFe9809a":"EASYMETER_60176785","address_0xCB2467bdF1e73c4DE1b6e78961097a48f623ED1E":"test123","name_stromdao-mp":"0xa296B84E2846Bf0fDD5CF57650B568B1bFe9809a","name_BLG":"0x0212B287976ea4b87093c64dd3a8f46b7AE043f5","name_EASYMETER_60176785":"0xa296B84E2846Bf0fDD5CF57650B568B1bFe9809a","address_0x0212B287976ea4b87093c64dd3a8f46b7AE043f5":"BLG"}
|
(this.webpackJsonpripple=this.webpackJsonpripple||[]).push([[0],{107:function(e,t,n){},108:function(e,t,n){"use strict";n.r(t);var a={};n.r(a),n.d(a,"TriangleIcon",(function(){return W})),n.d(a,"NetworkIcon",(function(){return M})),n.d(a,"TextIcon",(function(){return F})),n.d(a,"ChartIcon",(function(){return H})),n.d(a,"CircleIcon",(function(){return z}));var r=n(0),i=n.n(r),o=n(8),c=n.n(o),l=(n(54),n(1)),u=n(3),s=function(e){return void 0==e?Math.random().toString(36).substr(2,9):new Array(e).fill(0).map((function(){return Math.random().toString(36).substr(2,9)}))},d=function(e,t){return e[t.key].map((function(e){return e.id==t.id&&(Object.assign(e,Object(u.a)({},t.data)),e.version=s()),e})),e},m=function(e,t){return e.views=e.views.filter((function(e){return e.id!=t.id})),e.viewList=e.views.map((function(e){return"".concat(e.type,".").concat(e.id)})),e},f=function(e,t){return e.views.push({type:t.data.type,title:t.data.title,subTitle:t.data.subtitle,id:s(),view:t.data.view}),e},v=function(e,t){switch(e.timestamp=(new Date).toString(),t.type){case"CHANGE":return d(e,t);case"DELETE":return m(e,t);case"CREATE":return f(e,t);default:return e}},p={views:[{type:"network",title:"Friendship network",subTitle:"Based on aggregation II",id:s(),view:"aggregate"},{type:"text",title:"Text Example",subTitle:"Description of process",id:s(),view:"textbox"},{type:"time",title:"Connection Timeseries",subTitle:"Based on aggregation III",id:s(),view:"timeplot"}],annotations:{},allIds:[]};p.allIds=p.views.map((function(e){return"".concat(e.type,".").concat(e.id)}));var g=Object(r.createContext)(),E=function(e){var t=e.children,n=Object(r.useReducer)(v,p),a=Object(l.a)(n,2),o=a[0],c=a[1];return i.a.createElement(g.Provider,{value:{ram:o,ramUpdate:c}},t)},b=n(2),w=function(e,t){if(!(t="number"===typeof t?t:1/0))return Array.isArray(e)?e.map((function(e){return e})):e;return function e(n,a){return n.reduce((function(n,r){return Array.isArray(r)&&a<t?n.concat(e(r,a+1)):n.concat(r)}),[])}(e,1)},y=function e(t){return 1===t.length&&Array.isArray(t[0])?e(t[0]):Array.isArray(t)?t.map(e):t},h=function(e){return e=function e(t){if(t.length<=2)return t;for(var n=[];t.length>0;)n.push(t.splice(0,2));return e(n)}(e)},O=function(e,t){var n=t.view,a=Object(b.a)(w(e));return a.push(n),y(h(a))},j=function(e,t){var n=t.view,a=Object(b.a)(w(e));return a=a.filter((function(e){return e!==n})),y(h(a))},_=function e(t){var n=[];return t.forEach((function(t){if(Array.isArray(t)&&0!==t.length){var a=e(t);a.length>0&&n.push(a)}else"undefined"!==typeof t&&""!==t&&null!==t&&n.push(t)})),n},x=function(e){e=JSON.stringify(e);for(var t=/\[\[(\["\w+\.\d+","\w+\.\d+"\])\]\]/;t.test(e);)e=e.replace(t,"$1");for(var n=/\[(\["\w+\.\d+")\]/;n.test(e);)e=e.replace(n,"$1");for(var a=JSON.parse(e);Array.isArray(a[0])&&Array.isArray(a[0][0])&&1===a.length&&1===a[0].length;)a=a[0][0];return a},A=function(e,t){var n=t.dragged,a=t.to,r=t.pos,i=t.vertical,o=JSON.stringify(e).replace(/\s/,"").replace('"'.concat(n,'"'),"$from").replace('"'.concat(a,'"'),"$to");if("center"===r)return o=o.replace("$from",'"'.concat(a,'"')).replace("$to",'"'.concat(n,'"')),JSON.parse(o);var c=[];return c="left"===r||"top"===r?[n,a]:[a,n],(!i||"left"!==r&&"right"!==r)&&(i||"top"!==r&&"bottom"!==r)||(c=[c]),o=(o=o.replace("$from","null")).replace("$to",JSON.stringify(c)),e=_(JSON.parse(o)),x(e)},C=function(e,t){switch(t.type){case"ADD_VIEW":return O(e,t);case"REMOVE_VIEW":return j(e,t);case"MOVE_VIEW":return A(e,t);default:return e}},T=Object(r.createContext)(),N=function(e){var t=e.children,n=Object(r.useContext)(g).ram,a=Object(r.useReducer)(C,h(h(n.allIds))),o=Object(l.a)(a,2),c=o[0],u=o[1];return i.a.createElement(T.Provider,{value:{grid:c,dispatch:u,getVersion:function(e){var t=e.split("."),a=Object(l.a)(t,2),r=(a[0],a[1]);return n.views.find((function(e){return e.id==r})).version}}},t)},k=function(e){return JSON.parse(JSON.stringify(e))},I={id:"",title:"",timeStart:"",timeEnd:"",collection:"",series:"",fromNode:"",toNode:"",description:""},D={editing:!1,active:{},annotations:[]},S=Object(r.createContext)(),P=function(e){var t=e.children,n=Object(r.useState)(D),a=Object(l.a)(n,2),o=a[0],c=a[1],s=o.active;return i.a.createElement(S.Provider,{value:{annotation:o,active:s,updateAnnotation:function(e){if(console.log("Comparaison:",e.id,o.active.id),e.id!=o.active.id){var t=k(o);console.log("Active:",t.active,"Received:",e),t.annotations.push(k(t.active)),console.log("step1:",t);var n=t.annotations.findIndex((function(t){return t.id==e.id})),a=n>-1?t.annotations[n]:{};n>-1&&t.annotations.splice(n,1),t.active=Object(u.a)({},I,{},e,{},a),c(t)}},setAnnotationField:function(e,t){var n=k(o);n.active[e]=t,c(n)}}},t)},L=n(40),V=n.n(L),B=n(16),R=n.n(B),W=Object(r.memo)((function(e){return i.a.createElement("svg",Object.assign({height:"6",viewBox:"0 0 415.346 415.346"},e),i.a.createElement("path",{d:"M41.712,415.346c-11.763,0-21.3-9.537-21.3-21.3V21.299C20.412,9.536,29.949,0,41.712,0l346.122,191.697c0,0,15.975,15.975,0,31.951C371.859,239.622,41.712,415.346,41.712,415.346z"}))})),M=Object(r.memo)((function(e){return i.a.createElement("svg",Object.assign({height:"16",viewBox:"0 0 96.666 96.666"},e),i.a.createElement("rect",{x:"36",y:"6",width:"24.666",height:"24.666"}),i.a.createElement("rect",{y:"66",width:"24.666",height:"24.666"}),i.a.createElement("rect",{x:"72",y:"66",width:"24.666",height:"24.666"}),i.a.createElement("polygon",{points:"15.311,51.333 82.105,51.333 82.105,63.066 86.561,63.066 86.561,46.4 84.334,46.4 84.334,46.333 50.833,46.333 50.833,35 45.833,35 45.833,46.333 12.334,46.333 12.334,46.4 10.855,46.4 10.855,63.066 15.311,63.066"}))})),F=Object(r.memo)((function(e){return i.a.createElement("svg",Object.assign({height:"16",x:"0px",y:"0px",viewBox:"0 0 218 218"},e),i.a.createElement("polygon",{points:"103,41 133,41 133,73 167,73 167,7 0,7 0,73 34,73 34,41 64,41 64,177 48,177 48,211 120,211 120,177 103,177 \t"}),i.a.createElement("polygon",{points:"118,90 118,132 142,132 142,114 155,114 155,187 145,187 145,211 191,211 191,187 182,187 182,114 194,114 \r 194,132 218,132 218,90 \t"}))})),H=Object(r.memo)((function(e){return i.a.createElement("svg",Object.assign({height:"16",viewBox:"0 0 276.232 276.232"},e),i.a.createElement("path",{d:"M56.505,195.714c1.719,1.001,3.601,1.474,5.455,1.474c3.748,0,7.397-1.936,9.415-5.412l18.792-32.319c4.525-7.794,13.44-9.013,19.896-2.725l28.631,27.859c2.643,2.573,6.402,3.633,10.019,2.807c3.601-0.827,6.532-3.421,7.794-6.897l32.014-66.563c3.073-8.474,11.531-17.149,18.895-19.374c7.37-2.23,15.273,2.355,17.655,10.231l4.319,14.272c0.87,2.872,2.725,3.057,4.139,0.408l25.727-48.076c1.414-2.649,0.419-5.945-2.23-7.364l-48.076-25.743c-2.649-1.42-4.085-0.234-3.22,2.638c0,0,1.947,6.44,4.357,14.386c2.404,7.946-2.638,16.502-11.259,19.113l-16.274,4.928c-3.285,0.995-5.907,3.481-7.076,6.706l-28.131,55.848c-3.073,8.474-10.797,10.247-17.258,3.965l-26.543-25.825c-2.399-2.339-5.76-3.432-9.061-2.981c-3.318,0.451-6.244,2.415-7.925,5.309l-33.994,58.47C49.548,186.038,51.31,192.695,56.505,195.714z"}),i.a.createElement("path",{d:"M262.139,217.073c0,0-5.575-0.125-11.819-0.125H37.256c-9.013,0-16.344-7.299-16.393-16.317c-0.163-33.059-0.533-104.843-0.533-104.843c0-2.91-0.408-5.472-1.202-7.609c-1.305-3.503-4.803-5.765-8.915-5.765c-4.204,0-7.734,2.322-8.991,5.912c-0.74,2.105-1.115,4.618-1.115,7.468v111.805c0,1.588-0.027,3.242-0.054,4.917c-0.185,11.34-0.092,18.482,3.916,22.278c2.616,2.491,6.233,3.747,10.742,3.747h246.966c7.272-0.158,14.555-3.617,14.555-10.992C276.232,226.581,276.341,217.073,262.139,217.073z"}))})),z=Object(r.memo)((function(e){return i.a.createElement("svg",Object.assign({height:"16",viewBox:"0 0 512 512"},e),i.a.createElement("path",{d:"M256,0C114.837,0,0,114.837,0,256s114.837,256,256,256s256-114.837,256-256S397.163,0,256,0z"}))})),U=function(){var e=!(arguments.length>0&&void 0!==arguments[0])||arguments[0],t=Object(r.useState)(e),n=Object(l.a)(t,2),a=n[0],i=n[1],o=function(e){e.preventDefault(),i(!a)};return[a,o,i]},J=Object(r.memo)((function(e){var t=e.children,n=U(),a=Object(l.a)(n,2),r=a[0],o=a[1],c=r?void 0:{width:0,minWidth:0};return i.a.createElement("div",{className:R.a.PanelsList},i.a.createElement("div",{className:R.a.Panels+" customScrollBar",style:c},t),i.a.createElement("div",{className:R.a.PanelsToggle,onClick:o},i.a.createElement(W,{transform:"rotate(".concat(r?"180":"0",")")})))})),G=n(15),Y=n(11),$=n.n(Y),q=function(e){var t=e.view_type,n=e.view_id,a=Object(r.useContext)(T),i=a.grid,o=a.dispatch,c="".concat(t,".").concat(n),l=w(i).find((function(e){return e===c}));return[l,function(){return o({type:l?"REMOVE_VIEW":"ADD_VIEW",view:c})}]},X=function(e){return{draggable:!0,onDragStart:function(t){var n=document.getElementById("MainView"),a=t.target;setTimeout((function(){n.classList.add("drag"),a.classList.add("drag")}),1),t.dataTransfer.setData("text",e)},onDragEnd:function(e){var t=document.getElementById("MainView"),n=e.target;setTimeout((function(){t.classList.remove("drag"),n.classList.remove("drag")}),1)}}},Z=Object(r.memo)((function(e){var t=e.title,n=e.subTitle,r=e.flexOpen,o=e.icon,c=e.open,s=Object(G.a)(e,["title","subTitle","flexOpen","icon","open"]),d=U(c),m=Object(l.a)(d,2),f=m[0],v=m[1],p=q(s),g=Object(l.a)(p,2),E=g[0],b=g[1],w=r&&f?{flex:1,minHeight:0}:void 0,y=f?{}:{height:0};y=r&&f?Object(u.a)({height:"calc(100% - 1.25rem)"},y):y;var h=a[o];return i.a.createElement("div",{className:$.a.Panel,style:w},i.a.createElement("div",{className:$.a.PanelTitle,onClick:h?null:v},i.a.createElement(W,{transform:"rotate(".concat(f?"90":"0",")"),onClick:h?v:null}),i.a.createElement("span",{onClick:h?v:null},i.a.createElement("h5",null,t),i.a.createElement("h6",null,n)),h&&i.a.createElement("div",Object.assign({},X("".concat(s.view_type,".").concat(s.view_id)),{onClick:b,draggable:!E}),i.a.createElement(h,{className:E?$.a.IconActive:""}))),i.a.createElement("div",{className:$.a.PanelContent,style:y},s.children))})),K=n(13),Q=n(5),ee=n.n(Q),te=n(41),ne=n.n(te),ae=Object(r.memo)((function(e){var t=e.children,n=Object(G.a)(e,["children"]);return i.a.createElement("form",Object.assign({onSubmit:function(e){e.preventDefault()},className:ne.a.Form},n),t)})),re=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"",n=Object(r.useState)(t),a=Object(l.a)(n,2),i=a[0],o=a[1],c=function(e){return o(e.target.value)};return{name:e,value:i,onChange:c}},ie=n(17),oe=n.n(ie),ce=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:[],a=Object(r.useState)({loading:!0,data:null,error:null}),i=Object(l.a)(a,2),o=i[0],c=i[1];Object(r.useEffect)((function(){var n=new AbortController,a=n.signal;return function(){var n,r;oe.a.async((function(i){for(;;)switch(i.prev=i.next){case 0:return i.prev=0,i.next=3,oe.a.awrap(fetch(e,Object(u.a)({},t,{signal:a})));case 3:return n=i.sent,i.next=6,oe.a.awrap(n.json());case 6:r=i.sent,c({loading:!1,data:r,error:null}),i.next=16;break;case 10:if(i.prev=10,i.t0=i.catch(0),"AbortError"!==i.t0.name){i.next=14;break}return i.abrupt("return");case 14:throw c({loading:!1,data:null,error:i.t0}),i.t0;case 16:case"end":return i.stop()}}),null,null,[[0,10]])}(),function(){return n.abort()}}),Object(b.a)(n));var s=function(e){return o.data instanceof Array||"object"!==typeof o.data?c(Object(u.a)({},o,{data:e})):c(Object(u.a)({},o,{data:Object(u.a)({},o.data,{},e)}))};return[o.loading,o.data,o.error,s]},le=function(e){switch(e){case"Network":return["network","aggregate"];case"Timeseries":return["time","timeplot"];case"Text":return["text","textbox"];default:return["network","aggregate"]}},ue=function(){var e=Object(r.useContext)(g).ramUpdate;return function(t,n,a){var r=le(a),i=Object(l.a)(r,2),o=i[0],c=i[1];e({type:"CREATE",data:{title:t,subtitle:n,type:o,view:c}})}},se=function(e){var t=e.toggle,n=ce("api/add_view.json"),a=Object(l.a)(n,4),o=a[0],c=a[1],u=a[2],s=a[3],d=Object(r.useRef)(),m=re("title"),f=re("subtitle"),v=ue();if(o)return i.a.createElement("p",null,"Loading...");if(u)return i.a.createElement("p",null,"Error: ",u.message);var p={autoComplete:"off",autoCorrect:"off"};return i.a.createElement(ae,{autoComplete:!1},i.a.createElement("label",null,"Title"),i.a.createElement("input",Object.assign({},m,p,{ref:d})),i.a.createElement("label",null,"Subtitle"),i.a.createElement("input",Object.assign({},f,p)),i.a.createElement("label",null,"Type"),i.a.createElement("select",{required:!0,value:c.type,onChange:function(e){var t=e.target,n=t.name,a=t.value;return s(Object(K.a)({},n,a))},name:"type",style:{marginTop:"0.125rem"}},c.type_options.map((function(e,t){return i.a.createElement("option",{key:t,value:e,disabled:""===e},""===e?"No Selection":e)}))),i.a.createElement("div",{className:ee.a.AddButton,onClick:function(){""!=m.value?(v(m.value,f.value,c.type),t({preventDefault:function(){}}),m.onChange({target:{value:""}}),f.onChange({target:{value:""}})):d.current.focus()}},"Add"))},de=Object(r.memo)((function(){var e=U(!1),t=Object(l.a)(e,2),n=t[0],a=t[1],r=n?void 0:{height:0,minHeight:0};return i.a.createElement("div",{className:ee.a.AddContainer},i.a.createElement("div",{className:ee.a.AddPanel,onClick:a},n?"-":"+"),i.a.createElement("div",{className:ee.a.PanelContent},i.a.createElement("div",{className:ee.a.AddForm,style:r},i.a.createElement(se,{toggle:a}))))})),me=n(18),fe=n.n(me),ve=function(){var e=Object(r.useContext)(S),t=e.active,n=e.annotation,a=e.setAnnotationField,o=function(e){var t=e.target,n=t.name,r=t.value;a(n,r)};return console.log("annotation",n),i.a.createElement(ae,null,i.a.createElement("div",{className:fe.a.Controls},i.a.createElement("div",{className:fe.a.Status},"DB SAVED"),i.a.createElement("div",{className:fe.a.NewAnnotation},"NEW ANNOTATION")),i.a.createElement("label",null,"From Time"),i.a.createElement("input",{type:"text",value:t.timeStart,onChange:o,name:"timeStart"}),i.a.createElement("label",null,"To Time"),i.a.createElement("input",{type:"text",value:t.timeEnd,onChange:o,name:"timeEnd"}),i.a.createElement("label",null,"Collection"),i.a.createElement("input",{type:"text",value:t.collection,onChange:o,name:"collection"}),i.a.createElement("label",null,"Series"),i.a.createElement("input",{type:"text",value:t.series,onChange:o,name:"series"}),i.a.createElement("label",null,"From Node"),i.a.createElement("input",{type:"text",value:t.fromNode,onChange:o,name:"fromNode"}),i.a.createElement("label",null,"To Node"),i.a.createElement("input",{type:"text",value:t.toNode,onChange:o,name:"toNode"}),i.a.createElement("label",null,"Title"),i.a.createElement("input",{type:"text",value:t.title,onChange:o,name:"title"}),i.a.createElement("label",null,"Description"),i.a.createElement("textarea",{className:"customScrollBar",rows:"5",name:"description",value:t.description,onChange:o}))};var pe=function(e,t){var n,a=s(),r="N"==(n=t.data.property)?["[{id,node}]","node"]:"S"==n?["[{time,value}]","time"]:"E"==n?["[{id,source,target}]","network"]:"A"==n?["","annotation"]:["",null],i=Object(l.a)(r,2),o=i[0],c=i[1];return null==c?e:("annotation"==c?(e.annotations[a]={id:a,data:t.data},e.annotations.allIds.push(a)):(e.dataset[c][a]={id:a,type:c,format:o,label:t.data.label,data:t.data.data,treeLocation:t.data.treeLocation},e.dataset[c].allIds.push(a)),e)};var ge=function(e,t){switch(t.type){case"load":return pe(e,t);default:return e}},Ee=function(){var e=Object(r.useContext)(we).memoryUpdate,t=ce("./datasets"),n=Object(l.a)(t,4),a=n[0],o=n[1],c=n[2];n[3];return a?i.a.createElement("div",{id:"DataLayer",className:"loading"}):c?i.a.createElement("div",{id:"DataLayer",className:"error"}):(o.map((function(t){e({type:"load",data:{type:t.type,label:t.label,data:t.data,format:"",treeLocation:t.treeLocation,property:t.property}})})),i.a.createElement("div",{id:"DataLayer",className:"loaded"}))},be={dataset:{network:{allIds:[]},time:{allIds:[]},node:{allIds:[]}},annotations:[]},we=Object(r.createContext)(),ye=function(e){var t=e.children,n=Object(r.useReducer)(ge,be),a=Object(l.a)(n,2),o=a[0],c=a[1];return i.a.createElement(we.Provider,{value:{memory:o,memoryUpdate:c,getDatasetList:function(){return[].concat(Object(b.a)(o.dataset.network.allIds.map((function(e){var t=o.dataset.network[e];return{label:t.label,type:t.type,id:t.id}}))),Object(b.a)(o.dataset.time.allIds.map((function(e){var t=o.dataset.time[e];return{label:t.label,type:t.type,id:t.id}}))))},getDataset:function(e,t){return k(o.dataset[e][t])}}},i.a.createElement(Ee,null),t)},he=n(20),Oe=n.n(he),je=function(e){var t=e.isSuggestions,n=e.setToggle,a=e.suggestions,r=e.children,o=e.value,c=e.onChange,l=e.onBlur;return i.a.createElement("div",{className:Oe.a.Autocomplete,onBlur:l},r,t&&i.a.createElement("div",{className:Oe.a.AutocompleteItems},a.filter((function(e){return e.startsWith(o)})).map((function(e){return i.a.createElement("div",{onMouseDown:(t=e,function(e){n(!1),c({target:{value:t}})})},e);var t}))))},_e=function(e,t){var n=Object(r.useContext)(we).getDatasetList,a=Object(r.useContext)(g),i=a.ram,o=a.ramUpdate;return function(a){var r=i.views.find((function(t){return t.id==e}));r.inputs=n().filter((function(e){return e.type===t})).filter((function(e){return a.includes(e.label)})),o({type:"CHANGE",key:"views",id:e,data:r})}},xe=function(e){var t=e.viewId,n=(0,Object(r.useContext)(we).getDatasetList)().filter((function(e){return"network"===e.type})).map((function(e){return e.label})),a=U(!1),c=Object(l.a)(a,3),u=c[0],s=c[2],d=re("datasetInput",""),m=_e(t,"network"),f=Object(r.useRef)(),v=function(e){d.onChange(e);var t,a=Object(o.findDOMNode)(f.current).classList;t=e.target.value,(n.includes(t)||""==t)&&a.contains("invalid")?a.remove("invalid"):a.contains("invalid")||a.add("invalid")};return i.a.createElement(i.a.Fragment,null,i.a.createElement(je,Object.assign({},d,{onChange:v,suggestions:n,isSuggestions:u,setToggle:s,onBlur:function(e){if(n.includes(d.value)||""==d.value)return s(!1),Object(o.findDOMNode)(f.current).classList.remove("invalid"),void m([d.value]);setTimeout((function(){f.current.focus()}),1)}}),i.a.createElement("label",null,"Dataset"),i.a.createElement("input",Object.assign({type:"text"},d,{onChange:v,onFocus:function(){s(!0)},ref:f}))))},Ae=function(e,t){var n=Object(r.useContext)(T),a=n.grid,i=n.dispatch,o=Object(r.useContext)(g).ramUpdate,c="".concat(e,".").concat(t),l=w(a).find((function(e){return e===c}));return function(){i({type:l?"REMOVE_VIEW":"",view:c}),o({type:"DELETE",id:t})}},Ce=function(e,t){var n=e.split("."),a=Object(l.a)(n,2),r=(a[0],a[1]);return t.views.find((function(e){return e.id===r}))},Te=function(e,t,n,a){var r=Ce(".".concat(t),e).fields;return r[n].value=a,{type:"CHANGE",key:"views",id:t,data:{fields:r}}},Ne=function(e){var t=e.value,n=e.handleChange,a=e.defaultValue,o=e.name,c=re(o,t),l=Object(r.useRef)();return i.a.createElement("input",Object.assign({},c,{onChange:function(e){var t=e.target.value;c.onChange({target:{value:t}})},placeholder:""==a?"DD/MM/YYYY":a,onBlur:function(){!function(e){if(""==e)return!0;var t=e.split("/").reverse().join("-");return!isNaN(new Date(t).getTime())}(c.value)?setTimeout((function(){l.current.focus()}),1):c.value!=t&&n({target:{name:o,value:c.value.split("/").reverse().join()}})},ref:l}))};var ke=function(e){var t=e.fields,n=e.id,a=Object(r.useContext)(g),o=a.ram,c=a.ramUpdate,u=ce("api/field_options.json"),s=Object(l.a)(u,3),d=s[0],m=s[1],f=s[2];if(d)return i.a.createElement("p",null,"Loading...");if(f)return i.a.createElement("p",null,"Error: ",f.message);var v=function(e){var t=e.target,a=t.name,r=t.value,i=Te(o,n,a,r);c(i)};return Object.values(t).map((function(e){return"time"==e.type?i.a.createElement(i.a.Fragment,null,i.a.createElement("label",null,e.label),i.a.createElement(Ne,Object.assign({},e,{name:e.key,defaultValue:e.default,handleChange:v}))):i.a.createElement(i.a.Fragment,null,i.a.createElement("label",null,e.label),i.a.createElement("select",{required:!0,value:e.value,onChange:v,name:e.key},(t=e.type,m[t].options.map((function(e,t){return i.a.createElement("option",{key:t,value:e,disabled:""===e},""===e?"No Selection":e)})))));var t}))},Ie=function(e){var t=e.view_id,n=e.view_type,a=Object(r.useContext)(g).ram,o=Ce(".".concat(t),a),c=Ae(n,t);return"fields"in o?i.a.createElement(ae,null,i.a.createElement(xe,{viewId:t}),i.a.createElement(ke,o),i.a.createElement("div",{onClick:c,className:"delete-button"},"DELETE VIEW")):i.a.createElement("p",{style:{fontSize:".7rem"}},"Drag the view icon to the desired location...")},De=n(21),Se=n.n(De),Pe=n(22),Le=n.n(Pe),Ve=n(14),Be=n.n(Ve),Re=function(e){var t=e.item,n=e.i,a=e.id,r=e.remove;return i.a.createElement("div",{className:Be.a.PlotItem},i.a.createElement("b",{onClick:function(){return r(a,n)}},"X"),i.a.createElement("span",null,t))},We=n(23),Me=n.n(We),Fe=function(e){var t=e.id,n=e.suggestions,a=e.children,r=e.value,o=e.addData,c=e.setInputActivity,u=U(!0),s=Object(l.a)(u,3),d=s[0],m=(s[1],s[2]);return i.a.createElement("form",{autoComplete:!1},i.a.createElement("div",{className:Me.a.Autocomplete,onBlur:function(){return c(!1)}},a,d&&i.a.createElement("div",{className:Me.a.AutocompleteItems},n.filter((function(e){return e.startsWith(r)})).map((function(e){return i.a.createElement("div",{onMouseDown:(n=e,function(e){e.preventDefault(),m(!1),c(!1),o(t,n)})},e);var n})))))},He=function(e){var t=e.setInputActivity,n=e.content,a=e.addData,o=e.id,c=(0,Object(r.useContext)(we).getDatasetList)().filter((function(e){return"time"===e.type})).map((function(e){return e.label})),l=Object(r.useRef)(),u=re("datasetInput"),s=Object(b.a)(c).filter((function(e){return!n.includes(e)}));return Object(r.useEffect)((function(){s.length?l.current.focus():t(!1)})),i.a.createElement(Fe,Object.assign({},u,{id:o,addData:a,suggestions:s,setInputActivity:t}),i.a.createElement("div",{className:Be.a.PlotItem},i.a.createElement("b",{onClick:function(){return t(!1)}},"X"),i.a.createElement("input",Object.assign({},u,{onChange:function(e){(function(e){var t=e.target.value;return s.filter((function(e){return e.startsWith(t)})).length})(e)&&u.onChange(e)},ref:l}))))},ze=function(e){var t=e.id,n=e.label,a=e.content,r=e.remove,o=e.addData,c=e.isInputActive,l=e.setInputActivity;return i.a.createElement("div",{className:Le.a.Plot},i.a.createElement("h5",null,n),i.a.createElement("div",{className:Le.a.PlotContent,onDoubleClick:function(){return c?null:l(!0)}},c&&i.a.createElement(He,{id:t,content:a,setInputActivity:l,addData:o}),a.map((function(e,n){return i.a.createElement(Re,{item:e,i:n,remove:r,id:t,key:e})}))))},Ue=function(e){var t=e.view_type,n=e.view_id,a=U(!1),o=Object(l.a)(a,3),c=o[0],u=o[1],s=o[2],d=Ae(t,n),m=Object(r.useContext)(g),f=m.ram,v=(m.ramUpdate,Ce(".".concat(n),f)),p=_e(n,"time"),E=Object(r.useState)([{id:"mainplot",label:"Main Plot",content:v.inputs?v.inputs.map((function(e){return e.label})):[]}]),w=Object(l.a)(E,2),y=w[0],h=w[1],O=function(e){var t;h(e);var n=(t=[]).concat.apply(t,Object(b.a)(e.map((function(e){return e.content}))));p(n)};if(!("fields"in v))return i.a.createElement("p",{style:{fontSize:".7rem"}},"Drag the view icon to the desired location...");var j=function(e,t){var n=Object(b.a)(y);e=n.findIndex((function(t){return t.id===e})),n[e].content.splice(t,1),O(n)},_=function(e,t){var n=Object(b.a)(y);e=n.findIndex((function(t){return t.id===e})),n[e].content.unshift(t),O(n)};return i.a.createElement(i.a.Fragment,null,i.a.createElement("div",{className:Se.a.TimeSeriesView},i.a.createElement("div",{className:Se.a.AddPlot,onClick:u},"+"),y.map((function(e){return i.a.createElement(ze,Object.assign({},e,{remove:j,addData:_,isInputActive:c,setInputActivity:s,key:e.id}))}))),i.a.createElement(ae,null,i.a.createElement(ke,v),i.a.createElement("div",{onClick:d,className:"delete-button"},"DELETE VIEW")))},Je=(n(56),function(e){var t=e.view_id,n=e.view_type,a=Object(r.useContext)(g).ram,o=Ce(".".concat(t),a),c=Ae(n,t);return"fields"in o?i.a.createElement(ae,null,i.a.createElement(ke,o),i.a.createElement("div",{onClick:c,className:"delete-button"},"DELETE VIEW")):i.a.createElement("p",{style:{fontSize:".7rem"}},"Drag the view icon to the desired location...")}),Ge=(n(42),Object(r.memo)((function(){var e=re("from_time"),t=re("to_time");return i.a.createElement(ae,null,i.a.createElement("label",null,"From Time"),i.a.createElement("input",e),i.a.createElement("label",null,"To Time"),i.a.createElement("input",t))}))),Ye=function(e){var t=e.views;return t.filter((function(e){return"text"===e.type})).map((function(e){return i.a.createElement(Z,{title:"".concat(e.title),subTitle:"".concat(e.subTitle),icon:"TextIcon",open:!1,view_type:"text",view_id:e.id,key:e.id},i.a.createElement(Je,{views:t,view_type:"text",view_id:e.id}))}))},$e=function(e){var t=e.views;return t.filter((function(e){return"time"===e.type})).map((function(e){return i.a.createElement(Z,{title:"".concat(e.title),subTitle:"".concat(e.subTitle),icon:"ChartIcon",open:!1,view_type:"time",view_id:e.id,key:e.id},i.a.createElement(Ue,{views:t,view_type:"time",view_id:e.id}))}))},qe=function(e){var t=e.views;return t.filter((function(e){return"network"===e.type})).map((function(e){return i.a.createElement(Z,{title:"".concat(e.title),subTitle:"".concat(e.subTitle),icon:"NetworkIcon",open:!1,view_type:"network",view_id:e.id,key:e.id},i.a.createElement(Ie,{views:t,view_type:"network",view_id:e.id}))}))},Xe=function(){var e=Object(r.useContext)(g),t=e.ram;e.ramUpdate,Object(r.useContext)(T).grid;return i.a.createElement("div",{className:V.a.Sidebar},i.a.createElement(J,null,i.a.createElement(Z,{title:"DATA",flexOpen:!0}),i.a.createElement(Z,{title:"ANNOTATION"},i.a.createElement(ve,null))),i.a.createElement(J,null,i.a.createElement(Z,{title:"SYNCHRONIZE ALL"},i.a.createElement(Ge,null)),i.a.createElement(Ye,t),i.a.createElement($e,t),i.a.createElement(qe,t),i.a.createElement(de,null)))},Ze=n(9),Ke=n.n(Ze),Qe=Object(r.memo)((function(e){var t=e.view,n=e.vertical,a=Object(r.useContext)(T).dispatch,o=function(e){e.preventDefault()},c=function(e){var t=e.target;setTimeout((function(){return t.classList.add("active")}),1)},l=function(e){var t=e.target;setTimeout((function(){return t.classList.remove("active")}),1)},u=function(e){e.preventDefault&&e.preventDefault(),e.stopPropagation&&e.stopPropagation();var t=e.dataTransfer.getData("text"),r=e.target.getAttribute("view"),i=e.target.getAttribute("pos");t&&r&&i&&(setTimeout((function(){var e=document.getElementById("MainView");e.classList.remove("drag"),e.querySelectorAll(".drop-zone div").forEach((function(e){return e.classList.remove("active")})),e.querySelectorAll(".drag").forEach((function(e){return e.classList.remove("drag")}))}),1),a({type:"MOVE_VIEW",dragged:t,to:r,pos:i,vertical:n}))};return i.a.createElement("div",{className:"drop-zone"},["center","top","right","bottom","left"].map((function(e){return i.a.createElement("div",{className:e,key:e,view:t,pos:e,onDragOver:o,onDragEnter:c,onDragLeave:l,onDrop:u})})))})),et=function(e,t){return e[t.key]=Object.assign(e[t.key],t.data),e},tt=function(e,t){return delete e[t.key],e=e.filter((function(e){return e!==t.key}))},nt=function(e,t){return e[t.key]={timestamp:(new Date).toString()},e.allIds.push(t.key),e},at=function(e,t){switch(e.timestamp=(new Date).toString(),t.type){case"SET":return nt(e,t);case"CHANGE":return et(e,t);case"CLEAR":return tt(e,t);default:throw new Error("CACHE ERROR - Action: ".concat(t.type," is not available!"))}},rt=Object(r.createContext)(),it=function(e){var t=e.children,n=Object(r.useReducer)(at,{allIds:[]}),a=Object(l.a)(n,2),o=a[0],c=a[1];return i.a.createElement(rt.Provider,{value:{cache:o,cacheUpdate:c}},t)};Date.prototype.getTimeStamp=function(){return this.getDate()+"/"+(this.getMonth()+1)+"/"+this.getFullYear()};var ot=function(e,t){var n=t.map((function(e){return e.id})).join("-"),a={startTime:function(){var e;return t.forEach((function(t){var n=t.data,a=new Date(n[0].time);e=void 0==e?a:e<a?e:a})),void 0==e?"":e.getTimeStamp()},endTime:function(){var e;return t.forEach((function(t){var n=t.data,a=new Date(n[n.length-1].time);e=void 0==e?a:e<a?e:a})),void 0==e?"":e.getTimeStamp()},startAggregateTime:function(){var e=Object(l.a)(t,1)[0];return void 0==e?"":new Date(e.data[0].time_from).getTimeStamp()},endAggregateTime:function(){var e=Object(l.a)(t,1)[0];return void 0==e?"":new Date(e.data[e.data.length-1].time_from).getTimeStamp()}},r={};return Object.keys(e.fields).filter((function(t){return"time"==e.fields[t].type})).map((function(t){var n=e.fields[t];return n.default=a[t](),n})).forEach((function(e){r[e.key]=e})),{type:"CHANGE",key:"views",id:e.id,data:{fields:Object(u.a)({},e.fields,{},r),rendered:n}}},ct=function(e,t,n,a,r){e.dataset;var i=t.split("."),o=Object(l.a)(i,2);o[0];return{type:"CHANGE",key:"views",id:o[1],data:{fields:k(a).map((function(e){return e.value=e.default,e})).reduce((function(e,t){return e[t.key]=t,e}),{}),inputs:n,rendered:r}}},lt={responsive:!0,maintainAspectRatio:!1,animation:!1,events:["click"],onClick:function(e){console.log(e)}},ut=["#A8322D","#5B4E77","#218380","#FBB13C","#2E5EAA","#73D2DE"],st=n(43),dt=n.n(st),mt=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null,a=JSON.parse(JSON.stringify(e)).map((function(e){return e.time=new Date(e.time).getTime(),e}));return t=null==t||""==t?0:new Date(t).getTime(),n=null==n||""==n?Math.max.apply(Math,Object(b.a)(a.map((function(e){return e.time}))))+1:new Date(n).getTime(),a.filter((function(e){return e.time>=t&&e.time<=n}))},ft={chart:function(e){e.title;var t=e.inputs,n=e.fields,a=e.updateAnnotation,o=i.a.createRef(),c=k(t).map((function(e){return e.data=mt(e.data,n.startTime.value,n.endTime.value),e}));return Object(r.useEffect)((function(){var e=new dt.a(o.current,{type:"line",data:{labels:c[0].data.map((function(e){return new Date(e.time).toDateString()})),datasets:c.map((function(e,t){return{id:e.id,treeLocation:e.treeLocation,label:e.label,data:e.data.map((function(e){return e.value})),ids:e.data.map((function(e){return e.id})),borderColor:ut[t]}}))},options:Object(u.a)({},lt,{onClick:function(t){var n=e.getElementAtEvent(t)[0];if(n){var r=e.data.labels[n._index],i=e.data.datasets[n._datasetIndex],o=i.data[n._index],c=i.ids[n._index];a({id:i.label+"_"+c,title:"",timeStart:r,collection:i.treeLocation,series:i.label,description:"Value: ".concat(o)})}}})})})),i.a.createElement("div",{style:{margin:"auto",height:"100%",width:"100%"}},i.a.createElement("canvas",{ref:o}))},inputs:[{type:"time",format:"[{t,y}]",maxCurves:null}],fields:[{label:"Start time",type:"time",key:"startTime",default:""},{label:"End time",type:"time",key:"endTime",default:""}]},vt=n(10),pt=n.n(vt),gt=function(e){return Object(b.a)(new Set([].concat(Object(b.a)(e.map((function(e){return e.source}))),Object(b.a)(e.map((function(e){return e.target})))))).map((function(e){return{data:{id:e}}}))},Et=function(e){return{edges:e.map((function(e){return e.id=e.source+"-"+e.target,{data:e}})),nodes:gt(e)}},bt={chart:function(e){e.title,e.inputs;var t=e.fields,n=i.a.createRef();return Object(r.useEffect)((function(){pt()({container:n.current,elements:Et([{id:"ab",source:"a",target:"b"}]),style:[{selector:"node",style:{"background-color":t.nodeBackgroundColor.value,label:"data(id)"}},{selector:"edge",style:{width:t.edgeWidth.value,"line-color":t.edgeColor.value,"target-arrow-color":"#ccc","target-arrow-shape":"triangle"}}],layout:{name:"grid",rows:1}}).on("tap","node",(function(e){var t=e.target;console.log("tapped "+t.id())}))})),i.a.createElement("div",{style:{width:"100%",height:"100%",overflow:"hidden"},ref:n})},inputs:[{type:"network",format:"[{data:{id,source,target}}]"}],fields:[{label:"Node color",type:"color",key:"nodeBackgroundColor",default:"green"},{label:"Edge color",type:"color",key:"edgeColor",default:"grey"},{label:"Edge width",type:"number",key:"edgeWidth",default:3}]},wt=n(44),yt=n.n(wt),ht=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null;null!=t&&""!=t||(t=e[0].time_from),null!=n&&""!=n||(n=e[e.length-1].time_from);for(var a=e.filter((function(e){return new Date(e.time_from)>=new Date(t)&&new Date(e.time_from)<=new Date(n)})),r={},i=0;i<a.length;i++){var o=a[i],c=o.source,l=o.target,u=o.weight;void 0==r[c]&&(r[c]={}),void 0==r[c][l]&&(r[c][l]=0),r[c][l]+=+u?+u:1}var s=[];return Object.keys(r).forEach((function(e){Object.keys(r[e]).forEach((function(t){s.push({source:e,target:t,weight:r[e][t]})}))})),s};pt.a.use(yt.a);var Ot={chart:function(e){e.title;var t=e.inputs,n=e.fields,a=e.updateAnnotation,o=i.a.createRef();return console.log("inputs",t),Object(r.useEffect)((function(){var e="time_from"in t[0].data[0]?ht(t[0].data,n.startAggregateTime.value,n.endAggregateTime.value):t[0].data,r=Et(e),i=pt()({container:o.current,elements:r,style:[{selector:"node",style:{"background-color":n.nodeBackgroundColor.value,label:"data(id)",height:1.5*n.nodeSize.value,width:1.5*n.nodeSize.value,color:n.textColor.value,"font-size":n.textSize.value}},{selector:"edge",style:{width:n.edgeWidth.value/1.5,"line-color":n.edgeColor.value,"target-arrow-color":"#ccc","target-arrow-shape":"triangle"}}],layout:{name:"grid",rows:1}});i.layout({name:n.cytoRender.value,ready:function(){},stop:function(){},animate:!1,animationEasing:void 0,animationDuration:void 0,animateFilter:function(e,t){return!0},animationThreshold:250,refresh:20,fit:!0,padding:30,boundingBox:void 0,nodeDimensionsIncludeLabels:!1,randomize:!1,componentSpacing:40,nodeRepulsion:function(e){return 2048},nodeOverlap:4,idealEdgeLength:function(e){return 32},edgeElasticity:function(e){return 32},nestingFactor:1.2,gravity:1,numIter:1e3,initialTemp:1e3,coolingFactor:.99,minTemp:1}).run(),i.on("tap","node",(function(e){var n=e.target.id();a({id:t[0].id+"_node_"+n,fromNode:n,collection:t[0].treeLocation,series:t[0].label})})),i.on("tap","edge",(function(e){var n=e.target._private.data;a({id:t[0].id+"_edge_"+n.id,fromNode:n.source,toNode:n.target,collection:t[0].treeLocation,description:"weight : ".concat(n.weight),series:t[0].label})}))})),i.a.createElement("div",{style:{width:"100%",height:"100%",overflow:"hidden"},ref:o})},inputs:[{type:"network",format:"[{weight,source,target,time}]"}],fields:[{label:"Start time",type:"time",key:"startAggregateTime",default:""},{label:"End time",type:"time",key:"endAggregateTime",default:""},{label:"Node size",type:"number",key:"nodeSize",default:3},{label:"Node color",type:"color",key:"nodeBackgroundColor",default:"green"},{label:"Text size",type:"number",key:"textSize",default:3},{label:"Text color",type:"color",key:"textColor",default:"white"},{label:"Edge color",type:"color",key:"edgeColor",default:"grey"},{label:"Edge width",type:"number",key:"edgeWidth",default:1},{label:"Layout",type:"cyto_render",key:"cytoRender",default:"cose"}]},jt=n(45),_t=n.n(jt),xt=n(46),At=n.n(xt),Ct=n(24),Tt=n.n(Ct),Nt={chart:function(e){var t=e.id,n=(e.title,e.inputs,e.fields,Object(r.useContext)(rt)),a=n.cache,o=n.cacheUpdate,c=i.a.createRef(),u=U(!1),s=Object(l.a)(u,3),d=s[0],m=s[1],f=s[2],v=Object(r.useState)(a[t].text?a[t].text:"# Welcome to Ripple\n\n*Ripple* is a platform to allow data experts and domain experts to share insights. \ud83d\ude00\n"),p=Object(l.a)(v,2),g=p[0],E=p[1],b=function(e){o({type:"CHANGE",key:t,data:{text:e}})},w=function(e){E(e.target.value)},y=function(e){d&&b(g),f(!1)};return Object(r.useEffect)((function(){d&&c.current.focus()})),i.a.createElement("div",{style:{height:"100%",width:"100%"},onDoubleClick:function(e){d&&b(g),m(e)}},d?i.a.createElement("textarea",{className:Tt.a.textboxInput+" customScrollBar",rows:"5",name:"textBox",value:g,onChange:w,placeholder:"Please enter your text...",onBlur:y,ref:c}):i.a.createElement("div",{className:Tt.a.textboxContainer+" customScrollBar"},At()(_t()(g))))},inputs:[{type:"text",format:"string",editable:!0}],fields:[],isInputRequired:!1},kt=function(e,t){return console.log("ReRender?:",e.version==t.version),e.version==t.version},It=function(e){var t=function(e,t){switch("".concat(e,"|").concat(t)){case"time|timeplot":return ft;case"network|simple":return bt;case"network|aggregate":return Ot;case"text|textbox":return Nt;default:return{chart:function(){return i.a.createElement("div",null,"Template name ",t," for a ",e," chart was not found")},inputs:[],fields:[]}}}(e.type,e.view);return[Object(r.memo)((function(e){var n=!("isInputRequired"in t)||t.isInputRequired;return n&&e.inputs.length&&"data"in e.inputs[0]||!n?t.chart(e):i.a.createElement("div",null,"Please select an input...")}),kt),t.inputs,t.fields]},Dt=Object(r.memo)((function(e){var t=e.view,n=(e.version,e.updateAnnotation),a=Object(r.useContext)(we),o=a.memory,c=a.getDataset,u=Object(r.useContext)(g),s=u.ram,d=u.ramUpdate,m=Object(r.useContext)(rt),f=m.cache,v=m.cacheUpdate,p=Ce(t,s),E=It(p),b=Object(l.a)(E,3),w=b[0],y=b[1],h=b[2],O=p.id;(O in f||v({type:"SET",key:O}),"rendered"in p)||d(ct(o,t,y,h,p.view));var j=p.inputs.filter((function(e){return"id"in e})).map((function(e){return c(e.type,e.id)}));p.rendered!=j.map((function(e){return e.id})).join("-")&&d(ot(p,j));return i.a.createElement(w,Object.assign({},p,{inputs:j,updateAnnotation:n}))}),(function(e,t){return e.version==t.version})),St=function(e){var t="".concat(e.type,": ").concat(e.title);return t.charAt(0).toUpperCase()+t.substring(1)},Pt=Object(r.memo)((function(e){var t=e.view,n=Object(r.useContext)(g).ram,a=Ce(t,n),o=St(a);return i.a.createElement("div",Object.assign({className:"WindowTitle "+Ke.a.WindowTitle,view:t},X(t)),i.a.createElement(z,{height:"8"}),i.a.createElement("h5",null,o))})),Lt=function(e){var t=e.view,n=e.vertical,a=e.isViewActive,o=Object(r.useContext)(T).getVersion,c=Object(r.useContext)(S).updateAnnotation;return i.a.createElement("div",{className:"Window "+Ke.a.Window,view:t},i.a.createElement(Pt,{view:t}),i.a.createElement("div",{className:Ke.a.WindowContent},a&&i.a.createElement(Dt,{view:t,version:o(t),key:t,updateAnnotation:c})),i.a.createElement(Qe,{view:t,vertical:n}))},Vt=n(47),Bt=n.n(Vt),Rt=function(e){var t=e.setViewsActivity,n=e.vertical,a=Object(r.useRef)(null),o=Object(r.useRef)(null),c=Object(r.useRef)(null);return Object(r.useEffect)((function(){document.getElementById("MainView").classList.remove("drag");var e=c.current,r=e.parentElement,i=e.previousElementSibling,l=n?r.clientWidth:r.clientHeight,u=function(e){a.current=n?e.clientX:e.clientY,o.current=n?i.clientWidth:i.clientHeight,setTimeout((function(){return document.getElementById("MainView").classList.add("drag")}),1),t(!1)},s=function(e){if(null!==a.current){var t=(n?e.clientX:e.clientY)-a.current,i=o.current+t,c=.3*l,u=.7*l;i<c&&(i=c),i>u&&(i=u);var s="minmax(min-content, ".concat(i,"px) 4px auto");r.style.gridTemplate="".concat(s," / ").concat(s)}},d=function(){setTimeout((function(){return document.getElementById("MainView").classList.remove("drag")}),1),a.current=null,o.current=null,t(!0)};return e.addEventListener("mousedown",u),window.addEventListener("mousemove",s),window.addEventListener("mouseup",d),function(){e.removeEventListener("mousedown",u),window.removeEventListener("mousemove",s),window.removeEventListener("allmouseup",d)}})),i.a.createElement("div",{className:"".concat(Bt.a.Handler," handler-").concat(n?"cols":"rows"),ref:c})},Wt=n(48),Mt=n.n(Wt),Ft=function e(t){var n=t.grid,a=t.vertical,r=t.areViewsActive,o=t.setViewsActivity,c=n.filter(Boolean).map((function(){return"1fr"})).join(" 4px "),l={gridTemplate:"".concat(c," / ").concat(c)};if(1===n.length){if(Array.isArray(n[0]))return i.a.createElement(e,{grid:n[0],vertical:!a,areViewsActive:r,setViewsActivity:o});if("string"===typeof n[0])return i.a.createElement(Lt,{view:n[0],vertical:a,isViewActive:r})}return i.a.createElement("div",{className:"".concat(Mt.a.Grid," grid-").concat(a?"cols":"rows"),style:l},"string"===typeof n[0]&&i.a.createElement(Lt,{view:n[0],vertical:a,isViewActive:r}),Array.isArray(n[0])&&i.a.createElement(e,{grid:n[0],vertical:!a,areViewsActive:r,setViewsActivity:o}),n[1]&&i.a.createElement(Rt,{setViewsActivity:o,view:n[0],vertical:a}),"string"===typeof n[1]&&i.a.createElement(Lt,{view:n[1],vertical:a,isViewActive:r}),Array.isArray(n[1])&&i.a.createElement(e,{grid:n[1],vertical:!a,areViewsActive:r,setViewsActivity:o}))},Ht=(n(107),function(){var e=Object(r.useContext)(T).grid,t=(Object(r.useContext)(we).memory,Object(r.useContext)(g).ram,U(!0)),n=Object(l.a)(t,3),a=n[0],o=(n[1],n[2]),c=function(){var e=new Event("allmouseup");window.dispatchEvent(e)};return Object(r.useEffect)((function(){return window.addEventListener("mouseup",c),window.removeEventListener("allmouseup",c)})),i.a.createElement("div",{id:"MainView"},i.a.createElement(Ft,{grid:e,areViewsActive:a,setViewsActivity:o,vertical:!0}))}),zt=function(e){var t=e.children;return i.a.createElement(ye,null,i.a.createElement(E,null,i.a.createElement(N,null,i.a.createElement(it,null,i.a.createElement(P,null,t)))))},Ut=function(){return i.a.createElement("div",{className:"App"},i.a.createElement(zt,null,i.a.createElement(Xe,null),i.a.createElement(Ht,null)))};Boolean("localhost"===window.location.hostname||"[::1]"===window.location.hostname||window.location.hostname.match(/^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/));c.a.render(i.a.createElement(Ut,null),document.getElementById("root")),"serviceWorker"in navigator&&navigator.serviceWorker.ready.then((function(e){e.unregister()}))},11:function(e,t,n){e.exports={Panel:"Panel_Panel__3MTlv",PanelTitle:"Panel_PanelTitle__3tYPw",IconActive:"Panel_IconActive__2VByb",PanelContent:"Panel_PanelContent__2JHYQ"}},14:function(e,t,n){e.exports={PlotItem:"PlotItem_PlotItem__2GNUg"}},16:function(e,t,n){e.exports={PanelsList:"PanelsList_PanelsList__rb-Pb",Panels:"PanelsList_Panels__2etY7",PanelsToggle:"PanelsList_PanelsToggle__3822R"}},18:function(e,t,n){e.exports={Controls:"Annotation_Controls__12rrE",NewAnnotation:"Annotation_NewAnnotation__3UYlz",Status:"Annotation_Status__BPcIw",loading:"Annotation_loading__qHNf_"}},20:function(e,t,n){e.exports={Autocomplete:"Autocomplete_Autocomplete__3htHv",AutocompleteItems:"Autocomplete_AutocompleteItems__3MS2c"}},21:function(e,t,n){e.exports={TimeSeriesView:"TimeSeriesView_TimeSeriesView__354Zn",AddPlot:"TimeSeriesView_AddPlot__H5Rer"}},22:function(e,t,n){e.exports={Plot:"Plot_Plot__SjKEj",PlotContent:"Plot_PlotContent__3Slwn"}},23:function(e,t,n){e.exports={Autocomplete:"Autocomplete_Autocomplete__1Ny7x",AutocompleteItems:"Autocomplete_AutocompleteItems__3bPd5"}},24:function(e,t,n){e.exports={textboxContainer:"TextBox_textboxContainer__1_Cxt",textboxInput:"TextBox_textboxInput__3n0MT"}},40:function(e,t,n){e.exports={Sidebar:"Sidebar_Sidebar__2ajNT"}},41:function(e,t,n){e.exports={Form:"Form_Form__2boAo"}},42:function(e,t,n){e.exports={TreeView:"TreeView_TreeView__2oCx5"}},47:function(e,t,n){e.exports={Handler:"Handler_Handler__3uFNB"}},48:function(e,t,n){e.exports={Grid:"Grid_Grid__3ySV2"}},49:function(e,t,n){e.exports=n(108)},5:function(e,t,n){e.exports={AddPanel:"AddPanel_AddPanel__1e6pW",AddForm:"AddPanel_AddForm__3h1b-",AddButton:"AddPanel_AddButton__tCCdE",PanelContent:"AddPanel_PanelContent__XhLfX"}},54:function(e,t,n){},56:function(e,t,n){},89:function(e,t){},9:function(e,t,n){e.exports={Window:"Window_Window__3LwvP",WindowTitle:"Window_WindowTitle__BInoL",WindowContent:"Window_WindowContent__1Ls4_"}}},[[49,1,2]]]);
//# sourceMappingURL=main.aabe91ed.chunk.js.map
|
import * as _vue from "vue";
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? Object(arguments[i]) : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
// GENERATE BY ./scripts/generate.ts
// DON NOT EDIT IT MANUALLY
import DingtalkOutlinedSvg from "@ant-design/icons-svg/es/asn/DingtalkOutlined";
import AntdIcon from '../components/AntdIcon';
var DingtalkOutlined = function DingtalkOutlined(props, context) {
var p = _objectSpread({}, props, context.attrs);
return _vue.createVNode(AntdIcon, _vue.mergeProps(p, {
"icon": DingtalkOutlinedSvg
}), null);
};
DingtalkOutlined.displayName = 'DingtalkOutlined';
DingtalkOutlined.inheritAttrs = false;
export default DingtalkOutlined;
|
// module for database connection
const sqlite3 = require('sqlite3');
// module to allow direct paths to fileSize
const path = require('path');
// module for accessing the file system
const fs = require('fs');
const searches = document.querySelector('#Searches');
//Path to the searches database
const dbPath = path.resolve('C:\\Users\Ansari\\Documents\\GitHub\\BrandNinja\\Searches.db');
function loadSearches() {
//Adds back button
searches.innerHTML = ("<div style=\"color:#444; border:1px solid #CCC; background:#DDD; box-shadow: 0 0 5px -1px rgba(0,0,0,0.2);" +
"cursor:pointer; vertical-align:middle;\" onclick=\"loadSearchInfo('','','','')\">" +
"<p style=\"text-align:center; color:Red\">" + "< Back" + "</p>" +
"</div>");
//Opens database connection
let db = new sqlite3.Database('dbPath', sqlite3.OPEN_READWRITE, (err) => {
if (err) {
console.error(err.message);
}
console.log('Connected to the Searches database.');
});
//Adds each saved search to the page
db.serialize(function() {
db.each("SELECT * FROM saved_searches", function(err, row) {
searches.innerHTML += ("<div style=\"color:#444; border:1px solid #CCC; background:#DDD; box-shadow: 0 0 5px -1px rgba(0,0,0,0.2);" +
"cursor:pointer; vertical-align:middle;\" onclick=\"loadSearchInfo('" + row.name + "','" + row.links + "','" + row.keywords + "','" + row.depth + "')\">" +
"<p style=\"text-align:center;\">" + row.name + "</p>" +
"</div>");
});
});
//Closes teh database connection
db.close();
};
function loadSearchInfo(searchName, searchURL, searchKeys, searchDepth) {
window.location.href=(path.resolve(__dirname, '../index.html') + "#name=" + searchName + "&URL=" + searchURL + "&keys=" + searchKeys + "&depth=" + searchDepth);
}
|
/*
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for
* license information.
*
* Code generated by Microsoft (R) AutoRest Code Generator.
* Changes may cause incorrect behavior and will be lost if the code is
* regenerated.
*/
'use strict';
const models = require('./index');
/**
* @class
* Initializes a new instance of the OperationResult class.
* @constructor
* @member {string} [status] The status of the request. Possible values
* include: 'Succeeded', 'Failed', 'canceled', 'Accepted', 'Creating',
* 'Created', 'Updating', 'Updated', 'Deleting', 'Deleted', 'OK'
*
* @member {object} [error]
*
* @member {number} [error.code] The error code for an operation failure
*
* @member {string} [error.message] The detailed arror message
*
*/
class OperationResult {
constructor() {
}
/**
* Defines the metadata of OperationResult
*
* @returns {object} metadata of OperationResult
*
*/
mapper() {
return {
required: false,
serializedName: 'OperationResult',
type: {
name: 'Composite',
className: 'OperationResult',
modelProperties: {
status: {
required: false,
serializedName: 'status',
type: {
name: 'String'
}
},
error: {
required: false,
serializedName: 'error',
type: {
name: 'Composite',
className: 'OperationResultError'
}
}
}
}
};
}
}
module.exports = OperationResult;
|
import React from 'react';
import ReactDOM from 'react-dom';
import { Provider } from 'react-redux';
import { createStore, applyMiddleware } from 'redux';
import App from './components/app';
import reducers from './reducers';
import ReduxPromise from 'redux-promise';
const createStoreWithMiddleware = applyMiddleware(ReduxPromise)(createStore);
ReactDOM.render(
<Provider store={createStoreWithMiddleware(reducers)}>
<App />
</Provider>
, document.querySelector('.container-fluid'));
|
// modules are defined as an array
// [ module function, map of requireuires ]
//
// map of requireuires is short require name -> numeric require
//
// anything defined in a previous bundle is accessed via the
// orig method which is the requireuire for previous bundles
(function outer (modules, cache, entry) {
// Save the require from previous bundle to this closure if any
var previousRequire = typeof require == "function" && require;
function findProxyquireifyName() {
var deps = Object.keys(modules)
.map(function (k) { return modules[k][1]; });
for (var i = 0; i < deps.length; i++) {
var pq = deps[i]['proxyquireify'];
if (pq) return pq;
}
}
var proxyquireifyName = findProxyquireifyName();
function newRequire(name, jumped){
// Find the proxyquireify module, if present
var pqify = (proxyquireifyName != null) && cache[proxyquireifyName];
// Proxyquireify provides a separate cache that is used when inside
// a proxyquire call, and is set to null outside a proxyquire call.
// This allows the regular caching semantics to work correctly both
// inside and outside proxyquire calls while keeping the cached
// modules isolated.
// When switching from one proxyquire call to another, it clears
// the cache to prevent contamination between different sets
// of stubs.
var currentCache = (pqify && pqify.exports._cache) || cache;
if(!currentCache[name]) {
if(!modules[name]) {
// if we cannot find the the module within our internal map or
// cache jump to the current global require ie. the last bundle
// that was added to the page.
var currentRequire = typeof require == "function" && require;
if (!jumped && currentRequire) return currentRequire(name, true);
// If there are other bundles on this page the require from the
// previous one is saved to 'previousRequire'. Repeat this as
// many times as there are bundles until the module is found or
// we exhaust the require chain.
if (previousRequire) return previousRequire(name, true);
var err = new Error('Cannot find module \'' + name + '\'');
err.code = 'MODULE_NOT_FOUND';
throw err;
}
var m = currentCache[name] = {exports:{}};
// The normal browserify require function
var req = function(x){
var id = modules[name][1][x];
return newRequire(id ? id : x);
};
// The require function substituted for proxyquireify
var moduleRequire = function(x){
var pqify = (proxyquireifyName != null) && cache[proxyquireifyName];
// Only try to use the proxyquireify version if it has been `require`d
if (pqify && pqify.exports._proxy) {
return pqify.exports._proxy(req, x);
} else {
return req(x);
}
};
modules[name][0].call(m.exports,moduleRequire,m,m.exports,outer,modules,currentCache,entry);
}
return currentCache[name].exports;
}
for(var i=0;i<entry.length;i++) newRequire(entry[i]);
// Override the current require with this new one
return newRequire;
})
({1:[function(require,module,exports){
/**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
'use strict';
/**
* Half-precision floating-point negative infinity.
*
* @module @stdlib/constants/float16/ninf
* @type {number}
*
* @example
* var FLOAT16_NINF = require( '@stdlib/constants/float16/ninf' );
* // returns -infinity
*/
// MODULES //
var Number = require( '@stdlib/number/ctor' );
// MAIN //
/**
* Half-precision floating-point negative infinity.
*
* ## Notes
*
* Half-precision floating-point negative infinity has the bit sequence
*
* ```binarystring
* 1 11111 0000000000
* ```
*
* This bit sequence corresponds to the unsigned 16-bit integer `64512` and to the HEX value `0xfc00`.
*
* @constant
* @type {number}
* @default -infinity
* @see [half-precision floating-point format]{@link https://en.wikipedia.org/wiki/Half-precision_floating-point_format}
*/
var FLOAT16_NINF = Number.NEGATIVE_INFINITY; // TODO: if, and when, float16 is natively available, assign the true constant; otherwise, fall back to float64
// EXPORTS //
module.exports = FLOAT16_NINF;
},{"@stdlib/number/ctor":3}],2:[function(require,module,exports){
(function (__filename){(function (){
/**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
'use strict';
// MODULES //
var tape = require( 'tape' );
var Number = require( '@stdlib/number/ctor' );
var FLOAT16_NINF = require( './../lib' );
// TESTS //
tape( 'main export is a number', function test( t ) {
t.ok( true, __filename );
t.equal( typeof FLOAT16_NINF, 'number', 'main export is a number' );
t.end();
});
tape( 'export is equal to negative infinity', function test( t ) {
// Note: we rely on implicit type promotion. A 16-bit infinity should be promoted to a 64-bit infinity...
t.equal( FLOAT16_NINF, Number.NEGATIVE_INFINITY, 'equals -infinity' );
t.end();
});
}).call(this)}).call(this,"/lib/node_modules/@stdlib/constants/float16/ninf/test/test.js")
},{"./../lib":1,"@stdlib/number/ctor":3,"tape":108}],3:[function(require,module,exports){
/**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
'use strict';
/**
* Constructor which returns a `Number` object.
*
* @module @stdlib/number/ctor
*
* @example
* var Number = require( '@stdlib/number/ctor' );
*
* var v = new Number( 10.0 );
* // returns <Number>
*/
// MODULES //
var Number = require( './number.js' );
// EXPORTS //
module.exports = Number;
},{"./number.js":4}],4:[function(require,module,exports){
/**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
'use strict';
// EXPORTS //
module.exports = Number; // eslint-disable-line stdlib/require-globals
},{}],5:[function(require,module,exports){
'use strict'
exports.byteLength = byteLength
exports.toByteArray = toByteArray
exports.fromByteArray = fromByteArray
var lookup = []
var revLookup = []
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
for (var i = 0, len = code.length; i < len; ++i) {
lookup[i] = code[i]
revLookup[code.charCodeAt(i)] = i
}
// Support decoding URL-safe base64 strings, as Node.js does.
// See: https://en.wikipedia.org/wiki/Base64#URL_applications
revLookup['-'.charCodeAt(0)] = 62
revLookup['_'.charCodeAt(0)] = 63
function getLens (b64) {
var len = b64.length
if (len % 4 > 0) {
throw new Error('Invalid string. Length must be a multiple of 4')
}
// Trim off extra bytes after placeholder bytes are found
// See: https://github.com/beatgammit/base64-js/issues/42
var validLen = b64.indexOf('=')
if (validLen === -1) validLen = len
var placeHoldersLen = validLen === len
? 0
: 4 - (validLen % 4)
return [validLen, placeHoldersLen]
}
// base64 is 4/3 + up to two characters of the original data
function byteLength (b64) {
var lens = getLens(b64)
var validLen = lens[0]
var placeHoldersLen = lens[1]
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}
function _byteLength (b64, validLen, placeHoldersLen) {
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}
function toByteArray (b64) {
var tmp
var lens = getLens(b64)
var validLen = lens[0]
var placeHoldersLen = lens[1]
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
var curByte = 0
// if there are placeholders, only get up to the last complete 4 chars
var len = placeHoldersLen > 0
? validLen - 4
: validLen
var i
for (i = 0; i < len; i += 4) {
tmp =
(revLookup[b64.charCodeAt(i)] << 18) |
(revLookup[b64.charCodeAt(i + 1)] << 12) |
(revLookup[b64.charCodeAt(i + 2)] << 6) |
revLookup[b64.charCodeAt(i + 3)]
arr[curByte++] = (tmp >> 16) & 0xFF
arr[curByte++] = (tmp >> 8) & 0xFF
arr[curByte++] = tmp & 0xFF
}
if (placeHoldersLen === 2) {
tmp =
(revLookup[b64.charCodeAt(i)] << 2) |
(revLookup[b64.charCodeAt(i + 1)] >> 4)
arr[curByte++] = tmp & 0xFF
}
if (placeHoldersLen === 1) {
tmp =
(revLookup[b64.charCodeAt(i)] << 10) |
(revLookup[b64.charCodeAt(i + 1)] << 4) |
(revLookup[b64.charCodeAt(i + 2)] >> 2)
arr[curByte++] = (tmp >> 8) & 0xFF
arr[curByte++] = tmp & 0xFF
}
return arr
}
function tripletToBase64 (num) {
return lookup[num >> 18 & 0x3F] +
lookup[num >> 12 & 0x3F] +
lookup[num >> 6 & 0x3F] +
lookup[num & 0x3F]
}
function encodeChunk (uint8, start, end) {
var tmp
var output = []
for (var i = start; i < end; i += 3) {
tmp =
((uint8[i] << 16) & 0xFF0000) +
((uint8[i + 1] << 8) & 0xFF00) +
(uint8[i + 2] & 0xFF)
output.push(tripletToBase64(tmp))
}
return output.join('')
}
function fromByteArray (uint8) {
var tmp
var len = uint8.length
var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
var parts = []
var maxChunkLength = 16383 // must be multiple of 3
// go through the array every three bytes, we'll deal with trailing stuff later
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
}
// pad the end with zeros, but make sure to not forget the extra bytes
if (extraBytes === 1) {
tmp = uint8[len - 1]
parts.push(
lookup[tmp >> 2] +
lookup[(tmp << 4) & 0x3F] +
'=='
)
} else if (extraBytes === 2) {
tmp = (uint8[len - 2] << 8) + uint8[len - 1]
parts.push(
lookup[tmp >> 10] +
lookup[(tmp >> 4) & 0x3F] +
lookup[(tmp << 2) & 0x3F] +
'='
)
}
return parts.join('')
}
},{}],6:[function(require,module,exports){
},{}],7:[function(require,module,exports){
arguments[4][6][0].apply(exports,arguments)
},{"dup":6}],8:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
'use strict';
var R = typeof Reflect === 'object' ? Reflect : null
var ReflectApply = R && typeof R.apply === 'function'
? R.apply
: function ReflectApply(target, receiver, args) {
return Function.prototype.apply.call(target, receiver, args);
}
var ReflectOwnKeys
if (R && typeof R.ownKeys === 'function') {
ReflectOwnKeys = R.ownKeys
} else if (Object.getOwnPropertySymbols) {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target)
.concat(Object.getOwnPropertySymbols(target));
};
} else {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target);
};
}
function ProcessEmitWarning(warning) {
if (console && console.warn) console.warn(warning);
}
var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
return value !== value;
}
function EventEmitter() {
EventEmitter.init.call(this);
}
module.exports = EventEmitter;
module.exports.once = once;
// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._eventsCount = 0;
EventEmitter.prototype._maxListeners = undefined;
// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
var defaultMaxListeners = 10;
function checkListener(listener) {
if (typeof listener !== 'function') {
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
}
}
Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
enumerable: true,
get: function() {
return defaultMaxListeners;
},
set: function(arg) {
if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
}
defaultMaxListeners = arg;
}
});
EventEmitter.init = function() {
if (this._events === undefined ||
this._events === Object.getPrototypeOf(this)._events) {
this._events = Object.create(null);
this._eventsCount = 0;
}
this._maxListeners = this._maxListeners || undefined;
};
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
}
this._maxListeners = n;
return this;
};
function _getMaxListeners(that) {
if (that._maxListeners === undefined)
return EventEmitter.defaultMaxListeners;
return that._maxListeners;
}
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
return _getMaxListeners(this);
};
EventEmitter.prototype.emit = function emit(type) {
var args = [];
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
var doError = (type === 'error');
var events = this._events;
if (events !== undefined)
doError = (doError && events.error === undefined);
else if (!doError)
return false;
// If there is no 'error' event listener then throw.
if (doError) {
var er;
if (args.length > 0)
er = args[0];
if (er instanceof Error) {
// Note: The comments on the `throw` lines are intentional, they show
// up in Node's output if this results in an unhandled exception.
throw er; // Unhandled 'error' event
}
// At least give some kind of context to the user
var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
err.context = er;
throw err; // Unhandled 'error' event
}
var handler = events[type];
if (handler === undefined)
return false;
if (typeof handler === 'function') {
ReflectApply(handler, this, args);
} else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
ReflectApply(listeners[i], this, args);
}
return true;
};
function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;
checkListener(listener);
events = target._events;
if (events === undefined) {
events = target._events = Object.create(null);
target._eventsCount = 0;
} else {
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (events.newListener !== undefined) {
target.emit('newListener', type,
listener.listener ? listener.listener : listener);
// Re-assign `events` because a newListener handler could have caused the
// this._events to be assigned to a new object
events = target._events;
}
existing = events[type];
}
if (existing === undefined) {
// Optimize the case of one listener. Don't need the extra array object.
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === 'function') {
// Adding the second element, need to change to array.
existing = events[type] =
prepend ? [listener, existing] : [existing, listener];
// If we've already got an array, just append.
} else if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
// Check for listener leak
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
// No error code for this since it is a Warning
// eslint-disable-next-line no-restricted-syntax
var w = new Error('Possible EventEmitter memory leak detected. ' +
existing.length + ' ' + String(type) + ' listeners ' +
'added. Use emitter.setMaxListeners() to ' +
'increase limit');
w.name = 'MaxListenersExceededWarning';
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
return target;
}
EventEmitter.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.prependListener =
function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};
function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0)
return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
}
function _onceWrap(target, type, listener) {
var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
var wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}
EventEmitter.prototype.once = function once(type, listener) {
checkListener(listener);
this.on(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.prependOnceListener =
function prependOnceListener(type, listener) {
checkListener(listener);
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
// Emits a 'removeListener' event if and only if the listener was removed.
EventEmitter.prototype.removeListener =
function removeListener(type, listener) {
var list, events, position, i, originalListener;
checkListener(listener);
events = this._events;
if (events === undefined)
return this;
list = events[type];
if (list === undefined)
return this;
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
else {
delete events[type];
if (events.removeListener)
this.emit('removeListener', type, list.listener || listener);
}
} else if (typeof list !== 'function') {
position = -1;
for (i = list.length - 1; i >= 0; i--) {
if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
break;
}
}
if (position < 0)
return this;
if (position === 0)
list.shift();
else {
spliceOne(list, position);
}
if (list.length === 1)
events[type] = list[0];
if (events.removeListener !== undefined)
this.emit('removeListener', type, originalListener || listener);
}
return this;
};
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.removeAllListeners =
function removeAllListeners(type) {
var listeners, events, i;
events = this._events;
if (events === undefined)
return this;
// not listening for removeListener, no need to emit
if (events.removeListener === undefined) {
if (arguments.length === 0) {
this._events = Object.create(null);
this._eventsCount = 0;
} else if (events[type] !== undefined) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
else
delete events[type];
}
return this;
}
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
var keys = Object.keys(events);
var key;
for (i = 0; i < keys.length; ++i) {
key = keys[i];
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = Object.create(null);
this._eventsCount = 0;
return this;
}
listeners = events[type];
if (typeof listeners === 'function') {
this.removeListener(type, listeners);
} else if (listeners !== undefined) {
// LIFO order
for (i = listeners.length - 1; i >= 0; i--) {
this.removeListener(type, listeners[i]);
}
}
return this;
};
function _listeners(target, type, unwrap) {
var events = target._events;
if (events === undefined)
return [];
var evlistener = events[type];
if (evlistener === undefined)
return [];
if (typeof evlistener === 'function')
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
return unwrap ?
unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
}
EventEmitter.prototype.listeners = function listeners(type) {
return _listeners(this, type, true);
};
EventEmitter.prototype.rawListeners = function rawListeners(type) {
return _listeners(this, type, false);
};
EventEmitter.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === 'function') {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
};
EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events = this._events;
if (events !== undefined) {
var evlistener = events[type];
if (typeof evlistener === 'function') {
return 1;
} else if (evlistener !== undefined) {
return evlistener.length;
}
}
return 0;
}
EventEmitter.prototype.eventNames = function eventNames() {
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
};
function arrayClone(arr, n) {
var copy = new Array(n);
for (var i = 0; i < n; ++i)
copy[i] = arr[i];
return copy;
}
function spliceOne(list, index) {
for (; index + 1 < list.length; index++)
list[index] = list[index + 1];
list.pop();
}
function unwrapListeners(arr) {
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
}
function once(emitter, name) {
return new Promise(function (resolve, reject) {
function errorListener(err) {
emitter.removeListener(name, resolver);
reject(err);
}
function resolver() {
if (typeof emitter.removeListener === 'function') {
emitter.removeListener('error', errorListener);
}
resolve([].slice.call(arguments));
};
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
if (name !== 'error') {
addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
}
});
}
function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
if (typeof emitter.on === 'function') {
eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
}
}
function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
if (typeof emitter.on === 'function') {
if (flags.once) {
emitter.once(name, listener);
} else {
emitter.on(name, listener);
}
} else if (typeof emitter.addEventListener === 'function') {
// EventTarget does not have `error` event semantics like Node
// EventEmitters, we do not listen for `error` events here.
emitter.addEventListener(name, function wrapListener(arg) {
// IE does not have builtin `{ once: true }` support so we
// have to do it manually.
if (flags.once) {
emitter.removeEventListener(name, wrapListener);
}
listener(arg);
});
} else {
throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
}
}
},{}],9:[function(require,module,exports){
(function (process){(function (){
// 'path' module extracted from Node.js v8.11.1 (only the posix part)
// transplited with Babel
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
'use strict';
function assertPath(path) {
if (typeof path !== 'string') {
throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));
}
}
// Resolves . and .. elements in a path with directory names
function normalizeStringPosix(path, allowAboveRoot) {
var res = '';
var lastSegmentLength = 0;
var lastSlash = -1;
var dots = 0;
var code;
for (var i = 0; i <= path.length; ++i) {
if (i < path.length)
code = path.charCodeAt(i);
else if (code === 47 /*/*/)
break;
else
code = 47 /*/*/;
if (code === 47 /*/*/) {
if (lastSlash === i - 1 || dots === 1) {
// NOOP
} else if (lastSlash !== i - 1 && dots === 2) {
if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {
if (res.length > 2) {
var lastSlashIndex = res.lastIndexOf('/');
if (lastSlashIndex !== res.length - 1) {
if (lastSlashIndex === -1) {
res = '';
lastSegmentLength = 0;
} else {
res = res.slice(0, lastSlashIndex);
lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
}
lastSlash = i;
dots = 0;
continue;
}
} else if (res.length === 2 || res.length === 1) {
res = '';
lastSegmentLength = 0;
lastSlash = i;
dots = 0;
continue;
}
}
if (allowAboveRoot) {
if (res.length > 0)
res += '/..';
else
res = '..';
lastSegmentLength = 2;
}
} else {
if (res.length > 0)
res += '/' + path.slice(lastSlash + 1, i);
else
res = path.slice(lastSlash + 1, i);
lastSegmentLength = i - lastSlash - 1;
}
lastSlash = i;
dots = 0;
} else if (code === 46 /*.*/ && dots !== -1) {
++dots;
} else {
dots = -1;
}
}
return res;
}
function _format(sep, pathObject) {
var dir = pathObject.dir || pathObject.root;
var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');
if (!dir) {
return base;
}
if (dir === pathObject.root) {
return dir + base;
}
return dir + sep + base;
}
var posix = {
// path.resolve([from ...], to)
resolve: function resolve() {
var resolvedPath = '';
var resolvedAbsolute = false;
var cwd;
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
var path;
if (i >= 0)
path = arguments[i];
else {
if (cwd === undefined)
cwd = process.cwd();
path = cwd;
}
assertPath(path);
// Skip empty entries
if (path.length === 0) {
continue;
}
resolvedPath = path + '/' + resolvedPath;
resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;
}
// At this point the path should be resolved to a full absolute path, but
// handle relative paths to be safe (might happen when process.cwd() fails)
// Normalize the path
resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
if (resolvedAbsolute) {
if (resolvedPath.length > 0)
return '/' + resolvedPath;
else
return '/';
} else if (resolvedPath.length > 0) {
return resolvedPath;
} else {
return '.';
}
},
normalize: function normalize(path) {
assertPath(path);
if (path.length === 0) return '.';
var isAbsolute = path.charCodeAt(0) === 47 /*/*/;
var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;
// Normalize the path
path = normalizeStringPosix(path, !isAbsolute);
if (path.length === 0 && !isAbsolute) path = '.';
if (path.length > 0 && trailingSeparator) path += '/';
if (isAbsolute) return '/' + path;
return path;
},
isAbsolute: function isAbsolute(path) {
assertPath(path);
return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;
},
join: function join() {
if (arguments.length === 0)
return '.';
var joined;
for (var i = 0; i < arguments.length; ++i) {
var arg = arguments[i];
assertPath(arg);
if (arg.length > 0) {
if (joined === undefined)
joined = arg;
else
joined += '/' + arg;
}
}
if (joined === undefined)
return '.';
return posix.normalize(joined);
},
relative: function relative(from, to) {
assertPath(from);
assertPath(to);
if (from === to) return '';
from = posix.resolve(from);
to = posix.resolve(to);
if (from === to) return '';
// Trim any leading backslashes
var fromStart = 1;
for (; fromStart < from.length; ++fromStart) {
if (from.charCodeAt(fromStart) !== 47 /*/*/)
break;
}
var fromEnd = from.length;
var fromLen = fromEnd - fromStart;
// Trim any leading backslashes
var toStart = 1;
for (; toStart < to.length; ++toStart) {
if (to.charCodeAt(toStart) !== 47 /*/*/)
break;
}
var toEnd = to.length;
var toLen = toEnd - toStart;
// Compare paths to find the longest common path from root
var length = fromLen < toLen ? fromLen : toLen;
var lastCommonSep = -1;
var i = 0;
for (; i <= length; ++i) {
if (i === length) {
if (toLen > length) {
if (to.charCodeAt(toStart + i) === 47 /*/*/) {
// We get here if `from` is the exact base path for `to`.
// For example: from='/foo/bar'; to='/foo/bar/baz'
return to.slice(toStart + i + 1);
} else if (i === 0) {
// We get here if `from` is the root
// For example: from='/'; to='/foo'
return to.slice(toStart + i);
}
} else if (fromLen > length) {
if (from.charCodeAt(fromStart + i) === 47 /*/*/) {
// We get here if `to` is the exact base path for `from`.
// For example: from='/foo/bar/baz'; to='/foo/bar'
lastCommonSep = i;
} else if (i === 0) {
// We get here if `to` is the root.
// For example: from='/foo'; to='/'
lastCommonSep = 0;
}
}
break;
}
var fromCode = from.charCodeAt(fromStart + i);
var toCode = to.charCodeAt(toStart + i);
if (fromCode !== toCode)
break;
else if (fromCode === 47 /*/*/)
lastCommonSep = i;
}
var out = '';
// Generate the relative path based on the path difference between `to`
// and `from`
for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {
if (out.length === 0)
out += '..';
else
out += '/..';
}
}
// Lastly, append the rest of the destination (`to`) path that comes after
// the common path parts
if (out.length > 0)
return out + to.slice(toStart + lastCommonSep);
else {
toStart += lastCommonSep;
if (to.charCodeAt(toStart) === 47 /*/*/)
++toStart;
return to.slice(toStart);
}
},
_makeLong: function _makeLong(path) {
return path;
},
dirname: function dirname(path) {
assertPath(path);
if (path.length === 0) return '.';
var code = path.charCodeAt(0);
var hasRoot = code === 47 /*/*/;
var end = -1;
var matchedSlash = true;
for (var i = path.length - 1; i >= 1; --i) {
code = path.charCodeAt(i);
if (code === 47 /*/*/) {
if (!matchedSlash) {
end = i;
break;
}
} else {
// We saw the first non-path separator
matchedSlash = false;
}
}
if (end === -1) return hasRoot ? '/' : '.';
if (hasRoot && end === 1) return '//';
return path.slice(0, end);
},
basename: function basename(path, ext) {
if (ext !== undefined && typeof ext !== 'string') throw new TypeError('"ext" argument must be a string');
assertPath(path);
var start = 0;
var end = -1;
var matchedSlash = true;
var i;
if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
if (ext.length === path.length && ext === path) return '';
var extIdx = ext.length - 1;
var firstNonSlashEnd = -1;
for (i = path.length - 1; i >= 0; --i) {
var code = path.charCodeAt(i);
if (code === 47 /*/*/) {
// If we reached a path separator that was not part of a set of path
// separators at the end of the string, stop now
if (!matchedSlash) {
start = i + 1;
break;
}
} else {
if (firstNonSlashEnd === -1) {
// We saw the first non-path separator, remember this index in case
// we need it if the extension ends up not matching
matchedSlash = false;
firstNonSlashEnd = i + 1;
}
if (extIdx >= 0) {
// Try to match the explicit extension
if (code === ext.charCodeAt(extIdx)) {
if (--extIdx === -1) {
// We matched the extension, so mark this as the end of our path
// component
end = i;
}
} else {
// Extension does not match, so our result is the entire path
// component
extIdx = -1;
end = firstNonSlashEnd;
}
}
}
}
if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;
return path.slice(start, end);
} else {
for (i = path.length - 1; i >= 0; --i) {
if (path.charCodeAt(i) === 47 /*/*/) {
// If we reached a path separator that was not part of a set of path
// separators at the end of the string, stop now
if (!matchedSlash) {
start = i + 1;
break;
}
} else if (end === -1) {
// We saw the first non-path separator, mark this as the end of our
// path component
matchedSlash = false;
end = i + 1;
}
}
if (end === -1) return '';
return path.slice(start, end);
}
},
extname: function extname(path) {
assertPath(path);
var startDot = -1;
var startPart = 0;
var end = -1;
var matchedSlash = true;
// Track the state of characters (if any) we see before our first dot and
// after any path separator we find
var preDotState = 0;
for (var i = path.length - 1; i >= 0; --i) {
var code = path.charCodeAt(i);
if (code === 47 /*/*/) {
// If we reached a path separator that was not part of a set of path
// separators at the end of the string, stop now
if (!matchedSlash) {
startPart = i + 1;
break;
}
continue;
}
if (end === -1) {
// We saw the first non-path separator, mark this as the end of our
// extension
matchedSlash = false;
end = i + 1;
}
if (code === 46 /*.*/) {
// If this is our first dot, mark it as the start of our extension
if (startDot === -1)
startDot = i;
else if (preDotState !== 1)
preDotState = 1;
} else if (startDot !== -1) {
// We saw a non-dot and non-path separator before our dot, so we should
// have a good chance at having a non-empty extension
preDotState = -1;
}
}
if (startDot === -1 || end === -1 ||
// We saw a non-dot character immediately before the dot
preDotState === 0 ||
// The (right-most) trimmed path component is exactly '..'
preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
return '';
}
return path.slice(startDot, end);
},
format: function format(pathObject) {
if (pathObject === null || typeof pathObject !== 'object') {
throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
}
return _format('/', pathObject);
},
parse: function parse(path) {
assertPath(path);
var ret = { root: '', dir: '', base: '', ext: '', name: '' };
if (path.length === 0) return ret;
var code = path.charCodeAt(0);
var isAbsolute = code === 47 /*/*/;
var start;
if (isAbsolute) {
ret.root = '/';
start = 1;
} else {
start = 0;
}
var startDot = -1;
var startPart = 0;
var end = -1;
var matchedSlash = true;
var i = path.length - 1;
// Track the state of characters (if any) we see before our first dot and
// after any path separator we find
var preDotState = 0;
// Get non-dir info
for (; i >= start; --i) {
code = path.charCodeAt(i);
if (code === 47 /*/*/) {
// If we reached a path separator that was not part of a set of path
// separators at the end of the string, stop now
if (!matchedSlash) {
startPart = i + 1;
break;
}
continue;
}
if (end === -1) {
// We saw the first non-path separator, mark this as the end of our
// extension
matchedSlash = false;
end = i + 1;
}
if (code === 46 /*.*/) {
// If this is our first dot, mark it as the start of our extension
if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;
} else if (startDot !== -1) {
// We saw a non-dot and non-path separator before our dot, so we should
// have a good chance at having a non-empty extension
preDotState = -1;
}
}
if (startDot === -1 || end === -1 ||
// We saw a non-dot character immediately before the dot
preDotState === 0 ||
// The (right-most) trimmed path component is exactly '..'
preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
if (end !== -1) {
if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);
}
} else {
if (startPart === 0 && isAbsolute) {
ret.name = path.slice(1, startDot);
ret.base = path.slice(1, end);
} else {
ret.name = path.slice(startPart, startDot);
ret.base = path.slice(startPart, end);
}
ret.ext = path.slice(startDot, end);
}
if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';
return ret;
},
sep: '/',
delimiter: ':',
win32: null,
posix: null
};
posix.posix = posix;
module.exports = posix;
}).call(this)}).call(this,require('_process'))
},{"_process":100}],10:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
module.exports = Stream;
var EE = require('events').EventEmitter;
var inherits = require('inherits');
inherits(Stream, EE);
Stream.Readable = require('readable-stream/lib/_stream_readable.js');
Stream.Writable = require('readable-stream/lib/_stream_writable.js');
Stream.Duplex = require('readable-stream/lib/_stream_duplex.js');
Stream.Transform = require('readable-stream/lib/_stream_transform.js');
Stream.PassThrough = require('readable-stream/lib/_stream_passthrough.js');
Stream.finished = require('readable-stream/lib/internal/streams/end-of-stream.js')
Stream.pipeline = require('readable-stream/lib/internal/streams/pipeline.js')
// Backwards-compat with node 0.4.x
Stream.Stream = Stream;
// old-style streams. Note that the pipe method (the only relevant
// part of this class) is overridden in the Readable class.
function Stream() {
EE.call(this);
}
Stream.prototype.pipe = function(dest, options) {
var source = this;
function ondata(chunk) {
if (dest.writable) {
if (false === dest.write(chunk) && source.pause) {
source.pause();
}
}
}
source.on('data', ondata);
function ondrain() {
if (source.readable && source.resume) {
source.resume();
}
}
dest.on('drain', ondrain);
// If the 'end' option is not supplied, dest.end() will be called when
// source gets the 'end' or 'close' events. Only dest.end() once.
if (!dest._isStdio && (!options || options.end !== false)) {
source.on('end', onend);
source.on('close', onclose);
}
var didOnEnd = false;
function onend() {
if (didOnEnd) return;
didOnEnd = true;
dest.end();
}
function onclose() {
if (didOnEnd) return;
didOnEnd = true;
if (typeof dest.destroy === 'function') dest.destroy();
}
// don't leave dangling pipes when there are errors.
function onerror(er) {
cleanup();
if (EE.listenerCount(this, 'error') === 0) {
throw er; // Unhandled stream error in pipe.
}
}
source.on('error', onerror);
dest.on('error', onerror);
// remove all the event listeners that were added.
function cleanup() {
source.removeListener('data', ondata);
dest.removeListener('drain', ondrain);
source.removeListener('end', onend);
source.removeListener('close', onclose);
source.removeListener('error', onerror);
dest.removeListener('error', onerror);
source.removeListener('end', cleanup);
source.removeListener('close', cleanup);
dest.removeListener('close', cleanup);
}
source.on('end', cleanup);
source.on('close', cleanup);
dest.on('close', cleanup);
dest.emit('pipe', source);
// Allow for unix-like usage: A.pipe(B).pipe(C)
return dest;
};
},{"events":8,"inherits":95,"readable-stream/lib/_stream_duplex.js":12,"readable-stream/lib/_stream_passthrough.js":13,"readable-stream/lib/_stream_readable.js":14,"readable-stream/lib/_stream_transform.js":15,"readable-stream/lib/_stream_writable.js":16,"readable-stream/lib/internal/streams/end-of-stream.js":20,"readable-stream/lib/internal/streams/pipeline.js":22}],11:[function(require,module,exports){
'use strict';
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
var codes = {};
function createErrorType(code, message, Base) {
if (!Base) {
Base = Error;
}
function getMessage(arg1, arg2, arg3) {
if (typeof message === 'string') {
return message;
} else {
return message(arg1, arg2, arg3);
}
}
var NodeError =
/*#__PURE__*/
function (_Base) {
_inheritsLoose(NodeError, _Base);
function NodeError(arg1, arg2, arg3) {
return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
}
return NodeError;
}(Base);
NodeError.prototype.name = Base.name;
NodeError.prototype.code = code;
codes[code] = NodeError;
} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
function oneOf(expected, thing) {
if (Array.isArray(expected)) {
var len = expected.length;
expected = expected.map(function (i) {
return String(i);
});
if (len > 2) {
return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1];
} else if (len === 2) {
return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
} else {
return "of ".concat(thing, " ").concat(expected[0]);
}
} else {
return "of ".concat(thing, " ").concat(String(expected));
}
} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
function startsWith(str, search, pos) {
return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
function endsWith(str, search, this_len) {
if (this_len === undefined || this_len > str.length) {
this_len = str.length;
}
return str.substring(this_len - search.length, this_len) === search;
} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
function includes(str, search, start) {
if (typeof start !== 'number') {
start = 0;
}
if (start + search.length > str.length) {
return false;
} else {
return str.indexOf(search, start) !== -1;
}
}
createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
return 'The value "' + value + '" is invalid for option "' + name + '"';
}, TypeError);
createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
// determiner: 'must be' or 'must not be'
var determiner;
if (typeof expected === 'string' && startsWith(expected, 'not ')) {
determiner = 'must not be';
expected = expected.replace(/^not /, '');
} else {
determiner = 'must be';
}
var msg;
if (endsWith(name, ' argument')) {
// For cases like 'first argument'
msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
} else {
var type = includes(name, '.') ? 'property' : 'argument';
msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
}
msg += ". Received type ".concat(typeof actual);
return msg;
}, TypeError);
createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
return 'The ' + name + ' method is not implemented';
});
createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
createErrorType('ERR_STREAM_DESTROYED', function (name) {
return 'Cannot call ' + name + ' after a stream was destroyed';
});
createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
return 'Unknown encoding: ' + arg;
}, TypeError);
createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
module.exports.codes = codes;
},{}],12:[function(require,module,exports){
(function (process){(function (){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// a duplex stream is just a stream that is both readable and writable.
// Since JS doesn't have multiple prototypal inheritance, this class
// prototypally inherits from Readable, and then parasitically from
// Writable.
'use strict';
/*<replacement>*/
var objectKeys = Object.keys || function (obj) {
var keys = [];
for (var key in obj) {
keys.push(key);
}
return keys;
};
/*</replacement>*/
module.exports = Duplex;
var Readable = require('./_stream_readable');
var Writable = require('./_stream_writable');
require('inherits')(Duplex, Readable);
{
// Allow the keys array to be GC'ed.
var keys = objectKeys(Writable.prototype);
for (var v = 0; v < keys.length; v++) {
var method = keys[v];
if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
}
}
function Duplex(options) {
if (!(this instanceof Duplex)) return new Duplex(options);
Readable.call(this, options);
Writable.call(this, options);
this.allowHalfOpen = true;
if (options) {
if (options.readable === false) this.readable = false;
if (options.writable === false) this.writable = false;
if (options.allowHalfOpen === false) {
this.allowHalfOpen = false;
this.once('end', onend);
}
}
}
Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
// making it explicit this property is not enumerable
// because otherwise some prototype manipulation in
// userland will fail
enumerable: false,
get: function get() {
return this._writableState.highWaterMark;
}
});
Object.defineProperty(Duplex.prototype, 'writableBuffer', {
// making it explicit this property is not enumerable
// because otherwise some prototype manipulation in
// userland will fail
enumerable: false,
get: function get() {
return this._writableState && this._writableState.getBuffer();
}
});
Object.defineProperty(Duplex.prototype, 'writableLength', {
// making it explicit this property is not enumerable
// because otherwise some prototype manipulation in
// userland will fail
enumerable: false,
get: function get() {
return this._writableState.length;
}
}); // the no-half-open enforcer
function onend() {
// If the writable side ended, then we're ok.
if (this._writableState.ended) return; // no more data can be written.
// But allow more writes to happen in this tick.
process.nextTick(onEndNT, this);
}
function onEndNT(self) {
self.end();
}
Object.defineProperty(Duplex.prototype, 'destroyed', {
// making it explicit this property is not enumerable
// because otherwise some prototype manipulation in
// userland will fail
enumerable: false,
get: function get() {
if (this._readableState === undefined || this._writableState === undefined) {
return false;
}
return this._readableState.destroyed && this._writableState.destroyed;
},
set: function set(value) {
// we ignore the value if the stream
// has not been initialized yet
if (this._readableState === undefined || this._writableState === undefined) {
return;
} // backward compatibility, the user is explicitly
// managing destroyed
this._readableState.destroyed = value;
this._writableState.destroyed = value;
}
});
}).call(this)}).call(this,require('_process'))
},{"./_stream_readable":14,"./_stream_writable":16,"_process":100,"inherits":95}],13:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// a passthrough stream.
// basically just the most minimal sort of Transform stream.
// Every written chunk gets output as-is.
'use strict';
module.exports = PassThrough;
var Transform = require('./_stream_transform');
require('inherits')(PassThrough, Transform);
function PassThrough(options) {
if (!(this instanceof PassThrough)) return new PassThrough(options);
Transform.call(this, options);
}
PassThrough.prototype._transform = function (chunk, encoding, cb) {
cb(null, chunk);
};
},{"./_stream_transform":15,"inherits":95}],14:[function(require,module,exports){
(function (process,global){(function (){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
'use strict';
module.exports = Readable;
/*<replacement>*/
var Duplex;
/*</replacement>*/
Readable.ReadableState = ReadableState;
/*<replacement>*/
var EE = require('events').EventEmitter;
var EElistenerCount = function EElistenerCount(emitter, type) {
return emitter.listeners(type).length;
};
/*</replacement>*/
/*<replacement>*/
var Stream = require('./internal/streams/stream');
/*</replacement>*/
var Buffer = require('buffer').Buffer;
var OurUint8Array = global.Uint8Array || function () {};
function _uint8ArrayToBuffer(chunk) {
return Buffer.from(chunk);
}
function _isUint8Array(obj) {
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}
/*<replacement>*/
var debugUtil = require('util');
var debug;
if (debugUtil && debugUtil.debuglog) {
debug = debugUtil.debuglog('stream');
} else {
debug = function debug() {};
}
/*</replacement>*/
var BufferList = require('./internal/streams/buffer_list');
var destroyImpl = require('./internal/streams/destroy');
var _require = require('./internal/streams/state'),
getHighWaterMark = _require.getHighWaterMark;
var _require$codes = require('../errors').codes,
ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,
ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; // Lazy loaded to improve the startup performance.
var StringDecoder;
var createReadableStreamAsyncIterator;
var from;
require('inherits')(Readable, Stream);
var errorOrDestroy = destroyImpl.errorOrDestroy;
var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
function prependListener(emitter, event, fn) {
// Sadly this is not cacheable as some libraries bundle their own
// event emitter implementation with them.
if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any
// userland ones. NEVER DO THIS. This is here only because this code needs
// to continue to work with older versions of Node.js that do not include
// the prependListener() method. The goal is to eventually remove this hack.
if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
}
function ReadableState(options, stream, isDuplex) {
Duplex = Duplex || require('./_stream_duplex');
options = options || {}; // Duplex streams are both readable and writable, but share
// the same options object.
// However, some cases require setting options to different
// values for the readable and the writable sides of the duplex stream.
// These options can be provided separately as readableXXX and writableXXX.
if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to
// make all the buffer merging and length checks go away
this.objectMode = !!options.objectMode;
if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer
// Note: 0 is a valid value, means "don't call _read preemptively ever"
this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the
// linked list can remove elements from the beginning faster than
// array.shift()
this.buffer = new BufferList();
this.length = 0;
this.pipes = null;
this.pipesCount = 0;
this.flowing = null;
this.ended = false;
this.endEmitted = false;
this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted
// immediately, or on a later tick. We set this to true at first, because
// any actions that shouldn't happen until "later" should generally also
// not happen before the first read call.
this.sync = true; // whenever we return null, then we set a flag to say
// that we're awaiting a 'readable' event emission.
this.needReadable = false;
this.emittedReadable = false;
this.readableListening = false;
this.resumeScheduled = false;
this.paused = true; // Should close be emitted on destroy. Defaults to true.
this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')
this.autoDestroy = !!options.autoDestroy; // has it been destroyed
this.destroyed = false; // Crypto is kind of old and crusty. Historically, its default string
// encoding is 'binary' so we have to make this configurable.
// Everything else in the universe uses 'utf8', though.
this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s
this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled
this.readingMore = false;
this.decoder = null;
this.encoding = null;
if (options.encoding) {
if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
this.decoder = new StringDecoder(options.encoding);
this.encoding = options.encoding;
}
}
function Readable(options) {
Duplex = Duplex || require('./_stream_duplex');
if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside
// the ReadableState constructor, at least with V8 6.5
var isDuplex = this instanceof Duplex;
this._readableState = new ReadableState(options, this, isDuplex); // legacy
this.readable = true;
if (options) {
if (typeof options.read === 'function') this._read = options.read;
if (typeof options.destroy === 'function') this._destroy = options.destroy;
}
Stream.call(this);
}
Object.defineProperty(Readable.prototype, 'destroyed', {
// making it explicit this property is not enumerable
// because otherwise some prototype manipulation in
// userland will fail
enumerable: false,
get: function get() {
if (this._readableState === undefined) {
return false;
}
return this._readableState.destroyed;
},
set: function set(value) {
// we ignore the value if the stream
// has not been initialized yet
if (!this._readableState) {
return;
} // backward compatibility, the user is explicitly
// managing destroyed
this._readableState.destroyed = value;
}
});
Readable.prototype.destroy = destroyImpl.destroy;
Readable.prototype._undestroy = destroyImpl.undestroy;
Readable.prototype._destroy = function (err, cb) {
cb(err);
}; // Manually shove something into the read() buffer.
// This returns true if the highWaterMark has not been hit yet,
// similar to how Writable.write() returns true if you should
// write() some more.
Readable.prototype.push = function (chunk, encoding) {
var state = this._readableState;
var skipChunkCheck;
if (!state.objectMode) {
if (typeof chunk === 'string') {
encoding = encoding || state.defaultEncoding;
if (encoding !== state.encoding) {
chunk = Buffer.from(chunk, encoding);
encoding = '';
}
skipChunkCheck = true;
}
} else {
skipChunkCheck = true;
}
return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
}; // Unshift should *always* be something directly out of read()
Readable.prototype.unshift = function (chunk) {
return readableAddChunk(this, chunk, null, true, false);
};
function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
debug('readableAddChunk', chunk);
var state = stream._readableState;
if (chunk === null) {
state.reading = false;
onEofChunk(stream, state);
} else {
var er;
if (!skipChunkCheck) er = chunkInvalid(state, chunk);
if (er) {
errorOrDestroy(stream, er);
} else if (state.objectMode || chunk && chunk.length > 0) {
if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
chunk = _uint8ArrayToBuffer(chunk);
}
if (addToFront) {
if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);
} else if (state.ended) {
errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
} else if (state.destroyed) {
return false;
} else {
state.reading = false;
if (state.decoder && !encoding) {
chunk = state.decoder.write(chunk);
if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
} else {
addChunk(stream, state, chunk, false);
}
}
} else if (!addToFront) {
state.reading = false;
maybeReadMore(stream, state);
}
} // We can push more data if we are below the highWaterMark.
// Also, if we have no data yet, we can stand some more bytes.
// This is to work around cases where hwm=0, such as the repl.
return !state.ended && (state.length < state.highWaterMark || state.length === 0);
}
function addChunk(stream, state, chunk, addToFront) {
if (state.flowing && state.length === 0 && !state.sync) {
state.awaitDrain = 0;
stream.emit('data', chunk);
} else {
// update the buffer info.
state.length += state.objectMode ? 1 : chunk.length;
if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
if (state.needReadable) emitReadable(stream);
}
maybeReadMore(stream, state);
}
function chunkInvalid(state, chunk) {
var er;
if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
}
return er;
}
Readable.prototype.isPaused = function () {
return this._readableState.flowing === false;
}; // backwards compatibility.
Readable.prototype.setEncoding = function (enc) {
if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
var decoder = new StringDecoder(enc);
this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8
this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:
var p = this._readableState.buffer.head;
var content = '';
while (p !== null) {
content += decoder.write(p.data);
p = p.next;
}
this._readableState.buffer.clear();
if (content !== '') this._readableState.buffer.push(content);
this._readableState.length = content.length;
return this;
}; // Don't raise the hwm > 1GB
var MAX_HWM = 0x40000000;
function computeNewHighWaterMark(n) {
if (n >= MAX_HWM) {
// TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.
n = MAX_HWM;
} else {
// Get the next highest power of 2 to prevent increasing hwm excessively in
// tiny amounts
n--;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
n++;
}
return n;
} // This function is designed to be inlinable, so please take care when making
// changes to the function body.
function howMuchToRead(n, state) {
if (n <= 0 || state.length === 0 && state.ended) return 0;
if (state.objectMode) return 1;
if (n !== n) {
// Only flow one buffer at a time
if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
} // If we're asking for more than the current hwm, then raise the hwm.
if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
if (n <= state.length) return n; // Don't have enough
if (!state.ended) {
state.needReadable = true;
return 0;
}
return state.length;
} // you can override either this method, or the async _read(n) below.
Readable.prototype.read = function (n) {
debug('read', n);
n = parseInt(n, 10);
var state = this._readableState;
var nOrig = n;
if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we
// already have a bunch of data in the buffer, then just trigger
// the 'readable' event and move on.
if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
debug('read: emitReadable', state.length, state.ended);
if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
return null;
}
n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.
if (n === 0 && state.ended) {
if (state.length === 0) endReadable(this);
return null;
} // All the actual chunk generation logic needs to be
// *below* the call to _read. The reason is that in certain
// synthetic stream cases, such as passthrough streams, _read
// may be a completely synchronous operation which may change
// the state of the read buffer, providing enough data when
// before there was *not* enough.
//
// So, the steps are:
// 1. Figure out what the state of things will be after we do
// a read from the buffer.
//
// 2. If that resulting state will trigger a _read, then call _read.
// Note that this may be asynchronous, or synchronous. Yes, it is
// deeply ugly to write APIs this way, but that still doesn't mean
// that the Readable class should behave improperly, as streams are
// designed to be sync/async agnostic.
// Take note if the _read call is sync or async (ie, if the read call
// has returned yet), so that we know whether or not it's safe to emit
// 'readable' etc.
//
// 3. Actually pull the requested chunks out of the buffer and return.
// if we need a readable event, then we need to do some reading.
var doRead = state.needReadable;
debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some
if (state.length === 0 || state.length - n < state.highWaterMark) {
doRead = true;
debug('length less than watermark', doRead);
} // however, if we've ended, then there's no point, and if we're already
// reading, then it's unnecessary.
if (state.ended || state.reading) {
doRead = false;
debug('reading or ended', doRead);
} else if (doRead) {
debug('do read');
state.reading = true;
state.sync = true; // if the length is currently zero, then we *need* a readable event.
if (state.length === 0) state.needReadable = true; // call internal read method
this._read(state.highWaterMark);
state.sync = false; // If _read pushed data synchronously, then `reading` will be false,
// and we need to re-evaluate how much data we can return to the user.
if (!state.reading) n = howMuchToRead(nOrig, state);
}
var ret;
if (n > 0) ret = fromList(n, state);else ret = null;
if (ret === null) {
state.needReadable = state.length <= state.highWaterMark;
n = 0;
} else {
state.length -= n;
state.awaitDrain = 0;
}
if (state.length === 0) {
// If we have nothing in the buffer, then we want to know
// as soon as we *do* get something into the buffer.
if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.
if (nOrig !== n && state.ended) endReadable(this);
}
if (ret !== null) this.emit('data', ret);
return ret;
};
function onEofChunk(stream, state) {
debug('onEofChunk');
if (state.ended) return;
if (state.decoder) {
var chunk = state.decoder.end();
if (chunk && chunk.length) {
state.buffer.push(chunk);
state.length += state.objectMode ? 1 : chunk.length;
}
}
state.ended = true;
if (state.sync) {
// if we are sync, wait until next tick to emit the data.
// Otherwise we risk emitting data in the flow()
// the readable code triggers during a read() call
emitReadable(stream);
} else {
// emit 'readable' now to make sure it gets picked up.
state.needReadable = false;
if (!state.emittedReadable) {
state.emittedReadable = true;
emitReadable_(stream);
}
}
} // Don't emit readable right away in sync mode, because this can trigger
// another read() call => stack overflow. This way, it might trigger
// a nextTick recursion warning, but that's not so bad.
function emitReadable(stream) {
var state = stream._readableState;
debug('emitReadable', state.needReadable, state.emittedReadable);
state.needReadable = false;
if (!state.emittedReadable) {
debug('emitReadable', state.flowing);
state.emittedReadable = true;
process.nextTick(emitReadable_, stream);
}
}
function emitReadable_(stream) {
var state = stream._readableState;
debug('emitReadable_', state.destroyed, state.length, state.ended);
if (!state.destroyed && (state.length || state.ended)) {
stream.emit('readable');
state.emittedReadable = false;
} // The stream needs another readable event if
// 1. It is not flowing, as the flow mechanism will take
// care of it.
// 2. It is not ended.
// 3. It is below the highWaterMark, so we can schedule
// another readable later.
state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
flow(stream);
} // at this point, the user has presumably seen the 'readable' event,
// and called read() to consume some data. that may have triggered
// in turn another _read(n) call, in which case reading = true if
// it's in progress.
// However, if we're not ended, or reading, and the length < hwm,
// then go ahead and try to read some more preemptively.
function maybeReadMore(stream, state) {
if (!state.readingMore) {
state.readingMore = true;
process.nextTick(maybeReadMore_, stream, state);
}
}
function maybeReadMore_(stream, state) {
// Attempt to read more data if we should.
//
// The conditions for reading more data are (one of):
// - Not enough data buffered (state.length < state.highWaterMark). The loop
// is responsible for filling the buffer with enough data if such data
// is available. If highWaterMark is 0 and we are not in the flowing mode
// we should _not_ attempt to buffer any extra data. We'll get more data
// when the stream consumer calls read() instead.
// - No data in the buffer, and the stream is in flowing mode. In this mode
// the loop below is responsible for ensuring read() is called. Failing to
// call read here would abort the flow and there's no other mechanism for
// continuing the flow if the stream consumer has just subscribed to the
// 'data' event.
//
// In addition to the above conditions to keep reading data, the following
// conditions prevent the data from being read:
// - The stream has ended (state.ended).
// - There is already a pending 'read' operation (state.reading). This is a
// case where the the stream has called the implementation defined _read()
// method, but they are processing the call asynchronously and have _not_
// called push() with new data. In this case we skip performing more
// read()s. The execution ends in this method again after the _read() ends
// up calling push() with more data.
while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {
var len = state.length;
debug('maybeReadMore read 0');
stream.read(0);
if (len === state.length) // didn't get any data, stop spinning.
break;
}
state.readingMore = false;
} // abstract method. to be overridden in specific implementation classes.
// call cb(er, data) where data is <= n in length.
// for virtual (non-string, non-buffer) streams, "length" is somewhat
// arbitrary, and perhaps not very meaningful.
Readable.prototype._read = function (n) {
errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));
};
Readable.prototype.pipe = function (dest, pipeOpts) {
var src = this;
var state = this._readableState;
switch (state.pipesCount) {
case 0:
state.pipes = dest;
break;
case 1:
state.pipes = [state.pipes, dest];
break;
default:
state.pipes.push(dest);
break;
}
state.pipesCount += 1;
debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
var endFn = doEnd ? onend : unpipe;
if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);
dest.on('unpipe', onunpipe);
function onunpipe(readable, unpipeInfo) {
debug('onunpipe');
if (readable === src) {
if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
unpipeInfo.hasUnpiped = true;
cleanup();
}
}
}
function onend() {
debug('onend');
dest.end();
} // when the dest drains, it reduces the awaitDrain counter
// on the source. This would be more elegant with a .once()
// handler in flow(), but adding and removing repeatedly is
// too slow.
var ondrain = pipeOnDrain(src);
dest.on('drain', ondrain);
var cleanedUp = false;
function cleanup() {
debug('cleanup'); // cleanup event handlers once the pipe is broken
dest.removeListener('close', onclose);
dest.removeListener('finish', onfinish);
dest.removeListener('drain', ondrain);
dest.removeListener('error', onerror);
dest.removeListener('unpipe', onunpipe);
src.removeListener('end', onend);
src.removeListener('end', unpipe);
src.removeListener('data', ondata);
cleanedUp = true; // if the reader is waiting for a drain event from this
// specific writer, then it would cause it to never start
// flowing again.
// So, if this is awaiting a drain, then we just call it now.
// If we don't know, then assume that we are waiting for one.
if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
}
src.on('data', ondata);
function ondata(chunk) {
debug('ondata');
var ret = dest.write(chunk);
debug('dest.write', ret);
if (ret === false) {
// If the user unpiped during `dest.write()`, it is possible
// to get stuck in a permanently paused state if that write
// also returned false.
// => Check whether `dest` is still a piping destination.
if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
debug('false write response, pause', state.awaitDrain);
state.awaitDrain++;
}
src.pause();
}
} // if the dest has an error, then stop piping into it.
// however, don't suppress the throwing behavior for this.
function onerror(er) {
debug('onerror', er);
unpipe();
dest.removeListener('error', onerror);
if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);
} // Make sure our error handler is attached before userland ones.
prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.
function onclose() {
dest.removeListener('finish', onfinish);
unpipe();
}
dest.once('close', onclose);
function onfinish() {
debug('onfinish');
dest.removeListener('close', onclose);
unpipe();
}
dest.once('finish', onfinish);
function unpipe() {
debug('unpipe');
src.unpipe(dest);
} // tell the dest that it's being piped to
dest.emit('pipe', src); // start the flow if it hasn't been started already.
if (!state.flowing) {
debug('pipe resume');
src.resume();
}
return dest;
};
function pipeOnDrain(src) {
return function pipeOnDrainFunctionResult() {
var state = src._readableState;
debug('pipeOnDrain', state.awaitDrain);
if (state.awaitDrain) state.awaitDrain--;
if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
state.flowing = true;
flow(src);
}
};
}
Readable.prototype.unpipe = function (dest) {
var state = this._readableState;
var unpipeInfo = {
hasUnpiped: false
}; // if we're not piping anywhere, then do nothing.
if (state.pipesCount === 0) return this; // just one destination. most common case.
if (state.pipesCount === 1) {
// passed in one, but it's not the right one.
if (dest && dest !== state.pipes) return this;
if (!dest) dest = state.pipes; // got a match.
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;
if (dest) dest.emit('unpipe', this, unpipeInfo);
return this;
} // slow case. multiple pipe destinations.
if (!dest) {
// remove all.
var dests = state.pipes;
var len = state.pipesCount;
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;
for (var i = 0; i < len; i++) {
dests[i].emit('unpipe', this, {
hasUnpiped: false
});
}
return this;
} // try to find the right one.
var index = indexOf(state.pipes, dest);
if (index === -1) return this;
state.pipes.splice(index, 1);
state.pipesCount -= 1;
if (state.pipesCount === 1) state.pipes = state.pipes[0];
dest.emit('unpipe', this, unpipeInfo);
return this;
}; // set up data events if they are asked for
// Ensure readable listeners eventually get something
Readable.prototype.on = function (ev, fn) {
var res = Stream.prototype.on.call(this, ev, fn);
var state = this._readableState;
if (ev === 'data') {
// update readableListening so that resume() may be a no-op
// a few lines down. This is needed to support once('readable').
state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused
if (state.flowing !== false) this.resume();
} else if (ev === 'readable') {
if (!state.endEmitted && !state.readableListening) {
state.readableListening = state.needReadable = true;
state.flowing = false;
state.emittedReadable = false;
debug('on readable', state.length, state.reading);
if (state.length) {
emitReadable(this);
} else if (!state.reading) {
process.nextTick(nReadingNextTick, this);
}
}
}
return res;
};
Readable.prototype.addListener = Readable.prototype.on;
Readable.prototype.removeListener = function (ev, fn) {
var res = Stream.prototype.removeListener.call(this, ev, fn);
if (ev === 'readable') {
// We need to check if there is someone still listening to
// readable and reset the state. However this needs to happen
// after readable has been emitted but before I/O (nextTick) to
// support once('readable', fn) cycles. This means that calling
// resume within the same tick will have no
// effect.
process.nextTick(updateReadableListening, this);
}
return res;
};
Readable.prototype.removeAllListeners = function (ev) {
var res = Stream.prototype.removeAllListeners.apply(this, arguments);
if (ev === 'readable' || ev === undefined) {
// We need to check if there is someone still listening to
// readable and reset the state. However this needs to happen
// after readable has been emitted but before I/O (nextTick) to
// support once('readable', fn) cycles. This means that calling
// resume within the same tick will have no
// effect.
process.nextTick(updateReadableListening, this);
}
return res;
};
function updateReadableListening(self) {
var state = self._readableState;
state.readableListening = self.listenerCount('readable') > 0;
if (state.resumeScheduled && !state.paused) {
// flowing needs to be set to true now, otherwise
// the upcoming resume will not flow.
state.flowing = true; // crude way to check if we should resume
} else if (self.listenerCount('data') > 0) {
self.resume();
}
}
function nReadingNextTick(self) {
debug('readable nexttick read 0');
self.read(0);
} // pause() and resume() are remnants of the legacy readable stream API
// If the user uses them, then switch into old mode.
Readable.prototype.resume = function () {
var state = this._readableState;
if (!state.flowing) {
debug('resume'); // we flow only if there is no one listening
// for readable, but we still have to call
// resume()
state.flowing = !state.readableListening;
resume(this, state);
}
state.paused = false;
return this;
};
function resume(stream, state) {
if (!state.resumeScheduled) {
state.resumeScheduled = true;
process.nextTick(resume_, stream, state);
}
}
function resume_(stream, state) {
debug('resume', state.reading);
if (!state.reading) {
stream.read(0);
}
state.resumeScheduled = false;
stream.emit('resume');
flow(stream);
if (state.flowing && !state.reading) stream.read(0);
}
Readable.prototype.pause = function () {
debug('call pause flowing=%j', this._readableState.flowing);
if (this._readableState.flowing !== false) {
debug('pause');
this._readableState.flowing = false;
this.emit('pause');
}
this._readableState.paused = true;
return this;
};
function flow(stream) {
var state = stream._readableState;
debug('flow', state.flowing);
while (state.flowing && stream.read() !== null) {
;
}
} // wrap an old-style stream as the async data source.
// This is *not* part of the readable stream interface.
// It is an ugly unfortunate mess of history.
Readable.prototype.wrap = function (stream) {
var _this = this;
var state = this._readableState;
var paused = false;
stream.on('end', function () {
debug('wrapped end');
if (state.decoder && !state.ended) {
var chunk = state.decoder.end();
if (chunk && chunk.length) _this.push(chunk);
}
_this.push(null);
});
stream.on('data', function (chunk) {
debug('wrapped data');
if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode
if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
var ret = _this.push(chunk);
if (!ret) {
paused = true;
stream.pause();
}
}); // proxy all the other methods.
// important when wrapping filters and duplexes.
for (var i in stream) {
if (this[i] === undefined && typeof stream[i] === 'function') {
this[i] = function methodWrap(method) {
return function methodWrapReturnFunction() {
return stream[method].apply(stream, arguments);
};
}(i);
}
} // proxy certain important events.
for (var n = 0; n < kProxyEvents.length; n++) {
stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
} // when we try to consume some more bytes, simply unpause the
// underlying stream.
this._read = function (n) {
debug('wrapped _read', n);
if (paused) {
paused = false;
stream.resume();
}
};
return this;
};
if (typeof Symbol === 'function') {
Readable.prototype[Symbol.asyncIterator] = function () {
if (createReadableStreamAsyncIterator === undefined) {
createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');
}
return createReadableStreamAsyncIterator(this);
};
}
Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
// making it explicit this property is not enumerable
// because otherwise some prototype manipulation in
// userland will fail
enumerable: false,
get: function get() {
return this._readableState.highWaterMark;
}
});
Object.defineProperty(Readable.prototype, 'readableBuffer', {
// making it explicit this property is not enumerable
// because otherwise some prototype manipulation in
// userland will fail
enumerable: false,
get: function get() {
return this._readableState && this._readableState.buffer;
}
});
Object.defineProperty(Readable.prototype, 'readableFlowing', {
// making it explicit this property is not enumerable
// because otherwise some prototype manipulation in
// userland will fail
enumerable: false,
get: function get() {
return this._readableState.flowing;
},
set: function set(state) {
if (this._readableState) {
this._readableState.flowing = state;
}
}
}); // exposed for testing purposes only.
Readable._fromList = fromList;
Object.defineProperty(Readable.prototype, 'readableLength', {
// making it explicit this property is not enumerable
// because otherwise some prototype manipulation in
// userland will fail
enumerable: false,
get: function get() {
return this._readableState.length;
}
}); // Pluck off n bytes from an array of buffers.
// Length is the combined lengths of all the buffers in the list.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
function fromList(n, state) {
// nothing buffered
if (state.length === 0) return null;
var ret;
if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
// read it all, truncate the list
if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);
state.buffer.clear();
} else {
// read part of list
ret = state.buffer.consume(n, state.decoder);
}
return ret;
}
function endReadable(stream) {
var state = stream._readableState;
debug('endReadable', state.endEmitted);
if (!state.endEmitted) {
state.ended = true;
process.nextTick(endReadableNT, state, stream);
}
}
function endReadableNT(state, stream) {
debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.
if (!state.endEmitted && state.length === 0) {
state.endEmitted = true;
stream.readable = false;
stream.emit('end');
if (state.autoDestroy) {
// In case of duplex streams we need a way to detect
// if the writable side is ready for autoDestroy as well
var wState = stream._writableState;
if (!wState || wState.autoDestroy && wState.finished) {
stream.destroy();
}
}
}
}
if (typeof Symbol === 'function') {
Readable.from = function (iterable, opts) {
if (from === undefined) {
from = require('./internal/streams/from');
}
return from(Readable, iterable, opts);
};
}
function indexOf(xs, x) {
for (var i = 0, l = xs.length; i < l; i++) {
if (xs[i] === x) return i;
}
return -1;
}
}).call(this)}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"../errors":11,"./_stream_duplex":12,"./internal/streams/async_iterator":17,"./internal/streams/buffer_list":18,"./internal/streams/destroy":19,"./internal/streams/from":21,"./internal/streams/state":23,"./internal/streams/stream":24,"_process":100,"buffer":25,"events":8,"inherits":95,"string_decoder/":107,"util":6}],15:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// a transform stream is a readable/writable stream where you do
// something with the data. Sometimes it's called a "filter",
// but that's not a great name for it, since that implies a thing where
// some bits pass through, and others are simply ignored. (That would
// be a valid example of a transform, of course.)
//
// While the output is causally related to the input, it's not a
// necessarily symmetric or synchronous transformation. For example,
// a zlib stream might take multiple plain-text writes(), and then
// emit a single compressed chunk some time in the future.
//
// Here's how this works:
//
// The Transform stream has all the aspects of the readable and writable
// stream classes. When you write(chunk), that calls _write(chunk,cb)
// internally, and returns false if there's a lot of pending writes
// buffered up. When you call read(), that calls _read(n) until
// there's enough pending readable data buffered up.
//
// In a transform stream, the written data is placed in a buffer. When
// _read(n) is called, it transforms the queued up data, calling the
// buffered _write cb's as it consumes chunks. If consuming a single
// written chunk would result in multiple output chunks, then the first
// outputted bit calls the readcb, and subsequent chunks just go into
// the read buffer, and will cause it to emit 'readable' if necessary.
//
// This way, back-pressure is actually determined by the reading side,
// since _read has to be called to start processing a new chunk. However,
// a pathological inflate type of transform can cause excessive buffering
// here. For example, imagine a stream where every byte of input is
// interpreted as an integer from 0-255, and then results in that many
// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
// 1kb of data being output. In this case, you could write a very small
// amount of input, and end up with a very large amount of output. In
// such a pathological inflating mechanism, there'd be no way to tell
// the system to stop doing the transform. A single 4MB write could
// cause the system to run out of memory.
//
// However, even in such a pathological case, only a single written chunk
// would be consumed, and then the rest would wait (un-transformed) until
// the results of the previous transformed chunk were consumed.
'use strict';
module.exports = Transform;
var _require$codes = require('../errors').codes,
ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
var Duplex = require('./_stream_duplex');
require('inherits')(Transform, Duplex);
function afterTransform(er, data) {
var ts = this._transformState;
ts.transforming = false;
var cb = ts.writecb;
if (cb === null) {
return this.emit('error', new ERR_MULTIPLE_CALLBACK());
}
ts.writechunk = null;
ts.writecb = null;
if (data != null) // single equals check for both `null` and `undefined`
this.push(data);
cb(er);
var rs = this._readableState;
rs.reading = false;
if (rs.needReadable || rs.length < rs.highWaterMark) {
this._read(rs.highWaterMark);
}
}
function Transform(options) {
if (!(this instanceof Transform)) return new Transform(options);
Duplex.call(this, options);
this._transformState = {
afterTransform: afterTransform.bind(this),
needTransform: false,
transforming: false,
writecb: null,
writechunk: null,
writeencoding: null
}; // start out asking for a readable event once data is transformed.
this._readableState.needReadable = true; // we have implemented the _read method, and done the other things
// that Readable wants before the first _read call, so unset the
// sync guard flag.
this._readableState.sync = false;
if (options) {
if (typeof options.transform === 'function') this._transform = options.transform;
if (typeof options.flush === 'function') this._flush = options.flush;
} // When the writable side finishes, then flush out anything remaining.
this.on('prefinish', prefinish);
}
function prefinish() {
var _this = this;
if (typeof this._flush === 'function' && !this._readableState.destroyed) {
this._flush(function (er, data) {
done(_this, er, data);
});
} else {
done(this, null, null);
}
}
Transform.prototype.push = function (chunk, encoding) {
this._transformState.needTransform = false;
return Duplex.prototype.push.call(this, chunk, encoding);
}; // This is the part where you do stuff!
// override this function in implementation classes.
// 'chunk' is an input chunk.
//
// Call `push(newChunk)` to pass along transformed output
// to the readable side. You may call 'push' zero or more times.
//
// Call `cb(err)` when you are done with this chunk. If you pass
// an error, then that'll put the hurt on the whole operation. If you
// never call cb(), then you'll never get another chunk.
Transform.prototype._transform = function (chunk, encoding, cb) {
cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));
};
Transform.prototype._write = function (chunk, encoding, cb) {
var ts = this._transformState;
ts.writecb = cb;
ts.writechunk = chunk;
ts.writeencoding = encoding;
if (!ts.transforming) {
var rs = this._readableState;
if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
}
}; // Doesn't matter what the args are here.
// _transform does all the work.
// That we got here means that the readable side wants more data.
Transform.prototype._read = function (n) {
var ts = this._transformState;
if (ts.writechunk !== null && !ts.transforming) {
ts.transforming = true;
this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
} else {
// mark that we need a transform, so that any data that comes in
// will get processed, now that we've asked for it.
ts.needTransform = true;
}
};
Transform.prototype._destroy = function (err, cb) {
Duplex.prototype._destroy.call(this, err, function (err2) {
cb(err2);
});
};
function done(stream, er, data) {
if (er) return stream.emit('error', er);
if (data != null) // single equals check for both `null` and `undefined`
stream.push(data); // TODO(BridgeAR): Write a test for these two error cases
// if there's nothing in the write buffer, then that means
// that nothing more will ever be provided
if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
return stream.push(null);
}
},{"../errors":11,"./_stream_duplex":12,"inherits":95}],16:[function(require,module,exports){
(function (process,global){(function (){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// A bit simpler than readable streams.
// Implement an async ._write(chunk, encoding, cb), and it'll handle all
// the drain event emission and buffering.
'use strict';
module.exports = Writable;
/* <replacement> */
function WriteReq(chunk, encoding, cb) {
this.chunk = chunk;
this.encoding = encoding;
this.callback = cb;
this.next = null;
} // It seems a linked list but it is not
// there will be only 2 of these for each stream
function CorkedRequest(state) {
var _this = this;
this.next = null;
this.entry = null;
this.finish = function () {
onCorkedFinish(_this, state);
};
}
/* </replacement> */
/*<replacement>*/
var Duplex;
/*</replacement>*/
Writable.WritableState = WritableState;
/*<replacement>*/
var internalUtil = {
deprecate: require('util-deprecate')
};
/*</replacement>*/
/*<replacement>*/
var Stream = require('./internal/streams/stream');
/*</replacement>*/
var Buffer = require('buffer').Buffer;
var OurUint8Array = global.Uint8Array || function () {};
function _uint8ArrayToBuffer(chunk) {
return Buffer.from(chunk);
}
function _isUint8Array(obj) {
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}
var destroyImpl = require('./internal/streams/destroy');
var _require = require('./internal/streams/state'),
getHighWaterMark = _require.getHighWaterMark;
var _require$codes = require('../errors').codes,
ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,
ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,
ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,
ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
var errorOrDestroy = destroyImpl.errorOrDestroy;
require('inherits')(Writable, Stream);
function nop() {}
function WritableState(options, stream, isDuplex) {
Duplex = Duplex || require('./_stream_duplex');
options = options || {}; // Duplex streams are both readable and writable, but share
// the same options object.
// However, some cases require setting options to different
// values for the readable and the writable sides of the duplex stream,
// e.g. options.readableObjectMode vs. options.writableObjectMode, etc.
if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream
// contains buffers or objects.
this.objectMode = !!options.objectMode;
if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false
// Note: 0 is a valid value, means that we always return false if
// the entire buffer is not flushed immediately on write()
this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called
this.finalCalled = false; // drain event flag.
this.needDrain = false; // at the start of calling end()
this.ending = false; // when end() has been called, and returned
this.ended = false; // when 'finish' is emitted
this.finished = false; // has it been destroyed
this.destroyed = false; // should we decode strings into buffers before passing to _write?
// this is here so that some node-core streams can optimize string
// handling at a lower level.
var noDecode = options.decodeStrings === false;
this.decodeStrings = !noDecode; // Crypto is kind of old and crusty. Historically, its default string
// encoding is 'binary' so we have to make this configurable.
// Everything else in the universe uses 'utf8', though.
this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement
// of how much we're waiting to get pushed to some underlying
// socket or file.
this.length = 0; // a flag to see when we're in the middle of a write.
this.writing = false; // when true all writes will be buffered until .uncork() call
this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,
// or on a later tick. We set this to true at first, because any
// actions that shouldn't happen until "later" should generally also
// not happen before the first write call.
this.sync = true; // a flag to know if we're processing previously buffered items, which
// may call the _write() callback in the same tick, so that we don't
// end up in an overlapped onwrite situation.
this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)
this.onwrite = function (er) {
onwrite(stream, er);
}; // the callback that the user supplies to write(chunk,encoding,cb)
this.writecb = null; // the amount that is being written when _write is called.
this.writelen = 0;
this.bufferedRequest = null;
this.lastBufferedRequest = null; // number of pending user-supplied write callbacks
// this must be 0 before 'finish' can be emitted
this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs
// This is relevant for synchronous Transform streams
this.prefinished = false; // True if the error was already emitted and should not be thrown again
this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.
this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')
this.autoDestroy = !!options.autoDestroy; // count buffered requests
this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always
// one allocated and free to use, and we maintain at most two
this.corkedRequestsFree = new CorkedRequest(this);
}
WritableState.prototype.getBuffer = function getBuffer() {
var current = this.bufferedRequest;
var out = [];
while (current) {
out.push(current);
current = current.next;
}
return out;
};
(function () {
try {
Object.defineProperty(WritableState.prototype, 'buffer', {
get: internalUtil.deprecate(function writableStateBufferGetter() {
return this.getBuffer();
}, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
});
} catch (_) {}
})(); // Test _writableState for inheritance to account for Duplex streams,
// whose prototype chain only points to Readable.
var realHasInstance;
if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
realHasInstance = Function.prototype[Symbol.hasInstance];
Object.defineProperty(Writable, Symbol.hasInstance, {
value: function value(object) {
if (realHasInstance.call(this, object)) return true;
if (this !== Writable) return false;
return object && object._writableState instanceof WritableState;
}
});
} else {
realHasInstance = function realHasInstance(object) {
return object instanceof this;
};
}
function Writable(options) {
Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too.
// `realHasInstance` is necessary because using plain `instanceof`
// would return false, as no `_writableState` property is attached.
// Trying to use the custom `instanceof` for Writable here will also break the
// Node.js LazyTransform implementation, which has a non-trivial getter for
// `_writableState` that would lead to infinite recursion.
// Checking for a Stream.Duplex instance is faster here instead of inside
// the WritableState constructor, at least with V8 6.5
var isDuplex = this instanceof Duplex;
if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
this._writableState = new WritableState(options, this, isDuplex); // legacy.
this.writable = true;
if (options) {
if (typeof options.write === 'function') this._write = options.write;
if (typeof options.writev === 'function') this._writev = options.writev;
if (typeof options.destroy === 'function') this._destroy = options.destroy;
if (typeof options.final === 'function') this._final = options.final;
}
Stream.call(this);
} // Otherwise people can pipe Writable streams, which is just wrong.
Writable.prototype.pipe = function () {
errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
};
function writeAfterEnd(stream, cb) {
var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb
errorOrDestroy(stream, er);
process.nextTick(cb, er);
} // Checks that a user-supplied chunk is valid, especially for the particular
// mode the stream is in. Currently this means that `null` is never accepted
// and undefined/non-string values are only allowed in object mode.
function validChunk(stream, state, chunk, cb) {
var er;
if (chunk === null) {
er = new ERR_STREAM_NULL_VALUES();
} else if (typeof chunk !== 'string' && !state.objectMode) {
er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);
}
if (er) {
errorOrDestroy(stream, er);
process.nextTick(cb, er);
return false;
}
return true;
}
Writable.prototype.write = function (chunk, encoding, cb) {
var state = this._writableState;
var ret = false;
var isBuf = !state.objectMode && _isUint8Array(chunk);
if (isBuf && !Buffer.isBuffer(chunk)) {
chunk = _uint8ArrayToBuffer(chunk);
}
if (typeof encoding === 'function') {
cb = encoding;
encoding = null;
}
if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
if (typeof cb !== 'function') cb = nop;
if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
state.pendingcb++;
ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
}
return ret;
};
Writable.prototype.cork = function () {
this._writableState.corked++;
};
Writable.prototype.uncork = function () {
var state = this._writableState;
if (state.corked) {
state.corked--;
if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
}
};
Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
// node::ParseEncoding() requires lower case.
if (typeof encoding === 'string') encoding = encoding.toLowerCase();
if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);
this._writableState.defaultEncoding = encoding;
return this;
};
Object.defineProperty(Writable.prototype, 'writableBuffer', {
// making it explicit this property is not enumerable
// because otherwise some prototype manipulation in
// userland will fail
enumerable: false,
get: function get() {
return this._writableState && this._writableState.getBuffer();
}
});
function decodeChunk(state, chunk, encoding) {
if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
chunk = Buffer.from(chunk, encoding);
}
return chunk;
}
Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
// making it explicit this property is not enumerable
// because otherwise some prototype manipulation in
// userland will fail
enumerable: false,
get: function get() {
return this._writableState.highWaterMark;
}
}); // if we're already writing something, then just put this
// in the queue, and wait our turn. Otherwise, call _write
// If we return false, then we need a drain event, so set that flag.
function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
if (!isBuf) {
var newChunk = decodeChunk(state, chunk, encoding);
if (chunk !== newChunk) {
isBuf = true;
encoding = 'buffer';
chunk = newChunk;
}
}
var len = state.objectMode ? 1 : chunk.length;
state.length += len;
var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.
if (!ret) state.needDrain = true;
if (state.writing || state.corked) {
var last = state.lastBufferedRequest;
state.lastBufferedRequest = {
chunk: chunk,
encoding: encoding,
isBuf: isBuf,
callback: cb,
next: null
};
if (last) {
last.next = state.lastBufferedRequest;
} else {
state.bufferedRequest = state.lastBufferedRequest;
}
state.bufferedRequestCount += 1;
} else {
doWrite(stream, state, false, len, chunk, encoding, cb);
}
return ret;
}
function doWrite(stream, state, writev, len, chunk, encoding, cb) {
state.writelen = len;
state.writecb = cb;
state.writing = true;
state.sync = true;
if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
state.sync = false;
}
function onwriteError(stream, state, sync, er, cb) {
--state.pendingcb;
if (sync) {
// defer the callback if we are being called synchronously
// to avoid piling up things on the stack
process.nextTick(cb, er); // this can emit finish, and it will always happen
// after error
process.nextTick(finishMaybe, stream, state);
stream._writableState.errorEmitted = true;
errorOrDestroy(stream, er);
} else {
// the caller expect this to happen before if
// it is async
cb(er);
stream._writableState.errorEmitted = true;
errorOrDestroy(stream, er); // this can emit finish, but finish must
// always follow error
finishMaybe(stream, state);
}
}
function onwriteStateUpdate(state) {
state.writing = false;
state.writecb = null;
state.length -= state.writelen;
state.writelen = 0;
}
function onwrite(stream, er) {
var state = stream._writableState;
var sync = state.sync;
var cb = state.writecb;
if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();
onwriteStateUpdate(state);
if (er) onwriteError(stream, state, sync, er, cb);else {
// Check if we're actually ready to finish, but don't emit yet
var finished = needFinish(state) || stream.destroyed;
if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
clearBuffer(stream, state);
}
if (sync) {
process.nextTick(afterWrite, stream, state, finished, cb);
} else {
afterWrite(stream, state, finished, cb);
}
}
}
function afterWrite(stream, state, finished, cb) {
if (!finished) onwriteDrain(stream, state);
state.pendingcb--;
cb();
finishMaybe(stream, state);
} // Must force callback to be called on nextTick, so that we don't
// emit 'drain' before the write() consumer gets the 'false' return
// value, and has a chance to attach a 'drain' listener.
function onwriteDrain(stream, state) {
if (state.length === 0 && state.needDrain) {
state.needDrain = false;
stream.emit('drain');
}
} // if there's something in the buffer waiting, then process it
function clearBuffer(stream, state) {
state.bufferProcessing = true;
var entry = state.bufferedRequest;
if (stream._writev && entry && entry.next) {
// Fast case, write everything using _writev()
var l = state.bufferedRequestCount;
var buffer = new Array(l);
var holder = state.corkedRequestsFree;
holder.entry = entry;
var count = 0;
var allBuffers = true;
while (entry) {
buffer[count] = entry;
if (!entry.isBuf) allBuffers = false;
entry = entry.next;
count += 1;
}
buffer.allBuffers = allBuffers;
doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time
// as the hot path ends with doWrite
state.pendingcb++;
state.lastBufferedRequest = null;
if (holder.next) {
state.corkedRequestsFree = holder.next;
holder.next = null;
} else {
state.corkedRequestsFree = new CorkedRequest(state);
}
state.bufferedRequestCount = 0;
} else {
// Slow case, write chunks one-by-one
while (entry) {
var chunk = entry.chunk;
var encoding = entry.encoding;
var cb = entry.callback;
var len = state.objectMode ? 1 : chunk.length;
doWrite(stream, state, false, len, chunk, encoding, cb);
entry = entry.next;
state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then
// it means that we need to wait until it does.
// also, that means that the chunk and cb are currently
// being processed, so move the buffer counter past them.
if (state.writing) {
break;
}
}
if (entry === null) state.lastBufferedRequest = null;
}
state.bufferedRequest = entry;
state.bufferProcessing = false;
}
Writable.prototype._write = function (chunk, encoding, cb) {
cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));
};
Writable.prototype._writev = null;
Writable.prototype.end = function (chunk, encoding, cb) {
var state = this._writableState;
if (typeof chunk === 'function') {
cb = chunk;
chunk = null;
encoding = null;
} else if (typeof encoding === 'function') {
cb = encoding;
encoding = null;
}
if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks
if (state.corked) {
state.corked = 1;
this.uncork();
} // ignore unnecessary end() calls.
if (!state.ending) endWritable(this, state, cb);
return this;
};
Object.defineProperty(Writable.prototype, 'writableLength', {
// making it explicit this property is not enumerable
// because otherwise some prototype manipulation in
// userland will fail
enumerable: false,
get: function get() {
return this._writableState.length;
}
});
function needFinish(state) {
return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
}
function callFinal(stream, state) {
stream._final(function (err) {
state.pendingcb--;
if (err) {
errorOrDestroy(stream, err);
}
state.prefinished = true;
stream.emit('prefinish');
finishMaybe(stream, state);
});
}
function prefinish(stream, state) {
if (!state.prefinished && !state.finalCalled) {
if (typeof stream._final === 'function' && !state.destroyed) {
state.pendingcb++;
state.finalCalled = true;
process.nextTick(callFinal, stream, state);
} else {
state.prefinished = true;
stream.emit('prefinish');
}
}
}
function finishMaybe(stream, state) {
var need = needFinish(state);
if (need) {
prefinish(stream, state);
if (state.pendingcb === 0) {
state.finished = true;
stream.emit('finish');
if (state.autoDestroy) {
// In case of duplex streams we need a way to detect
// if the readable side is ready for autoDestroy as well
var rState = stream._readableState;
if (!rState || rState.autoDestroy && rState.endEmitted) {
stream.destroy();
}
}
}
}
return need;
}
function endWritable(stream, state, cb) {
state.ending = true;
finishMaybe(stream, state);
if (cb) {
if (state.finished) process.nextTick(cb);else stream.once('finish', cb);
}
state.ended = true;
stream.writable = false;
}
function onCorkedFinish(corkReq, state, err) {
var entry = corkReq.entry;
corkReq.entry = null;
while (entry) {
var cb = entry.callback;
state.pendingcb--;
cb(err);
entry = entry.next;
} // reuse the free corkReq.
state.corkedRequestsFree.next = corkReq;
}
Object.defineProperty(Writable.prototype, 'destroyed', {
// making it explicit this property is not enumerable
// because otherwise some prototype manipulation in
// userland will fail
enumerable: false,
get: function get() {
if (this._writableState === undefined) {
return false;
}
return this._writableState.destroyed;
},
set: function set(value) {
// we ignore the value if the stream
// has not been initialized yet
if (!this._writableState) {
return;
} // backward compatibility, the user is explicitly
// managing destroyed
this._writableState.destroyed = value;
}
});
Writable.prototype.destroy = destroyImpl.destroy;
Writable.prototype._undestroy = destroyImpl.undestroy;
Writable.prototype._destroy = function (err, cb) {
cb(err);
};
}).call(this)}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"../errors":11,"./_stream_duplex":12,"./internal/streams/destroy":19,"./internal/streams/state":23,"./internal/streams/stream":24,"_process":100,"buffer":25,"inherits":95,"util-deprecate":116}],17:[function(require,module,exports){
(function (process){(function (){
'use strict';
var _Object$setPrototypeO;
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var finished = require('./end-of-stream');
var kLastResolve = Symbol('lastResolve');
var kLastReject = Symbol('lastReject');
var kError = Symbol('error');
var kEnded = Symbol('ended');
var kLastPromise = Symbol('lastPromise');
var kHandlePromise = Symbol('handlePromise');
var kStream = Symbol('stream');
function createIterResult(value, done) {
return {
value: value,
done: done
};
}
function readAndResolve(iter) {
var resolve = iter[kLastResolve];
if (resolve !== null) {
var data = iter[kStream].read(); // we defer if data is null
// we can be expecting either 'end' or
// 'error'
if (data !== null) {
iter[kLastPromise] = null;
iter[kLastResolve] = null;
iter[kLastReject] = null;
resolve(createIterResult(data, false));
}
}
}
function onReadable(iter) {
// we wait for the next tick, because it might
// emit an error with process.nextTick
process.nextTick(readAndResolve, iter);
}
function wrapForNext(lastPromise, iter) {
return function (resolve, reject) {
lastPromise.then(function () {
if (iter[kEnded]) {
resolve(createIterResult(undefined, true));
return;
}
iter[kHandlePromise](resolve, reject);
}, reject);
};
}
var AsyncIteratorPrototype = Object.getPrototypeOf(function () {});
var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
get stream() {
return this[kStream];
},
next: function next() {
var _this = this;
// if we have detected an error in the meanwhile
// reject straight away
var error = this[kError];
if (error !== null) {
return Promise.reject(error);
}
if (this[kEnded]) {
return Promise.resolve(createIterResult(undefined, true));
}
if (this[kStream].destroyed) {
// We need to defer via nextTick because if .destroy(err) is
// called, the error will be emitted via nextTick, and
// we cannot guarantee that there is no error lingering around
// waiting to be emitted.
return new Promise(function (resolve, reject) {
process.nextTick(function () {
if (_this[kError]) {
reject(_this[kError]);
} else {
resolve(createIterResult(undefined, true));
}
});
});
} // if we have multiple next() calls
// we will wait for the previous Promise to finish
// this logic is optimized to support for await loops,
// where next() is only called once at a time
var lastPromise = this[kLastPromise];
var promise;
if (lastPromise) {
promise = new Promise(wrapForNext(lastPromise, this));
} else {
// fast path needed to support multiple this.push()
// without triggering the next() queue
var data = this[kStream].read();
if (data !== null) {
return Promise.resolve(createIterResult(data, false));
}
promise = new Promise(this[kHandlePromise]);
}
this[kLastPromise] = promise;
return promise;
}
}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {
return this;
}), _defineProperty(_Object$setPrototypeO, "return", function _return() {
var _this2 = this;
// destroy(err, cb) is a private API
// we can guarantee we have that here, because we control the
// Readable class this is attached to
return new Promise(function (resolve, reject) {
_this2[kStream].destroy(null, function (err) {
if (err) {
reject(err);
return;
}
resolve(createIterResult(undefined, true));
});
});
}), _Object$setPrototypeO), AsyncIteratorPrototype);
var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
var _Object$create;
var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
value: stream,
writable: true
}), _defineProperty(_Object$create, kLastResolve, {
value: null,
writable: true
}), _defineProperty(_Object$create, kLastReject, {
value: null,
writable: true
}), _defineProperty(_Object$create, kError, {
value: null,
writable: true
}), _defineProperty(_Object$create, kEnded, {
value: stream._readableState.endEmitted,
writable: true
}), _defineProperty(_Object$create, kHandlePromise, {
value: function value(resolve, reject) {
var data = iterator[kStream].read();
if (data) {
iterator[kLastPromise] = null;
iterator[kLastResolve] = null;
iterator[kLastReject] = null;
resolve(createIterResult(data, false));
} else {
iterator[kLastResolve] = resolve;
iterator[kLastReject] = reject;
}
},
writable: true
}), _Object$create));
iterator[kLastPromise] = null;
finished(stream, function (err) {
if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise
// returned by next() and store the error
if (reject !== null) {
iterator[kLastPromise] = null;
iterator[kLastResolve] = null;
iterator[kLastReject] = null;
reject(err);
}
iterator[kError] = err;
return;
}
var resolve = iterator[kLastResolve];
if (resolve !== null) {
iterator[kLastPromise] = null;
iterator[kLastResolve] = null;
iterator[kLastReject] = null;
resolve(createIterResult(undefined, true));
}
iterator[kEnded] = true;
});
stream.on('readable', onReadable.bind(null, iterator));
return iterator;
};
module.exports = createReadableStreamAsyncIterator;
}).call(this)}).call(this,require('_process'))
},{"./end-of-stream":20,"_process":100}],18:[function(require,module,exports){
'use strict';
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var _require = require('buffer'),
Buffer = _require.Buffer;
var _require2 = require('util'),
inspect = _require2.inspect;
var custom = inspect && inspect.custom || 'inspect';
function copyBuffer(src, target, offset) {
Buffer.prototype.copy.call(src, target, offset);
}
module.exports =
/*#__PURE__*/
function () {
function BufferList() {
_classCallCheck(this, BufferList);
this.head = null;
this.tail = null;
this.length = 0;
}
_createClass(BufferList, [{
key: "push",
value: function push(v) {
var entry = {
data: v,
next: null
};
if (this.length > 0) this.tail.next = entry;else this.head = entry;
this.tail = entry;
++this.length;
}
}, {
key: "unshift",
value: function unshift(v) {
var entry = {
data: v,
next: this.head
};
if (this.length === 0) this.tail = entry;
this.head = entry;
++this.length;
}
}, {
key: "shift",
value: function shift() {
if (this.length === 0) return;
var ret = this.head.data;
if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
--this.length;
return ret;
}
}, {
key: "clear",
value: function clear() {
this.head = this.tail = null;
this.length = 0;
}
}, {
key: "join",
value: function join(s) {
if (this.length === 0) return '';
var p = this.head;
var ret = '' + p.data;
while (p = p.next) {
ret += s + p.data;
}
return ret;
}
}, {
key: "concat",
value: function concat(n) {
if (this.length === 0) return Buffer.alloc(0);
var ret = Buffer.allocUnsafe(n >>> 0);
var p = this.head;
var i = 0;
while (p) {
copyBuffer(p.data, ret, i);
i += p.data.length;
p = p.next;
}
return ret;
} // Consumes a specified amount of bytes or characters from the buffered data.
}, {
key: "consume",
value: function consume(n, hasStrings) {
var ret;
if (n < this.head.data.length) {
// `slice` is the same for buffers and strings.
ret = this.head.data.slice(0, n);
this.head.data = this.head.data.slice(n);
} else if (n === this.head.data.length) {
// First chunk is a perfect match.
ret = this.shift();
} else {
// Result spans more than one buffer.
ret = hasStrings ? this._getString(n) : this._getBuffer(n);
}
return ret;
}
}, {
key: "first",
value: function first() {
return this.head.data;
} // Consumes a specified amount of characters from the buffered data.
}, {
key: "_getString",
value: function _getString(n) {
var p = this.head;
var c = 1;
var ret = p.data;
n -= ret.length;
while (p = p.next) {
var str = p.data;
var nb = n > str.length ? str.length : n;
if (nb === str.length) ret += str;else ret += str.slice(0, n);
n -= nb;
if (n === 0) {
if (nb === str.length) {
++c;
if (p.next) this.head = p.next;else this.head = this.tail = null;
} else {
this.head = p;
p.data = str.slice(nb);
}
break;
}
++c;
}
this.length -= c;
return ret;
} // Consumes a specified amount of bytes from the buffered data.
}, {
key: "_getBuffer",
value: function _getBuffer(n) {
var ret = Buffer.allocUnsafe(n);
var p = this.head;
var c = 1;
p.data.copy(ret);
n -= p.data.length;
while (p = p.next) {
var buf = p.data;
var nb = n > buf.length ? buf.length : n;
buf.copy(ret, ret.length - n, 0, nb);
n -= nb;
if (n === 0) {
if (nb === buf.length) {
++c;
if (p.next) this.head = p.next;else this.head = this.tail = null;
} else {
this.head = p;
p.data = buf.slice(nb);
}
break;
}
++c;
}
this.length -= c;
return ret;
} // Make sure the linked list only shows the minimal necessary information.
}, {
key: custom,
value: function value(_, options) {
return inspect(this, _objectSpread({}, options, {
// Only inspect one level.
depth: 0,
// It should not recurse.
customInspect: false
}));
}
}]);
return BufferList;
}();
},{"buffer":25,"util":6}],19:[function(require,module,exports){
(function (process){(function (){
'use strict'; // undocumented cb() API, needed for core, not for public API
function destroy(err, cb) {
var _this = this;
var readableDestroyed = this._readableState && this._readableState.destroyed;
var writableDestroyed = this._writableState && this._writableState.destroyed;
if (readableDestroyed || writableDestroyed) {
if (cb) {
cb(err);
} else if (err) {
if (!this._writableState) {
process.nextTick(emitErrorNT, this, err);
} else if (!this._writableState.errorEmitted) {
this._writableState.errorEmitted = true;
process.nextTick(emitErrorNT, this, err);
}
}
return this;
} // we set destroyed to true before firing error callbacks in order
// to make it re-entrance safe in case destroy() is called within callbacks
if (this._readableState) {
this._readableState.destroyed = true;
} // if this is a duplex stream mark the writable part as destroyed as well
if (this._writableState) {
this._writableState.destroyed = true;
}
this._destroy(err || null, function (err) {
if (!cb && err) {
if (!_this._writableState) {
process.nextTick(emitErrorAndCloseNT, _this, err);
} else if (!_this._writableState.errorEmitted) {
_this._writableState.errorEmitted = true;
process.nextTick(emitErrorAndCloseNT, _this, err);
} else {
process.nextTick(emitCloseNT, _this);
}
} else if (cb) {
process.nextTick(emitCloseNT, _this);
cb(err);
} else {
process.nextTick(emitCloseNT, _this);
}
});
return this;
}
function emitErrorAndCloseNT(self, err) {
emitErrorNT(self, err);
emitCloseNT(self);
}
function emitCloseNT(self) {
if (self._writableState && !self._writableState.emitClose) return;
if (self._readableState && !self._readableState.emitClose) return;
self.emit('close');
}
function undestroy() {
if (this._readableState) {
this._readableState.destroyed = false;
this._readableState.reading = false;
this._readableState.ended = false;
this._readableState.endEmitted = false;
}
if (this._writableState) {
this._writableState.destroyed = false;
this._writableState.ended = false;
this._writableState.ending = false;
this._writableState.finalCalled = false;
this._writableState.prefinished = false;
this._writableState.finished = false;
this._writableState.errorEmitted = false;
}
}
function emitErrorNT(self, err) {
self.emit('error', err);
}
function errorOrDestroy(stream, err) {
// We have tests that rely on errors being emitted
// in the same tick, so changing this is semver major.
// For now when you opt-in to autoDestroy we allow
// the error to be emitted nextTick. In a future
// semver major update we should change the default to this.
var rState = stream._readableState;
var wState = stream._writableState;
if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
}
module.exports = {
destroy: destroy,
undestroy: undestroy,
errorOrDestroy: errorOrDestroy
};
}).call(this)}).call(this,require('_process'))
},{"_process":100}],20:[function(require,module,exports){
// Ported from https://github.com/mafintosh/end-of-stream with
// permission from the author, Mathias Buus (@mafintosh).
'use strict';
var ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;
function once(callback) {
var called = false;
return function () {
if (called) return;
called = true;
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
callback.apply(this, args);
};
}
function noop() {}
function isRequest(stream) {
return stream.setHeader && typeof stream.abort === 'function';
}
function eos(stream, opts, callback) {
if (typeof opts === 'function') return eos(stream, null, opts);
if (!opts) opts = {};
callback = once(callback || noop);
var readable = opts.readable || opts.readable !== false && stream.readable;
var writable = opts.writable || opts.writable !== false && stream.writable;
var onlegacyfinish = function onlegacyfinish() {
if (!stream.writable) onfinish();
};
var writableEnded = stream._writableState && stream._writableState.finished;
var onfinish = function onfinish() {
writable = false;
writableEnded = true;
if (!readable) callback.call(stream);
};
var readableEnded = stream._readableState && stream._readableState.endEmitted;
var onend = function onend() {
readable = false;
readableEnded = true;
if (!writable) callback.call(stream);
};
var onerror = function onerror(err) {
callback.call(stream, err);
};
var onclose = function onclose() {
var err;
if (readable && !readableEnded) {
if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
return callback.call(stream, err);
}
if (writable && !writableEnded) {
if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
return callback.call(stream, err);
}
};
var onrequest = function onrequest() {
stream.req.on('finish', onfinish);
};
if (isRequest(stream)) {
stream.on('complete', onfinish);
stream.on('abort', onclose);
if (stream.req) onrequest();else stream.on('request', onrequest);
} else if (writable && !stream._writableState) {
// legacy streams
stream.on('end', onlegacyfinish);
stream.on('close', onlegacyfinish);
}
stream.on('end', onend);
stream.on('finish', onfinish);
if (opts.error !== false) stream.on('error', onerror);
stream.on('close', onclose);
return function () {
stream.removeListener('complete', onfinish);
stream.removeListener('abort', onclose);
stream.removeListener('request', onrequest);
if (stream.req) stream.req.removeListener('finish', onfinish);
stream.removeListener('end', onlegacyfinish);
stream.removeListener('close', onlegacyfinish);
stream.removeListener('finish', onfinish);
stream.removeListener('end', onend);
stream.removeListener('error', onerror);
stream.removeListener('close', onclose);
};
}
module.exports = eos;
},{"../../../errors":11}],21:[function(require,module,exports){
module.exports = function () {
throw new Error('Readable.from is not available in the browser')
};
},{}],22:[function(require,module,exports){
// Ported from https://github.com/mafintosh/pump with
// permission from the author, Mathias Buus (@mafintosh).
'use strict';
var eos;
function once(callback) {
var called = false;
return function () {
if (called) return;
called = true;
callback.apply(void 0, arguments);
};
}
var _require$codes = require('../../../errors').codes,
ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
function noop(err) {
// Rethrow the error if it exists to avoid swallowing it
if (err) throw err;
}
function isRequest(stream) {
return stream.setHeader && typeof stream.abort === 'function';
}
function destroyer(stream, reading, writing, callback) {
callback = once(callback);
var closed = false;
stream.on('close', function () {
closed = true;
});
if (eos === undefined) eos = require('./end-of-stream');
eos(stream, {
readable: reading,
writable: writing
}, function (err) {
if (err) return callback(err);
closed = true;
callback();
});
var destroyed = false;
return function (err) {
if (closed) return;
if (destroyed) return;
destroyed = true; // request.destroy just do .end - .abort is what we want
if (isRequest(stream)) return stream.abort();
if (typeof stream.destroy === 'function') return stream.destroy();
callback(err || new ERR_STREAM_DESTROYED('pipe'));
};
}
function call(fn) {
fn();
}
function pipe(from, to) {
return from.pipe(to);
}
function popCallback(streams) {
if (!streams.length) return noop;
if (typeof streams[streams.length - 1] !== 'function') return noop;
return streams.pop();
}
function pipeline() {
for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
streams[_key] = arguments[_key];
}
var callback = popCallback(streams);
if (Array.isArray(streams[0])) streams = streams[0];
if (streams.length < 2) {
throw new ERR_MISSING_ARGS('streams');
}
var error;
var destroys = streams.map(function (stream, i) {
var reading = i < streams.length - 1;
var writing = i > 0;
return destroyer(stream, reading, writing, function (err) {
if (!error) error = err;
if (err) destroys.forEach(call);
if (reading) return;
destroys.forEach(call);
callback(error);
});
});
return streams.reduce(pipe);
}
module.exports = pipeline;
},{"../../../errors":11,"./end-of-stream":20}],23:[function(require,module,exports){
'use strict';
var ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;
function highWaterMarkFrom(options, isDuplex, duplexKey) {
return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
}
function getHighWaterMark(state, options, duplexKey, isDuplex) {
var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
if (hwm != null) {
if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
var name = isDuplex ? duplexKey : 'highWaterMark';
throw new ERR_INVALID_OPT_VALUE(name, hwm);
}
return Math.floor(hwm);
} // Default value
return state.objectMode ? 16 : 16 * 1024;
}
module.exports = {
getHighWaterMark: getHighWaterMark
};
},{"../../../errors":11}],24:[function(require,module,exports){
module.exports = require('events').EventEmitter;
},{"events":8}],25:[function(require,module,exports){
(function (Buffer){(function (){
/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <https://feross.org>
* @license MIT
*/
/* eslint-disable no-proto */
'use strict'
var base64 = require('base64-js')
var ieee754 = require('ieee754')
exports.Buffer = Buffer
exports.SlowBuffer = SlowBuffer
exports.INSPECT_MAX_BYTES = 50
var K_MAX_LENGTH = 0x7fffffff
exports.kMaxLength = K_MAX_LENGTH
/**
* If `Buffer.TYPED_ARRAY_SUPPORT`:
* === true Use Uint8Array implementation (fastest)
* === false Print warning and recommend using `buffer` v4.x which has an Object
* implementation (most compatible, even IE6)
*
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
* Opera 11.6+, iOS 4.2+.
*
* We report that the browser does not support typed arrays if the are not subclassable
* using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
* (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
* for __proto__ and has a buggy typed array implementation.
*/
Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
typeof console.error === 'function') {
console.error(
'This browser lacks typed array (Uint8Array) support which is required by ' +
'`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
)
}
function typedArraySupport () {
// Can typed array instances can be augmented?
try {
var arr = new Uint8Array(1)
arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }
return arr.foo() === 42
} catch (e) {
return false
}
}
Object.defineProperty(Buffer.prototype, 'parent', {
enumerable: true,
get: function () {
if (!Buffer.isBuffer(this)) return undefined
return this.buffer
}
})
Object.defineProperty(Buffer.prototype, 'offset', {
enumerable: true,
get: function () {
if (!Buffer.isBuffer(this)) return undefined
return this.byteOffset
}
})
function createBuffer (length) {
if (length > K_MAX_LENGTH) {
throw new RangeError('The value "' + length + '" is invalid for option "size"')
}
// Return an augmented `Uint8Array` instance
var buf = new Uint8Array(length)
buf.__proto__ = Buffer.prototype
return buf
}
/**
* The Buffer constructor returns instances of `Uint8Array` that have their
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
* returns a single octet.
*
* The `Uint8Array` prototype remains unmodified.
*/
function Buffer (arg, encodingOrOffset, length) {
// Common case.
if (typeof arg === 'number') {
if (typeof encodingOrOffset === 'string') {
throw new TypeError(
'The "string" argument must be of type string. Received type number'
)
}
return allocUnsafe(arg)
}
return from(arg, encodingOrOffset, length)
}
// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
if (typeof Symbol !== 'undefined' && Symbol.species != null &&
Buffer[Symbol.species] === Buffer) {
Object.defineProperty(Buffer, Symbol.species, {
value: null,
configurable: true,
enumerable: false,
writable: false
})
}
Buffer.poolSize = 8192 // not used by this implementation
function from (value, encodingOrOffset, length) {
if (typeof value === 'string') {
return fromString(value, encodingOrOffset)
}
if (ArrayBuffer.isView(value)) {
return fromArrayLike(value)
}
if (value == null) {
throw TypeError(
'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
'or Array-like Object. Received type ' + (typeof value)
)
}
if (isInstance(value, ArrayBuffer) ||
(value && isInstance(value.buffer, ArrayBuffer))) {
return fromArrayBuffer(value, encodingOrOffset, length)
}
if (typeof value === 'number') {
throw new TypeError(
'The "value" argument must not be of type number. Received type number'
)
}
var valueOf = value.valueOf && value.valueOf()
if (valueOf != null && valueOf !== value) {
return Buffer.from(valueOf, encodingOrOffset, length)
}
var b = fromObject(value)
if (b) return b
if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
typeof value[Symbol.toPrimitive] === 'function') {
return Buffer.from(
value[Symbol.toPrimitive]('string'), encodingOrOffset, length
)
}
throw new TypeError(
'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
'or Array-like Object. Received type ' + (typeof value)
)
}
/**
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
* if value is a number.
* Buffer.from(str[, encoding])
* Buffer.from(array)
* Buffer.from(buffer)
* Buffer.from(arrayBuffer[, byteOffset[, length]])
**/
Buffer.from = function (value, encodingOrOffset, length) {
return from(value, encodingOrOffset, length)
}
// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
// https://github.com/feross/buffer/pull/148
Buffer.prototype.__proto__ = Uint8Array.prototype
Buffer.__proto__ = Uint8Array
function assertSize (size) {
if (typeof size !== 'number') {
throw new TypeError('"size" argument must be of type number')
} else if (size < 0) {
throw new RangeError('The value "' + size + '" is invalid for option "size"')
}
}
function alloc (size, fill, encoding) {
assertSize(size)
if (size <= 0) {
return createBuffer(size)
}
if (fill !== undefined) {
// Only pay attention to encoding if it's a string. This
// prevents accidentally sending in a number that would
// be interpretted as a start offset.
return typeof encoding === 'string'
? createBuffer(size).fill(fill, encoding)
: createBuffer(size).fill(fill)
}
return createBuffer(size)
}
/**
* Creates a new filled Buffer instance.
* alloc(size[, fill[, encoding]])
**/
Buffer.alloc = function (size, fill, encoding) {
return alloc(size, fill, encoding)
}
function allocUnsafe (size) {
assertSize(size)
return createBuffer(size < 0 ? 0 : checked(size) | 0)
}
/**
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
* */
Buffer.allocUnsafe = function (size) {
return allocUnsafe(size)
}
/**
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
*/
Buffer.allocUnsafeSlow = function (size) {
return allocUnsafe(size)
}
function fromString (string, encoding) {
if (typeof encoding !== 'string' || encoding === '') {
encoding = 'utf8'
}
if (!Buffer.isEncoding(encoding)) {
throw new TypeError('Unknown encoding: ' + encoding)
}
var length = byteLength(string, encoding) | 0
var buf = createBuffer(length)
var actual = buf.write(string, encoding)
if (actual !== length) {
// Writing a hex string, for example, that contains invalid characters will
// cause everything after the first invalid character to be ignored. (e.g.
// 'abxxcd' will be treated as 'ab')
buf = buf.slice(0, actual)
}
return buf
}
function fromArrayLike (array) {
var length = array.length < 0 ? 0 : checked(array.length) | 0
var buf = createBuffer(length)
for (var i = 0; i < length; i += 1) {
buf[i] = array[i] & 255
}
return buf
}
function fromArrayBuffer (array, byteOffset, length) {
if (byteOffset < 0 || array.byteLength < byteOffset) {
throw new RangeError('"offset" is outside of buffer bounds')
}
if (array.byteLength < byteOffset + (length || 0)) {
throw new RangeError('"length" is outside of buffer bounds')
}
var buf
if (byteOffset === undefined && length === undefined) {
buf = new Uint8Array(array)
} else if (length === undefined) {
buf = new Uint8Array(array, byteOffset)
} else {
buf = new Uint8Array(array, byteOffset, length)
}
// Return an augmented `Uint8Array` instance
buf.__proto__ = Buffer.prototype
return buf
}
function fromObject (obj) {
if (Buffer.isBuffer(obj)) {
var len = checked(obj.length) | 0
var buf = createBuffer(len)
if (buf.length === 0) {
return buf
}
obj.copy(buf, 0, 0, len)
return buf
}
if (obj.length !== undefined) {
if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
return createBuffer(0)
}
return fromArrayLike(obj)
}
if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
return fromArrayLike(obj.data)
}
}
function checked (length) {
// Note: cannot use `length < K_MAX_LENGTH` here because that fails when
// length is NaN (which is otherwise coerced to zero.)
if (length >= K_MAX_LENGTH) {
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
}
return length | 0
}
function SlowBuffer (length) {
if (+length != length) { // eslint-disable-line eqeqeq
length = 0
}
return Buffer.alloc(+length)
}
Buffer.isBuffer = function isBuffer (b) {
return b != null && b._isBuffer === true &&
b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
}
Buffer.compare = function compare (a, b) {
if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
throw new TypeError(
'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
)
}
if (a === b) return 0
var x = a.length
var y = b.length
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
if (a[i] !== b[i]) {
x = a[i]
y = b[i]
break
}
}
if (x < y) return -1
if (y < x) return 1
return 0
}
Buffer.isEncoding = function isEncoding (encoding) {
switch (String(encoding).toLowerCase()) {
case 'hex':
case 'utf8':
case 'utf-8':
case 'ascii':
case 'latin1':
case 'binary':
case 'base64':
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return true
default:
return false
}
}
Buffer.concat = function concat (list, length) {
if (!Array.isArray(list)) {
throw new TypeError('"list" argument must be an Array of Buffers')
}
if (list.length === 0) {
return Buffer.alloc(0)
}
var i
if (length === undefined) {
length = 0
for (i = 0; i < list.length; ++i) {
length += list[i].length
}
}
var buffer = Buffer.allocUnsafe(length)
var pos = 0
for (i = 0; i < list.length; ++i) {
var buf = list[i]
if (isInstance(buf, Uint8Array)) {
buf = Buffer.from(buf)
}
if (!Buffer.isBuffer(buf)) {
throw new TypeError('"list" argument must be an Array of Buffers')
}
buf.copy(buffer, pos)
pos += buf.length
}
return buffer
}
function byteLength (string, encoding) {
if (Buffer.isBuffer(string)) {
return string.length
}
if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
return string.byteLength
}
if (typeof string !== 'string') {
throw new TypeError(
'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
'Received type ' + typeof string
)
}
var len = string.length
var mustMatch = (arguments.length > 2 && arguments[2] === true)
if (!mustMatch && len === 0) return 0
// Use a for loop to avoid recursion
var loweredCase = false
for (;;) {
switch (encoding) {
case 'ascii':
case 'latin1':
case 'binary':
return len
case 'utf8':
case 'utf-8':
return utf8ToBytes(string).length
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return len * 2
case 'hex':
return len >>> 1
case 'base64':
return base64ToBytes(string).length
default:
if (loweredCase) {
return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
}
encoding = ('' + encoding).toLowerCase()
loweredCase = true
}
}
}
Buffer.byteLength = byteLength
function slowToString (encoding, start, end) {
var loweredCase = false
// No need to verify that "this.length <= MAX_UINT32" since it's a read-only
// property of a typed array.
// This behaves neither like String nor Uint8Array in that we set start/end
// to their upper/lower bounds if the value passed is out of range.
// undefined is handled specially as per ECMA-262 6th Edition,
// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
if (start === undefined || start < 0) {
start = 0
}
// Return early if start > this.length. Done here to prevent potential uint32
// coercion fail below.
if (start > this.length) {
return ''
}
if (end === undefined || end > this.length) {
end = this.length
}
if (end <= 0) {
return ''
}
// Force coersion to uint32. This will also coerce falsey/NaN values to 0.
end >>>= 0
start >>>= 0
if (end <= start) {
return ''
}
if (!encoding) encoding = 'utf8'
while (true) {
switch (encoding) {
case 'hex':
return hexSlice(this, start, end)
case 'utf8':
case 'utf-8':
return utf8Slice(this, start, end)
case 'ascii':
return asciiSlice(this, start, end)
case 'latin1':
case 'binary':
return latin1Slice(this, start, end)
case 'base64':
return base64Slice(this, start, end)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return utf16leSlice(this, start, end)
default:
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
encoding = (encoding + '').toLowerCase()
loweredCase = true
}
}
}
// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
// reliably in a browserify context because there could be multiple different
// copies of the 'buffer' package in use. This method works even for Buffer
// instances that were created from another copy of the `buffer` package.
// See: https://github.com/feross/buffer/issues/154
Buffer.prototype._isBuffer = true
function swap (b, n, m) {
var i = b[n]
b[n] = b[m]
b[m] = i
}
Buffer.prototype.swap16 = function swap16 () {
var len = this.length
if (len % 2 !== 0) {
throw new RangeError('Buffer size must be a multiple of 16-bits')
}
for (var i = 0; i < len; i += 2) {
swap(this, i, i + 1)
}
return this
}
Buffer.prototype.swap32 = function swap32 () {
var len = this.length
if (len % 4 !== 0) {
throw new RangeError('Buffer size must be a multiple of 32-bits')
}
for (var i = 0; i < len; i += 4) {
swap(this, i, i + 3)
swap(this, i + 1, i + 2)
}
return this
}
Buffer.prototype.swap64 = function swap64 () {
var len = this.length
if (len % 8 !== 0) {
throw new RangeError('Buffer size must be a multiple of 64-bits')
}
for (var i = 0; i < len; i += 8) {
swap(this, i, i + 7)
swap(this, i + 1, i + 6)
swap(this, i + 2, i + 5)
swap(this, i + 3, i + 4)
}
return this
}
Buffer.prototype.toString = function toString () {
var length = this.length
if (length === 0) return ''
if (arguments.length === 0) return utf8Slice(this, 0, length)
return slowToString.apply(this, arguments)
}
Buffer.prototype.toLocaleString = Buffer.prototype.toString
Buffer.prototype.equals = function equals (b) {
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
if (this === b) return true
return Buffer.compare(this, b) === 0
}
Buffer.prototype.inspect = function inspect () {
var str = ''
var max = exports.INSPECT_MAX_BYTES
str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
if (this.length > max) str += ' ... '
return '<Buffer ' + str + '>'
}
Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
if (isInstance(target, Uint8Array)) {
target = Buffer.from(target, target.offset, target.byteLength)
}
if (!Buffer.isBuffer(target)) {
throw new TypeError(
'The "target" argument must be one of type Buffer or Uint8Array. ' +
'Received type ' + (typeof target)
)
}
if (start === undefined) {
start = 0
}
if (end === undefined) {
end = target ? target.length : 0
}
if (thisStart === undefined) {
thisStart = 0
}
if (thisEnd === undefined) {
thisEnd = this.length
}
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
throw new RangeError('out of range index')
}
if (thisStart >= thisEnd && start >= end) {
return 0
}
if (thisStart >= thisEnd) {
return -1
}
if (start >= end) {
return 1
}
start >>>= 0
end >>>= 0
thisStart >>>= 0
thisEnd >>>= 0
if (this === target) return 0
var x = thisEnd - thisStart
var y = end - start
var len = Math.min(x, y)
var thisCopy = this.slice(thisStart, thisEnd)
var targetCopy = target.slice(start, end)
for (var i = 0; i < len; ++i) {
if (thisCopy[i] !== targetCopy[i]) {
x = thisCopy[i]
y = targetCopy[i]
break
}
}
if (x < y) return -1
if (y < x) return 1
return 0
}
// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
//
// Arguments:
// - buffer - a Buffer to search
// - val - a string, Buffer, or number
// - byteOffset - an index into `buffer`; will be clamped to an int32
// - encoding - an optional encoding, relevant is val is a string
// - dir - true for indexOf, false for lastIndexOf
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
// Empty buffer means no match
if (buffer.length === 0) return -1
// Normalize byteOffset
if (typeof byteOffset === 'string') {
encoding = byteOffset
byteOffset = 0
} else if (byteOffset > 0x7fffffff) {
byteOffset = 0x7fffffff
} else if (byteOffset < -0x80000000) {
byteOffset = -0x80000000
}
byteOffset = +byteOffset // Coerce to Number.
if (numberIsNaN(byteOffset)) {
// byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
byteOffset = dir ? 0 : (buffer.length - 1)
}
// Normalize byteOffset: negative offsets start from the end of the buffer
if (byteOffset < 0) byteOffset = buffer.length + byteOffset
if (byteOffset >= buffer.length) {
if (dir) return -1
else byteOffset = buffer.length - 1
} else if (byteOffset < 0) {
if (dir) byteOffset = 0
else return -1
}
// Normalize val
if (typeof val === 'string') {
val = Buffer.from(val, encoding)
}
// Finally, search either indexOf (if dir is true) or lastIndexOf
if (Buffer.isBuffer(val)) {
// Special case: looking for empty string/buffer always fails
if (val.length === 0) {
return -1
}
return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
} else if (typeof val === 'number') {
val = val & 0xFF // Search for a byte value [0-255]
if (typeof Uint8Array.prototype.indexOf === 'function') {
if (dir) {
return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
} else {
return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
}
}
return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
}
throw new TypeError('val must be string, number or Buffer')
}
function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
var indexSize = 1
var arrLength = arr.length
var valLength = val.length
if (encoding !== undefined) {
encoding = String(encoding).toLowerCase()
if (encoding === 'ucs2' || encoding === 'ucs-2' ||
encoding === 'utf16le' || encoding === 'utf-16le') {
if (arr.length < 2 || val.length < 2) {
return -1
}
indexSize = 2
arrLength /= 2
valLength /= 2
byteOffset /= 2
}
}
function read (buf, i) {
if (indexSize === 1) {
return buf[i]
} else {
return buf.readUInt16BE(i * indexSize)
}
}
var i
if (dir) {
var foundIndex = -1
for (i = byteOffset; i < arrLength; i++) {
if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
if (foundIndex === -1) foundIndex = i
if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
} else {
if (foundIndex !== -1) i -= i - foundIndex
foundIndex = -1
}
}
} else {
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
for (i = byteOffset; i >= 0; i--) {
var found = true
for (var j = 0; j < valLength; j++) {
if (read(arr, i + j) !== read(val, j)) {
found = false
break
}
}
if (found) return i
}
}
return -1
}
Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1
}
Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
}
Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
}
function hexWrite (buf, string, offset, length) {
offset = Number(offset) || 0
var remaining = buf.length - offset
if (!length) {
length = remaining
} else {
length = Number(length)
if (length > remaining) {
length = remaining
}
}
var strLen = string.length
if (length > strLen / 2) {
length = strLen / 2
}
for (var i = 0; i < length; ++i) {
var parsed = parseInt(string.substr(i * 2, 2), 16)
if (numberIsNaN(parsed)) return i
buf[offset + i] = parsed
}
return i
}
function utf8Write (buf, string, offset, length) {
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
}
function asciiWrite (buf, string, offset, length) {
return blitBuffer(asciiToBytes(string), buf, offset, length)
}
function latin1Write (buf, string, offset, length) {
return asciiWrite(buf, string, offset, length)
}
function base64Write (buf, string, offset, length) {
return blitBuffer(base64ToBytes(string), buf, offset, length)
}
function ucs2Write (buf, string, offset, length) {
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
}
Buffer.prototype.write = function write (string, offset, length, encoding) {
// Buffer#write(string)
if (offset === undefined) {
encoding = 'utf8'
length = this.length
offset = 0
// Buffer#write(string, encoding)
} else if (length === undefined && typeof offset === 'string') {
encoding = offset
length = this.length
offset = 0
// Buffer#write(string, offset[, length][, encoding])
} else if (isFinite(offset)) {
offset = offset >>> 0
if (isFinite(length)) {
length = length >>> 0
if (encoding === undefined) encoding = 'utf8'
} else {
encoding = length
length = undefined
}
} else {
throw new Error(
'Buffer.write(string, encoding, offset[, length]) is no longer supported'
)
}
var remaining = this.length - offset
if (length === undefined || length > remaining) length = remaining
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
throw new RangeError('Attempt to write outside buffer bounds')
}
if (!encoding) encoding = 'utf8'
var loweredCase = false
for (;;) {
switch (encoding) {
case 'hex':
return hexWrite(this, string, offset, length)
case 'utf8':
case 'utf-8':
return utf8Write(this, string, offset, length)
case 'ascii':
return asciiWrite(this, string, offset, length)
case 'latin1':
case 'binary':
return latin1Write(this, string, offset, length)
case 'base64':
// Warning: maxLength not taken into account in base64Write
return base64Write(this, string, offset, length)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return ucs2Write(this, string, offset, length)
default:
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
encoding = ('' + encoding).toLowerCase()
loweredCase = true
}
}
}
Buffer.prototype.toJSON = function toJSON () {
return {
type: 'Buffer',
data: Array.prototype.slice.call(this._arr || this, 0)
}
}
function base64Slice (buf, start, end) {
if (start === 0 && end === buf.length) {
return base64.fromByteArray(buf)
} else {
return base64.fromByteArray(buf.slice(start, end))
}
}
function utf8Slice (buf, start, end) {
end = Math.min(buf.length, end)
var res = []
var i = start
while (i < end) {
var firstByte = buf[i]
var codePoint = null
var bytesPerSequence = (firstByte > 0xEF) ? 4
: (firstByte > 0xDF) ? 3
: (firstByte > 0xBF) ? 2
: 1
if (i + bytesPerSequence <= end) {
var secondByte, thirdByte, fourthByte, tempCodePoint
switch (bytesPerSequence) {
case 1:
if (firstByte < 0x80) {
codePoint = firstByte
}
break
case 2:
secondByte = buf[i + 1]
if ((secondByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
if (tempCodePoint > 0x7F) {
codePoint = tempCodePoint
}
}
break
case 3:
secondByte = buf[i + 1]
thirdByte = buf[i + 2]
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
codePoint = tempCodePoint
}
}
break
case 4:
secondByte = buf[i + 1]
thirdByte = buf[i + 2]
fourthByte = buf[i + 3]
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
codePoint = tempCodePoint
}
}
}
}
if (codePoint === null) {
// we did not generate a valid codePoint so insert a
// replacement char (U+FFFD) and advance only 1 byte
codePoint = 0xFFFD
bytesPerSequence = 1
} else if (codePoint > 0xFFFF) {
// encode to utf16 (surrogate pair dance)
codePoint -= 0x10000
res.push(codePoint >>> 10 & 0x3FF | 0xD800)
codePoint = 0xDC00 | codePoint & 0x3FF
}
res.push(codePoint)
i += bytesPerSequence
}
return decodeCodePointsArray(res)
}
// Based on http://stackoverflow.com/a/22747272/680742, the browser with
// the lowest limit is Chrome, with 0x10000 args.
// We go 1 magnitude less, for safety
var MAX_ARGUMENTS_LENGTH = 0x1000
function decodeCodePointsArray (codePoints) {
var len = codePoints.length
if (len <= MAX_ARGUMENTS_LENGTH) {
return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
}
// Decode in chunks to avoid "call stack size exceeded".
var res = ''
var i = 0
while (i < len) {
res += String.fromCharCode.apply(
String,
codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
)
}
return res
}
function asciiSlice (buf, start, end) {
var ret = ''
end = Math.min(buf.length, end)
for (var i = start; i < end; ++i) {
ret += String.fromCharCode(buf[i] & 0x7F)
}
return ret
}
function latin1Slice (buf, start, end) {
var ret = ''
end = Math.min(buf.length, end)
for (var i = start; i < end; ++i) {
ret += String.fromCharCode(buf[i])
}
return ret
}
function hexSlice (buf, start, end) {
var len = buf.length
if (!start || start < 0) start = 0
if (!end || end < 0 || end > len) end = len
var out = ''
for (var i = start; i < end; ++i) {
out += toHex(buf[i])
}
return out
}
function utf16leSlice (buf, start, end) {
var bytes = buf.slice(start, end)
var res = ''
for (var i = 0; i < bytes.length; i += 2) {
res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
}
return res
}
Buffer.prototype.slice = function slice (start, end) {
var len = this.length
start = ~~start
end = end === undefined ? len : ~~end
if (start < 0) {
start += len
if (start < 0) start = 0
} else if (start > len) {
start = len
}
if (end < 0) {
end += len
if (end < 0) end = 0
} else if (end > len) {
end = len
}
if (end < start) end = start
var newBuf = this.subarray(start, end)
// Return an augmented `Uint8Array` instance
newBuf.__proto__ = Buffer.prototype
return newBuf
}
/*
* Need to make sure that buffer isn't trying to write out of bounds.
*/
function checkOffset (offset, ext, length) {
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
}
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert) checkOffset(offset, byteLength, this.length)
var val = this[offset]
var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul
}
return val
}
Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert) {
checkOffset(offset, byteLength, this.length)
}
var val = this[offset + --byteLength]
var mul = 1
while (byteLength > 0 && (mul *= 0x100)) {
val += this[offset + --byteLength] * mul
}
return val
}
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 1, this.length)
return this[offset]
}
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 2, this.length)
return this[offset] | (this[offset + 1] << 8)
}
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 2, this.length)
return (this[offset] << 8) | this[offset + 1]
}
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 4, this.length)
return ((this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16)) +
(this[offset + 3] * 0x1000000)
}
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 4, this.length)
return (this[offset] * 0x1000000) +
((this[offset + 1] << 16) |
(this[offset + 2] << 8) |
this[offset + 3])
}
Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert) checkOffset(offset, byteLength, this.length)
var val = this[offset]
var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul
}
mul *= 0x80
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
return val
}
Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert) checkOffset(offset, byteLength, this.length)
var i = byteLength
var mul = 1
var val = this[offset + --i]
while (i > 0 && (mul *= 0x100)) {
val += this[offset + --i] * mul
}
mul *= 0x80
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
return val
}
Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 1, this.length)
if (!(this[offset] & 0x80)) return (this[offset])
return ((0xff - this[offset] + 1) * -1)
}
Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 2, this.length)
var val = this[offset] | (this[offset + 1] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}
Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 2, this.length)
var val = this[offset + 1] | (this[offset] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}
Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 4, this.length)
return (this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16) |
(this[offset + 3] << 24)
}
Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 4, this.length)
return (this[offset] << 24) |
(this[offset + 1] << 16) |
(this[offset + 2] << 8) |
(this[offset + 3])
}
Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, true, 23, 4)
}
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, false, 23, 4)
}
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, true, 52, 8)
}
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, false, 52, 8)
}
function checkInt (buf, value, offset, ext, max, min) {
if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
if (offset + ext > buf.length) throw new RangeError('Index out of range')
}
Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
value = +value
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1
checkInt(this, value, offset, byteLength, maxBytes, 0)
}
var mul = 1
var i = 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
value = +value
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1
checkInt(this, value, offset, byteLength, maxBytes, 0)
}
var i = byteLength - 1
var mul = 1
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
this[offset] = (value & 0xff)
return offset + 1
}
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
this[offset] = (value & 0xff)
this[offset + 1] = (value >>> 8)
return offset + 2
}
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
this[offset] = (value >>> 8)
this[offset + 1] = (value & 0xff)
return offset + 2
}
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
this[offset + 3] = (value >>> 24)
this[offset + 2] = (value >>> 16)
this[offset + 1] = (value >>> 8)
this[offset] = (value & 0xff)
return offset + 4
}
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = (value & 0xff)
return offset + 4
}
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) {
var limit = Math.pow(2, (8 * byteLength) - 1)
checkInt(this, value, offset, byteLength, limit - 1, -limit)
}
var i = 0
var mul = 1
var sub = 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
sub = 1
}
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) {
var limit = Math.pow(2, (8 * byteLength) - 1)
checkInt(this, value, offset, byteLength, limit - 1, -limit)
}
var i = byteLength - 1
var mul = 1
var sub = 0
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
sub = 1
}
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
if (value < 0) value = 0xff + value + 1
this[offset] = (value & 0xff)
return offset + 1
}
Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
this[offset] = (value & 0xff)
this[offset + 1] = (value >>> 8)
return offset + 2
}
Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
this[offset] = (value >>> 8)
this[offset + 1] = (value & 0xff)
return offset + 2
}
Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
this[offset] = (value & 0xff)
this[offset + 1] = (value >>> 8)
this[offset + 2] = (value >>> 16)
this[offset + 3] = (value >>> 24)
return offset + 4
}
Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (value < 0) value = 0xffffffff + value + 1
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = (value & 0xff)
return offset + 4
}
function checkIEEE754 (buf, value, offset, ext, max, min) {
if (offset + ext > buf.length) throw new RangeError('Index out of range')
if (offset < 0) throw new RangeError('Index out of range')
}
function writeFloat (buf, value, offset, littleEndian, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) {
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
}
ieee754.write(buf, value, offset, littleEndian, 23, 4)
return offset + 4
}
Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
return writeFloat(this, value, offset, true, noAssert)
}
Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
return writeFloat(this, value, offset, false, noAssert)
}
function writeDouble (buf, value, offset, littleEndian, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) {
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
}
ieee754.write(buf, value, offset, littleEndian, 52, 8)
return offset + 8
}
Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
return writeDouble(this, value, offset, true, noAssert)
}
Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
return writeDouble(this, value, offset, false, noAssert)
}
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
if (!start) start = 0
if (!end && end !== 0) end = this.length
if (targetStart >= target.length) targetStart = target.length
if (!targetStart) targetStart = 0
if (end > 0 && end < start) end = start
// Copy 0 bytes; we're done
if (end === start) return 0
if (target.length === 0 || this.length === 0) return 0
// Fatal error conditions
if (targetStart < 0) {
throw new RangeError('targetStart out of bounds')
}
if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
if (end < 0) throw new RangeError('sourceEnd out of bounds')
// Are we oob?
if (end > this.length) end = this.length
if (target.length - targetStart < end - start) {
end = target.length - targetStart + start
}
var len = end - start
if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
// Use built-in when available, missing from IE11
this.copyWithin(targetStart, start, end)
} else if (this === target && start < targetStart && targetStart < end) {
// descending copy from end
for (var i = len - 1; i >= 0; --i) {
target[i + targetStart] = this[i + start]
}
} else {
Uint8Array.prototype.set.call(
target,
this.subarray(start, end),
targetStart
)
}
return len
}
// Usage:
// buffer.fill(number[, offset[, end]])
// buffer.fill(buffer[, offset[, end]])
// buffer.fill(string[, offset[, end]][, encoding])
Buffer.prototype.fill = function fill (val, start, end, encoding) {
// Handle string cases:
if (typeof val === 'string') {
if (typeof start === 'string') {
encoding = start
start = 0
end = this.length
} else if (typeof end === 'string') {
encoding = end
end = this.length
}
if (encoding !== undefined && typeof encoding !== 'string') {
throw new TypeError('encoding must be a string')
}
if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
throw new TypeError('Unknown encoding: ' + encoding)
}
if (val.length === 1) {
var code = val.charCodeAt(0)
if ((encoding === 'utf8' && code < 128) ||
encoding === 'latin1') {
// Fast path: If `val` fits into a single byte, use that numeric value.
val = code
}
}
} else if (typeof val === 'number') {
val = val & 255
}
// Invalid ranges are not set to a default, so can range check early.
if (start < 0 || this.length < start || this.length < end) {
throw new RangeError('Out of range index')
}
if (end <= start) {
return this
}
start = start >>> 0
end = end === undefined ? this.length : end >>> 0
if (!val) val = 0
var i
if (typeof val === 'number') {
for (i = start; i < end; ++i) {
this[i] = val
}
} else {
var bytes = Buffer.isBuffer(val)
? val
: Buffer.from(val, encoding)
var len = bytes.length
if (len === 0) {
throw new TypeError('The value "' + val +
'" is invalid for argument "value"')
}
for (i = 0; i < end - start; ++i) {
this[i + start] = bytes[i % len]
}
}
return this
}
// HELPER FUNCTIONS
// ================
var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
function base64clean (str) {
// Node takes equal signs as end of the Base64 encoding
str = str.split('=')[0]
// Node strips out invalid characters like \n and \t from the string, base64-js does not
str = str.trim().replace(INVALID_BASE64_RE, '')
// Node converts strings with length < 2 to ''
if (str.length < 2) return ''
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
while (str.length % 4 !== 0) {
str = str + '='
}
return str
}
function toHex (n) {
if (n < 16) return '0' + n.toString(16)
return n.toString(16)
}
function utf8ToBytes (string, units) {
units = units || Infinity
var codePoint
var length = string.length
var leadSurrogate = null
var bytes = []
for (var i = 0; i < length; ++i) {
codePoint = string.charCodeAt(i)
// is surrogate component
if (codePoint > 0xD7FF && codePoint < 0xE000) {
// last char was a lead
if (!leadSurrogate) {
// no lead yet
if (codePoint > 0xDBFF) {
// unexpected trail
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
continue
} else if (i + 1 === length) {
// unpaired lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
continue
}
// valid lead
leadSurrogate = codePoint
continue
}
// 2 leads in a row
if (codePoint < 0xDC00) {
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
leadSurrogate = codePoint
continue
}
// valid surrogate pair
codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
} else if (leadSurrogate) {
// valid bmp char, but last char was a lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
}
leadSurrogate = null
// encode utf8
if (codePoint < 0x80) {
if ((units -= 1) < 0) break
bytes.push(codePoint)
} else if (codePoint < 0x800) {
if ((units -= 2) < 0) break
bytes.push(
codePoint >> 0x6 | 0xC0,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x10000) {
if ((units -= 3) < 0) break
bytes.push(
codePoint >> 0xC | 0xE0,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x110000) {
if ((units -= 4) < 0) break
bytes.push(
codePoint >> 0x12 | 0xF0,
codePoint >> 0xC & 0x3F | 0x80,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else {
throw new Error('Invalid code point')
}
}
return bytes
}
function asciiToBytes (str) {
var byteArray = []
for (var i = 0; i < str.length; ++i) {
// Node's code seems to be doing this and not & 0x7F..
byteArray.push(str.charCodeAt(i) & 0xFF)
}
return byteArray
}
function utf16leToBytes (str, units) {
var c, hi, lo
var byteArray = []
for (var i = 0; i < str.length; ++i) {
if ((units -= 2) < 0) break
c = str.charCodeAt(i)
hi = c >> 8
lo = c % 256
byteArray.push(lo)
byteArray.push(hi)
}
return byteArray
}
function base64ToBytes (str) {
return base64.toByteArray(base64clean(str))
}
function blitBuffer (src, dst, offset, length) {
for (var i = 0; i < length; ++i) {
if ((i + offset >= dst.length) || (i >= src.length)) break
dst[i + offset] = src[i]
}
return i
}
// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
// the `instanceof` check but they should be treated as of that type.
// See: https://github.com/feross/buffer/issues/166
function isInstance (obj, type) {
return obj instanceof type ||
(obj != null && obj.constructor != null && obj.constructor.name != null &&
obj.constructor.name === type.name)
}
function numberIsNaN (obj) {
// For IE11 support
return obj !== obj // eslint-disable-line no-self-compare
}
}).call(this)}).call(this,require("buffer").Buffer)
},{"base64-js":5,"buffer":25,"ieee754":94}],26:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var callBind = require('./');
var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));
module.exports = function callBoundIntrinsic(name, allowMissing) {
var intrinsic = GetIntrinsic(name, !!allowMissing);
if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
return callBind(intrinsic);
}
return intrinsic;
};
},{"./":27,"get-intrinsic":90}],27:[function(require,module,exports){
'use strict';
var bind = require('function-bind');
var GetIntrinsic = require('get-intrinsic');
var $apply = GetIntrinsic('%Function.prototype.apply%');
var $call = GetIntrinsic('%Function.prototype.call%');
var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);
var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);
var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
var $max = GetIntrinsic('%Math.max%');
if ($defineProperty) {
try {
$defineProperty({}, 'a', { value: 1 });
} catch (e) {
// IE 8 has a broken defineProperty
$defineProperty = null;
}
}
module.exports = function callBind(originalFunction) {
var func = $reflectApply(bind, $call, arguments);
if ($gOPD && $defineProperty) {
var desc = $gOPD(func, 'length');
if (desc.configurable) {
// original length, plus the receiver, minus any additional arguments (after the receiver)
$defineProperty(
func,
'length',
{ value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }
);
}
}
return func;
};
var applyBind = function applyBind() {
return $reflectApply(bind, $apply, arguments);
};
if ($defineProperty) {
$defineProperty(module.exports, 'apply', { value: applyBind });
} else {
module.exports.apply = applyBind;
}
},{"function-bind":89,"get-intrinsic":90}],28:[function(require,module,exports){
var pSlice = Array.prototype.slice;
var objectKeys = require('./lib/keys.js');
var isArguments = require('./lib/is_arguments.js');
var deepEqual = module.exports = function (actual, expected, opts) {
if (!opts) opts = {};
// 7.1. All identical values are equivalent, as determined by ===.
if (actual === expected) {
return true;
} else if (actual instanceof Date && expected instanceof Date) {
return actual.getTime() === expected.getTime();
// 7.3. Other pairs that do not both pass typeof value == 'object',
// equivalence is determined by ==.
} else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') {
return opts.strict ? actual === expected : actual == expected;
// 7.4. For all other Object pairs, including Array objects, equivalence is
// determined by having the same number of owned properties (as verified
// with Object.prototype.hasOwnProperty.call), the same set of keys
// (although not necessarily the same order), equivalent values for every
// corresponding key, and an identical 'prototype' property. Note: this
// accounts for both named and indexed properties on Arrays.
} else {
return objEquiv(actual, expected, opts);
}
}
function isUndefinedOrNull(value) {
return value === null || value === undefined;
}
function isBuffer (x) {
if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false;
if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
return false;
}
if (x.length > 0 && typeof x[0] !== 'number') return false;
return true;
}
function objEquiv(a, b, opts) {
var i, key;
if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
return false;
// an identical 'prototype' property.
if (a.prototype !== b.prototype) return false;
//~~~I've managed to break Object.keys through screwy arguments passing.
// Converting to array solves the problem.
if (isArguments(a)) {
if (!isArguments(b)) {
return false;
}
a = pSlice.call(a);
b = pSlice.call(b);
return deepEqual(a, b, opts);
}
if (isBuffer(a)) {
if (!isBuffer(b)) {
return false;
}
if (a.length !== b.length) return false;
for (i = 0; i < a.length; i++) {
if (a[i] !== b[i]) return false;
}
return true;
}
try {
var ka = objectKeys(a),
kb = objectKeys(b);
} catch (e) {//happens when one is a string literal and the other isn't
return false;
}
// having the same number of owned properties (keys incorporates
// hasOwnProperty)
if (ka.length != kb.length)
return false;
//the same set of keys (although not necessarily the same order),
ka.sort();
kb.sort();
//~~~cheap key test
for (i = ka.length - 1; i >= 0; i--) {
if (ka[i] != kb[i])
return false;
}
//equivalent values for every corresponding key, and
//~~~possibly expensive deep test
for (i = ka.length - 1; i >= 0; i--) {
key = ka[i];
if (!deepEqual(a[key], b[key], opts)) return false;
}
return typeof a === typeof b;
}
},{"./lib/is_arguments.js":29,"./lib/keys.js":30}],29:[function(require,module,exports){
var supportsArgumentsClass = (function(){
return Object.prototype.toString.call(arguments)
})() == '[object Arguments]';
exports = module.exports = supportsArgumentsClass ? supported : unsupported;
exports.supported = supported;
function supported(object) {
return Object.prototype.toString.call(object) == '[object Arguments]';
};
exports.unsupported = unsupported;
function unsupported(object){
return object &&
typeof object == 'object' &&
typeof object.length == 'number' &&
Object.prototype.hasOwnProperty.call(object, 'callee') &&
!Object.prototype.propertyIsEnumerable.call(object, 'callee') ||
false;
};
},{}],30:[function(require,module,exports){
exports = module.exports = typeof Object.keys === 'function'
? Object.keys : shim;
exports.shim = shim;
function shim (obj) {
var keys = [];
for (var key in obj) keys.push(key);
return keys;
}
},{}],31:[function(require,module,exports){
'use strict';
var keys = require('object-keys');
var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
var toStr = Object.prototype.toString;
var concat = Array.prototype.concat;
var origDefineProperty = Object.defineProperty;
var isFunction = function (fn) {
return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
};
var arePropertyDescriptorsSupported = function () {
var obj = {};
try {
origDefineProperty(obj, 'x', { enumerable: false, value: obj });
// eslint-disable-next-line no-unused-vars, no-restricted-syntax
for (var _ in obj) { // jscs:ignore disallowUnusedVariables
return false;
}
return obj.x === obj;
} catch (e) { /* this is IE 8. */
return false;
}
};
var supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported();
var defineProperty = function (object, name, value, predicate) {
if (name in object && (!isFunction(predicate) || !predicate())) {
return;
}
if (supportsDescriptors) {
origDefineProperty(object, name, {
configurable: true,
enumerable: false,
value: value,
writable: true
});
} else {
object[name] = value;
}
};
var defineProperties = function (object, map) {
var predicates = arguments.length > 2 ? arguments[2] : {};
var props = keys(map);
if (hasSymbols) {
props = concat.call(props, Object.getOwnPropertySymbols(map));
}
for (var i = 0; i < props.length; i += 1) {
defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
}
};
defineProperties.supportsDescriptors = !!supportsDescriptors;
module.exports = defineProperties;
},{"object-keys":98}],32:[function(require,module,exports){
module.exports = function () {
for (var i = 0; i < arguments.length; i++) {
if (arguments[i] !== undefined) return arguments[i];
}
};
},{}],33:[function(require,module,exports){
'use strict';
var ToNumber = require('./ToNumber');
var ToPrimitive = require('./ToPrimitive');
var Type = require('./Type');
// https://262.ecma-international.org/5.1/#sec-11.9.3
module.exports = function AbstractEqualityComparison(x, y) {
var xType = Type(x);
var yType = Type(y);
if (xType === yType) {
return x === y; // ES6+ specified this shortcut anyways.
}
if (x == null && y == null) {
return true;
}
if (xType === 'Number' && yType === 'String') {
return AbstractEqualityComparison(x, ToNumber(y));
}
if (xType === 'String' && yType === 'Number') {
return AbstractEqualityComparison(ToNumber(x), y);
}
if (xType === 'Boolean') {
return AbstractEqualityComparison(ToNumber(x), y);
}
if (yType === 'Boolean') {
return AbstractEqualityComparison(x, ToNumber(y));
}
if ((xType === 'String' || xType === 'Number') && yType === 'Object') {
return AbstractEqualityComparison(x, ToPrimitive(y));
}
if (xType === 'Object' && (yType === 'String' || yType === 'Number')) {
return AbstractEqualityComparison(ToPrimitive(x), y);
}
return false;
};
},{"./ToNumber":63,"./ToPrimitive":65,"./Type":70}],34:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var $Number = GetIntrinsic('%Number%');
var $TypeError = GetIntrinsic('%TypeError%');
var $isNaN = require('../helpers/isNaN');
var $isFinite = require('../helpers/isFinite');
var isPrefixOf = require('../helpers/isPrefixOf');
var ToNumber = require('./ToNumber');
var ToPrimitive = require('./ToPrimitive');
var Type = require('./Type');
// https://262.ecma-international.org/5.1/#sec-11.8.5
// eslint-disable-next-line max-statements
module.exports = function AbstractRelationalComparison(x, y, LeftFirst) {
if (Type(LeftFirst) !== 'Boolean') {
throw new $TypeError('Assertion failed: LeftFirst argument must be a Boolean');
}
var px;
var py;
if (LeftFirst) {
px = ToPrimitive(x, $Number);
py = ToPrimitive(y, $Number);
} else {
py = ToPrimitive(y, $Number);
px = ToPrimitive(x, $Number);
}
var bothStrings = Type(px) === 'String' && Type(py) === 'String';
if (!bothStrings) {
var nx = ToNumber(px);
var ny = ToNumber(py);
if ($isNaN(nx) || $isNaN(ny)) {
return undefined;
}
if ($isFinite(nx) && $isFinite(ny) && nx === ny) {
return false;
}
if (nx === Infinity) {
return false;
}
if (ny === Infinity) {
return true;
}
if (ny === -Infinity) {
return false;
}
if (nx === -Infinity) {
return true;
}
return nx < ny; // by now, these are both nonzero, finite, and not equal
}
if (isPrefixOf(py, px)) {
return false;
}
if (isPrefixOf(px, py)) {
return true;
}
return px < py; // both strings, neither a prefix of the other. shortcut for steps c-f
};
},{"../helpers/isFinite":79,"../helpers/isNaN":80,"../helpers/isPrefixOf":81,"./ToNumber":63,"./ToPrimitive":65,"./Type":70,"get-intrinsic":90}],35:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var $TypeError = GetIntrinsic('%TypeError%');
// http://262.ecma-international.org/5.1/#sec-9.10
module.exports = function CheckObjectCoercible(value, optMessage) {
if (value == null) {
throw new $TypeError(optMessage || ('Cannot call method on ' + value));
}
return value;
};
},{"get-intrinsic":90}],36:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var $EvalError = GetIntrinsic('%EvalError%');
var DayWithinYear = require('./DayWithinYear');
var InLeapYear = require('./InLeapYear');
var MonthFromTime = require('./MonthFromTime');
// https://262.ecma-international.org/5.1/#sec-15.9.1.5
module.exports = function DateFromTime(t) {
var m = MonthFromTime(t);
var d = DayWithinYear(t);
if (m === 0) {
return d + 1;
}
if (m === 1) {
return d - 30;
}
var leap = InLeapYear(t);
if (m === 2) {
return d - 58 - leap;
}
if (m === 3) {
return d - 89 - leap;
}
if (m === 4) {
return d - 119 - leap;
}
if (m === 5) {
return d - 150 - leap;
}
if (m === 6) {
return d - 180 - leap;
}
if (m === 7) {
return d - 211 - leap;
}
if (m === 8) {
return d - 242 - leap;
}
if (m === 9) {
return d - 272 - leap;
}
if (m === 10) {
return d - 303 - leap;
}
if (m === 11) {
return d - 333 - leap;
}
throw new $EvalError('Assertion failed: MonthFromTime returned an impossible value: ' + m);
};
},{"./DayWithinYear":39,"./InLeapYear":43,"./MonthFromTime":53,"get-intrinsic":90}],37:[function(require,module,exports){
'use strict';
var floor = require('./floor');
var msPerDay = require('../helpers/timeConstants').msPerDay;
// https://262.ecma-international.org/5.1/#sec-15.9.1.2
module.exports = function Day(t) {
return floor(t / msPerDay);
};
},{"../helpers/timeConstants":85,"./floor":74}],38:[function(require,module,exports){
'use strict';
var floor = require('./floor');
// https://262.ecma-international.org/5.1/#sec-15.9.1.3
module.exports = function DayFromYear(y) {
return (365 * (y - 1970)) + floor((y - 1969) / 4) - floor((y - 1901) / 100) + floor((y - 1601) / 400);
};
},{"./floor":74}],39:[function(require,module,exports){
'use strict';
var Day = require('./Day');
var DayFromYear = require('./DayFromYear');
var YearFromTime = require('./YearFromTime');
// https://262.ecma-international.org/5.1/#sec-15.9.1.4
module.exports = function DayWithinYear(t) {
return Day(t) - DayFromYear(YearFromTime(t));
};
},{"./Day":37,"./DayFromYear":38,"./YearFromTime":72}],40:[function(require,module,exports){
'use strict';
var modulo = require('./modulo');
// https://262.ecma-international.org/5.1/#sec-15.9.1.3
module.exports = function DaysInYear(y) {
if (modulo(y, 4) !== 0) {
return 365;
}
if (modulo(y, 100) !== 0) {
return 366;
}
if (modulo(y, 400) !== 0) {
return 365;
}
return 366;
};
},{"./modulo":75}],41:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var $TypeError = GetIntrinsic('%TypeError%');
var Type = require('./Type');
var IsDataDescriptor = require('./IsDataDescriptor');
var IsAccessorDescriptor = require('./IsAccessorDescriptor');
var assertRecord = require('../helpers/assertRecord');
// https://262.ecma-international.org/5.1/#sec-8.10.4
module.exports = function FromPropertyDescriptor(Desc) {
if (typeof Desc === 'undefined') {
return Desc;
}
assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
if (IsDataDescriptor(Desc)) {
return {
value: Desc['[[Value]]'],
writable: !!Desc['[[Writable]]'],
enumerable: !!Desc['[[Enumerable]]'],
configurable: !!Desc['[[Configurable]]']
};
} else if (IsAccessorDescriptor(Desc)) {
return {
get: Desc['[[Get]]'],
set: Desc['[[Set]]'],
enumerable: !!Desc['[[Enumerable]]'],
configurable: !!Desc['[[Configurable]]']
};
} else {
throw new $TypeError('FromPropertyDescriptor must be called with a fully populated Property Descriptor');
}
};
},{"../helpers/assertRecord":78,"./IsAccessorDescriptor":44,"./IsDataDescriptor":46,"./Type":70,"get-intrinsic":90}],42:[function(require,module,exports){
'use strict';
var floor = require('./floor');
var modulo = require('./modulo');
var timeConstants = require('../helpers/timeConstants');
var msPerHour = timeConstants.msPerHour;
var HoursPerDay = timeConstants.HoursPerDay;
// https://262.ecma-international.org/5.1/#sec-15.9.1.10
module.exports = function HourFromTime(t) {
return modulo(floor(t / msPerHour), HoursPerDay);
};
},{"../helpers/timeConstants":85,"./floor":74,"./modulo":75}],43:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var $EvalError = GetIntrinsic('%EvalError%');
var DaysInYear = require('./DaysInYear');
var YearFromTime = require('./YearFromTime');
// https://262.ecma-international.org/5.1/#sec-15.9.1.3
module.exports = function InLeapYear(t) {
var days = DaysInYear(YearFromTime(t));
if (days === 365) {
return 0;
}
if (days === 366) {
return 1;
}
throw new $EvalError('Assertion failed: there are not 365 or 366 days in a year, got: ' + days);
};
},{"./DaysInYear":40,"./YearFromTime":72,"get-intrinsic":90}],44:[function(require,module,exports){
'use strict';
var has = require('has');
var Type = require('./Type');
var assertRecord = require('../helpers/assertRecord');
// https://262.ecma-international.org/5.1/#sec-8.10.1
module.exports = function IsAccessorDescriptor(Desc) {
if (typeof Desc === 'undefined') {
return false;
}
assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
if (!has(Desc, '[[Get]]') && !has(Desc, '[[Set]]')) {
return false;
}
return true;
};
},{"../helpers/assertRecord":78,"./Type":70,"has":93}],45:[function(require,module,exports){
'use strict';
// http://262.ecma-international.org/5.1/#sec-9.11
module.exports = require('is-callable');
},{"is-callable":96}],46:[function(require,module,exports){
'use strict';
var has = require('has');
var Type = require('./Type');
var assertRecord = require('../helpers/assertRecord');
// https://262.ecma-international.org/5.1/#sec-8.10.2
module.exports = function IsDataDescriptor(Desc) {
if (typeof Desc === 'undefined') {
return false;
}
assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
if (!has(Desc, '[[Value]]') && !has(Desc, '[[Writable]]')) {
return false;
}
return true;
};
},{"../helpers/assertRecord":78,"./Type":70,"has":93}],47:[function(require,module,exports){
'use strict';
var IsAccessorDescriptor = require('./IsAccessorDescriptor');
var IsDataDescriptor = require('./IsDataDescriptor');
var Type = require('./Type');
var assertRecord = require('../helpers/assertRecord');
// https://262.ecma-international.org/5.1/#sec-8.10.3
module.exports = function IsGenericDescriptor(Desc) {
if (typeof Desc === 'undefined') {
return false;
}
assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
if (!IsAccessorDescriptor(Desc) && !IsDataDescriptor(Desc)) {
return true;
}
return false;
};
},{"../helpers/assertRecord":78,"./IsAccessorDescriptor":44,"./IsDataDescriptor":46,"./Type":70}],48:[function(require,module,exports){
'use strict';
// TODO, semver-major: delete this
var isPropertyDescriptor = require('../helpers/isPropertyDescriptor');
var Type = require('./Type');
var IsDataDescriptor = require('./IsDataDescriptor');
var IsAccessorDescriptor = require('./IsAccessorDescriptor');
// https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type
module.exports = function IsPropertyDescriptor(Desc) {
return isPropertyDescriptor({
IsDataDescriptor: IsDataDescriptor,
IsAccessorDescriptor: IsAccessorDescriptor,
Type: Type
}, Desc);
};
},{"../helpers/isPropertyDescriptor":82,"./IsAccessorDescriptor":44,"./IsDataDescriptor":46,"./Type":70}],49:[function(require,module,exports){
'use strict';
var $isFinite = require('../helpers/isFinite');
var msPerDay = require('../helpers/timeConstants').msPerDay;
// https://262.ecma-international.org/5.1/#sec-15.9.1.13
module.exports = function MakeDate(day, time) {
if (!$isFinite(day) || !$isFinite(time)) {
return NaN;
}
return (day * msPerDay) + time;
};
},{"../helpers/isFinite":79,"../helpers/timeConstants":85}],50:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var $DateUTC = GetIntrinsic('%Date.UTC%');
var $isFinite = require('../helpers/isFinite');
var DateFromTime = require('./DateFromTime');
var Day = require('./Day');
var floor = require('./floor');
var modulo = require('./modulo');
var MonthFromTime = require('./MonthFromTime');
var ToInteger = require('./ToInteger');
var YearFromTime = require('./YearFromTime');
// https://262.ecma-international.org/5.1/#sec-15.9.1.12
module.exports = function MakeDay(year, month, date) {
if (!$isFinite(year) || !$isFinite(month) || !$isFinite(date)) {
return NaN;
}
var y = ToInteger(year);
var m = ToInteger(month);
var dt = ToInteger(date);
var ym = y + floor(m / 12);
var mn = modulo(m, 12);
var t = $DateUTC(ym, mn, 1);
if (YearFromTime(t) !== ym || MonthFromTime(t) !== mn || DateFromTime(t) !== 1) {
return NaN;
}
return Day(t) + dt - 1;
};
},{"../helpers/isFinite":79,"./DateFromTime":36,"./Day":37,"./MonthFromTime":53,"./ToInteger":62,"./YearFromTime":72,"./floor":74,"./modulo":75,"get-intrinsic":90}],51:[function(require,module,exports){
'use strict';
var $isFinite = require('../helpers/isFinite');
var timeConstants = require('../helpers/timeConstants');
var msPerSecond = timeConstants.msPerSecond;
var msPerMinute = timeConstants.msPerMinute;
var msPerHour = timeConstants.msPerHour;
var ToInteger = require('./ToInteger');
// https://262.ecma-international.org/5.1/#sec-15.9.1.11
module.exports = function MakeTime(hour, min, sec, ms) {
if (!$isFinite(hour) || !$isFinite(min) || !$isFinite(sec) || !$isFinite(ms)) {
return NaN;
}
var h = ToInteger(hour);
var m = ToInteger(min);
var s = ToInteger(sec);
var milli = ToInteger(ms);
var t = (h * msPerHour) + (m * msPerMinute) + (s * msPerSecond) + milli;
return t;
};
},{"../helpers/isFinite":79,"../helpers/timeConstants":85,"./ToInteger":62}],52:[function(require,module,exports){
'use strict';
var floor = require('./floor');
var modulo = require('./modulo');
var timeConstants = require('../helpers/timeConstants');
var msPerMinute = timeConstants.msPerMinute;
var MinutesPerHour = timeConstants.MinutesPerHour;
// https://262.ecma-international.org/5.1/#sec-15.9.1.10
module.exports = function MinFromTime(t) {
return modulo(floor(t / msPerMinute), MinutesPerHour);
};
},{"../helpers/timeConstants":85,"./floor":74,"./modulo":75}],53:[function(require,module,exports){
'use strict';
var DayWithinYear = require('./DayWithinYear');
var InLeapYear = require('./InLeapYear');
// https://262.ecma-international.org/5.1/#sec-15.9.1.4
module.exports = function MonthFromTime(t) {
var day = DayWithinYear(t);
if (0 <= day && day < 31) {
return 0;
}
var leap = InLeapYear(t);
if (31 <= day && day < (59 + leap)) {
return 1;
}
if ((59 + leap) <= day && day < (90 + leap)) {
return 2;
}
if ((90 + leap) <= day && day < (120 + leap)) {
return 3;
}
if ((120 + leap) <= day && day < (151 + leap)) {
return 4;
}
if ((151 + leap) <= day && day < (181 + leap)) {
return 5;
}
if ((181 + leap) <= day && day < (212 + leap)) {
return 6;
}
if ((212 + leap) <= day && day < (243 + leap)) {
return 7;
}
if ((243 + leap) <= day && day < (273 + leap)) {
return 8;
}
if ((273 + leap) <= day && day < (304 + leap)) {
return 9;
}
if ((304 + leap) <= day && day < (334 + leap)) {
return 10;
}
if ((334 + leap) <= day && day < (365 + leap)) {
return 11;
}
};
},{"./DayWithinYear":39,"./InLeapYear":43}],54:[function(require,module,exports){
'use strict';
var $isNaN = require('../helpers/isNaN');
// http://262.ecma-international.org/5.1/#sec-9.12
module.exports = function SameValue(x, y) {
if (x === y) { // 0 === -0, but they are not identical.
if (x === 0) { return 1 / x === 1 / y; }
return true;
}
return $isNaN(x) && $isNaN(y);
};
},{"../helpers/isNaN":80}],55:[function(require,module,exports){
'use strict';
var floor = require('./floor');
var modulo = require('./modulo');
var timeConstants = require('../helpers/timeConstants');
var msPerSecond = timeConstants.msPerSecond;
var SecondsPerMinute = timeConstants.SecondsPerMinute;
// https://262.ecma-international.org/5.1/#sec-15.9.1.10
module.exports = function SecFromTime(t) {
return modulo(floor(t / msPerSecond), SecondsPerMinute);
};
},{"../helpers/timeConstants":85,"./floor":74,"./modulo":75}],56:[function(require,module,exports){
'use strict';
var Type = require('./Type');
// https://262.ecma-international.org/5.1/#sec-11.9.6
module.exports = function StrictEqualityComparison(x, y) {
var xType = Type(x);
var yType = Type(y);
if (xType !== yType) {
return false;
}
if (xType === 'Undefined' || xType === 'Null') {
return true;
}
return x === y; // shortcut for steps 4-7
};
},{"./Type":70}],57:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var $Date = GetIntrinsic('%Date%');
var $Number = GetIntrinsic('%Number%');
var $isFinite = require('../helpers/isFinite');
var abs = require('./abs');
var ToNumber = require('./ToNumber');
// https://262.ecma-international.org/5.1/#sec-15.9.1.14
module.exports = function TimeClip(time) {
if (!$isFinite(time) || abs(time) > 8.64e15) {
return NaN;
}
return $Number(new $Date(ToNumber(time)));
};
},{"../helpers/isFinite":79,"./ToNumber":63,"./abs":73,"get-intrinsic":90}],58:[function(require,module,exports){
'use strict';
var msPerDay = require('../helpers/timeConstants').msPerDay;
var DayFromYear = require('./DayFromYear');
// https://262.ecma-international.org/5.1/#sec-15.9.1.3
module.exports = function TimeFromYear(y) {
return msPerDay * DayFromYear(y);
};
},{"../helpers/timeConstants":85,"./DayFromYear":38}],59:[function(require,module,exports){
'use strict';
var modulo = require('./modulo');
var msPerDay = require('../helpers/timeConstants').msPerDay;
// https://262.ecma-international.org/5.1/#sec-15.9.1.2
module.exports = function TimeWithinDay(t) {
return modulo(t, msPerDay);
};
},{"../helpers/timeConstants":85,"./modulo":75}],60:[function(require,module,exports){
'use strict';
// http://262.ecma-international.org/5.1/#sec-9.2
module.exports = function ToBoolean(value) { return !!value; };
},{}],61:[function(require,module,exports){
'use strict';
var ToNumber = require('./ToNumber');
// http://262.ecma-international.org/5.1/#sec-9.5
module.exports = function ToInt32(x) {
return ToNumber(x) >> 0;
};
},{"./ToNumber":63}],62:[function(require,module,exports){
'use strict';
var abs = require('./abs');
var floor = require('./floor');
var ToNumber = require('./ToNumber');
var $isNaN = require('../helpers/isNaN');
var $isFinite = require('../helpers/isFinite');
var $sign = require('../helpers/sign');
// http://262.ecma-international.org/5.1/#sec-9.4
module.exports = function ToInteger(value) {
var number = ToNumber(value);
if ($isNaN(number)) { return 0; }
if (number === 0 || !$isFinite(number)) { return number; }
return $sign(number) * floor(abs(number));
};
},{"../helpers/isFinite":79,"../helpers/isNaN":80,"../helpers/sign":84,"./ToNumber":63,"./abs":73,"./floor":74}],63:[function(require,module,exports){
'use strict';
var ToPrimitive = require('./ToPrimitive');
// http://262.ecma-international.org/5.1/#sec-9.3
module.exports = function ToNumber(value) {
var prim = ToPrimitive(value, Number);
if (typeof prim !== 'string') {
return +prim; // eslint-disable-line no-implicit-coercion
}
// eslint-disable-next-line no-control-regex
var trimmed = prim.replace(/^[ \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u0085]+|[ \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u0085]+$/g, '');
if ((/^0[ob]|^[+-]0x/).test(trimmed)) {
return NaN;
}
return +trimmed; // eslint-disable-line no-implicit-coercion
};
},{"./ToPrimitive":65}],64:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var $Object = GetIntrinsic('%Object%');
var CheckObjectCoercible = require('./CheckObjectCoercible');
// http://262.ecma-international.org/5.1/#sec-9.9
module.exports = function ToObject(value) {
CheckObjectCoercible(value);
return $Object(value);
};
},{"./CheckObjectCoercible":35,"get-intrinsic":90}],65:[function(require,module,exports){
'use strict';
// http://262.ecma-international.org/5.1/#sec-9.1
module.exports = require('es-to-primitive/es5');
},{"es-to-primitive/es5":86}],66:[function(require,module,exports){
'use strict';
var has = require('has');
var GetIntrinsic = require('get-intrinsic');
var $TypeError = GetIntrinsic('%TypeError%');
var Type = require('./Type');
var ToBoolean = require('./ToBoolean');
var IsCallable = require('./IsCallable');
// https://262.ecma-international.org/5.1/#sec-8.10.5
module.exports = function ToPropertyDescriptor(Obj) {
if (Type(Obj) !== 'Object') {
throw new $TypeError('ToPropertyDescriptor requires an object');
}
var desc = {};
if (has(Obj, 'enumerable')) {
desc['[[Enumerable]]'] = ToBoolean(Obj.enumerable);
}
if (has(Obj, 'configurable')) {
desc['[[Configurable]]'] = ToBoolean(Obj.configurable);
}
if (has(Obj, 'value')) {
desc['[[Value]]'] = Obj.value;
}
if (has(Obj, 'writable')) {
desc['[[Writable]]'] = ToBoolean(Obj.writable);
}
if (has(Obj, 'get')) {
var getter = Obj.get;
if (typeof getter !== 'undefined' && !IsCallable(getter)) {
throw new $TypeError('getter must be a function');
}
desc['[[Get]]'] = getter;
}
if (has(Obj, 'set')) {
var setter = Obj.set;
if (typeof setter !== 'undefined' && !IsCallable(setter)) {
throw new $TypeError('setter must be a function');
}
desc['[[Set]]'] = setter;
}
if ((has(desc, '[[Get]]') || has(desc, '[[Set]]')) && (has(desc, '[[Value]]') || has(desc, '[[Writable]]'))) {
throw new $TypeError('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');
}
return desc;
};
},{"./IsCallable":45,"./ToBoolean":60,"./Type":70,"get-intrinsic":90,"has":93}],67:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var $String = GetIntrinsic('%String%');
// http://262.ecma-international.org/5.1/#sec-9.8
module.exports = function ToString(value) {
return $String(value);
};
},{"get-intrinsic":90}],68:[function(require,module,exports){
'use strict';
var abs = require('./abs');
var floor = require('./floor');
var modulo = require('./modulo');
var ToNumber = require('./ToNumber');
var $isNaN = require('../helpers/isNaN');
var $isFinite = require('../helpers/isFinite');
var $sign = require('../helpers/sign');
// http://262.ecma-international.org/5.1/#sec-9.7
module.exports = function ToUint16(value) {
var number = ToNumber(value);
if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; }
var posInt = $sign(number) * floor(abs(number));
return modulo(posInt, 0x10000);
};
},{"../helpers/isFinite":79,"../helpers/isNaN":80,"../helpers/sign":84,"./ToNumber":63,"./abs":73,"./floor":74,"./modulo":75}],69:[function(require,module,exports){
'use strict';
var ToNumber = require('./ToNumber');
// http://262.ecma-international.org/5.1/#sec-9.6
module.exports = function ToUint32(x) {
return ToNumber(x) >>> 0;
};
},{"./ToNumber":63}],70:[function(require,module,exports){
'use strict';
// https://262.ecma-international.org/5.1/#sec-8
module.exports = function Type(x) {
if (x === null) {
return 'Null';
}
if (typeof x === 'undefined') {
return 'Undefined';
}
if (typeof x === 'function' || typeof x === 'object') {
return 'Object';
}
if (typeof x === 'number') {
return 'Number';
}
if (typeof x === 'boolean') {
return 'Boolean';
}
if (typeof x === 'string') {
return 'String';
}
};
},{}],71:[function(require,module,exports){
'use strict';
var Day = require('./Day');
var modulo = require('./modulo');
// https://262.ecma-international.org/5.1/#sec-15.9.1.6
module.exports = function WeekDay(t) {
return modulo(Day(t) + 4, 7);
};
},{"./Day":37,"./modulo":75}],72:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var $Date = GetIntrinsic('%Date%');
var callBound = require('call-bind/callBound');
var $getUTCFullYear = callBound('Date.prototype.getUTCFullYear');
// https://262.ecma-international.org/5.1/#sec-15.9.1.3
module.exports = function YearFromTime(t) {
// largest y such that this.TimeFromYear(y) <= t
return $getUTCFullYear(new $Date(t));
};
},{"call-bind/callBound":26,"get-intrinsic":90}],73:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var $abs = GetIntrinsic('%Math.abs%');
// http://262.ecma-international.org/5.1/#sec-5.2
module.exports = function abs(x) {
return $abs(x);
};
},{"get-intrinsic":90}],74:[function(require,module,exports){
'use strict';
// var modulo = require('./modulo');
var $floor = Math.floor;
// http://262.ecma-international.org/5.1/#sec-5.2
module.exports = function floor(x) {
// return x - modulo(x, 1);
return $floor(x);
};
},{}],75:[function(require,module,exports){
'use strict';
var mod = require('../helpers/mod');
// https://262.ecma-international.org/5.1/#sec-5.2
module.exports = function modulo(x, y) {
return mod(x, y);
};
},{"../helpers/mod":83}],76:[function(require,module,exports){
'use strict';
var modulo = require('./modulo');
var msPerSecond = require('../helpers/timeConstants').msPerSecond;
// https://262.ecma-international.org/5.1/#sec-15.9.1.10
module.exports = function msFromTime(t) {
return modulo(t, msPerSecond);
};
},{"../helpers/timeConstants":85,"./modulo":75}],77:[function(require,module,exports){
'use strict';
/* eslint global-require: 0 */
// https://es5.github.io/#x9
module.exports = {
'Abstract Equality Comparison': require('./5/AbstractEqualityComparison'),
'Abstract Relational Comparison': require('./5/AbstractRelationalComparison'),
'Strict Equality Comparison': require('./5/StrictEqualityComparison'),
abs: require('./5/abs'),
CheckObjectCoercible: require('./5/CheckObjectCoercible'),
DateFromTime: require('./5/DateFromTime'),
Day: require('./5/Day'),
DayFromYear: require('./5/DayFromYear'),
DaysInYear: require('./5/DaysInYear'),
DayWithinYear: require('./5/DayWithinYear'),
floor: require('./5/floor'),
FromPropertyDescriptor: require('./5/FromPropertyDescriptor'),
HourFromTime: require('./5/HourFromTime'),
InLeapYear: require('./5/InLeapYear'),
IsAccessorDescriptor: require('./5/IsAccessorDescriptor'),
IsCallable: require('./5/IsCallable'),
IsDataDescriptor: require('./5/IsDataDescriptor'),
IsGenericDescriptor: require('./5/IsGenericDescriptor'),
IsPropertyDescriptor: require('./5/IsPropertyDescriptor'),
MakeDate: require('./5/MakeDate'),
MakeDay: require('./5/MakeDay'),
MakeTime: require('./5/MakeTime'),
MinFromTime: require('./5/MinFromTime'),
modulo: require('./5/modulo'),
MonthFromTime: require('./5/MonthFromTime'),
msFromTime: require('./5/msFromTime'),
SameValue: require('./5/SameValue'),
SecFromTime: require('./5/SecFromTime'),
TimeClip: require('./5/TimeClip'),
TimeFromYear: require('./5/TimeFromYear'),
TimeWithinDay: require('./5/TimeWithinDay'),
ToBoolean: require('./5/ToBoolean'),
ToInt32: require('./5/ToInt32'),
ToInteger: require('./5/ToInteger'),
ToNumber: require('./5/ToNumber'),
ToObject: require('./5/ToObject'),
ToPrimitive: require('./5/ToPrimitive'),
ToPropertyDescriptor: require('./5/ToPropertyDescriptor'),
ToString: require('./5/ToString'),
ToUint16: require('./5/ToUint16'),
ToUint32: require('./5/ToUint32'),
Type: require('./5/Type'),
WeekDay: require('./5/WeekDay'),
YearFromTime: require('./5/YearFromTime')
};
},{"./5/AbstractEqualityComparison":33,"./5/AbstractRelationalComparison":34,"./5/CheckObjectCoercible":35,"./5/DateFromTime":36,"./5/Day":37,"./5/DayFromYear":38,"./5/DayWithinYear":39,"./5/DaysInYear":40,"./5/FromPropertyDescriptor":41,"./5/HourFromTime":42,"./5/InLeapYear":43,"./5/IsAccessorDescriptor":44,"./5/IsCallable":45,"./5/IsDataDescriptor":46,"./5/IsGenericDescriptor":47,"./5/IsPropertyDescriptor":48,"./5/MakeDate":49,"./5/MakeDay":50,"./5/MakeTime":51,"./5/MinFromTime":52,"./5/MonthFromTime":53,"./5/SameValue":54,"./5/SecFromTime":55,"./5/StrictEqualityComparison":56,"./5/TimeClip":57,"./5/TimeFromYear":58,"./5/TimeWithinDay":59,"./5/ToBoolean":60,"./5/ToInt32":61,"./5/ToInteger":62,"./5/ToNumber":63,"./5/ToObject":64,"./5/ToPrimitive":65,"./5/ToPropertyDescriptor":66,"./5/ToString":67,"./5/ToUint16":68,"./5/ToUint32":69,"./5/Type":70,"./5/WeekDay":71,"./5/YearFromTime":72,"./5/abs":73,"./5/floor":74,"./5/modulo":75,"./5/msFromTime":76}],78:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var $TypeError = GetIntrinsic('%TypeError%');
var $SyntaxError = GetIntrinsic('%SyntaxError%');
var has = require('has');
var predicates = {
// https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type
'Property Descriptor': function isPropertyDescriptor(Type, Desc) {
if (Type(Desc) !== 'Object') {
return false;
}
var allowed = {
'[[Configurable]]': true,
'[[Enumerable]]': true,
'[[Get]]': true,
'[[Set]]': true,
'[[Value]]': true,
'[[Writable]]': true
};
for (var key in Desc) { // eslint-disable-line
if (has(Desc, key) && !allowed[key]) {
return false;
}
}
var isData = has(Desc, '[[Value]]');
var IsAccessor = has(Desc, '[[Get]]') || has(Desc, '[[Set]]');
if (isData && IsAccessor) {
throw new $TypeError('Property Descriptors may not be both accessor and data descriptors');
}
return true;
}
};
module.exports = function assertRecord(Type, recordType, argumentName, value) {
var predicate = predicates[recordType];
if (typeof predicate !== 'function') {
throw new $SyntaxError('unknown record type: ' + recordType);
}
if (!predicate(Type, value)) {
throw new $TypeError(argumentName + ' must be a ' + recordType);
}
};
},{"get-intrinsic":90,"has":93}],79:[function(require,module,exports){
'use strict';
var $isNaN = Number.isNaN || function (a) { return a !== a; };
module.exports = Number.isFinite || function (x) { return typeof x === 'number' && !$isNaN(x) && x !== Infinity && x !== -Infinity; };
},{}],80:[function(require,module,exports){
'use strict';
module.exports = Number.isNaN || function isNaN(a) {
return a !== a;
};
},{}],81:[function(require,module,exports){
'use strict';
var $strSlice = require('call-bind/callBound')('String.prototype.slice');
module.exports = function isPrefixOf(prefix, string) {
if (prefix === string) {
return true;
}
if (prefix.length > string.length) {
return false;
}
return $strSlice(string, 0, prefix.length) === prefix;
};
},{"call-bind/callBound":26}],82:[function(require,module,exports){
'use strict';
var GetIntrinsic = require('get-intrinsic');
var has = require('has');
var $TypeError = GetIntrinsic('%TypeError%');
module.exports = function IsPropertyDescriptor(ES, Desc) {
if (ES.Type(Desc) !== 'Object') {
return false;
}
var allowed = {
'[[Configurable]]': true,
'[[Enumerable]]': true,
'[[Get]]': true,
'[[Set]]': true,
'[[Value]]': true,
'[[Writable]]': true
};
for (var key in Desc) { // eslint-disable-line no-restricted-syntax
if (has(Desc, key) && !allowed[key]) {
return false;
}
}
if (ES.IsDataDescriptor(Desc) && ES.IsAccessorDescriptor(Desc)) {
throw new $TypeError('Property Descriptors may not be both accessor and data descriptors');
}
return true;
};
},{"get-intrinsic":90,"has":93}],83:[function(require,module,exports){
'use strict';
var $floor = Math.floor;
module.exports = function mod(number, modulo) {
var remain = number % modulo;
return $floor(remain >= 0 ? remain : remain + modulo);
};
},{}],84:[function(require,module,exports){
'use strict';
module.exports = function sign(number) {
return number >= 0 ? 1 : -1;
};
},{}],85:[function(require,module,exports){
'use strict';
var HoursPerDay = 24;
var MinutesPerHour = 60;
var SecondsPerMinute = 60;
var msPerSecond = 1e3;
var msPerMinute = msPerSecond * SecondsPerMinute;
var msPerHour = msPerMinute * MinutesPerHour;
var msPerDay = 86400000;
module.exports = {
HoursPerDay: HoursPerDay,
MinutesPerHour: MinutesPerHour,
SecondsPerMinute: SecondsPerMinute,
msPerSecond: msPerSecond,
msPerMinute: msPerMinute,
msPerHour: msPerHour,
msPerDay: msPerDay
};
},{}],86:[function(require,module,exports){
'use strict';
var toStr = Object.prototype.toString;
var isPrimitive = require('./helpers/isPrimitive');
var isCallable = require('is-callable');
// http://ecma-international.org/ecma-262/5.1/#sec-8.12.8
var ES5internalSlots = {
'[[DefaultValue]]': function (O) {
var actualHint;
if (arguments.length > 1) {
actualHint = arguments[1];
} else {
actualHint = toStr.call(O) === '[object Date]' ? String : Number;
}
if (actualHint === String || actualHint === Number) {
var methods = actualHint === String ? ['toString', 'valueOf'] : ['valueOf', 'toString'];
var value, i;
for (i = 0; i < methods.length; ++i) {
if (isCallable(O[methods[i]])) {
value = O[methods[i]]();
if (isPrimitive(value)) {
return value;
}
}
}
throw new TypeError('No default value');
}
throw new TypeError('invalid [[DefaultValue]] hint supplied');
}
};
// http://ecma-international.org/ecma-262/5.1/#sec-9.1
module.exports = function ToPrimitive(input) {
if (isPrimitive(input)) {
return input;
}
if (arguments.length > 1) {
return ES5internalSlots['[[DefaultValue]]'](input, arguments[1]);
}
return ES5internalSlots['[[DefaultValue]]'](input);
};
},{"./helpers/isPrimitive":87,"is-callable":96}],87:[function(require,module,exports){
'use strict';
module.exports = function isPrimitive(value) {
return value === null || (typeof value !== 'function' && typeof value !== 'object');
};
},{}],88:[function(require,module,exports){
'use strict';
/* eslint no-invalid-this: 1 */
var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
var slice = Array.prototype.slice;
var toStr = Object.prototype.toString;
var funcType = '[object Function]';
module.exports = function bind(that) {
var target = this;
if (typeof target !== 'function' || toStr.call(target) !== funcType) {
throw new TypeError(ERROR_MESSAGE + target);
}
var args = slice.call(arguments, 1);
var bound;
var binder = function () {
if (this instanceof bound) {
var result = target.apply(
this,
args.concat(slice.call(arguments))
);
if (Object(result) === result) {
return result;
}
return this;
} else {
return target.apply(
that,
args.concat(slice.call(arguments))
);
}
};
var boundLength = Math.max(0, target.length - args.length);
var boundArgs = [];
for (var i = 0; i < boundLength; i++) {
boundArgs.push('$' + i);
}
bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
if (target.prototype) {
var Empty = function Empty() {};
Empty.prototype = target.prototype;
bound.prototype = new Empty();
Empty.prototype = null;
}
return bound;
};
},{}],89:[function(require,module,exports){
'use strict';
var implementation = require('./implementation');
module.exports = Function.prototype.bind || implementation;
},{"./implementation":88}],90:[function(require,module,exports){
'use strict';
var undefined;
var $SyntaxError = SyntaxError;
var $Function = Function;
var $TypeError = TypeError;
// eslint-disable-next-line consistent-return
var getEvalledConstructor = function (expressionSyntax) {
try {
return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
} catch (e) {}
};
var $gOPD = Object.getOwnPropertyDescriptor;
if ($gOPD) {
try {
$gOPD({}, '');
} catch (e) {
$gOPD = null; // this is IE 8, which has a broken gOPD
}
}
var throwTypeError = function () {
throw new $TypeError();
};
var ThrowTypeError = $gOPD
? (function () {
try {
// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
arguments.callee; // IE 8 does not throw here
return throwTypeError;
} catch (calleeThrows) {
try {
// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
return $gOPD(arguments, 'callee').get;
} catch (gOPDthrows) {
return throwTypeError;
}
}
}())
: throwTypeError;
var hasSymbols = require('has-symbols')();
var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
var needsEval = {};
var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);
var INTRINSICS = {
'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,
'%Array%': Array,
'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
'%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,
'%AsyncFromSyncIteratorPrototype%': undefined,
'%AsyncFunction%': needsEval,
'%AsyncGenerator%': needsEval,
'%AsyncGeneratorFunction%': needsEval,
'%AsyncIteratorPrototype%': needsEval,
'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,
'%Boolean%': Boolean,
'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,
'%Date%': Date,
'%decodeURI%': decodeURI,
'%decodeURIComponent%': decodeURIComponent,
'%encodeURI%': encodeURI,
'%encodeURIComponent%': encodeURIComponent,
'%Error%': Error,
'%eval%': eval, // eslint-disable-line no-eval
'%EvalError%': EvalError,
'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,
'%Function%': $Function,
'%GeneratorFunction%': needsEval,
'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,
'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,
'%isFinite%': isFinite,
'%isNaN%': isNaN,
'%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,
'%JSON%': typeof JSON === 'object' ? JSON : undefined,
'%Map%': typeof Map === 'undefined' ? undefined : Map,
'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),
'%Math%': Math,
'%Number%': Number,
'%Object%': Object,
'%parseFloat%': parseFloat,
'%parseInt%': parseInt,
'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
'%RangeError%': RangeError,
'%ReferenceError%': ReferenceError,
'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
'%RegExp%': RegExp,
'%Set%': typeof Set === 'undefined' ? undefined : Set,
'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),
'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
'%String%': String,
'%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,
'%Symbol%': hasSymbols ? Symbol : undefined,
'%SyntaxError%': $SyntaxError,
'%ThrowTypeError%': ThrowTypeError,
'%TypedArray%': TypedArray,
'%TypeError%': $TypeError,
'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
'%URIError%': URIError,
'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,
'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet
};
var doEval = function doEval(name) {
var value;
if (name === '%AsyncFunction%') {
value = getEvalledConstructor('async function () {}');
} else if (name === '%GeneratorFunction%') {
value = getEvalledConstructor('function* () {}');
} else if (name === '%AsyncGeneratorFunction%') {
value = getEvalledConstructor('async function* () {}');
} else if (name === '%AsyncGenerator%') {
var fn = doEval('%AsyncGeneratorFunction%');
if (fn) {
value = fn.prototype;
}
} else if (name === '%AsyncIteratorPrototype%') {
var gen = doEval('%AsyncGenerator%');
if (gen) {
value = getProto(gen.prototype);
}
}
INTRINSICS[name] = value;
return value;
};
var LEGACY_ALIASES = {
'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
'%ArrayPrototype%': ['Array', 'prototype'],
'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
'%ArrayProto_values%': ['Array', 'prototype', 'values'],
'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
'%BooleanPrototype%': ['Boolean', 'prototype'],
'%DataViewPrototype%': ['DataView', 'prototype'],
'%DatePrototype%': ['Date', 'prototype'],
'%ErrorPrototype%': ['Error', 'prototype'],
'%EvalErrorPrototype%': ['EvalError', 'prototype'],
'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
'%FunctionPrototype%': ['Function', 'prototype'],
'%Generator%': ['GeneratorFunction', 'prototype'],
'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
'%JSONParse%': ['JSON', 'parse'],
'%JSONStringify%': ['JSON', 'stringify'],
'%MapPrototype%': ['Map', 'prototype'],
'%NumberPrototype%': ['Number', 'prototype'],
'%ObjectPrototype%': ['Object', 'prototype'],
'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
'%PromisePrototype%': ['Promise', 'prototype'],
'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
'%Promise_all%': ['Promise', 'all'],
'%Promise_reject%': ['Promise', 'reject'],
'%Promise_resolve%': ['Promise', 'resolve'],
'%RangeErrorPrototype%': ['RangeError', 'prototype'],
'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
'%RegExpPrototype%': ['RegExp', 'prototype'],
'%SetPrototype%': ['Set', 'prototype'],
'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
'%StringPrototype%': ['String', 'prototype'],
'%SymbolPrototype%': ['Symbol', 'prototype'],
'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
'%TypeErrorPrototype%': ['TypeError', 'prototype'],
'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
'%URIErrorPrototype%': ['URIError', 'prototype'],
'%WeakMapPrototype%': ['WeakMap', 'prototype'],
'%WeakSetPrototype%': ['WeakSet', 'prototype']
};
var bind = require('function-bind');
var hasOwn = require('has');
var $concat = bind.call(Function.call, Array.prototype.concat);
var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
var $replace = bind.call(Function.call, String.prototype.replace);
var $strSlice = bind.call(Function.call, String.prototype.slice);
/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
var stringToPath = function stringToPath(string) {
var first = $strSlice(string, 0, 1);
var last = $strSlice(string, -1);
if (first === '%' && last !== '%') {
throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
} else if (last === '%' && first !== '%') {
throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
}
var result = [];
$replace(string, rePropName, function (match, number, quote, subString) {
result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
});
return result;
};
/* end adaptation */
var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
var intrinsicName = name;
var alias;
if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
alias = LEGACY_ALIASES[intrinsicName];
intrinsicName = '%' + alias[0] + '%';
}
if (hasOwn(INTRINSICS, intrinsicName)) {
var value = INTRINSICS[intrinsicName];
if (value === needsEval) {
value = doEval(intrinsicName);
}
if (typeof value === 'undefined' && !allowMissing) {
throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
}
return {
alias: alias,
name: intrinsicName,
value: value
};
}
throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
};
module.exports = function GetIntrinsic(name, allowMissing) {
if (typeof name !== 'string' || name.length === 0) {
throw new $TypeError('intrinsic name must be a non-empty string');
}
if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
throw new $TypeError('"allowMissing" argument must be a boolean');
}
var parts = stringToPath(name);
var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
var intrinsicRealName = intrinsic.name;
var value = intrinsic.value;
var skipFurtherCaching = false;
var alias = intrinsic.alias;
if (alias) {
intrinsicBaseName = alias[0];
$spliceApply(parts, $concat([0, 1], alias));
}
for (var i = 1, isOwn = true; i < parts.length; i += 1) {
var part = parts[i];
var first = $strSlice(part, 0, 1);
var last = $strSlice(part, -1);
if (
(
(first === '"' || first === "'" || first === '`')
|| (last === '"' || last === "'" || last === '`')
)
&& first !== last
) {
throw new $SyntaxError('property names with quotes must have matching quotes');
}
if (part === 'constructor' || !isOwn) {
skipFurtherCaching = true;
}
intrinsicBaseName += '.' + part;
intrinsicRealName = '%' + intrinsicBaseName + '%';
if (hasOwn(INTRINSICS, intrinsicRealName)) {
value = INTRINSICS[intrinsicRealName];
} else if (value != null) {
if (!(part in value)) {
if (!allowMissing) {
throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
}
return void undefined;
}
if ($gOPD && (i + 1) >= parts.length) {
var desc = $gOPD(value, part);
isOwn = !!desc;
// By convention, when a data property is converted to an accessor
// property to emulate a data property that does not suffer from
// the override mistake, that accessor's getter is marked with
// an `originalValue` property. Here, when we detect this, we
// uphold the illusion by pretending to see that original data
// property, i.e., returning the value rather than the getter
// itself.
if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
value = desc.get;
} else {
value = value[part];
}
} else {
isOwn = hasOwn(value, part);
value = value[part];
}
if (isOwn && !skipFurtherCaching) {
INTRINSICS[intrinsicRealName] = value;
}
}
}
return value;
};
},{"function-bind":89,"has":93,"has-symbols":91}],91:[function(require,module,exports){
'use strict';
var origSymbol = typeof Symbol !== 'undefined' && Symbol;
var hasSymbolSham = require('./shams');
module.exports = function hasNativeSymbols() {
if (typeof origSymbol !== 'function') { return false; }
if (typeof Symbol !== 'function') { return false; }
if (typeof origSymbol('foo') !== 'symbol') { return false; }
if (typeof Symbol('bar') !== 'symbol') { return false; }
return hasSymbolSham();
};
},{"./shams":92}],92:[function(require,module,exports){
'use strict';
/* eslint complexity: [2, 18], max-statements: [2, 33] */
module.exports = function hasSymbols() {
if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
if (typeof Symbol.iterator === 'symbol') { return true; }
var obj = {};
var sym = Symbol('test');
var symObj = Object(sym);
if (typeof sym === 'string') { return false; }
if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
// temp disabled per https://github.com/ljharb/object.assign/issues/17
// if (sym instanceof Symbol) { return false; }
// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
// if (!(symObj instanceof Symbol)) { return false; }
// if (typeof Symbol.prototype.toString !== 'function') { return false; }
// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
var symVal = 42;
obj[sym] = symVal;
for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
var syms = Object.getOwnPropertySymbols(obj);
if (syms.length !== 1 || syms[0] !== sym) { return false; }
if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
if (typeof Object.getOwnPropertyDescriptor === 'function') {
var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
}
return true;
};
},{}],93:[function(require,module,exports){
'use strict';
var bind = require('function-bind');
module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
},{"function-bind":89}],94:[function(require,module,exports){
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
var e, m
var eLen = (nBytes * 8) - mLen - 1
var eMax = (1 << eLen) - 1
var eBias = eMax >> 1
var nBits = -7
var i = isLE ? (nBytes - 1) : 0
var d = isLE ? -1 : 1
var s = buffer[offset + i]
i += d
e = s & ((1 << (-nBits)) - 1)
s >>= (-nBits)
nBits += eLen
for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
m = e & ((1 << (-nBits)) - 1)
e >>= (-nBits)
nBits += mLen
for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
if (e === 0) {
e = 1 - eBias
} else if (e === eMax) {
return m ? NaN : ((s ? -1 : 1) * Infinity)
} else {
m = m + Math.pow(2, mLen)
e = e - eBias
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
}
exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c
var eLen = (nBytes * 8) - mLen - 1
var eMax = (1 << eLen) - 1
var eBias = eMax >> 1
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
var i = isLE ? 0 : (nBytes - 1)
var d = isLE ? 1 : -1
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
value = Math.abs(value)
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0
e = eMax
} else {
e = Math.floor(Math.log(value) / Math.LN2)
if (value * (c = Math.pow(2, -e)) < 1) {
e--
c *= 2
}
if (e + eBias >= 1) {
value += rt / c
} else {
value += rt * Math.pow(2, 1 - eBias)
}
if (value * c >= 2) {
e++
c /= 2
}
if (e + eBias >= eMax) {
m = 0
e = eMax
} else if (e + eBias >= 1) {
m = ((value * c) - 1) * Math.pow(2, mLen)
e = e + eBias
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
e = 0
}
}
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
e = (e << mLen) | m
eLen += mLen
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
buffer[offset + i - d] |= s * 128
}
},{}],95:[function(require,module,exports){
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
})
}
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}
}
},{}],96:[function(require,module,exports){
'use strict';
var fnToStr = Function.prototype.toString;
var reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;
var badArrayLike;
var isCallableMarker;
if (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {
try {
badArrayLike = Object.defineProperty({}, 'length', {
get: function () {
throw isCallableMarker;
}
});
isCallableMarker = {};
// eslint-disable-next-line no-throw-literal
reflectApply(function () { throw 42; }, null, badArrayLike);
} catch (_) {
if (_ !== isCallableMarker) {
reflectApply = null;
}
}
} else {
reflectApply = null;
}
var constructorRegex = /^\s*class\b/;
var isES6ClassFn = function isES6ClassFunction(value) {
try {
var fnStr = fnToStr.call(value);
return constructorRegex.test(fnStr);
} catch (e) {
return false; // not a function
}
};
var tryFunctionObject = function tryFunctionToStr(value) {
try {
if (isES6ClassFn(value)) { return false; }
fnToStr.call(value);
return true;
} catch (e) {
return false;
}
};
var toStr = Object.prototype.toString;
var fnClass = '[object Function]';
var genClass = '[object GeneratorFunction]';
var hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`
/* globals document: false */
var documentDotAll = typeof document === 'object' && typeof document.all === 'undefined' && document.all !== undefined ? document.all : {};
module.exports = reflectApply
? function isCallable(value) {
if (value === documentDotAll) { return true; }
if (!value) { return false; }
if (typeof value !== 'function' && typeof value !== 'object') { return false; }
if (typeof value === 'function' && !value.prototype) { return true; }
try {
reflectApply(value, null, badArrayLike);
} catch (e) {
if (e !== isCallableMarker) { return false; }
}
return !isES6ClassFn(value);
}
: function isCallable(value) {
if (value === documentDotAll) { return true; }
if (!value) { return false; }
if (typeof value !== 'function' && typeof value !== 'object') { return false; }
if (typeof value === 'function' && !value.prototype) { return true; }
if (hasToStringTag) { return tryFunctionObject(value); }
if (isES6ClassFn(value)) { return false; }
var strClass = toStr.call(value);
return strClass === fnClass || strClass === genClass;
};
},{}],97:[function(require,module,exports){
'use strict';
var keysShim;
if (!Object.keys) {
// modified from https://github.com/es-shims/es5-shim
var has = Object.prototype.hasOwnProperty;
var toStr = Object.prototype.toString;
var isArgs = require('./isArguments'); // eslint-disable-line global-require
var isEnumerable = Object.prototype.propertyIsEnumerable;
var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
var dontEnums = [
'toString',
'toLocaleString',
'valueOf',
'hasOwnProperty',
'isPrototypeOf',
'propertyIsEnumerable',
'constructor'
];
var equalsConstructorPrototype = function (o) {
var ctor = o.constructor;
return ctor && ctor.prototype === o;
};
var excludedKeys = {
$applicationCache: true,
$console: true,
$external: true,
$frame: true,
$frameElement: true,
$frames: true,
$innerHeight: true,
$innerWidth: true,
$onmozfullscreenchange: true,
$onmozfullscreenerror: true,
$outerHeight: true,
$outerWidth: true,
$pageXOffset: true,
$pageYOffset: true,
$parent: true,
$scrollLeft: true,
$scrollTop: true,
$scrollX: true,
$scrollY: true,
$self: true,
$webkitIndexedDB: true,
$webkitStorageInfo: true,
$window: true
};
var hasAutomationEqualityBug = (function () {
/* global window */
if (typeof window === 'undefined') { return false; }
for (var k in window) {
try {
if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
try {
equalsConstructorPrototype(window[k]);
} catch (e) {
return true;
}
}
} catch (e) {
return true;
}
}
return false;
}());
var equalsConstructorPrototypeIfNotBuggy = function (o) {
/* global window */
if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
return equalsConstructorPrototype(o);
}
try {
return equalsConstructorPrototype(o);
} catch (e) {
return false;
}
};
keysShim = function keys(object) {
var isObject = object !== null && typeof object === 'object';
var isFunction = toStr.call(object) === '[object Function]';
var isArguments = isArgs(object);
var isString = isObject && toStr.call(object) === '[object String]';
var theKeys = [];
if (!isObject && !isFunction && !isArguments) {
throw new TypeError('Object.keys called on a non-object');
}
var skipProto = hasProtoEnumBug && isFunction;
if (isString && object.length > 0 && !has.call(object, 0)) {
for (var i = 0; i < object.length; ++i) {
theKeys.push(String(i));
}
}
if (isArguments && object.length > 0) {
for (var j = 0; j < object.length; ++j) {
theKeys.push(String(j));
}
} else {
for (var name in object) {
if (!(skipProto && name === 'prototype') && has.call(object, name)) {
theKeys.push(String(name));
}
}
}
if (hasDontEnumBug) {
var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
for (var k = 0; k < dontEnums.length; ++k) {
if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
theKeys.push(dontEnums[k]);
}
}
}
return theKeys;
};
}
module.exports = keysShim;
},{"./isArguments":99}],98:[function(require,module,exports){
'use strict';
var slice = Array.prototype.slice;
var isArgs = require('./isArguments');
var origKeys = Object.keys;
var keysShim = origKeys ? function keys(o) { return origKeys(o); } : require('./implementation');
var originalKeys = Object.keys;
keysShim.shim = function shimObjectKeys() {
if (Object.keys) {
var keysWorksWithArguments = (function () {
// Safari 5.0 bug
var args = Object.keys(arguments);
return args && args.length === arguments.length;
}(1, 2));
if (!keysWorksWithArguments) {
Object.keys = function keys(object) { // eslint-disable-line func-name-matching
if (isArgs(object)) {
return originalKeys(slice.call(object));
}
return originalKeys(object);
};
}
} else {
Object.keys = keysShim;
}
return Object.keys || keysShim;
};
module.exports = keysShim;
},{"./implementation":97,"./isArguments":99}],99:[function(require,module,exports){
'use strict';
var toStr = Object.prototype.toString;
module.exports = function isArguments(value) {
var str = toStr.call(value);
var isArgs = str === '[object Arguments]';
if (!isArgs) {
isArgs = str !== '[object Array]' &&
value !== null &&
typeof value === 'object' &&
typeof value.length === 'number' &&
value.length >= 0 &&
toStr.call(value.callee) === '[object Function]';
}
return isArgs;
};
},{}],100:[function(require,module,exports){
// shim for using process in browser
var process = module.exports = {};
// cached from whatever global is present so that test runners that stub it
// don't break things. But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals. It's inside a
// function because try/catches deoptimize in certain engines.
var cachedSetTimeout;
var cachedClearTimeout;
function defaultSetTimout() {
throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
throw new Error('clearTimeout has not been defined');
}
(function () {
try {
if (typeof setTimeout === 'function') {
cachedSetTimeout = setTimeout;
} else {
cachedSetTimeout = defaultSetTimout;
}
} catch (e) {
cachedSetTimeout = defaultSetTimout;
}
try {
if (typeof clearTimeout === 'function') {
cachedClearTimeout = clearTimeout;
} else {
cachedClearTimeout = defaultClearTimeout;
}
} catch (e) {
cachedClearTimeout = defaultClearTimeout;
}
} ())
function runTimeout(fun) {
if (cachedSetTimeout === setTimeout) {
//normal enviroments in sane situations
return setTimeout(fun, 0);
}
// if setTimeout wasn't available but was latter defined
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
cachedSetTimeout = setTimeout;
return setTimeout(fun, 0);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedSetTimeout(fun, 0);
} catch(e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedSetTimeout.call(null, fun, 0);
} catch(e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
return cachedSetTimeout.call(this, fun, 0);
}
}
}
function runClearTimeout(marker) {
if (cachedClearTimeout === clearTimeout) {
//normal enviroments in sane situations
return clearTimeout(marker);
}
// if clearTimeout wasn't available but was latter defined
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
cachedClearTimeout = clearTimeout;
return clearTimeout(marker);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedClearTimeout(marker);
} catch (e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedClearTimeout.call(null, marker);
} catch (e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
return cachedClearTimeout.call(this, marker);
}
}
}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
if (!draining || !currentQueue) {
return;
}
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = runTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while(len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
runClearTimeout(timeout);
}
process.nextTick = function (fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
runTimeout(drainQueue);
}
};
// v8 likes predictible objects
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;
process.listeners = function (name) { return [] }
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };
},{}],101:[function(require,module,exports){
(function (process,setImmediate){(function (){
var through = require('through');
var nextTick = typeof setImmediate !== 'undefined'
? setImmediate
: process.nextTick
;
module.exports = function (write, end) {
var tr = through(write, end);
tr.pause();
var resume = tr.resume;
var pause = tr.pause;
var paused = false;
tr.pause = function () {
paused = true;
return pause.apply(this, arguments);
};
tr.resume = function () {
paused = false;
return resume.apply(this, arguments);
};
nextTick(function () {
if (!paused) tr.resume();
});
return tr;
};
}).call(this)}).call(this,require('_process'),require("timers").setImmediate)
},{"_process":100,"through":114,"timers":115}],102:[function(require,module,exports){
/* eslint-disable node/no-deprecated-api */
var buffer = require('buffer')
var Buffer = buffer.Buffer
// alternative to using Object.keys for old browsers
function copyProps (src, dst) {
for (var key in src) {
dst[key] = src[key]
}
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
module.exports = buffer
} else {
// Copy properties from require('buffer')
copyProps(buffer, exports)
exports.Buffer = SafeBuffer
}
function SafeBuffer (arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length)
}
// Copy static methods from Buffer
copyProps(Buffer, SafeBuffer)
SafeBuffer.from = function (arg, encodingOrOffset, length) {
if (typeof arg === 'number') {
throw new TypeError('Argument must not be a number')
}
return Buffer(arg, encodingOrOffset, length)
}
SafeBuffer.alloc = function (size, fill, encoding) {
if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
var buf = Buffer(size)
if (fill !== undefined) {
if (typeof encoding === 'string') {
buf.fill(fill, encoding)
} else {
buf.fill(fill)
}
} else {
buf.fill(0)
}
return buf
}
SafeBuffer.allocUnsafe = function (size) {
if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
return Buffer(size)
}
SafeBuffer.allocUnsafeSlow = function (size) {
if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
return buffer.SlowBuffer(size)
}
},{"buffer":25}],103:[function(require,module,exports){
'use strict';
var bind = require('function-bind');
var ES = require('es-abstract/es5');
var replace = bind.call(Function.call, String.prototype.replace);
var leftWhitespace = /^[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+/;
var rightWhitespace = /[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+$/;
module.exports = function trim() {
var S = ES.ToString(ES.CheckObjectCoercible(this));
return replace(replace(S, leftWhitespace, ''), rightWhitespace, '');
};
},{"es-abstract/es5":77,"function-bind":89}],104:[function(require,module,exports){
'use strict';
var bind = require('function-bind');
var define = require('define-properties');
var implementation = require('./implementation');
var getPolyfill = require('./polyfill');
var shim = require('./shim');
var boundTrim = bind.call(Function.call, getPolyfill());
define(boundTrim, {
getPolyfill: getPolyfill,
implementation: implementation,
shim: shim
});
module.exports = boundTrim;
},{"./implementation":103,"./polyfill":105,"./shim":106,"define-properties":31,"function-bind":89}],105:[function(require,module,exports){
'use strict';
var implementation = require('./implementation');
var zeroWidthSpace = '\u200b';
module.exports = function getPolyfill() {
if (String.prototype.trim && zeroWidthSpace.trim() === zeroWidthSpace) {
return String.prototype.trim;
}
return implementation;
};
},{"./implementation":103}],106:[function(require,module,exports){
'use strict';
var define = require('define-properties');
var getPolyfill = require('./polyfill');
module.exports = function shimStringTrim() {
var polyfill = getPolyfill();
define(String.prototype, { trim: polyfill }, { trim: function () { return String.prototype.trim !== polyfill; } });
return polyfill;
};
},{"./polyfill":105,"define-properties":31}],107:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
'use strict';
/*<replacement>*/
var Buffer = require('safe-buffer').Buffer;
/*</replacement>*/
var isEncoding = Buffer.isEncoding || function (encoding) {
encoding = '' + encoding;
switch (encoding && encoding.toLowerCase()) {
case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
return true;
default:
return false;
}
};
function _normalizeEncoding(enc) {
if (!enc) return 'utf8';
var retried;
while (true) {
switch (enc) {
case 'utf8':
case 'utf-8':
return 'utf8';
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return 'utf16le';
case 'latin1':
case 'binary':
return 'latin1';
case 'base64':
case 'ascii':
case 'hex':
return enc;
default:
if (retried) return; // undefined
enc = ('' + enc).toLowerCase();
retried = true;
}
}
};
// Do not cache `Buffer.isEncoding` when checking encoding names as some
// modules monkey-patch it to support additional encodings
function normalizeEncoding(enc) {
var nenc = _normalizeEncoding(enc);
if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
return nenc || enc;
}
// StringDecoder provides an interface for efficiently splitting a series of
// buffers into a series of JS strings without breaking apart multi-byte
// characters.
exports.StringDecoder = StringDecoder;
function StringDecoder(encoding) {
this.encoding = normalizeEncoding(encoding);
var nb;
switch (this.encoding) {
case 'utf16le':
this.text = utf16Text;
this.end = utf16End;
nb = 4;
break;
case 'utf8':
this.fillLast = utf8FillLast;
nb = 4;
break;
case 'base64':
this.text = base64Text;
this.end = base64End;
nb = 3;
break;
default:
this.write = simpleWrite;
this.end = simpleEnd;
return;
}
this.lastNeed = 0;
this.lastTotal = 0;
this.lastChar = Buffer.allocUnsafe(nb);
}
StringDecoder.prototype.write = function (buf) {
if (buf.length === 0) return '';
var r;
var i;
if (this.lastNeed) {
r = this.fillLast(buf);
if (r === undefined) return '';
i = this.lastNeed;
this.lastNeed = 0;
} else {
i = 0;
}
if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
return r || '';
};
StringDecoder.prototype.end = utf8End;
// Returns only complete characters in a Buffer
StringDecoder.prototype.text = utf8Text;
// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
StringDecoder.prototype.fillLast = function (buf) {
if (this.lastNeed <= buf.length) {
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
}
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
this.lastNeed -= buf.length;
};
// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
// continuation byte. If an invalid byte is detected, -2 is returned.
function utf8CheckByte(byte) {
if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
return byte >> 6 === 0x02 ? -1 : -2;
}
// Checks at most 3 bytes at the end of a Buffer in order to detect an
// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
// needed to complete the UTF-8 character (if applicable) are returned.
function utf8CheckIncomplete(self, buf, i) {
var j = buf.length - 1;
if (j < i) return 0;
var nb = utf8CheckByte(buf[j]);
if (nb >= 0) {
if (nb > 0) self.lastNeed = nb - 1;
return nb;
}
if (--j < i || nb === -2) return 0;
nb = utf8CheckByte(buf[j]);
if (nb >= 0) {
if (nb > 0) self.lastNeed = nb - 2;
return nb;
}
if (--j < i || nb === -2) return 0;
nb = utf8CheckByte(buf[j]);
if (nb >= 0) {
if (nb > 0) {
if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
}
return nb;
}
return 0;
}
// Validates as many continuation bytes for a multi-byte UTF-8 character as
// needed or are available. If we see a non-continuation byte where we expect
// one, we "replace" the validated continuation bytes we've seen so far with
// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
// behavior. The continuation byte check is included three times in the case
// where all of the continuation bytes for a character exist in the same buffer.
// It is also done this way as a slight performance increase instead of using a
// loop.
function utf8CheckExtraBytes(self, buf, p) {
if ((buf[0] & 0xC0) !== 0x80) {
self.lastNeed = 0;
return '\ufffd';
}
if (self.lastNeed > 1 && buf.length > 1) {
if ((buf[1] & 0xC0) !== 0x80) {
self.lastNeed = 1;
return '\ufffd';
}
if (self.lastNeed > 2 && buf.length > 2) {
if ((buf[2] & 0xC0) !== 0x80) {
self.lastNeed = 2;
return '\ufffd';
}
}
}
}
// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
function utf8FillLast(buf) {
var p = this.lastTotal - this.lastNeed;
var r = utf8CheckExtraBytes(this, buf, p);
if (r !== undefined) return r;
if (this.lastNeed <= buf.length) {
buf.copy(this.lastChar, p, 0, this.lastNeed);
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
}
buf.copy(this.lastChar, p, 0, buf.length);
this.lastNeed -= buf.length;
}
// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
// partial character, the character's bytes are buffered until the required
// number of bytes are available.
function utf8Text(buf, i) {
var total = utf8CheckIncomplete(this, buf, i);
if (!this.lastNeed) return buf.toString('utf8', i);
this.lastTotal = total;
var end = buf.length - (total - this.lastNeed);
buf.copy(this.lastChar, 0, end);
return buf.toString('utf8', i, end);
}
// For UTF-8, a replacement character is added when ending on a partial
// character.
function utf8End(buf) {
var r = buf && buf.length ? this.write(buf) : '';
if (this.lastNeed) return r + '\ufffd';
return r;
}
// UTF-16LE typically needs two bytes per character, but even if we have an even
// number of bytes available, we need to check if we end on a leading/high
// surrogate. In that case, we need to wait for the next two bytes in order to
// decode the last character properly.
function utf16Text(buf, i) {
if ((buf.length - i) % 2 === 0) {
var r = buf.toString('utf16le', i);
if (r) {
var c = r.charCodeAt(r.length - 1);
if (c >= 0xD800 && c <= 0xDBFF) {
this.lastNeed = 2;
this.lastTotal = 4;
this.lastChar[0] = buf[buf.length - 2];
this.lastChar[1] = buf[buf.length - 1];
return r.slice(0, -1);
}
}
return r;
}
this.lastNeed = 1;
this.lastTotal = 2;
this.lastChar[0] = buf[buf.length - 1];
return buf.toString('utf16le', i, buf.length - 1);
}
// For UTF-16LE we do not explicitly append special replacement characters if we
// end on a partial character, we simply let v8 handle that.
function utf16End(buf) {
var r = buf && buf.length ? this.write(buf) : '';
if (this.lastNeed) {
var end = this.lastTotal - this.lastNeed;
return r + this.lastChar.toString('utf16le', 0, end);
}
return r;
}
function base64Text(buf, i) {
var n = (buf.length - i) % 3;
if (n === 0) return buf.toString('base64', i);
this.lastNeed = 3 - n;
this.lastTotal = 3;
if (n === 1) {
this.lastChar[0] = buf[buf.length - 1];
} else {
this.lastChar[0] = buf[buf.length - 2];
this.lastChar[1] = buf[buf.length - 1];
}
return buf.toString('base64', i, buf.length - n);
}
function base64End(buf) {
var r = buf && buf.length ? this.write(buf) : '';
if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
return r;
}
// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
function simpleWrite(buf) {
return buf.toString(this.encoding);
}
function simpleEnd(buf) {
return buf && buf.length ? this.write(buf) : '';
}
},{"safe-buffer":102}],108:[function(require,module,exports){
(function (process,setImmediate){(function (){
var defined = require('defined');
var createDefaultStream = require('./lib/default_stream');
var Test = require('./lib/test');
var createResult = require('./lib/results');
var through = require('through');
var canEmitExit = typeof process !== 'undefined' && process
&& typeof process.on === 'function' && process.browser !== true
;
var canExit = typeof process !== 'undefined' && process
&& typeof process.exit === 'function'
;
var nextTick = typeof setImmediate !== 'undefined'
? setImmediate
: process.nextTick
;
exports = module.exports = (function () {
var harness;
var lazyLoad = function () {
return getHarness().apply(this, arguments);
};
lazyLoad.only = function () {
return getHarness().only.apply(this, arguments);
};
lazyLoad.createStream = function (opts) {
if (!opts) opts = {};
if (!harness) {
var output = through();
getHarness({ stream: output, objectMode: opts.objectMode });
return output;
}
return harness.createStream(opts);
};
lazyLoad.onFinish = function () {
return getHarness().onFinish.apply(this, arguments);
};
lazyLoad.getHarness = getHarness
return lazyLoad
function getHarness (opts) {
if (!opts) opts = {};
opts.autoclose = !canEmitExit;
if (!harness) harness = createExitHarness(opts);
return harness;
}
})();
function createExitHarness (conf) {
if (!conf) conf = {};
var harness = createHarness({
autoclose: defined(conf.autoclose, false)
});
var stream = harness.createStream({ objectMode: conf.objectMode });
var es = stream.pipe(conf.stream || createDefaultStream());
if (canEmitExit) {
es.on('error', function (err) { harness._exitCode = 1 });
}
var ended = false;
stream.on('end', function () { ended = true });
if (conf.exit === false) return harness;
if (!canEmitExit || !canExit) return harness;
var inErrorState = false;
process.on('exit', function (code) {
// let the process exit cleanly.
if (code !== 0) {
return
}
if (!ended) {
var only = harness._results._only;
for (var i = 0; i < harness._tests.length; i++) {
var t = harness._tests[i];
if (only && t.name !== only) continue;
t._exit();
}
}
harness.close();
process.exit(code || harness._exitCode);
});
return harness;
}
exports.createHarness = createHarness;
exports.Test = Test;
exports.test = exports; // tap compat
exports.test.skip = Test.skip;
var exitInterval;
function createHarness (conf_) {
if (!conf_) conf_ = {};
var results = createResult();
if (conf_.autoclose !== false) {
results.once('done', function () { results.close() });
}
var test = function (name, conf, cb) {
var t = new Test(name, conf, cb);
test._tests.push(t);
(function inspectCode (st) {
st.on('test', function sub (st_) {
inspectCode(st_);
});
st.on('result', function (r) {
if (!r.ok && typeof r !== 'string') test._exitCode = 1
});
})(t);
results.push(t);
return t;
};
test._results = results;
test._tests = [];
test.createStream = function (opts) {
return results.createStream(opts);
};
test.onFinish = function (cb) {
results.on('done', cb);
};
var only = false;
test.only = function (name) {
if (only) throw new Error('there can only be one only test');
results.only(name);
only = true;
return test.apply(null, arguments);
};
test._exitCode = 0;
test.close = function () { results.close() };
return test;
}
}).call(this)}).call(this,require('_process'),require("timers").setImmediate)
},{"./lib/default_stream":109,"./lib/results":111,"./lib/test":112,"_process":100,"defined":32,"through":114,"timers":115}],109:[function(require,module,exports){
(function (process){(function (){
var through = require('through');
var fs = require('fs');
module.exports = function () {
var line = '';
var stream = through(write, flush);
return stream;
function write (buf) {
for (var i = 0; i < buf.length; i++) {
var c = typeof buf === 'string'
? buf.charAt(i)
: String.fromCharCode(buf[i])
;
if (c === '\n') flush();
else line += c;
}
}
function flush () {
if (fs.writeSync && /^win/.test(process.platform)) {
try { fs.writeSync(1, line + '\n'); }
catch (e) { stream.emit('error', e) }
}
else {
try { console.log(line) }
catch (e) { stream.emit('error', e) }
}
line = '';
}
};
}).call(this)}).call(this,require('_process'))
},{"_process":100,"fs":7,"through":114}],110:[function(require,module,exports){
(function (process,setImmediate){(function (){
module.exports = typeof setImmediate !== 'undefined'
? setImmediate
: process.nextTick
;
}).call(this)}).call(this,require('_process'),require("timers").setImmediate)
},{"_process":100,"timers":115}],111:[function(require,module,exports){
(function (process,setImmediate){(function (){
var EventEmitter = require('events').EventEmitter;
var inherits = require('inherits');
var through = require('through');
var resumer = require('resumer');
var inspect = require('object-inspect');
var bind = require('function-bind');
var has = require('has');
var regexpTest = bind.call(Function.call, RegExp.prototype.test);
var yamlIndicators = /\:|\-|\?/;
var nextTick = typeof setImmediate !== 'undefined'
? setImmediate
: process.nextTick
;
module.exports = Results;
inherits(Results, EventEmitter);
function Results () {
if (!(this instanceof Results)) return new Results;
this.count = 0;
this.fail = 0;
this.pass = 0;
this._stream = through();
this.tests = [];
}
Results.prototype.createStream = function (opts) {
if (!opts) opts = {};
var self = this;
var output, testId = 0;
if (opts.objectMode) {
output = through();
self.on('_push', function ontest (t, extra) {
if (!extra) extra = {};
var id = testId++;
t.once('prerun', function () {
var row = {
type: 'test',
name: t.name,
id: id
};
if (has(extra, 'parent')) {
row.parent = extra.parent;
}
output.queue(row);
});
t.on('test', function (st) {
ontest(st, { parent: id });
});
t.on('result', function (res) {
res.test = id;
res.type = 'assert';
output.queue(res);
});
t.on('end', function () {
output.queue({ type: 'end', test: id });
});
});
self.on('done', function () { output.queue(null) });
}
else {
output = resumer();
output.queue('TAP version 13\n');
self._stream.pipe(output);
}
nextTick(function next() {
var t;
while (t = getNextTest(self)) {
t.run();
if (!t.ended) return t.once('end', function(){ nextTick(next); });
}
self.emit('done');
});
return output;
};
Results.prototype.push = function (t) {
var self = this;
self.tests.push(t);
self._watch(t);
self.emit('_push', t);
};
Results.prototype.only = function (name) {
this._only = name;
};
Results.prototype._watch = function (t) {
var self = this;
var write = function (s) { self._stream.queue(s) };
t.once('prerun', function () {
write('# ' + t.name + '\n');
});
t.on('result', function (res) {
if (typeof res === 'string') {
write('# ' + res + '\n');
return;
}
write(encodeResult(res, self.count + 1));
self.count ++;
if (res.ok) self.pass ++
else self.fail ++
});
t.on('test', function (st) { self._watch(st) });
};
Results.prototype.close = function () {
var self = this;
if (self.closed) self._stream.emit('error', new Error('ALREADY CLOSED'));
self.closed = true;
var write = function (s) { self._stream.queue(s) };
write('\n1..' + self.count + '\n');
write('# tests ' + self.count + '\n');
write('# pass ' + self.pass + '\n');
if (self.fail) write('# fail ' + self.fail + '\n')
else write('\n# ok\n')
self._stream.queue(null);
};
function encodeResult (res, count) {
var output = '';
output += (res.ok ? 'ok ' : 'not ok ') + count;
output += res.name ? ' ' + res.name.toString().replace(/\s+/g, ' ') : '';
if (res.skip) output += ' # SKIP';
else if (res.todo) output += ' # TODO';
output += '\n';
if (res.ok) return output;
var outer = ' ';
var inner = outer + ' ';
output += outer + '---\n';
output += inner + 'operator: ' + res.operator + '\n';
if (has(res, 'expected') || has(res, 'actual')) {
var ex = inspect(res.expected);
var ac = inspect(res.actual);
if (Math.max(ex.length, ac.length) > 65 || invalidYaml(ex) || invalidYaml(ac)) {
output += inner + 'expected: |-\n' + inner + ' ' + ex + '\n';
output += inner + 'actual: |-\n' + inner + ' ' + ac + '\n';
}
else {
output += inner + 'expected: ' + ex + '\n';
output += inner + 'actual: ' + ac + '\n';
}
}
if (res.at) {
output += inner + 'at: ' + res.at + '\n';
}
if (res.operator === 'error' && res.actual && res.actual.stack) {
var lines = String(res.actual.stack).split('\n');
output += inner + 'stack: |-\n';
for (var i = 0; i < lines.length; i++) {
output += inner + ' ' + lines[i] + '\n';
}
}
output += outer + '...\n';
return output;
}
function getNextTest (results) {
if (!results._only) {
return results.tests.shift();
}
do {
var t = results.tests.shift();
if (!t) continue;
if (results._only === t.name) {
return t;
}
} while (results.tests.length !== 0)
}
function invalidYaml (str) {
return regexpTest(yamlIndicators, str);
}
}).call(this)}).call(this,require('_process'),require("timers").setImmediate)
},{"_process":100,"events":8,"function-bind":89,"has":93,"inherits":95,"object-inspect":113,"resumer":101,"through":114,"timers":115}],112:[function(require,module,exports){
(function (__dirname){(function (){
var deepEqual = require('deep-equal');
var defined = require('defined');
var path = require('path');
var inherits = require('inherits');
var EventEmitter = require('events').EventEmitter;
var has = require('has');
var trim = require('string.prototype.trim');
var nextTick = require('./next_tick');
module.exports = Test;
inherits(Test, EventEmitter);
var getTestArgs = function (name_, opts_, cb_) {
var name = '(anonymous)';
var opts = {};
var cb;
for (var i = 0; i < arguments.length; i++) {
var arg = arguments[i];
var t = typeof arg;
if (t === 'string') {
name = arg;
}
else if (t === 'object') {
opts = arg || opts;
}
else if (t === 'function') {
cb = arg;
}
}
return { name: name, opts: opts, cb: cb };
};
function Test (name_, opts_, cb_) {
if (! (this instanceof Test)) {
return new Test(name_, opts_, cb_);
}
var args = getTestArgs(name_, opts_, cb_);
this.readable = true;
this.name = args.name || '(anonymous)';
this.assertCount = 0;
this.pendingCount = 0;
this._skip = args.opts.skip || false;
this._timeout = args.opts.timeout;
this._plan = undefined;
this._cb = args.cb;
this._progeny = [];
this._ok = true;
for (var prop in this) {
this[prop] = (function bind(self, val) {
if (typeof val === 'function') {
return function bound() {
return val.apply(self, arguments);
};
}
else return val;
})(this, this[prop]);
}
}
Test.prototype.run = function () {
if (this._skip) {
this.comment('SKIP ' + this.name);
}
if (!this._cb || this._skip) {
return this._end();
}
if (this._timeout != null) {
this.timeoutAfter(this._timeout);
}
this.emit('prerun');
this._cb(this);
this.emit('run');
};
Test.prototype.test = function (name, opts, cb) {
var self = this;
var t = new Test(name, opts, cb);
this._progeny.push(t);
this.pendingCount++;
this.emit('test', t);
t.on('prerun', function () {
self.assertCount++;
})
if (!self._pendingAsserts()) {
nextTick(function () {
self._end();
});
}
nextTick(function() {
if (!self._plan && self.pendingCount == self._progeny.length) {
self._end();
}
});
};
Test.prototype.comment = function (msg) {
var that = this;
trim(msg).split('\n').forEach(function (aMsg) {
that.emit('result', trim(aMsg).replace(/^#\s*/, ''));
});
};
Test.prototype.plan = function (n) {
this._plan = n;
this.emit('plan', n);
};
Test.prototype.timeoutAfter = function(ms) {
if (!ms) throw new Error('timeoutAfter requires a timespan');
var self = this;
var timeout = setTimeout(function() {
self.fail('test timed out after ' + ms + 'ms');
self.end();
}, ms);
this.once('end', function() {
clearTimeout(timeout);
});
}
Test.prototype.end = function (err) {
var self = this;
if (arguments.length >= 1 && !!err) {
this.ifError(err);
}
if (this.calledEnd) {
this.fail('.end() called twice');
}
this.calledEnd = true;
this._end();
};
Test.prototype._end = function (err) {
var self = this;
if (this._progeny.length) {
var t = this._progeny.shift();
t.on('end', function () { self._end() });
t.run();
return;
}
if (!this.ended) this.emit('end');
var pendingAsserts = this._pendingAsserts();
if (!this._planError && this._plan !== undefined && pendingAsserts) {
this._planError = true;
this.fail('plan != count', {
expected : this._plan,
actual : this.assertCount
});
}
this.ended = true;
};
Test.prototype._exit = function () {
if (this._plan !== undefined &&
!this._planError && this.assertCount !== this._plan) {
this._planError = true;
this.fail('plan != count', {
expected : this._plan,
actual : this.assertCount,
exiting : true
});
}
else if (!this.ended) {
this.fail('test exited without ending', {
exiting: true
});
}
};
Test.prototype._pendingAsserts = function () {
if (this._plan === undefined) {
return 1;
}
else {
return this._plan - (this._progeny.length + this.assertCount);
}
};
Test.prototype._assert = function assert (ok, opts) {
var self = this;
var extra = opts.extra || {};
var res = {
id : self.assertCount ++,
ok : Boolean(ok),
skip : defined(extra.skip, opts.skip),
name : defined(extra.message, opts.message, '(unnamed assert)'),
operator : defined(extra.operator, opts.operator)
};
if (has(opts, 'actual') || has(extra, 'actual')) {
res.actual = defined(extra.actual, opts.actual);
}
if (has(opts, 'expected') || has(extra, 'expected')) {
res.expected = defined(extra.expected, opts.expected);
}
this._ok = Boolean(this._ok && ok);
if (!ok) {
res.error = defined(extra.error, opts.error, new Error(res.name));
}
if (!ok) {
var e = new Error('exception');
var err = (e.stack || '').split('\n');
var dir = path.dirname(__dirname) + '/';
for (var i = 0; i < err.length; i++) {
var m = /^[^\s]*\s*\bat\s+(.+)/.exec(err[i]);
if (!m) {
continue;
}
var s = m[1].split(/\s+/);
var filem = /(\/[^:\s]+:(\d+)(?::(\d+))?)/.exec(s[1]);
if (!filem) {
filem = /(\/[^:\s]+:(\d+)(?::(\d+))?)/.exec(s[2]);
if (!filem) {
filem = /(\/[^:\s]+:(\d+)(?::(\d+))?)/.exec(s[3]);
if (!filem) {
continue;
}
}
}
if (filem[1].slice(0, dir.length) === dir) {
continue;
}
res.functionName = s[0];
res.file = filem[1];
res.line = Number(filem[2]);
if (filem[3]) res.column = filem[3];
res.at = m[1];
break;
}
}
self.emit('result', res);
var pendingAsserts = self._pendingAsserts();
if (!pendingAsserts) {
if (extra.exiting) {
self._end();
} else {
nextTick(function () {
self._end();
});
}
}
if (!self._planError && pendingAsserts < 0) {
self._planError = true;
self.fail('plan != count', {
expected : self._plan,
actual : self._plan - pendingAsserts
});
}
};
Test.prototype.fail = function (msg, extra) {
this._assert(false, {
message : msg,
operator : 'fail',
extra : extra
});
};
Test.prototype.pass = function (msg, extra) {
this._assert(true, {
message : msg,
operator : 'pass',
extra : extra
});
};
Test.prototype.skip = function (msg, extra) {
this._assert(true, {
message : msg,
operator : 'skip',
skip : true,
extra : extra
});
};
Test.prototype.ok
= Test.prototype['true']
= Test.prototype.assert
= function (value, msg, extra) {
this._assert(value, {
message : msg,
operator : 'ok',
expected : true,
actual : value,
extra : extra
});
};
Test.prototype.notOk
= Test.prototype['false']
= Test.prototype.notok
= function (value, msg, extra) {
this._assert(!value, {
message : msg,
operator : 'notOk',
expected : false,
actual : value,
extra : extra
});
};
Test.prototype.error
= Test.prototype.ifError
= Test.prototype.ifErr
= Test.prototype.iferror
= function (err, msg, extra) {
this._assert(!err, {
message : defined(msg, String(err)),
operator : 'error',
actual : err,
extra : extra
});
};
Test.prototype.equal
= Test.prototype.equals
= Test.prototype.isEqual
= Test.prototype.is
= Test.prototype.strictEqual
= Test.prototype.strictEquals
= function (a, b, msg, extra) {
this._assert(a === b, {
message : defined(msg, 'should be equal'),
operator : 'equal',
actual : a,
expected : b,
extra : extra
});
};
Test.prototype.notEqual
= Test.prototype.notEquals
= Test.prototype.notStrictEqual
= Test.prototype.notStrictEquals
= Test.prototype.isNotEqual
= Test.prototype.isNot
= Test.prototype.not
= Test.prototype.doesNotEqual
= Test.prototype.isInequal
= function (a, b, msg, extra) {
this._assert(a !== b, {
message : defined(msg, 'should not be equal'),
operator : 'notEqual',
actual : a,
notExpected : b,
extra : extra
});
};
Test.prototype.deepEqual
= Test.prototype.deepEquals
= Test.prototype.isEquivalent
= Test.prototype.same
= function (a, b, msg, extra) {
this._assert(deepEqual(a, b, { strict: true }), {
message : defined(msg, 'should be equivalent'),
operator : 'deepEqual',
actual : a,
expected : b,
extra : extra
});
};
Test.prototype.deepLooseEqual
= Test.prototype.looseEqual
= Test.prototype.looseEquals
= function (a, b, msg, extra) {
this._assert(deepEqual(a, b), {
message : defined(msg, 'should be equivalent'),
operator : 'deepLooseEqual',
actual : a,
expected : b,
extra : extra
});
};
Test.prototype.notDeepEqual
= Test.prototype.notEquivalent
= Test.prototype.notDeeply
= Test.prototype.notSame
= Test.prototype.isNotDeepEqual
= Test.prototype.isNotDeeply
= Test.prototype.isNotEquivalent
= Test.prototype.isInequivalent
= function (a, b, msg, extra) {
this._assert(!deepEqual(a, b, { strict: true }), {
message : defined(msg, 'should not be equivalent'),
operator : 'notDeepEqual',
actual : a,
notExpected : b,
extra : extra
});
};
Test.prototype.notDeepLooseEqual
= Test.prototype.notLooseEqual
= Test.prototype.notLooseEquals
= function (a, b, msg, extra) {
this._assert(!deepEqual(a, b), {
message : defined(msg, 'should be equivalent'),
operator : 'notDeepLooseEqual',
actual : a,
expected : b,
extra : extra
});
};
Test.prototype['throws'] = function (fn, expected, msg, extra) {
if (typeof expected === 'string') {
msg = expected;
expected = undefined;
}
var caught = undefined;
try {
fn();
} catch (err) {
caught = { error : err };
var message = err.message;
delete err.message;
err.message = message;
}
var passed = caught;
if (expected instanceof RegExp) {
passed = expected.test(caught && caught.error);
expected = String(expected);
}
if (typeof expected === 'function' && caught) {
passed = caught.error instanceof expected;
caught.error = caught.error.constructor;
}
this._assert(typeof fn === 'function' && passed, {
message : defined(msg, 'should throw'),
operator : 'throws',
actual : caught && caught.error,
expected : expected,
error: !passed && caught && caught.error,
extra : extra
});
};
Test.prototype.doesNotThrow = function (fn, expected, msg, extra) {
if (typeof expected === 'string') {
msg = expected;
expected = undefined;
}
var caught = undefined;
try {
fn();
}
catch (err) {
caught = { error : err };
}
this._assert(!caught, {
message : defined(msg, 'should not throw'),
operator : 'throws',
actual : caught && caught.error,
expected : expected,
error : caught && caught.error,
extra : extra
});
};
Test.skip = function (name_, _opts, _cb) {
var args = getTestArgs.apply(null, arguments);
args.opts.skip = true;
return Test(args.name, args.opts, args.cb);
};
// vim: set softtabstop=4 shiftwidth=4:
}).call(this)}).call(this,"/node_modules/tape/lib")
},{"./next_tick":110,"deep-equal":28,"defined":32,"events":8,"has":93,"inherits":95,"path":9,"string.prototype.trim":104}],113:[function(require,module,exports){
var hasMap = typeof Map === 'function' && Map.prototype;
var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;
var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;
var mapForEach = hasMap && Map.prototype.forEach;
var hasSet = typeof Set === 'function' && Set.prototype;
var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;
var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;
var setForEach = hasSet && Set.prototype.forEach;
module.exports = function inspect_ (obj, opts, depth, seen) {
if (!opts) opts = {};
var maxDepth = opts.depth === undefined ? 5 : opts.depth;
if (depth === undefined) depth = 0;
if (depth >= maxDepth && maxDepth > 0
&& obj && typeof obj === 'object') {
return '[Object]';
}
if (seen === undefined) seen = [];
else if (indexOf(seen, obj) >= 0) {
return '[Circular]';
}
function inspect (value, from) {
if (from) {
seen = seen.slice();
seen.push(from);
}
return inspect_(value, opts, depth + 1, seen);
}
if (typeof obj === 'string') {
return inspectString(obj);
}
else if (typeof obj === 'function') {
var name = nameOf(obj);
return '[Function' + (name ? ': ' + name : '') + ']';
}
else if (obj === null) {
return 'null';
}
else if (isSymbol(obj)) {
var symString = Symbol.prototype.toString.call(obj);
return typeof obj === 'object' ? 'Object(' + symString + ')' : symString;
}
else if (isElement(obj)) {
var s = '<' + String(obj.nodeName).toLowerCase();
var attrs = obj.attributes || [];
for (var i = 0; i < attrs.length; i++) {
s += ' ' + attrs[i].name + '="' + quote(attrs[i].value) + '"';
}
s += '>';
if (obj.childNodes && obj.childNodes.length) s += '...';
s += '</' + String(obj.nodeName).toLowerCase() + '>';
return s;
}
else if (isArray(obj)) {
if (obj.length === 0) return '[]';
var xs = Array(obj.length);
for (var i = 0; i < obj.length; i++) {
xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';
}
return '[ ' + xs.join(', ') + ' ]';
}
else if (isError(obj)) {
var parts = [];
for (var key in obj) {
if (!has(obj, key)) continue;
if (/[^\w$]/.test(key)) {
parts.push(inspect(key) + ': ' + inspect(obj[key]));
}
else {
parts.push(key + ': ' + inspect(obj[key]));
}
}
if (parts.length === 0) return '[' + obj + ']';
return '{ [' + obj + '] ' + parts.join(', ') + ' }';
}
else if (typeof obj === 'object' && typeof obj.inspect === 'function') {
return obj.inspect();
}
else if (isMap(obj)) {
var parts = [];
mapForEach.call(obj, function (value, key) {
parts.push(inspect(key, obj) + ' => ' + inspect(value, obj));
});
return 'Map (' + mapSize.call(obj) + ') {' + parts.join(', ') + '}';
}
else if (isSet(obj)) {
var parts = [];
setForEach.call(obj, function (value ) {
parts.push(inspect(value, obj));
});
return 'Set (' + setSize.call(obj) + ') {' + parts.join(', ') + '}';
}
else if (typeof obj === 'object' && !isDate(obj) && !isRegExp(obj)) {
var xs = [], keys = [];
for (var key in obj) {
if (has(obj, key)) keys.push(key);
}
keys.sort();
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (/[^\w$]/.test(key)) {
xs.push(inspect(key) + ': ' + inspect(obj[key], obj));
}
else xs.push(key + ': ' + inspect(obj[key], obj));
}
if (xs.length === 0) return '{}';
return '{ ' + xs.join(', ') + ' }';
}
else return String(obj);
};
function quote (s) {
return String(s).replace(/"/g, '"');
}
function isArray (obj) { return toStr(obj) === '[object Array]' }
function isDate (obj) { return toStr(obj) === '[object Date]' }
function isRegExp (obj) { return toStr(obj) === '[object RegExp]' }
function isError (obj) { return toStr(obj) === '[object Error]' }
function isSymbol (obj) { return toStr(obj) === '[object Symbol]' }
var hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };
function has (obj, key) {
return hasOwn.call(obj, key);
}
function toStr (obj) {
return Object.prototype.toString.call(obj);
}
function nameOf (f) {
if (f.name) return f.name;
var m = f.toString().match(/^function\s*([\w$]+)/);
if (m) return m[1];
}
function indexOf (xs, x) {
if (xs.indexOf) return xs.indexOf(x);
for (var i = 0, l = xs.length; i < l; i++) {
if (xs[i] === x) return i;
}
return -1;
}
function isMap (x) {
if (!mapSize) {
return false;
}
try {
mapSize.call(x);
return true;
} catch (e) {}
return false;
}
function isSet (x) {
if (!setSize) {
return false;
}
try {
setSize.call(x);
return true;
} catch (e) {}
return false;
}
function isElement (x) {
if (!x || typeof x !== 'object') return false;
if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {
return true;
}
return typeof x.nodeName === 'string'
&& typeof x.getAttribute === 'function'
;
}
function inspectString (str) {
var s = str.replace(/(['\\])/g, '\\$1').replace(/[\x00-\x1f]/g, lowbyte);
return "'" + s + "'";
function lowbyte (c) {
var n = c.charCodeAt(0);
var x = { 8: 'b', 9: 't', 10: 'n', 12: 'f', 13: 'r' }[n];
if (x) return '\\' + x;
return '\\x' + (n < 0x10 ? '0' : '') + n.toString(16);
}
}
},{}],114:[function(require,module,exports){
(function (process){(function (){
var Stream = require('stream')
// through
//
// a stream that does nothing but re-emit the input.
// useful for aggregating a series of changing but not ending streams into one stream)
exports = module.exports = through
through.through = through
//create a readable writable stream.
function through (write, end, opts) {
write = write || function (data) { this.queue(data) }
end = end || function () { this.queue(null) }
var ended = false, destroyed = false, buffer = [], _ended = false
var stream = new Stream()
stream.readable = stream.writable = true
stream.paused = false
// stream.autoPause = !(opts && opts.autoPause === false)
stream.autoDestroy = !(opts && opts.autoDestroy === false)
stream.write = function (data) {
write.call(this, data)
return !stream.paused
}
function drain() {
while(buffer.length && !stream.paused) {
var data = buffer.shift()
if(null === data)
return stream.emit('end')
else
stream.emit('data', data)
}
}
stream.queue = stream.push = function (data) {
// console.error(ended)
if(_ended) return stream
if(data === null) _ended = true
buffer.push(data)
drain()
return stream
}
//this will be registered as the first 'end' listener
//must call destroy next tick, to make sure we're after any
//stream piped from here.
//this is only a problem if end is not emitted synchronously.
//a nicer way to do this is to make sure this is the last listener for 'end'
stream.on('end', function () {
stream.readable = false
if(!stream.writable && stream.autoDestroy)
process.nextTick(function () {
stream.destroy()
})
})
function _end () {
stream.writable = false
end.call(stream)
if(!stream.readable && stream.autoDestroy)
stream.destroy()
}
stream.end = function (data) {
if(ended) return
ended = true
if(arguments.length) stream.write(data)
_end() // will emit or queue
return stream
}
stream.destroy = function () {
if(destroyed) return
destroyed = true
ended = true
buffer.length = 0
stream.writable = stream.readable = false
stream.emit('close')
return stream
}
stream.pause = function () {
if(stream.paused) return
stream.paused = true
return stream
}
stream.resume = function () {
if(stream.paused) {
stream.paused = false
stream.emit('resume')
}
drain()
//may have become paused again,
//as drain emits 'data'.
if(!stream.paused)
stream.emit('drain')
return stream
}
return stream
}
}).call(this)}).call(this,require('_process'))
},{"_process":100,"stream":10}],115:[function(require,module,exports){
(function (setImmediate,clearImmediate){(function (){
var nextTick = require('process/browser.js').nextTick;
var apply = Function.prototype.apply;
var slice = Array.prototype.slice;
var immediateIds = {};
var nextImmediateId = 0;
// DOM APIs, for completeness
exports.setTimeout = function() {
return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
};
exports.setInterval = function() {
return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
};
exports.clearTimeout =
exports.clearInterval = function(timeout) { timeout.close(); };
function Timeout(id, clearFn) {
this._id = id;
this._clearFn = clearFn;
}
Timeout.prototype.unref = Timeout.prototype.ref = function() {};
Timeout.prototype.close = function() {
this._clearFn.call(window, this._id);
};
// Does not start the time, just sets up the members needed.
exports.enroll = function(item, msecs) {
clearTimeout(item._idleTimeoutId);
item._idleTimeout = msecs;
};
exports.unenroll = function(item) {
clearTimeout(item._idleTimeoutId);
item._idleTimeout = -1;
};
exports._unrefActive = exports.active = function(item) {
clearTimeout(item._idleTimeoutId);
var msecs = item._idleTimeout;
if (msecs >= 0) {
item._idleTimeoutId = setTimeout(function onTimeout() {
if (item._onTimeout)
item._onTimeout();
}, msecs);
}
};
// That's not how node.js implements it but the exposed api is the same.
exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
var id = nextImmediateId++;
var args = arguments.length < 2 ? false : slice.call(arguments, 1);
immediateIds[id] = true;
nextTick(function onNextTick() {
if (immediateIds[id]) {
// fn.call() is faster so we optimize for the common use-case
// @see http://jsperf.com/call-apply-segu
if (args) {
fn.apply(null, args);
} else {
fn.call(null);
}
// Prevent ids from leaking
exports.clearImmediate(id);
}
});
return id;
};
exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
delete immediateIds[id];
};
}).call(this)}).call(this,require("timers").setImmediate,require("timers").clearImmediate)
},{"process/browser.js":100,"timers":115}],116:[function(require,module,exports){
(function (global){(function (){
/**
* Module exports.
*/
module.exports = deprecate;
/**
* Mark that a method should not be used.
* Returns a modified function which warns once by default.
*
* If `localStorage.noDeprecation = true` is set, then it is a no-op.
*
* If `localStorage.throwDeprecation = true` is set, then deprecated functions
* will throw an Error when invoked.
*
* If `localStorage.traceDeprecation = true` is set, then deprecated functions
* will invoke `console.trace()` instead of `console.error()`.
*
* @param {Function} fn - the function to deprecate
* @param {String} msg - the string to print to the console when `fn` is invoked
* @returns {Function} a new "deprecated" version of `fn`
* @api public
*/
function deprecate (fn, msg) {
if (config('noDeprecation')) {
return fn;
}
var warned = false;
function deprecated() {
if (!warned) {
if (config('throwDeprecation')) {
throw new Error(msg);
} else if (config('traceDeprecation')) {
console.trace(msg);
} else {
console.warn(msg);
}
warned = true;
}
return fn.apply(this, arguments);
}
return deprecated;
}
/**
* Checks `localStorage` for boolean values for the given `name`.
*
* @param {String} name
* @returns {Boolean}
* @api private
*/
function config (name) {
// accessing global.localStorage can trigger a DOMException in sandboxed iframes
try {
if (!global.localStorage) return false;
} catch (_) {
return false;
}
var val = global.localStorage[name];
if (null == val) return false;
return String(val).toLowerCase() === 'true';
}
}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}]},{},[2]);
|
var NAVTREE =
[
[ "Introduction", "index.html", [
[ "Documentation", "modules.html", "modules" ]
] ]
];
var NAVTREEINDEX =
[
"classc_g_e_l_linear_spring.html"
];
var SYNCONMSG = 'click to disable panel synchronisation';
var SYNCOFFMSG = 'click to enable panel synchronisation';
|
import React from 'react';
import { Router } from 'react-router-dom';
import history from './services/history';
import GlobalStyle from './styles/global';
import Navbar from './components/navbar';
import Routes from './routes';
import Footer from './components/footer';
export default function App() {
return (
<Router history={history}>
<GlobalStyle />
<Navbar/>
<Routes/>
<Footer />
</Router>
);
};
|
/**
* Copyright IBM Corp. 2019, 2020
*
* This source code is licensed under the Apache-2.0 license found in the
* LICENSE file in the root directory of this source tree.
*
* Code generated by @carbon/icon-build-helpers. DO NOT EDIT.
*/
import { _ as _objectWithoutProperties, I as Icon, a as _extends } from '../../Icon-83b9d1f1.js';
import '@carbon/icon-helpers';
import 'prop-types';
import React from 'react';
var _ref2 =
/*#__PURE__*/
/*#__PURE__*/
React.createElement("path", {
d: "M21.49 13.1151l-9-5a1 1 0 00-1 0l-9 5A1.0078 1.0078 0 002 14v9.9951a1 1 0 00.52.87l9 5A1.0045 1.0045 0 0012 30a1.0559 1.0559 0 00.49-.1349l9-5A.9923.9923 0 0022 24V14A1.0079 1.0079 0 0021.49 13.1151zM11 27.2951l-7-3.89v-7.72l7 3.89zm1-9.45L5.06 14 12 10.1351l6.94 3.86zm8 5.56l-7 3.89v-7.72l7-3.89zM30 6L26 6 26 2 24 2 24 6 20 6 20 8 24 8 24 12 26 12 26 8 30 8 30 6z"
});
var WatsonHealth3DSoftware32 = /*#__PURE__*/React.forwardRef(function WatsonHealth3DSoftware32(_ref, ref) {
var children = _ref.children,
rest = _objectWithoutProperties(_ref, ["children"]);
return /*#__PURE__*/React.createElement(Icon, _extends({
width: 32,
height: 32,
viewBox: "0 0 32 32",
xmlns: "http://www.w3.org/2000/svg",
fill: "currentColor",
ref: ref
}, rest), _ref2, children);
});
export default WatsonHealth3DSoftware32;
|
var mongodb = require("./"),
ObjectID = mongodb.ObjectID,
CoreConnection = mongodb.CoreConnection,
CoreServer = mongodb.CoreServer;
var uri = "mongodb://localhost:27017/test";
// mongostat -u foo -p bar --authenticationDatabase driver-test --host rs-ds021331/ds021331-a0.mlab.com:21331,ds021331-a1.mlab.com:21331 --discover
// var options = {server: {socketOptions: {connectTimeoutMS: 5000, socketTimeoutMS: 15000}}}
// var interval = 100;
// var total = 1000;
// // console.dir(CoreConnection)
// CoreConnection.enableConnectionAccounting();
// CoreServer.enableServerAccounting();
// var openThenClose = function(count){
var MongoClient = mongodb.MongoClient;
MongoClient.connect(uri, {}, function(err, db) {
var date = new Date();
date.setTime(0);
date.setSeconds(1)
date.setMilliseconds(0);
var a = new ObjectID("000000010000000000000001");
var b = ObjectID.createFromTime(date.getTime());
var c = new ObjectID();
c.generationTime = date.getTime();
db.collection('t1').insertMany([
{_id: new ObjectID()},
{_id: a},
{_id: b},
{_id: c}
], function() {
db.close();
});
// db.collection('t').findOne({id:1}, function(err, d) {
// console.log(d._id.getTimestamp())
// var i = new ObjectID("000000010000000000000001");
//
// db.collection('t').insertOne({_id: i, id:2}, function(err, d) {
// console.log("=== timestamp :: " + i.getTimestamp().getTime())
// console.log("=== timestamp :: " + i.getTimestamp())
// db.close();
// });
// // var a = new ObjectId();
// // a.generationTime
// });
});
|
/**
* Module dependencies.
*/
var mongoose = require('mongoose');
var crypto = require('crypto');
var Schema = mongoose.Schema;
var oAuthTypes = [
'github',
'twitter',
'facebook',
'google',
'linkedin'
];
/**
* User Schema
*/
var UserSchema = new Schema({
name: { type: String, default: '' },
email: { type: String, default: '' },
username: { type: String, default: '' },
provider: { type: String, default: '' },
hashed_password: { type: String, default: '' },
salt: { type: String, default: '' },
authToken: { type: String, default: '' },
facebook: {},
twitter: {},
github: {},
google: {},
linkedin: {}
});
/**
* Virtuals
*/
UserSchema
.virtual('password')
.set(function(password) {
this._password = password;
this.salt = this.makeSalt();
this.hashed_password = this.encryptPassword(password);
})
.get(function() { return this._password });
/**
* Validations
*/
var validatePresenceOf = function (value) {
return value && value.length;
};
// the below 5 validations only apply if you are signing up traditionally
UserSchema.path('name').validate(function (name) {
if (this.skipValidation()) return true;
return name.length;
}, 'Name cannot be blank');
UserSchema.path('email').validate(function (email) {
if (this.skipValidation()) return true;
return email.length;
}, 'Email cannot be blank');
UserSchema.path('email').validate(function (email, fn) {
var User = mongoose.model('User');
if (this.skipValidation()) fn(true);
// Check only when it is a new user or when email field is modified
if (this.isNew || this.isModified('email')) {
User.find({ email: email }).exec(function (err, users) {
fn(!err && users.length === 0);
});
} else fn(true);
}, 'Email already exists');
UserSchema.path('username').validate(function (username) {
if (this.skipValidation()) return true;
return username.length;
}, 'Username cannot be blank');
UserSchema.path('hashed_password').validate(function (hashed_password) {
if (this.skipValidation()) return true;
return hashed_password.length;
}, 'Password cannot be blank');
/**
* Pre-save hook
*/
UserSchema.pre('save', function(next) {
if (!this.isNew) return next();
if (!validatePresenceOf(this.password) && !this.skipValidation()) {
next(new Error('Invalid password'));
} else {
next();
}
})
/**
* Methods
*/
UserSchema.methods = {
/**
* Authenticate - check if the passwords are the same
*
* @param {String} plainText
* @return {Boolean}
* @api public
*/
authenticate: function (plainText) {
return this.encryptPassword(plainText) === this.hashed_password;
},
/**
* Make salt
*
* @return {String}
* @api public
*/
makeSalt: function () {
return Math.round((new Date().valueOf() * Math.random())) + '';
},
/**
* Encrypt password
*
* @param {String} password
* @return {String}
* @api public
*/
encryptPassword: function (password) {
if (!password) return '';
try {
return crypto
.createHmac('sha1', this.salt)
.update(password)
.digest('hex');
} catch (err) {
return '';
}
},
/**
* Validation is not required if using OAuth
*/
skipValidation: function() {
return ~oAuthTypes.indexOf(this.provider);
}
};
/**
* Statics
*/
UserSchema.statics = {
/**
* Load
*
* @param {Object} options
* @param {Function} cb
* @api private
*/
load: function (options, cb) {
options.select = options.select || 'id name username';
this.findOne(options.criteria)
.select(options.select)
.exec(cb);
}
}
mongoose.model('User', UserSchema);
|
import {BaseComponent, html} from "../../scripts/components.js";
class HeaderComponent extends BaseComponent {
constructor(parent, events) {
super(events);
this.render(parent);
}
render(parent) {
this.el = parent.appendChild(html('header', null, [
html('input', {type: 'search', placeholder: 'Search...', $input: (e) => this.event(e, 'onSearch', e.target.value)}),
html('a', {href: '#', class: 'btn', text: 'Add Note', $click: (e) => this.event(e, 'onAdd')})
]));
}
}
export {HeaderComponent};
|
//>>built
define("dojox/html/format",["dojo/_base/kernel","./entities","dojo/_base/array","dojo/_base/window","dojo/_base/sniff"],function(h,x,C,D,y){var p=h.getObject("dojox.html.format",!0);p.prettyPrint=function(p,m,n,z,E){var g=[],k=0,u=[],l="\t",e="",A=[],v,F=/[=]([^"']+?)(\s|>)/g,G=/style=("[^"]*"|'[^']*'|\S*)/gi,H=/[\w-]+=("[^"]*"|'[^']*'|\S*)/gi;if(m&&0<m&&10>m){l="";for(v=0;v<m;v++)l+=" "}m=D.doc.createElement("div");m.innerHTML=p;var I=x.encode,J=x.decode,w=m.ownerDocument.createElement("div"),K=
function(a){a=a.cloneNode(!1);w.appendChild(a);a=w.innerHTML;w.innerHTML="";return a},q=function(){var a;for(a=0;a<k;a++)g.push(l)},r=function(){g.push("\n")},s=function(a){var b,d;a=a.split("\n");for(b=0;b<a.length;b++)a[b]=h.trim(a[b]);a=a.join(" ");a=h.trim(a);if(""!==a){var c=[];if(n&&0<n){var f="";for(b=0;b<k;b++)f+=l;b=f.length;f=n;for(n>b&&(f-=b);a;)if(a.length>n){for(b=f;0<b&&" "!==a.charAt(b);b--);if(!b)for(b=f;b<a.length&&" "!==a.charAt(b);b++);var e=a.substring(0,b),e=h.trim(e);a=h.trim(a.substring(b==
a.length?a.length:b+1,a.length));if(e){d="";for(b=0;b<k;b++)d+=l;e=d+e+"\n"}c.push(e)}else{d="";for(b=0;b<k;b++)d+=l;a=d+a+"\n";c.push(a);a=null}return c.join("")}d="";for(b=0;b<k;b++)d+=l;return d+a+"\n"}return""},L=function(a){if(a){var b=a;b&&(b=b.replace(/"/gi,'"'),b=b.replace(/>/gi,"\x3e"),b=b.replace(/</gi,"\x3c"),b=b.replace(/&/gi,"\x26"));var d,c;a=0;for(var f=b.split("\n"),e=[],b=0;b<f.length;b++){var g=f[b],t=-1<g.indexOf("\n");if(g=h.trim(g)){t=a;for(d=0;d<g.length;d++)c=
g.charAt(d),"{"===c?a++:"}"===c&&(a--,t=a);c="";for(d=0;d<k+t;d++)c+=l;e.push(c+g+"\n")}else t&&0===b&&e.push("\n")}a=e.join("")}return a},M=function(a){var b=a.nodeName.toLowerCase(),d=h.trim(K(a));a=d.substring(0,d.indexOf("\x3e")+1);a=a.replace(F,'\x3d"$1"$2');a=a.replace(G,function(a){var b=a.substring(0,6);a=a.substring(6,a.length);var c=a.charAt(0);a=h.trim(a.substring(1,a.length-1));a=a.split(";");var d=[];C.forEach(a,function(a){if(a=h.trim(a))a=a.substring(0,a.indexOf(":")).toLowerCase()+
a.substring(a.indexOf(":"),a.length),d.push(a)});d=d.sort();a=d.join("; ");var e=h.trim(a);return!e||";"===e?"":b+c+(a+";")+c});var c=[];a=a.replace(H,function(a){c.push(h.trim(a));return""});c=c.sort();a="\x3c"+b;c.length&&(a+=" "+c.join(" "));-1!=d.indexOf("\x3c/")?(u.push(b),a+="\x3e"):(a=E?a+" /\x3e":a+"\x3e",u.push(!1));a:switch(b){case "a":case "b":case "strong":case "s":case "strike":case "i":case "u":case "em":case "sup":case "sub":case "span":case "font":case "big":case "cite":case "q":case "small":b=
!0;break a;default:b=!1}A.push(b);e&&!b&&(g.push(s(e)),e="");b?e+=a:(q(),g.push(a),r(),k++)},B=function(a){var b=a.childNodes;if(b){var d;for(d=0;d<b.length;d++){var c=b[d];if(1===c.nodeType){var f=h.trim(c.tagName.toLowerCase());!(y("ie")&&c.parentNode!=a)&&!(f&&"/"===f.charAt(0))&&(M(c),"script"===f?g.push(L(c.innerHTML)):"pre"===f?(c=c.innerHTML,y("mozilla")&&(c=c.replace("\x3cbr\x3e","\n"),c=c.replace("\x3cpre\x3e",""),c=c.replace("\x3c/pre\x3e","")),"\n"!==c.charAt(c.length-1)&&(c+="\n"),g.push(c)):
B(c),c=A.pop(),e&&!c&&(g.push(s(e)),e=""),(f=u.pop())?(f="\x3c/"+f+"\x3e",c?e+=f:(k--,q(),g.push(f),r())):k--)}else 3===c.nodeType||4===c.nodeType?e+=I(c.nodeValue,z):8===c.nodeType&&(c=J(c.nodeValue,z),q(),g.push("\x3c!--"),r(),k++,g.push(s(c)),k--,q(),g.push("--\x3e"),r())}}};B(m);e&&(g.push(s(e)),e="");return g.join("")};return p});
//# sourceMappingURL=format.js.map
|
(self.webpackChunkCnblogs_Theme_SimpleMemory=self.webpackChunkCnblogs_Theme_SimpleMemory||[]).push([[2447],{8061:function(e,s,l){"use strict";l.r(s)}}]);
|
const crypto = require('crypto');
const Router = require('express').Router;
const bodyParser = require('body-parser');
const Validator = require('jsonschema').Validator;
const log = require('../../support/log');
const schemas = require('../../domain/schemas');
const Pipeline = require('../../domain/Pipeline');
const ErrorTracker = require('../../domain/ErrorTracker');
const { StdoutLogStorage, DefaultLogStorage } = require('../../domain/LogStorage');
const FunctionsRequest = require('../FunctionsRequest');
const Metric = require('../../domain/Metric');
const SchemaResponse = require('../SchemaResponse');
const router = new Router();
const { bodyParserLimit } = require('../../support/config');
function codeFileName(namespace, codeId) {
return `${namespace}/${codeId}.js`;
}
router.get('/', async (req, res) => {
const memoryStorage = req.app.get('memoryStorage');
const page = parseInt(req.query.page || '1', 10);
const perPage = parseInt(req.query.perPage || '10', 10);
const { namespace, id } = req.query;
const functionsRequest = new FunctionsRequest(req);
try {
let list = {};
if (namespace) {
list = await memoryStorage.search(namespace, id, page, perPage);
} else {
list = await memoryStorage.listNamespaces(page, perPage);
}
new SchemaResponse(functionsRequest, res, 'functions/list').json(list);
} catch (err) {
log.error(`Error listing namespaces and its functions: ${err}`);
res.status(500).json({ error: err.message });
}
});
router.all('/:namespace/:id*', (req, res, next) => {
req.log = new StdoutLogStorage(req.params.namespace, req.params.id).console;
next();
});
router.put('/:namespace/:id', bodyParser.json({ limit: bodyParserLimit }), async (req, res) => {
const validationResult = new Validator().validate(req.body, schemas['functions/item']);
const memoryStorage = req.app.get('memoryStorage');
if (!validationResult.valid) {
const error = 'Invalid instance';
const details = validationResult.errors.map(e => e.toString());
res.status(400).json({ error, details });
return;
}
const {
namespace,
id,
} = req.params;
const {
code,
env,
} = req.body;
const filename = codeFileName(namespace, id);
const sandbox = req.app.get('sandbox');
const invalid = sandbox.testSyntaxError(filename, code, {
console: new StdoutLogStorage(namespace, id).console,
});
if (invalid) {
req.log.error(`Failed to post code: ${invalid.error}`);
res.status(400).json(invalid);
return;
}
const hash = crypto.createHash('sha1').update(code).digest('hex');
const data = { id, code, hash };
if (env) {
data.env = env;
}
try {
await memoryStorage.putCode(namespace, id, data);
res.set({ ETag: data.hash });
const functionsRequest = new FunctionsRequest(req);
new SchemaResponse(functionsRequest, res, 'functions/item').json(data);
} catch (err) {
log.error(`[${namespace}:${id}] ${err}`);
res.status(500).json({ error: err.message });
}
});
router.put('/:namespace/:id/env/:env', bodyParser.json({ strict: false, limit: bodyParserLimit }), async (req, res) => {
const validationResult = new Validator().validate(req.body, schemas['functions/env']);
const memoryStorage = req.app.get('memoryStorage');
if (!validationResult.valid) {
const error = 'Invalid instance';
const details = validationResult.errors.map(e => e.toString());
res.status(400).json({ error, details });
return;
}
const {
namespace,
id,
env,
} = req.params;
try {
await memoryStorage
.putCodeEnviromentVariable(namespace, id, env, req.body);
res.status(204).end();
} catch (err) {
log.error(`[${namespace}:${id}] Failed to set enviroment variable ${env}, error: ${err}`);
res.status(err.statusCode || 500).json({ error: err.message });
}
});
router.delete('/:namespace/:id/env/:env', async (req, res) => {
const {
namespace,
id,
env,
} = req.params;
const memoryStorage = req.app.get('memoryStorage');
try {
await memoryStorage
.deleteCodeEnviromentVariable(namespace, id, env);
res.status(204).end();
} catch (err) {
log.error(`[${namespace}:${id}] Failed to unset enviroment variable ${env}, error: ${err}`);
res.status(err.statusCode || 500).json({ error: err.message });
}
});
router.get('/:namespace/:id', async (req, res) => {
const {
namespace,
id,
} = req.params;
const memoryStorage = req.app.get('memoryStorage');
try {
const code = await memoryStorage.getCode(namespace, id);
if (!code) {
const error = 'Code not found';
req.log.error(error);
res.status(404).json({ error });
return;
}
res.set({ ETag: code.hash });
const functionsRequest = new FunctionsRequest(req);
new SchemaResponse(functionsRequest, res, 'functions/item').json(code);
} catch (err) {
req.log.error(`${err}`);
req.log.error(`${err.stack}`);
res.status(500).json({ error: err.message });
}
});
router.delete('/:namespace/:id', async (req, res) => {
const namespace = req.params.namespace;
const id = req.params.id;
const memoryStorage = req.app.get('memoryStorage');
try {
await memoryStorage.deleteCode(namespace, id);
res.status(204).end();
} catch (err) {
req.log.error(`Failed to delete code id: ${err}`);
res.status(500).json({ error: err.message });
}
});
async function functionsRunHandler(req, res) {
const { namespace, id } = req.params;
const memoryStorage = req.app.get('memoryStorage');
const sandbox = req.app.get('sandbox');
const filename = codeFileName(namespace, id);
const metric = new Metric('function-run');
const logStorage = new DefaultLogStorage(namespace, id, req);
let code;
try {
code = await memoryStorage.getCodeByCache(namespace, id, {
preCache: (preCode) => {
preCode.script = sandbox.compileCode(filename, preCode.code);
return preCode;
},
});
if (!code) {
const error = new Error(`Code '${namespace}/${id}' is not found`);
error.statusCode = 404;
throw error;
}
} catch (err) {
res.status(err.statusCode || 500).json({ error: err.message });
return;
}
try {
const options = {
console: logStorage.console,
env: code.env,
};
const result = await sandbox.runScript(code.script, req, options);
res.set(result.headers);
res.status(result.status);
res.json(result.body);
const spent = metric.finish({
filename,
status: result.status,
});
logStorage.flush({
status: result.status,
requestTime: spent,
});
} catch (err) {
logStorage.console.error(`Failed to run function: ${err}`);
logStorage.console.error(err.stack);
const status = err.statusCode || 500;
res.status(status).json({ error: err.message });
const spent = metric.finish({
filename,
status,
error: err.message,
});
const logResult = logStorage.flush({
status,
requestTime: spent,
});
const { namespaceSettings } = code;
const { sentryDSN } = namespaceSettings || {};
const extra = Object.assign({ body: req.body }, logResult || {});
const errTracker = new ErrorTracker({
sentryDSN,
filename,
extra,
tags: { codeHash: code.hash },
code: code.code,
});
errTracker.notify(err);
}
}
const methodNotAllowed = (req, res) => res.status(405).send();
router.route('/:namespace/:id/run')
.get(bodyParser.json({ limit: bodyParserLimit }), functionsRunHandler)
.put(bodyParser.json({ limit: bodyParserLimit }), functionsRunHandler)
.post(bodyParser.json({ limit: bodyParserLimit }), functionsRunHandler)
.delete(bodyParser.json({ limit: bodyParserLimit }), methodNotAllowed);
router.put('/pipeline', bodyParser.json({ limit: bodyParserLimit }), async (req, res) => {
const memoryStorage = req.app.get('memoryStorage');
const sandbox = req.app.get('sandbox');
let { steps } = req.query;
if (!steps) {
res.status(400).json({ error: 'Pass step by querystring is required' });
return;
}
steps = steps.map((step) => {
const [namespace, id] = step.split('/', 2);
return { namespace, id };
});
try {
const codes = await memoryStorage.getCodesByCache(steps, {
preCache: (code) => {
const filename = codeFileName(code.namespace, code.id);
code.script = sandbox.compileCode(filename, code.code);
return code;
},
});
for (let i = 0; i < codes.length; i += 1) {
if (!codes[i]) {
const { namespace, id } = steps[i];
const e = new Error(`Code '${namespace}/${id}' is not found`);
e.statusCode = 404;
throw e;
}
}
const result = await new Pipeline(sandbox, req, codes).run();
res.set(result.headers);
res.status(result.status);
res.json(result.body);
} catch (err) {
const status = err.statusCode || 500;
res.status(status).json({ error: err.message });
}
});
module.exports = router;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.