10771 lines
No EOL
882 KiB
JavaScript
10771 lines
No EOL
882 KiB
JavaScript
module.exports =
|
|
/******/ (function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
/******/
|
|
/******/ // Check if module is in cache
|
|
/******/ if(installedModules[moduleId]) {
|
|
/******/ return installedModules[moduleId].exports;
|
|
/******/ }
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = installedModules[moduleId] = {
|
|
/******/ i: moduleId,
|
|
/******/ l: false,
|
|
/******/ exports: {}
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
/******/
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.l = true;
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/******/
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = modules;
|
|
/******/
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = installedModules;
|
|
/******/
|
|
/******/ // define getter function for harmony exports
|
|
/******/ __webpack_require__.d = function(exports, name, getter) {
|
|
/******/ if(!__webpack_require__.o(exports, name)) {
|
|
/******/ Object.defineProperty(exports, name, {
|
|
/******/ configurable: false,
|
|
/******/ enumerable: true,
|
|
/******/ get: getter
|
|
/******/ });
|
|
/******/ }
|
|
/******/ };
|
|
/******/
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
/******/ __webpack_require__.n = function(module) {
|
|
/******/ var getter = module && module.__esModule ?
|
|
/******/ function getDefault() { return module['default']; } :
|
|
/******/ function getModuleExports() { return module; };
|
|
/******/ __webpack_require__.d(getter, 'a', getter);
|
|
/******/ return getter;
|
|
/******/ };
|
|
/******/
|
|
/******/ // Object.prototype.hasOwnProperty.call
|
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
|
/******/
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "/";
|
|
/******/
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__(__webpack_require__.s = 45);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ([
|
|
/* 0 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("react");
|
|
|
|
/***/ }),
|
|
/* 1 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("react-redux");
|
|
|
|
/***/ }),
|
|
/* 2 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("winston");
|
|
|
|
/***/ }),
|
|
/* 3 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var speechConfig = {
|
|
analytics: {
|
|
googleId: 'UA-60403362-6' // google id for analytics tracking; leave `null` if not applicable
|
|
},
|
|
session: {
|
|
sessionKey: 'nans$#kfjanwe234rydns' // enter a secret key to be used for session encryption
|
|
},
|
|
files: {
|
|
uploadDirectory: '/home/lbry/Uploads' // enter file path to where uploads/publishes should be stored
|
|
},
|
|
site: {
|
|
title: 'dev1.Spee.ch',
|
|
name: 'dev1.Spee.ch',
|
|
host: 'https://dev1.spee.ch',
|
|
description: 'Open-source, decentralized image and video sharing.'
|
|
},
|
|
publish: {
|
|
primaryClaimAddress: 'bDZ2wPwtULUGxT7GXuNLpQhXmdPRUTUkcL',
|
|
additionalClaimAddresses: ['banpwixPosfVDWnGvXqU2af36Qpsd7buGd'],
|
|
thumbnailChannel: '@dev1thumbs', // create a channel to use for thumbnail images
|
|
thumbnailChannelId: 'aeb625ff6f66c3eeeb42885070f4e53876033626' // the channel_id (claim id) for the channel above
|
|
},
|
|
claim: {
|
|
defaultTitle: 'dev1 Spee.ch',
|
|
defaultThumbnail: 'https://spee.ch/assets/img/video_thumb_default.png',
|
|
defaultDescription: 'Open-source, decentralized image and video sharing.'
|
|
}
|
|
};
|
|
|
|
module.exports = speechConfig;
|
|
|
|
/***/ }),
|
|
/* 4 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("react-router-dom");
|
|
|
|
/***/ }),
|
|
/* 5 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.selectFile = selectFile;
|
|
exports.clearFile = clearFile;
|
|
exports.updateMetadata = updateMetadata;
|
|
exports.updateClaim = updateClaim;
|
|
exports.setPublishInChannel = setPublishInChannel;
|
|
exports.updatePublishStatus = updatePublishStatus;
|
|
exports.updateError = updateError;
|
|
exports.updateSelectedChannel = updateSelectedChannel;
|
|
exports.toggleMetadataInputs = toggleMetadataInputs;
|
|
exports.onNewThumbnail = onNewThumbnail;
|
|
exports.startPublish = startPublish;
|
|
|
|
var _publish_action_types = __webpack_require__(33);
|
|
|
|
var actions = _interopRequireWildcard(_publish_action_types);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
// export action creators
|
|
function selectFile(file) {
|
|
return {
|
|
type: actions.FILE_SELECTED,
|
|
data: file
|
|
};
|
|
};
|
|
|
|
function clearFile() {
|
|
return {
|
|
type: actions.FILE_CLEAR
|
|
};
|
|
};
|
|
|
|
function updateMetadata(name, value) {
|
|
return {
|
|
type: actions.METADATA_UPDATE,
|
|
data: {
|
|
name: name,
|
|
value: value
|
|
}
|
|
};
|
|
};
|
|
|
|
function updateClaim(value) {
|
|
return {
|
|
type: actions.CLAIM_UPDATE,
|
|
data: value
|
|
};
|
|
};
|
|
|
|
function setPublishInChannel(channel) {
|
|
return {
|
|
type: actions.SET_PUBLISH_IN_CHANNEL,
|
|
channel: channel
|
|
};
|
|
};
|
|
|
|
function updatePublishStatus(status, message) {
|
|
return {
|
|
type: actions.PUBLISH_STATUS_UPDATE,
|
|
data: {
|
|
status: status,
|
|
message: message
|
|
}
|
|
};
|
|
};
|
|
|
|
function updateError(name, value) {
|
|
return {
|
|
type: actions.ERROR_UPDATE,
|
|
data: {
|
|
name: name,
|
|
value: value
|
|
}
|
|
};
|
|
};
|
|
|
|
function updateSelectedChannel(channelName) {
|
|
return {
|
|
type: actions.SELECTED_CHANNEL_UPDATE,
|
|
data: channelName
|
|
};
|
|
};
|
|
|
|
function toggleMetadataInputs(showMetadataInputs) {
|
|
return {
|
|
type: actions.TOGGLE_METADATA_INPUTS,
|
|
data: showMetadataInputs
|
|
};
|
|
};
|
|
|
|
function onNewThumbnail(file) {
|
|
return {
|
|
type: actions.THUMBNAIL_NEW,
|
|
data: file
|
|
};
|
|
};
|
|
|
|
function startPublish(history) {
|
|
return {
|
|
type: actions.PUBLISH_START,
|
|
data: { history: history }
|
|
};
|
|
}
|
|
|
|
/***/ }),
|
|
/* 6 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _channel = __webpack_require__(19);
|
|
|
|
var _view = __webpack_require__(92);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
var _publish = __webpack_require__(5);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var channel = _ref.channel;
|
|
|
|
return {
|
|
channelName: channel.loggedInChannel.name,
|
|
channelShortId: channel.loggedInChannel.shortId,
|
|
channelLongId: channel.loggedInChannel.longId
|
|
};
|
|
};
|
|
|
|
var mapDispatchToProps = function mapDispatchToProps(dispatch) {
|
|
return {
|
|
onChannelLogin: function onChannelLogin(name, shortId, longId) {
|
|
dispatch((0, _channel.updateLoggedInChannel)(name, shortId, longId));
|
|
dispatch((0, _publish.updateSelectedChannel)(name));
|
|
},
|
|
onChannelLogout: function onChannelLogout() {
|
|
dispatch((0, _channel.updateLoggedInChannel)(null, null, null));
|
|
}
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 7 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.onHandleShowPageUri = onHandleShowPageUri;
|
|
exports.onRequestError = onRequestError;
|
|
exports.onNewChannelRequest = onNewChannelRequest;
|
|
exports.onNewAssetRequest = onNewAssetRequest;
|
|
exports.onRequestUpdate = onRequestUpdate;
|
|
exports.addRequestToRequestList = addRequestToRequestList;
|
|
exports.addAssetToAssetList = addAssetToAssetList;
|
|
exports.addNewChannelToChannelList = addNewChannelToChannelList;
|
|
exports.onUpdateChannelClaims = onUpdateChannelClaims;
|
|
exports.updateChannelClaims = updateChannelClaims;
|
|
exports.fileRequested = fileRequested;
|
|
exports.updateFileAvailability = updateFileAvailability;
|
|
exports.updateDisplayAssetError = updateDisplayAssetError;
|
|
|
|
var _show_action_types = __webpack_require__(12);
|
|
|
|
var actions = _interopRequireWildcard(_show_action_types);
|
|
|
|
var _show_request_types = __webpack_require__(42);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
// basic request parsing
|
|
function onHandleShowPageUri(params) {
|
|
return {
|
|
type: actions.HANDLE_SHOW_URI,
|
|
data: params
|
|
};
|
|
};
|
|
|
|
function onRequestError(error) {
|
|
return {
|
|
type: actions.REQUEST_ERROR,
|
|
data: error
|
|
};
|
|
};
|
|
|
|
function onNewChannelRequest(channelName, channelId) {
|
|
var requestType = _show_request_types.CHANNEL;
|
|
var requestId = 'cr#' + channelName + '#' + channelId;
|
|
return {
|
|
type: actions.CHANNEL_REQUEST_NEW,
|
|
data: { requestType: requestType, requestId: requestId, channelName: channelName, channelId: channelId }
|
|
};
|
|
};
|
|
|
|
function onNewAssetRequest(name, id, channelName, channelId, extension) {
|
|
var requestType = extension ? _show_request_types.ASSET_LITE : _show_request_types.ASSET_DETAILS;
|
|
var requestId = 'ar#' + name + '#' + id + '#' + channelName + '#' + channelId;
|
|
return {
|
|
type: actions.ASSET_REQUEST_NEW,
|
|
data: {
|
|
requestType: requestType,
|
|
requestId: requestId,
|
|
name: name,
|
|
modifier: {
|
|
id: id,
|
|
channel: {
|
|
name: channelName,
|
|
id: channelId
|
|
}
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
function onRequestUpdate(requestType, requestId) {
|
|
return {
|
|
type: actions.REQUEST_UPDATE,
|
|
data: {
|
|
requestType: requestType,
|
|
requestId: requestId
|
|
}
|
|
};
|
|
};
|
|
|
|
function addRequestToRequestList(id, error, key) {
|
|
return {
|
|
type: actions.REQUEST_LIST_ADD,
|
|
data: { id: id, error: error, key: key }
|
|
};
|
|
};
|
|
|
|
// asset actions
|
|
|
|
function addAssetToAssetList(id, error, name, claimId, shortId, claimData) {
|
|
return {
|
|
type: actions.ASSET_ADD,
|
|
data: { id: id, error: error, name: name, claimId: claimId, shortId: shortId, claimData: claimData }
|
|
};
|
|
}
|
|
|
|
// channel actions
|
|
|
|
function addNewChannelToChannelList(id, name, shortId, longId, claimsData) {
|
|
return {
|
|
type: actions.CHANNEL_ADD,
|
|
data: { id: id, name: name, shortId: shortId, longId: longId, claimsData: claimsData }
|
|
};
|
|
};
|
|
|
|
function onUpdateChannelClaims(channelKey, name, longId, page) {
|
|
return {
|
|
type: actions.CHANNEL_CLAIMS_UPDATE_ASYNC,
|
|
data: { channelKey: channelKey, name: name, longId: longId, page: page }
|
|
};
|
|
};
|
|
|
|
function updateChannelClaims(channelListId, claimsData) {
|
|
return {
|
|
type: actions.CHANNEL_CLAIMS_UPDATE_SUCCESS,
|
|
data: { channelListId: channelListId, claimsData: claimsData }
|
|
};
|
|
};
|
|
|
|
// display a file
|
|
|
|
function fileRequested(name, claimId) {
|
|
return {
|
|
type: actions.FILE_REQUESTED,
|
|
data: { name: name, claimId: claimId }
|
|
};
|
|
};
|
|
|
|
function updateFileAvailability(status) {
|
|
return {
|
|
type: actions.FILE_AVAILABILITY_UPDATE,
|
|
data: status
|
|
};
|
|
};
|
|
|
|
function updateDisplayAssetError(error) {
|
|
return {
|
|
type: actions.DISPLAY_ASSET_ERROR,
|
|
data: error
|
|
};
|
|
};
|
|
|
|
/***/ }),
|
|
/* 8 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _reactHelmet = __webpack_require__(14);
|
|
|
|
var _reactHelmet2 = _interopRequireDefault(_reactHelmet);
|
|
|
|
var _propTypes = __webpack_require__(9);
|
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes);
|
|
|
|
var _pageTitle = __webpack_require__(89);
|
|
|
|
var _metaTags = __webpack_require__(90);
|
|
|
|
var _canonicalLink = __webpack_require__(91);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var SEO = function (_React$Component) {
|
|
_inherits(SEO, _React$Component);
|
|
|
|
function SEO() {
|
|
_classCallCheck(this, SEO);
|
|
|
|
return _possibleConstructorReturn(this, (SEO.__proto__ || Object.getPrototypeOf(SEO)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(SEO, [{
|
|
key: 'render',
|
|
value: function render() {
|
|
var _props = this.props,
|
|
pageTitle = _props.pageTitle,
|
|
asset = _props.asset,
|
|
channel = _props.channel,
|
|
pageUri = _props.pageUri;
|
|
|
|
pageTitle = (0, _pageTitle.createPageTitle)(pageTitle);
|
|
var metaTags = (0, _metaTags.createMetaTags)(asset, channel);
|
|
var canonicalLink = (0, _canonicalLink.createCanonicalLink)(asset, channel, pageUri);
|
|
return _react2.default.createElement(_reactHelmet2.default, {
|
|
title: pageTitle,
|
|
meta: metaTags,
|
|
link: [{ rel: 'canonical', href: canonicalLink }]
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return SEO;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
SEO.propTypes = {
|
|
pageTitle: _propTypes2.default.string,
|
|
pageUri: _propTypes2.default.string,
|
|
channel: _propTypes2.default.object,
|
|
asset: _propTypes2.default.object
|
|
};
|
|
|
|
exports.default = SEO;
|
|
|
|
/***/ }),
|
|
/* 9 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("prop-types");
|
|
|
|
/***/ }),
|
|
/* 10 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
|
|
|
|
exports.default = request;
|
|
|
|
__webpack_require__(95);
|
|
|
|
/**
|
|
* Parses the JSON returned by a network request
|
|
*
|
|
* @param {object} response A response from a network request
|
|
*
|
|
* @return {object} The parsed JSON from the request
|
|
*/
|
|
function parseJSON(response) {
|
|
if (response.status === 204 || response.status === 205) {
|
|
return null;
|
|
}
|
|
return response.json();
|
|
}
|
|
|
|
/**
|
|
* Parses the status returned by a network request
|
|
*
|
|
* @param {object} response A response from a network request
|
|
* @param {object} response The parsed JSON from the network request
|
|
*
|
|
* @return {object | undefined} Returns object with status and statusText, or undefined
|
|
*/
|
|
function checkStatus(response, jsonResponse) {
|
|
if (response.status >= 200 && response.status < 300) {
|
|
return jsonResponse;
|
|
}
|
|
var error = new Error(jsonResponse.message);
|
|
error.response = response;
|
|
throw error;
|
|
}
|
|
|
|
/**
|
|
* Requests a URL, returning a promise
|
|
*
|
|
* @param {string} url The URL we want to request
|
|
* @param {object} [options] The options we want to pass to "fetch"
|
|
*
|
|
* @return {object} The response data
|
|
*/
|
|
|
|
function request(url, options) {
|
|
return fetch(url, options).then(function (response) {
|
|
return Promise.all([response, parseJSON(response)]);
|
|
}).then(function (_ref) {
|
|
var _ref2 = _slicedToArray(_ref, 2),
|
|
response = _ref2[0],
|
|
jsonResponse = _ref2[1];
|
|
|
|
return checkStatus(response, jsonResponse);
|
|
});
|
|
}
|
|
|
|
/***/ }),
|
|
/* 11 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var Sequelize = __webpack_require__(70);
|
|
var logger = __webpack_require__(2);
|
|
|
|
console.log('exporting sequelize models');
|
|
|
|
var _require = __webpack_require__(23),
|
|
database = _require.database,
|
|
username = _require.username,
|
|
password = _require.password;
|
|
|
|
var db = {};
|
|
// set sequelize options
|
|
var sequelize = new Sequelize(database, username, password, {
|
|
host: 'localhost',
|
|
dialect: 'mysql',
|
|
dialectOptions: { decimalNumbers: true }, // fix to ensure DECIMAL will not be stored as a string
|
|
logging: false,
|
|
pool: {
|
|
max: 5,
|
|
min: 0,
|
|
idle: 10000,
|
|
acquire: 10000
|
|
}
|
|
});
|
|
|
|
// establish mysql connection
|
|
sequelize.authenticate().then(function () {
|
|
logger.info('Sequelize has established mysql connection successfully.');
|
|
}).catch(function (err) {
|
|
logger.error('Sequelize was unable to connect to the database:', err);
|
|
});
|
|
|
|
// manually add each model to the db object
|
|
var Certificate = __webpack_require__(71);
|
|
var Channel = __webpack_require__(72);
|
|
var Claim = __webpack_require__(73);
|
|
var File = __webpack_require__(74);
|
|
var Request = __webpack_require__(75);
|
|
var User = __webpack_require__(76);
|
|
db['Certificate'] = sequelize.import('Certificate', Certificate);
|
|
db['Channel'] = sequelize.import('Channel', Channel);
|
|
db['Claim'] = sequelize.import('Claim', Claim);
|
|
db['File'] = sequelize.import('File', File);
|
|
db['Request'] = sequelize.import('Request', Request);
|
|
db['User'] = sequelize.import('User', User);
|
|
|
|
// run model.association for each model in the db object that has an association
|
|
Object.keys(db).forEach(function (modelName) {
|
|
if (db[modelName].associate) {
|
|
logger.info('Associating model:', modelName);
|
|
db[modelName].associate(db);
|
|
}
|
|
});
|
|
|
|
db.sequelize = sequelize;
|
|
db.Sequelize = Sequelize;
|
|
|
|
// add an 'upsert' method to the db object
|
|
db.upsert = function (Model, values, condition, tableName) {
|
|
return Model.findOne({
|
|
where: condition
|
|
}).then(function (obj) {
|
|
if (obj) {
|
|
// update
|
|
logger.debug('updating record in db.' + tableName);
|
|
return obj.update(values);
|
|
} else {
|
|
// insert
|
|
logger.debug('creating record in db.' + tableName);
|
|
return Model.create(values);
|
|
}
|
|
}).catch(function (error) {
|
|
logger.error(tableName + '.upsert error', error);
|
|
throw error;
|
|
});
|
|
};
|
|
|
|
module.exports = db;
|
|
|
|
/***/ }),
|
|
/* 12 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
// request actions
|
|
var HANDLE_SHOW_URI = exports.HANDLE_SHOW_URI = 'HANDLE_SHOW_URI';
|
|
var REQUEST_ERROR = exports.REQUEST_ERROR = 'REQUEST_ERROR';
|
|
var REQUEST_UPDATE = exports.REQUEST_UPDATE = 'REQUEST_UPDATE';
|
|
var ASSET_REQUEST_NEW = exports.ASSET_REQUEST_NEW = 'ASSET_REQUEST_NEW';
|
|
var CHANNEL_REQUEST_NEW = exports.CHANNEL_REQUEST_NEW = 'CHANNEL_REQUEST_NEW';
|
|
var REQUEST_LIST_ADD = exports.REQUEST_LIST_ADD = 'REQUEST_LIST_ADD';
|
|
|
|
// asset actions
|
|
var ASSET_ADD = exports.ASSET_ADD = 'ASSET_ADD';
|
|
|
|
// channel actions
|
|
var CHANNEL_ADD = exports.CHANNEL_ADD = 'CHANNEL_ADD';
|
|
|
|
var CHANNEL_CLAIMS_UPDATE_ASYNC = exports.CHANNEL_CLAIMS_UPDATE_ASYNC = 'CHANNEL_CLAIMS_UPDATE_ASYNC';
|
|
var CHANNEL_CLAIMS_UPDATE_SUCCESS = exports.CHANNEL_CLAIMS_UPDATE_SUCCESS = 'CHANNEL_CLAIMS_UPDATE_SUCCESS';
|
|
|
|
// asset/file display actions
|
|
var FILE_REQUESTED = exports.FILE_REQUESTED = 'FILE_REQUESTED';
|
|
var FILE_AVAILABILITY_UPDATE = exports.FILE_AVAILABILITY_UPDATE = 'FILE_AVAILABILITY_UPDATE';
|
|
var DISPLAY_ASSET_ERROR = exports.DISPLAY_ASSET_ERROR = 'DISPLAY_ASSET_ERROR';
|
|
|
|
/***/ }),
|
|
/* 13 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var selectAsset = exports.selectAsset = function selectAsset(show) {
|
|
var request = show.requestList[show.request.id];
|
|
var assetKey = request.key;
|
|
return show.assetList[assetKey];
|
|
};
|
|
|
|
var selectShowState = exports.selectShowState = function selectShowState(state) {
|
|
return state.show;
|
|
};
|
|
|
|
/***/ }),
|
|
/* 14 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("react-helmet");
|
|
|
|
/***/ }),
|
|
/* 15 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("redux-saga/effects");
|
|
|
|
/***/ }),
|
|
/* 16 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var axios = __webpack_require__(63);
|
|
var logger = __webpack_require__(2);
|
|
|
|
var _require = __webpack_require__(64),
|
|
_require$api = _require.api,
|
|
apiHost = _require$api.apiHost,
|
|
apiPort = _require$api.apiPort;
|
|
|
|
var lbryApiUri = 'http://' + apiHost + ':' + apiPort;
|
|
|
|
var _require2 = __webpack_require__(17),
|
|
chooseGaLbrynetPublishLabel = _require2.chooseGaLbrynetPublishLabel,
|
|
sendGATimingEvent = _require2.sendGATimingEvent;
|
|
|
|
var handleLbrynetResponse = function handleLbrynetResponse(_ref, resolve, reject) {
|
|
var data = _ref.data;
|
|
|
|
logger.debug('lbry api data:', data);
|
|
if (data.result) {
|
|
// check for an error
|
|
if (data.result.error) {
|
|
logger.debug('Lbrynet api error:', data.result.error);
|
|
reject(new Error(data.result.error));
|
|
return;
|
|
};
|
|
resolve(data.result);
|
|
return;
|
|
}
|
|
// fallback in case it just timed out
|
|
reject(JSON.stringify(data));
|
|
};
|
|
|
|
module.exports = {
|
|
publishClaim: function publishClaim(publishParams) {
|
|
logger.debug('lbryApi >> Publishing claim to "' + publishParams.name + '"');
|
|
var gaStartTime = Date.now();
|
|
return new Promise(function (resolve, reject) {
|
|
axios.post(lbryApiUri, {
|
|
method: 'publish',
|
|
params: publishParams
|
|
}).then(function (response) {
|
|
sendGATimingEvent('lbrynet', 'publish', chooseGaLbrynetPublishLabel(publishParams), gaStartTime, Date.now());
|
|
handleLbrynetResponse(response, resolve, reject);
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
},
|
|
getClaim: function getClaim(uri) {
|
|
logger.debug('lbryApi >> Getting Claim for "' + uri + '"');
|
|
var gaStartTime = Date.now();
|
|
return new Promise(function (resolve, reject) {
|
|
axios.post(lbryApiUri, {
|
|
method: 'get',
|
|
params: { uri: uri, timeout: 20 }
|
|
}).then(function (response) {
|
|
sendGATimingEvent('lbrynet', 'getClaim', 'GET', gaStartTime, Date.now());
|
|
handleLbrynetResponse(response, resolve, reject);
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
},
|
|
getClaimList: function getClaimList(claimName) {
|
|
logger.debug('lbryApi >> Getting claim_list for "' + claimName + '"');
|
|
var gaStartTime = Date.now();
|
|
return new Promise(function (resolve, reject) {
|
|
axios.post(lbryApiUri, {
|
|
method: 'claim_list',
|
|
params: { name: claimName }
|
|
}).then(function (response) {
|
|
sendGATimingEvent('lbrynet', 'getClaimList', 'CLAIM_LIST', gaStartTime, Date.now());
|
|
handleLbrynetResponse(response, resolve, reject);
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
},
|
|
resolveUri: function resolveUri(uri) {
|
|
logger.debug('lbryApi >> Resolving URI for "' + uri + '"');
|
|
var gaStartTime = Date.now();
|
|
return new Promise(function (resolve, reject) {
|
|
axios.post(lbryApiUri, {
|
|
method: 'resolve',
|
|
params: { uri: uri }
|
|
}).then(function (_ref2) {
|
|
var data = _ref2.data;
|
|
|
|
sendGATimingEvent('lbrynet', 'resolveUri', 'RESOLVE', gaStartTime, Date.now());
|
|
if (data.result[uri].error) {
|
|
// check for errors
|
|
reject(data.result[uri].error);
|
|
} else {
|
|
// if no errors, resolve
|
|
resolve(data.result[uri]);
|
|
}
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
},
|
|
getDownloadDirectory: function getDownloadDirectory() {
|
|
logger.debug('lbryApi >> Retrieving the download directory path from lbry daemon...');
|
|
var gaStartTime = Date.now();
|
|
return new Promise(function (resolve, reject) {
|
|
axios.post(lbryApiUri, {
|
|
method: 'settings_get'
|
|
}).then(function (_ref3) {
|
|
var data = _ref3.data;
|
|
|
|
sendGATimingEvent('lbrynet', 'getDownloadDirectory', 'SETTINGS_GET', gaStartTime, Date.now());
|
|
if (data.result) {
|
|
resolve(data.result.download_directory);
|
|
} else {
|
|
return new Error('Successfully connected to lbry daemon, but unable to retrieve the download directory.');
|
|
}
|
|
}).catch(function (error) {
|
|
logger.error('Lbrynet Error:', error);
|
|
resolve('/home/lbry/Downloads/');
|
|
});
|
|
});
|
|
},
|
|
createChannel: function createChannel(name) {
|
|
logger.debug('lbryApi >> Creating channel for ' + name + '...');
|
|
var gaStartTime = Date.now();
|
|
return new Promise(function (resolve, reject) {
|
|
axios.post(lbryApiUri, {
|
|
method: 'channel_new',
|
|
params: {
|
|
channel_name: name,
|
|
amount: 0.1
|
|
}
|
|
}).then(function (response) {
|
|
sendGATimingEvent('lbrynet', 'createChannel', 'CHANNEL_NEW', gaStartTime, Date.now());
|
|
handleLbrynetResponse(response, resolve, reject);
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 17 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var logger = __webpack_require__(2);
|
|
var ua = __webpack_require__(65);
|
|
|
|
var _require = __webpack_require__(3),
|
|
googleId = _require.analytics.googleId,
|
|
siteName = _require.site.name;
|
|
|
|
function createServeEventParams(headers, ip, originalUrl) {
|
|
return {
|
|
eventCategory: 'client requests',
|
|
eventAction: 'serve request',
|
|
eventLabel: originalUrl,
|
|
ipOverride: ip,
|
|
userAgentOverride: headers['user-agent']
|
|
};
|
|
};
|
|
|
|
function createPublishTimingEventParams(category, variable, label, startTime, endTime) {
|
|
var duration = endTime - startTime;
|
|
return {
|
|
userTimingCategory: category,
|
|
userTimingVariableName: variable,
|
|
userTimingTime: duration,
|
|
userTimingLabel: label
|
|
};
|
|
};
|
|
|
|
function sendGoogleAnalyticsEvent(ip, params) {
|
|
var visitorId = ip.replace(/\./g, '-');
|
|
var visitor = ua(googleId, visitorId, { strictCidFormat: false, https: true });
|
|
visitor.event(params, function (err) {
|
|
if (err) {
|
|
logger.error('Google Analytics Event Error >>', err);
|
|
}
|
|
});
|
|
};
|
|
|
|
function sendGoogleAnalyticsTiming(visitorId, params) {
|
|
var visitor = ua(googleId, visitorId, { strictCidFormat: false, https: true });
|
|
visitor.timing(params, function (err) {
|
|
if (err) {
|
|
logger.error('Google Analytics Event Error >>', err);
|
|
}
|
|
logger.debug('Timing event successfully sent to google analytics');
|
|
});
|
|
};
|
|
|
|
module.exports = {
|
|
sendGAServeEvent: function sendGAServeEvent(headers, ip, originalUrl) {
|
|
var params = createServeEventParams(headers, ip, originalUrl);
|
|
sendGoogleAnalyticsEvent(ip, params);
|
|
},
|
|
sendGATimingEvent: function sendGATimingEvent(category, variable, label, startTime, endTime) {
|
|
var params = createPublishTimingEventParams(category, variable, label, startTime, endTime);
|
|
sendGoogleAnalyticsTiming(siteName, params);
|
|
},
|
|
chooseGaLbrynetPublishLabel: function chooseGaLbrynetPublishLabel(_ref) {
|
|
var channelName = _ref.channel_name,
|
|
channelId = _ref.channel_id;
|
|
|
|
return channelName || channelId ? 'PUBLISH_IN_CHANNEL_CLAIM' : 'PUBLISH_ANONYMOUS_CLAIM';
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 18 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("redux");
|
|
|
|
/***/ }),
|
|
/* 19 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.updateLoggedInChannel = updateLoggedInChannel;
|
|
|
|
var _channel_action_types = __webpack_require__(35);
|
|
|
|
var actions = _interopRequireWildcard(_channel_action_types);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
// export action creators
|
|
|
|
function updateLoggedInChannel(name, shortId, longId) {
|
|
return {
|
|
type: actions.CHANNEL_UPDATE,
|
|
data: {
|
|
name: name,
|
|
shortId: shortId,
|
|
longId: longId
|
|
}
|
|
};
|
|
};
|
|
|
|
/***/ }),
|
|
/* 20 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _propTypes = __webpack_require__(9);
|
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes);
|
|
|
|
var _ActiveStatusBar = __webpack_require__(117);
|
|
|
|
var _ActiveStatusBar2 = _interopRequireDefault(_ActiveStatusBar);
|
|
|
|
var _InactiveStatusBar = __webpack_require__(118);
|
|
|
|
var _InactiveStatusBar2 = _interopRequireDefault(_InactiveStatusBar);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var ProgressBar = function (_React$Component) {
|
|
_inherits(ProgressBar, _React$Component);
|
|
|
|
function ProgressBar(props) {
|
|
_classCallCheck(this, ProgressBar);
|
|
|
|
var _this = _possibleConstructorReturn(this, (ProgressBar.__proto__ || Object.getPrototypeOf(ProgressBar)).call(this, props));
|
|
|
|
_this.state = {
|
|
bars: [],
|
|
index: 0,
|
|
incrementer: 1
|
|
};
|
|
_this.createBars = _this.createBars.bind(_this);
|
|
_this.startProgressBar = _this.startProgressBar.bind(_this);
|
|
_this.updateProgressBar = _this.updateProgressBar.bind(_this);
|
|
_this.stopProgressBar = _this.stopProgressBar.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ProgressBar, [{
|
|
key: 'componentDidMount',
|
|
value: function componentDidMount() {
|
|
this.createBars();
|
|
this.startProgressBar();
|
|
}
|
|
}, {
|
|
key: 'componentWillUnmount',
|
|
value: function componentWillUnmount() {
|
|
this.stopProgressBar();
|
|
}
|
|
}, {
|
|
key: 'createBars',
|
|
value: function createBars() {
|
|
var bars = [];
|
|
for (var i = 0; i <= this.props.size; i++) {
|
|
bars.push({ isActive: false });
|
|
}
|
|
this.setState({ bars: bars });
|
|
}
|
|
}, {
|
|
key: 'startProgressBar',
|
|
value: function startProgressBar() {
|
|
this.updateInterval = setInterval(this.updateProgressBar.bind(this), 300);
|
|
}
|
|
}, {
|
|
key: 'updateProgressBar',
|
|
value: function updateProgressBar() {
|
|
var index = this.state.index;
|
|
var incrementer = this.state.incrementer;
|
|
var bars = this.state.bars;
|
|
// flip incrementer if necessary, to stay in bounds
|
|
if (index < 0 || index > this.props.size) {
|
|
incrementer = incrementer * -1;
|
|
index += incrementer;
|
|
}
|
|
// update the indexed bar
|
|
if (incrementer > 0) {
|
|
bars[index].isActive = true;
|
|
} else {
|
|
bars[index].isActive = false;
|
|
};
|
|
// increment index
|
|
index += incrementer;
|
|
// update state
|
|
this.setState({
|
|
bars: bars,
|
|
incrementer: incrementer,
|
|
index: index
|
|
});
|
|
}
|
|
}, {
|
|
key: 'stopProgressBar',
|
|
value: function stopProgressBar() {
|
|
clearInterval(this.updateInterval);
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
this.state.bars.map(function (bar, index) {
|
|
return bar.isActive ? _react2.default.createElement(_ActiveStatusBar2.default, { key: index }) : _react2.default.createElement(_InactiveStatusBar2.default, { key: index });
|
|
})
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return ProgressBar;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
ProgressBar.propTypes = {
|
|
size: _propTypes2.default.number.isRequired
|
|
};
|
|
|
|
exports.default = ProgressBar;
|
|
|
|
/***/ }),
|
|
/* 21 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _propTypes = __webpack_require__(9);
|
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes);
|
|
|
|
var _NavBar = __webpack_require__(6);
|
|
|
|
var _NavBar2 = _interopRequireDefault(_NavBar);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var ErrorPage = function (_React$Component) {
|
|
_inherits(ErrorPage, _React$Component);
|
|
|
|
function ErrorPage() {
|
|
_classCallCheck(this, ErrorPage);
|
|
|
|
return _possibleConstructorReturn(this, (ErrorPage.__proto__ || Object.getPrototypeOf(ErrorPage)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(ErrorPage, [{
|
|
key: 'render',
|
|
value: function render() {
|
|
var error = this.props.error;
|
|
|
|
return _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(_NavBar2.default, null),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
error
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return ErrorPage;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
ErrorPage.propTypes = {
|
|
error: _propTypes2.default.string.isRequired
|
|
};
|
|
|
|
exports.default = ErrorPage;
|
|
|
|
/***/ }),
|
|
/* 22 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("passport");
|
|
|
|
/***/ }),
|
|
/* 23 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
function MysqlConfig() {
|
|
var _this = this;
|
|
|
|
this.database = 'default';
|
|
this.username = 'default';
|
|
this.password = 'default';
|
|
this.configure = function (_ref) {
|
|
var database = _ref.database,
|
|
username = _ref.username,
|
|
password = _ref.password;
|
|
|
|
if (database) _this.database = database;
|
|
if (username) _this.username = username;
|
|
if (password) _this.password = password;
|
|
};
|
|
};
|
|
|
|
module.exports = new MysqlConfig();
|
|
|
|
/***/ }),
|
|
/* 24 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
function SlackConfig() {
|
|
var _this = this;
|
|
|
|
this.slackWebHook = 'default';
|
|
this.slackErrorChannel = 'default';
|
|
this.slackInfoChannel = 'default';
|
|
this.configure = function (_ref) {
|
|
var slackWebHook = _ref.slackWebHook,
|
|
slackErrorChannel = _ref.slackErrorChannel,
|
|
slackInfoChannel = _ref.slackInfoChannel;
|
|
|
|
if (slackWebHook) _this.slackWebHook = slackWebHook;
|
|
if (slackErrorChannel) _this.slackErrorChannel = slackErrorChannel;
|
|
if (slackInfoChannel) _this.slackInfoChannel = slackInfoChannel;
|
|
};
|
|
};
|
|
|
|
module.exports = new SlackConfig();
|
|
|
|
/***/ }),
|
|
/* 25 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("passport-local");
|
|
|
|
/***/ }),
|
|
/* 26 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
module.exports = {
|
|
returnShortId: function returnShortId(claimsArray, longId) {
|
|
var claimIndex = void 0;
|
|
var shortId = longId.substring(0, 1); // default short id is the first letter
|
|
var shortIdLength = 0;
|
|
// find the index of this claim id
|
|
claimIndex = claimsArray.findIndex(function (element) {
|
|
return element.claimId === longId;
|
|
});
|
|
if (claimIndex < 0) {
|
|
throw new Error('claim id not found in claims list');
|
|
}
|
|
// get an array of all claims with lower height
|
|
var possibleMatches = claimsArray.slice(0, claimIndex);
|
|
// remove certificates with the same prefixes until none are left.
|
|
while (possibleMatches.length > 0) {
|
|
shortIdLength += 1;
|
|
shortId = longId.substring(0, shortIdLength);
|
|
possibleMatches = possibleMatches.filter(function (element) {
|
|
return element.claimId && element.claimId.substring(0, shortIdLength) === shortId;
|
|
});
|
|
}
|
|
return shortId;
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 27 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var logger = __webpack_require__(2);
|
|
var fs = __webpack_require__(79);
|
|
|
|
var _require = __webpack_require__(3),
|
|
site = _require.site,
|
|
wallet = _require.wallet,
|
|
publish = _require.publish;
|
|
|
|
module.exports = {
|
|
parsePublishApiRequestBody: function parsePublishApiRequestBody(_ref) {
|
|
var name = _ref.name,
|
|
nsfw = _ref.nsfw,
|
|
license = _ref.license,
|
|
title = _ref.title,
|
|
description = _ref.description,
|
|
thumbnail = _ref.thumbnail;
|
|
|
|
// validate name
|
|
if (!name) {
|
|
throw new Error('no name field found in request');
|
|
}
|
|
var invalidNameCharacters = /[^A-Za-z0-9,-]/.exec(name);
|
|
if (invalidNameCharacters) {
|
|
throw new Error('The claim name you provided is not allowed. Only the following characters are allowed: A-Z, a-z, 0-9, and "-"');
|
|
}
|
|
// optional parameters
|
|
nsfw = nsfw === 'true';
|
|
license = license || null;
|
|
title = title || null;
|
|
description = description || null;
|
|
thumbnail = thumbnail || null;
|
|
// return results
|
|
return {
|
|
name: name,
|
|
nsfw: nsfw,
|
|
license: license,
|
|
title: title,
|
|
description: description,
|
|
thumbnail: thumbnail
|
|
};
|
|
},
|
|
parsePublishApiRequestFiles: function parsePublishApiRequestFiles(_ref2) {
|
|
var file = _ref2.file,
|
|
thumbnail = _ref2.thumbnail;
|
|
|
|
// make sure a file was provided
|
|
if (!file) {
|
|
throw new Error('no file with key of [file] found in request');
|
|
}
|
|
if (!file.path) {
|
|
throw new Error('no file path found');
|
|
}
|
|
if (!file.type) {
|
|
throw new Error('no file type found');
|
|
}
|
|
if (!file.size) {
|
|
throw new Error('no file type found');
|
|
}
|
|
// validate the file name
|
|
if (/'/.test(file.name)) {
|
|
throw new Error('apostrophes are not allowed in the file name');
|
|
}
|
|
// validate the file
|
|
module.exports.validateFileTypeAndSize(file);
|
|
// return results
|
|
return {
|
|
fileName: file.name,
|
|
filePath: file.path,
|
|
fileType: file.type,
|
|
thumbnailFileName: thumbnail ? thumbnail.name : null,
|
|
thumbnailFilePath: thumbnail ? thumbnail.path : null,
|
|
thumbnailFileType: thumbnail ? thumbnail.type : null
|
|
};
|
|
},
|
|
validateFileTypeAndSize: function validateFileTypeAndSize(file) {
|
|
// check file type and size
|
|
switch (file.type) {
|
|
case 'image/jpeg':
|
|
case 'image/jpg':
|
|
case 'image/png':
|
|
if (file.size > 10000000) {
|
|
logger.debug('publish > file validation > .jpeg/.jpg/.png was too big');
|
|
throw new Error('Sorry, images are limited to 10 megabytes.');
|
|
}
|
|
break;
|
|
case 'image/gif':
|
|
if (file.size > 50000000) {
|
|
logger.debug('publish > file validation > .gif was too big');
|
|
throw new Error('Sorry, .gifs are limited to 50 megabytes.');
|
|
}
|
|
break;
|
|
case 'video/mp4':
|
|
if (file.size > 50000000) {
|
|
logger.debug('publish > file validation > .mp4 was too big');
|
|
throw new Error('Sorry, videos are limited to 50 megabytes.');
|
|
}
|
|
break;
|
|
default:
|
|
logger.debug('publish > file validation > unrecognized file type');
|
|
throw new Error('The ' + file.type + ' content type is not supported. Only, .jpeg, .png, .gif, and .mp4 files are currently supported.');
|
|
}
|
|
return file;
|
|
},
|
|
createBasicPublishParams: function createBasicPublishParams(filePath, name, title, description, license, nsfw, thumbnail) {
|
|
logger.debug('Creating Publish Parameters');
|
|
// provide defaults for title
|
|
if (title === null || title.trim() === '') {
|
|
title = name;
|
|
}
|
|
// provide default for description
|
|
if (description === null || description.trim() === '') {
|
|
description = '';
|
|
}
|
|
// provide default for license
|
|
if (license === null || license.trim() === '') {
|
|
license = ' '; // default to empty string
|
|
}
|
|
// create the publish params
|
|
var publishParams = {
|
|
name: name,
|
|
file_path: filePath,
|
|
bid: 0.01,
|
|
metadata: {
|
|
description: description,
|
|
title: title,
|
|
author: site.title,
|
|
language: 'en',
|
|
license: license,
|
|
nsfw: nsfw
|
|
},
|
|
claim_address: wallet.lbryClaimAddress
|
|
};
|
|
// add thumbnail to channel if video
|
|
if (thumbnail) {
|
|
publishParams['metadata']['thumbnail'] = thumbnail;
|
|
}
|
|
return publishParams;
|
|
},
|
|
createThumbnailPublishParams: function createThumbnailPublishParams(thumbnailFilePath, claimName, license, nsfw) {
|
|
if (!thumbnailFilePath) {
|
|
return;
|
|
}
|
|
logger.debug('Creating Thumbnail Publish Parameters');
|
|
// create the publish params
|
|
return {
|
|
name: claimName + '-thumb',
|
|
file_path: thumbnailFilePath,
|
|
bid: 0.01,
|
|
metadata: {
|
|
title: claimName + ' thumbnail',
|
|
description: 'a thumbnail for ' + claimName,
|
|
author: site.title,
|
|
language: 'en',
|
|
license: license,
|
|
nsfw: nsfw
|
|
},
|
|
claim_address: wallet.lbryClaimAddress,
|
|
channel_name: publish.thumbnailChannel,
|
|
channel_id: publish.thumbnailChannelId
|
|
};
|
|
},
|
|
deleteTemporaryFile: function deleteTemporaryFile(filePath) {
|
|
fs.unlink(filePath, function (err) {
|
|
if (err) {
|
|
logger.error('error deleting temporary file ' + filePath);
|
|
throw err;
|
|
}
|
|
logger.debug('successfully deleted ' + filePath);
|
|
});
|
|
},
|
|
addGetResultsToFileData: function addGetResultsToFileData(fileInfo, getResult) {
|
|
fileInfo.fileName = getResult.file_name;
|
|
fileInfo.filePath = getResult.download_path;
|
|
return fileInfo;
|
|
},
|
|
createFileData: function createFileData(_ref3) {
|
|
var name = _ref3.name,
|
|
claimId = _ref3.claimId,
|
|
outpoint = _ref3.outpoint,
|
|
height = _ref3.height,
|
|
address = _ref3.address,
|
|
nsfw = _ref3.nsfw,
|
|
contentType = _ref3.contentType;
|
|
|
|
return {
|
|
name: name,
|
|
claimId: claimId,
|
|
outpoint: outpoint,
|
|
height: height,
|
|
address: address,
|
|
fileName: '',
|
|
filePath: '',
|
|
fileType: contentType,
|
|
nsfw: nsfw
|
|
};
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 28 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
|
|
|
|
var logger = __webpack_require__(2);
|
|
|
|
module.exports = {
|
|
handleErrorResponse: function handleErrorResponse(originalUrl, ip, error, res) {
|
|
logger.error('Error on ' + originalUrl, module.exports.useObjectPropertiesIfNoKeys(error));
|
|
|
|
var _module$exports$retur = module.exports.returnErrorMessageAndStatus(error),
|
|
_module$exports$retur2 = _slicedToArray(_module$exports$retur, 2),
|
|
status = _module$exports$retur2[0],
|
|
message = _module$exports$retur2[1];
|
|
|
|
res.status(status).json(module.exports.createErrorResponsePayload(status, message));
|
|
},
|
|
returnErrorMessageAndStatus: function returnErrorMessageAndStatus(error) {
|
|
var status = void 0,
|
|
message = void 0;
|
|
// check for daemon being turned off
|
|
if (error.code === 'ECONNREFUSED') {
|
|
status = 503;
|
|
message = 'Connection refused. The daemon may not be running.';
|
|
// fallback for everything else
|
|
} else {
|
|
status = 400;
|
|
if (error.message) {
|
|
message = error.message;
|
|
} else {
|
|
message = error;
|
|
};
|
|
};
|
|
return [status, message];
|
|
},
|
|
useObjectPropertiesIfNoKeys: function useObjectPropertiesIfNoKeys(err) {
|
|
if (Object.keys(err).length === 0) {
|
|
var newErrorObject = {};
|
|
Object.getOwnPropertyNames(err).forEach(function (key) {
|
|
newErrorObject[key] = err[key];
|
|
});
|
|
return newErrorObject;
|
|
}
|
|
return err;
|
|
},
|
|
createErrorResponsePayload: function createErrorResponsePayload(status, message) {
|
|
return {
|
|
status: status,
|
|
success: false,
|
|
message: message
|
|
};
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 29 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
|
|
|
|
var db = __webpack_require__(11);
|
|
var logger = __webpack_require__(2);
|
|
|
|
var _require = __webpack_require__(81),
|
|
returnPaginatedChannelClaims = _require.returnPaginatedChannelClaims;
|
|
|
|
var NO_CHANNEL = 'NO_CHANNEL';
|
|
var NO_CLAIM = 'NO_CLAIM';
|
|
var NO_FILE = 'NO_FILE';
|
|
|
|
module.exports = {
|
|
getClaimId: function getClaimId(channelName, channelClaimId, name, claimId) {
|
|
if (channelName) {
|
|
return module.exports.getClaimIdByChannel(channelName, channelClaimId, name);
|
|
} else {
|
|
return module.exports.getClaimIdByClaim(name, claimId);
|
|
}
|
|
},
|
|
getClaimIdByClaim: function getClaimIdByClaim(claimName, claimId) {
|
|
logger.debug('getClaimIdByClaim(' + claimName + ', ' + claimId + ')');
|
|
return new Promise(function (resolve, reject) {
|
|
db.Claim.getLongClaimId(claimName, claimId).then(function (longClaimId) {
|
|
if (!longClaimId) {
|
|
resolve(NO_CLAIM);
|
|
}
|
|
resolve(longClaimId);
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
},
|
|
getClaimIdByChannel: function getClaimIdByChannel(channelName, channelClaimId, claimName) {
|
|
logger.debug('getClaimIdByChannel(' + channelName + ', ' + channelClaimId + ', ' + claimName + ')');
|
|
return new Promise(function (resolve, reject) {
|
|
db.Certificate.getLongChannelId(channelName, channelClaimId) // 1. get the long channel id
|
|
.then(function (longChannelId) {
|
|
if (!longChannelId) {
|
|
return [null, null];
|
|
}
|
|
return Promise.all([longChannelId, db.Claim.getClaimIdByLongChannelId(longChannelId, claimName)]); // 2. get the long claim id
|
|
}).then(function (_ref) {
|
|
var _ref2 = _slicedToArray(_ref, 2),
|
|
longChannelId = _ref2[0],
|
|
longClaimId = _ref2[1];
|
|
|
|
if (!longChannelId) {
|
|
return resolve(NO_CHANNEL);
|
|
}
|
|
if (!longClaimId) {
|
|
return resolve(NO_CLAIM);
|
|
}
|
|
resolve(longClaimId);
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
},
|
|
getChannelData: function getChannelData(channelName, channelClaimId, page) {
|
|
return new Promise(function (resolve, reject) {
|
|
// 1. get the long channel Id (make sure channel exists)
|
|
db.Certificate.getLongChannelId(channelName, channelClaimId).then(function (longChannelClaimId) {
|
|
if (!longChannelClaimId) {
|
|
return [null, null, null];
|
|
}
|
|
// 2. get the short ID and all claims for that channel
|
|
return Promise.all([longChannelClaimId, db.Certificate.getShortChannelIdFromLongChannelId(longChannelClaimId, channelName)]);
|
|
}).then(function (_ref3) {
|
|
var _ref4 = _slicedToArray(_ref3, 2),
|
|
longChannelClaimId = _ref4[0],
|
|
shortChannelClaimId = _ref4[1];
|
|
|
|
if (!longChannelClaimId) {
|
|
return resolve(NO_CHANNEL);
|
|
}
|
|
// 3. return all the channel information
|
|
resolve({
|
|
channelName: channelName,
|
|
longChannelClaimId: longChannelClaimId,
|
|
shortChannelClaimId: shortChannelClaimId
|
|
});
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
},
|
|
getChannelClaims: function getChannelClaims(channelName, channelClaimId, page) {
|
|
return new Promise(function (resolve, reject) {
|
|
// 1. get the long channel Id (make sure channel exists)
|
|
db.Certificate.getLongChannelId(channelName, channelClaimId).then(function (longChannelClaimId) {
|
|
if (!longChannelClaimId) {
|
|
return [null, null, null];
|
|
}
|
|
// 2. get the short ID and all claims for that channel
|
|
return Promise.all([longChannelClaimId, db.Claim.getAllChannelClaims(longChannelClaimId)]);
|
|
}).then(function (_ref5) {
|
|
var _ref6 = _slicedToArray(_ref5, 2),
|
|
longChannelClaimId = _ref6[0],
|
|
channelClaimsArray = _ref6[1];
|
|
|
|
if (!longChannelClaimId) {
|
|
return resolve(NO_CHANNEL);
|
|
}
|
|
// 3. format the data for the view, including pagination
|
|
var paginatedChannelViewData = returnPaginatedChannelClaims(channelName, longChannelClaimId, channelClaimsArray, page);
|
|
// 4. return all the channel information and contents
|
|
resolve(paginatedChannelViewData);
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
},
|
|
getLocalFileRecord: function getLocalFileRecord(claimId, name) {
|
|
return db.File.findOne({ where: { claimId: claimId, name: name } }).then(function (file) {
|
|
if (!file) {
|
|
return NO_FILE;
|
|
}
|
|
return file.dataValues;
|
|
});
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 30 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _server = __webpack_require__(31);
|
|
|
|
var _redux = __webpack_require__(18);
|
|
|
|
var _reducers = __webpack_require__(32);
|
|
|
|
var _reducers2 = _interopRequireDefault(_reducers);
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _reactRouterDom = __webpack_require__(4);
|
|
|
|
var _GAListener = __webpack_require__(37);
|
|
|
|
var _GAListener2 = _interopRequireDefault(_GAListener);
|
|
|
|
var _app = __webpack_require__(38);
|
|
|
|
var _app2 = _interopRequireDefault(_app);
|
|
|
|
var _renderFullPage = __webpack_require__(44);
|
|
|
|
var _renderFullPage2 = _interopRequireDefault(_renderFullPage);
|
|
|
|
var _reactHelmet = __webpack_require__(14);
|
|
|
|
var _reactHelmet2 = _interopRequireDefault(_reactHelmet);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
module.exports = function (req, res) {
|
|
var context = {};
|
|
|
|
// create a new Redux store instance
|
|
var store = (0, _redux.createStore)(_reducers2.default);
|
|
|
|
// render component to a string
|
|
var html = (0, _server.renderToString)(_react2.default.createElement(
|
|
_reactRedux.Provider,
|
|
{ store: store },
|
|
_react2.default.createElement(
|
|
_reactRouterDom.StaticRouter,
|
|
{ location: req.url, context: context },
|
|
_react2.default.createElement(
|
|
_GAListener2.default,
|
|
null,
|
|
_react2.default.createElement(_app2.default, null)
|
|
)
|
|
)
|
|
));
|
|
|
|
// get head tags from helmet
|
|
var helmet = _reactHelmet2.default.renderStatic();
|
|
|
|
// check for a redirect
|
|
if (context.url) {
|
|
// Somewhere a `<Redirect>` was rendered
|
|
return res.redirect(301, context.url);
|
|
} else {}
|
|
// we're good, send the response
|
|
|
|
|
|
// get the initial state from our Redux store
|
|
var preloadedState = store.getState();
|
|
|
|
// send the rendered page back to the client
|
|
res.send((0, _renderFullPage2.default)(helmet, html, preloadedState));
|
|
};
|
|
|
|
/***/ }),
|
|
/* 31 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("react-dom/server");
|
|
|
|
/***/ }),
|
|
/* 32 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _redux = __webpack_require__(18);
|
|
|
|
var _publish = __webpack_require__(83);
|
|
|
|
var _publish2 = _interopRequireDefault(_publish);
|
|
|
|
var _channel = __webpack_require__(84);
|
|
|
|
var _channel2 = _interopRequireDefault(_channel);
|
|
|
|
var _show = __webpack_require__(85);
|
|
|
|
var _show2 = _interopRequireDefault(_show);
|
|
|
|
var _site = __webpack_require__(86);
|
|
|
|
var _site2 = _interopRequireDefault(_site);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
exports.default = (0, _redux.combineReducers)({
|
|
channel: _channel2.default,
|
|
publish: _publish2.default,
|
|
show: _show2.default,
|
|
site: _site2.default
|
|
});
|
|
|
|
/***/ }),
|
|
/* 33 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var FILE_SELECTED = exports.FILE_SELECTED = 'FILE_SELECTED';
|
|
var FILE_CLEAR = exports.FILE_CLEAR = 'FILE_CLEAR';
|
|
var METADATA_UPDATE = exports.METADATA_UPDATE = 'METADATA_UPDATE';
|
|
var CLAIM_UPDATE = exports.CLAIM_UPDATE = 'CLAIM_UPDATE';
|
|
var SET_PUBLISH_IN_CHANNEL = exports.SET_PUBLISH_IN_CHANNEL = 'SET_PUBLISH_IN_CHANNEL';
|
|
var PUBLISH_STATUS_UPDATE = exports.PUBLISH_STATUS_UPDATE = 'PUBLISH_STATUS_UPDATE';
|
|
var ERROR_UPDATE = exports.ERROR_UPDATE = 'ERROR_UPDATE';
|
|
var SELECTED_CHANNEL_UPDATE = exports.SELECTED_CHANNEL_UPDATE = 'SELECTED_CHANNEL_UPDATE';
|
|
var TOGGLE_METADATA_INPUTS = exports.TOGGLE_METADATA_INPUTS = 'TOGGLE_METADATA_INPUTS';
|
|
var THUMBNAIL_NEW = exports.THUMBNAIL_NEW = 'THUMBNAIL_NEW';
|
|
var PUBLISH_START = exports.PUBLISH_START = 'PUBLISH_START';
|
|
|
|
/***/ }),
|
|
/* 34 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var LOGIN = exports.LOGIN = 'Existing';
|
|
var CREATE = exports.CREATE = 'New';
|
|
|
|
/***/ }),
|
|
/* 35 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var CHANNEL_UPDATE = exports.CHANNEL_UPDATE = 'CHANNEL_UPDATE';
|
|
|
|
/***/ }),
|
|
/* 36 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var LOCAL_CHECK = exports.LOCAL_CHECK = 'LOCAL_CHECK';
|
|
var UNAVAILABLE = exports.UNAVAILABLE = 'UNAVAILABLE';
|
|
var ERROR = exports.ERROR = 'ERROR';
|
|
var AVAILABLE = exports.AVAILABLE = 'AVAILABLE';
|
|
|
|
/***/ }),
|
|
/* 37 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _reactGa = __webpack_require__(87);
|
|
|
|
var _reactGa2 = _interopRequireDefault(_reactGa);
|
|
|
|
var _reactRouterDom = __webpack_require__(4);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var config = __webpack_require__(3);
|
|
var googleApiKey = config.analytics.googleId;
|
|
|
|
_reactGa2.default.initialize(googleApiKey);
|
|
|
|
var GAListener = function (_React$Component) {
|
|
_inherits(GAListener, _React$Component);
|
|
|
|
function GAListener() {
|
|
_classCallCheck(this, GAListener);
|
|
|
|
return _possibleConstructorReturn(this, (GAListener.__proto__ || Object.getPrototypeOf(GAListener)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(GAListener, [{
|
|
key: 'componentDidMount',
|
|
value: function componentDidMount() {
|
|
this.sendPageView(this.props.history.location);
|
|
this.props.history.listen(this.sendPageView);
|
|
}
|
|
}, {
|
|
key: 'sendPageView',
|
|
value: function sendPageView(location) {
|
|
_reactGa2.default.set({ page: location.pathname });
|
|
_reactGa2.default.pageview(location.pathname);
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
return this.props.children;
|
|
}
|
|
}]);
|
|
|
|
return GAListener;
|
|
}(_react2.default.Component);
|
|
|
|
exports.default = (0, _reactRouterDom.withRouter)(GAListener);
|
|
|
|
/***/ }),
|
|
/* 38 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _reactRouterDom = __webpack_require__(4);
|
|
|
|
var _HomePage = __webpack_require__(88);
|
|
|
|
var _HomePage2 = _interopRequireDefault(_HomePage);
|
|
|
|
var _AboutPage = __webpack_require__(122);
|
|
|
|
var _AboutPage2 = _interopRequireDefault(_AboutPage);
|
|
|
|
var _LoginPage = __webpack_require__(123);
|
|
|
|
var _LoginPage2 = _interopRequireDefault(_LoginPage);
|
|
|
|
var _ShowPage = __webpack_require__(125);
|
|
|
|
var _ShowPage2 = _interopRequireDefault(_ShowPage);
|
|
|
|
var _FourOhFourPage = __webpack_require__(141);
|
|
|
|
var _FourOhFourPage2 = _interopRequireDefault(_FourOhFourPage);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var App = function App() {
|
|
return _react2.default.createElement(
|
|
_reactRouterDom.Switch,
|
|
null,
|
|
_react2.default.createElement(_reactRouterDom.Route, { exact: true, path: '/', component: _HomePage2.default }),
|
|
_react2.default.createElement(_reactRouterDom.Route, { exact: true, path: '/about', component: _AboutPage2.default }),
|
|
_react2.default.createElement(_reactRouterDom.Route, { exact: true, path: '/login', component: _LoginPage2.default }),
|
|
_react2.default.createElement(_reactRouterDom.Route, { exact: true, path: '/:identifier/:claim', component: _ShowPage2.default }),
|
|
_react2.default.createElement(_reactRouterDom.Route, { exact: true, path: '/:claim', component: _ShowPage2.default }),
|
|
_react2.default.createElement(_reactRouterDom.Route, { component: _FourOhFourPage2.default })
|
|
);
|
|
};
|
|
|
|
exports.default = App;
|
|
|
|
/***/ }),
|
|
/* 39 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _publish = __webpack_require__(5);
|
|
|
|
var _view = __webpack_require__(98);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var publish = _ref.publish;
|
|
|
|
return {
|
|
file: publish.file,
|
|
thumbnail: publish.thumbnail,
|
|
fileError: publish.error.file
|
|
};
|
|
};
|
|
|
|
var mapDispatchToProps = function mapDispatchToProps(dispatch) {
|
|
return {
|
|
selectFile: function selectFile(file) {
|
|
dispatch((0, _publish.selectFile)(file));
|
|
},
|
|
setFileError: function setFileError(value) {
|
|
dispatch((0, _publish.clearFile)());
|
|
dispatch((0, _publish.updateError)('file', value));
|
|
}
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 40 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _channel = __webpack_require__(19);
|
|
|
|
var _view = __webpack_require__(115);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
var _publish = __webpack_require__(5);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapDispatchToProps = function mapDispatchToProps(dispatch) {
|
|
return {
|
|
onChannelLogin: function onChannelLogin(name, shortId, longId) {
|
|
dispatch((0, _channel.updateLoggedInChannel)(name, shortId, longId));
|
|
dispatch((0, _publish.updateSelectedChannel)(name));
|
|
}
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(null, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 41 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _channel = __webpack_require__(19);
|
|
|
|
var _view = __webpack_require__(116);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
var _publish = __webpack_require__(5);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapDispatchToProps = function mapDispatchToProps(dispatch) {
|
|
return {
|
|
onChannelLogin: function onChannelLogin(name, shortId, longId) {
|
|
dispatch((0, _channel.updateLoggedInChannel)(name, shortId, longId));
|
|
dispatch((0, _publish.updateSelectedChannel)(name));
|
|
}
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(null, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 42 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var CHANNEL = exports.CHANNEL = 'CHANNEL';
|
|
var ASSET_LITE = exports.ASSET_LITE = 'ASSET_LITE';
|
|
var ASSET_DETAILS = exports.ASSET_DETAILS = 'ASSET_DETAILS';
|
|
|
|
/***/ }),
|
|
/* 43 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _view = __webpack_require__(129);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
var _show = __webpack_require__(7);
|
|
|
|
var _show2 = __webpack_require__(13);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var show = _ref.show;
|
|
|
|
// select error and status
|
|
var error = show.displayAsset.error;
|
|
var status = show.displayAsset.status;
|
|
// select asset
|
|
var asset = (0, _show2.selectAsset)(show);
|
|
// return props
|
|
return {
|
|
error: error,
|
|
status: status,
|
|
asset: asset
|
|
};
|
|
};
|
|
|
|
var mapDispatchToProps = function mapDispatchToProps(dispatch) {
|
|
return {
|
|
onFileRequest: function onFileRequest(name, claimId) {
|
|
dispatch((0, _show.fileRequested)(name, claimId));
|
|
}
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 44 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
module.exports = function (helmet, html, preloadedState) {
|
|
// take the html and preloadedState and return the full page
|
|
return '\n <!DOCTYPE html>\n <html lang="en" prefix="og: http://ogp.me/ns# fb: http://ogp.me/ns/fb#">\n <head>\n <meta charset="UTF-8">\n <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1, user-scalable=no">\n <meta http-equiv="X-UA-Compatible" content="ie=edge">\n <!--helmet-->\n ' + helmet.title.toString() + '\n ' + helmet.meta.toString() + '\n ' + helmet.link.toString() + '\n <!--style sheets-->\n <link rel="stylesheet" href="/assets/css/reset.css" type="text/css">\n <link rel="stylesheet" href="/assets/css/general.css" type="text/css">\n <link rel="stylesheet" href="/assets/css/mediaQueries.css" type="text/css">\n <!--google font-->\n <link href="https://fonts.googleapis.com/css?family=Roboto:300" rel="stylesheet">\n </head>\n <body id="main-body">\n <div class="row row--tall flex-container--column">\n <div id="react-app" class="row row--tall flex-container--column">' + html + '</div>\n </div>\n <script>\n window.__PRELOADED_STATE__ = ' + JSON.stringify(preloadedState).replace(/</g, '\\<') + '\n </script>\n <script src="/bundle/bundle.js"></script>\n </body>\n </html>\n ';
|
|
};
|
|
|
|
/***/ }),
|
|
/* 45 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
__webpack_require__(46);
|
|
__webpack_require__(47);
|
|
module.exports = __webpack_require__(48);
|
|
|
|
|
|
/***/ }),
|
|
/* 46 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("babel-polyfill");
|
|
|
|
/***/ }),
|
|
/* 47 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("whatwg-fetch");
|
|
|
|
/***/ }),
|
|
/* 48 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
// app dependencies
|
|
var express = __webpack_require__(49);
|
|
var bodyParser = __webpack_require__(50);
|
|
var expressHandlebars = __webpack_require__(51);
|
|
var Handlebars = __webpack_require__(52);
|
|
var helmet = __webpack_require__(53);
|
|
var passport = __webpack_require__(22);
|
|
|
|
var _require = __webpack_require__(54),
|
|
populateLocalsDotUser = _require.populateLocalsDotUser,
|
|
serializeSpeechUser = _require.serializeSpeechUser,
|
|
deserializeSpeechUser = _require.deserializeSpeechUser;
|
|
|
|
var cookieSession = __webpack_require__(55);
|
|
var http = __webpack_require__(56);
|
|
// logging dependencies
|
|
var logger = __webpack_require__(2);
|
|
|
|
function SpeechServer(_ref) {
|
|
var _this = this;
|
|
|
|
var mysqlConfig = _ref.mysqlConfig,
|
|
siteConfig = _ref.siteConfig,
|
|
slackConfig = _ref.slackConfig;
|
|
|
|
this.PORT = 3000;
|
|
this.speak = function (something) {
|
|
console.log(something);
|
|
};
|
|
this.start = function () {
|
|
_this.configureConfigFiles();
|
|
_this.configureLogging();
|
|
_this.configureApp();
|
|
_this.configureServer();
|
|
_this.startServer();
|
|
};
|
|
this.configureConfigFiles = function () {
|
|
var mysqlAppConfig = __webpack_require__(23);
|
|
mysqlAppConfig.configure(mysqlConfig);
|
|
var slackAppConfig = __webpack_require__(24);
|
|
slackAppConfig.configure(slackConfig);
|
|
// print the config variables
|
|
console.log('configured config files');
|
|
__webpack_require__(57)(mysqlAppConfig);
|
|
__webpack_require__(57)(slackAppConfig);
|
|
};
|
|
this.configureLogging = function () {
|
|
__webpack_require__(58)(logger);
|
|
__webpack_require__(60)(logger);
|
|
};
|
|
this.configureApp = function () {
|
|
var app = express(); // create an Express application
|
|
|
|
// trust the proxy to get ip address for us
|
|
app.enable('trust proxy');
|
|
|
|
// add middleware
|
|
app.use(helmet()); // set HTTP headers to protect against well-known web vulnerabilties
|
|
app.use(express.static(__dirname + '/public')); // 'express.static' to serve static files from public directory
|
|
app.use(bodyParser.json()); // 'body parser' for parsing application/json
|
|
app.use(bodyParser.urlencoded({ extended: true })); // 'body parser' for parsing application/x-www-form-urlencoded
|
|
app.use(function (req, res, next) {
|
|
// custom logging middleware to log all incoming http requests
|
|
logger.verbose('Request on ' + req.originalUrl + ' from ' + req.ip);
|
|
next();
|
|
});
|
|
|
|
// configure passport
|
|
passport.serializeUser(serializeSpeechUser);
|
|
passport.deserializeUser(deserializeSpeechUser);
|
|
var localSignupStrategy = __webpack_require__(62);
|
|
var localLoginStrategy = __webpack_require__(66);
|
|
passport.use('local-signup', localSignupStrategy);
|
|
passport.use('local-login', localLoginStrategy);
|
|
// initialize passport
|
|
app.use(cookieSession({
|
|
name: 'session',
|
|
keys: [siteConfig.session.sessionKey],
|
|
maxAge: 24 * 60 * 60 * 1000 // i.e. 24 hours
|
|
}));
|
|
app.use(passport.initialize());
|
|
app.use(passport.session());
|
|
|
|
// configure handlebars & register it with express app
|
|
var hbs = expressHandlebars.create({
|
|
defaultLayout: 'embed',
|
|
handlebars: Handlebars
|
|
});
|
|
app.engine('handlebars', hbs.engine);
|
|
app.set('view engine', 'handlebars');
|
|
|
|
// middleware to pass user info back to client (for handlebars access), if user is logged in
|
|
app.use(populateLocalsDotUser); // note: I don't think I need this any more?
|
|
|
|
// set the routes on the app
|
|
__webpack_require__(67)(app);
|
|
__webpack_require__(68)(app);
|
|
__webpack_require__(82)(app);
|
|
__webpack_require__(142)(app);
|
|
__webpack_require__(153)(app);
|
|
|
|
_this.app = app;
|
|
};
|
|
this.configureServer = function () {
|
|
_this.server = http.Server(_this.app);
|
|
};
|
|
this.startServer = function () {
|
|
var db = __webpack_require__(11);
|
|
// sync sequelize
|
|
db.sequelize.sync()
|
|
// start the server
|
|
.then(function () {
|
|
_this.server.listen(_this.PORT, function () {
|
|
logger.info('Server is listening on PORT ' + _this.PORT);
|
|
});
|
|
}).catch(function (error) {
|
|
logger.error('Startup Error:', error);
|
|
});
|
|
};
|
|
};
|
|
|
|
module.exports = SpeechServer;
|
|
|
|
/***/ }),
|
|
/* 49 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("express");
|
|
|
|
/***/ }),
|
|
/* 50 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("body-parser");
|
|
|
|
/***/ }),
|
|
/* 51 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("express-handlebars");
|
|
|
|
/***/ }),
|
|
/* 52 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("handlebars");
|
|
|
|
/***/ }),
|
|
/* 53 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("helmet");
|
|
|
|
/***/ }),
|
|
/* 54 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var logger = __webpack_require__(2);
|
|
|
|
module.exports = {
|
|
populateLocalsDotUser: function populateLocalsDotUser(req, res, next) {
|
|
if (req.user) {
|
|
logger.debug('populating res.locals.user');
|
|
res.locals.user = {
|
|
id: req.user.id,
|
|
userName: req.user.userName,
|
|
channelName: req.user.channelName,
|
|
channelClaimId: req.user.channelClaimId,
|
|
shortChannelId: req.user.shortChannelId
|
|
};
|
|
}
|
|
next();
|
|
},
|
|
serializeSpeechUser: function serializeSpeechUser(user, done) {
|
|
// returns user data to be serialized into session
|
|
logger.debug('serializing user');
|
|
done(null, user);
|
|
},
|
|
deserializeSpeechUser: function deserializeSpeechUser(user, done) {
|
|
// deserializes session and populates additional info to req.user
|
|
logger.debug('deserializing user');
|
|
done(null, user);
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 55 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("cookie-session");
|
|
|
|
/***/ }),
|
|
/* 56 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("http");
|
|
|
|
/***/ }),
|
|
/* 57 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var logger = __webpack_require__(2);
|
|
|
|
module.exports = function (config) {
|
|
// get the config file
|
|
for (var configCategoryKey in config) {
|
|
if (config.hasOwnProperty(configCategoryKey)) {
|
|
// get the final variables for each config category
|
|
var configVariables = config[configCategoryKey];
|
|
for (var configVarKey in configVariables) {
|
|
if (configVariables.hasOwnProperty(configVarKey)) {
|
|
// print each variable
|
|
logger.debug('CONFIG CHECK: ' + configCategoryKey + '.' + configVarKey + ' === ' + configVariables[configVarKey]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 58 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _require = __webpack_require__(59),
|
|
logLevel = _require.logLevel;
|
|
|
|
module.exports = function (winston) {
|
|
// configure
|
|
winston.configure({
|
|
transports: [new winston.transports.Console({
|
|
level: logLevel,
|
|
timestamp: false,
|
|
colorize: true,
|
|
prettyPrint: true,
|
|
handleExceptions: true,
|
|
humanReadableUnhandledException: true
|
|
})]
|
|
});
|
|
// test all the log levels
|
|
winston.error('Level 0');
|
|
winston.warn('Level 1');
|
|
winston.info('Level 2');
|
|
winston.verbose('Level 3');
|
|
winston.debug('Level 4');
|
|
winston.silly('Level 5');
|
|
};
|
|
|
|
/***/ }),
|
|
/* 59 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var loggerConfig = {
|
|
logLevel: 'debug' // options: silly, debug, verbose, info
|
|
};
|
|
|
|
module.exports = loggerConfig;
|
|
|
|
/***/ }),
|
|
/* 60 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var winstonSlackWebHook = __webpack_require__(61).SlackWebHook;
|
|
var slackConfig = __webpack_require__(24);
|
|
|
|
module.exports = function (winston) {
|
|
var slackWebHook = slackConfig.slackWebHook,
|
|
slackErrorChannel = slackConfig.slackErrorChannel,
|
|
slackInfoChannel = slackConfig.slackInfoChannel;
|
|
|
|
if (slackWebHook) {
|
|
// add a transport for errors to slack
|
|
if (slackErrorChannel) {
|
|
winston.add(winstonSlackWebHook, {
|
|
name: 'slack-errors-transport',
|
|
level: 'warn',
|
|
webhookUrl: slackWebHook,
|
|
channel: slackErrorChannel,
|
|
username: 'spee.ch',
|
|
iconEmoji: ':face_with_head_bandage:'
|
|
});
|
|
};
|
|
if (slackInfoChannel) {
|
|
winston.add(winstonSlackWebHook, {
|
|
name: 'slack-info-transport',
|
|
level: 'info',
|
|
webhookUrl: slackWebHook,
|
|
channel: slackInfoChannel,
|
|
username: 'spee.ch',
|
|
iconEmoji: ':nerd_face:'
|
|
});
|
|
};
|
|
// send test message
|
|
winston.error('Slack "error" logging is online.');
|
|
winston.info('Slack "info" logging is online.');
|
|
} else {
|
|
winston.warn('Slack logging is not enabled because no slackWebHook config var provided.');
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 61 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("winston-slack-webhook");
|
|
|
|
/***/ }),
|
|
/* 62 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
|
|
|
|
var PassportLocalStrategy = __webpack_require__(25).Strategy;
|
|
var lbryApi = __webpack_require__(16);
|
|
var logger = __webpack_require__(2);
|
|
|
|
module.exports = function (db) {
|
|
return new PassportLocalStrategy({
|
|
usernameField: 'username',
|
|
passwordField: 'password'
|
|
}, function (username, password, done) {
|
|
logger.verbose('new channel signup request. user: ' + username + ' pass: ' + password + ' .');
|
|
var userInfo = {};
|
|
// server-side validaton of inputs (username, password)
|
|
|
|
// create the channel and retrieve the metadata
|
|
return lbryApi.createChannel('@' + username).then(function (tx) {
|
|
// create user record
|
|
var userData = {
|
|
userName: username,
|
|
password: password
|
|
};
|
|
logger.verbose('userData >', userData);
|
|
// create user record
|
|
var channelData = {
|
|
channelName: '@' + username,
|
|
channelClaimId: tx.claim_id
|
|
};
|
|
logger.verbose('channelData >', channelData);
|
|
// create certificate record
|
|
var certificateData = {
|
|
claimId: tx.claim_id,
|
|
name: '@' + username
|
|
// address,
|
|
};
|
|
logger.verbose('certificateData >', certificateData);
|
|
// save user and certificate to db
|
|
return Promise.all([db.User.create(userData), db.Channel.create(channelData), db.Certificate.create(certificateData)]);
|
|
}).then(function (_ref) {
|
|
var _ref2 = _slicedToArray(_ref, 3),
|
|
newUser = _ref2[0],
|
|
newChannel = _ref2[1],
|
|
newCertificate = _ref2[2];
|
|
|
|
logger.verbose('user and certificate successfully created');
|
|
// store the relevant newUser info to be passed back for req.User
|
|
userInfo['id'] = newUser.id;
|
|
userInfo['userName'] = newUser.userName;
|
|
userInfo['channelName'] = newChannel.channelName;
|
|
userInfo['channelClaimId'] = newChannel.channelClaimId;
|
|
// associate the instances
|
|
return Promise.all([newCertificate.setChannel(newChannel), newChannel.setUser(newUser)]);
|
|
}).then(function () {
|
|
logger.verbose('user and certificate successfully associated');
|
|
return db.Certificate.getShortChannelIdFromLongChannelId(userInfo.channelClaimId, userInfo.channelName);
|
|
}).then(function (shortChannelId) {
|
|
userInfo['shortChannelId'] = shortChannelId;
|
|
return done(null, userInfo);
|
|
}).catch(function (error) {
|
|
logger.error('signup error', error);
|
|
return done(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
/***/ }),
|
|
/* 63 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("axios");
|
|
|
|
/***/ }),
|
|
/* 64 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var lbryConfig = {
|
|
api: {
|
|
apiHost: 'localhost',
|
|
apiPort: '5279'
|
|
}
|
|
};
|
|
|
|
module.exports = lbryConfig;
|
|
|
|
/***/ }),
|
|
/* 65 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("universal-analytics");
|
|
|
|
/***/ }),
|
|
/* 66 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var PassportLocalStrategy = __webpack_require__(25).Strategy;
|
|
var logger = __webpack_require__(2);
|
|
|
|
module.exports = function (db) {
|
|
var returnUserAndChannelInfo = function returnUserAndChannelInfo(userInstance) {
|
|
return new Promise(function (resolve, reject) {
|
|
var userInfo = {};
|
|
userInfo['id'] = userInstance.id;
|
|
userInfo['userName'] = userInstance.userName;
|
|
userInstance.getChannel().then(function (_ref) {
|
|
var channelName = _ref.channelName,
|
|
channelClaimId = _ref.channelClaimId;
|
|
|
|
userInfo['channelName'] = channelName;
|
|
userInfo['channelClaimId'] = channelClaimId;
|
|
return db.Certificate.getShortChannelIdFromLongChannelId(channelClaimId, channelName);
|
|
}).then(function (shortChannelId) {
|
|
userInfo['shortChannelId'] = shortChannelId;
|
|
resolve(userInfo);
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
return new PassportLocalStrategy({
|
|
usernameField: 'username',
|
|
passwordField: 'password'
|
|
}, function (username, password, done) {
|
|
return db.User.findOne({
|
|
where: { userName: username }
|
|
}).then(function (user) {
|
|
if (!user) {
|
|
logger.debug('no user found');
|
|
return done(null, false, { message: 'Incorrect username or password' });
|
|
}
|
|
return user.comparePassword(password).then(function (isMatch) {
|
|
if (!isMatch) {
|
|
logger.debug('incorrect password');
|
|
return done(null, false, { message: 'Incorrect username or password' });
|
|
}
|
|
logger.debug('Password was a match, returning User');
|
|
return returnUserAndChannelInfo(user).then(function (userInfo) {
|
|
return done(null, userInfo);
|
|
}).catch(function (error) {
|
|
return error;
|
|
});
|
|
}).catch(function (error) {
|
|
return error;
|
|
});
|
|
}).catch(function (error) {
|
|
return done(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
/***/ }),
|
|
/* 67 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var logger = __webpack_require__(2);
|
|
var passport = __webpack_require__(22);
|
|
|
|
module.exports = function (app) {
|
|
// route for sign up
|
|
app.post('/signup', passport.authenticate('local-signup'), function (req, res) {
|
|
logger.verbose('successful signup for ' + req.user.channelName);
|
|
res.status(200).json({
|
|
success: true,
|
|
channelName: req.user.channelName,
|
|
channelClaimId: req.user.channelClaimId,
|
|
shortChannelId: req.user.shortChannelId
|
|
});
|
|
});
|
|
// route for log in
|
|
app.post('/login', function (req, res, next) {
|
|
passport.authenticate('local-login', function (err, user, info) {
|
|
logger.debug('info:', info);
|
|
if (err) {
|
|
return next(err);
|
|
}
|
|
if (!user) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
message: info.message
|
|
});
|
|
}
|
|
logger.debug('successful login');
|
|
req.logIn(user, function (err) {
|
|
if (err) {
|
|
return next(err);
|
|
}
|
|
return res.status(200).json({
|
|
success: true,
|
|
channelName: req.user.channelName,
|
|
channelClaimId: req.user.channelClaimId,
|
|
shortChannelId: req.user.shortChannelId
|
|
});
|
|
});
|
|
})(req, res, next);
|
|
});
|
|
// route to log out
|
|
app.get('/logout', function (req, res) {
|
|
req.logout();
|
|
res.status(200).json({ success: true, message: 'you successfully logged out' });
|
|
});
|
|
// see if user is authenticated, and return credentials if so
|
|
app.get('/user', function (req, res) {
|
|
if (req.user) {
|
|
res.status(200).json({ success: true, data: req.user });
|
|
} else {
|
|
res.status(401).json({ success: false, message: 'user is not logged in' });
|
|
}
|
|
});
|
|
};
|
|
|
|
/***/ }),
|
|
/* 68 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
|
|
|
|
var logger = __webpack_require__(2);
|
|
var multipart = __webpack_require__(69);
|
|
|
|
var _require = __webpack_require__(3),
|
|
files = _require.files,
|
|
site = _require.site;
|
|
|
|
var multipartMiddleware = multipart({ uploadDir: files.uploadDirectory });
|
|
var db = __webpack_require__(11);
|
|
|
|
var _require2 = __webpack_require__(78),
|
|
claimNameIsAvailable = _require2.claimNameIsAvailable,
|
|
checkChannelAvailability = _require2.checkChannelAvailability,
|
|
publish = _require2.publish;
|
|
|
|
var _require3 = __webpack_require__(16),
|
|
getClaimList = _require3.getClaimList,
|
|
resolveUri = _require3.resolveUri,
|
|
getClaim = _require3.getClaim;
|
|
|
|
var _require4 = __webpack_require__(27),
|
|
addGetResultsToFileData = _require4.addGetResultsToFileData,
|
|
createBasicPublishParams = _require4.createBasicPublishParams,
|
|
createThumbnailPublishParams = _require4.createThumbnailPublishParams,
|
|
parsePublishApiRequestBody = _require4.parsePublishApiRequestBody,
|
|
parsePublishApiRequestFiles = _require4.parsePublishApiRequestFiles,
|
|
createFileData = _require4.createFileData;
|
|
|
|
var errorHandlers = __webpack_require__(28);
|
|
|
|
var _require5 = __webpack_require__(17),
|
|
sendGATimingEvent = _require5.sendGATimingEvent;
|
|
|
|
var _require6 = __webpack_require__(80),
|
|
authenticateUser = _require6.authenticateUser;
|
|
|
|
var _require7 = __webpack_require__(29),
|
|
getChannelData = _require7.getChannelData,
|
|
getChannelClaims = _require7.getChannelClaims,
|
|
getClaimId = _require7.getClaimId;
|
|
|
|
var NO_CHANNEL = 'NO_CHANNEL';
|
|
var NO_CLAIM = 'NO_CLAIM';
|
|
|
|
module.exports = function (app) {
|
|
// route to check whether site has published to a channel
|
|
app.get('/api/channel/availability/:name', function (_ref, res) {
|
|
var ip = _ref.ip,
|
|
originalUrl = _ref.originalUrl,
|
|
params = _ref.params;
|
|
|
|
checkChannelAvailability(params.name).then(function (result) {
|
|
if (result === true) {
|
|
res.status(200).json(true);
|
|
} else {
|
|
res.status(200).json(false);
|
|
}
|
|
}).catch(function (error) {
|
|
errorHandlers.handleErrorResponse(originalUrl, ip, error, res);
|
|
});
|
|
});
|
|
// route to get a short channel id from long channel Id
|
|
app.get('/api/channel/short-id/:longId/:name', function (_ref2, res) {
|
|
var ip = _ref2.ip,
|
|
originalUrl = _ref2.originalUrl,
|
|
params = _ref2.params;
|
|
|
|
db.Certificate.getShortChannelIdFromLongChannelId(params.longId, params.name).then(function (shortId) {
|
|
res.status(200).json(shortId);
|
|
}).catch(function (error) {
|
|
errorHandlers.handleErrorResponse(originalUrl, ip, error, res);
|
|
});
|
|
});
|
|
app.get('/api/channel/data/:channelName/:channelClaimId', function (_ref3, res) {
|
|
var ip = _ref3.ip,
|
|
originalUrl = _ref3.originalUrl,
|
|
body = _ref3.body,
|
|
params = _ref3.params;
|
|
|
|
var channelName = params.channelName;
|
|
var channelClaimId = params.channelClaimId;
|
|
if (channelClaimId === 'none') channelClaimId = null;
|
|
getChannelData(channelName, channelClaimId, 0).then(function (data) {
|
|
if (data === NO_CHANNEL) {
|
|
return res.status(404).json({ success: false, message: 'No matching channel was found' });
|
|
}
|
|
res.status(200).json({ success: true, data: data });
|
|
}).catch(function (error) {
|
|
errorHandlers.handleErrorResponse(originalUrl, ip, error, res);
|
|
});
|
|
});
|
|
app.get('/api/channel/claims/:channelName/:channelClaimId/:page', function (_ref4, res) {
|
|
var ip = _ref4.ip,
|
|
originalUrl = _ref4.originalUrl,
|
|
body = _ref4.body,
|
|
params = _ref4.params;
|
|
|
|
var channelName = params.channelName;
|
|
var channelClaimId = params.channelClaimId;
|
|
if (channelClaimId === 'none') channelClaimId = null;
|
|
var page = params.page;
|
|
getChannelClaims(channelName, channelClaimId, page).then(function (data) {
|
|
if (data === NO_CHANNEL) {
|
|
return res.status(404).json({ success: false, message: 'No matching channel was found' });
|
|
}
|
|
res.status(200).json({ success: true, data: data });
|
|
}).catch(function (error) {
|
|
errorHandlers.handleErrorResponse(originalUrl, ip, error, res);
|
|
});
|
|
});
|
|
// route to run a claim_list request on the daemon
|
|
app.get('/api/claim/list/:name', function (_ref5, res) {
|
|
var ip = _ref5.ip,
|
|
originalUrl = _ref5.originalUrl,
|
|
params = _ref5.params;
|
|
|
|
getClaimList(params.name).then(function (claimsList) {
|
|
res.status(200).json(claimsList);
|
|
}).catch(function (error) {
|
|
errorHandlers.handleErrorResponse(originalUrl, ip, error, res);
|
|
});
|
|
});
|
|
// route to get an asset
|
|
app.get('/api/claim/get/:name/:claimId', function (_ref6, res) {
|
|
var ip = _ref6.ip,
|
|
originalUrl = _ref6.originalUrl,
|
|
params = _ref6.params;
|
|
|
|
var name = params.name;
|
|
var claimId = params.claimId;
|
|
// resolve the claim
|
|
db.Claim.resolveClaim(name, claimId).then(function (resolveResult) {
|
|
// make sure a claim actually exists at that uri
|
|
if (!resolveResult) {
|
|
throw new Error('No matching uri found in Claim table');
|
|
}
|
|
var fileData = createFileData(resolveResult);
|
|
// get the claim
|
|
return Promise.all([fileData, getClaim(name + '#' + claimId)]);
|
|
}).then(function (_ref7) {
|
|
var _ref8 = _slicedToArray(_ref7, 2),
|
|
fileData = _ref8[0],
|
|
getResult = _ref8[1];
|
|
|
|
fileData = addGetResultsToFileData(fileData, getResult);
|
|
return Promise.all([db.upsert(db.File, fileData, { name: name, claimId: claimId }, 'File'), getResult]);
|
|
}).then(function (_ref9) {
|
|
var _ref10 = _slicedToArray(_ref9, 2),
|
|
fileRecord = _ref10[0],
|
|
_ref10$ = _ref10[1],
|
|
message = _ref10$.message,
|
|
completed = _ref10$.completed;
|
|
|
|
res.status(200).json({ success: true, message: message, completed: completed });
|
|
}).catch(function (error) {
|
|
errorHandlers.handleErrorResponse(originalUrl, ip, error, res);
|
|
});
|
|
});
|
|
// route to check whether this site published to a claim
|
|
app.get('/api/claim/availability/:name', function (_ref11, res) {
|
|
var ip = _ref11.ip,
|
|
originalUrl = _ref11.originalUrl,
|
|
params = _ref11.params;
|
|
|
|
claimNameIsAvailable(params.name).then(function (result) {
|
|
res.status(200).json(result);
|
|
}).catch(function (error) {
|
|
errorHandlers.handleErrorResponse(originalUrl, ip, error, res);
|
|
});
|
|
});
|
|
// route to run a resolve request on the daemon
|
|
app.get('/api/claim/resolve/:name/:claimId', function (_ref12, res) {
|
|
var headers = _ref12.headers,
|
|
ip = _ref12.ip,
|
|
originalUrl = _ref12.originalUrl,
|
|
params = _ref12.params;
|
|
|
|
resolveUri(params.name + '#' + params.claimId).then(function (resolvedUri) {
|
|
res.status(200).json(resolvedUri);
|
|
}).catch(function (error) {
|
|
errorHandlers.handleErrorResponse(originalUrl, ip, error, res);
|
|
});
|
|
});
|
|
// route to run a publish request on the daemon
|
|
app.post('/api/claim/publish', multipartMiddleware, function (_ref13, res) {
|
|
var body = _ref13.body,
|
|
files = _ref13.files,
|
|
headers = _ref13.headers,
|
|
ip = _ref13.ip,
|
|
originalUrl = _ref13.originalUrl,
|
|
user = _ref13.user;
|
|
|
|
logger.debug('api/claim/publish req.body:', body);
|
|
logger.debug('api/claim/publish req.files:', files);
|
|
// define variables
|
|
var channelName = void 0,
|
|
channelId = void 0,
|
|
channelPassword = void 0,
|
|
description = void 0,
|
|
fileName = void 0,
|
|
filePath = void 0,
|
|
fileType = void 0,
|
|
gaStartTime = void 0,
|
|
license = void 0,
|
|
name = void 0,
|
|
nsfw = void 0,
|
|
thumbnail = void 0,
|
|
thumbnailFileName = void 0,
|
|
thumbnailFilePath = void 0,
|
|
thumbnailFileType = void 0,
|
|
title = void 0;
|
|
// record the start time of the request
|
|
gaStartTime = Date.now();
|
|
// validate the body and files of the request
|
|
try {
|
|
var _parsePublishApiReque = parsePublishApiRequestBody(body);
|
|
// validateApiPublishRequest(body, files);
|
|
|
|
|
|
name = _parsePublishApiReque.name;
|
|
nsfw = _parsePublishApiReque.nsfw;
|
|
license = _parsePublishApiReque.license;
|
|
title = _parsePublishApiReque.title;
|
|
description = _parsePublishApiReque.description;
|
|
thumbnail = _parsePublishApiReque.thumbnail;
|
|
|
|
var _parsePublishApiReque2 = parsePublishApiRequestFiles(files);
|
|
|
|
fileName = _parsePublishApiReque2.fileName;
|
|
filePath = _parsePublishApiReque2.filePath;
|
|
fileType = _parsePublishApiReque2.fileType;
|
|
thumbnailFileName = _parsePublishApiReque2.thumbnailFileName;
|
|
thumbnailFilePath = _parsePublishApiReque2.thumbnailFilePath;
|
|
thumbnailFileType = _parsePublishApiReque2.thumbnailFileType;
|
|
channelName = body.channelName;
|
|
channelId = body.channelId;
|
|
channelPassword = body.channelPassword;
|
|
} catch (error) {
|
|
return res.status(400).json({ success: false, message: error.message });
|
|
}
|
|
// check channel authorization
|
|
Promise.all([authenticateUser(channelName, channelId, channelPassword, user), claimNameIsAvailable(name), createBasicPublishParams(filePath, name, title, description, license, nsfw, thumbnail), createThumbnailPublishParams(thumbnailFilePath, name, license, nsfw)]).then(function (_ref14) {
|
|
var _ref15 = _slicedToArray(_ref14, 4),
|
|
_ref15$ = _ref15[0],
|
|
channelName = _ref15$.channelName,
|
|
channelClaimId = _ref15$.channelClaimId,
|
|
validatedClaimName = _ref15[1],
|
|
publishParams = _ref15[2],
|
|
thumbnailPublishParams = _ref15[3];
|
|
|
|
// add channel details to the publish params
|
|
if (channelName && channelClaimId) {
|
|
publishParams['channel_name'] = channelName;
|
|
publishParams['channel_id'] = channelClaimId;
|
|
}
|
|
// publish the thumbnail
|
|
if (thumbnailPublishParams) {
|
|
publish(thumbnailPublishParams, thumbnailFileName, thumbnailFileType);
|
|
}
|
|
// publish the asset
|
|
return publish(publishParams, fileName, fileType);
|
|
}).then(function (result) {
|
|
res.status(200).json({
|
|
success: true,
|
|
message: 'publish completed successfully',
|
|
data: {
|
|
name: name,
|
|
claimId: result.claim_id,
|
|
url: site.host + '/' + result.claim_id + '/' + name,
|
|
lbryTx: result
|
|
}
|
|
});
|
|
// record the publish end time and send to google analytics
|
|
sendGATimingEvent('end-to-end', 'publish', fileType, gaStartTime, Date.now());
|
|
}).catch(function (error) {
|
|
errorHandlers.handleErrorResponse(originalUrl, ip, error, res);
|
|
});
|
|
});
|
|
// route to get a short claim id from long claim Id
|
|
app.get('/api/claim/short-id/:longId/:name', function (_ref16, res) {
|
|
var ip = _ref16.ip,
|
|
originalUrl = _ref16.originalUrl,
|
|
body = _ref16.body,
|
|
params = _ref16.params;
|
|
|
|
db.Claim.getShortClaimIdFromLongClaimId(params.longId, params.name).then(function (shortId) {
|
|
res.status(200).json({ success: true, data: shortId });
|
|
}).catch(function (error) {
|
|
errorHandlers.handleErrorResponse(originalUrl, ip, error, res);
|
|
});
|
|
});
|
|
app.post('/api/claim/long-id', function (_ref17, res) {
|
|
var ip = _ref17.ip,
|
|
originalUrl = _ref17.originalUrl,
|
|
body = _ref17.body,
|
|
params = _ref17.params;
|
|
|
|
logger.debug('body:', body);
|
|
var channelName = body.channelName;
|
|
var channelClaimId = body.channelClaimId;
|
|
var claimName = body.claimName;
|
|
var claimId = body.claimId;
|
|
getClaimId(channelName, channelClaimId, claimName, claimId).then(function (result) {
|
|
if (result === NO_CHANNEL) {
|
|
return res.status(404).json({ success: false, message: 'No matching channel could be found' });
|
|
}
|
|
if (result === NO_CLAIM) {
|
|
return res.status(404).json({ success: false, message: 'No matching claim id could be found' });
|
|
}
|
|
res.status(200).json({ success: true, data: result });
|
|
}).catch(function (error) {
|
|
errorHandlers.handleErrorResponse(originalUrl, ip, error, res);
|
|
});
|
|
});
|
|
app.get('/api/claim/data/:claimName/:claimId', function (_ref18, res) {
|
|
var ip = _ref18.ip,
|
|
originalUrl = _ref18.originalUrl,
|
|
body = _ref18.body,
|
|
params = _ref18.params;
|
|
|
|
var claimName = params.claimName;
|
|
var claimId = params.claimId;
|
|
if (claimId === 'none') claimId = null;
|
|
db.Claim.resolveClaim(claimName, claimId).then(function (claimInfo) {
|
|
if (!claimInfo) {
|
|
return res.status(404).json({ success: false, message: 'No claim could be found' });
|
|
}
|
|
res.status(200).json({ success: true, data: claimInfo });
|
|
}).catch(function (error) {
|
|
errorHandlers.handleErrorResponse(originalUrl, ip, error, res);
|
|
});
|
|
});
|
|
// route to see if asset is available locally
|
|
app.get('/api/file/availability/:name/:claimId', function (_ref19, res) {
|
|
var ip = _ref19.ip,
|
|
originalUrl = _ref19.originalUrl,
|
|
params = _ref19.params;
|
|
|
|
var name = params.name;
|
|
var claimId = params.claimId;
|
|
db.File.findOne({ where: { name: name, claimId: claimId } }).then(function (result) {
|
|
if (result) {
|
|
return res.status(200).json({ success: true, data: true });
|
|
}
|
|
res.status(200).json({ success: true, data: false });
|
|
}).catch(function (error) {
|
|
errorHandlers.handleErrorResponse(originalUrl, ip, error, res);
|
|
});
|
|
});
|
|
};
|
|
|
|
/***/ }),
|
|
/* 69 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("connect-multiparty");
|
|
|
|
/***/ }),
|
|
/* 70 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("sequelize");
|
|
|
|
/***/ }),
|
|
/* 71 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var logger = __webpack_require__(2);
|
|
|
|
var _require = __webpack_require__(26),
|
|
returnShortId = _require.returnShortId;
|
|
|
|
module.exports = function (sequelize, _ref) {
|
|
var STRING = _ref.STRING,
|
|
BOOLEAN = _ref.BOOLEAN,
|
|
INTEGER = _ref.INTEGER,
|
|
TEXT = _ref.TEXT,
|
|
DECIMAL = _ref.DECIMAL;
|
|
|
|
var Certificate = sequelize.define('Certificate', {
|
|
address: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
amount: {
|
|
type: DECIMAL(19, 8),
|
|
default: null
|
|
},
|
|
claimId: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
claimSequence: {
|
|
type: INTEGER,
|
|
default: null
|
|
},
|
|
decodedClaim: {
|
|
type: BOOLEAN,
|
|
default: null
|
|
},
|
|
depth: {
|
|
type: INTEGER,
|
|
default: null
|
|
},
|
|
effectiveAmount: {
|
|
type: DECIMAL(19, 8),
|
|
default: null
|
|
},
|
|
hasSignature: {
|
|
type: BOOLEAN,
|
|
default: null
|
|
},
|
|
height: {
|
|
type: INTEGER,
|
|
default: null
|
|
},
|
|
hex: {
|
|
type: TEXT('long'),
|
|
default: null
|
|
},
|
|
name: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
nout: {
|
|
type: INTEGER,
|
|
default: null
|
|
},
|
|
txid: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
validAtHeight: {
|
|
type: INTEGER,
|
|
default: null
|
|
},
|
|
outpoint: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
valueVersion: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
claimType: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
certificateVersion: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
keyType: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
publicKey: {
|
|
type: TEXT('long'),
|
|
default: null
|
|
}
|
|
}, {
|
|
freezeTableName: true
|
|
});
|
|
|
|
Certificate.associate = function (db) {
|
|
Certificate.belongsTo(db.Channel, {
|
|
foreignKey: {
|
|
allowNull: true
|
|
}
|
|
});
|
|
};
|
|
|
|
Certificate.getShortChannelIdFromLongChannelId = function (longChannelId, channelName) {
|
|
var _this = this;
|
|
|
|
logger.debug('getShortChannelIdFromLongChannelId ' + channelName + ':' + longChannelId);
|
|
return new Promise(function (resolve, reject) {
|
|
_this.findAll({
|
|
where: { name: channelName },
|
|
order: [['height', 'ASC']]
|
|
}).then(function (result) {
|
|
switch (result.length) {
|
|
case 0:
|
|
throw new Error('No channel(s) found with that channel name');
|
|
default:
|
|
return resolve(returnShortId(result, longChannelId));
|
|
}
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
Certificate.getLongChannelIdFromShortChannelId = function (channelName, channelClaimId) {
|
|
var _this2 = this;
|
|
|
|
logger.debug('getLongChannelIdFromShortChannelId(' + channelName + ', ' + channelClaimId + ')');
|
|
return new Promise(function (resolve, reject) {
|
|
_this2.findAll({
|
|
where: {
|
|
name: channelName,
|
|
claimId: {
|
|
$like: channelClaimId + '%'
|
|
}
|
|
},
|
|
order: [['height', 'ASC']]
|
|
}).then(function (result) {
|
|
switch (result.length) {
|
|
case 0:
|
|
return resolve(null);
|
|
default:
|
|
// note results must be sorted
|
|
return resolve(result[0].claimId);
|
|
}
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
Certificate.getLongChannelIdFromChannelName = function (channelName) {
|
|
var _this3 = this;
|
|
|
|
logger.debug('getLongChannelIdFromChannelName(' + channelName + ')');
|
|
return new Promise(function (resolve, reject) {
|
|
_this3.findAll({
|
|
where: { name: channelName },
|
|
order: [['effectiveAmount', 'DESC'], ['height', 'ASC']]
|
|
}).then(function (result) {
|
|
switch (result.length) {
|
|
case 0:
|
|
return resolve(null);
|
|
default:
|
|
return resolve(result[0].claimId);
|
|
}
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
Certificate.validateLongChannelId = function (name, claimId) {
|
|
var _this4 = this;
|
|
|
|
logger.debug('validateLongChannelId(' + name + ', ' + claimId + ')');
|
|
return new Promise(function (resolve, reject) {
|
|
_this4.findOne({
|
|
where: { name: name, claimId: claimId }
|
|
}).then(function (result) {
|
|
if (!result) {
|
|
return resolve(null);
|
|
};
|
|
resolve(claimId);
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
Certificate.getLongChannelId = function (channelName, channelClaimId) {
|
|
logger.debug('getLongChannelId(' + channelName + ', ' + channelClaimId + ')');
|
|
if (channelClaimId && channelClaimId.length === 40) {
|
|
// if a full channel id is provided
|
|
return this.validateLongChannelId(channelName, channelClaimId);
|
|
} else if (channelClaimId && channelClaimId.length < 40) {
|
|
// if a short channel id is provided
|
|
return this.getLongChannelIdFromShortChannelId(channelName, channelClaimId);
|
|
} else {
|
|
return this.getLongChannelIdFromChannelName(channelName); // if no channel id provided
|
|
}
|
|
};
|
|
|
|
return Certificate;
|
|
};
|
|
|
|
/***/ }),
|
|
/* 72 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
module.exports = function (sequelize, _ref) {
|
|
var STRING = _ref.STRING;
|
|
|
|
var Channel = sequelize.define('Channel', {
|
|
channelName: {
|
|
type: STRING,
|
|
allowNull: false
|
|
},
|
|
channelClaimId: {
|
|
type: STRING,
|
|
allowNull: false
|
|
}
|
|
}, {
|
|
freezeTableName: true
|
|
});
|
|
|
|
Channel.associate = function (db) {
|
|
Channel.belongsTo(db.User);
|
|
Channel.hasOne(db.Certificate);
|
|
};
|
|
|
|
return Channel;
|
|
};
|
|
|
|
/***/ }),
|
|
/* 73 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var logger = __webpack_require__(2);
|
|
|
|
var _require = __webpack_require__(26),
|
|
returnShortId = _require.returnShortId;
|
|
|
|
var _require2 = __webpack_require__(3),
|
|
claim = _require2.claim,
|
|
site = _require2.site;
|
|
|
|
var defaultThumbnail = claim.defaultThumbnail;
|
|
|
|
|
|
function determineFileExtensionFromContentType(contentType) {
|
|
switch (contentType) {
|
|
case 'image/jpeg':
|
|
case 'image/jpg':
|
|
return 'jpeg';
|
|
case 'image/png':
|
|
return 'png';
|
|
case 'image/gif':
|
|
return 'gif';
|
|
case 'video/mp4':
|
|
return 'mp4';
|
|
default:
|
|
logger.debug('setting unknown file type as file extension jpeg');
|
|
return 'jpeg';
|
|
}
|
|
};
|
|
|
|
function determineThumbnail(storedThumbnail, defaultThumbnail) {
|
|
if (storedThumbnail === '') {
|
|
return defaultThumbnail;
|
|
}
|
|
return storedThumbnail;
|
|
};
|
|
|
|
function prepareClaimData(claim) {
|
|
// logger.debug('preparing claim data based on resolved data:', claim);
|
|
claim['thumbnail'] = determineThumbnail(claim.thumbnail, defaultThumbnail);
|
|
claim['fileExt'] = determineFileExtensionFromContentType(claim.contentType);
|
|
claim['host'] = site.host;
|
|
return claim;
|
|
};
|
|
|
|
module.exports = function (sequelize, _ref) {
|
|
var STRING = _ref.STRING,
|
|
BOOLEAN = _ref.BOOLEAN,
|
|
INTEGER = _ref.INTEGER,
|
|
TEXT = _ref.TEXT,
|
|
DECIMAL = _ref.DECIMAL;
|
|
|
|
var Claim = sequelize.define('Claim', {
|
|
address: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
amount: {
|
|
type: DECIMAL(19, 8),
|
|
default: null
|
|
},
|
|
claimId: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
claimSequence: {
|
|
type: INTEGER,
|
|
default: null
|
|
},
|
|
decodedClaim: {
|
|
type: BOOLEAN,
|
|
default: null
|
|
},
|
|
depth: {
|
|
type: INTEGER,
|
|
default: null
|
|
},
|
|
effectiveAmount: {
|
|
type: DECIMAL(19, 8),
|
|
default: null
|
|
},
|
|
hasSignature: {
|
|
type: BOOLEAN,
|
|
default: null
|
|
},
|
|
height: {
|
|
type: INTEGER,
|
|
default: null
|
|
},
|
|
hex: {
|
|
type: TEXT('long'),
|
|
default: null
|
|
},
|
|
name: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
nout: {
|
|
type: INTEGER,
|
|
default: null
|
|
},
|
|
txid: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
validAtHeight: {
|
|
type: INTEGER,
|
|
default: null
|
|
},
|
|
outpoint: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
claimType: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
certificateId: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
author: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
description: {
|
|
type: TEXT('long'),
|
|
default: null
|
|
},
|
|
language: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
license: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
licenseUrl: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
nsfw: {
|
|
type: BOOLEAN,
|
|
default: null
|
|
},
|
|
preview: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
thumbnail: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
title: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
metadataVersion: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
contentType: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
source: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
sourceType: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
sourceVersion: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
streamVersion: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
valueVersion: {
|
|
type: STRING,
|
|
default: null
|
|
},
|
|
channelName: {
|
|
type: STRING,
|
|
allowNull: true,
|
|
default: null
|
|
}
|
|
}, {
|
|
freezeTableName: true
|
|
});
|
|
|
|
Claim.associate = function (db) {
|
|
Claim.belongsTo(db.File, {
|
|
foreignKey: {
|
|
allowNull: true
|
|
}
|
|
});
|
|
};
|
|
|
|
Claim.getShortClaimIdFromLongClaimId = function (claimId, claimName) {
|
|
var _this = this;
|
|
|
|
logger.debug('Claim.getShortClaimIdFromLongClaimId for ' + claimName + '#' + claimId);
|
|
return new Promise(function (resolve, reject) {
|
|
_this.findAll({
|
|
where: { name: claimName },
|
|
order: [['height', 'ASC']]
|
|
}).then(function (result) {
|
|
switch (result.length) {
|
|
case 0:
|
|
throw new Error('No claim(s) found with that claim name');
|
|
default:
|
|
resolve(returnShortId(result, claimId));
|
|
}
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
Claim.getAllChannelClaims = function (channelClaimId) {
|
|
var _this2 = this;
|
|
|
|
logger.debug('Claim.getAllChannelClaims for ' + channelClaimId);
|
|
return new Promise(function (resolve, reject) {
|
|
_this2.findAll({
|
|
where: { certificateId: channelClaimId },
|
|
order: [['height', 'ASC']],
|
|
raw: true // returns an array of only data, not an array of instances
|
|
}).then(function (channelClaimsArray) {
|
|
// logger.debug('channelclaimsarray length:', channelClaimsArray.length);
|
|
switch (channelClaimsArray.length) {
|
|
case 0:
|
|
return resolve(null);
|
|
default:
|
|
channelClaimsArray.forEach(function (claim) {
|
|
claim['fileExt'] = determineFileExtensionFromContentType(claim.contentType);
|
|
claim['thumbnail'] = determineThumbnail(claim.thumbnail, defaultThumbnail);
|
|
return claim;
|
|
});
|
|
return resolve(channelClaimsArray);
|
|
}
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
Claim.getClaimIdByLongChannelId = function (channelClaimId, claimName) {
|
|
var _this3 = this;
|
|
|
|
logger.debug('finding claim id for claim ' + claimName + ' from channel ' + channelClaimId);
|
|
return new Promise(function (resolve, reject) {
|
|
_this3.findAll({
|
|
where: { name: claimName, certificateId: channelClaimId },
|
|
order: [['id', 'ASC']]
|
|
}).then(function (result) {
|
|
switch (result.length) {
|
|
case 0:
|
|
return resolve(null);
|
|
case 1:
|
|
return resolve(result[0].claimId);
|
|
default:
|
|
logger.error(result.length + ' records found for "' + claimName + '" in channel "' + channelClaimId + '"');
|
|
return resolve(result[0].claimId);
|
|
}
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
Claim.getLongClaimIdFromShortClaimId = function (name, shortId) {
|
|
var _this4 = this;
|
|
|
|
return new Promise(function (resolve, reject) {
|
|
_this4.findAll({
|
|
where: {
|
|
name: name,
|
|
claimId: {
|
|
$like: shortId + '%'
|
|
} },
|
|
order: [['height', 'ASC']]
|
|
}).then(function (result) {
|
|
switch (result.length) {
|
|
case 0:
|
|
return resolve(null);
|
|
default:
|
|
// note results must be sorted
|
|
return resolve(result[0].claimId);
|
|
}
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
Claim.getTopFreeClaimIdByClaimName = function (name) {
|
|
var _this5 = this;
|
|
|
|
return new Promise(function (resolve, reject) {
|
|
_this5.findAll({
|
|
where: { name: name },
|
|
order: [['effectiveAmount', 'DESC'], ['height', 'ASC']] // note: maybe height and effective amount need to switch?
|
|
}).then(function (result) {
|
|
logger.debug('length of result', result.length);
|
|
switch (result.length) {
|
|
case 0:
|
|
return resolve(null);
|
|
default:
|
|
return resolve(result[0].dataValues.claimId);
|
|
}
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
Claim.validateLongClaimId = function (name, claimId) {
|
|
var _this6 = this;
|
|
|
|
return new Promise(function (resolve, reject) {
|
|
_this6.findOne({
|
|
where: { name: name, claimId: claimId }
|
|
}).then(function (result) {
|
|
if (!result) {
|
|
return resolve(null);
|
|
};
|
|
resolve(claimId);
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
Claim.getLongClaimId = function (claimName, claimId) {
|
|
logger.debug('getLongClaimId(' + claimName + ', ' + claimId + ')');
|
|
if (claimId && claimId.length === 40) {
|
|
// if a full claim id is provided
|
|
return this.validateLongClaimId(claimName, claimId);
|
|
} else if (claimId && claimId.length < 40) {
|
|
return this.getLongClaimIdFromShortClaimId(claimName, claimId); // if a short claim id is provided
|
|
} else {
|
|
return this.getTopFreeClaimIdByClaimName(claimName); // if no claim id is provided
|
|
}
|
|
};
|
|
|
|
Claim.resolveClaim = function (name, claimId) {
|
|
var _this7 = this;
|
|
|
|
logger.debug('Claim.resolveClaim: ' + name + ' ' + claimId);
|
|
return new Promise(function (resolve, reject) {
|
|
_this7.findAll({
|
|
where: { name: name, claimId: claimId }
|
|
}).then(function (claimArray) {
|
|
logger.debug('claims found on resolve:', claimArray.length);
|
|
switch (claimArray.length) {
|
|
case 0:
|
|
return resolve(null);
|
|
case 1:
|
|
return resolve(prepareClaimData(claimArray[0].dataValues));
|
|
default:
|
|
logger.error('more than one entry matches that name (' + name + ') and claimID (' + claimId + ')');
|
|
return resolve(prepareClaimData(claimArray[0].dataValues));
|
|
}
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
};
|
|
|
|
return Claim;
|
|
};
|
|
|
|
/***/ }),
|
|
/* 74 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
module.exports = function (sequelize, _ref) {
|
|
var STRING = _ref.STRING,
|
|
BOOLEAN = _ref.BOOLEAN,
|
|
INTEGER = _ref.INTEGER;
|
|
|
|
var File = sequelize.define('File', {
|
|
name: {
|
|
type: STRING,
|
|
allowNull: false
|
|
},
|
|
claimId: {
|
|
type: STRING,
|
|
allowNull: false
|
|
},
|
|
address: {
|
|
type: STRING,
|
|
allowNull: false
|
|
},
|
|
outpoint: {
|
|
type: STRING,
|
|
allowNull: false
|
|
},
|
|
height: {
|
|
type: INTEGER,
|
|
allowNull: false,
|
|
default: 0
|
|
},
|
|
fileName: {
|
|
type: STRING,
|
|
allowNull: false
|
|
},
|
|
filePath: {
|
|
type: STRING,
|
|
allowNull: false
|
|
},
|
|
fileType: {
|
|
type: STRING
|
|
},
|
|
nsfw: {
|
|
type: BOOLEAN,
|
|
allowNull: false,
|
|
defaultValue: false
|
|
},
|
|
trendingEligible: {
|
|
type: BOOLEAN,
|
|
allowNull: false,
|
|
defaultValue: true
|
|
}
|
|
}, {
|
|
freezeTableName: true
|
|
});
|
|
|
|
File.associate = function (db) {
|
|
File.hasMany(db.Request);
|
|
File.hasOne(db.Claim);
|
|
};
|
|
|
|
File.getRecentClaims = function () {
|
|
return this.findAll({
|
|
where: { nsfw: false, trendingEligible: true },
|
|
order: [['createdAt', 'DESC']],
|
|
limit: 25
|
|
});
|
|
};
|
|
|
|
return File;
|
|
};
|
|
|
|
/***/ }),
|
|
/* 75 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
module.exports = function (sequelize, _ref) {
|
|
var STRING = _ref.STRING,
|
|
BOOLEAN = _ref.BOOLEAN,
|
|
TEXT = _ref.TEXT;
|
|
|
|
var Request = sequelize.define('Request', {
|
|
action: {
|
|
type: STRING,
|
|
allowNull: false
|
|
},
|
|
url: {
|
|
type: STRING,
|
|
allowNull: false
|
|
},
|
|
ipAddress: {
|
|
type: STRING,
|
|
allowNull: true
|
|
},
|
|
result: {
|
|
type: TEXT('long'),
|
|
allowNull: true,
|
|
default: null
|
|
}
|
|
}, {
|
|
freezeTableName: true
|
|
});
|
|
|
|
Request.associate = function (db) {
|
|
Request.belongsTo(db.File, {
|
|
foreignKey: {
|
|
allowNull: true
|
|
}
|
|
});
|
|
};
|
|
|
|
return Request;
|
|
};
|
|
|
|
/***/ }),
|
|
/* 76 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var bcrypt = __webpack_require__(77);
|
|
var logger = __webpack_require__(2);
|
|
|
|
module.exports = function (sequelize, _ref) {
|
|
var STRING = _ref.STRING;
|
|
|
|
var User = sequelize.define('User', {
|
|
userName: {
|
|
type: STRING,
|
|
allowNull: false
|
|
},
|
|
password: {
|
|
type: STRING,
|
|
allowNull: false
|
|
}
|
|
}, {
|
|
freezeTableName: true
|
|
});
|
|
|
|
User.associate = function (db) {
|
|
User.hasOne(db.Channel);
|
|
};
|
|
|
|
User.prototype.comparePassword = function (password) {
|
|
return bcrypt.compare(password, this.password);
|
|
};
|
|
|
|
User.prototype.changePassword = function (newPassword) {
|
|
var _this = this;
|
|
|
|
return new Promise(function (resolve, reject) {
|
|
// generate a salt string to use for hashing
|
|
bcrypt.genSalt(function (saltError, salt) {
|
|
if (saltError) {
|
|
logger.error('salt error', saltError);
|
|
reject(saltError);
|
|
return;
|
|
}
|
|
// generate a hashed version of the user's password
|
|
bcrypt.hash(newPassword, salt, function (hashError, hash) {
|
|
// if there is an error with the hash generation return the error
|
|
if (hashError) {
|
|
logger.error('hash error', hashError);
|
|
reject(hashError);
|
|
return;
|
|
}
|
|
// replace the current password with the new hash
|
|
_this.update({ password: hash }).then(function () {
|
|
resolve();
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
// pre-save hook method to hash the user's password before the user's info is saved to the db.
|
|
User.hook('beforeCreate', function (user, options) {
|
|
logger.debug('User.beforeCreate hook...');
|
|
return new Promise(function (resolve, reject) {
|
|
// generate a salt string to use for hashing
|
|
bcrypt.genSalt(function (saltError, salt) {
|
|
if (saltError) {
|
|
logger.error('salt error', saltError);
|
|
reject(saltError);
|
|
return;
|
|
}
|
|
// generate a hashed version of the user's password
|
|
bcrypt.hash(user.password, salt, function (hashError, hash) {
|
|
// if there is an error with the hash generation return the error
|
|
if (hashError) {
|
|
logger.error('hash error', hashError);
|
|
reject(hashError);
|
|
return;
|
|
}
|
|
// replace the password string with the hash password value
|
|
user.password = hash;
|
|
resolve();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
return User;
|
|
};
|
|
|
|
/***/ }),
|
|
/* 77 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("bcrypt");
|
|
|
|
/***/ }),
|
|
/* 78 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
|
|
|
|
var logger = __webpack_require__(2);
|
|
var db = __webpack_require__(11);
|
|
var lbryApi = __webpack_require__(16);
|
|
var publishHelpers = __webpack_require__(27);
|
|
var config = __webpack_require__(3);
|
|
|
|
module.exports = {
|
|
publish: function publish(publishParams, fileName, fileType) {
|
|
return new Promise(function (resolve, reject) {
|
|
var publishResults = void 0,
|
|
certificateId = void 0,
|
|
channelName = void 0;
|
|
// publish the file
|
|
return lbryApi.publishClaim(publishParams).then(function (tx) {
|
|
logger.info('Successfully published ' + publishParams.name + ' ' + fileName, tx);
|
|
publishResults = tx;
|
|
// get the channel information
|
|
if (publishParams.channel_name) {
|
|
logger.debug('this claim was published in channel: ' + publishParams.channel_name);
|
|
return db.Channel.findOne({ where: { channelName: publishParams.channel_name } });
|
|
} else {
|
|
logger.debug('this claim was not published in a channel');
|
|
return null;
|
|
}
|
|
}).then(function (channel) {
|
|
// set channel information
|
|
certificateId = null;
|
|
channelName = null;
|
|
if (channel) {
|
|
certificateId = channel.channelClaimId;
|
|
channelName = channel.channelName;
|
|
}
|
|
logger.debug('certificateId: ' + certificateId);
|
|
}).then(function () {
|
|
// create the File record
|
|
var fileRecord = {
|
|
name: publishParams.name,
|
|
claimId: publishResults.claim_id,
|
|
title: publishParams.metadata.title,
|
|
description: publishParams.metadata.description,
|
|
address: publishParams.claim_address,
|
|
outpoint: publishResults.txid + ':' + publishResults.nout,
|
|
height: 0,
|
|
fileName: fileName,
|
|
filePath: publishParams.file_path,
|
|
fileType: fileType,
|
|
nsfw: publishParams.metadata.nsfw
|
|
};
|
|
// create the Claim record
|
|
var claimRecord = {
|
|
name: publishParams.name,
|
|
claimId: publishResults.claim_id,
|
|
title: publishParams.metadata.title,
|
|
description: publishParams.metadata.description,
|
|
address: publishParams.claim_address,
|
|
thumbnail: publishParams.metadata.thumbnail,
|
|
outpoint: publishResults.txid + ':' + publishResults.nout,
|
|
height: 0,
|
|
contentType: fileType,
|
|
nsfw: publishParams.metadata.nsfw,
|
|
amount: publishParams.bid,
|
|
certificateId: certificateId,
|
|
channelName: channelName
|
|
};
|
|
// upsert criteria
|
|
var upsertCriteria = {
|
|
name: publishParams.name,
|
|
claimId: publishResults.claim_id
|
|
};
|
|
// upsert the records
|
|
return Promise.all([db.upsert(db.File, fileRecord, upsertCriteria, 'File'), db.upsert(db.Claim, claimRecord, upsertCriteria, 'Claim')]);
|
|
}).then(function (_ref) {
|
|
var _ref2 = _slicedToArray(_ref, 2),
|
|
file = _ref2[0],
|
|
claim = _ref2[1];
|
|
|
|
logger.debug('File and Claim records successfully created');
|
|
return Promise.all([file.setClaim(claim), claim.setFile(file)]);
|
|
}).then(function () {
|
|
logger.debug('File and Claim records successfully associated');
|
|
resolve(publishResults); // resolve the promise with the result from lbryApi.publishClaim;
|
|
}).catch(function (error) {
|
|
logger.error('PUBLISH ERROR', error);
|
|
publishHelpers.deleteTemporaryFile(publishParams.file_path); // delete the local file
|
|
reject(error);
|
|
});
|
|
});
|
|
},
|
|
claimNameIsAvailable: function claimNameIsAvailable(name) {
|
|
// find any records where the name is used
|
|
return db.File.findAll({ where: { name: name } }).then(function (result) {
|
|
if (result.length >= 1) {
|
|
var claimAddress = config.wallet.lbryClaimAddress;
|
|
// filter out any results that were not published from spee.ch's wallet address
|
|
var filteredResult = result.filter(function (claim) {
|
|
return claim.address === claimAddress;
|
|
});
|
|
// return based on whether any non-spee.ch claims were left
|
|
if (filteredResult.length >= 1) {
|
|
throw new Error('That claim is already in use');
|
|
};
|
|
return name;
|
|
};
|
|
return name;
|
|
});
|
|
},
|
|
checkChannelAvailability: function checkChannelAvailability(name) {
|
|
return new Promise(function (resolve, reject) {
|
|
// find any records where the name is used
|
|
db.Channel.findAll({ where: { channelName: name } }).then(function (result) {
|
|
if (result.length >= 1) {
|
|
return resolve(false);
|
|
}
|
|
resolve(true);
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 79 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("fs");
|
|
|
|
/***/ }),
|
|
/* 80 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var db = __webpack_require__(11);
|
|
var logger = __webpack_require__(2);
|
|
|
|
module.exports = {
|
|
authenticateUser: function authenticateUser(channelName, channelId, channelPassword, user) {
|
|
// case: no channelName or channel Id are provided (anonymous), regardless of whether user token is provided
|
|
if (!channelName && !channelId) {
|
|
return {
|
|
channelName: null,
|
|
channelClaimId: null
|
|
};
|
|
}
|
|
// case: channelName or channel Id are provided with user token
|
|
if (user) {
|
|
if (channelName && channelName !== user.channelName) {
|
|
throw new Error('the provided channel name does not match user credentials');
|
|
}
|
|
if (channelId && channelId !== user.channelClaimId) {
|
|
throw new Error('the provided channel id does not match user credentials');
|
|
}
|
|
return {
|
|
channelName: user.channelName,
|
|
channelClaimId: user.channelClaimId
|
|
};
|
|
}
|
|
// case: channelName or channel Id are provided with password instead of user token
|
|
if (!channelPassword) throw new Error('no channel password provided');
|
|
return module.exports.authenticateChannelCredentials(channelName, channelId, channelPassword);
|
|
},
|
|
authenticateChannelCredentials: function authenticateChannelCredentials(channelName, channelId, userPassword) {
|
|
return new Promise(function (resolve, reject) {
|
|
// hoisted variables
|
|
var channelData = void 0;
|
|
// build the params for finding the channel
|
|
var channelFindParams = {};
|
|
if (channelName) channelFindParams['channelName'] = channelName;
|
|
if (channelId) channelFindParams['channelClaimId'] = channelId;
|
|
// find the channel
|
|
db.Channel.findOne({
|
|
where: channelFindParams
|
|
}).then(function (channel) {
|
|
if (!channel) {
|
|
logger.debug('no channel found');
|
|
throw new Error('Authentication failed, you do not have access to that channel');
|
|
}
|
|
channelData = channel.get();
|
|
logger.debug('channel data:', channelData);
|
|
return db.User.findOne({
|
|
where: { userName: channelData.channelName.substring(1) }
|
|
});
|
|
}).then(function (user) {
|
|
if (!user) {
|
|
logger.debug('no user found');
|
|
throw new Error('Authentication failed, you do not have access to that channel');
|
|
}
|
|
return user.comparePassword(userPassword);
|
|
}).then(function (isMatch) {
|
|
if (!isMatch) {
|
|
logger.debug('incorrect password');
|
|
throw new Error('Authentication failed, you do not have access to that channel');
|
|
}
|
|
logger.debug('...password was a match...');
|
|
resolve(channelData);
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 81 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var CLAIMS_PER_PAGE = 12;
|
|
|
|
module.exports = {
|
|
returnPaginatedChannelClaims: function returnPaginatedChannelClaims(channelName, longChannelClaimId, claims, page) {
|
|
var totalPages = module.exports.determineTotalPages(claims);
|
|
var paginationPage = module.exports.getPageFromQuery(page);
|
|
var viewData = {
|
|
channelName: channelName,
|
|
longChannelClaimId: longChannelClaimId,
|
|
claims: module.exports.extractPageFromClaims(claims, paginationPage),
|
|
previousPage: module.exports.determinePreviousPage(paginationPage),
|
|
currentPage: paginationPage,
|
|
nextPage: module.exports.determineNextPage(totalPages, paginationPage),
|
|
totalPages: totalPages,
|
|
totalResults: module.exports.determineTotalClaims(claims)
|
|
};
|
|
return viewData;
|
|
},
|
|
getPageFromQuery: function getPageFromQuery(page) {
|
|
if (page) {
|
|
return parseInt(page);
|
|
}
|
|
return 1;
|
|
},
|
|
extractPageFromClaims: function extractPageFromClaims(claims, pageNumber) {
|
|
if (!claims) {
|
|
return []; // if no claims, return this default
|
|
}
|
|
// logger.debug('claims is array?', Array.isArray(claims));
|
|
// logger.debug(`pageNumber ${pageNumber} is number?`, Number.isInteger(pageNumber));
|
|
var claimStartIndex = (pageNumber - 1) * CLAIMS_PER_PAGE;
|
|
var claimEndIndex = claimStartIndex + CLAIMS_PER_PAGE;
|
|
var pageOfClaims = claims.slice(claimStartIndex, claimEndIndex);
|
|
return pageOfClaims;
|
|
},
|
|
determineTotalPages: function determineTotalPages(claims) {
|
|
if (!claims) {
|
|
return 0;
|
|
} else {
|
|
var totalClaims = claims.length;
|
|
if (totalClaims < CLAIMS_PER_PAGE) {
|
|
return 1;
|
|
}
|
|
var fullPages = Math.floor(totalClaims / CLAIMS_PER_PAGE);
|
|
var remainder = totalClaims % CLAIMS_PER_PAGE;
|
|
if (remainder === 0) {
|
|
return fullPages;
|
|
}
|
|
return fullPages + 1;
|
|
}
|
|
},
|
|
determinePreviousPage: function determinePreviousPage(currentPage) {
|
|
if (currentPage === 1) {
|
|
return null;
|
|
}
|
|
return currentPage - 1;
|
|
},
|
|
determineNextPage: function determineNextPage(totalPages, currentPage) {
|
|
if (currentPage === totalPages) {
|
|
return null;
|
|
}
|
|
return currentPage + 1;
|
|
},
|
|
determineTotalClaims: function determineTotalClaims(claims) {
|
|
if (!claims) {
|
|
return 0;
|
|
}
|
|
return claims.length;
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 82 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _require = __webpack_require__(3),
|
|
site = _require.site;
|
|
|
|
var handlePageRender = __webpack_require__(30);
|
|
|
|
module.exports = function (app) {
|
|
// route for the home page
|
|
app.get('/', function (req, res) {
|
|
handlePageRender(req, res);
|
|
});
|
|
// route to display login page
|
|
app.get('/login', function (req, res) {
|
|
handlePageRender(req, res);
|
|
});
|
|
// route to show 'about' page
|
|
app.get('/about', function (req, res) {
|
|
handlePageRender(req, res);
|
|
});
|
|
// route to display a list of the trending images
|
|
app.get('/trending', function (req, res) {
|
|
res.status(301).redirect('/popular');
|
|
});
|
|
app.get('/popular', function (req, res) {
|
|
handlePageRender(req, res);
|
|
});
|
|
// route to display a list of the trending images
|
|
app.get('/new', function (req, res) {
|
|
handlePageRender(req, res);
|
|
});
|
|
// route to send embedable video player (for twitter)
|
|
app.get('/embed/:claimId/:name', function (_ref, res) {
|
|
var params = _ref.params;
|
|
|
|
var claimId = params.claimId;
|
|
var name = params.name;
|
|
var host = site.host;
|
|
// get and render the content
|
|
res.status(200).render('embed', { layout: 'embed', host: host, claimId: claimId, name: name });
|
|
});
|
|
};
|
|
|
|
/***/ }),
|
|
/* 83 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
exports.default = function () {
|
|
var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
|
|
var action = arguments[1];
|
|
|
|
switch (action.type) {
|
|
case actions.FILE_SELECTED:
|
|
return Object.assign({}, initialState, { // note: clears to initial state
|
|
file: action.data
|
|
});
|
|
case actions.FILE_CLEAR:
|
|
return initialState;
|
|
case actions.METADATA_UPDATE:
|
|
return Object.assign({}, state, {
|
|
metadata: Object.assign({}, state.metadata, _defineProperty({}, action.data.name, action.data.value))
|
|
});
|
|
case actions.CLAIM_UPDATE:
|
|
return Object.assign({}, state, {
|
|
claim: action.data
|
|
});
|
|
case actions.SET_PUBLISH_IN_CHANNEL:
|
|
return Object.assign({}, state, {
|
|
publishInChannel: action.channel
|
|
});
|
|
case actions.PUBLISH_STATUS_UPDATE:
|
|
return Object.assign({}, state, {
|
|
status: action.data
|
|
});
|
|
case actions.ERROR_UPDATE:
|
|
return Object.assign({}, state, {
|
|
error: Object.assign({}, state.error, _defineProperty({}, action.data.name, action.data.value))
|
|
});
|
|
case actions.SELECTED_CHANNEL_UPDATE:
|
|
return Object.assign({}, state, {
|
|
selectedChannel: action.data
|
|
});
|
|
case actions.TOGGLE_METADATA_INPUTS:
|
|
return Object.assign({}, state, {
|
|
showMetadataInputs: action.data
|
|
});
|
|
case actions.THUMBNAIL_NEW:
|
|
return Object.assign({}, state, {
|
|
thumbnail: action.data
|
|
});
|
|
default:
|
|
return state;
|
|
}
|
|
};
|
|
|
|
var _publish_action_types = __webpack_require__(33);
|
|
|
|
var actions = _interopRequireWildcard(_publish_action_types);
|
|
|
|
var _publish_channel_select_states = __webpack_require__(34);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
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 _require = __webpack_require__(3),
|
|
publish = _require.publish;
|
|
|
|
var initialState = {
|
|
publishInChannel: false,
|
|
selectedChannel: _publish_channel_select_states.LOGIN,
|
|
showMetadataInputs: false,
|
|
status: {
|
|
status: null,
|
|
message: null
|
|
},
|
|
error: {
|
|
file: null,
|
|
url: null,
|
|
channel: null,
|
|
publishSubmit: null
|
|
},
|
|
file: null,
|
|
claim: '',
|
|
metadata: {
|
|
title: '',
|
|
description: '',
|
|
license: '',
|
|
nsfw: false
|
|
},
|
|
thumbnailChannel: publish.thumbnailChannel,
|
|
thumbnailChannelId: publish.thumbnailChannelId,
|
|
thumbnail: null
|
|
};
|
|
|
|
/***/ }),
|
|
/* 84 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
exports.default = function () {
|
|
var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
|
|
var action = arguments[1];
|
|
|
|
switch (action.type) {
|
|
case actions.CHANNEL_UPDATE:
|
|
return Object.assign({}, state, {
|
|
loggedInChannel: action.data
|
|
});
|
|
default:
|
|
return state;
|
|
}
|
|
};
|
|
|
|
var _channel_action_types = __webpack_require__(35);
|
|
|
|
var actions = _interopRequireWildcard(_channel_action_types);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
var initialState = {
|
|
loggedInChannel: {
|
|
name: null,
|
|
shortId: null,
|
|
longId: null
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 85 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
exports.default = function () {
|
|
var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
|
|
var action = arguments[1];
|
|
|
|
switch (action.type) {
|
|
// handle request
|
|
case actions.REQUEST_ERROR:
|
|
return Object.assign({}, state, {
|
|
request: Object.assign({}, state.request, {
|
|
error: action.data
|
|
})
|
|
});
|
|
case actions.REQUEST_UPDATE:
|
|
return Object.assign({}, state, {
|
|
request: Object.assign({}, state.request, {
|
|
type: action.data.requestType,
|
|
id: action.data.requestId
|
|
})
|
|
});
|
|
// store requests
|
|
case actions.REQUEST_LIST_ADD:
|
|
return Object.assign({}, state, {
|
|
requestList: Object.assign({}, state.requestList, _defineProperty({}, action.data.id, {
|
|
error: action.data.error,
|
|
key: action.data.key
|
|
}))
|
|
});
|
|
// asset data
|
|
case actions.ASSET_ADD:
|
|
return Object.assign({}, state, {
|
|
assetList: Object.assign({}, state.assetList, _defineProperty({}, action.data.id, {
|
|
error: action.data.error,
|
|
name: action.data.name,
|
|
claimId: action.data.claimId,
|
|
shortId: action.data.shortId,
|
|
claimData: action.data.claimData
|
|
}))
|
|
});
|
|
// channel data
|
|
case actions.CHANNEL_ADD:
|
|
return Object.assign({}, state, {
|
|
channelList: Object.assign({}, state.channelList, _defineProperty({}, action.data.id, {
|
|
name: action.data.name,
|
|
longId: action.data.longId,
|
|
shortId: action.data.shortId,
|
|
claimsData: action.data.claimsData
|
|
}))
|
|
});
|
|
case actions.CHANNEL_CLAIMS_UPDATE_SUCCESS:
|
|
return Object.assign({}, state, {
|
|
channelList: Object.assign({}, state.channelList, _defineProperty({}, action.data.channelListId, Object.assign({}, state.channelList[action.data.channelListId], {
|
|
claimsData: action.data.claimsData
|
|
})))
|
|
});
|
|
// display an asset
|
|
case actions.FILE_AVAILABILITY_UPDATE:
|
|
return Object.assign({}, state, {
|
|
displayAsset: Object.assign({}, state.displayAsset, {
|
|
status: action.data
|
|
})
|
|
});
|
|
case actions.DISPLAY_ASSET_ERROR:
|
|
return Object.assign({}, state, {
|
|
displayAsset: Object.assign({}, state.displayAsset, {
|
|
error: action.data,
|
|
status: _asset_display_states.ERROR
|
|
})
|
|
});
|
|
default:
|
|
return state;
|
|
}
|
|
};
|
|
|
|
var _show_action_types = __webpack_require__(12);
|
|
|
|
var actions = _interopRequireWildcard(_show_action_types);
|
|
|
|
var _asset_display_states = __webpack_require__(36);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
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 initialState = {
|
|
request: {
|
|
error: null,
|
|
type: null,
|
|
id: null
|
|
},
|
|
requestList: {},
|
|
channelList: {},
|
|
assetList: {},
|
|
displayAsset: {
|
|
error: null,
|
|
status: _asset_display_states.LOCAL_CHECK
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 86 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
exports.default = function () {
|
|
var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
|
|
var action = arguments[1];
|
|
|
|
switch (action.type) {
|
|
default:
|
|
return state;
|
|
}
|
|
};
|
|
|
|
var _require = __webpack_require__(3),
|
|
site = _require.site;
|
|
|
|
var initialState = {
|
|
host: site.host
|
|
};
|
|
|
|
/***/ }),
|
|
/* 87 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("react-ga");
|
|
|
|
/***/ }),
|
|
/* 88 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _SEO = __webpack_require__(8);
|
|
|
|
var _SEO2 = _interopRequireDefault(_SEO);
|
|
|
|
var _NavBar = __webpack_require__(6);
|
|
|
|
var _NavBar2 = _interopRequireDefault(_NavBar);
|
|
|
|
var _PublishTool = __webpack_require__(96);
|
|
|
|
var _PublishTool2 = _interopRequireDefault(_PublishTool);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var HomePage = function (_React$Component) {
|
|
_inherits(HomePage, _React$Component);
|
|
|
|
function HomePage() {
|
|
_classCallCheck(this, HomePage);
|
|
|
|
return _possibleConstructorReturn(this, (HomePage.__proto__ || Object.getPrototypeOf(HomePage)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(HomePage, [{
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--tall flex-container--column' },
|
|
_react2.default.createElement(_SEO2.default, null),
|
|
_react2.default.createElement(_NavBar2.default, null),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--tall row--padded flex-container--column' },
|
|
_react2.default.createElement(_PublishTool2.default, null)
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return HomePage;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = HomePage;
|
|
|
|
/***/ }),
|
|
/* 89 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _require = __webpack_require__(3),
|
|
siteTitle = _require.site.title;
|
|
|
|
var createPageTitle = exports.createPageTitle = function createPageTitle(pageTitle) {
|
|
if (!pageTitle) {
|
|
return '' + siteTitle;
|
|
}
|
|
return siteTitle + ' - ' + pageTitle;
|
|
};
|
|
|
|
/***/ }),
|
|
/* 90 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _require = __webpack_require__(3),
|
|
_require$site = _require.site,
|
|
title = _require$site.title,
|
|
host = _require$site.host,
|
|
description = _require$site.description,
|
|
_require$claim = _require.claim,
|
|
defaultThumbnail = _require$claim.defaultThumbnail,
|
|
defaultDescription = _require$claim.defaultDescription;
|
|
|
|
var determineOgThumbnailContentType = function determineOgThumbnailContentType(thumbnail) {
|
|
if (thumbnail) {
|
|
var fileExt = thumbnail.substring(thumbnail.lastIndexOf('.'));
|
|
switch (fileExt) {
|
|
case 'jpeg':
|
|
case 'jpg':
|
|
return 'image/jpeg';
|
|
case 'png':
|
|
return 'image/png';
|
|
case 'gif':
|
|
return 'image/gif';
|
|
case 'mp4':
|
|
return 'video/mp4';
|
|
default:
|
|
return 'image/jpeg';
|
|
}
|
|
}
|
|
return '';
|
|
};
|
|
|
|
var createBasicMetaTags = function createBasicMetaTags() {
|
|
return [{ property: 'og:title', content: title }, { property: 'og:url', content: host }, { property: 'og:site_name', content: title }, { property: 'og:description', content: description }, { property: 'twitter:site', content: '@spee_ch' }, { property: 'twitter:card', content: 'summary' }];
|
|
};
|
|
|
|
var createChannelMetaTags = function createChannelMetaTags(channel) {
|
|
var name = channel.name,
|
|
longId = channel.longId;
|
|
|
|
return [{ property: 'og:title', content: name + ' on ' + title }, { property: 'og:url', content: host + '/' + name + ':' + longId }, { property: 'og:site_name', content: title }, { property: 'og:description', content: name + ', a channel on ' + title }, { property: 'twitter:site', content: '@spee_ch' }, { property: 'twitter:card', content: 'summary' }];
|
|
};
|
|
|
|
var createAssetMetaTags = function createAssetMetaTags(asset) {
|
|
var claimData = asset.claimData;
|
|
var contentType = claimData.contentType;
|
|
|
|
var embedUrl = host + '/' + claimData.claimId + '/' + claimData.name;
|
|
var showUrl = host + '/' + claimData.claimId + '/' + claimData.name;
|
|
var source = host + '/' + claimData.claimId + '/' + claimData.name + '.' + claimData.fileExt;
|
|
var ogTitle = claimData.title || claimData.name;
|
|
var ogDescription = claimData.description || defaultDescription;
|
|
var ogThumbnailContentType = determineOgThumbnailContentType(claimData.thumbnail);
|
|
var ogThumbnail = claimData.thumbnail || defaultThumbnail;
|
|
var metaTags = [{ property: 'og:title', content: ogTitle }, { property: 'og:url', content: showUrl }, { property: 'og:site_name', content: title }, { property: 'og:description', content: ogDescription }, { property: 'og:image:width', content: 600 }, { property: 'og:image:height', content: 315 }, { property: 'twitter:site', content: '@spee_ch' }];
|
|
if (contentType === 'video/mp4' || contentType === 'video/webm') {
|
|
metaTags.push({ property: 'og:video', content: source });
|
|
metaTags.push({ property: 'og:video:secure_url', content: source });
|
|
metaTags.push({ property: 'og:video:type', content: contentType });
|
|
metaTags.push({ property: 'og:image', content: ogThumbnail });
|
|
metaTags.push({ property: 'og:image:type', content: ogThumbnailContentType });
|
|
metaTags.push({ property: 'og:type', content: 'video' });
|
|
metaTags.push({ property: 'twitter:card', content: 'player' });
|
|
metaTags.push({ property: 'twitter:player', content: embedUrl });
|
|
metaTags.push({ property: 'twitter:player:width', content: 600 });
|
|
metaTags.push({ property: 'twitter:text:player_width', content: 600 });
|
|
metaTags.push({ property: 'twitter:player:height', content: 337 });
|
|
metaTags.push({ property: 'twitter:player:stream', content: source });
|
|
metaTags.push({ property: 'twitter:player:stream:content_type', content: contentType });
|
|
} else {
|
|
metaTags.push({ property: 'og:image', content: source });
|
|
metaTags.push({ property: 'og:image:type', content: contentType });
|
|
metaTags.push({ property: 'og:type', content: 'article' });
|
|
metaTags.push({ property: 'twitter:card', content: 'summary_large_image' });
|
|
}
|
|
return metaTags;
|
|
};
|
|
|
|
var createMetaTags = exports.createMetaTags = function createMetaTags(asset, channel) {
|
|
if (asset) {
|
|
return createAssetMetaTags(asset);
|
|
};
|
|
if (channel) {
|
|
return createChannelMetaTags(channel);
|
|
};
|
|
return createBasicMetaTags();
|
|
};
|
|
|
|
/***/ }),
|
|
/* 91 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _require = __webpack_require__(3),
|
|
host = _require.site.host;
|
|
|
|
var createBasicCanonicalLink = function createBasicCanonicalLink(page) {
|
|
if (!page) {
|
|
return '' + host;
|
|
};
|
|
return host + '/' + page;
|
|
};
|
|
|
|
var createAssetCanonicalLink = function createAssetCanonicalLink(asset) {
|
|
var channelName = void 0,
|
|
certificateId = void 0,
|
|
name = void 0,
|
|
claimId = void 0;
|
|
if (asset.claimData) {
|
|
var _asset$claimData = asset.claimData;
|
|
channelName = _asset$claimData.channelName;
|
|
certificateId = _asset$claimData.certificateId;
|
|
name = _asset$claimData.name;
|
|
claimId = _asset$claimData.claimId;
|
|
};
|
|
if (channelName) {
|
|
return host + '/' + channelName + ':' + certificateId + '/' + name;
|
|
};
|
|
return host + '/' + claimId + '/' + name;
|
|
};
|
|
|
|
var createChannelCanonicalLink = function createChannelCanonicalLink(channel) {
|
|
var name = channel.name,
|
|
longId = channel.longId;
|
|
|
|
return host + '/' + name + ':' + longId;
|
|
};
|
|
|
|
var createCanonicalLink = exports.createCanonicalLink = function createCanonicalLink(asset, channel, page) {
|
|
if (asset) {
|
|
return createAssetCanonicalLink(asset);
|
|
}
|
|
if (channel) {
|
|
return createChannelCanonicalLink(channel);
|
|
}
|
|
if (page) {
|
|
return createBasicCanonicalLink(page);
|
|
}
|
|
return createBasicCanonicalLink();
|
|
};
|
|
|
|
/***/ }),
|
|
/* 92 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _reactRouterDom = __webpack_require__(4);
|
|
|
|
var _Logo = __webpack_require__(93);
|
|
|
|
var _Logo2 = _interopRequireDefault(_Logo);
|
|
|
|
var _NavBarChannelOptionsDropdown = __webpack_require__(94);
|
|
|
|
var _NavBarChannelOptionsDropdown2 = _interopRequireDefault(_NavBarChannelOptionsDropdown);
|
|
|
|
var _request = __webpack_require__(10);
|
|
|
|
var _request2 = _interopRequireDefault(_request);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var VIEW = 'VIEW';
|
|
var LOGOUT = 'LOGOUT';
|
|
|
|
var NavBar = function (_React$Component) {
|
|
_inherits(NavBar, _React$Component);
|
|
|
|
function NavBar(props) {
|
|
_classCallCheck(this, NavBar);
|
|
|
|
var _this = _possibleConstructorReturn(this, (NavBar.__proto__ || Object.getPrototypeOf(NavBar)).call(this, props));
|
|
|
|
_this.checkForLoggedInUser = _this.checkForLoggedInUser.bind(_this);
|
|
_this.logoutUser = _this.logoutUser.bind(_this);
|
|
_this.handleSelection = _this.handleSelection.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(NavBar, [{
|
|
key: 'componentDidMount',
|
|
value: function componentDidMount() {
|
|
// check to see if the user is already logged in
|
|
this.checkForLoggedInUser();
|
|
}
|
|
}, {
|
|
key: 'checkForLoggedInUser',
|
|
value: function checkForLoggedInUser() {
|
|
var _this2 = this;
|
|
|
|
var params = { credentials: 'include' };
|
|
(0, _request2.default)('/user', params).then(function (_ref) {
|
|
var data = _ref.data;
|
|
|
|
_this2.props.onChannelLogin(data.channelName, data.shortChannelId, data.channelClaimId);
|
|
}).catch(function (error) {
|
|
console.log('/user error:', error.message);
|
|
});
|
|
}
|
|
}, {
|
|
key: 'logoutUser',
|
|
value: function logoutUser() {
|
|
var _this3 = this;
|
|
|
|
var params = { credentials: 'include' };
|
|
(0, _request2.default)('/logout', params).then(function () {
|
|
_this3.props.onChannelLogout();
|
|
}).catch(function (error) {
|
|
console.log('/logout error', error.message);
|
|
});
|
|
}
|
|
}, {
|
|
key: 'handleSelection',
|
|
value: function handleSelection(event) {
|
|
var value = event.target.selectedOptions[0].value;
|
|
switch (value) {
|
|
case LOGOUT:
|
|
this.logoutUser();
|
|
break;
|
|
case VIEW:
|
|
// redirect to channel page
|
|
this.props.history.push('/' + this.props.channelName + ':' + this.props.channelLongId);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--wide nav-bar' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded row--short flex-container--row flex-container--space-between-center' },
|
|
_react2.default.createElement(_Logo2.default, null),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'nav-bar--center' },
|
|
_react2.default.createElement(
|
|
'span',
|
|
{ className: 'nav-bar-tagline' },
|
|
'Open-source, decentralized image and video sharing.'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'nav-bar--right' },
|
|
_react2.default.createElement(
|
|
_reactRouterDom.NavLink,
|
|
{ className: 'nav-bar-link link--nav', activeClassName: 'link--nav-active', to: '/', exact: true },
|
|
'Publish'
|
|
),
|
|
_react2.default.createElement(
|
|
_reactRouterDom.NavLink,
|
|
{ className: 'nav-bar-link link--nav', activeClassName: 'link--nav-active', to: '/about' },
|
|
'About'
|
|
),
|
|
this.props.channelName ? _react2.default.createElement(_NavBarChannelOptionsDropdown2.default, {
|
|
channelName: this.props.channelName,
|
|
handleSelection: this.handleSelection,
|
|
defaultSelection: this.props.channelName,
|
|
VIEW: VIEW,
|
|
LOGOUT: LOGOUT
|
|
}) : _react2.default.createElement(
|
|
_reactRouterDom.NavLink,
|
|
{ id: 'nav-bar-login-link', className: 'nav-bar-link link--nav', activeClassName: 'link--nav-active', to: '/login' },
|
|
'Channel'
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return NavBar;
|
|
}(_react2.default.Component);
|
|
|
|
exports.default = (0, _reactRouterDom.withRouter)(NavBar);
|
|
|
|
/***/ }),
|
|
/* 93 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _reactRouterDom = __webpack_require__(4);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function Logo() {
|
|
return _react2.default.createElement(
|
|
'svg',
|
|
{ version: '1.1', id: 'Layer_1', x: '0px', y: '0px', height: '24px', viewBox: '0 0 80 31', enableBackground: 'new 0 0 80 31', className: 'nav-bar-logo' },
|
|
_react2.default.createElement(
|
|
_reactRouterDom.Link,
|
|
{ to: '/' },
|
|
_react2.default.createElement(
|
|
'title',
|
|
null,
|
|
'Logo'
|
|
),
|
|
_react2.default.createElement(
|
|
'desc',
|
|
null,
|
|
'Spee.ch logo'
|
|
),
|
|
_react2.default.createElement(
|
|
'g',
|
|
{ id: 'About' },
|
|
_react2.default.createElement(
|
|
'g',
|
|
{ id: 'Publish-Form-V2-_x28_filled_x29_', transform: 'translate(-42.000000, -23.000000)' },
|
|
_react2.default.createElement(
|
|
'g',
|
|
{ id: 'Group-17', transform: 'translate(42.000000, 22.000000)' },
|
|
_react2.default.createElement(
|
|
'text',
|
|
{ transform: 'matrix(1 0 0 1 0 20)', fontSize: '25', fontFamily: 'Roboto' },
|
|
'Spee<h'
|
|
),
|
|
_react2.default.createElement(
|
|
'g',
|
|
{ id: 'Group-16', transform: 'translate(0.000000, 30.000000)' },
|
|
_react2.default.createElement('path', { id: 'Line-8', fill: 'none', stroke: '#09F911', strokeWidth: '1', strokeLinecap: 'square', d: 'M0.5,1.5h15' }),
|
|
_react2.default.createElement('path', { id: 'Line-8-Copy', fill: 'none', stroke: '#029D74', strokeWidth: '1', strokeLinecap: 'square', d: 'M16.5,1.5h15' }),
|
|
_react2.default.createElement('path', { id: 'Line-8-Copy-2', fill: 'none', stroke: '#E35BD8', strokeWidth: '1', strokeLinecap: 'square', d: 'M32.5,1.5h15' }),
|
|
_react2.default.createElement('path', { id: 'Line-8-Copy-3', fill: 'none', stroke: '#4156C5', strokeWidth: '1', strokeLinecap: 'square', d: 'M48.5,1.5h15' }),
|
|
_react2.default.createElement('path', { id: 'Line-8-Copy-4', fill: 'none', stroke: '#635688', strokeWidth: '1', strokeLinecap: 'square', d: 'M64.5,1.5h15' })
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
};
|
|
|
|
exports.default = Logo;
|
|
|
|
/***/ }),
|
|
/* 94 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function NavBarChannelDropdown(_ref) {
|
|
var channelName = _ref.channelName,
|
|
handleSelection = _ref.handleSelection,
|
|
defaultSelection = _ref.defaultSelection,
|
|
VIEW = _ref.VIEW,
|
|
LOGOUT = _ref.LOGOUT;
|
|
|
|
return _react2.default.createElement(
|
|
'select',
|
|
{ type: 'text', id: 'nav-bar-channel-select', className: 'select select--arrow link--nav', onChange: handleSelection, value: defaultSelection },
|
|
_react2.default.createElement(
|
|
'option',
|
|
{ id: 'nav-bar-channel-select-channel-option' },
|
|
channelName
|
|
),
|
|
_react2.default.createElement(
|
|
'option',
|
|
{ value: VIEW },
|
|
'View'
|
|
),
|
|
_react2.default.createElement(
|
|
'option',
|
|
{ value: LOGOUT },
|
|
'Logout'
|
|
)
|
|
);
|
|
};
|
|
|
|
exports.default = NavBarChannelDropdown;
|
|
|
|
/***/ }),
|
|
/* 95 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("cross-fetch/polyfill");
|
|
|
|
/***/ }),
|
|
/* 96 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _view = __webpack_require__(97);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var publish = _ref.publish;
|
|
|
|
return {
|
|
file: publish.file,
|
|
status: publish.status.status
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, null)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 97 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _Dropzone = __webpack_require__(39);
|
|
|
|
var _Dropzone2 = _interopRequireDefault(_Dropzone);
|
|
|
|
var _PublishDetails = __webpack_require__(101);
|
|
|
|
var _PublishDetails2 = _interopRequireDefault(_PublishDetails);
|
|
|
|
var _PublishStatus = __webpack_require__(119);
|
|
|
|
var _PublishStatus2 = _interopRequireDefault(_PublishStatus);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var PublishTool = function (_React$Component) {
|
|
_inherits(PublishTool, _React$Component);
|
|
|
|
function PublishTool() {
|
|
_classCallCheck(this, PublishTool);
|
|
|
|
return _possibleConstructorReturn(this, (PublishTool.__proto__ || Object.getPrototypeOf(PublishTool)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(PublishTool, [{
|
|
key: 'render',
|
|
value: function render() {
|
|
if (this.props.file) {
|
|
if (this.props.status) {
|
|
return _react2.default.createElement(_PublishStatus2.default, null);
|
|
} else {
|
|
return _react2.default.createElement(_PublishDetails2.default, null);
|
|
}
|
|
} else {
|
|
return _react2.default.createElement(_Dropzone2.default, null);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return PublishTool;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = PublishTool;
|
|
|
|
/***/ }),
|
|
/* 98 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _file = __webpack_require__(99);
|
|
|
|
var _Preview = __webpack_require__(100);
|
|
|
|
var _Preview2 = _interopRequireDefault(_Preview);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var Dropzone = function (_React$Component) {
|
|
_inherits(Dropzone, _React$Component);
|
|
|
|
function Dropzone(props) {
|
|
_classCallCheck(this, Dropzone);
|
|
|
|
var _this = _possibleConstructorReturn(this, (Dropzone.__proto__ || Object.getPrototypeOf(Dropzone)).call(this, props));
|
|
|
|
_this.state = {
|
|
dragOver: false,
|
|
mouseOver: false,
|
|
dimPreview: false
|
|
};
|
|
_this.handleDrop = _this.handleDrop.bind(_this);
|
|
_this.handleDragOver = _this.handleDragOver.bind(_this);
|
|
_this.handleDragEnd = _this.handleDragEnd.bind(_this);
|
|
_this.handleDragEnter = _this.handleDragEnter.bind(_this);
|
|
_this.handleDragLeave = _this.handleDragLeave.bind(_this);
|
|
_this.handleMouseEnter = _this.handleMouseEnter.bind(_this);
|
|
_this.handleMouseLeave = _this.handleMouseLeave.bind(_this);
|
|
_this.handleClick = _this.handleClick.bind(_this);
|
|
_this.handleFileInput = _this.handleFileInput.bind(_this);
|
|
_this.chooseFile = _this.chooseFile.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Dropzone, [{
|
|
key: 'handleDrop',
|
|
value: function handleDrop(event) {
|
|
event.preventDefault();
|
|
this.setState({ dragOver: false });
|
|
// if dropped items aren't files, reject them
|
|
var dt = event.dataTransfer;
|
|
if (dt.items) {
|
|
if (dt.items[0].kind === 'file') {
|
|
var droppedFile = dt.items[0].getAsFile();
|
|
this.chooseFile(droppedFile);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: 'handleDragOver',
|
|
value: function handleDragOver(event) {
|
|
event.preventDefault();
|
|
}
|
|
}, {
|
|
key: 'handleDragEnd',
|
|
value: function handleDragEnd(event) {
|
|
var dt = event.dataTransfer;
|
|
if (dt.items) {
|
|
for (var i = 0; i < dt.items.length; i++) {
|
|
dt.items.remove(i);
|
|
}
|
|
} else {
|
|
event.dataTransfer.clearData();
|
|
}
|
|
}
|
|
}, {
|
|
key: 'handleDragEnter',
|
|
value: function handleDragEnter() {
|
|
this.setState({ dragOver: true, dimPreview: true });
|
|
}
|
|
}, {
|
|
key: 'handleDragLeave',
|
|
value: function handleDragLeave() {
|
|
this.setState({ dragOver: false, dimPreview: false });
|
|
}
|
|
}, {
|
|
key: 'handleMouseEnter',
|
|
value: function handleMouseEnter() {
|
|
this.setState({ mouseOver: true, dimPreview: true });
|
|
}
|
|
}, {
|
|
key: 'handleMouseLeave',
|
|
value: function handleMouseLeave() {
|
|
this.setState({ mouseOver: false, dimPreview: false });
|
|
}
|
|
}, {
|
|
key: 'handleClick',
|
|
value: function handleClick(event) {
|
|
event.preventDefault();
|
|
document.getElementById('file_input').click();
|
|
}
|
|
}, {
|
|
key: 'handleFileInput',
|
|
value: function handleFileInput(event) {
|
|
event.preventDefault();
|
|
var fileList = event.target.files;
|
|
this.chooseFile(fileList[0]);
|
|
}
|
|
}, {
|
|
key: 'chooseFile',
|
|
value: function chooseFile(file) {
|
|
if (file) {
|
|
try {
|
|
(0, _file.validateFile)(file); // validate the file's name, type, and size
|
|
} catch (error) {
|
|
return this.props.setFileError(error.message);
|
|
}
|
|
// stage it so it will be ready when the publish button is clicked
|
|
this.props.selectFile(file);
|
|
}
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--tall flex-container--column' },
|
|
_react2.default.createElement(
|
|
'form',
|
|
null,
|
|
_react2.default.createElement('input', { className: 'input-file', type: 'file', id: 'file_input', name: 'file_input', accept: 'video/*,image/*', onChange: this.handleFileInput, encType: 'multipart/form-data' })
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ id: 'preview-dropzone', className: 'row row--padded row--tall dropzone' + (this.state.dragOver ? ' dropzone--drag-over' : ''), onDrop: this.handleDrop, onDragOver: this.handleDragOver, onDragEnd: this.handleDragEnd, onDragEnter: this.handleDragEnter, onDragLeave: this.handleDragLeave, onMouseEnter: this.handleMouseEnter, onMouseLeave: this.handleMouseLeave, onClick: this.handleClick },
|
|
this.props.file ? _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(_Preview2.default, {
|
|
dimPreview: this.state.dimPreview,
|
|
file: this.props.file,
|
|
thumbnail: this.props.thumbnail
|
|
}),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ id: 'dropzone-text-holder', className: 'flex-container--column flex-container--center-center' },
|
|
this.state.dragOver ? _react2.default.createElement(
|
|
'div',
|
|
{ id: 'dropzone-dragover' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'blue' },
|
|
'Drop it.'
|
|
)
|
|
) : null,
|
|
this.state.mouseOver ? _react2.default.createElement(
|
|
'div',
|
|
{ id: 'dropzone-instructions' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'info-message-placeholder info-message--failure', id: 'input-error-file-selection' },
|
|
this.props.fileError
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Drag & drop image or video here to publish'
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'fine-print' },
|
|
'OR'
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'blue--underlined' },
|
|
'CHOOSE FILE'
|
|
)
|
|
) : null
|
|
)
|
|
) : _react2.default.createElement(
|
|
'div',
|
|
{ id: 'dropzone-text-holder', className: 'flex-container--column flex-container--center-center' },
|
|
this.state.dragOver ? _react2.default.createElement(
|
|
'div',
|
|
{ id: 'dropzone-dragover' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'blue' },
|
|
'Drop it.'
|
|
)
|
|
) : _react2.default.createElement(
|
|
'div',
|
|
{ id: 'dropzone-instructions' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'info-message-placeholder info-message--failure', id: 'input-error-file-selection' },
|
|
this.props.fileError
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Drag & drop image or video here to publish'
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'fine-print' },
|
|
'OR'
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'blue--underlined' },
|
|
'CHOOSE FILE'
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return Dropzone;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = Dropzone;
|
|
|
|
/***/ }),
|
|
/* 99 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
module.exports = {
|
|
validateFile: function validateFile(file) {
|
|
if (!file) {
|
|
throw new Error('no file provided');
|
|
}
|
|
if (/'/.test(file.name)) {
|
|
throw new Error('apostrophes are not allowed in the file name');
|
|
}
|
|
// validate size and type
|
|
switch (file.type) {
|
|
case 'image/jpeg':
|
|
case 'image/jpg':
|
|
case 'image/png':
|
|
if (file.size > 10000000) {
|
|
throw new Error('Sorry, images are limited to 10 megabytes.');
|
|
}
|
|
break;
|
|
case 'image/gif':
|
|
if (file.size > 50000000) {
|
|
throw new Error('Sorry, GIFs are limited to 50 megabytes.');
|
|
}
|
|
break;
|
|
case 'video/mp4':
|
|
if (file.size > 50000000) {
|
|
throw new Error('Sorry, videos are limited to 50 megabytes.');
|
|
}
|
|
break;
|
|
default:
|
|
throw new Error(file.type + ' is not a supported file type. Only, .jpeg, .png, .gif, and .mp4 files are currently supported.');
|
|
}
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 100 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _propTypes = __webpack_require__(9);
|
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var Preview = function (_React$Component) {
|
|
_inherits(Preview, _React$Component);
|
|
|
|
function Preview(props) {
|
|
_classCallCheck(this, Preview);
|
|
|
|
var _this = _possibleConstructorReturn(this, (Preview.__proto__ || Object.getPrototypeOf(Preview)).call(this, props));
|
|
|
|
_this.state = {
|
|
imgSource: '',
|
|
defaultThumbnail: '/assets/img/video_thumb_default.png'
|
|
};
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Preview, [{
|
|
key: 'componentDidMount',
|
|
value: function componentDidMount() {
|
|
this.setPreviewImageSource(this.props.file);
|
|
}
|
|
}, {
|
|
key: 'componentWillReceiveProps',
|
|
value: function componentWillReceiveProps(newProps) {
|
|
if (newProps.file !== this.props.file) {
|
|
this.setPreviewImageSource(newProps.file);
|
|
}
|
|
if (newProps.thumbnail !== this.props.thumbnail) {
|
|
if (newProps.thumbnail) {
|
|
this.setPreviewImageSourceFromFile(newProps.thumbnail);
|
|
} else {
|
|
this.setState({ imgSource: this.state.defaultThumbnail });
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: 'setPreviewImageSourceFromFile',
|
|
value: function setPreviewImageSourceFromFile(file) {
|
|
var _this2 = this;
|
|
|
|
var previewReader = new FileReader();
|
|
previewReader.readAsDataURL(file);
|
|
previewReader.onloadend = function () {
|
|
_this2.setState({ imgSource: previewReader.result });
|
|
};
|
|
}
|
|
}, {
|
|
key: 'setPreviewImageSource',
|
|
value: function setPreviewImageSource(file) {
|
|
if (file.type !== 'video/mp4') {
|
|
this.setPreviewImageSourceFromFile(file);
|
|
} else {
|
|
if (this.props.thumbnail) {
|
|
this.setPreviewImageSourceFromFile(this.props.thumbnail);
|
|
}
|
|
this.setState({ imgSource: this.state.defaultThumbnail });
|
|
}
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement('img', {
|
|
id: 'dropzone-preview',
|
|
src: this.state.imgSource,
|
|
className: this.props.dimPreview ? 'dim' : '',
|
|
alt: 'publish preview'
|
|
});
|
|
}
|
|
}]);
|
|
|
|
return Preview;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
Preview.propTypes = {
|
|
dimPreview: _propTypes2.default.bool.isRequired,
|
|
file: _propTypes2.default.object.isRequired,
|
|
thumbnail: _propTypes2.default.object
|
|
};
|
|
|
|
exports.default = Preview;
|
|
|
|
/***/ }),
|
|
/* 101 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _publish = __webpack_require__(5);
|
|
|
|
var _view = __webpack_require__(102);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var channel = _ref.channel,
|
|
publish = _ref.publish;
|
|
|
|
return {
|
|
file: publish.file
|
|
};
|
|
};
|
|
|
|
var mapDispatchToProps = {
|
|
clearFile: _publish.clearFile,
|
|
startPublish: _publish.startPublish
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 102 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _reactRouterDom = __webpack_require__(4);
|
|
|
|
var _Dropzone = __webpack_require__(39);
|
|
|
|
var _Dropzone2 = _interopRequireDefault(_Dropzone);
|
|
|
|
var _PublishTitleInput = __webpack_require__(103);
|
|
|
|
var _PublishTitleInput2 = _interopRequireDefault(_PublishTitleInput);
|
|
|
|
var _PublishUrlInput = __webpack_require__(105);
|
|
|
|
var _PublishUrlInput2 = _interopRequireDefault(_PublishUrlInput);
|
|
|
|
var _PublishThumbnailInput = __webpack_require__(108);
|
|
|
|
var _PublishThumbnailInput2 = _interopRequireDefault(_PublishThumbnailInput);
|
|
|
|
var _PublishMetadataInputs = __webpack_require__(110);
|
|
|
|
var _PublishMetadataInputs2 = _interopRequireDefault(_PublishMetadataInputs);
|
|
|
|
var _ChannelSelect = __webpack_require__(113);
|
|
|
|
var _ChannelSelect2 = _interopRequireDefault(_ChannelSelect);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var PublishDetails = function (_React$Component) {
|
|
_inherits(PublishDetails, _React$Component);
|
|
|
|
function PublishDetails(props) {
|
|
_classCallCheck(this, PublishDetails);
|
|
|
|
var _this = _possibleConstructorReturn(this, (PublishDetails.__proto__ || Object.getPrototypeOf(PublishDetails)).call(this, props));
|
|
|
|
_this.onPublishSubmit = _this.onPublishSubmit.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(PublishDetails, [{
|
|
key: 'onPublishSubmit',
|
|
value: function onPublishSubmit() {
|
|
this.props.startPublish(this.props.history);
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--no-bottom' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--10' },
|
|
_react2.default.createElement(_PublishTitleInput2.default, null)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--5 column--sml-10' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded' },
|
|
_react2.default.createElement(_Dropzone2.default, null)
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--5 column--sml-10 align-content-top' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ id: 'publish-active-area', className: 'row row--padded' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded row--no-top row--wide' },
|
|
_react2.default.createElement(_PublishUrlInput2.default, null)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded row--no-top row--wide' },
|
|
_react2.default.createElement(_ChannelSelect2.default, null)
|
|
),
|
|
this.props.file.type === 'video/mp4' && _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded row--no-top row--wide ' },
|
|
_react2.default.createElement(_PublishThumbnailInput2.default, null)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded row--no-top row--no-bottom row--wide' },
|
|
_react2.default.createElement(_PublishMetadataInputs2.default, null)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--wide align-content-center' },
|
|
_react2.default.createElement(
|
|
'button',
|
|
{ id: 'publish-submit', className: 'button--primary button--large', onClick: this.onPublishSubmit },
|
|
'Publish'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded row--no-bottom align-content-center' },
|
|
_react2.default.createElement(
|
|
'button',
|
|
{ className: 'button--cancel', onClick: this.props.clearFile },
|
|
'Cancel'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--short align-content-center' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'fine-print' },
|
|
'By clicking \'Publish\', you affirm that you have the rights to publish this content to the LBRY network, and that you understand the properties of publishing it to a decentralized, user-controlled network. ',
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: '_blank', href: 'https://lbry.io/learn' },
|
|
'Read more.'
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return PublishDetails;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = (0, _reactRouterDom.withRouter)(PublishDetails);
|
|
|
|
/***/ }),
|
|
/* 103 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _publish = __webpack_require__(5);
|
|
|
|
var _view = __webpack_require__(104);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var publish = _ref.publish;
|
|
|
|
return {
|
|
title: publish.metadata.title
|
|
};
|
|
};
|
|
|
|
var mapDispatchToProps = function mapDispatchToProps(dispatch) {
|
|
return {
|
|
onMetadataChange: function onMetadataChange(name, value) {
|
|
dispatch((0, _publish.updateMetadata)(name, value));
|
|
}
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 104 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var PublishTitleInput = function (_React$Component) {
|
|
_inherits(PublishTitleInput, _React$Component);
|
|
|
|
function PublishTitleInput(props) {
|
|
_classCallCheck(this, PublishTitleInput);
|
|
|
|
var _this = _possibleConstructorReturn(this, (PublishTitleInput.__proto__ || Object.getPrototypeOf(PublishTitleInput)).call(this, props));
|
|
|
|
_this.handleInput = _this.handleInput.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(PublishTitleInput, [{
|
|
key: 'handleInput',
|
|
value: function handleInput(e) {
|
|
var name = e.target.name;
|
|
var value = e.target.value;
|
|
this.props.onMetadataChange(name, value);
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement('input', { type: 'text', id: 'publish-title', className: 'input-text text--large input-text--full-width', name: 'title', placeholder: 'Give your post a title...', onChange: this.handleInput, value: this.props.title });
|
|
}
|
|
}]);
|
|
|
|
return PublishTitleInput;
|
|
}(_react2.default.Component);
|
|
|
|
exports.default = PublishTitleInput;
|
|
|
|
/***/ }),
|
|
/* 105 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _publish = __webpack_require__(5);
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _view = __webpack_require__(106);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var channel = _ref.channel,
|
|
publish = _ref.publish;
|
|
|
|
return {
|
|
loggedInChannelName: channel.loggedInChannel.name,
|
|
loggedInChannelShortId: channel.loggedInChannel.shortId,
|
|
fileName: publish.file.name,
|
|
publishInChannel: publish.publishInChannel,
|
|
selectedChannel: publish.selectedChannel,
|
|
claim: publish.claim,
|
|
urlError: publish.error.url
|
|
};
|
|
};
|
|
|
|
var mapDispatchToProps = function mapDispatchToProps(dispatch) {
|
|
return {
|
|
onClaimChange: function onClaimChange(value) {
|
|
dispatch((0, _publish.updateClaim)(value));
|
|
dispatch((0, _publish.updateError)('publishSubmit', null));
|
|
},
|
|
onUrlError: function onUrlError(value) {
|
|
dispatch((0, _publish.updateError)('url', value));
|
|
}
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 106 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _request = __webpack_require__(10);
|
|
|
|
var _request2 = _interopRequireDefault(_request);
|
|
|
|
var _PublishUrlMiddleDisplay = __webpack_require__(107);
|
|
|
|
var _PublishUrlMiddleDisplay2 = _interopRequireDefault(_PublishUrlMiddleDisplay);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var PublishUrlInput = function (_React$Component) {
|
|
_inherits(PublishUrlInput, _React$Component);
|
|
|
|
function PublishUrlInput(props) {
|
|
_classCallCheck(this, PublishUrlInput);
|
|
|
|
var _this = _possibleConstructorReturn(this, (PublishUrlInput.__proto__ || Object.getPrototypeOf(PublishUrlInput)).call(this, props));
|
|
|
|
_this.handleInput = _this.handleInput.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(PublishUrlInput, [{
|
|
key: 'componentDidMount',
|
|
value: function componentDidMount() {
|
|
var _props = this.props,
|
|
claim = _props.claim,
|
|
fileName = _props.fileName;
|
|
|
|
if (!claim) {
|
|
this.setClaimName(fileName);
|
|
}
|
|
}
|
|
}, {
|
|
key: 'componentWillReceiveProps',
|
|
value: function componentWillReceiveProps(_ref) {
|
|
var claim = _ref.claim,
|
|
fileName = _ref.fileName;
|
|
|
|
// if a new file was chosen, update the claim name
|
|
if (fileName !== this.props.fileName) {
|
|
return this.setClaimName(fileName);
|
|
}
|
|
// if the claim has updated, check its availability
|
|
if (claim !== this.props.claim) {
|
|
this.validateClaim(claim);
|
|
}
|
|
}
|
|
}, {
|
|
key: 'handleInput',
|
|
value: function handleInput(event) {
|
|
var value = event.target.value;
|
|
value = this.cleanseInput(value);
|
|
// update the state
|
|
this.props.onClaimChange(value);
|
|
}
|
|
}, {
|
|
key: 'cleanseInput',
|
|
value: function cleanseInput(input) {
|
|
input = input.replace(/\s+/g, '-'); // replace spaces with dashes
|
|
input = input.replace(/[^A-Za-z0-9-]/g, ''); // remove all characters that are not A-Z, a-z, 0-9, or '-'
|
|
return input;
|
|
}
|
|
}, {
|
|
key: 'setClaimName',
|
|
value: function setClaimName(fileName) {
|
|
var fileNameWithoutEnding = fileName.substring(0, fileName.lastIndexOf('.'));
|
|
var cleanClaimName = this.cleanseInput(fileNameWithoutEnding);
|
|
this.props.onClaimChange(cleanClaimName);
|
|
}
|
|
}, {
|
|
key: 'validateClaim',
|
|
value: function validateClaim(claim) {
|
|
var _this2 = this;
|
|
|
|
if (!claim) {
|
|
return this.props.onUrlError('Enter a url above');
|
|
}
|
|
(0, _request2.default)('/api/claim/availability/' + claim).then(function () {
|
|
_this2.props.onUrlError(null);
|
|
}).catch(function (error) {
|
|
_this2.props.onUrlError(error.message);
|
|
});
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
var _props2 = this.props,
|
|
claim = _props2.claim,
|
|
loggedInChannelName = _props2.loggedInChannelName,
|
|
loggedInChannelShortId = _props2.loggedInChannelShortId,
|
|
publishInChannel = _props2.publishInChannel,
|
|
selectedChannel = _props2.selectedChannel,
|
|
urlError = _props2.urlError;
|
|
|
|
return _react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--10 column--sml-10' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'input-text--primary span--relative' },
|
|
_react2.default.createElement(
|
|
'span',
|
|
{ className: 'url-text--secondary' },
|
|
'spee.ch / '
|
|
),
|
|
_react2.default.createElement(_PublishUrlMiddleDisplay2.default, {
|
|
publishInChannel: publishInChannel,
|
|
selectedChannel: selectedChannel,
|
|
loggedInChannelName: loggedInChannelName,
|
|
loggedInChannelShortId: loggedInChannelShortId
|
|
}),
|
|
_react2.default.createElement('input', { type: 'text', id: 'claim-name-input', className: 'input-text', name: 'claim', placeholder: 'your-url-here', onChange: this.handleInput, value: claim }),
|
|
claim && !urlError && _react2.default.createElement(
|
|
'span',
|
|
{ id: 'input-success-claim-name', className: 'info-message--success span--absolute' },
|
|
'\u2713'
|
|
),
|
|
urlError && _react2.default.createElement(
|
|
'span',
|
|
{ id: 'input-success-channel-name', className: 'info-message--failure span--absolute' },
|
|
'\u2716'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
null,
|
|
urlError ? _react2.default.createElement(
|
|
'p',
|
|
{ id: 'input-error-claim-name', className: 'info-message--failure' },
|
|
urlError
|
|
) : _react2.default.createElement(
|
|
'p',
|
|
{ className: 'info-message' },
|
|
'Choose a custom url'
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return PublishUrlInput;
|
|
}(_react2.default.Component);
|
|
|
|
exports.default = PublishUrlInput;
|
|
|
|
/***/ }),
|
|
/* 107 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _propTypes = __webpack_require__(9);
|
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function UrlMiddle(_ref) {
|
|
var publishInChannel = _ref.publishInChannel,
|
|
selectedChannel = _ref.selectedChannel,
|
|
loggedInChannelName = _ref.loggedInChannelName,
|
|
loggedInChannelShortId = _ref.loggedInChannelShortId;
|
|
|
|
if (publishInChannel) {
|
|
if (selectedChannel === loggedInChannelName) {
|
|
return _react2.default.createElement(
|
|
'span',
|
|
{ id: 'url-channel', className: 'url-text--secondary' },
|
|
loggedInChannelName,
|
|
':',
|
|
loggedInChannelShortId,
|
|
' /'
|
|
);
|
|
}
|
|
return _react2.default.createElement(
|
|
'span',
|
|
{ id: 'url-channel-placeholder', className: 'url-text--secondary tooltip' },
|
|
'@channel',
|
|
_react2.default.createElement(
|
|
'span',
|
|
{
|
|
className: 'tooltip-text' },
|
|
'Select a channel below'
|
|
),
|
|
' /'
|
|
);
|
|
}
|
|
return _react2.default.createElement(
|
|
'span',
|
|
{ id: 'url-no-channel-placeholder', className: 'url-text--secondary tooltip' },
|
|
'xyz',
|
|
_react2.default.createElement(
|
|
'span',
|
|
{ className: 'tooltip-text' },
|
|
'This will be a random id'
|
|
),
|
|
' /'
|
|
);
|
|
}
|
|
|
|
UrlMiddle.propTypes = {
|
|
publishInChannel: _propTypes2.default.bool.isRequired,
|
|
loggedInChannelName: _propTypes2.default.string,
|
|
loggedInChannelShortId: _propTypes2.default.string
|
|
};
|
|
|
|
exports.default = UrlMiddle;
|
|
|
|
/***/ }),
|
|
/* 108 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _publish = __webpack_require__(5);
|
|
|
|
var _view = __webpack_require__(109);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var file = _ref.publish.file;
|
|
|
|
return {
|
|
file: file
|
|
};
|
|
};
|
|
|
|
var mapDispatchToProps = {
|
|
onNewThumbnail: _publish.onNewThumbnail
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 109 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
function dataURItoBlob(dataURI) {
|
|
// convert base64/URLEncoded data component to raw binary data held in a string
|
|
var byteString = atob(dataURI.split(',')[1]);
|
|
// separate out the mime component
|
|
var mimeString = dataURI.split(',')[0].split(':')[1].split(';')[0];
|
|
// write the bytes of the string to a typed array
|
|
var ia = new Uint8Array(byteString.length);
|
|
for (var i = 0; i < byteString.length; i++) {
|
|
ia[i] = byteString.charCodeAt(i);
|
|
}
|
|
return new Blob([ia], { type: mimeString });
|
|
}
|
|
|
|
var PublishThumbnailInput = function (_React$Component) {
|
|
_inherits(PublishThumbnailInput, _React$Component);
|
|
|
|
function PublishThumbnailInput(props) {
|
|
_classCallCheck(this, PublishThumbnailInput);
|
|
|
|
var _this = _possibleConstructorReturn(this, (PublishThumbnailInput.__proto__ || Object.getPrototypeOf(PublishThumbnailInput)).call(this, props));
|
|
|
|
_this.state = {
|
|
videoSource: null,
|
|
error: null,
|
|
sliderMinRange: 1,
|
|
sliderMaxRange: null,
|
|
sliderValue: null
|
|
};
|
|
_this.handleVideoLoadedData = _this.handleVideoLoadedData.bind(_this);
|
|
_this.handleSliderChange = _this.handleSliderChange.bind(_this);
|
|
_this.createThumbnail = _this.createThumbnail.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(PublishThumbnailInput, [{
|
|
key: 'componentDidMount',
|
|
value: function componentDidMount() {
|
|
var file = this.props.file;
|
|
|
|
this.setVideoSource(file);
|
|
}
|
|
}, {
|
|
key: 'componentWillReceiveProps',
|
|
value: function componentWillReceiveProps(nextProps) {
|
|
// if file changes
|
|
if (nextProps.file && nextProps.file !== this.props.file) {
|
|
var file = nextProps.file;
|
|
|
|
this.setVideoSource(file);
|
|
};
|
|
}
|
|
}, {
|
|
key: 'setVideoSource',
|
|
value: function setVideoSource(file) {
|
|
var _this2 = this;
|
|
|
|
var previewReader = new FileReader();
|
|
previewReader.readAsDataURL(file);
|
|
previewReader.onloadend = function () {
|
|
var dataUri = previewReader.result;
|
|
var blob = dataURItoBlob(dataUri);
|
|
var videoSource = URL.createObjectURL(blob);
|
|
_this2.setState({ videoSource: videoSource });
|
|
};
|
|
}
|
|
}, {
|
|
key: 'handleVideoLoadedData',
|
|
value: function handleVideoLoadedData(event) {
|
|
var duration = event.target.duration;
|
|
var totalMinutes = Math.floor(duration / 60);
|
|
var totalSeconds = Math.floor(duration % 60);
|
|
// set the slider
|
|
this.setState({
|
|
sliderMaxRange: duration * 100,
|
|
sliderValue: duration * 100 / 2,
|
|
totalMinutes: totalMinutes,
|
|
totalSeconds: totalSeconds
|
|
});
|
|
// update the current time of the video
|
|
var video = document.getElementById('video-thumb-player');
|
|
video.currentTime = duration / 2;
|
|
}
|
|
}, {
|
|
key: 'handleSliderChange',
|
|
value: function handleSliderChange(event) {
|
|
var value = parseInt(event.target.value);
|
|
// update the slider value
|
|
this.setState({
|
|
sliderValue: value
|
|
});
|
|
// update the current time of the video
|
|
var video = document.getElementById('video-thumb-player');
|
|
video.currentTime = value / 100;
|
|
}
|
|
}, {
|
|
key: 'createThumbnail',
|
|
value: function createThumbnail() {
|
|
// take a snapshot
|
|
var video = document.getElementById('video-thumb-player');
|
|
var canvas = document.createElement('canvas');
|
|
canvas.width = video.videoWidth;
|
|
canvas.height = video.videoHeight;
|
|
canvas.getContext('2d').drawImage(video, 0, 0, canvas.width, canvas.height);
|
|
var dataUrl = canvas.toDataURL();
|
|
var blob = dataURItoBlob(dataUrl);
|
|
var snapshot = new File([blob], 'thumbnail.png', {
|
|
type: 'image/png'
|
|
});
|
|
// set the thumbnail in redux store
|
|
if (snapshot) {
|
|
this.props.onNewThumbnail(snapshot);
|
|
}
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
var _state = this.state,
|
|
error = _state.error,
|
|
videoSource = _state.videoSource,
|
|
sliderMinRange = _state.sliderMinRange,
|
|
sliderMaxRange = _state.sliderMaxRange,
|
|
sliderValue = _state.sliderValue,
|
|
totalMinutes = _state.totalMinutes,
|
|
totalSeconds = _state.totalSeconds;
|
|
|
|
return _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(
|
|
'label',
|
|
{ className: 'label' },
|
|
'Thumbnail:'
|
|
),
|
|
_react2.default.createElement('video', {
|
|
id: 'video-thumb-player',
|
|
preload: 'metadata',
|
|
muted: true,
|
|
style: { display: 'none' },
|
|
playsInline: true,
|
|
onLoadedData: this.handleVideoLoadedData,
|
|
src: videoSource,
|
|
onSeeked: this.createThumbnail
|
|
}),
|
|
sliderValue ? _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'flex-container--row flex-container--space-between-center', style: { width: '100%' } },
|
|
_react2.default.createElement(
|
|
'span',
|
|
{ className: 'info-message' },
|
|
'0\'00"'
|
|
),
|
|
_react2.default.createElement(
|
|
'span',
|
|
{ className: 'info-message' },
|
|
totalMinutes,
|
|
'\'',
|
|
totalSeconds,
|
|
'"'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement('input', {
|
|
type: 'range',
|
|
min: sliderMinRange,
|
|
max: sliderMaxRange,
|
|
value: sliderValue,
|
|
className: 'slider',
|
|
onChange: this.handleSliderChange
|
|
})
|
|
)
|
|
) : _react2.default.createElement(
|
|
'p',
|
|
{ className: 'info-message' },
|
|
'loading... '
|
|
),
|
|
error ? _react2.default.createElement(
|
|
'p',
|
|
{ className: 'info-message--failure' },
|
|
error
|
|
) : _react2.default.createElement(
|
|
'p',
|
|
{ className: 'info-message' },
|
|
'Use slider to set thumbnail'
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return PublishThumbnailInput;
|
|
}(_react2.default.Component);
|
|
|
|
exports.default = PublishThumbnailInput;
|
|
|
|
/***/ }),
|
|
/* 110 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _publish = __webpack_require__(5);
|
|
|
|
var _view = __webpack_require__(111);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var publish = _ref.publish;
|
|
|
|
return {
|
|
showMetadataInputs: publish.showMetadataInputs,
|
|
description: publish.metadata.description,
|
|
license: publish.metadata.license,
|
|
nsfw: publish.metadata.nsfw
|
|
};
|
|
};
|
|
|
|
var mapDispatchToProps = function mapDispatchToProps(dispatch) {
|
|
return {
|
|
onMetadataChange: function onMetadataChange(name, value) {
|
|
dispatch((0, _publish.updateMetadata)(name, value));
|
|
},
|
|
onToggleMetadataInputs: function onToggleMetadataInputs(value) {
|
|
dispatch((0, _publish.toggleMetadataInputs)(value));
|
|
}
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 111 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _ExpandingTextArea = __webpack_require__(112);
|
|
|
|
var _ExpandingTextArea2 = _interopRequireDefault(_ExpandingTextArea);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var PublishMetadataInputs = function (_React$Component) {
|
|
_inherits(PublishMetadataInputs, _React$Component);
|
|
|
|
function PublishMetadataInputs(props) {
|
|
_classCallCheck(this, PublishMetadataInputs);
|
|
|
|
var _this = _possibleConstructorReturn(this, (PublishMetadataInputs.__proto__ || Object.getPrototypeOf(PublishMetadataInputs)).call(this, props));
|
|
|
|
_this.toggleShowInputs = _this.toggleShowInputs.bind(_this);
|
|
_this.handleInput = _this.handleInput.bind(_this);
|
|
_this.handleSelect = _this.handleSelect.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(PublishMetadataInputs, [{
|
|
key: 'toggleShowInputs',
|
|
value: function toggleShowInputs() {
|
|
this.props.onToggleMetadataInputs(!this.props.showMetadataInputs);
|
|
}
|
|
}, {
|
|
key: 'handleInput',
|
|
value: function handleInput(event) {
|
|
var target = event.target;
|
|
var value = target.type === 'checkbox' ? target.checked : target.value;
|
|
var name = target.name;
|
|
this.props.onMetadataChange(name, value);
|
|
}
|
|
}, {
|
|
key: 'handleSelect',
|
|
value: function handleSelect(event) {
|
|
var name = event.target.name;
|
|
var selectedOption = event.target.selectedOptions[0].value;
|
|
this.props.onMetadataChange(name, selectedOption);
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement(
|
|
'div',
|
|
{ id: 'publish-details', className: 'row row--padded row--no-top row--wide' },
|
|
this.props.showMetadataInputs && _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--no-top' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--3 column--med-10 align-content-top' },
|
|
_react2.default.createElement(
|
|
'label',
|
|
{ htmlFor: 'publish-license', className: 'label' },
|
|
'Description:'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--7 column--sml-10' },
|
|
_react2.default.createElement(_ExpandingTextArea2.default, {
|
|
id: 'publish-description',
|
|
className: 'textarea textarea--primary textarea--full-width',
|
|
rows: 1,
|
|
maxLength: 2000,
|
|
style: { maxHeight: 200 },
|
|
name: 'description',
|
|
placeholder: 'Optional description',
|
|
value: this.props.description,
|
|
onChange: this.handleInput })
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--no-top' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--3 column--med-10' },
|
|
_react2.default.createElement(
|
|
'label',
|
|
{ htmlFor: 'publish-license', className: 'label' },
|
|
'License:'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--7 column--sml-10' },
|
|
_react2.default.createElement(
|
|
'select',
|
|
{ type: 'text', name: 'license', id: 'publish-license', className: 'select select--primary', onChange: this.handleSelect },
|
|
_react2.default.createElement(
|
|
'option',
|
|
{ value: ' ' },
|
|
'Unspecified'
|
|
),
|
|
_react2.default.createElement(
|
|
'option',
|
|
{ value: 'Public Domain' },
|
|
'Public Domain'
|
|
),
|
|
_react2.default.createElement(
|
|
'option',
|
|
{ value: 'Creative Commons' },
|
|
'Creative Commons'
|
|
)
|
|
)
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--no-top' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--3' },
|
|
_react2.default.createElement(
|
|
'label',
|
|
{ htmlFor: 'publish-nsfw', className: 'label' },
|
|
'Mature:'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--7' },
|
|
_react2.default.createElement('input', { className: 'input-checkbox', type: 'checkbox', id: 'publish-nsfw', name: 'nsfw', value: this.props.nsfw, onChange: this.handleInput })
|
|
)
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'button',
|
|
{ className: 'button--secondary', onClick: this.toggleShowInputs },
|
|
this.props.showMetadataInputs ? 'less' : 'more'
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return PublishMetadataInputs;
|
|
}(_react2.default.Component);
|
|
|
|
exports.default = PublishMetadataInputs;
|
|
|
|
/***/ }),
|
|
/* 112 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _propTypes = __webpack_require__(9);
|
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var ExpandingTextarea = function (_Component) {
|
|
_inherits(ExpandingTextarea, _Component);
|
|
|
|
function ExpandingTextarea(props) {
|
|
_classCallCheck(this, ExpandingTextarea);
|
|
|
|
var _this = _possibleConstructorReturn(this, (ExpandingTextarea.__proto__ || Object.getPrototypeOf(ExpandingTextarea)).call(this, props));
|
|
|
|
_this._handleChange = _this._handleChange.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ExpandingTextarea, [{
|
|
key: 'componentDidMount',
|
|
value: function componentDidMount() {
|
|
this.adjustTextarea({});
|
|
}
|
|
}, {
|
|
key: '_handleChange',
|
|
value: function _handleChange(event) {
|
|
var onChange = this.props.onChange;
|
|
|
|
if (onChange) onChange(event);
|
|
this.adjustTextarea(event);
|
|
}
|
|
}, {
|
|
key: 'adjustTextarea',
|
|
value: function adjustTextarea(_ref) {
|
|
var _ref$target = _ref.target,
|
|
target = _ref$target === undefined ? this.el : _ref$target;
|
|
|
|
target.style.height = 0;
|
|
target.style.height = target.scrollHeight + 'px';
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var rest = _objectWithoutProperties(this.props, []);
|
|
|
|
return _react2.default.createElement('textarea', _extends({}, rest, {
|
|
ref: function ref(x) {
|
|
return _this2.el = x;
|
|
},
|
|
onChange: this._handleChange
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return ExpandingTextarea;
|
|
}(_react.Component);
|
|
|
|
ExpandingTextarea.propTypes = {
|
|
onChange: _propTypes2.default.func
|
|
};
|
|
|
|
exports.default = ExpandingTextarea;
|
|
|
|
/***/ }),
|
|
/* 113 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _publish = __webpack_require__(5);
|
|
|
|
var _view = __webpack_require__(114);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var channel = _ref.channel,
|
|
publish = _ref.publish;
|
|
|
|
return {
|
|
loggedInChannelName: channel.loggedInChannel.name,
|
|
publishInChannel: publish.publishInChannel,
|
|
selectedChannel: publish.selectedChannel,
|
|
channelError: publish.error.channel
|
|
};
|
|
};
|
|
|
|
var mapDispatchToProps = function mapDispatchToProps(dispatch) {
|
|
return {
|
|
onPublishInChannelChange: function onPublishInChannelChange(value) {
|
|
dispatch((0, _publish.updateError)('channel', null));
|
|
dispatch((0, _publish.setPublishInChannel)(value));
|
|
},
|
|
onChannelSelect: function onChannelSelect(value) {
|
|
dispatch((0, _publish.updateError)('channel', null));
|
|
dispatch((0, _publish.updateSelectedChannel)(value));
|
|
}
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 114 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _ChannelLoginForm = __webpack_require__(40);
|
|
|
|
var _ChannelLoginForm2 = _interopRequireDefault(_ChannelLoginForm);
|
|
|
|
var _ChannelCreateForm = __webpack_require__(41);
|
|
|
|
var _ChannelCreateForm2 = _interopRequireDefault(_ChannelCreateForm);
|
|
|
|
var _publish_channel_select_states = __webpack_require__(34);
|
|
|
|
var states = _interopRequireWildcard(_publish_channel_select_states);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var ChannelSelect = function (_React$Component) {
|
|
_inherits(ChannelSelect, _React$Component);
|
|
|
|
function ChannelSelect(props) {
|
|
_classCallCheck(this, ChannelSelect);
|
|
|
|
var _this = _possibleConstructorReturn(this, (ChannelSelect.__proto__ || Object.getPrototypeOf(ChannelSelect)).call(this, props));
|
|
|
|
_this.toggleAnonymousPublish = _this.toggleAnonymousPublish.bind(_this);
|
|
_this.handleSelection = _this.handleSelection.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ChannelSelect, [{
|
|
key: 'toggleAnonymousPublish',
|
|
value: function toggleAnonymousPublish(event) {
|
|
var value = event.target.value;
|
|
if (value === 'anonymous') {
|
|
this.props.onPublishInChannelChange(false);
|
|
} else {
|
|
this.props.onPublishInChannelChange(true);
|
|
}
|
|
}
|
|
}, {
|
|
key: 'handleSelection',
|
|
value: function handleSelection(event) {
|
|
var selectedOption = event.target.selectedOptions[0].value;
|
|
this.props.onChannelSelect(selectedOption);
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(
|
|
'form',
|
|
null,
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--3 column--med-10' },
|
|
_react2.default.createElement('input', { type: 'radio', name: 'anonymous-or-channel', id: 'anonymous-radio', className: 'input-radio', value: 'anonymous', checked: !this.props.publishInChannel, onChange: this.toggleAnonymousPublish }),
|
|
_react2.default.createElement(
|
|
'label',
|
|
{ className: 'label label--pointer', htmlFor: 'anonymous-radio' },
|
|
'Anonymous'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--7 column--med-10' },
|
|
_react2.default.createElement('input', { type: 'radio', name: 'anonymous-or-channel', id: 'channel-radio', className: 'input-radio', value: 'in a channel', checked: this.props.publishInChannel, onChange: this.toggleAnonymousPublish }),
|
|
_react2.default.createElement(
|
|
'label',
|
|
{ className: 'label label--pointer', htmlFor: 'channel-radio' },
|
|
'In a channel'
|
|
)
|
|
),
|
|
this.props.channelError ? _react2.default.createElement(
|
|
'p',
|
|
{ className: 'info-message--failure' },
|
|
this.props.channelError
|
|
) : _react2.default.createElement(
|
|
'p',
|
|
{ className: 'info-message' },
|
|
'Publish anonymously or in a channel'
|
|
)
|
|
),
|
|
this.props.publishInChannel && _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--3' },
|
|
_react2.default.createElement(
|
|
'label',
|
|
{ className: 'label', htmlFor: 'channel-name-select' },
|
|
'Channel:'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--7' },
|
|
_react2.default.createElement(
|
|
'select',
|
|
{ type: 'text', id: 'channel-name-select', className: 'select select--arrow', value: this.props.selectedChannel, onChange: this.handleSelection },
|
|
this.props.loggedInChannelName && _react2.default.createElement(
|
|
'option',
|
|
{ value: this.props.loggedInChannelName, id: 'publish-channel-select-channel-option' },
|
|
this.props.loggedInChannelName
|
|
),
|
|
_react2.default.createElement(
|
|
'option',
|
|
{ value: states.LOGIN },
|
|
'Existing'
|
|
),
|
|
_react2.default.createElement(
|
|
'option',
|
|
{ value: states.CREATE },
|
|
'New'
|
|
)
|
|
)
|
|
),
|
|
this.props.selectedChannel === states.LOGIN && _react2.default.createElement(_ChannelLoginForm2.default, null),
|
|
this.props.selectedChannel === states.CREATE && _react2.default.createElement(_ChannelCreateForm2.default, null)
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return ChannelSelect;
|
|
}(_react2.default.Component);
|
|
|
|
exports.default = ChannelSelect;
|
|
|
|
/***/ }),
|
|
/* 115 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _request = __webpack_require__(10);
|
|
|
|
var _request2 = _interopRequireDefault(_request);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
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 _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var ChannelLoginForm = function (_React$Component) {
|
|
_inherits(ChannelLoginForm, _React$Component);
|
|
|
|
function ChannelLoginForm(props) {
|
|
_classCallCheck(this, ChannelLoginForm);
|
|
|
|
var _this = _possibleConstructorReturn(this, (ChannelLoginForm.__proto__ || Object.getPrototypeOf(ChannelLoginForm)).call(this, props));
|
|
|
|
_this.state = {
|
|
error: null,
|
|
name: '',
|
|
password: ''
|
|
};
|
|
_this.handleInput = _this.handleInput.bind(_this);
|
|
_this.loginToChannel = _this.loginToChannel.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ChannelLoginForm, [{
|
|
key: 'handleInput',
|
|
value: function handleInput(event) {
|
|
var name = event.target.name;
|
|
var value = event.target.value;
|
|
this.setState(_defineProperty({}, name, value));
|
|
}
|
|
}, {
|
|
key: 'loginToChannel',
|
|
value: function loginToChannel(event) {
|
|
var _this2 = this;
|
|
|
|
event.preventDefault();
|
|
var params = {
|
|
method: 'POST',
|
|
body: JSON.stringify({ username: this.state.name, password: this.state.password }),
|
|
headers: new Headers({
|
|
'Content-Type': 'application/json'
|
|
}),
|
|
credentials: 'include'
|
|
};
|
|
(0, _request2.default)('login', params).then(function (_ref) {
|
|
var success = _ref.success,
|
|
channelName = _ref.channelName,
|
|
shortChannelId = _ref.shortChannelId,
|
|
channelClaimId = _ref.channelClaimId,
|
|
message = _ref.message;
|
|
|
|
if (success) {
|
|
_this2.props.onChannelLogin(channelName, shortChannelId, channelClaimId);
|
|
} else {
|
|
_this2.setState({ 'error': message });
|
|
};
|
|
}).catch(function (error) {
|
|
if (error.message) {
|
|
_this2.setState({ 'error': error.message });
|
|
} else {
|
|
_this2.setState({ 'error': error });
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement(
|
|
'form',
|
|
{ id: 'channel-login-form' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--wide row--short' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--3 column--sml-10' },
|
|
_react2.default.createElement(
|
|
'label',
|
|
{ className: 'label', htmlFor: 'channel-login-name-input' },
|
|
'Name:'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--6 column--sml-10' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'input-text--primary flex-container--row flex-container--left-bottom' },
|
|
_react2.default.createElement(
|
|
'span',
|
|
null,
|
|
'@'
|
|
),
|
|
_react2.default.createElement('input', { type: 'text', id: 'channel-login-name-input', className: 'input-text', name: 'name', placeholder: 'Your Channel Name', value: this.state.channelName, onChange: this.handleInput })
|
|
)
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--wide row--short' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--3 column--sml-10' },
|
|
_react2.default.createElement(
|
|
'label',
|
|
{ className: 'label', htmlFor: 'channel-login-password-input' },
|
|
'Password:'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--6 column--sml-10' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'input-text--primary' },
|
|
_react2.default.createElement('input', { type: 'password', id: 'channel-login-password-input', name: 'password', className: 'input-text', placeholder: '', value: this.state.channelPassword, onChange: this.handleInput })
|
|
)
|
|
)
|
|
),
|
|
this.state.error ? _react2.default.createElement(
|
|
'p',
|
|
{ className: 'info-message--failure' },
|
|
this.state.error
|
|
) : _react2.default.createElement(
|
|
'p',
|
|
{ className: 'info-message' },
|
|
'Enter the name and password for your channel'
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--wide' },
|
|
_react2.default.createElement(
|
|
'button',
|
|
{ className: 'button--primary', onClick: this.loginToChannel },
|
|
'Authenticate'
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return ChannelLoginForm;
|
|
}(_react2.default.Component);
|
|
|
|
exports.default = ChannelLoginForm;
|
|
|
|
/***/ }),
|
|
/* 116 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _ProgressBar = __webpack_require__(20);
|
|
|
|
var _ProgressBar2 = _interopRequireDefault(_ProgressBar);
|
|
|
|
var _request = __webpack_require__(10);
|
|
|
|
var _request2 = _interopRequireDefault(_request);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
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 _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var ChannelCreateForm = function (_React$Component) {
|
|
_inherits(ChannelCreateForm, _React$Component);
|
|
|
|
function ChannelCreateForm(props) {
|
|
_classCallCheck(this, ChannelCreateForm);
|
|
|
|
var _this = _possibleConstructorReturn(this, (ChannelCreateForm.__proto__ || Object.getPrototypeOf(ChannelCreateForm)).call(this, props));
|
|
|
|
_this.state = {
|
|
error: null,
|
|
channel: '',
|
|
password: '',
|
|
status: null
|
|
};
|
|
_this.handleChannelInput = _this.handleChannelInput.bind(_this);
|
|
_this.handleInput = _this.handleInput.bind(_this);
|
|
_this.createChannel = _this.createChannel.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ChannelCreateForm, [{
|
|
key: 'cleanseChannelInput',
|
|
value: function cleanseChannelInput(input) {
|
|
input = input.replace(/\s+/g, '-'); // replace spaces with dashes
|
|
input = input.replace(/[^A-Za-z0-9-]/g, ''); // remove all characters that are not A-Z, a-z, 0-9, or '-'
|
|
return input;
|
|
}
|
|
}, {
|
|
key: 'handleChannelInput',
|
|
value: function handleChannelInput(event) {
|
|
var value = event.target.value;
|
|
value = this.cleanseChannelInput(value);
|
|
this.setState({ channel: value });
|
|
if (value) {
|
|
this.updateIsChannelAvailable(value);
|
|
} else {
|
|
this.setState({ error: 'Please enter a channel name' });
|
|
}
|
|
}
|
|
}, {
|
|
key: 'handleInput',
|
|
value: function handleInput(event) {
|
|
var name = event.target.name;
|
|
var value = event.target.value;
|
|
this.setState(_defineProperty({}, name, value));
|
|
}
|
|
}, {
|
|
key: 'updateIsChannelAvailable',
|
|
value: function updateIsChannelAvailable(channel) {
|
|
var _this2 = this;
|
|
|
|
var channelWithAtSymbol = '@' + channel;
|
|
(0, _request2.default)('/api/channel/availability/' + channelWithAtSymbol).then(function (isAvailable) {
|
|
if (isAvailable) {
|
|
_this2.setState({ 'error': null });
|
|
} else {
|
|
_this2.setState({ 'error': 'That channel has already been claimed' });
|
|
}
|
|
}).catch(function (error) {
|
|
_this2.setState({ 'error': error.message });
|
|
});
|
|
}
|
|
}, {
|
|
key: 'checkIsChannelAvailable',
|
|
value: function checkIsChannelAvailable(channel) {
|
|
var channelWithAtSymbol = '@' + channel;
|
|
return new Promise(function (resolve, reject) {
|
|
(0, _request2.default)('/api/channel/availability/' + channelWithAtSymbol).then(function (isAvailable) {
|
|
if (!isAvailable) {
|
|
return reject(new Error('That channel has already been claimed'));
|
|
}
|
|
resolve();
|
|
}).catch(function (error) {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: 'checkIsPasswordProvided',
|
|
value: function checkIsPasswordProvided() {
|
|
var password = this.state.password;
|
|
return new Promise(function (resolve, reject) {
|
|
if (!password || password.length < 1) {
|
|
return reject(new Error('Please provide a password'));
|
|
}
|
|
resolve();
|
|
});
|
|
}
|
|
}, {
|
|
key: 'makePublishChannelRequest',
|
|
value: function makePublishChannelRequest(username, password) {
|
|
var params = {
|
|
method: 'POST',
|
|
body: JSON.stringify({ username: username, password: password }),
|
|
headers: new Headers({
|
|
'Content-Type': 'application/json'
|
|
}),
|
|
credentials: 'include'
|
|
};
|
|
return new Promise(function (resolve, reject) {
|
|
(0, _request2.default)('/signup', params).then(function (result) {
|
|
return resolve(result);
|
|
}).catch(function (error) {
|
|
reject(new Error('Unfortunately, we encountered an error while creating your channel. Please let us know in Discord! ' + error.message));
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: 'createChannel',
|
|
value: function createChannel(event) {
|
|
var _this3 = this;
|
|
|
|
event.preventDefault();
|
|
this.checkIsPasswordProvided().then(function () {
|
|
return _this3.checkIsChannelAvailable(_this3.state.channel, _this3.state.password);
|
|
}).then(function () {
|
|
_this3.setState({ status: 'We are publishing your new channel. Sit tight...' });
|
|
return _this3.makePublishChannelRequest(_this3.state.channel, _this3.state.password);
|
|
}).then(function (result) {
|
|
_this3.setState({ status: null });
|
|
_this3.props.onChannelLogin(result.channelName, result.shortChannelId, result.channelClaimId);
|
|
}).catch(function (error) {
|
|
_this3.setState({ 'error': error.message, status: null });
|
|
});
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
!this.state.status ? _react2.default.createElement(
|
|
'form',
|
|
{ id: 'publish-channel-form' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--wide row--short' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--3 column--sml-10' },
|
|
_react2.default.createElement(
|
|
'label',
|
|
{ className: 'label', htmlFor: 'new-channel-name' },
|
|
'Name:'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--6 column--sml-10' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'input-text--primary flex-container--row flex-container--left-bottom span--relative' },
|
|
_react2.default.createElement(
|
|
'span',
|
|
null,
|
|
'@'
|
|
),
|
|
_react2.default.createElement('input', { type: 'text', name: 'channel', id: 'new-channel-name', className: 'input-text', placeholder: 'exampleChannelName', value: this.state.channel, onChange: this.handleChannelInput }),
|
|
this.state.channel && !this.state.error && _react2.default.createElement(
|
|
'span',
|
|
{ id: 'input-success-channel-name', className: 'info-message--success span--absolute' },
|
|
'\u2713'
|
|
),
|
|
this.state.error && _react2.default.createElement(
|
|
'span',
|
|
{ id: 'input-success-channel-name', className: 'info-message--failure span--absolute' },
|
|
'\u2716'
|
|
)
|
|
)
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--wide row--short' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--3 column--sml-10' },
|
|
_react2.default.createElement(
|
|
'label',
|
|
{ className: 'label', htmlFor: 'new-channel-password' },
|
|
'Password:'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--6 column--sml-10' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'input-text--primary' },
|
|
_react2.default.createElement('input', { type: 'password', name: 'password', id: 'new-channel-password', className: 'input-text', placeholder: '', value: this.state.password, onChange: this.handleInput })
|
|
)
|
|
)
|
|
),
|
|
this.state.error ? _react2.default.createElement(
|
|
'p',
|
|
{ className: 'info-message--failure' },
|
|
this.state.error
|
|
) : _react2.default.createElement(
|
|
'p',
|
|
{ className: 'info-message' },
|
|
'Choose a name and password for your channel'
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--wide' },
|
|
_react2.default.createElement(
|
|
'button',
|
|
{ className: 'button--primary', onClick: this.createChannel },
|
|
'Create Channel'
|
|
)
|
|
)
|
|
) : _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'fine-print' },
|
|
this.state.status
|
|
),
|
|
_react2.default.createElement(_ProgressBar2.default, { size: 12 })
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return ChannelCreateForm;
|
|
}(_react2.default.Component);
|
|
|
|
exports.default = ChannelCreateForm;
|
|
|
|
/***/ }),
|
|
/* 117 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var ActiveStatusBar = function ActiveStatusBar() {
|
|
return _react2.default.createElement(
|
|
'span',
|
|
{ className: 'progress-bar progress-bar--active' },
|
|
'| '
|
|
);
|
|
};
|
|
|
|
exports.default = ActiveStatusBar;
|
|
|
|
/***/ }),
|
|
/* 118 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var InactiveStatusBar = function InactiveStatusBar() {
|
|
return _react2.default.createElement(
|
|
'span',
|
|
{ className: 'progress-bar progress-bar--inactive' },
|
|
'| '
|
|
);
|
|
};
|
|
|
|
exports.default = InactiveStatusBar;
|
|
|
|
/***/ }),
|
|
/* 119 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _publish = __webpack_require__(5);
|
|
|
|
var _view = __webpack_require__(120);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var publish = _ref.publish;
|
|
|
|
return {
|
|
status: publish.status.status,
|
|
message: publish.status.message
|
|
};
|
|
};
|
|
|
|
var mapDispatchToProps = {
|
|
clearFile: _publish.clearFile
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 120 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _ProgressBar = __webpack_require__(20);
|
|
|
|
var _ProgressBar2 = _interopRequireDefault(_ProgressBar);
|
|
|
|
var _publish_claim_states = __webpack_require__(121);
|
|
|
|
var publishStates = _interopRequireWildcard(_publish_claim_states);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var PublishStatus = function (_React$Component) {
|
|
_inherits(PublishStatus, _React$Component);
|
|
|
|
function PublishStatus() {
|
|
_classCallCheck(this, PublishStatus);
|
|
|
|
return _possibleConstructorReturn(this, (PublishStatus.__proto__ || Object.getPrototypeOf(PublishStatus)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(PublishStatus, [{
|
|
key: 'render',
|
|
value: function render() {
|
|
var _props = this.props,
|
|
status = _props.status,
|
|
message = _props.message,
|
|
clearFile = _props.clearFile;
|
|
|
|
return _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--tall flex-container--column flex-container--center-center' },
|
|
status === publishStates.LOAD_START && _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row align-content-center' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'File is loading to server'
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'blue' },
|
|
'0%'
|
|
)
|
|
),
|
|
status === publishStates.LOADING && _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row align-content-center' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'File is loading to server'
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'blue' },
|
|
message
|
|
)
|
|
)
|
|
),
|
|
status === publishStates.PUBLISHING && _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row align-content-center' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Upload complete. Your file is now being published on the blockchain...'
|
|
),
|
|
_react2.default.createElement(_ProgressBar2.default, { size: 12 }),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Curious what magic is happening here? ',
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: 'blank', href: 'https://lbry.io/faq/what-is-lbry' },
|
|
'Learn more.'
|
|
)
|
|
)
|
|
),
|
|
status === publishStates.SUCCESS && _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row align-content-center' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Your publish is complete! You are being redirected to it now.'
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'If you are not automatically redirected, ',
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: '_blank', href: message },
|
|
'click here.'
|
|
)
|
|
)
|
|
),
|
|
status === publishStates.FAILED && _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row align-content-center' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Something went wrong...'
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
_react2.default.createElement(
|
|
'strong',
|
|
null,
|
|
message
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'For help, post the above error text in the #speech channel on the ',
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', href: 'https://discord.gg/YjYbwhS', target: '_blank' },
|
|
'lbry discord'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'button',
|
|
{ className: 'button--secondary', onClick: clearFile },
|
|
'Reset'
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return PublishStatus;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = PublishStatus;
|
|
|
|
/***/ }),
|
|
/* 121 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var LOAD_START = exports.LOAD_START = 'LOAD_START';
|
|
var LOADING = exports.LOADING = 'LOADING';
|
|
var PUBLISHING = exports.PUBLISHING = 'PUBLISHING';
|
|
var SUCCESS = exports.SUCCESS = 'SUCCESS';
|
|
var FAILED = exports.FAILED = 'FAILED';
|
|
|
|
/***/ }),
|
|
/* 122 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _NavBar = __webpack_require__(6);
|
|
|
|
var _NavBar2 = _interopRequireDefault(_NavBar);
|
|
|
|
var _SEO = __webpack_require__(8);
|
|
|
|
var _SEO2 = _interopRequireDefault(_SEO);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var AboutPage = function (_React$Component) {
|
|
_inherits(AboutPage, _React$Component);
|
|
|
|
function AboutPage() {
|
|
_classCallCheck(this, AboutPage);
|
|
|
|
return _possibleConstructorReturn(this, (AboutPage.__proto__ || Object.getPrototypeOf(AboutPage)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(AboutPage, [{
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(_SEO2.default, { pageTitle: 'About', pageUri: 'about' }),
|
|
_react2.default.createElement(_NavBar2.default, null),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--5 column--med-10 align-content-top' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--8 column--med-10' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'pull-quote' },
|
|
'Spee.ch is an open-source project. Please contribute to the existing site, or fork it and make your own.'
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: '_blank', href: 'https://twitter.com/spee_ch' },
|
|
'TWITTER'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: '_blank', href: 'https://github.com/lbryio/spee.ch' },
|
|
'GITHUB'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: '_blank', href: 'https://discord.gg/YjYbwhS' },
|
|
'DISCORD CHANNEL'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: '_blank', href: 'https://github.com/lbryio/spee.ch/blob/master/README.md' },
|
|
'DOCUMENTATION'
|
|
)
|
|
)
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--5 column--med-10 align-content-top' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--8 column--med-10' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Spee.ch is a media-hosting site that reads from and publishes content to the ',
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', href: 'https://lbry.io' },
|
|
'LBRY'
|
|
),
|
|
' blockchain.'
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Spee.ch is a hosting service, but with the added benefit that it stores your content on a decentralized network of computers -- the LBRY network. This means that your images are stored in multiple locations without a single point of failure.'
|
|
),
|
|
_react2.default.createElement(
|
|
'h3',
|
|
null,
|
|
'Contribute'
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'If you have an idea for your own spee.ch-like site on top of LBRY, fork our ',
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', href: 'https://github.com/lbryio/spee.ch' },
|
|
'github repo'
|
|
),
|
|
' and go to town!'
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'If you want to improve spee.ch, join our ',
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', href: 'https://discord.gg/YjYbwhS' },
|
|
'discord channel'
|
|
),
|
|
' or solve one of our ',
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', href: 'https://github.com/lbryio/spee.ch/issues' },
|
|
'github issues'
|
|
),
|
|
'.'
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return AboutPage;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = AboutPage;
|
|
|
|
/***/ }),
|
|
/* 123 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _view = __webpack_require__(124);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var channel = _ref.channel;
|
|
|
|
return {
|
|
loggedInChannelName: channel.loggedInChannel.name
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, null)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 124 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _reactRouterDom = __webpack_require__(4);
|
|
|
|
var _SEO = __webpack_require__(8);
|
|
|
|
var _SEO2 = _interopRequireDefault(_SEO);
|
|
|
|
var _NavBar = __webpack_require__(6);
|
|
|
|
var _NavBar2 = _interopRequireDefault(_NavBar);
|
|
|
|
var _ChannelLoginForm = __webpack_require__(40);
|
|
|
|
var _ChannelLoginForm2 = _interopRequireDefault(_ChannelLoginForm);
|
|
|
|
var _ChannelCreateForm = __webpack_require__(41);
|
|
|
|
var _ChannelCreateForm2 = _interopRequireDefault(_ChannelCreateForm);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var LoginPage = function (_React$Component) {
|
|
_inherits(LoginPage, _React$Component);
|
|
|
|
function LoginPage() {
|
|
_classCallCheck(this, LoginPage);
|
|
|
|
return _possibleConstructorReturn(this, (LoginPage.__proto__ || Object.getPrototypeOf(LoginPage)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(LoginPage, [{
|
|
key: 'componentWillReceiveProps',
|
|
value: function componentWillReceiveProps(newProps) {
|
|
// re-route the user to the homepage if the user is logged in
|
|
if (newProps.loggedInChannelName !== this.props.loggedInChannelName) {
|
|
this.props.history.push('/');
|
|
}
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(_SEO2.default, { pageTitle: 'Login', pageUri: 'login' }),
|
|
_react2.default.createElement(_NavBar2.default, null),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--5 column--med-10 align-content-top' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--8 column--med-10' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Channels allow you to publish and group content under an identity. You can create a channel for yourself, or share one with like-minded friends. You can create 1 channel, or 100, so whether you\'re ',
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: '_blank', href: '/@catalonia2017:43dcf47163caa21d8404d9fe9b30f78ef3e146a8' },
|
|
'documenting important events'
|
|
),
|
|
', or making a public repository for ',
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: '_blank', href: '/@catGifs' },
|
|
'cat gifs'
|
|
),
|
|
' (password: \'1234\'), try creating a channel for it!'
|
|
)
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--5 column--med-10 align-content-top' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--8 column--med-10' },
|
|
_react2.default.createElement(
|
|
'h3',
|
|
{ className: 'h3--no-bottom' },
|
|
'Log in to an existing channel:'
|
|
),
|
|
_react2.default.createElement(_ChannelLoginForm2.default, null),
|
|
_react2.default.createElement(
|
|
'h3',
|
|
{ className: 'h3--no-bottom' },
|
|
'Create a brand new channel:'
|
|
),
|
|
_react2.default.createElement(_ChannelCreateForm2.default, null)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return LoginPage;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = (0, _reactRouterDom.withRouter)(LoginPage);
|
|
|
|
/***/ }),
|
|
/* 125 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _show = __webpack_require__(7);
|
|
|
|
var _view = __webpack_require__(126);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var show = _ref.show;
|
|
|
|
return {
|
|
error: show.request.error,
|
|
requestType: show.request.type
|
|
};
|
|
};
|
|
|
|
var mapDispatchToProps = {
|
|
onHandleShowPageUri: _show.onHandleShowPageUri
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 126 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _ErrorPage = __webpack_require__(21);
|
|
|
|
var _ErrorPage2 = _interopRequireDefault(_ErrorPage);
|
|
|
|
var _ShowAssetLite = __webpack_require__(127);
|
|
|
|
var _ShowAssetLite2 = _interopRequireDefault(_ShowAssetLite);
|
|
|
|
var _ShowAssetDetails = __webpack_require__(130);
|
|
|
|
var _ShowAssetDetails2 = _interopRequireDefault(_ShowAssetDetails);
|
|
|
|
var _ShowChannel = __webpack_require__(136);
|
|
|
|
var _ShowChannel2 = _interopRequireDefault(_ShowChannel);
|
|
|
|
var _show_request_types = __webpack_require__(42);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var ShowPage = function (_React$Component) {
|
|
_inherits(ShowPage, _React$Component);
|
|
|
|
function ShowPage() {
|
|
_classCallCheck(this, ShowPage);
|
|
|
|
return _possibleConstructorReturn(this, (ShowPage.__proto__ || Object.getPrototypeOf(ShowPage)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(ShowPage, [{
|
|
key: 'componentDidMount',
|
|
value: function componentDidMount() {
|
|
this.props.onHandleShowPageUri(this.props.match.params);
|
|
}
|
|
}, {
|
|
key: 'componentWillReceiveProps',
|
|
value: function componentWillReceiveProps(nextProps) {
|
|
if (nextProps.match.params !== this.props.match.params) {
|
|
this.props.onHandleShowPageUri(nextProps.match.params);
|
|
}
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
var _props = this.props,
|
|
error = _props.error,
|
|
requestType = _props.requestType;
|
|
|
|
if (error) {
|
|
return _react2.default.createElement(_ErrorPage2.default, { error: error });
|
|
}
|
|
switch (requestType) {
|
|
case _show_request_types.CHANNEL:
|
|
return _react2.default.createElement(_ShowChannel2.default, null);
|
|
case _show_request_types.ASSET_LITE:
|
|
return _react2.default.createElement(_ShowAssetLite2.default, null);
|
|
case _show_request_types.ASSET_DETAILS:
|
|
return _react2.default.createElement(_ShowAssetDetails2.default, null);
|
|
default:
|
|
return _react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'loading...'
|
|
);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return ShowPage;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = ShowPage;
|
|
|
|
/***/ }),
|
|
/* 127 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _view = __webpack_require__(128);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var show = _ref.show;
|
|
|
|
// select request info
|
|
var requestId = show.request.id;
|
|
// select asset info
|
|
var asset = void 0;
|
|
var request = show.requestList[requestId] || null;
|
|
var assetList = show.assetList;
|
|
if (request && assetList) {
|
|
var assetKey = request.key; // note: just store this in the request
|
|
asset = assetList[assetKey] || null;
|
|
};
|
|
// return props
|
|
return {
|
|
asset: asset
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, null)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 128 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _SEO = __webpack_require__(8);
|
|
|
|
var _SEO2 = _interopRequireDefault(_SEO);
|
|
|
|
var _reactRouterDom = __webpack_require__(4);
|
|
|
|
var _AssetDisplay = __webpack_require__(43);
|
|
|
|
var _AssetDisplay2 = _interopRequireDefault(_AssetDisplay);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var ShowLite = function (_React$Component) {
|
|
_inherits(ShowLite, _React$Component);
|
|
|
|
function ShowLite() {
|
|
_classCallCheck(this, ShowLite);
|
|
|
|
return _possibleConstructorReturn(this, (ShowLite.__proto__ || Object.getPrototypeOf(ShowLite)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(ShowLite, [{
|
|
key: 'render',
|
|
value: function render() {
|
|
var asset = this.props.asset;
|
|
|
|
if (asset) {
|
|
var _asset$claimData = asset.claimData,
|
|
name = _asset$claimData.name,
|
|
claimId = _asset$claimData.claimId;
|
|
|
|
return _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--tall flex-container--column flex-container--center-center show-lite-container' },
|
|
_react2.default.createElement(_SEO2.default, { pageTitle: name, asset: asset }),
|
|
_react2.default.createElement(_AssetDisplay2.default, null),
|
|
_react2.default.createElement(
|
|
_reactRouterDom.Link,
|
|
{ id: 'asset-boilerpate', className: 'link--primary fine-print', to: '/' + claimId + '/' + name },
|
|
'hosted via Spee.ch'
|
|
)
|
|
);
|
|
}
|
|
return _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--tall row--padded flex-container--column flex-container--center-center' },
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'loading asset data...'
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return ShowLite;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = ShowLite;
|
|
|
|
/***/ }),
|
|
/* 129 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _ProgressBar = __webpack_require__(20);
|
|
|
|
var _ProgressBar2 = _interopRequireDefault(_ProgressBar);
|
|
|
|
var _asset_display_states = __webpack_require__(36);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var AssetDisplay = function (_React$Component) {
|
|
_inherits(AssetDisplay, _React$Component);
|
|
|
|
function AssetDisplay() {
|
|
_classCallCheck(this, AssetDisplay);
|
|
|
|
return _possibleConstructorReturn(this, (AssetDisplay.__proto__ || Object.getPrototypeOf(AssetDisplay)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(AssetDisplay, [{
|
|
key: 'componentDidMount',
|
|
value: function componentDidMount() {
|
|
var _props$asset$claimDat = this.props.asset.claimData,
|
|
name = _props$asset$claimDat.name,
|
|
claimId = _props$asset$claimDat.claimId;
|
|
|
|
this.props.onFileRequest(name, claimId);
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
var _props = this.props,
|
|
status = _props.status,
|
|
error = _props.error,
|
|
_props$asset$claimDat2 = _props.asset.claimData,
|
|
name = _props$asset$claimDat2.name,
|
|
claimId = _props$asset$claimDat2.claimId,
|
|
contentType = _props$asset$claimDat2.contentType,
|
|
fileExt = _props$asset$claimDat2.fileExt,
|
|
thumbnail = _props$asset$claimDat2.thumbnail;
|
|
|
|
return _react2.default.createElement(
|
|
'div',
|
|
{ id: 'asset-display-component' },
|
|
status === _asset_display_states.LOCAL_CHECK && _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Checking to see if Spee.ch has your asset locally...'
|
|
)
|
|
),
|
|
status === _asset_display_states.UNAVAILABLE && _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Sit tight, we\'re searching the LBRY blockchain for your asset!'
|
|
),
|
|
_react2.default.createElement(_ProgressBar2.default, { size: 12 }),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Curious what magic is happening here? ',
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: 'blank', href: 'https://lbry.io/faq/what-is-lbry' },
|
|
'Learn more.'
|
|
)
|
|
)
|
|
),
|
|
status === _asset_display_states.ERROR && _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Unfortunately, we couldn\'t download your asset from LBRY. You can help us out by sharing the below error message in the ',
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', href: 'https://discord.gg/YjYbwhS', target: '_blank' },
|
|
'LBRY discord'
|
|
),
|
|
'.'
|
|
),
|
|
_react2.default.createElement(
|
|
'i',
|
|
null,
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ id: 'error-message' },
|
|
error
|
|
)
|
|
)
|
|
),
|
|
status === _asset_display_states.AVAILABLE && function () {
|
|
switch (contentType) {
|
|
case 'image/jpeg':
|
|
case 'image/jpg':
|
|
case 'image/png':
|
|
return _react2.default.createElement('img', {
|
|
className: 'asset',
|
|
src: '/' + claimId + '/' + name + '.' + fileExt,
|
|
alt: name });
|
|
case 'image/gif':
|
|
return _react2.default.createElement('img', {
|
|
className: 'asset',
|
|
src: '/' + claimId + '/' + name + '.' + fileExt,
|
|
alt: name
|
|
});
|
|
case 'video/mp4':
|
|
return _react2.default.createElement(
|
|
'video',
|
|
{ className: 'asset video', controls: true, poster: thumbnail },
|
|
_react2.default.createElement('source', {
|
|
src: '/' + claimId + '/' + name + '.' + fileExt
|
|
}),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Your browser does not support the ',
|
|
_react2.default.createElement(
|
|
'code',
|
|
null,
|
|
'video'
|
|
),
|
|
' element.'
|
|
)
|
|
);
|
|
default:
|
|
return _react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'Unsupported file type'
|
|
);
|
|
}
|
|
}()
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return AssetDisplay;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = AssetDisplay;
|
|
|
|
/***/ }),
|
|
/* 130 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _view = __webpack_require__(131);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var show = _ref.show;
|
|
|
|
// select request info
|
|
var requestId = show.request.id;
|
|
// select asset info
|
|
var asset = void 0;
|
|
var request = show.requestList[requestId] || null;
|
|
var assetList = show.assetList;
|
|
if (request && assetList) {
|
|
var assetKey = request.key; // note: just store this in the request
|
|
asset = assetList[assetKey] || null;
|
|
};
|
|
// return props
|
|
return {
|
|
asset: asset
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, null)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 131 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _SEO = __webpack_require__(8);
|
|
|
|
var _SEO2 = _interopRequireDefault(_SEO);
|
|
|
|
var _NavBar = __webpack_require__(6);
|
|
|
|
var _NavBar2 = _interopRequireDefault(_NavBar);
|
|
|
|
var _ErrorPage = __webpack_require__(21);
|
|
|
|
var _ErrorPage2 = _interopRequireDefault(_ErrorPage);
|
|
|
|
var _AssetTitle = __webpack_require__(132);
|
|
|
|
var _AssetTitle2 = _interopRequireDefault(_AssetTitle);
|
|
|
|
var _AssetDisplay = __webpack_require__(43);
|
|
|
|
var _AssetDisplay2 = _interopRequireDefault(_AssetDisplay);
|
|
|
|
var _AssetInfo = __webpack_require__(134);
|
|
|
|
var _AssetInfo2 = _interopRequireDefault(_AssetInfo);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var ShowAssetDetails = function (_React$Component) {
|
|
_inherits(ShowAssetDetails, _React$Component);
|
|
|
|
function ShowAssetDetails() {
|
|
_classCallCheck(this, ShowAssetDetails);
|
|
|
|
return _possibleConstructorReturn(this, (ShowAssetDetails.__proto__ || Object.getPrototypeOf(ShowAssetDetails)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(ShowAssetDetails, [{
|
|
key: 'render',
|
|
value: function render() {
|
|
var asset = this.props.asset;
|
|
|
|
if (asset) {
|
|
var name = asset.claimData.name;
|
|
|
|
return _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(_SEO2.default, { pageTitle: name + ' - details', asset: asset }),
|
|
_react2.default.createElement(_NavBar2.default, null),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--tall row--padded' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--10' },
|
|
_react2.default.createElement(_AssetTitle2.default, null)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--5 column--sml-10 align-content-top' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded show-details-container' },
|
|
_react2.default.createElement(_AssetDisplay2.default, null)
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--5 column--sml-10 align-content-top' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded' },
|
|
_react2.default.createElement(_AssetInfo2.default, null)
|
|
)
|
|
)
|
|
),
|
|
'}'
|
|
);
|
|
};
|
|
return _react2.default.createElement(_ErrorPage2.default, { error: 'loading asset data...' });
|
|
}
|
|
}]);
|
|
|
|
return ShowAssetDetails;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = ShowAssetDetails;
|
|
|
|
/***/ }),
|
|
/* 132 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _view = __webpack_require__(133);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
var _show = __webpack_require__(13);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var show = _ref.show;
|
|
|
|
var _selectAsset = (0, _show.selectAsset)(show),
|
|
title = _selectAsset.claimData.title;
|
|
|
|
return {
|
|
title: title
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, null)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 133 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var AssetTitle = function AssetTitle(_ref) {
|
|
var title = _ref.title;
|
|
|
|
return _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(
|
|
'span',
|
|
{ className: 'text--large' },
|
|
title
|
|
)
|
|
);
|
|
};
|
|
|
|
exports.default = AssetTitle;
|
|
|
|
/***/ }),
|
|
/* 134 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _view = __webpack_require__(135);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
var _show = __webpack_require__(13);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var show = _ref.show;
|
|
|
|
// select asset
|
|
var asset = (0, _show.selectAsset)(show);
|
|
// return props
|
|
return {
|
|
asset: asset
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, null)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 135 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _reactRouterDom = __webpack_require__(4);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var AssetInfo = function (_React$Component) {
|
|
_inherits(AssetInfo, _React$Component);
|
|
|
|
function AssetInfo(props) {
|
|
_classCallCheck(this, AssetInfo);
|
|
|
|
var _this = _possibleConstructorReturn(this, (AssetInfo.__proto__ || Object.getPrototypeOf(AssetInfo)).call(this, props));
|
|
|
|
_this.copyToClipboard = _this.copyToClipboard.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(AssetInfo, [{
|
|
key: 'copyToClipboard',
|
|
value: function copyToClipboard(event) {
|
|
var elementToCopy = event.target.dataset.elementtocopy;
|
|
var element = document.getElementById(elementToCopy);
|
|
element.select();
|
|
try {
|
|
document.execCommand('copy');
|
|
} catch (err) {
|
|
this.setState({ error: 'Oops, unable to copy' });
|
|
}
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
var _props$asset = this.props.asset,
|
|
shortId = _props$asset.shortId,
|
|
_props$asset$claimDat = _props$asset.claimData,
|
|
channelName = _props$asset$claimDat.channelName,
|
|
certificateId = _props$asset$claimDat.certificateId,
|
|
description = _props$asset$claimDat.description,
|
|
name = _props$asset$claimDat.name,
|
|
claimId = _props$asset$claimDat.claimId,
|
|
fileExt = _props$asset$claimDat.fileExt,
|
|
contentType = _props$asset$claimDat.contentType,
|
|
thumbnail = _props$asset$claimDat.thumbnail,
|
|
host = _props$asset$claimDat.host;
|
|
|
|
return _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
channelName && _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded row--wide row--no-top' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--2 column--med-10' },
|
|
_react2.default.createElement(
|
|
'span',
|
|
{ className: 'text' },
|
|
'Channel:'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--8 column--med-10' },
|
|
_react2.default.createElement(
|
|
'span',
|
|
{ className: 'text' },
|
|
_react2.default.createElement(
|
|
_reactRouterDom.Link,
|
|
{ to: '/' + channelName + ':' + certificateId },
|
|
channelName
|
|
)
|
|
)
|
|
)
|
|
),
|
|
description && _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded row--wide row--no-top' },
|
|
_react2.default.createElement(
|
|
'span',
|
|
{ className: 'text' },
|
|
description
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ id: 'show-share-buttons' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded row--wide row--no-top' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--2 column--med-10' },
|
|
_react2.default.createElement(
|
|
'span',
|
|
{ className: 'text' },
|
|
'Share:'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--8 column--med-10' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{
|
|
className: 'row row--short row--wide flex-container--row flex-container--space-between-bottom flex-container--wrap' },
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: '_blank', href: 'https://twitter.com/intent/tweet?text=' + host + '/' + shortId + '/' + name },
|
|
'twitter'
|
|
),
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: '_blank', href: 'https://www.facebook.com/sharer/sharer.php?u=' + host + '/' + shortId + '/' + name },
|
|
'facebook'
|
|
),
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: '_blank', href: 'http://tumblr.com/widgets/share/tool?canonicalUrl=' + host + '/' + shortId + '/' + name },
|
|
'tumblr'
|
|
),
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: '_blank', href: 'https://www.reddit.com/submit?url=' + host + '/' + shortId + '/' + name + '&title=' + name },
|
|
'reddit'
|
|
)
|
|
)
|
|
)
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded row--wide row--no-top' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ id: 'show-short-link' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--2 column--med-10' },
|
|
_react2.default.createElement(
|
|
'span',
|
|
{ className: 'text' },
|
|
'Link:'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--8 column--med-10' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--short row--wide' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--7' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'input-error', id: 'input-error-copy-short-link', hidden: 'true' },
|
|
'error here'
|
|
),
|
|
_react2.default.createElement('input', { type: 'text', id: 'short-link', className: 'input-disabled input-text--full-width', readOnly: true,
|
|
spellCheck: 'false',
|
|
value: host + '/' + shortId + '/' + name + '.' + fileExt,
|
|
onClick: this.select })
|
|
),
|
|
_react2.default.createElement('div', { className: 'column column--1' }),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--2' },
|
|
_react2.default.createElement(
|
|
'button',
|
|
{ className: 'button--primary button--wide', 'data-elementtocopy': 'short-link',
|
|
onClick: this.copyToClipboard },
|
|
'copy'
|
|
)
|
|
)
|
|
)
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ id: 'show-embed-code' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--2 column--med-10' },
|
|
_react2.default.createElement(
|
|
'span',
|
|
{ className: 'text' },
|
|
'Embed:'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--8 column--med-10' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--short row--wide' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--7' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'input-error', id: 'input-error-copy-embed-text', hidden: 'true' },
|
|
'error here'
|
|
),
|
|
contentType === 'video/mp4' ? _react2.default.createElement('input', { type: 'text', id: 'embed-text', className: 'input-disabled input-text--full-width', readOnly: true,
|
|
onClick: this.select, spellCheck: 'false',
|
|
value: '<video width="100%" controls poster="' + thumbnail + '" src="' + host + '/' + claimId + '/' + name + '.' + fileExt + '"/></video>' }) : _react2.default.createElement('input', { type: 'text', id: 'embed-text', className: 'input-disabled input-text--full-width', readOnly: true,
|
|
onClick: this.select, spellCheck: 'false',
|
|
value: '<img src="' + host + '/' + claimId + '/' + name + '.' + fileExt + '"/>'
|
|
})
|
|
),
|
|
_react2.default.createElement('div', { className: 'column column--1' }),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--2' },
|
|
_react2.default.createElement(
|
|
'button',
|
|
{ className: 'button--primary button--wide', 'data-elementtocopy': 'embed-text',
|
|
onClick: this.copyToClipboard },
|
|
'copy'
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'flex-container--row flex-container--space-between-bottom' },
|
|
_react2.default.createElement(
|
|
_reactRouterDom.Link,
|
|
{ className: 'link--primary', to: '/' + shortId + '/' + name + '.' + fileExt },
|
|
_react2.default.createElement(
|
|
'span',
|
|
{
|
|
className: 'text' },
|
|
'Direct Link'
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', href: host + '/' + claimId + '/' + name + '.' + fileExt, download: name },
|
|
'Download'
|
|
),
|
|
_react2.default.createElement(
|
|
'a',
|
|
{ className: 'link--primary', target: '_blank', href: 'https://lbry.io/dmca' },
|
|
'Report'
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return AssetInfo;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = AssetInfo;
|
|
|
|
/***/ }),
|
|
/* 136 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _view = __webpack_require__(137);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var show = _ref.show;
|
|
|
|
// select request info
|
|
var requestId = show.request.id;
|
|
// select request
|
|
var previousRequest = show.requestList[requestId] || null;
|
|
// select channel
|
|
var channel = void 0;
|
|
if (previousRequest) {
|
|
var channelKey = previousRequest.key;
|
|
channel = show.channelList[channelKey] || null;
|
|
}
|
|
return {
|
|
channel: channel
|
|
};
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, null)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 137 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _SEO = __webpack_require__(8);
|
|
|
|
var _SEO2 = _interopRequireDefault(_SEO);
|
|
|
|
var _ErrorPage = __webpack_require__(21);
|
|
|
|
var _ErrorPage2 = _interopRequireDefault(_ErrorPage);
|
|
|
|
var _NavBar = __webpack_require__(6);
|
|
|
|
var _NavBar2 = _interopRequireDefault(_NavBar);
|
|
|
|
var _ChannelClaimsDisplay = __webpack_require__(138);
|
|
|
|
var _ChannelClaimsDisplay2 = _interopRequireDefault(_ChannelClaimsDisplay);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var ShowChannel = function (_React$Component) {
|
|
_inherits(ShowChannel, _React$Component);
|
|
|
|
function ShowChannel() {
|
|
_classCallCheck(this, ShowChannel);
|
|
|
|
return _possibleConstructorReturn(this, (ShowChannel.__proto__ || Object.getPrototypeOf(ShowChannel)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(ShowChannel, [{
|
|
key: 'render',
|
|
value: function render() {
|
|
var channel = this.props.channel;
|
|
|
|
if (channel) {
|
|
var name = channel.name,
|
|
longId = channel.longId,
|
|
shortId = channel.shortId;
|
|
|
|
return _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(_SEO2.default, { pageTitle: name, channel: channel }),
|
|
_react2.default.createElement(_NavBar2.default, null),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--tall row--padded' },
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--10' },
|
|
_react2.default.createElement(
|
|
'h2',
|
|
null,
|
|
'channel name: ',
|
|
name
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'fine-print' },
|
|
'full channel id: ',
|
|
longId
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
{ className: 'fine-print' },
|
|
'short channel id: ',
|
|
shortId
|
|
)
|
|
),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'column column--10' },
|
|
_react2.default.createElement(_ChannelClaimsDisplay2.default, null)
|
|
)
|
|
)
|
|
);
|
|
};
|
|
return _react2.default.createElement(_ErrorPage2.default, { error: 'loading channel data...' });
|
|
}
|
|
}]);
|
|
|
|
return ShowChannel;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = ShowChannel;
|
|
|
|
/***/ }),
|
|
/* 138 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _show = __webpack_require__(7);
|
|
|
|
var _view = __webpack_require__(139);
|
|
|
|
var _view2 = _interopRequireDefault(_view);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var mapStateToProps = function mapStateToProps(_ref) {
|
|
var show = _ref.show;
|
|
|
|
// select channel key
|
|
var request = show.requestList[show.request.id];
|
|
var channelKey = request.key;
|
|
// select channel claims
|
|
var channel = show.channelList[channelKey] || null;
|
|
// return props
|
|
return {
|
|
channelKey: channelKey,
|
|
channel: channel
|
|
};
|
|
};
|
|
|
|
var mapDispatchToProps = {
|
|
onUpdateChannelClaims: _show.onUpdateChannelClaims
|
|
};
|
|
|
|
exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_view2.default);
|
|
|
|
/***/ }),
|
|
/* 139 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _AssetPreview = __webpack_require__(140);
|
|
|
|
var _AssetPreview2 = _interopRequireDefault(_AssetPreview);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var ChannelClaimsDisplay = function (_React$Component) {
|
|
_inherits(ChannelClaimsDisplay, _React$Component);
|
|
|
|
function ChannelClaimsDisplay(props) {
|
|
_classCallCheck(this, ChannelClaimsDisplay);
|
|
|
|
var _this = _possibleConstructorReturn(this, (ChannelClaimsDisplay.__proto__ || Object.getPrototypeOf(ChannelClaimsDisplay)).call(this, props));
|
|
|
|
_this.showNextResultsPage = _this.showNextResultsPage.bind(_this);
|
|
_this.showPreviousResultsPage = _this.showPreviousResultsPage.bind(_this);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ChannelClaimsDisplay, [{
|
|
key: 'showPreviousResultsPage',
|
|
value: function showPreviousResultsPage() {
|
|
var currentPage = this.props.channel.claimsData.currentPage;
|
|
|
|
var previousPage = parseInt(currentPage) - 1;
|
|
this.showNewPage(previousPage);
|
|
}
|
|
}, {
|
|
key: 'showNextResultsPage',
|
|
value: function showNextResultsPage() {
|
|
var currentPage = this.props.channel.claimsData.currentPage;
|
|
|
|
var nextPage = parseInt(currentPage) + 1;
|
|
this.showNewPage(nextPage);
|
|
}
|
|
}, {
|
|
key: 'showNewPage',
|
|
value: function showNewPage(page) {
|
|
var _props = this.props,
|
|
channelKey = _props.channelKey,
|
|
_props$channel = _props.channel,
|
|
name = _props$channel.name,
|
|
longId = _props$channel.longId;
|
|
|
|
this.props.onUpdateChannelClaims(channelKey, name, longId, page);
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
var _props$channel$claims = this.props.channel.claimsData,
|
|
claims = _props$channel$claims.claims,
|
|
currentPage = _props$channel$claims.currentPage,
|
|
totalPages = _props$channel$claims.totalPages;
|
|
|
|
return _react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--tall' },
|
|
claims.length > 0 ? _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
claims.map(function (claim, index) {
|
|
return _react2.default.createElement(_AssetPreview2.default, {
|
|
claimData: claim,
|
|
key: claim.name + '-' + index
|
|
});
|
|
}),
|
|
_react2.default.createElement(
|
|
'div',
|
|
null,
|
|
currentPage > 1 && _react2.default.createElement(
|
|
'button',
|
|
{ className: 'button--secondary', onClick: this.showPreviousResultsPage },
|
|
'Previous Page'
|
|
),
|
|
currentPage < totalPages && _react2.default.createElement(
|
|
'button',
|
|
{ className: 'button--secondary', onClick: this.showNextResultsPage },
|
|
'Next Page'
|
|
)
|
|
)
|
|
) : _react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'There are no claims in this channel'
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return ChannelClaimsDisplay;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = ChannelClaimsDisplay;
|
|
|
|
/***/ }),
|
|
/* 140 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _reactRouterDom = __webpack_require__(4);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var _require = __webpack_require__(3),
|
|
defaultThumbnail = _require.claim.defaultThumbnail;
|
|
|
|
var AssetPreview = function AssetPreview(_ref) {
|
|
var _ref$claimData = _ref.claimData,
|
|
name = _ref$claimData.name,
|
|
claimId = _ref$claimData.claimId,
|
|
fileExt = _ref$claimData.fileExt,
|
|
contentType = _ref$claimData.contentType,
|
|
thumbnail = _ref$claimData.thumbnail;
|
|
|
|
var directSourceLink = claimId + '/' + name + '.' + fileExt;
|
|
var showUrlLink = '/' + claimId + '/' + name;
|
|
return _react2.default.createElement(
|
|
'div',
|
|
{ className: 'asset-holder' },
|
|
_react2.default.createElement(
|
|
_reactRouterDom.Link,
|
|
{ to: showUrlLink },
|
|
function () {
|
|
switch (contentType) {
|
|
case 'image/jpeg':
|
|
case 'image/jpg':
|
|
case 'image/png':
|
|
case 'image/gif':
|
|
return _react2.default.createElement('img', {
|
|
className: 'asset-preview',
|
|
src: directSourceLink,
|
|
alt: name
|
|
});
|
|
case 'video/mp4':
|
|
return _react2.default.createElement('img', {
|
|
className: 'asset-preview video',
|
|
src: thumbnail || defaultThumbnail,
|
|
alt: name
|
|
});
|
|
default:
|
|
return _react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'unsupported file type'
|
|
);
|
|
}
|
|
}()
|
|
)
|
|
);
|
|
};
|
|
|
|
exports.default = AssetPreview;
|
|
|
|
/***/ }),
|
|
/* 141 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _NavBar = __webpack_require__(6);
|
|
|
|
var _NavBar2 = _interopRequireDefault(_NavBar);
|
|
|
|
var _reactHelmet = __webpack_require__(14);
|
|
|
|
var _reactHelmet2 = _interopRequireDefault(_reactHelmet);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var _require = __webpack_require__(3),
|
|
_require$site = _require.site,
|
|
title = _require$site.title,
|
|
host = _require$site.host;
|
|
|
|
var FourOhForPage = function (_React$Component) {
|
|
_inherits(FourOhForPage, _React$Component);
|
|
|
|
function FourOhForPage() {
|
|
_classCallCheck(this, FourOhForPage);
|
|
|
|
return _possibleConstructorReturn(this, (FourOhForPage.__proto__ || Object.getPrototypeOf(FourOhForPage)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(FourOhForPage, [{
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react2.default.createElement(
|
|
'div',
|
|
null,
|
|
_react2.default.createElement(
|
|
_reactHelmet2.default,
|
|
null,
|
|
_react2.default.createElement(
|
|
'title',
|
|
null,
|
|
title,
|
|
' - 404'
|
|
),
|
|
_react2.default.createElement('link', { rel: 'canonical', href: host + '/404' })
|
|
),
|
|
_react2.default.createElement(_NavBar2.default, null),
|
|
_react2.default.createElement(
|
|
'div',
|
|
{ className: 'row row--padded' },
|
|
_react2.default.createElement(
|
|
'h2',
|
|
null,
|
|
'404'
|
|
),
|
|
_react2.default.createElement(
|
|
'p',
|
|
null,
|
|
'That page does not exist'
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}]);
|
|
|
|
return FourOhForPage;
|
|
}(_react2.default.Component);
|
|
|
|
;
|
|
|
|
exports.default = FourOhForPage;
|
|
|
|
/***/ }),
|
|
/* 142 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
|
|
|
|
var _require = __webpack_require__(17),
|
|
sendGAServeEvent = _require.sendGAServeEvent;
|
|
|
|
var _require2 = __webpack_require__(143),
|
|
determineResponseType = _require2.determineResponseType,
|
|
flipClaimNameAndIdForBackwardsCompatibility = _require2.flipClaimNameAndIdForBackwardsCompatibility,
|
|
logRequestData = _require2.logRequestData,
|
|
getClaimIdAndServeAsset = _require2.getClaimIdAndServeAsset;
|
|
|
|
var lbryUri = __webpack_require__(144);
|
|
var handleShowRender = __webpack_require__(145);
|
|
var SERVE = 'SERVE';
|
|
|
|
module.exports = function (app) {
|
|
// route to serve a specific asset using the channel or claim id
|
|
app.get('/:identifier/:claim', function (req, res) {
|
|
var headers = req.headers,
|
|
ip = req.ip,
|
|
originalUrl = req.originalUrl,
|
|
params = req.params;
|
|
// decide if this is a show request
|
|
|
|
var hasFileExtension = void 0;
|
|
try {
|
|
var _lbryUri$parseModifie = lbryUri.parseModifier(params.claim);
|
|
|
|
hasFileExtension = _lbryUri$parseModifie.hasFileExtension;
|
|
} catch (error) {
|
|
return res.status(400).json({ success: false, message: error.message });
|
|
}
|
|
var responseType = determineResponseType(hasFileExtension, headers);
|
|
if (responseType !== SERVE) {
|
|
return handleShowRender(req, res);
|
|
}
|
|
// handle serve request
|
|
// send google analytics
|
|
sendGAServeEvent(headers, ip, originalUrl);
|
|
// parse the claim
|
|
var claimName = void 0;
|
|
try {
|
|
var _lbryUri$parseClaim = lbryUri.parseClaim(params.claim);
|
|
|
|
claimName = _lbryUri$parseClaim.claimName;
|
|
} catch (error) {
|
|
return res.status(400).json({ success: false, message: error.message });
|
|
}
|
|
// parse the identifier
|
|
var isChannel = void 0,
|
|
channelName = void 0,
|
|
channelClaimId = void 0,
|
|
claimId = void 0;
|
|
try {
|
|
var _lbryUri$parseIdentif = lbryUri.parseIdentifier(params.identifier);
|
|
|
|
isChannel = _lbryUri$parseIdentif.isChannel;
|
|
channelName = _lbryUri$parseIdentif.channelName;
|
|
channelClaimId = _lbryUri$parseIdentif.channelClaimId;
|
|
claimId = _lbryUri$parseIdentif.claimId;
|
|
} catch (error) {
|
|
return res.status(400).json({ success: false, message: error.message });
|
|
}
|
|
if (!isChannel) {
|
|
var _flipClaimNameAndIdFo = flipClaimNameAndIdForBackwardsCompatibility(claimId, claimName);
|
|
|
|
var _flipClaimNameAndIdFo2 = _slicedToArray(_flipClaimNameAndIdFo, 2);
|
|
|
|
claimId = _flipClaimNameAndIdFo2[0];
|
|
claimName = _flipClaimNameAndIdFo2[1];
|
|
}
|
|
// log the request data for debugging
|
|
logRequestData(responseType, claimName, channelName, claimId);
|
|
// get the claim Id and then serve the asset
|
|
getClaimIdAndServeAsset(channelName, channelClaimId, claimName, claimId, originalUrl, ip, res);
|
|
});
|
|
// route to serve the winning asset at a claim or a channel page
|
|
app.get('/:claim', function (req, res) {
|
|
var headers = req.headers,
|
|
ip = req.ip,
|
|
originalUrl = req.originalUrl,
|
|
params = req.params;
|
|
// decide if this is a show request
|
|
|
|
var hasFileExtension = void 0;
|
|
try {
|
|
var _lbryUri$parseModifie2 = lbryUri.parseModifier(params.claim);
|
|
|
|
hasFileExtension = _lbryUri$parseModifie2.hasFileExtension;
|
|
} catch (error) {
|
|
return res.status(400).json({ success: false, message: error.message });
|
|
}
|
|
var responseType = determineResponseType(hasFileExtension, headers);
|
|
if (responseType !== SERVE) {
|
|
return handleShowRender(req, res);
|
|
}
|
|
// handle serve request
|
|
// send google analytics
|
|
sendGAServeEvent(headers, ip, originalUrl);
|
|
// parse the claim
|
|
var claimName = void 0;
|
|
try {
|
|
var _lbryUri$parseClaim2 = lbryUri.parseClaim(params.claim);
|
|
|
|
claimName = _lbryUri$parseClaim2.claimName;
|
|
} catch (error) {
|
|
return res.status(400).json({ success: false, message: error.message });
|
|
}
|
|
// log the request data for debugging
|
|
logRequestData(responseType, claimName, null, null);
|
|
// get the claim Id and then serve the asset
|
|
getClaimIdAndServeAsset(null, null, claimName, null, originalUrl, ip, res);
|
|
});
|
|
};
|
|
|
|
/***/ }),
|
|
/* 143 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var logger = __webpack_require__(2);
|
|
|
|
var _require = __webpack_require__(29),
|
|
getClaimId = _require.getClaimId,
|
|
getLocalFileRecord = _require.getLocalFileRecord;
|
|
|
|
var _require2 = __webpack_require__(28),
|
|
handleErrorResponse = _require2.handleErrorResponse;
|
|
|
|
var SERVE = 'SERVE';
|
|
var SHOW = 'SHOW';
|
|
var NO_FILE = 'NO_FILE';
|
|
var NO_CHANNEL = 'NO_CHANNEL';
|
|
var NO_CLAIM = 'NO_CLAIM';
|
|
|
|
function clientAcceptsHtml(_ref) {
|
|
var accept = _ref.accept;
|
|
|
|
return accept && accept.match(/text\/html/);
|
|
};
|
|
|
|
function requestIsFromBrowser(headers) {
|
|
return headers['user-agent'] && headers['user-agent'].match(/Mozilla/);
|
|
};
|
|
|
|
function clientWantsAsset(_ref2) {
|
|
var accept = _ref2.accept,
|
|
range = _ref2.range;
|
|
|
|
var imageIsWanted = accept && accept.match(/image\/.*/) && !accept.match(/text\/html/) && !accept.match(/text\/\*/);
|
|
var videoIsWanted = accept && range;
|
|
return imageIsWanted || videoIsWanted;
|
|
};
|
|
|
|
function isValidClaimId(claimId) {
|
|
return claimId.length === 40 && !/[^A-Za-z0-9]/g.test(claimId);
|
|
};
|
|
|
|
function isValidShortId(claimId) {
|
|
return claimId.length === 1; // it should really evaluate the short url itself
|
|
};
|
|
|
|
function isValidShortIdOrClaimId(input) {
|
|
return isValidClaimId(input) || isValidShortId(input);
|
|
};
|
|
|
|
function serveAssetToClient(claimId, name, res) {
|
|
return getLocalFileRecord(claimId, name).then(function (fileRecord) {
|
|
// check that a local record was found
|
|
if (fileRecord === NO_FILE) {
|
|
return res.status(307).redirect('/api/claim/get/' + name + '/' + claimId);
|
|
}
|
|
// serve the file
|
|
var filePath = fileRecord.filePath,
|
|
fileType = fileRecord.fileType;
|
|
|
|
logger.verbose('serving file: ' + filePath);
|
|
var sendFileOptions = {
|
|
headers: {
|
|
'X-Content-Type-Options': 'nosniff',
|
|
'Content-Type': fileType || 'image/jpeg'
|
|
}
|
|
};
|
|
res.status(200).sendFile(filePath, sendFileOptions);
|
|
}).catch(function (error) {
|
|
throw error;
|
|
});
|
|
};
|
|
|
|
module.exports = {
|
|
getClaimIdAndServeAsset: function getClaimIdAndServeAsset(channelName, channelClaimId, claimName, claimId, originalUrl, ip, res) {
|
|
// get the claim Id and then serve the asset
|
|
getClaimId(channelName, channelClaimId, claimName, claimId).then(function (fullClaimId) {
|
|
if (fullClaimId === NO_CLAIM) {
|
|
return res.status(404).json({ success: false, message: 'no claim id could be found' });
|
|
} else if (fullClaimId === NO_CHANNEL) {
|
|
return res.status(404).json({ success: false, message: 'no channel id could be found' });
|
|
}
|
|
serveAssetToClient(fullClaimId, claimName, res);
|
|
// postToStats(responseType, originalUrl, ip, claimName, fullClaimId, 'success');
|
|
}).catch(function (error) {
|
|
handleErrorResponse(originalUrl, ip, error, res);
|
|
// postToStats(responseType, originalUrl, ip, claimName, fullClaimId, 'fail');
|
|
});
|
|
},
|
|
determineResponseType: function determineResponseType(hasFileExtension, headers) {
|
|
var responseType = void 0;
|
|
if (hasFileExtension) {
|
|
responseType = SERVE; // assume a serve request if file extension is present
|
|
if (clientAcceptsHtml(headers)) {
|
|
// if the request comes from a browser, change it to a show request
|
|
responseType = SHOW;
|
|
}
|
|
} else {
|
|
responseType = SHOW;
|
|
if (clientWantsAsset(headers) && requestIsFromBrowser(headers)) {
|
|
// this is in case someone embeds a show url
|
|
logger.debug('Show request came from browser but wants an image/video. Changing response to serve...');
|
|
responseType = SERVE;
|
|
}
|
|
}
|
|
return responseType;
|
|
},
|
|
flipClaimNameAndIdForBackwardsCompatibility: function flipClaimNameAndIdForBackwardsCompatibility(identifier, name) {
|
|
// this is a patch for backwards compatability with '/name/claim_id' url format
|
|
if (isValidShortIdOrClaimId(name) && !isValidShortIdOrClaimId(identifier)) {
|
|
var tempName = name;
|
|
name = identifier;
|
|
identifier = tempName;
|
|
}
|
|
return [identifier, name];
|
|
},
|
|
logRequestData: function logRequestData(responseType, claimName, channelName, claimId) {
|
|
logger.debug('responseType ===', responseType);
|
|
logger.debug('claim name === ', claimName);
|
|
logger.debug('channel name ===', channelName);
|
|
logger.debug('claim id ===', claimId);
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 144 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
|
|
|
|
var logger = __webpack_require__(2);
|
|
|
|
module.exports = {
|
|
REGEXP_INVALID_CLAIM: /[^A-Za-z0-9-]/g,
|
|
REGEXP_INVALID_CHANNEL: /[^A-Za-z0-9-@]/g,
|
|
REGEXP_ADDRESS: /^b(?=[^0OIl]{32,33})[0-9A-Za-z]{32,33}$/,
|
|
CHANNEL_CHAR: '@',
|
|
parseIdentifier: function parseIdentifier(identifier) {
|
|
logger.debug('parsing identifier:', identifier);
|
|
var componentsRegex = new RegExp('([^:$#/]*)' + // value (stops at the first separator or end)
|
|
'([:$#]?)([^/]*)' // modifier separator, modifier (stops at the first path separator or end)
|
|
);
|
|
|
|
var _componentsRegex$exec = componentsRegex.exec(identifier).map(function (match) {
|
|
return match || null;
|
|
}),
|
|
_componentsRegex$exec2 = _slicedToArray(_componentsRegex$exec, 4),
|
|
proto = _componentsRegex$exec2[0],
|
|
value = _componentsRegex$exec2[1],
|
|
modifierSeperator = _componentsRegex$exec2[2],
|
|
modifier = _componentsRegex$exec2[3];
|
|
|
|
logger.debug(proto + ', ' + value + ', ' + modifierSeperator + ', ' + modifier);
|
|
|
|
// Validate and process name
|
|
if (!value) {
|
|
throw new Error('Check your url. No channel name provided before "' + modifierSeperator + '"');
|
|
}
|
|
var isChannel = value.startsWith(module.exports.CHANNEL_CHAR);
|
|
var channelName = isChannel ? value : null;
|
|
var claimId = void 0;
|
|
if (isChannel) {
|
|
if (!channelName) {
|
|
throw new Error('No channel name after @.');
|
|
}
|
|
var nameBadChars = channelName.match(module.exports.REGEXP_INVALID_CHANNEL);
|
|
if (nameBadChars) {
|
|
throw new Error('Invalid characters in channel name: ' + nameBadChars.join(', ') + '.');
|
|
}
|
|
} else {
|
|
claimId = value;
|
|
}
|
|
|
|
// Validate and process modifier
|
|
var channelClaimId = void 0;
|
|
if (modifierSeperator) {
|
|
if (!modifier) {
|
|
throw new Error('No modifier provided after separator "' + modifierSeperator + '"');
|
|
}
|
|
|
|
if (modifierSeperator === ':') {
|
|
channelClaimId = modifier;
|
|
} else {
|
|
throw new Error('The "' + modifierSeperator + '" modifier is not currently supported');
|
|
}
|
|
}
|
|
return {
|
|
isChannel: isChannel,
|
|
channelName: channelName,
|
|
channelClaimId: channelClaimId,
|
|
claimId: claimId
|
|
};
|
|
},
|
|
parseClaim: function parseClaim(claim) {
|
|
logger.debug('parsing name:', claim);
|
|
var componentsRegex = new RegExp('([^:$#/.]*)' + // name (stops at the first modifier)
|
|
'([:$#.]?)([^/]*)' // modifier separator, modifier (stops at the first path separator or end)
|
|
);
|
|
|
|
var _componentsRegex$exec3 = componentsRegex.exec(claim).map(function (match) {
|
|
return match || null;
|
|
}),
|
|
_componentsRegex$exec4 = _slicedToArray(_componentsRegex$exec3, 4),
|
|
proto = _componentsRegex$exec4[0],
|
|
claimName = _componentsRegex$exec4[1],
|
|
modifierSeperator = _componentsRegex$exec4[2],
|
|
modifier = _componentsRegex$exec4[3];
|
|
|
|
logger.debug(proto + ', ' + claimName + ', ' + modifierSeperator + ', ' + modifier);
|
|
|
|
// Validate and process name
|
|
if (!claimName) {
|
|
throw new Error('No claim name provided before .');
|
|
}
|
|
var nameBadChars = claimName.match(module.exports.REGEXP_INVALID_CLAIM);
|
|
if (nameBadChars) {
|
|
throw new Error('Invalid characters in claim name: ' + nameBadChars.join(', ') + '.');
|
|
}
|
|
// Validate and process modifier
|
|
if (modifierSeperator) {
|
|
if (!modifier) {
|
|
throw new Error('No file extension provided after separator ' + modifierSeperator + '.');
|
|
}
|
|
if (modifierSeperator !== '.') {
|
|
throw new Error('The ' + modifierSeperator + ' modifier is not supported in the claim name');
|
|
}
|
|
}
|
|
// return results
|
|
return {
|
|
claimName: claimName
|
|
};
|
|
},
|
|
parseModifier: function parseModifier(claim) {
|
|
logger.debug('parsing modifier:', claim);
|
|
var componentsRegex = new RegExp('([^:$#/.]*)' + // name (stops at the first modifier)
|
|
'([:$#.]?)([^/]*)' // modifier separator, modifier (stops at the first path separator or end)
|
|
);
|
|
|
|
var _componentsRegex$exec5 = componentsRegex.exec(claim).map(function (match) {
|
|
return match || null;
|
|
}),
|
|
_componentsRegex$exec6 = _slicedToArray(_componentsRegex$exec5, 4),
|
|
proto = _componentsRegex$exec6[0],
|
|
claimName = _componentsRegex$exec6[1],
|
|
modifierSeperator = _componentsRegex$exec6[2],
|
|
modifier = _componentsRegex$exec6[3];
|
|
|
|
logger.debug(proto + ', ' + claimName + ', ' + modifierSeperator + ', ' + modifier);
|
|
// Validate and process modifier
|
|
var hasFileExtension = false;
|
|
if (modifierSeperator) {
|
|
hasFileExtension = true;
|
|
}
|
|
return {
|
|
hasFileExtension: hasFileExtension
|
|
};
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 145 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _react = __webpack_require__(0);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _server = __webpack_require__(31);
|
|
|
|
var _redux = __webpack_require__(18);
|
|
|
|
var _reducers = __webpack_require__(32);
|
|
|
|
var _reducers2 = _interopRequireDefault(_reducers);
|
|
|
|
var _reactRedux = __webpack_require__(1);
|
|
|
|
var _reactRouterDom = __webpack_require__(4);
|
|
|
|
var _GAListener = __webpack_require__(37);
|
|
|
|
var _GAListener2 = _interopRequireDefault(_GAListener);
|
|
|
|
var _app = __webpack_require__(38);
|
|
|
|
var _app2 = _interopRequireDefault(_app);
|
|
|
|
var _renderFullPage = __webpack_require__(44);
|
|
|
|
var _renderFullPage2 = _interopRequireDefault(_renderFullPage);
|
|
|
|
var _reduxSaga = __webpack_require__(146);
|
|
|
|
var _reduxSaga2 = _interopRequireDefault(_reduxSaga);
|
|
|
|
var _effects = __webpack_require__(15);
|
|
|
|
var _show_uri = __webpack_require__(147);
|
|
|
|
var _show = __webpack_require__(7);
|
|
|
|
var _reactHelmet = __webpack_require__(14);
|
|
|
|
var _reactHelmet2 = _interopRequireDefault(_reactHelmet);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var returnSagaWithParams = function returnSagaWithParams(saga, params) {
|
|
return (/*#__PURE__*/regeneratorRuntime.mark(function _callee() {
|
|
return regeneratorRuntime.wrap(function _callee$(_context) {
|
|
while (1) {
|
|
switch (_context.prev = _context.next) {
|
|
case 0:
|
|
_context.next = 2;
|
|
return (0, _effects.call)(saga, params);
|
|
|
|
case 2:
|
|
case 'end':
|
|
return _context.stop();
|
|
}
|
|
}
|
|
}, _callee, this);
|
|
})
|
|
);
|
|
};
|
|
|
|
module.exports = function (req, res) {
|
|
var context = {};
|
|
|
|
// create and apply middleware
|
|
var sagaMiddleware = (0, _reduxSaga2.default)();
|
|
var middleware = (0, _redux.applyMiddleware)(sagaMiddleware);
|
|
|
|
// create a new Redux store instance
|
|
var store = (0, _redux.createStore)(_reducers2.default, middleware);
|
|
|
|
// create saga
|
|
var action = (0, _show.onHandleShowPageUri)(req.params);
|
|
var saga = returnSagaWithParams(_show_uri.handleShowPageUri, action);
|
|
|
|
// run the saga middleware
|
|
sagaMiddleware.run(saga).done.then(function () {
|
|
// render component to a string
|
|
var html = (0, _server.renderToString)(_react2.default.createElement(
|
|
_reactRedux.Provider,
|
|
{ store: store },
|
|
_react2.default.createElement(
|
|
_reactRouterDom.StaticRouter,
|
|
{ location: req.url, context: context },
|
|
_react2.default.createElement(
|
|
_GAListener2.default,
|
|
null,
|
|
_react2.default.createElement(_app2.default, null)
|
|
)
|
|
)
|
|
));
|
|
|
|
// get head tags from helmet
|
|
var helmet = _reactHelmet2.default.renderStatic();
|
|
|
|
// check for a redirect
|
|
if (context.url) {
|
|
return res.redirect(301, context.url);
|
|
}
|
|
|
|
// get the initial state from our Redux store
|
|
var preloadedState = store.getState();
|
|
|
|
// send the rendered page back to the client
|
|
res.send((0, _renderFullPage2.default)(helmet, html, preloadedState));
|
|
});
|
|
};
|
|
|
|
/***/ }),
|
|
/* 146 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("redux-saga");
|
|
|
|
/***/ }),
|
|
/* 147 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.handleShowPageUri = handleShowPageUri;
|
|
exports.watchHandleShowPageUri = watchHandleShowPageUri;
|
|
|
|
var _effects = __webpack_require__(15);
|
|
|
|
var _show_action_types = __webpack_require__(12);
|
|
|
|
var actions = _interopRequireWildcard(_show_action_types);
|
|
|
|
var _show = __webpack_require__(7);
|
|
|
|
var _show_asset = __webpack_require__(148);
|
|
|
|
var _show_channel = __webpack_require__(150);
|
|
|
|
var _lbryUri = __webpack_require__(152);
|
|
|
|
var _lbryUri2 = _interopRequireDefault(_lbryUri);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
var _marked = /*#__PURE__*/regeneratorRuntime.mark(parseAndUpdateIdentifierAndClaim),
|
|
_marked2 = /*#__PURE__*/regeneratorRuntime.mark(parseAndUpdateClaimOnly),
|
|
_marked3 = /*#__PURE__*/regeneratorRuntime.mark(handleShowPageUri),
|
|
_marked4 = /*#__PURE__*/regeneratorRuntime.mark(watchHandleShowPageUri);
|
|
|
|
function parseAndUpdateIdentifierAndClaim(modifier, claim) {
|
|
var isChannel, channelName, channelClaimId, claimId, claimName, extension, _lbryUri$parseIdentif, _lbryUri$parseClaim;
|
|
|
|
return regeneratorRuntime.wrap(function parseAndUpdateIdentifierAndClaim$(_context) {
|
|
while (1) {
|
|
switch (_context.prev = _context.next) {
|
|
case 0:
|
|
// this is a request for an asset
|
|
// claim will be an asset claim
|
|
// the identifier could be a channel or a claim id
|
|
isChannel = void 0, channelName = void 0, channelClaimId = void 0, claimId = void 0, claimName = void 0, extension = void 0;
|
|
_context.prev = 1;
|
|
_lbryUri$parseIdentif = _lbryUri2.default.parseIdentifier(modifier);
|
|
isChannel = _lbryUri$parseIdentif.isChannel;
|
|
channelName = _lbryUri$parseIdentif.channelName;
|
|
channelClaimId = _lbryUri$parseIdentif.channelClaimId;
|
|
claimId = _lbryUri$parseIdentif.claimId;
|
|
_lbryUri$parseClaim = _lbryUri2.default.parseClaim(claim);
|
|
claimName = _lbryUri$parseClaim.claimName;
|
|
extension = _lbryUri$parseClaim.extension;
|
|
_context.next = 17;
|
|
break;
|
|
|
|
case 12:
|
|
_context.prev = 12;
|
|
_context.t0 = _context['catch'](1);
|
|
_context.next = 16;
|
|
return (0, _effects.put)((0, _show.onRequestError)(_context.t0.message));
|
|
|
|
case 16:
|
|
return _context.abrupt('return', _context.sent);
|
|
|
|
case 17:
|
|
if (!isChannel) {
|
|
_context.next = 21;
|
|
break;
|
|
}
|
|
|
|
_context.next = 20;
|
|
return (0, _effects.call)(_show_asset.newAssetRequest, (0, _show.onNewAssetRequest)(claimName, null, channelName, channelClaimId, extension));
|
|
|
|
case 20:
|
|
return _context.abrupt('return', _context.sent);
|
|
|
|
case 21:
|
|
;
|
|
_context.next = 24;
|
|
return (0, _effects.call)(_show_asset.newAssetRequest, (0, _show.onNewAssetRequest)(claimName, claimId, null, null, extension));
|
|
|
|
case 24:
|
|
case 'end':
|
|
return _context.stop();
|
|
}
|
|
}
|
|
}, _marked, this, [[1, 12]]);
|
|
}
|
|
function parseAndUpdateClaimOnly(claim) {
|
|
var isChannel, channelName, channelClaimId, _lbryUri$parseIdentif2, claimName, extension, _lbryUri$parseClaim2;
|
|
|
|
return regeneratorRuntime.wrap(function parseAndUpdateClaimOnly$(_context2) {
|
|
while (1) {
|
|
switch (_context2.prev = _context2.next) {
|
|
case 0:
|
|
// this could be a request for an asset or a channel page
|
|
// claim could be an asset claim or a channel claim
|
|
isChannel = void 0, channelName = void 0, channelClaimId = void 0;
|
|
_context2.prev = 1;
|
|
_lbryUri$parseIdentif2 = _lbryUri2.default.parseIdentifier(claim);
|
|
isChannel = _lbryUri$parseIdentif2.isChannel;
|
|
channelName = _lbryUri$parseIdentif2.channelName;
|
|
channelClaimId = _lbryUri$parseIdentif2.channelClaimId;
|
|
_context2.next = 13;
|
|
break;
|
|
|
|
case 8:
|
|
_context2.prev = 8;
|
|
_context2.t0 = _context2['catch'](1);
|
|
_context2.next = 12;
|
|
return (0, _effects.put)((0, _show.onRequestError)(_context2.t0.message));
|
|
|
|
case 12:
|
|
return _context2.abrupt('return', _context2.sent);
|
|
|
|
case 13:
|
|
if (!isChannel) {
|
|
_context2.next = 17;
|
|
break;
|
|
}
|
|
|
|
_context2.next = 16;
|
|
return (0, _effects.call)(_show_channel.newChannelRequest, (0, _show.onNewChannelRequest)(channelName, channelClaimId));
|
|
|
|
case 16:
|
|
return _context2.abrupt('return', _context2.sent);
|
|
|
|
case 17:
|
|
// if not for a channel, parse the claim request
|
|
claimName = void 0, extension = void 0;
|
|
_context2.prev = 18;
|
|
_lbryUri$parseClaim2 = _lbryUri2.default.parseClaim(claim);
|
|
claimName = _lbryUri$parseClaim2.claimName;
|
|
extension = _lbryUri$parseClaim2.extension;
|
|
_context2.next = 29;
|
|
break;
|
|
|
|
case 24:
|
|
_context2.prev = 24;
|
|
_context2.t1 = _context2['catch'](18);
|
|
_context2.next = 28;
|
|
return (0, _effects.put)((0, _show.onRequestError)(_context2.t1.message));
|
|
|
|
case 28:
|
|
return _context2.abrupt('return', _context2.sent);
|
|
|
|
case 29:
|
|
_context2.next = 31;
|
|
return (0, _effects.call)(_show_asset.newAssetRequest, (0, _show.onNewAssetRequest)(claimName, null, null, null, extension));
|
|
|
|
case 31:
|
|
case 'end':
|
|
return _context2.stop();
|
|
}
|
|
}
|
|
}, _marked2, this, [[1, 8], [18, 24]]);
|
|
}
|
|
|
|
function handleShowPageUri(action) {
|
|
var _action$data, identifier, claim;
|
|
|
|
return regeneratorRuntime.wrap(function handleShowPageUri$(_context3) {
|
|
while (1) {
|
|
switch (_context3.prev = _context3.next) {
|
|
case 0:
|
|
_action$data = action.data, identifier = _action$data.identifier, claim = _action$data.claim;
|
|
|
|
if (!identifier) {
|
|
_context3.next = 5;
|
|
break;
|
|
}
|
|
|
|
_context3.next = 4;
|
|
return (0, _effects.call)(parseAndUpdateIdentifierAndClaim, identifier, claim);
|
|
|
|
case 4:
|
|
return _context3.abrupt('return', _context3.sent);
|
|
|
|
case 5:
|
|
_context3.next = 7;
|
|
return (0, _effects.call)(parseAndUpdateClaimOnly, claim);
|
|
|
|
case 7:
|
|
case 'end':
|
|
return _context3.stop();
|
|
}
|
|
}
|
|
}, _marked3, this);
|
|
};
|
|
|
|
function watchHandleShowPageUri() {
|
|
return regeneratorRuntime.wrap(function watchHandleShowPageUri$(_context4) {
|
|
while (1) {
|
|
switch (_context4.prev = _context4.next) {
|
|
case 0:
|
|
_context4.next = 2;
|
|
return (0, _effects.takeLatest)(actions.HANDLE_SHOW_URI, handleShowPageUri);
|
|
|
|
case 2:
|
|
case 'end':
|
|
return _context4.stop();
|
|
}
|
|
}
|
|
}, _marked4, this);
|
|
};
|
|
|
|
/***/ }),
|
|
/* 148 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.newAssetRequest = newAssetRequest;
|
|
exports.watchNewAssetRequest = watchNewAssetRequest;
|
|
|
|
var _effects = __webpack_require__(15);
|
|
|
|
var _show_action_types = __webpack_require__(12);
|
|
|
|
var actions = _interopRequireWildcard(_show_action_types);
|
|
|
|
var _show = __webpack_require__(7);
|
|
|
|
var _assetApi = __webpack_require__(149);
|
|
|
|
var _show2 = __webpack_require__(13);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
var _marked = /*#__PURE__*/regeneratorRuntime.mark(newAssetRequest),
|
|
_marked2 = /*#__PURE__*/regeneratorRuntime.mark(watchNewAssetRequest);
|
|
|
|
function newAssetRequest(action) {
|
|
var _action$data, requestType, requestId, name, modifier, state, longId, _ref, assetKey, shortId, _ref2, claimData, _ref3;
|
|
|
|
return regeneratorRuntime.wrap(function newAssetRequest$(_context) {
|
|
while (1) {
|
|
switch (_context.prev = _context.next) {
|
|
case 0:
|
|
_action$data = action.data, requestType = _action$data.requestType, requestId = _action$data.requestId, name = _action$data.name, modifier = _action$data.modifier;
|
|
// put an action to update the request in redux
|
|
|
|
_context.next = 3;
|
|
return (0, _effects.put)((0, _show.onRequestUpdate)(requestType, requestId));
|
|
|
|
case 3:
|
|
_context.next = 5;
|
|
return (0, _effects.select)(_show2.selectShowState);
|
|
|
|
case 5:
|
|
state = _context.sent;
|
|
|
|
if (!state.requestList[requestId]) {
|
|
_context.next = 8;
|
|
break;
|
|
}
|
|
|
|
return _context.abrupt('return', null);
|
|
|
|
case 8:
|
|
// get long id && add request to request list
|
|
longId = void 0;
|
|
_context.prev = 9;
|
|
_context.next = 12;
|
|
return (0, _effects.call)(_assetApi.getLongClaimId, name, modifier);
|
|
|
|
case 12:
|
|
_ref = _context.sent;
|
|
longId = _ref.data;
|
|
_context.next = 21;
|
|
break;
|
|
|
|
case 16:
|
|
_context.prev = 16;
|
|
_context.t0 = _context['catch'](9);
|
|
_context.next = 20;
|
|
return (0, _effects.put)((0, _show.onRequestError)(_context.t0.message));
|
|
|
|
case 20:
|
|
return _context.abrupt('return', _context.sent);
|
|
|
|
case 21:
|
|
assetKey = 'a#' + name + '#' + longId;
|
|
_context.next = 24;
|
|
return (0, _effects.put)((0, _show.addRequestToRequestList)(requestId, null, assetKey));
|
|
|
|
case 24:
|
|
if (!state.assetList[assetKey]) {
|
|
_context.next = 26;
|
|
break;
|
|
}
|
|
|
|
return _context.abrupt('return', null);
|
|
|
|
case 26:
|
|
// get short Id
|
|
shortId = void 0;
|
|
_context.prev = 27;
|
|
_context.next = 30;
|
|
return (0, _effects.call)(_assetApi.getShortId, name, longId);
|
|
|
|
case 30:
|
|
_ref2 = _context.sent;
|
|
shortId = _ref2.data;
|
|
_context.next = 39;
|
|
break;
|
|
|
|
case 34:
|
|
_context.prev = 34;
|
|
_context.t1 = _context['catch'](27);
|
|
_context.next = 38;
|
|
return (0, _effects.put)((0, _show.onRequestError)(_context.t1.message));
|
|
|
|
case 38:
|
|
return _context.abrupt('return', _context.sent);
|
|
|
|
case 39:
|
|
// get asset claim data
|
|
claimData = void 0;
|
|
_context.prev = 40;
|
|
_context.next = 43;
|
|
return (0, _effects.call)(_assetApi.getClaimData, name, longId);
|
|
|
|
case 43:
|
|
_ref3 = _context.sent;
|
|
claimData = _ref3.data;
|
|
_context.next = 52;
|
|
break;
|
|
|
|
case 47:
|
|
_context.prev = 47;
|
|
_context.t2 = _context['catch'](40);
|
|
_context.next = 51;
|
|
return (0, _effects.put)((0, _show.onRequestError)(_context.t2.message));
|
|
|
|
case 51:
|
|
return _context.abrupt('return', _context.sent);
|
|
|
|
case 52:
|
|
_context.next = 54;
|
|
return (0, _effects.put)((0, _show.addAssetToAssetList)(assetKey, null, name, longId, shortId, claimData));
|
|
|
|
case 54:
|
|
_context.next = 56;
|
|
return (0, _effects.put)((0, _show.onRequestError)(null));
|
|
|
|
case 56:
|
|
case 'end':
|
|
return _context.stop();
|
|
}
|
|
}
|
|
}, _marked, this, [[9, 16], [27, 34], [40, 47]]);
|
|
};
|
|
|
|
function watchNewAssetRequest() {
|
|
return regeneratorRuntime.wrap(function watchNewAssetRequest$(_context2) {
|
|
while (1) {
|
|
switch (_context2.prev = _context2.next) {
|
|
case 0:
|
|
_context2.next = 2;
|
|
return (0, _effects.takeLatest)(actions.ASSET_REQUEST_NEW, newAssetRequest);
|
|
|
|
case 2:
|
|
case 'end':
|
|
return _context2.stop();
|
|
}
|
|
}
|
|
}, _marked2, this);
|
|
};
|
|
|
|
/***/ }),
|
|
/* 149 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.getLongClaimId = getLongClaimId;
|
|
exports.getShortId = getShortId;
|
|
exports.getClaimData = getClaimData;
|
|
|
|
var _request = __webpack_require__(10);
|
|
|
|
var _request2 = _interopRequireDefault(_request);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var _require = __webpack_require__(3),
|
|
host = _require.site.host;
|
|
|
|
function getLongClaimId(name, modifier) {
|
|
var body = {};
|
|
// create request params
|
|
if (modifier) {
|
|
if (modifier.id) {
|
|
body['claimId'] = modifier.id;
|
|
} else {
|
|
body['channelName'] = modifier.channel.name;
|
|
body['channelClaimId'] = modifier.channel.id;
|
|
}
|
|
}
|
|
body['claimName'] = name;
|
|
var params = {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify(body)
|
|
};
|
|
// create url
|
|
var url = host + '/api/claim/long-id';
|
|
// return the request promise
|
|
return (0, _request2.default)(url, params);
|
|
};
|
|
|
|
function getShortId(name, claimId) {
|
|
var url = host + '/api/claim/short-id/' + claimId + '/' + name;
|
|
return (0, _request2.default)(url);
|
|
};
|
|
|
|
function getClaimData(name, claimId) {
|
|
var url = host + '/api/claim/data/' + name + '/' + claimId;
|
|
return (0, _request2.default)(url);
|
|
};
|
|
|
|
/***/ }),
|
|
/* 150 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.newChannelRequest = newChannelRequest;
|
|
exports.watchNewChannelRequest = watchNewChannelRequest;
|
|
exports.watchUpdateChannelClaims = watchUpdateChannelClaims;
|
|
|
|
var _effects = __webpack_require__(15);
|
|
|
|
var _show_action_types = __webpack_require__(12);
|
|
|
|
var actions = _interopRequireWildcard(_show_action_types);
|
|
|
|
var _show = __webpack_require__(7);
|
|
|
|
var _channelApi = __webpack_require__(151);
|
|
|
|
var _show2 = __webpack_require__(13);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
var _marked = /*#__PURE__*/regeneratorRuntime.mark(newChannelRequest),
|
|
_marked2 = /*#__PURE__*/regeneratorRuntime.mark(watchNewChannelRequest),
|
|
_marked3 = /*#__PURE__*/regeneratorRuntime.mark(getNewClaimsAndUpdateChannel),
|
|
_marked4 = /*#__PURE__*/regeneratorRuntime.mark(watchUpdateChannelClaims);
|
|
|
|
function newChannelRequest(action) {
|
|
var _action$data, requestType, requestId, channelName, channelId, state, longId, shortId, _ref, _ref$data, channelKey, claimsData, _ref2;
|
|
|
|
return regeneratorRuntime.wrap(function newChannelRequest$(_context) {
|
|
while (1) {
|
|
switch (_context.prev = _context.next) {
|
|
case 0:
|
|
_action$data = action.data, requestType = _action$data.requestType, requestId = _action$data.requestId, channelName = _action$data.channelName, channelId = _action$data.channelId;
|
|
// put an action to update the request in redux
|
|
|
|
_context.next = 3;
|
|
return (0, _effects.put)((0, _show.onRequestUpdate)(requestType, requestId));
|
|
|
|
case 3:
|
|
_context.next = 5;
|
|
return (0, _effects.select)(_show2.selectShowState);
|
|
|
|
case 5:
|
|
state = _context.sent;
|
|
|
|
if (!state.requestList[requestId]) {
|
|
_context.next = 8;
|
|
break;
|
|
}
|
|
|
|
return _context.abrupt('return', null);
|
|
|
|
case 8:
|
|
// get channel long id
|
|
longId = void 0, shortId = void 0;
|
|
_context.prev = 9;
|
|
_context.next = 12;
|
|
return (0, _effects.call)(_channelApi.getChannelData, channelName, channelId);
|
|
|
|
case 12:
|
|
_ref = _context.sent;
|
|
_ref$data = _ref.data;
|
|
longId = _ref$data.longChannelClaimId;
|
|
shortId = _ref$data.shortChannelClaimId;
|
|
_context.next = 23;
|
|
break;
|
|
|
|
case 18:
|
|
_context.prev = 18;
|
|
_context.t0 = _context['catch'](9);
|
|
_context.next = 22;
|
|
return (0, _effects.put)((0, _show.onRequestError)(_context.t0.message));
|
|
|
|
case 22:
|
|
return _context.abrupt('return', _context.sent);
|
|
|
|
case 23:
|
|
// store the request in the channel requests list
|
|
channelKey = 'c#' + channelName + '#' + longId;
|
|
_context.next = 26;
|
|
return (0, _effects.put)((0, _show.addRequestToRequestList)(requestId, null, channelKey));
|
|
|
|
case 26:
|
|
if (!state.channelList[channelKey]) {
|
|
_context.next = 28;
|
|
break;
|
|
}
|
|
|
|
return _context.abrupt('return', null);
|
|
|
|
case 28:
|
|
// get channel claims data
|
|
claimsData = void 0;
|
|
_context.prev = 29;
|
|
_context.next = 32;
|
|
return (0, _effects.call)(_channelApi.getChannelClaims, channelName, longId, 1);
|
|
|
|
case 32:
|
|
_ref2 = _context.sent;
|
|
claimsData = _ref2.data;
|
|
_context.next = 41;
|
|
break;
|
|
|
|
case 36:
|
|
_context.prev = 36;
|
|
_context.t1 = _context['catch'](29);
|
|
_context.next = 40;
|
|
return (0, _effects.put)((0, _show.onRequestError)(_context.t1.message));
|
|
|
|
case 40:
|
|
return _context.abrupt('return', _context.sent);
|
|
|
|
case 41:
|
|
_context.next = 43;
|
|
return (0, _effects.put)((0, _show.addNewChannelToChannelList)(channelKey, channelName, shortId, longId, claimsData));
|
|
|
|
case 43:
|
|
_context.next = 45;
|
|
return (0, _effects.put)((0, _show.onRequestError)(null));
|
|
|
|
case 45:
|
|
case 'end':
|
|
return _context.stop();
|
|
}
|
|
}
|
|
}, _marked, this, [[9, 18], [29, 36]]);
|
|
}
|
|
|
|
function watchNewChannelRequest() {
|
|
return regeneratorRuntime.wrap(function watchNewChannelRequest$(_context2) {
|
|
while (1) {
|
|
switch (_context2.prev = _context2.next) {
|
|
case 0:
|
|
_context2.next = 2;
|
|
return (0, _effects.takeLatest)(actions.CHANNEL_REQUEST_NEW, newChannelRequest);
|
|
|
|
case 2:
|
|
case 'end':
|
|
return _context2.stop();
|
|
}
|
|
}
|
|
}, _marked2, this);
|
|
};
|
|
|
|
function getNewClaimsAndUpdateChannel(action) {
|
|
var _action$data2, channelKey, name, longId, page, claimsData, _ref3;
|
|
|
|
return regeneratorRuntime.wrap(function getNewClaimsAndUpdateChannel$(_context3) {
|
|
while (1) {
|
|
switch (_context3.prev = _context3.next) {
|
|
case 0:
|
|
_action$data2 = action.data, channelKey = _action$data2.channelKey, name = _action$data2.name, longId = _action$data2.longId, page = _action$data2.page;
|
|
claimsData = void 0;
|
|
_context3.prev = 2;
|
|
_context3.next = 5;
|
|
return (0, _effects.call)(_channelApi.getChannelClaims, name, longId, page);
|
|
|
|
case 5:
|
|
_ref3 = _context3.sent;
|
|
claimsData = _ref3.data;
|
|
_context3.next = 14;
|
|
break;
|
|
|
|
case 9:
|
|
_context3.prev = 9;
|
|
_context3.t0 = _context3['catch'](2);
|
|
_context3.next = 13;
|
|
return (0, _effects.put)((0, _show.onRequestError)(_context3.t0.message));
|
|
|
|
case 13:
|
|
return _context3.abrupt('return', _context3.sent);
|
|
|
|
case 14:
|
|
_context3.next = 16;
|
|
return (0, _effects.put)((0, _show.updateChannelClaims)(channelKey, claimsData));
|
|
|
|
case 16:
|
|
case 'end':
|
|
return _context3.stop();
|
|
}
|
|
}
|
|
}, _marked3, this, [[2, 9]]);
|
|
}
|
|
|
|
function watchUpdateChannelClaims() {
|
|
return regeneratorRuntime.wrap(function watchUpdateChannelClaims$(_context4) {
|
|
while (1) {
|
|
switch (_context4.prev = _context4.next) {
|
|
case 0:
|
|
_context4.next = 2;
|
|
return (0, _effects.takeLatest)(actions.CHANNEL_CLAIMS_UPDATE_ASYNC, getNewClaimsAndUpdateChannel);
|
|
|
|
case 2:
|
|
case 'end':
|
|
return _context4.stop();
|
|
}
|
|
}
|
|
}, _marked4, this);
|
|
}
|
|
|
|
/***/ }),
|
|
/* 151 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.getChannelData = getChannelData;
|
|
exports.getChannelClaims = getChannelClaims;
|
|
|
|
var _request = __webpack_require__(10);
|
|
|
|
var _request2 = _interopRequireDefault(_request);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var _require = __webpack_require__(3),
|
|
host = _require.site.host;
|
|
|
|
function getChannelData(name, id) {
|
|
if (!id) id = 'none';
|
|
var url = host + '/api/channel/data/' + name + '/' + id;
|
|
return (0, _request2.default)(url);
|
|
};
|
|
|
|
function getChannelClaims(name, longId, page) {
|
|
if (!page) page = 1;
|
|
var url = host + '/api/channel/claims/' + name + '/' + longId + '/' + page;
|
|
return (0, _request2.default)(url);
|
|
};
|
|
|
|
/***/ }),
|
|
/* 152 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
|
|
|
|
module.exports = {
|
|
REGEXP_INVALID_CLAIM: /[^A-Za-z0-9-]/g,
|
|
REGEXP_INVALID_CHANNEL: /[^A-Za-z0-9-@]/g,
|
|
REGEXP_ADDRESS: /^b(?=[^0OIl]{32,33})[0-9A-Za-z]{32,33}$/,
|
|
CHANNEL_CHAR: '@',
|
|
parseIdentifier: function parseIdentifier(identifier) {
|
|
var componentsRegex = new RegExp('([^:$#/]*)' + // value (stops at the first separator or end)
|
|
'([:$#]?)([^/]*)' // modifier separator, modifier (stops at the first path separator or end)
|
|
);
|
|
|
|
var _componentsRegex$exec = componentsRegex // eslint-disable-line no-unused-vars
|
|
.exec(identifier).map(function (match) {
|
|
return match || null;
|
|
}),
|
|
_componentsRegex$exec2 = _slicedToArray(_componentsRegex$exec, 4),
|
|
proto = _componentsRegex$exec2[0],
|
|
value = _componentsRegex$exec2[1],
|
|
modifierSeperator = _componentsRegex$exec2[2],
|
|
modifier = _componentsRegex$exec2[3];
|
|
|
|
// Validate and process name
|
|
|
|
|
|
if (!value) {
|
|
throw new Error('Check your URL. No channel name provided before "' + modifierSeperator + '"');
|
|
}
|
|
var isChannel = value.startsWith(module.exports.CHANNEL_CHAR);
|
|
var channelName = isChannel ? value : null;
|
|
var claimId = void 0;
|
|
if (isChannel) {
|
|
if (!channelName) {
|
|
throw new Error('Check your URL. No channel name after "@".');
|
|
}
|
|
var nameBadChars = channelName.match(module.exports.REGEXP_INVALID_CHANNEL);
|
|
if (nameBadChars) {
|
|
throw new Error('Check your URL. Invalid characters in channel name: "' + nameBadChars.join(', ') + '".');
|
|
}
|
|
} else {
|
|
claimId = value;
|
|
}
|
|
|
|
// Validate and process modifier
|
|
var channelClaimId = void 0;
|
|
if (modifierSeperator) {
|
|
if (!modifier) {
|
|
throw new Error('Check your URL. No modifier provided after separator "' + modifierSeperator + '"');
|
|
}
|
|
|
|
if (modifierSeperator === ':') {
|
|
channelClaimId = modifier;
|
|
} else {
|
|
throw new Error('Check your URL. The "' + modifierSeperator + '" modifier is not currently supported');
|
|
}
|
|
}
|
|
return {
|
|
isChannel: isChannel,
|
|
channelName: channelName,
|
|
channelClaimId: channelClaimId || null,
|
|
claimId: claimId || null
|
|
};
|
|
},
|
|
parseClaim: function parseClaim(name) {
|
|
var componentsRegex = new RegExp('([^:$#/.]*)' + // name (stops at the first extension)
|
|
'([:$#.]?)([^/]*)' // extension separator, extension (stops at the first path separator or end)
|
|
);
|
|
|
|
var _componentsRegex$exec3 = componentsRegex // eslint-disable-line no-unused-vars
|
|
.exec(name).map(function (match) {
|
|
return match || null;
|
|
}),
|
|
_componentsRegex$exec4 = _slicedToArray(_componentsRegex$exec3, 4),
|
|
proto = _componentsRegex$exec4[0],
|
|
claimName = _componentsRegex$exec4[1],
|
|
extensionSeperator = _componentsRegex$exec4[2],
|
|
extension = _componentsRegex$exec4[3];
|
|
|
|
// Validate and process name
|
|
|
|
|
|
if (!claimName) {
|
|
throw new Error('Check your URL. No claim name provided before "."');
|
|
}
|
|
var nameBadChars = claimName.match(module.exports.REGEXP_INVALID_CLAIM);
|
|
if (nameBadChars) {
|
|
throw new Error('Check your URL. Invalid characters in claim name: "' + nameBadChars.join(', ') + '".');
|
|
}
|
|
// Validate and process extension
|
|
if (extensionSeperator) {
|
|
if (!extension) {
|
|
throw new Error('Check your URL. No file extension provided after separator "' + extensionSeperator + '".');
|
|
}
|
|
if (extensionSeperator !== '.') {
|
|
throw new Error('Check your URL. The "' + extensionSeperator + '" separator is not supported in the claim name.');
|
|
}
|
|
}
|
|
return {
|
|
claimName: claimName,
|
|
extension: extension || null
|
|
};
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 153 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
var handlePageRender = __webpack_require__(30);
|
|
|
|
module.exports = function (app) {
|
|
// a catch-all route if someone visits a page that does not exist
|
|
app.use('*', function (req, res) {
|
|
// send response
|
|
handlePageRender(req, res);
|
|
});
|
|
};
|
|
|
|
/***/ })
|
|
/******/ ]);
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/bootstrap ccaf8d6da25f6866aa0d","webpack:///external \"react\"","webpack:///external \"react-redux\"","webpack:///external \"winston\"","webpack:///./config/speechConfig.js","webpack:///external \"react-router-dom\"","webpack:///./react/actions/publish.js","webpack:///./react/containers/NavBar/index.js","webpack:///./react/actions/show.js","webpack:///./react/components/SEO/index.jsx","webpack:///external \"prop-types\"","webpack:///./react/utils/request.js","webpack:///./models/index.js","webpack:///./react/constants/show_action_types.js","webpack:///./react/selectors/show.js","webpack:///external \"react-helmet\"","webpack:///external \"redux-saga/effects\"","webpack:///./helpers/lbryApi.js","webpack:///./helpers/googleAnalytics.js","webpack:///external \"redux\"","webpack:///./react/actions/channel.js","webpack:///./react/components/ProgressBar/index.jsx","webpack:///./react/components/ErrorPage/index.jsx","webpack:///external \"passport\"","webpack:///./config/mysqlConfig.js","webpack:///./config/slackConfig.js","webpack:///external \"passport-local\"","webpack:///./helpers/sequelizeHelpers.js","webpack:///./helpers/publishHelpers.js","webpack:///./helpers/errorHandlers.js","webpack:///./controllers/serveController.js","webpack:///./helpers/handlePageRender.jsx","webpack:///external \"react-dom/server\"","webpack:///./react/reducers/index.js","webpack:///./react/constants/publish_action_types.js","webpack:///./react/constants/publish_channel_select_states.js","webpack:///./react/constants/channel_action_types.js","webpack:///./react/constants/asset_display_states.js","webpack:///./react/components/GAListener/index.jsx","webpack:///./react/app.js","webpack:///./react/containers/Dropzone/index.js","webpack:///./react/containers/ChannelLoginForm/index.js","webpack:///./react/containers/ChannelCreateForm/index.js","webpack:///./react/constants/show_request_types.js","webpack:///./react/containers/AssetDisplay/index.js","webpack:///./helpers/renderFullPage.js","webpack:///external \"babel-polyfill\"","webpack:///external \"whatwg-fetch\"","webpack:///./server.js","webpack:///external \"express\"","webpack:///external \"body-parser\"","webpack:///external \"express-handlebars\"","webpack:///external \"handlebars\"","webpack:///external \"helmet\"","webpack:///./helpers/authHelpers.js","webpack:///external \"cookie-session\"","webpack:///external \"http\"","webpack:///./helpers/configVarCheck.js","webpack:///./helpers/configureLogger.js","webpack:///./config/loggerConfig.js","webpack:///./helpers/configureSlack.js","webpack:///external \"winston-slack-webhook\"","webpack:///./passport/local-signup.js","webpack:///external \"axios\"","webpack:///./config/lbryConfig.js","webpack:///external \"universal-analytics\"","webpack:///./passport/local-login.js","webpack:///./routes/auth-routes.js","webpack:///./routes/api-routes.js","webpack:///external \"connect-multiparty\"","webpack:///external \"sequelize\"","webpack:///./models/certificate.js","webpack:///./models/channel.js","webpack:///./models/claim.js","webpack:///./models/file.js","webpack:///./models/request.js","webpack:///./models/user.js","webpack:///external \"bcrypt\"","webpack:///./controllers/publishController.js","webpack:///external \"fs\"","webpack:///./auth/authentication.js","webpack:///./helpers/channelPagination.js","webpack:///./routes/page-routes.js","webpack:///./react/reducers/publish.js","webpack:///./react/reducers/channel.js","webpack:///./react/reducers/show.js","webpack:///./react/reducers/site.js","webpack:///external \"react-ga\"","webpack:///./react/components/HomePage/index.jsx","webpack:///./react/utils/pageTitle.js","webpack:///./react/utils/metaTags.js","webpack:///./react/utils/canonicalLink.js","webpack:///./react/containers/NavBar/view.jsx","webpack:///./react/components/Logo/index.jsx","webpack:///./react/components/NavBarChannelOptionsDropdown/index.jsx","webpack:///external \"cross-fetch/polyfill\"","webpack:///./react/containers/PublishTool/index.js","webpack:///./react/containers/PublishTool/view.jsx","webpack:///./react/containers/Dropzone/view.jsx","webpack:///./react/utils/file.js","webpack:///./react/components/Preview/index.jsx","webpack:///./react/containers/PublishDetails/index.js","webpack:///./react/containers/PublishDetails/view.jsx","webpack:///./react/containers/PublishTitleInput/index.js","webpack:///./react/containers/PublishTitleInput/view.jsx","webpack:///./react/containers/PublishUrlInput/index.js","webpack:///./react/containers/PublishUrlInput/view.jsx","webpack:///./react/components/PublishUrlMiddleDisplay/index.jsx","webpack:///./react/containers/PublishThumbnailInput/index.js","webpack:///./react/containers/PublishThumbnailInput/view.jsx","webpack:///./react/containers/PublishMetadataInputs/index.js","webpack:///./react/containers/PublishMetadataInputs/view.jsx","webpack:///./react/components/ExpandingTextArea/index.jsx","webpack:///./react/containers/ChannelSelect/index.js","webpack:///./react/containers/ChannelSelect/view.jsx","webpack:///./react/containers/ChannelLoginForm/view.jsx","webpack:///./react/containers/ChannelCreateForm/view.jsx","webpack:///./react/components/ActiveStatusBar/index.jsx","webpack:///./react/components/InactiveStatusBar/index.jsx","webpack:///./react/containers/PublishStatus/index.js","webpack:///./react/containers/PublishStatus/view.jsx","webpack:///./react/constants/publish_claim_states.js","webpack:///./react/components/AboutPage/index.jsx","webpack:///./react/containers/LoginPage/index.js","webpack:///./react/containers/LoginPage/view.jsx","webpack:///./react/containers/ShowPage/index.js","webpack:///./react/containers/ShowPage/view.jsx","webpack:///./react/containers/ShowAssetLite/index.js","webpack:///./react/containers/ShowAssetLite/view.jsx","webpack:///./react/containers/AssetDisplay/view.jsx","webpack:///./react/containers/ShowAssetDetails/index.js","webpack:///./react/containers/ShowAssetDetails/view.jsx","webpack:///./react/containers/AssetTitle/index.js","webpack:///./react/containers/AssetTitle/view.jsx","webpack:///./react/containers/AssetInfo/index.js","webpack:///./react/containers/AssetInfo/view.jsx","webpack:///./react/containers/ShowChannel/index.js","webpack:///./react/containers/ShowChannel/view.jsx","webpack:///./react/containers/ChannelClaimsDisplay/index.js","webpack:///./react/containers/ChannelClaimsDisplay/view.jsx","webpack:///./react/components/AssetPreview/index.jsx","webpack:///./react/components/FourOhFourPage/index.jsx","webpack:///./routes/serve-routes.js","webpack:///./helpers/serveHelpers.js","webpack:///./helpers/lbryUri.js","webpack:///./helpers/handleShowRender.jsx","webpack:///external \"redux-saga\"","webpack:///./react/sagas/show_uri.js","webpack:///./react/sagas/show_asset.js","webpack:///./react/api/assetApi.js","webpack:///./react/sagas/show_channel.js","webpack:///./react/api/channelApi.js","webpack:///./react/utils/lbryUri.js","webpack:///./routes/fallback-routes.js"],"names":["speechConfig","analytics","googleId","session","sessionKey","files","uploadDirectory","site","title","name","host","description","publish","primaryClaimAddress","additionalClaimAddresses","thumbnailChannel","thumbnailChannelId","claim","defaultTitle","defaultThumbnail","defaultDescription","module","exports","selectFile","clearFile","updateMetadata","updateClaim","setPublishInChannel","updatePublishStatus","updateError","updateSelectedChannel","toggleMetadataInputs","onNewThumbnail","startPublish","actions","file","type","FILE_SELECTED","data","FILE_CLEAR","value","METADATA_UPDATE","CLAIM_UPDATE","channel","SET_PUBLISH_IN_CHANNEL","status","message","PUBLISH_STATUS_UPDATE","ERROR_UPDATE","channelName","SELECTED_CHANNEL_UPDATE","showMetadataInputs","TOGGLE_METADATA_INPUTS","THUMBNAIL_NEW","history","PUBLISH_START","mapStateToProps","loggedInChannel","channelShortId","shortId","channelLongId","longId","mapDispatchToProps","onChannelLogin","dispatch","onChannelLogout","onHandleShowPageUri","onRequestError","onNewChannelRequest","onNewAssetRequest","onRequestUpdate","addRequestToRequestList","addAssetToAssetList","addNewChannelToChannelList","onUpdateChannelClaims","updateChannelClaims","fileRequested","updateFileAvailability","updateDisplayAssetError","params","HANDLE_SHOW_URI","error","REQUEST_ERROR","channelId","requestType","requestId","CHANNEL_REQUEST_NEW","id","extension","ASSET_REQUEST_NEW","modifier","REQUEST_UPDATE","key","REQUEST_LIST_ADD","claimId","claimData","ASSET_ADD","claimsData","CHANNEL_ADD","channelKey","page","CHANNEL_CLAIMS_UPDATE_ASYNC","channelListId","CHANNEL_CLAIMS_UPDATE_SUCCESS","FILE_REQUESTED","FILE_AVAILABILITY_UPDATE","DISPLAY_ASSET_ERROR","SEO","props","pageTitle","asset","pageUri","metaTags","canonicalLink","rel","href","Component","propTypes","string","object","request","parseJSON","response","json","checkStatus","jsonResponse","Error","url","options","fetch","then","Promise","all","Sequelize","require","logger","console","log","database","username","password","db","sequelize","dialect","dialectOptions","decimalNumbers","logging","pool","max","min","idle","acquire","authenticate","info","catch","err","Certificate","Channel","Claim","File","Request","User","import","Object","keys","forEach","modelName","associate","upsert","Model","values","condition","tableName","findOne","where","obj","debug","update","create","selectAsset","show","requestList","assetKey","assetList","selectShowState","state","axios","api","apiHost","apiPort","lbryApiUri","chooseGaLbrynetPublishLabel","sendGATimingEvent","handleLbrynetResponse","resolve","reject","result","JSON","stringify","publishClaim","publishParams","gaStartTime","Date","now","post","method","getClaim","uri","timeout","getClaimList","claimName","resolveUri","getDownloadDirectory","download_directory","createChannel","channel_name","amount","ua","siteName","createServeEventParams","headers","ip","originalUrl","eventCategory","eventAction","eventLabel","ipOverride","userAgentOverride","createPublishTimingEventParams","category","variable","label","startTime","endTime","duration","userTimingCategory","userTimingVariableName","userTimingTime","userTimingLabel","sendGoogleAnalyticsEvent","visitorId","replace","visitor","strictCidFormat","https","event","sendGoogleAnalyticsTiming","timing","sendGAServeEvent","channel_id","updateLoggedInChannel","CHANNEL_UPDATE","ProgressBar","bars","index","incrementer","createBars","bind","startProgressBar","updateProgressBar","stopProgressBar","i","size","push","isActive","setState","updateInterval","setInterval","clearInterval","map","bar","number","isRequired","ErrorPage","MysqlConfig","configure","SlackConfig","slackWebHook","slackErrorChannel","slackInfoChannel","returnShortId","claimsArray","claimIndex","substring","shortIdLength","findIndex","element","possibleMatches","slice","length","filter","fs","wallet","parsePublishApiRequestBody","nsfw","license","thumbnail","invalidNameCharacters","exec","parsePublishApiRequestFiles","path","test","validateFileTypeAndSize","fileName","filePath","fileType","thumbnailFileName","thumbnailFilePath","thumbnailFileType","createBasicPublishParams","trim","file_path","bid","metadata","author","language","claim_address","lbryClaimAddress","createThumbnailPublishParams","deleteTemporaryFile","unlink","addGetResultsToFileData","fileInfo","getResult","file_name","download_path","createFileData","outpoint","height","address","contentType","handleErrorResponse","res","useObjectPropertiesIfNoKeys","returnErrorMessageAndStatus","createErrorResponsePayload","code","newErrorObject","getOwnPropertyNames","success","returnPaginatedChannelClaims","NO_CHANNEL","NO_CLAIM","NO_FILE","getClaimId","channelClaimId","getClaimIdByChannel","getClaimIdByClaim","getLongClaimId","longClaimId","getLongChannelId","longChannelId","getClaimIdByLongChannelId","getChannelData","longChannelClaimId","getShortChannelIdFromLongChannelId","shortChannelClaimId","getChannelClaims","getAllChannelClaims","channelClaimsArray","paginatedChannelViewData","getLocalFileRecord","dataValues","req","context","store","html","helmet","renderStatic","redirect","preloadedState","getState","send","LOGIN","CREATE","LOCAL_CHECK","UNAVAILABLE","ERROR","AVAILABLE","config","googleApiKey","initialize","GAListener","sendPageView","location","listen","set","pathname","pageview","children","App","fileError","setFileError","CHANNEL","ASSET_LITE","ASSET_DETAILS","displayAsset","onFileRequest","toString","meta","link","express","bodyParser","expressHandlebars","Handlebars","passport","populateLocalsDotUser","serializeSpeechUser","deserializeSpeechUser","cookieSession","http","SpeechServer","mysqlConfig","siteConfig","slackConfig","PORT","speak","something","start","configureConfigFiles","configureLogging","configureApp","configureServer","startServer","mysqlAppConfig","slackAppConfig","app","enable","use","static","__dirname","urlencoded","extended","next","verbose","serializeUser","deserializeUser","localSignupStrategy","localLoginStrategy","maxAge","hbs","defaultLayout","handlebars","engine","server","Server","sync","user","locals","userName","shortChannelId","done","configCategoryKey","hasOwnProperty","configVariables","configVarKey","logLevel","winston","transports","Console","level","timestamp","colorize","prettyPrint","handleExceptions","humanReadableUnhandledException","warn","silly","loggerConfig","winstonSlackWebHook","SlackWebHook","add","webhookUrl","iconEmoji","PassportLocalStrategy","Strategy","lbryApi","usernameField","passwordField","userInfo","userData","channelData","tx","claim_id","certificateData","newUser","newChannel","newCertificate","setChannel","setUser","lbryConfig","returnUserAndChannelInfo","userInstance","getChannel","comparePassword","isMatch","logIn","get","logout","multipart","multipartMiddleware","uploadDir","claimNameIsAvailable","checkChannelAvailability","errorHandlers","authenticateUser","body","claimsList","resolveClaim","resolveResult","fileData","fileRecord","completed","resolvedUri","channelPassword","validatedClaimName","thumbnailPublishParams","lbryTx","getShortClaimIdFromLongClaimId","claimInfo","STRING","BOOLEAN","INTEGER","TEXT","DECIMAL","define","default","claimSequence","decodedClaim","depth","effectiveAmount","hasSignature","hex","nout","txid","validAtHeight","valueVersion","claimType","certificateVersion","keyType","publicKey","freezeTableName","belongsTo","foreignKey","allowNull","findAll","order","getLongChannelIdFromShortChannelId","$like","getLongChannelIdFromChannelName","validateLongChannelId","hasOne","determineFileExtensionFromContentType","determineThumbnail","storedThumbnail","prepareClaimData","certificateId","licenseUrl","preview","metadataVersion","source","sourceType","sourceVersion","streamVersion","raw","getLongClaimIdFromShortClaimId","getTopFreeClaimIdByClaimName","validateLongClaimId","claimArray","defaultValue","trendingEligible","hasMany","getRecentClaims","limit","action","ipAddress","bcrypt","prototype","compare","changePassword","newPassword","genSalt","saltError","salt","hash","hashError","hook","publishHelpers","publishResults","claimRecord","upsertCriteria","setClaim","setFile","claimAddress","filteredResult","authenticateChannelCredentials","userPassword","channelFindParams","CLAIMS_PER_PAGE","claims","totalPages","determineTotalPages","paginationPage","getPageFromQuery","viewData","extractPageFromClaims","previousPage","determinePreviousPage","currentPage","nextPage","determineNextPage","totalResults","determineTotalClaims","parseInt","pageNumber","claimStartIndex","claimEndIndex","pageOfClaims","totalClaims","fullPages","Math","floor","remainder","handlePageRender","render","layout","initialState","assign","publishInChannel","selectedChannel","publishSubmit","channelList","HomePage","siteTitle","createPageTitle","determineOgThumbnailContentType","fileExt","lastIndexOf","createBasicMetaTags","property","content","createChannelMetaTags","createAssetMetaTags","embedUrl","showUrl","ogTitle","ogDescription","ogThumbnailContentType","ogThumbnail","createMetaTags","createBasicCanonicalLink","createAssetCanonicalLink","createChannelCanonicalLink","createCanonicalLink","VIEW","LOGOUT","NavBar","checkForLoggedInUser","logoutUser","handleSelection","credentials","target","selectedOptions","Logo","NavBarChannelDropdown","defaultSelection","PublishTool","Dropzone","dragOver","mouseOver","dimPreview","handleDrop","handleDragOver","handleDragEnd","handleDragEnter","handleDragLeave","handleMouseEnter","handleMouseLeave","handleClick","handleFileInput","chooseFile","preventDefault","dt","dataTransfer","items","kind","droppedFile","getAsFile","remove","clearData","document","getElementById","click","fileList","validateFile","Preview","imgSource","setPreviewImageSource","newProps","setPreviewImageSourceFromFile","previewReader","FileReader","readAsDataURL","onloadend","bool","PublishDetails","onPublishSubmit","onMetadataChange","PublishTitleInput","handleInput","e","loggedInChannelName","loggedInChannelShortId","urlError","onClaimChange","onUrlError","PublishUrlInput","setClaimName","validateClaim","cleanseInput","input","fileNameWithoutEnding","cleanClaimName","UrlMiddle","dataURItoBlob","dataURI","byteString","atob","split","mimeString","ia","Uint8Array","charCodeAt","Blob","PublishThumbnailInput","videoSource","sliderMinRange","sliderMaxRange","sliderValue","handleVideoLoadedData","handleSliderChange","createThumbnail","setVideoSource","nextProps","dataUri","blob","URL","createObjectURL","totalMinutes","totalSeconds","video","currentTime","canvas","createElement","width","videoWidth","videoHeight","getContext","drawImage","dataUrl","toDataURL","snapshot","display","onToggleMetadataInputs","PublishMetadataInputs","toggleShowInputs","handleSelect","checked","selectedOption","maxHeight","ExpandingTextarea","_handleChange","adjustTextarea","onChange","el","style","scrollHeight","rest","x","func","channelError","onPublishInChannelChange","onChannelSelect","states","ChannelSelect","toggleAnonymousPublish","ChannelLoginForm","loginToChannel","Headers","ChannelCreateForm","handleChannelInput","cleanseChannelInput","updateIsChannelAvailable","channelWithAtSymbol","isAvailable","checkIsPasswordProvided","checkIsChannelAvailable","makePublishChannelRequest","ActiveStatusBar","InactiveStatusBar","publishStates","PublishStatus","LOAD_START","LOADING","PUBLISHING","SUCCESS","FAILED","AboutPage","LoginPage","ShowPage","match","ShowLite","AssetDisplay","ShowAssetDetails","AssetTitle","AssetInfo","copyToClipboard","elementToCopy","dataset","elementtocopy","select","execCommand","previousRequest","ShowChannel","ChannelClaimsDisplay","showNextResultsPage","showPreviousResultsPage","showNewPage","AssetPreview","directSourceLink","showUrlLink","FourOhForPage","determineResponseType","flipClaimNameAndIdForBackwardsCompatibility","logRequestData","getClaimIdAndServeAsset","lbryUri","handleShowRender","SERVE","hasFileExtension","parseModifier","responseType","parseClaim","isChannel","parseIdentifier","identifier","SHOW","clientAcceptsHtml","accept","requestIsFromBrowser","clientWantsAsset","range","imageIsWanted","videoIsWanted","isValidClaimId","isValidShortId","isValidShortIdOrClaimId","serveAssetToClient","sendFileOptions","sendFile","fullClaimId","tempName","REGEXP_INVALID_CLAIM","REGEXP_INVALID_CHANNEL","REGEXP_ADDRESS","CHANNEL_CHAR","componentsRegex","RegExp","proto","modifierSeperator","startsWith","nameBadChars","join","returnSagaWithParams","saga","sagaMiddleware","middleware","run","handleShowPageUri","watchHandleShowPageUri","parseAndUpdateIdentifierAndClaim","parseAndUpdateClaimOnly","newAssetRequest","watchNewAssetRequest","getShortId","getClaimData","newChannelRequest","watchNewChannelRequest","watchUpdateChannelClaims","getNewClaimsAndUpdateChannel","extensionSeperator"],"mappings":";;AAAA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAK;AACL;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;AAEA;AACA;;;;;;;AC7DA,kC;;;;;;ACAA,wC;;;;;;ACAA,oC;;;;;;;;;ACAA,IAAMA,eAAe;AACnBC,aAAW;AACTC,cAAU,eADD,CACkB;AADlB,GADQ;AAInBC,WAAS;AACPC,gBAAY,uBADL,CAC+B;AAD/B,GAJU;AAOnBC,SAAO;AACLC,qBAAiB,oBADZ,CACmC;AADnC,GAPY;AAUnBC,QAAM;AACJC,WAAa,cADT;AAEJC,UAAa,cAFT;AAGJC,UAAa,sBAHT;AAIJC,iBAAa;AAJT,GAVa;AAgBnBC,WAAS;AACPC,yBAA0B,oCADnB;AAEPC,8BAA0B,CAAC,oCAAD,CAFnB;AAGPC,sBAA0B,aAHnB,EAGmC;AAC1CC,wBAA0B,0CAJnB,CAIgE;AAJhE,GAhBU;AAsBnBC,SAAO;AACLC,kBAAoB,cADf;AAELC,sBAAoB,oDAFf;AAGLC,wBAAoB;AAHf;AAtBY,CAArB;;AA6BAC,OAAOC,OAAP,GAAiBtB,YAAjB,C;;;;;;AC7BA,6C;;;;;;;;;;;;QCGgBuB,U,GAAAA,U;QAOAC,S,GAAAA,S;QAMAC,c,GAAAA,c;QAUAC,W,GAAAA,W;QAOAC,mB,GAAAA,mB;QAOAC,mB,GAAAA,mB;QAUAC,W,GAAAA,W;QAUAC,qB,GAAAA,qB;QAOAC,oB,GAAAA,oB;QAOAC,c,GAAAA,c;QAOAC,Y,GAAAA,Y;;AAjFhB;;IAAYC,O;;;;AAEZ;AACO,SAASX,UAAT,CAAqBY,IAArB,EAA2B;AAChC,SAAO;AACLC,UAAMF,QAAQG,aADT;AAELC,UAAMH;AAFD,GAAP;AAID;;AAEM,SAASX,SAAT,GAAsB;AAC3B,SAAO;AACLY,UAAMF,QAAQK;AADT,GAAP;AAGD;;AAEM,SAASd,cAAT,CAAyBhB,IAAzB,EAA+B+B,KAA/B,EAAsC;AAC3C,SAAO;AACLJ,UAAMF,QAAQO,eADT;AAELH,UAAM;AACJ7B,gBADI;AAEJ+B;AAFI;AAFD,GAAP;AAOD;;AAEM,SAASd,WAAT,CAAsBc,KAAtB,EAA6B;AAClC,SAAO;AACLJ,UAAMF,QAAQQ,YADT;AAELJ,UAAME;AAFD,GAAP;AAID;;AAEM,SAASb,mBAAT,CAA8BgB,OAA9B,EAAuC;AAC5C,SAAO;AACLP,UAAMF,QAAQU,sBADT;AAELD;AAFK,GAAP;AAID;;AAEM,SAASf,mBAAT,CAA8BiB,MAA9B,EAAsCC,OAAtC,EAA+C;AACpD,SAAO;AACLV,UAAMF,QAAQa,qBADT;AAELT,UAAM;AACJO,oBADI;AAEJC;AAFI;AAFD,GAAP;AAOD;;AAEM,SAASjB,WAAT,CAAsBpB,IAAtB,EAA4B+B,KAA5B,EAAmC;AACxC,SAAO;AACLJ,UAAMF,QAAQc,YADT;AAELV,UAAM;AACJ7B,gBADI;AAEJ+B;AAFI;AAFD,GAAP;AAOD;;AAEM,SAASV,qBAAT,CAAgCmB,WAAhC,EAA6C;AAClD,SAAO;AACLb,UAAMF,QAAQgB,uBADT;AAELZ,UAAMW;AAFD,GAAP;AAID;;AAEM,SAASlB,oBAAT,CAA+BoB,kBAA/B,EAAmD;AACxD,SAAO;AACLf,UAAMF,QAAQkB,sBADT;AAELd,UAAMa;AAFD,GAAP;AAID;;AAEM,SAASnB,cAAT,CAAyBG,IAAzB,EAA+B;AACpC,SAAO;AACLC,UAAMF,QAAQmB,aADT;AAELf,UAAMH;AAFD,GAAP;AAID;;AAEM,SAASF,YAAT,CAAuBqB,OAAvB,EAAgC;AACrC,SAAO;AACLlB,UAAMF,QAAQqB,aADT;AAELjB,UAAM,EAAEgB,gBAAF;AAFD,GAAP;AAID,C;;;;;;;;;;;;;ACtFD;;AACA;;AACA;;;;AACA;;;;AAEA,IAAME,kBAAkB,SAAlBA,eAAkB,OAAiB;AAAA,MAAdb,OAAc,QAAdA,OAAc;;AACvC,SAAO;AACLM,iBAAgBN,QAAQc,eAAR,CAAwBhD,IADnC;AAELiD,oBAAgBf,QAAQc,eAAR,CAAwBE,OAFnC;AAGLC,mBAAgBjB,QAAQc,eAAR,CAAwBI;AAHnC,GAAP;AAKD,CAND;;AAQA,IAAMC,qBAAqB,SAArBA,kBAAqB,WAAY;AACrC,SAAO;AACLC,oBAAgB,wBAACtD,IAAD,EAAOkD,OAAP,EAAgBE,MAAhB,EAA2B;AACzCG,eAAS,oCAAsBvD,IAAtB,EAA4BkD,OAA5B,EAAqCE,MAArC,CAAT;AACAG,eAAS,oCAAsBvD,IAAtB,CAAT;AACD,KAJI;AAKLwD,qBAAiB,2BAAM;AACrBD,eAAS,oCAAsB,IAAtB,EAA4B,IAA5B,EAAkC,IAAlC,CAAT;AACD;AAPI,GAAP;AASD,CAVD;;kBAYe,yBAAQR,eAAR,EAAyBM,kBAAzB,iB;;;;;;;;;;;;QCpBCI,mB,GAAAA,mB;QAOAC,c,GAAAA,c;QAOAC,mB,GAAAA,mB;QASAC,iB,GAAAA,iB;QAoBAC,e,GAAAA,e;QAUAC,uB,GAAAA,uB;QASAC,mB,GAAAA,mB;QASAC,0B,GAAAA,0B;QAOAC,qB,GAAAA,qB;QAOAC,mB,GAAAA,mB;QASAC,a,GAAAA,a;QAOAC,sB,GAAAA,sB;QAOAC,uB,GAAAA,uB;;AAjHhB;;IAAY5C,O;;AAEZ;;;;AAEA;AACO,SAASgC,mBAAT,CAA8Ba,MAA9B,EAAsC;AAC3C,SAAO;AACL3C,UAAMF,QAAQ8C,eADT;AAEL1C,UAAMyC;AAFD,GAAP;AAID;;AAEM,SAASZ,cAAT,CAAyBc,KAAzB,EAAgC;AACrC,SAAO;AACL7C,UAAMF,QAAQgD,aADT;AAEL5C,UAAM2C;AAFD,GAAP;AAID;;AAEM,SAASb,mBAAT,CAA8BnB,WAA9B,EAA2CkC,SAA3C,EAAsD;AAC3D,MAAMC,yCAAN;AACA,MAAMC,oBAAkBpC,WAAlB,SAAiCkC,SAAvC;AACA,SAAO;AACL/C,UAAMF,QAAQoD,mBADT;AAELhD,UAAM,EAAE8C,wBAAF,EAAeC,oBAAf,EAA0BpC,wBAA1B,EAAuCkC,oBAAvC;AAFD,GAAP;AAID;;AAEM,SAASd,iBAAT,CAA4B5D,IAA5B,EAAkC8E,EAAlC,EAAsCtC,WAAtC,EAAmDkC,SAAnD,EAA8DK,SAA9D,EAAyE;AAC9E,MAAMJ,cAAcI,8EAApB;AACA,MAAMH,oBAAkB5E,IAAlB,SAA0B8E,EAA1B,SAAgCtC,WAAhC,SAA+CkC,SAArD;AACA,SAAO;AACL/C,UAAMF,QAAQuD,iBADT;AAELnD,UAAM;AACJ8C,8BADI;AAEJC,0BAFI;AAGJ5E,gBAHI;AAIJiF,gBAAU;AACRH,cADQ;AAER5C,iBAAS;AACPlC,gBAAMwC,WADC;AAEPsC,cAAMJ;AAFC;AAFD;AAJN;AAFD,GAAP;AAeD;;AAEM,SAASb,eAAT,CAA0Bc,WAA1B,EAAuCC,SAAvC,EAAkD;AACvD,SAAO;AACLjD,UAAMF,QAAQyD,cADT;AAELrD,UAAM;AACJ8C,8BADI;AAEJC;AAFI;AAFD,GAAP;AAOD;;AAEM,SAASd,uBAAT,CAAkCgB,EAAlC,EAAsCN,KAAtC,EAA6CW,GAA7C,EAAkD;AACvD,SAAO;AACLxD,UAAMF,QAAQ2D,gBADT;AAELvD,UAAM,EAAEiD,MAAF,EAAMN,YAAN,EAAaW,QAAb;AAFD,GAAP;AAID;;AAED;;AAEO,SAASpB,mBAAT,CAA8Be,EAA9B,EAAkCN,KAAlC,EAAyCxE,IAAzC,EAA+CqF,OAA/C,EAAwDnC,OAAxD,EAAiEoC,SAAjE,EAA4E;AACjF,SAAO;AACL3D,UAAMF,QAAQ8D,SADT;AAEL1D,UAAM,EAAEiD,MAAF,EAAMN,YAAN,EAAaxE,UAAb,EAAmBqF,gBAAnB,EAA4BnC,gBAA5B,EAAqCoC,oBAArC;AAFD,GAAP;AAID;;AAED;;AAEO,SAAStB,0BAAT,CAAqCc,EAArC,EAAyC9E,IAAzC,EAA+CkD,OAA/C,EAAwDE,MAAxD,EAAgEoC,UAAhE,EAA4E;AACjF,SAAO;AACL7D,UAAMF,QAAQgE,WADT;AAEL5D,UAAM,EAAEiD,MAAF,EAAM9E,UAAN,EAAYkD,gBAAZ,EAAqBE,cAArB,EAA6BoC,sBAA7B;AAFD,GAAP;AAID;;AAEM,SAASvB,qBAAT,CAAgCyB,UAAhC,EAA4C1F,IAA5C,EAAkDoD,MAAlD,EAA0DuC,IAA1D,EAAgE;AACrE,SAAO;AACLhE,UAAMF,QAAQmE,2BADT;AAEL/D,UAAM,EAAC6D,sBAAD,EAAa1F,UAAb,EAAmBoD,cAAnB,EAA2BuC,UAA3B;AAFD,GAAP;AAID;;AAEM,SAASzB,mBAAT,CAA8B2B,aAA9B,EAA6CL,UAA7C,EAAyD;AAC9D,SAAO;AACL7D,UAAMF,QAAQqE,6BADT;AAELjE,UAAM,EAACgE,4BAAD,EAAgBL,sBAAhB;AAFD,GAAP;AAID;;AAED;;AAEO,SAASrB,aAAT,CAAwBnE,IAAxB,EAA8BqF,OAA9B,EAAuC;AAC5C,SAAO;AACL1D,UAAMF,QAAQsE,cADT;AAELlE,UAAM,EAAE7B,UAAF,EAAQqF,gBAAR;AAFD,GAAP;AAID;;AAEM,SAASjB,sBAAT,CAAiChC,MAAjC,EAAyC;AAC9C,SAAO;AACLT,UAAMF,QAAQuE,wBADT;AAELnE,UAAMO;AAFD,GAAP;AAID;;AAEM,SAASiC,uBAAT,CAAkCG,KAAlC,EAAyC;AAC9C,SAAO;AACL7C,UAAMF,QAAQwE,mBADT;AAELpE,UAAM2C;AAFD,GAAP;AAID,E;;;;;;;;;;;;;;;ACtHD;;;;AACA;;;;AACA;;;;AAEA;;AACA;;AACA;;;;;;;;;;IAEM0B,G;;;;;;;;;;;6BACM;AAAA,mBACqC,KAAKC,KAD1C;AAAA,UACFC,SADE,UACFA,SADE;AAAA,UACSC,KADT,UACSA,KADT;AAAA,UACgBnE,OADhB,UACgBA,OADhB;AAAA,UACyBoE,OADzB,UACyBA,OADzB;;AAERF,kBAAY,gCAAgBA,SAAhB,CAAZ;AACA,UAAMG,WAAW,8BAAeF,KAAf,EAAsBnE,OAAtB,CAAjB;AACA,UAAMsE,gBAAgB,wCAAoBH,KAApB,EAA2BnE,OAA3B,EAAoCoE,OAApC,CAAtB;AACA,aACE;AACE,eAAOF,SADT;AAEE,cAAMG,QAFR;AAGE,cAAM,CAAC,EAACE,KAAK,WAAN,EAAmBC,MAAMF,aAAzB,EAAD;AAHR,QADF;AAOD;;;;EAbe,gBAAMG,S;;AAcvB;;AAEDT,IAAIU,SAAJ,GAAgB;AACdR,aAAW,oBAAUS,MADP;AAEdP,WAAW,oBAAUO,MAFP;AAGd3E,WAAW,oBAAU4E,MAHP;AAIdT,SAAW,oBAAUS;AAJP,CAAhB;;kBAOeZ,G;;;;;;AC/Bf,uC;;;;;;;;;;;;;;;kBC0CwBa,O;;AA1CxB;;AAEA;;;;;;;AAOA,SAASC,SAAT,CAAoBC,QAApB,EAA8B;AAC5B,MAAIA,SAAS7E,MAAT,KAAoB,GAApB,IAA2B6E,SAAS7E,MAAT,KAAoB,GAAnD,EAAwD;AACtD,WAAO,IAAP;AACD;AACD,SAAO6E,SAASC,IAAT,EAAP;AACD;;AAED;;;;;;;;AAQA,SAASC,WAAT,CAAsBF,QAAtB,EAAgCG,YAAhC,EAA8C;AAC5C,MAAIH,SAAS7E,MAAT,IAAmB,GAAnB,IAA0B6E,SAAS7E,MAAT,GAAkB,GAAhD,EAAqD;AACnD,WAAOgF,YAAP;AACD;AACD,MAAM5C,QAAQ,IAAI6C,KAAJ,CAAUD,aAAa/E,OAAvB,CAAd;AACAmC,QAAMyC,QAAN,GAAiBA,QAAjB;AACA,QAAMzC,KAAN;AACD;;AAED;;;;;;;;;AASe,SAASuC,OAAT,CAAkBO,GAAlB,EAAuBC,OAAvB,EAAgC;AAC7C,SAAOC,MAAMF,GAAN,EAAWC,OAAX,EACJE,IADI,CACC,oBAAY;AAChB,WAAOC,QAAQC,GAAR,CAAY,CAACV,QAAD,EAAWD,UAAUC,QAAV,CAAX,CAAZ,CAAP;AACD,GAHI,EAIJQ,IAJI,CAIC,gBAA8B;AAAA;AAAA,QAA5BR,QAA4B;AAAA,QAAlBG,YAAkB;;AAClC,WAAOD,YAAYF,QAAZ,EAAsBG,YAAtB,CAAP;AACD,GANI,CAAP;AAOD,C;;;;;;;;;AClDD,IAAMQ,YAAY,mBAAAC,CAAQ,EAAR,CAAlB;AACA,IAAMC,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;AAEAE,QAAQC,GAAR,CAAY,4BAAZ;;eACyC,mBAAAH,CAAQ,EAAR,C;IAAjCI,Q,YAAAA,Q;IAAUC,Q,YAAAA,Q;IAAUC,Q,YAAAA,Q;;AAC5B,IAAMC,KAAK,EAAX;AACA;AACA,IAAMC,YAAY,IAAIT,SAAJ,CAAcK,QAAd,EAAwBC,QAAxB,EAAkCC,QAAlC,EAA4C;AAC5DlI,QAAgB,WAD4C;AAE5DqI,WAAgB,OAF4C;AAG5DC,kBAAgB,EAACC,gBAAgB,IAAjB,EAH4C,EAGpB;AACxCC,WAAgB,KAJ4C;AAK5DC,QAAgB;AACdC,SAAS,CADK;AAEdC,SAAS,CAFK;AAGdC,UAAS,KAHK;AAIdC,aAAS;AAJK;AAL4C,CAA5C,CAAlB;;AAaA;AACAT,UACGU,YADH,GAEGtB,IAFH,CAEQ,YAAM;AACVK,SAAOkB,IAAP,CAAY,0DAAZ;AACD,CAJH,EAKGC,KALH,CAKS,eAAO;AACZnB,SAAOtD,KAAP,CAAa,kDAAb,EAAiE0E,GAAjE;AACD,CAPH;;AASA;AACA,IAAMC,cAAc,mBAAAtB,CAAQ,EAAR,CAApB;AACA,IAAMuB,UAAU,mBAAAvB,CAAQ,EAAR,CAAhB;AACA,IAAMwB,QAAQ,mBAAAxB,CAAQ,EAAR,CAAd;AACA,IAAMyB,OAAO,mBAAAzB,CAAQ,EAAR,CAAb;AACA,IAAM0B,UAAU,mBAAA1B,CAAQ,EAAR,CAAhB;AACA,IAAM2B,OAAO,mBAAA3B,CAAQ,EAAR,CAAb;AACAO,GAAG,aAAH,IAAoBC,UAAUoB,MAAV,CAAiB,aAAjB,EAAgCN,WAAhC,CAApB;AACAf,GAAG,SAAH,IAAgBC,UAAUoB,MAAV,CAAiB,SAAjB,EAA4BL,OAA5B,CAAhB;AACAhB,GAAG,OAAH,IAAcC,UAAUoB,MAAV,CAAiB,OAAjB,EAA0BJ,KAA1B,CAAd;AACAjB,GAAG,MAAH,IAAaC,UAAUoB,MAAV,CAAiB,MAAjB,EAAyBH,IAAzB,CAAb;AACAlB,GAAG,SAAH,IAAgBC,UAAUoB,MAAV,CAAiB,SAAjB,EAA4BF,OAA5B,CAAhB;AACAnB,GAAG,MAAH,IAAaC,UAAUoB,MAAV,CAAiB,MAAjB,EAAyBD,IAAzB,CAAb;;AAEA;AACAE,OAAOC,IAAP,CAAYvB,EAAZ,EAAgBwB,OAAhB,CAAwB,qBAAa;AACnC,MAAIxB,GAAGyB,SAAH,EAAcC,SAAlB,EAA6B;AAC3BhC,WAAOkB,IAAP,CAAY,oBAAZ,EAAkCa,SAAlC;AACAzB,OAAGyB,SAAH,EAAcC,SAAd,CAAwB1B,EAAxB;AACD;AACF,CALD;;AAOAA,GAAGC,SAAH,GAAeA,SAAf;AACAD,GAAGR,SAAH,GAAeA,SAAf;;AAEA;AACAQ,GAAG2B,MAAH,GAAY,UAACC,KAAD,EAAQC,MAAR,EAAgBC,SAAhB,EAA2BC,SAA3B,EAAyC;AACnD,SAAOH,MACJI,OADI,CACI;AACPC,WAAOH;AADA,GADJ,EAIJzC,IAJI,CAIC,eAAO;AACX,QAAI6C,GAAJ,EAAS;AAAG;AACVxC,aAAOyC,KAAP,4BAAsCJ,SAAtC;AACA,aAAOG,IAAIE,MAAJ,CAAWP,MAAX,CAAP;AACD,KAHD,MAGO;AAAG;AACRnC,aAAOyC,KAAP,4BAAsCJ,SAAtC;AACA,aAAOH,MAAMS,MAAN,CAAaR,MAAb,CAAP;AACD;AACF,GAZI,EAaJhB,KAbI,CAaE,UAAUzE,KAAV,EAAiB;AACtBsD,WAAOtD,KAAP,CAAgB2F,SAAhB,oBAA0C3F,KAA1C;AACA,UAAMA,KAAN;AACD,GAhBI,CAAP;AAiBD,CAlBD;;AAoBA5D,OAAOC,OAAP,GAAiBuH,EAAjB,C;;;;;;;;;;;;AC5EA;AACO,IAAM7D,4CAAkB,iBAAxB;AACA,IAAME,wCAAgB,eAAtB;AACA,IAAMS,0CAAiB,gBAAvB;AACA,IAAMF,gDAAoB,mBAA1B;AACA,IAAMH,oDAAsB,qBAA5B;AACA,IAAMO,8CAAmB,kBAAzB;;AAEP;AACO,IAAMG,2CAAN;;AAEP;AACO,IAAME,oCAAc,aAApB;;AAEA,IAAMG,oEAA8B,6BAApC;AACA,IAAME,wEAAgC,+BAAtC;;AAEP;AACO,IAAMC,0CAAiB,gBAAvB;AACA,IAAMC,8DAA2B,0BAAjC;AACA,IAAMC,oDAAsB,qBAA5B,C;;;;;;;;;;;;ACpBA,IAAMyE,oCAAc,SAAdA,WAAc,CAACC,IAAD,EAAU;AACnC,MAAM5D,UAAU4D,KAAKC,WAAL,CAAiBD,KAAK5D,OAAL,CAAajC,EAA9B,CAAhB;AACA,MAAM+F,WAAW9D,QAAQ5B,GAAzB;AACA,SAAOwF,KAAKG,SAAL,CAAeD,QAAf,CAAP;AACD,CAJM;;AAMA,IAAME,4CAAkB,SAAlBA,eAAkB,CAACC,KAAD,EAAW;AACxC,SAAOA,MAAML,IAAb;AACD,CAFM,C;;;;;;ACNP,yC;;;;;;ACAA,+C;;;;;;;;;ACAA,IAAMM,QAAQ,mBAAApD,CAAQ,EAAR,CAAd;AACA,IAAMC,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;eACsC,mBAAAA,CAAQ,EAAR,C;4BAA9BqD,G;IAAOC,O,gBAAAA,O;IAASC,O,gBAAAA,O;;AACxB,IAAMC,aAAa,YAAYF,OAAZ,GAAsB,GAAtB,GAA4BC,OAA/C;;gBAC2D,mBAAAvD,CAAQ,EAAR,C;IAAnDyD,2B,aAAAA,2B;IAA6BC,iB,aAAAA,iB;;AAErC,IAAMC,wBAAwB,SAAxBA,qBAAwB,OAAWC,OAAX,EAAoBC,MAApB,EAA+B;AAAA,MAA5B7J,IAA4B,QAA5BA,IAA4B;;AAC3DiG,SAAOyC,KAAP,CAAa,gBAAb,EAA+B1I,IAA/B;AACA,MAAIA,KAAK8J,MAAT,EAAiB;AACf;AACA,QAAI9J,KAAK8J,MAAL,CAAYnH,KAAhB,EAAuB;AACrBsD,aAAOyC,KAAP,CAAa,oBAAb,EAAmC1I,KAAK8J,MAAL,CAAYnH,KAA/C;AACAkH,aAAO,IAAIrE,KAAJ,CAAUxF,KAAK8J,MAAL,CAAYnH,KAAtB,CAAP;AACA;AACD;AACDiH,YAAQ5J,KAAK8J,MAAb;AACA;AACD;AACD;AACAD,SAAOE,KAAKC,SAAL,CAAehK,IAAf,CAAP;AACD,CAdD;;AAgBAjB,OAAOC,OAAP,GAAiB;AACfiL,cADe,wBACDC,aADC,EACc;AAC3BjE,WAAOyC,KAAP,sCAAgDwB,cAAc/L,IAA9D;AACA,QAAMgM,cAAcC,KAAKC,GAAL,EAApB;AACA,WAAO,IAAIxE,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtCT,YACGkB,IADH,CACQd,UADR,EACoB;AAChBe,gBAAQ,SADQ;AAEhB9H,gBAAQyH;AAFQ,OADpB,EAKGtE,IALH,CAKQ,oBAAY;AAChB8D,0BAAkB,SAAlB,EAA6B,SAA7B,EAAwCD,4BAA4BS,aAA5B,CAAxC,EAAoFC,WAApF,EAAiGC,KAAKC,GAAL,EAAjG;AACAV,8BAAsBvE,QAAtB,EAAgCwE,OAAhC,EAAyCC,MAAzC;AACD,OARH,EASGzC,KATH,CASS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAXH;AAYD,KAbM,CAAP;AAcD,GAlBc;AAmBf6H,UAnBe,oBAmBLC,GAnBK,EAmBA;AACbxE,WAAOyC,KAAP,oCAA8C+B,GAA9C;AACA,QAAMN,cAAcC,KAAKC,GAAL,EAApB;AACA,WAAO,IAAIxE,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtCT,YACGkB,IADH,CACQd,UADR,EACoB;AAChBe,gBAAQ,KADQ;AAEhB9H,gBAAQ,EAAEgI,QAAF,EAAOC,SAAS,EAAhB;AAFQ,OADpB,EAKG9E,IALH,CAKQ,oBAAY;AAChB8D,0BAAkB,SAAlB,EAA6B,UAA7B,EAAyC,KAAzC,EAAgDS,WAAhD,EAA6DC,KAAKC,GAAL,EAA7D;AACAV,8BAAsBvE,QAAtB,EAAgCwE,OAAhC,EAAyCC,MAAzC;AACD,OARH,EASGzC,KATH,CASS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAXH;AAYD,KAbM,CAAP;AAcD,GApCc;AAqCfgI,cArCe,wBAqCDC,SArCC,EAqCU;AACvB3E,WAAOyC,KAAP,yCAAmDkC,SAAnD;AACA,QAAMT,cAAcC,KAAKC,GAAL,EAApB;AACA,WAAO,IAAIxE,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtCT,YACGkB,IADH,CACQd,UADR,EACoB;AAChBe,gBAAQ,YADQ;AAEhB9H,gBAAQ,EAAEtE,MAAMyM,SAAR;AAFQ,OADpB,EAKGhF,IALH,CAKQ,oBAAY;AAChB8D,0BAAkB,SAAlB,EAA6B,cAA7B,EAA6C,YAA7C,EAA2DS,WAA3D,EAAwEC,KAAKC,GAAL,EAAxE;AACAV,8BAAsBvE,QAAtB,EAAgCwE,OAAhC,EAAyCC,MAAzC;AACD,OARH,EASGzC,KATH,CASS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAXH;AAYD,KAbM,CAAP;AAcD,GAtDc;AAuDfkI,YAvDe,sBAuDHJ,GAvDG,EAuDE;AACfxE,WAAOyC,KAAP,oCAA8C+B,GAA9C;AACA,QAAMN,cAAcC,KAAKC,GAAL,EAApB;AACA,WAAO,IAAIxE,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtCT,YACGkB,IADH,CACQd,UADR,EACoB;AAChBe,gBAAQ,SADQ;AAEhB9H,gBAAQ,EAAEgI,QAAF;AAFQ,OADpB,EAKG7E,IALH,CAKQ,iBAAc;AAAA,YAAX5F,IAAW,SAAXA,IAAW;;AAClB0J,0BAAkB,SAAlB,EAA6B,YAA7B,EAA2C,SAA3C,EAAsDS,WAAtD,EAAmEC,KAAKC,GAAL,EAAnE;AACA,YAAIrK,KAAK8J,MAAL,CAAYW,GAAZ,EAAiB9H,KAArB,EAA4B;AAAG;AAC7BkH,iBAAO7J,KAAK8J,MAAL,CAAYW,GAAZ,EAAiB9H,KAAxB;AACD,SAFD,MAEO;AAAG;AACRiH,kBAAQ5J,KAAK8J,MAAL,CAAYW,GAAZ,CAAR;AACD;AACF,OAZH,EAaGrD,KAbH,CAaS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAfH;AAgBD,KAjBM,CAAP;AAkBD,GA5Ec;AA6EfmI,sBA7Ee,kCA6ES;AACtB7E,WAAOyC,KAAP,CAAa,uEAAb;AACA,QAAMyB,cAAcC,KAAKC,GAAL,EAApB;AACA,WAAO,IAAIxE,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtCT,YACGkB,IADH,CACQd,UADR,EACoB;AAChBe,gBAAQ;AADQ,OADpB,EAIG3E,IAJH,CAIQ,iBAAc;AAAA,YAAX5F,IAAW,SAAXA,IAAW;;AAClB0J,0BAAkB,SAAlB,EAA6B,sBAA7B,EAAqD,cAArD,EAAqES,WAArE,EAAkFC,KAAKC,GAAL,EAAlF;AACA,YAAIrK,KAAK8J,MAAT,EAAiB;AACfF,kBAAQ5J,KAAK8J,MAAL,CAAYiB,kBAApB;AACD,SAFD,MAEO;AACL,iBAAO,IAAIvF,KAAJ,CAAU,uFAAV,CAAP;AACD;AACF,OAXH,EAYG4B,KAZH,CAYS,iBAAS;AACdnB,eAAOtD,KAAP,CAAa,gBAAb,EAA+BA,KAA/B;AACAiH,gBAAQ,uBAAR;AACD,OAfH;AAgBD,KAjBM,CAAP;AAkBD,GAlGc;AAmGfoB,eAnGe,yBAmGA7M,IAnGA,EAmGM;AACnB8H,WAAOyC,KAAP,sCAAgDvK,IAAhD;AACA,QAAMgM,cAAcC,KAAKC,GAAL,EAApB;AACA,WAAO,IAAIxE,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtCT,YACGkB,IADH,CACQd,UADR,EACoB;AAChBe,gBAAQ,aADQ;AAEhB9H,gBAAQ;AACNwI,wBAAc9M,IADR;AAEN+M,kBAAc;AAFR;AAFQ,OADpB,EAQGtF,IARH,CAQQ,oBAAY;AAChB8D,0BAAkB,SAAlB,EAA6B,eAA7B,EAA8C,aAA9C,EAA6DS,WAA7D,EAA0EC,KAAKC,GAAL,EAA1E;AACAV,8BAAsBvE,QAAtB,EAAgCwE,OAAhC,EAAyCC,MAAzC;AACD,OAXH,EAYGzC,KAZH,CAYS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAdH;AAeD,KAhBM,CAAP;AAiBD;AAvHc,CAAjB,C;;;;;;;;;ACtBA,IAAMsD,SAAS,mBAAAD,CAAQ,CAAR,CAAf;AACA,IAAMmF,KAAK,mBAAAnF,CAAQ,EAAR,CAAX;;eAC+D,mBAAAA,CAAQ,CAAR,C;IAAzCpI,Q,YAAdD,S,CAAcC,Q;IAA0BwN,Q,YAAdnN,I,CAAQE,I;;AAE1C,SAASkN,sBAAT,CAAiCC,OAAjC,EAA0CC,EAA1C,EAA8CC,WAA9C,EAA2D;AACzD,SAAO;AACLC,mBAAmB,iBADd;AAELC,iBAAmB,eAFd;AAGLC,gBAAmBH,WAHd;AAILI,gBAAmBL,EAJd;AAKLM,uBAAmBP,QAAQ,YAAR;AALd,GAAP;AAOD;;AAED,SAASQ,8BAAT,CAAyCC,QAAzC,EAAmDC,QAAnD,EAA6DC,KAA7D,EAAoEC,SAApE,EAA+EC,OAA/E,EAAwF;AACtF,MAAMC,WAAWD,UAAUD,SAA3B;AACA,SAAO;AACLG,wBAAwBN,QADnB;AAELO,4BAAwBN,QAFnB;AAGLO,oBAAwBH,QAHnB;AAILI,qBAAwBP;AAJnB,GAAP;AAMD;;AAED,SAASQ,wBAAT,CAAmClB,EAAnC,EAAuC9I,MAAvC,EAA+C;AAC7C,MAAMiK,YAAYnB,GAAGoB,OAAH,CAAW,KAAX,EAAkB,GAAlB,CAAlB;AACA,MAAMC,UAAUzB,GAAGvN,QAAH,EAAa8O,SAAb,EAAwB,EAAEG,iBAAiB,KAAnB,EAA0BC,OAAO,IAAjC,EAAxB,CAAhB;AACAF,UAAQG,KAAR,CAActK,MAAd,EAAsB,UAAC4E,GAAD,EAAS;AAC7B,QAAIA,GAAJ,EAAS;AACPpB,aAAOtD,KAAP,CAAa,iCAAb,EAAgD0E,GAAhD;AACD;AACF,GAJD;AAKD;;AAED,SAAS2F,yBAAT,CAAoCN,SAApC,EAA+CjK,MAA/C,EAAuD;AACrD,MAAMmK,UAAUzB,GAAGvN,QAAH,EAAa8O,SAAb,EAAwB,EAAEG,iBAAiB,KAAnB,EAA0BC,OAAO,IAAjC,EAAxB,CAAhB;AACAF,UAAQK,MAAR,CAAexK,MAAf,EAAuB,UAAC4E,GAAD,EAAS;AAC9B,QAAIA,GAAJ,EAAS;AACPpB,aAAOtD,KAAP,CAAa,iCAAb,EAAgD0E,GAAhD;AACD;AACDpB,WAAOyC,KAAP;AACD,GALD;AAMD;;AAED3J,OAAOC,OAAP,GAAiB;AACfkO,kBADe,4BACG5B,OADH,EACYC,EADZ,EACgBC,WADhB,EAC6B;AAC1C,QAAM/I,SAAS4I,uBAAuBC,OAAvB,EAAgCC,EAAhC,EAAoCC,WAApC,CAAf;AACAiB,6BAAyBlB,EAAzB,EAA6B9I,MAA7B;AACD,GAJc;AAKfiH,mBALe,6BAKIqC,QALJ,EAKcC,QALd,EAKwBC,KALxB,EAK+BC,SAL/B,EAK0CC,OAL1C,EAKmD;AAChE,QAAM1J,SAASqJ,+BAA+BC,QAA/B,EAAyCC,QAAzC,EAAmDC,KAAnD,EAA0DC,SAA1D,EAAqEC,OAArE,CAAf;AACAa,8BAA0B5B,QAA1B,EAAoC3I,MAApC;AACD,GARc;AASfgH,6BATe,6CASoE;AAAA,QAAtC9I,WAAsC,QAApDsK,YAAoD;AAAA,QAAbpI,SAAa,QAAzBsK,UAAyB;;AACjF,WAAQxM,eAAekC,SAAf,GAA2B,0BAA3B,GAAwD,yBAAhE;AACD;AAXc,CAAjB,C;;;;;;AC5CA,kC;;;;;;;;;;;;QCIgBuK,qB,GAAAA,qB;;AAJhB;;IAAYxN,O;;;;AAEZ;;AAEO,SAASwN,qBAAT,CAAgCjP,IAAhC,EAAsCkD,OAAtC,EAA+CE,MAA/C,EAAuD;AAC5D,SAAO;AACLzB,UAAMF,QAAQyN,cADT;AAELrN,UAAM;AACJ7B,gBADI;AAEJkD,sBAFI;AAGJE;AAHI;AAFD,GAAP;AAQD,E;;;;;;;;;;;;;;;ACbD;;;;AACA;;;;AACA;;;;AACA;;;;;;;;;;;;IAEM+L,W;;;AACJ,uBAAahJ,KAAb,EAAoB;AAAA;;AAAA,0HACZA,KADY;;AAElB,UAAK6E,KAAL,GAAa;AACXoE,YAAa,EADF;AAEXC,aAAa,CAFF;AAGXC,mBAAa;AAHF,KAAb;AAKA,UAAKC,UAAL,GAAkB,MAAKA,UAAL,CAAgBC,IAAhB,OAAlB;AACA,UAAKC,gBAAL,GAAwB,MAAKA,gBAAL,CAAsBD,IAAtB,OAAxB;AACA,UAAKE,iBAAL,GAAyB,MAAKA,iBAAL,CAAuBF,IAAvB,OAAzB;AACA,UAAKG,eAAL,GAAuB,MAAKA,eAAL,CAAqBH,IAArB,OAAvB;AAVkB;AAWnB;;;;wCACoB;AACnB,WAAKD,UAAL;AACA,WAAKE,gBAAL;AACD;;;2CACuB;AACtB,WAAKE,eAAL;AACD;;;iCACa;AACZ,UAAMP,OAAO,EAAb;AACA,WAAK,IAAIQ,IAAI,CAAb,EAAgBA,KAAK,KAAKzJ,KAAL,CAAW0J,IAAhC,EAAsCD,GAAtC,EAA2C;AACzCR,aAAKU,IAAL,CAAU,EAACC,UAAU,KAAX,EAAV;AACD;AACD,WAAKC,QAAL,CAAc,EAAEZ,UAAF,EAAd;AACD;;;uCACmB;AAClB,WAAKa,cAAL,GAAsBC,YAAY,KAAKR,iBAAL,CAAuBF,IAAvB,CAA4B,IAA5B,CAAZ,EAA+C,GAA/C,CAAtB;AACD;;;wCACoB;AACnB,UAAIH,QAAQ,KAAKrE,KAAL,CAAWqE,KAAvB;AACA,UAAIC,cAAc,KAAKtE,KAAL,CAAWsE,WAA7B;AACA,UAAIF,OAAO,KAAKpE,KAAL,CAAWoE,IAAtB;AACA;AACA,UAAKC,QAAQ,CAAT,IAAgBA,QAAQ,KAAKlJ,KAAL,CAAW0J,IAAvC,EAA8C;AAC5CP,sBAAcA,cAAc,CAAC,CAA7B;AACAD,iBAASC,WAAT;AACD;AACD;AACA,UAAIA,cAAc,CAAlB,EAAqB;AACnBF,aAAKC,KAAL,EAAYU,QAAZ,GAAuB,IAAvB;AACD,OAFD,MAEO;AACLX,aAAKC,KAAL,EAAYU,QAAZ,GAAuB,KAAvB;AACD;AACD;AACAV,eAASC,WAAT;AACA;AACA,WAAKU,QAAL,CAAc;AACZZ,kBADY;AAEZE,gCAFY;AAGZD;AAHY,OAAd;AAKD;;;sCACkB;AACjBc,oBAAc,KAAKF,cAAnB;AACD;;;6BACS;AACR,aACE;AAAA;AAAA;AACG,aAAKjF,KAAL,CAAWoE,IAAX,CAAgBgB,GAAhB,CAAoB,UAACC,GAAD,EAAMhB,KAAN;AAAA,iBAAgBgB,IAAIN,QAAJ,GAAe,2DAAiB,KAAKV,KAAtB,GAAf,GAAiD,6DAAmB,KAAKA,KAAxB,GAAjE;AAAA,SAApB;AADH,OADF;AAKD;;;;EA/DuB,gBAAM1I,S;;AAgE/B;;AAEDwI,YAAYvI,SAAZ,GAAwB;AACtBiJ,QAAM,oBAAUS,MAAV,CAAiBC;AADD,CAAxB;;kBAIepB,W;;;;;;;;;;;;;;;AC3Ef;;;;AACA;;;;AACA;;;;;;;;;;;;IAEMqB,S;;;;;;;;;;;6BACM;AAAA,UACAhM,KADA,GACU,KAAK2B,KADf,CACA3B,KADA;;AAER,aACE;AAAA;AAAA;AACE,6DADF;AAEE;AAAA;AAAA,YAAK,WAAU,iBAAf;AACE;AAAA;AAAA;AAAIA;AAAJ;AADF;AAFF,OADF;AAQD;;;;EAXqB,gBAAMmC,S;;AAY7B;;AAED6J,UAAU5J,SAAV,GAAsB;AACpBpC,SAAO,oBAAUqC,MAAV,CAAiB0J;AADJ,CAAtB;;kBAIeC,S;;;;;;ACtBf,qC;;;;;;;;;ACAA,SAASC,WAAT,GAAwB;AAAA;;AACtB,OAAKxI,QAAL,GAAgB,SAAhB;AACA,OAAKC,QAAL,GAAgB,SAAhB;AACA,OAAKC,QAAL,GAAgB,SAAhB;AACA,OAAKuI,SAAL,GAAiB,gBAAoC;AAAA,QAAlCzI,QAAkC,QAAlCA,QAAkC;AAAA,QAAxBC,QAAwB,QAAxBA,QAAwB;AAAA,QAAdC,QAAc,QAAdA,QAAc;;AACnD,QAAIF,QAAJ,EAAc,MAAKA,QAAL,GAAgBA,QAAhB;AACd,QAAIC,QAAJ,EAAc,MAAKA,QAAL,GAAgBA,QAAhB;AACd,QAAIC,QAAJ,EAAc,MAAKA,QAAL,GAAgBA,QAAhB;AACf,GAJD;AAKD;;AAEDvH,OAAOC,OAAP,GAAiB,IAAI4P,WAAJ,EAAjB,C;;;;;;;;;ACXA,SAASE,WAAT,GAAwB;AAAA;;AACtB,OAAKC,YAAL,GAAyB,SAAzB;AACA,OAAKC,iBAAL,GAAyB,SAAzB;AACA,OAAKC,gBAAL,GAAyB,SAAzB;AACA,OAAKJ,SAAL,GAAiB,gBAAyD;AAAA,QAAvDE,YAAuD,QAAvDA,YAAuD;AAAA,QAAzCC,iBAAyC,QAAzCA,iBAAyC;AAAA,QAAtBC,gBAAsB,QAAtBA,gBAAsB;;AACxE,QAAIF,YAAJ,EAAkB,MAAKA,YAAL,GAAoBA,YAApB;AAClB,QAAIC,iBAAJ,EAAuB,MAAKA,iBAAL,GAAyBA,iBAAzB;AACvB,QAAIC,gBAAJ,EAAsB,MAAKA,gBAAL,GAAwBA,gBAAxB;AACvB,GAJD;AAKD;;AAEDlQ,OAAOC,OAAP,GAAiB,IAAI8P,WAAJ,EAAjB,C;;;;;;ACXA,2C;;;;;;;;;ACAA/P,OAAOC,OAAP,GAAiB;AACfkQ,iBAAe,uBAAUC,WAAV,EAAuB5N,MAAvB,EAA+B;AAC5C,QAAI6N,mBAAJ;AACA,QAAI/N,UAAUE,OAAO8N,SAAP,CAAiB,CAAjB,EAAoB,CAApB,CAAd,CAF4C,CAEN;AACtC,QAAIC,gBAAgB,CAApB;AACA;AACAF,iBAAaD,YAAYI,SAAZ,CAAsB,mBAAW;AAC5C,aAAOC,QAAQhM,OAAR,KAAoBjC,MAA3B;AACD,KAFY,CAAb;AAGA,QAAI6N,aAAa,CAAjB,EAAoB;AAClB,YAAM,IAAI5J,KAAJ,CAAU,mCAAV,CAAN;AACD;AACD;AACA,QAAIiK,kBAAkBN,YAAYO,KAAZ,CAAkB,CAAlB,EAAqBN,UAArB,CAAtB;AACA;AACA,WAAOK,gBAAgBE,MAAhB,GAAyB,CAAhC,EAAmC;AACjCL,uBAAiB,CAAjB;AACAjO,gBAAUE,OAAO8N,SAAP,CAAiB,CAAjB,EAAoBC,aAApB,CAAV;AACAG,wBAAkBA,gBAAgBG,MAAhB,CAAuB,mBAAW;AAClD,eAAQJ,QAAQhM,OAAR,IAAoBgM,QAAQhM,OAAR,CAAgB6L,SAAhB,CAA0B,CAA1B,EAA6BC,aAA7B,MAAgDjO,OAA5E;AACD,OAFiB,CAAlB;AAGD;AACD,WAAOA,OAAP;AACD;AAvBc,CAAjB,C;;;;;;;;;ACAA,IAAM4E,SAAS,mBAAAD,CAAQ,CAAR,CAAf;AACA,IAAM6J,KAAK,mBAAA7J,CAAQ,EAAR,CAAX;;eACkC,mBAAAA,CAAQ,CAAR,C;IAA1B/H,I,YAAAA,I;IAAM6R,M,YAAAA,M;IAAQxR,O,YAAAA,O;;AAEtBS,OAAOC,OAAP,GAAiB;AACf+Q,4BADe,4CACmE;AAAA,QAArD5R,IAAqD,QAArDA,IAAqD;AAAA,QAA/C6R,IAA+C,QAA/CA,IAA+C;AAAA,QAAzCC,OAAyC,QAAzCA,OAAyC;AAAA,QAAhC/R,KAAgC,QAAhCA,KAAgC;AAAA,QAAzBG,WAAyB,QAAzBA,WAAyB;AAAA,QAAZ6R,SAAY,QAAZA,SAAY;;AAChF;AACA,QAAI,CAAC/R,IAAL,EAAW;AACT,YAAM,IAAIqH,KAAJ,CAAU,gCAAV,CAAN;AACD;AACD,QAAM2K,wBAAwB,iBAAiBC,IAAjB,CAAsBjS,IAAtB,CAA9B;AACA,QAAIgS,qBAAJ,EAA2B;AACzB,YAAM,IAAI3K,KAAJ,CAAU,gHAAV,CAAN;AACD;AACD;AACAwK,WAAQA,SAAS,MAAjB;AACAC,cAAUA,WAAW,IAArB;AACA/R,YAAQA,SAAS,IAAjB;AACAG,kBAAcA,eAAe,IAA7B;AACA6R,gBAAYA,aAAa,IAAzB;AACA;AACA,WAAO;AACL/R,gBADK;AAEL6R,gBAFK;AAGLC,sBAHK;AAIL/R,kBAJK;AAKLG,8BALK;AAML6R;AANK,KAAP;AAQD,GAzBc;AA0BfG,6BA1Be,8CA0BiC;AAAA,QAAlBxQ,IAAkB,SAAlBA,IAAkB;AAAA,QAAZqQ,SAAY,SAAZA,SAAY;;AAC9C;AACA,QAAI,CAACrQ,IAAL,EAAW;AACT,YAAM,IAAI2F,KAAJ,CAAU,6CAAV,CAAN;AACD;AACD,QAAI,CAAC3F,KAAKyQ,IAAV,EAAgB;AACd,YAAM,IAAI9K,KAAJ,CAAU,oBAAV,CAAN;AACD;AACD,QAAI,CAAC3F,KAAKC,IAAV,EAAgB;AACd,YAAM,IAAI0F,KAAJ,CAAU,oBAAV,CAAN;AACD;AACD,QAAI,CAAC3F,KAAKmO,IAAV,EAAgB;AACd,YAAM,IAAIxI,KAAJ,CAAU,oBAAV,CAAN;AACD;AACD;AACA,QAAI,IAAI+K,IAAJ,CAAS1Q,KAAK1B,IAAd,CAAJ,EAAyB;AACvB,YAAM,IAAIqH,KAAJ,CAAU,8CAAV,CAAN;AACD;AACD;AACAzG,WAAOC,OAAP,CAAewR,uBAAf,CAAuC3Q,IAAvC;AACA;AACA,WAAO;AACL4Q,gBAAmB5Q,KAAK1B,IADnB;AAELuS,gBAAmB7Q,KAAKyQ,IAFnB;AAGLK,gBAAmB9Q,KAAKC,IAHnB;AAIL8Q,yBAAoBV,YAAYA,UAAU/R,IAAtB,GAA6B,IAJ5C;AAKL0S,yBAAoBX,YAAYA,UAAUI,IAAtB,GAA6B,IAL5C;AAMLQ,yBAAoBZ,YAAYA,UAAUpQ,IAAtB,GAA6B;AAN5C,KAAP;AAQD,GAvDc;AAwDf0Q,yBAxDe,mCAwDU3Q,IAxDV,EAwDgB;AAC7B;AACA,YAAQA,KAAKC,IAAb;AACE,WAAK,YAAL;AACA,WAAK,WAAL;AACA,WAAK,WAAL;AACE,YAAID,KAAKmO,IAAL,GAAY,QAAhB,EAA0B;AACxB/H,iBAAOyC,KAAP,CAAa,yDAAb;AACA,gBAAM,IAAIlD,KAAJ,CAAU,4CAAV,CAAN;AACD;AACD;AACF,WAAK,WAAL;AACE,YAAI3F,KAAKmO,IAAL,GAAY,QAAhB,EAA0B;AACxB/H,iBAAOyC,KAAP,CAAa,8CAAb;AACA,gBAAM,IAAIlD,KAAJ,CAAU,2CAAV,CAAN;AACD;AACD;AACF,WAAK,WAAL;AACE,YAAI3F,KAAKmO,IAAL,GAAY,QAAhB,EAA0B;AACxB/H,iBAAOyC,KAAP,CAAa,8CAAb;AACA,gBAAM,IAAIlD,KAAJ,CAAU,4CAAV,CAAN;AACD;AACD;AACF;AACES,eAAOyC,KAAP,CAAa,oDAAb;AACA,cAAM,IAAIlD,KAAJ,CAAU,SAAS3F,KAAKC,IAAd,GAAqB,mGAA/B,CAAN;AAvBJ;AAyBA,WAAOD,IAAP;AACD,GApFc;AAqFfkR,0BArFe,oCAqFWL,QArFX,EAqFqBvS,IArFrB,EAqF2BD,KArF3B,EAqFkCG,WArFlC,EAqF+C4R,OArF/C,EAqFwDD,IArFxD,EAqF8DE,SArF9D,EAqFyE;AACtFjK,WAAOyC,KAAP;AACA;AACA,QAAIxK,UAAU,IAAV,IAAkBA,MAAM8S,IAAN,OAAiB,EAAvC,EAA2C;AACzC9S,cAAQC,IAAR;AACD;AACD;AACA,QAAIE,gBAAgB,IAAhB,IAAwBA,YAAY2S,IAAZ,OAAuB,EAAnD,EAAuD;AACrD3S,oBAAc,EAAd;AACD;AACD;AACA,QAAI4R,YAAY,IAAZ,IAAoBA,QAAQe,IAAR,OAAmB,EAA3C,EAA+C;AAC7Cf,gBAAU,GAAV,CAD6C,CAC7B;AACjB;AACD;AACA,QAAM/F,gBAAgB;AACpB/L,gBADoB;AAEpB8S,iBAAWP,QAFS;AAGpBQ,WAAW,IAHS;AAIpBC,gBAAW;AACT9S,gCADS;AAETH,oBAFS;AAGTkT,gBAAUnT,KAAKC,KAHN;AAITmT,kBAAU,IAJD;AAKTpB,wBALS;AAMTD;AANS,OAJS;AAYpBsB,qBAAexB,OAAOyB;AAZF,KAAtB;AAcA;AACA,QAAIrB,SAAJ,EAAe;AACbhG,oBAAc,UAAd,EAA0B,WAA1B,IAAyCgG,SAAzC;AACD;AACD,WAAOhG,aAAP;AACD,GAvHc;AAwHfsH,8BAxHe,wCAwHeX,iBAxHf,EAwHkCjG,SAxHlC,EAwH6CqF,OAxH7C,EAwHsDD,IAxHtD,EAwH4D;AACzE,QAAI,CAACa,iBAAL,EAAwB;AACtB;AACD;AACD5K,WAAOyC,KAAP;AACA;AACA,WAAO;AACLvK,YAAcyM,SAAd,WADK;AAELqG,iBAAWJ,iBAFN;AAGLK,WAAW,IAHN;AAILC,gBAAW;AACTjT,eAAgB0M,SAAhB,eADS;AAETvM,0CAAgCuM,SAFvB;AAGTwG,gBAAanT,KAAKC,KAHT;AAITmT,kBAAa,IAJJ;AAKTpB,wBALS;AAMTD;AANS,OAJN;AAYLsB,qBAAexB,OAAOyB,gBAZjB;AAaLtG,oBAAe3M,QAAQG,gBAblB;AAcL0O,kBAAe7O,QAAQI;AAdlB,KAAP;AAgBD,GA9Ic;AA+If+S,qBA/Ie,+BA+IMf,QA/IN,EA+IgB;AAC7Bb,OAAG6B,MAAH,CAAUhB,QAAV,EAAoB,eAAO;AACzB,UAAIrJ,GAAJ,EAAS;AACPpB,eAAOtD,KAAP,oCAA8C+N,QAA9C;AACA,cAAMrJ,GAAN;AACD;AACDpB,aAAOyC,KAAP,2BAAqCgI,QAArC;AACD,KAND;AAOD,GAvJc;AAwJfiB,yBAxJe,mCAwJUC,QAxJV,EAwJoBC,SAxJpB,EAwJ+B;AAC5CD,aAASnB,QAAT,GAAoBoB,UAAUC,SAA9B;AACAF,aAASlB,QAAT,GAAoBmB,UAAUE,aAA9B;AACA,WAAOH,QAAP;AACD,GA5Jc;AA6JfI,gBA7Je,iCA6JkE;AAAA,QAA/D7T,IAA+D,SAA/DA,IAA+D;AAAA,QAAzDqF,OAAyD,SAAzDA,OAAyD;AAAA,QAAhDyO,QAAgD,SAAhDA,QAAgD;AAAA,QAAtCC,MAAsC,SAAtCA,MAAsC;AAAA,QAA9BC,OAA8B,SAA9BA,OAA8B;AAAA,QAArBnC,IAAqB,SAArBA,IAAqB;AAAA,QAAfoC,WAAe,SAAfA,WAAe;;AAC/E,WAAO;AACLjU,gBADK;AAELqF,sBAFK;AAGLyO,wBAHK;AAILC,oBAJK;AAKLC,sBALK;AAML1B,gBAAU,EANL;AAOLC,gBAAU,EAPL;AAQLC,gBAAUyB,WARL;AASLpC;AATK,KAAP;AAWD;AAzKc,CAAjB,C;;;;;;;;;;;ACJA,IAAM/J,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;AAEAjH,OAAOC,OAAP,GAAiB;AACfqT,uBAAqB,6BAAU7G,WAAV,EAAuBD,EAAvB,EAA2B5I,KAA3B,EAAkC2P,GAAlC,EAAuC;AAC1DrM,WAAOtD,KAAP,eAAyB6I,WAAzB,EAAwCzM,OAAOC,OAAP,CAAeuT,2BAAf,CAA2C5P,KAA3C,CAAxC;;AAD0D,gCAEhC5D,OAAOC,OAAP,CAAewT,2BAAf,CAA2C7P,KAA3C,CAFgC;AAAA;AAAA,QAEnDpC,MAFmD;AAAA,QAE3CC,OAF2C;;AAG1D8R,QACG/R,MADH,CACUA,MADV,EAEG8E,IAFH,CAEQtG,OAAOC,OAAP,CAAeyT,0BAAf,CAA0ClS,MAA1C,EAAkDC,OAAlD,CAFR;AAGD,GAPc;AAQfgS,+BAA6B,qCAAU7P,KAAV,EAAiB;AAC5C,QAAIpC,eAAJ;AAAA,QAAYC,gBAAZ;AACA;AACA,QAAImC,MAAM+P,IAAN,KAAe,cAAnB,EAAmC;AACjCnS,eAAS,GAAT;AACAC,gBAAU,qDAAV;AACA;AACD,KAJD,MAIO;AACLD,eAAS,GAAT;AACA,UAAIoC,MAAMnC,OAAV,EAAmB;AACjBA,kBAAUmC,MAAMnC,OAAhB;AACD,OAFD,MAEO;AACLA,kBAAUmC,KAAV;AACD;AACF;AACD,WAAO,CAACpC,MAAD,EAASC,OAAT,CAAP;AACD,GAxBc;AAyBf+R,+BAA6B,qCAAUlL,GAAV,EAAe;AAC1C,QAAIQ,OAAOC,IAAP,CAAYT,GAAZ,EAAiBsI,MAAjB,KAA4B,CAAhC,EAAmC;AACjC,UAAIgD,iBAAiB,EAArB;AACA9K,aAAO+K,mBAAP,CAA2BvL,GAA3B,EAAgCU,OAAhC,CAAwC,UAACzE,GAAD,EAAS;AAC/CqP,uBAAerP,GAAf,IAAsB+D,IAAI/D,GAAJ,CAAtB;AACD,OAFD;AAGA,aAAOqP,cAAP;AACD;AACD,WAAOtL,GAAP;AACD,GAlCc;AAmCfoL,4BAnCe,sCAmCalS,MAnCb,EAmCqBC,OAnCrB,EAmC8B;AAC3C,WAAO;AACLD,oBADK;AAELsS,eAAS,KAFJ;AAGLrS;AAHK,KAAP;AAKD;AAzCc,CAAjB,C;;;;;;;;;;;ACFA,IAAM+F,KAAK,mBAAAP,CAAQ,EAAR,CAAX;AACA,IAAMC,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;eACyC,mBAAAA,CAAQ,EAAR,C;IAAjC8M,4B,YAAAA,4B;;AAER,IAAMC,aAAa,YAAnB;AACA,IAAMC,WAAW,UAAjB;AACA,IAAMC,UAAU,SAAhB;;AAEAlU,OAAOC,OAAP,GAAiB;AACfkU,YADe,sBACHvS,WADG,EACUwS,cADV,EAC0BhV,IAD1B,EACgCqF,OADhC,EACyC;AACtD,QAAI7C,WAAJ,EAAiB;AACf,aAAO5B,OAAOC,OAAP,CAAeoU,mBAAf,CAAmCzS,WAAnC,EAAgDwS,cAAhD,EAAgEhV,IAAhE,CAAP;AACD,KAFD,MAEO;AACL,aAAOY,OAAOC,OAAP,CAAeqU,iBAAf,CAAiClV,IAAjC,EAAuCqF,OAAvC,CAAP;AACD;AACF,GAPc;AAQf6P,mBARe,6BAQIzI,SARJ,EAQepH,OARf,EAQwB;AACrCyC,WAAOyC,KAAP,wBAAkCkC,SAAlC,UAAgDpH,OAAhD;AACA,WAAO,IAAIqC,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtCtD,SAAGiB,KAAH,CAAS8L,cAAT,CAAwB1I,SAAxB,EAAmCpH,OAAnC,EACGoC,IADH,CACQ,uBAAe;AACnB,YAAI,CAAC2N,WAAL,EAAkB;AAChB3J,kBAAQoJ,QAAR;AACD;AACDpJ,gBAAQ2J,WAAR;AACD,OANH,EAOGnM,KAPH,CAOS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OATH;AAUD,KAXM,CAAP;AAYD,GAtBc;AAuBfyQ,qBAvBe,+BAuBMzS,WAvBN,EAuBmBwS,cAvBnB,EAuBmCvI,SAvBnC,EAuB8C;AAC3D3E,WAAOyC,KAAP,0BAAoC/H,WAApC,UAAoDwS,cAApD,UAAuEvI,SAAvE;AACA,WAAO,IAAI/E,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtCtD,SAAGe,WAAH,CAAekM,gBAAf,CAAgC7S,WAAhC,EAA6CwS,cAA7C,EAA6D;AAA7D,OACGvN,IADH,CACQ,yBAAiB;AACrB,YAAI,CAAC6N,aAAL,EAAoB;AAClB,iBAAO,CAAC,IAAD,EAAO,IAAP,CAAP;AACD;AACD,eAAO5N,QAAQC,GAAR,CAAY,CAAC2N,aAAD,EAAgBlN,GAAGiB,KAAH,CAASkM,yBAAT,CAAmCD,aAAnC,EAAkD7I,SAAlD,CAAhB,CAAZ,CAAP,CAJqB,CAI+E;AACrG,OANH,EAOGhF,IAPH,CAOQ,gBAAkC;AAAA;AAAA,YAAhC6N,aAAgC;AAAA,YAAjBF,WAAiB;;AACtC,YAAI,CAACE,aAAL,EAAoB;AAClB,iBAAO7J,QAAQmJ,UAAR,CAAP;AACD;AACD,YAAI,CAACQ,WAAL,EAAkB;AAChB,iBAAO3J,QAAQoJ,QAAR,CAAP;AACD;AACDpJ,gBAAQ2J,WAAR;AACD,OAfH,EAgBGnM,KAhBH,CAgBS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAlBH;AAmBD,KApBM,CAAP;AAqBD,GA9Cc;AA+CfgR,gBA/Ce,0BA+CChT,WA/CD,EA+CcwS,cA/Cd,EA+C8BrP,IA/C9B,EA+CoC;AACjD,WAAO,IAAI+B,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC;AACAtD,SAAGe,WAAH,CAAekM,gBAAf,CAAgC7S,WAAhC,EAA6CwS,cAA7C,EACGvN,IADH,CACQ,8BAAsB;AAC1B,YAAI,CAACgO,kBAAL,EAAyB;AACvB,iBAAO,CAAC,IAAD,EAAO,IAAP,EAAa,IAAb,CAAP;AACD;AACD;AACA,eAAO/N,QAAQC,GAAR,CAAY,CAAC8N,kBAAD,EAAqBrN,GAAGe,WAAH,CAAeuM,kCAAf,CAAkDD,kBAAlD,EAAsEjT,WAAtE,CAArB,CAAZ,CAAP;AACD,OAPH,EAQGiF,IARH,CAQQ,iBAA+C;AAAA;AAAA,YAA7CgO,kBAA6C;AAAA,YAAzBE,mBAAyB;;AACnD,YAAI,CAACF,kBAAL,EAAyB;AACvB,iBAAOhK,QAAQmJ,UAAR,CAAP;AACD;AACD;AACAnJ,gBAAQ;AACNjJ,kCADM;AAENiT,gDAFM;AAGNE;AAHM,SAAR;AAKD,OAlBH,EAmBG1M,KAnBH,CAmBS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OArBH;AAsBD,KAxBM,CAAP;AAyBD,GAzEc;AA0EfoR,kBA1Ee,4BA0EGpT,WA1EH,EA0EgBwS,cA1EhB,EA0EgCrP,IA1EhC,EA0EsC;AACnD,WAAO,IAAI+B,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC;AACAtD,SAAGe,WAAH,CAAekM,gBAAf,CAAgC7S,WAAhC,EAA6CwS,cAA7C,EACGvN,IADH,CACQ,8BAAsB;AAC1B,YAAI,CAACgO,kBAAL,EAAyB;AACvB,iBAAO,CAAC,IAAD,EAAO,IAAP,EAAa,IAAb,CAAP;AACD;AACD;AACA,eAAO/N,QAAQC,GAAR,CAAY,CAAC8N,kBAAD,EAAqBrN,GAAGiB,KAAH,CAASwM,mBAAT,CAA6BJ,kBAA7B,CAArB,CAAZ,CAAP;AACD,OAPH,EAQGhO,IARH,CAQQ,iBAA8C;AAAA;AAAA,YAA5CgO,kBAA4C;AAAA,YAAxBK,kBAAwB;;AAClD,YAAI,CAACL,kBAAL,EAAyB;AACvB,iBAAOhK,QAAQmJ,UAAR,CAAP;AACD;AACD;AACA,YAAImB,2BAA2BpB,6BAA6BnS,WAA7B,EAA0CiT,kBAA1C,EAA8DK,kBAA9D,EAAkFnQ,IAAlF,CAA/B;AACA;AACA8F,gBAAQsK,wBAAR;AACD,OAhBH,EAiBG9M,KAjBH,CAiBS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAnBH;AAoBD,KAtBM,CAAP;AAuBD,GAlGc;AAmGfwR,oBAnGe,8BAmGK3Q,OAnGL,EAmGcrF,IAnGd,EAmGoB;AACjC,WAAOoI,GAAGkB,IAAH,CAAQc,OAAR,CAAgB,EAACC,OAAO,EAAChF,gBAAD,EAAUrF,UAAV,EAAR,EAAhB,EACJyH,IADI,CACC,gBAAQ;AACZ,UAAI,CAAC/F,IAAL,EAAW;AACT,eAAOoT,OAAP;AACD;AACD,aAAOpT,KAAKuU,UAAZ;AACD,KANI,CAAP;AAOD;AA3Gc,CAAjB,C;;;;;;;;;ACRA;;;;AACA;;AACA;;AACA;;;;AACA;;AACA;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;AAEArV,OAAOC,OAAP,GAAiB,UAACqV,GAAD,EAAM/B,GAAN,EAAc;AAC7B,MAAIgC,UAAU,EAAd;;AAEA;AACA,MAAMC,QAAQ,2CAAd;;AAEA;AACA,MAAMC,OAAO,4BACX;AAAA;AAAA,MAAU,OAAOD,KAAjB;AACE;AAAA;AAAA,QAAc,UAAUF,IAAI5O,GAA5B,EAAiC,SAAS6O,OAA1C;AACE;AAAA;AAAA;AACE;AADF;AADF;AADF,GADW,CAAb;;AAUA;AACA,MAAMG,SAAS,sBAAOC,YAAP,EAAf;;AAEA;AACA,MAAIJ,QAAQ7O,GAAZ,EAAiB;AACf;AACA,WAAO6M,IAAIqC,QAAJ,CAAa,GAAb,EAAkBL,QAAQ7O,GAA1B,CAAP;AACD,GAHD,MAGO,CAEN;AADC;;;AAGF;AACA,MAAMmP,iBAAiBL,MAAMM,QAAN,EAAvB;;AAEA;AACAvC,MAAIwC,IAAJ,CAAS,8BAAeL,MAAf,EAAuBD,IAAvB,EAA6BI,cAA7B,CAAT;AACD,CAjCD,C;;;;;;ACXA,6C;;;;;;;;;;;;;ACAA;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;kBAEe,4BAAgB;AAC7BvU,4BAD6B;AAE7B/B,4BAF6B;AAG7BwK,sBAH6B;AAI7B7K;AAJ6B,CAAhB,C;;;;;;;;;;;;ACNR,IAAM8B,wCAAgB,eAAtB;AACA,IAAME,kCAAa,YAAnB;AACA,IAAME,4CAAkB,iBAAxB;AACA,IAAMC,sCAAe,cAArB;AACA,IAAME,0DAAyB,wBAA/B;AACA,IAAMG,wDAAwB,uBAA9B;AACA,IAAMC,sCAAe,cAArB;AACA,IAAME,4DAA0B,yBAAhC;AACA,IAAME,0DAAyB,wBAA/B;AACA,IAAMC,wCAAgB,eAAtB;AACA,IAAME,wCAAgB,eAAtB,C;;;;;;;;;;;;ACVA,IAAM8T,wBAAQ,UAAd;AACA,IAAMC,0BAAS,KAAf,C;;;;;;;;;;;;ACDA,IAAM3H,0CAAiB,gBAAvB,C;;;;;;;;;;;;ACAA,IAAM4H,oCAAc,aAApB;AACA,IAAMC,oCAAc,aAApB;AACA,IAAMC,wBAAQ,OAAd;AACA,IAAMC,gCAAY,WAAlB,C;;;;;;;;;;;;;;;ACHP;;;;AACA;;;;AACA;;;;;;;;;;AACA,IAAMC,SAAS,mBAAArP,CAAQ,CAAR,CAAf;AACA,IAAMsP,eAAeD,OAAO1X,SAAP,CAAiBC,QAAtC;;AAEA,kBAAgB2X,UAAhB,CAA2BD,YAA3B;;IAEME,U;;;;;;;;;;;wCACiB;AACnB,WAAKC,YAAL,CAAkB,KAAKnR,KAAL,CAAWtD,OAAX,CAAmB0U,QAArC;AACA,WAAKpR,KAAL,CAAWtD,OAAX,CAAmB2U,MAAnB,CAA0B,KAAKF,YAA/B;AACD;;;iCAEaC,Q,EAAU;AACtB,wBAAgBE,GAAhB,CAAoB,EAAE9R,MAAM4R,SAASG,QAAjB,EAApB;AACA,wBAAgBC,QAAhB,CAAyBJ,SAASG,QAAlC;AACD;;;6BAES;AACR,aAAO,KAAKvR,KAAL,CAAWyR,QAAlB;AACD;;;;EAbsB,gBAAMjR,S;;kBAgBhB,gCAAW0Q,UAAX,C;;;;;;;;;;;;;ACxBf;;;;AACA;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;AAEA,IAAMQ,MAAM,SAANA,GAAM,GAAM;AAChB,SACE;AAAA;AAAA;AACE,2DAAO,WAAP,EAAa,MAAK,GAAlB,EAAsB,6BAAtB,GADF;AAEE,2DAAO,WAAP,EAAa,MAAK,QAAlB,EAA2B,8BAA3B,GAFF;AAGE,2DAAO,WAAP,EAAa,MAAK,QAAlB,EAA2B,8BAA3B,GAHF;AAIE,2DAAO,WAAP,EAAa,MAAK,qBAAlB,EAAwC,6BAAxC,GAJF;AAKE,2DAAO,WAAP,EAAa,MAAK,SAAlB,EAA4B,6BAA5B,GALF;AAME,2DAAO,mCAAP;AANF,GADF;AAUD,CAXD;;kBAaeA,G;;;;;;;;;;;;;ACrBf;;AACA;;AACA;;;;;;AAEA,IAAM9U,kBAAkB,SAAlBA,eAAkB,OAAiB;AAAA,MAAd5C,OAAc,QAAdA,OAAc;;AACvC,SAAO;AACLuB,UAAWvB,QAAQuB,IADd;AAELqQ,eAAW5R,QAAQ4R,SAFd;AAGL+F,eAAW3X,QAAQqE,KAAR,CAAc9C;AAHpB,GAAP;AAKD,CAND;;AAQA,IAAM2B,qBAAqB,SAArBA,kBAAqB,WAAY;AACrC,SAAO;AACLvC,gBAAY,oBAACY,IAAD,EAAU;AACpB6B,eAAS,yBAAW7B,IAAX,CAAT;AACD,KAHI;AAILqW,kBAAc,sBAAChW,KAAD,EAAW;AACvBwB,eAAS,yBAAT;AACAA,eAAS,0BAAY,MAAZ,EAAoBxB,KAApB,CAAT;AACD;AAPI,GAAP;AASD,CAVD;;kBAYe,yBAAQgB,eAAR,EAAyBM,kBAAzB,iB;;;;;;;;;;;;;ACxBf;;AACA;;AACA;;;;AACA;;;;AAEA,IAAMA,qBAAqB,SAArBA,kBAAqB,WAAY;AACrC,SAAO;AACLC,oBAAgB,wBAACtD,IAAD,EAAOkD,OAAP,EAAgBE,MAAhB,EAA2B;AACzCG,eAAS,oCAAsBvD,IAAtB,EAA4BkD,OAA5B,EAAqCE,MAArC,CAAT;AACAG,eAAS,oCAAsBvD,IAAtB,CAAT;AACD;AAJI,GAAP;AAMD,CAPD;;kBASe,yBAAQ,IAAR,EAAcqD,kBAAd,iB;;;;;;;;;;;;;ACdf;;AACA;;AACA;;;;AACA;;;;AAEA,IAAMA,qBAAqB,SAArBA,kBAAqB,WAAY;AACrC,SAAO;AACLC,oBAAgB,wBAACtD,IAAD,EAAOkD,OAAP,EAAgBE,MAAhB,EAA2B;AACzCG,eAAS,oCAAsBvD,IAAtB,EAA4BkD,OAA5B,EAAqCE,MAArC,CAAT;AACAG,eAAS,oCAAsBvD,IAAtB,CAAT;AACD;AAJI,GAAP;AAMD,CAPD;;kBASe,yBAAQ,IAAR,EAAcqD,kBAAd,iB;;;;;;;;;;;;ACdR,IAAM2U,4BAAU,SAAhB;AACA,IAAMC,kCAAa,YAAnB;AACA,IAAMC,wCAAgB,eAAtB,C;;;;;;;;;;;;;ACFP;;AACA;;;;AACA;;AACA;;;;AAEA,IAAMnV,kBAAkB,SAAlBA,eAAkB,OAAc;AAAA,MAAX4H,IAAW,QAAXA,IAAW;;AACpC;AACA,MAAMnG,QAASmG,KAAKwN,YAAL,CAAkB3T,KAAjC;AACA,MAAMpC,SAASuI,KAAKwN,YAAL,CAAkB/V,MAAjC;AACA;AACA,MAAMiE,QAAQ,wBAAYsE,IAAZ,CAAd;AACA;AACA,SAAO;AACLnG,gBADK;AAELpC,kBAFK;AAGLiE;AAHK,GAAP;AAKD,CAZD;;AAcA,IAAMhD,qBAAqB,SAArBA,kBAAqB,WAAY;AACrC,SAAO;AACL+U,mBAAe,uBAACpY,IAAD,EAAOqF,OAAP,EAAmB;AAChC9B,eAAS,yBAAcvD,IAAd,EAAoBqF,OAApB,CAAT;AACD;AAHI,GAAP;AAKD,CAND;;kBAQe,yBAAQtC,eAAR,EAAyBM,kBAAzB,iB;;;;;;;;;AC3BfzC,OAAOC,OAAP,GAAiB,UAACyV,MAAD,EAASD,IAAT,EAAeI,cAAf,EAAkC;AACjD;AACA,0YAQYH,OAAOvW,KAAP,CAAasY,QAAb,EARZ,sBASY/B,OAAOgC,IAAP,CAAYD,QAAZ,EATZ,sBAUY/B,OAAOiC,IAAP,CAAYF,QAAZ,EAVZ,0mBAoBiFhC,IApBjF,uGAuB6CzK,KAAKC,SAAL,CAAe4K,cAAf,EAA+BjI,OAA/B,CAAuC,IAAvC,EAA6C,KAA7C,CAvB7C;AA6BD,CA/BD,C;;;;;;;;;;;;;;;ACAA,2C;;;;;;ACAA,yC;;;;;;;;;ACAA;AACA,IAAMgK,UAAU,mBAAA3Q,CAAQ,EAAR,CAAhB;AACA,IAAM4Q,aAAa,mBAAA5Q,CAAQ,EAAR,CAAnB;AACA,IAAM6Q,oBAAoB,mBAAA7Q,CAAQ,EAAR,CAA1B;AACA,IAAM8Q,aAAa,mBAAA9Q,CAAQ,EAAR,CAAnB;AACA,IAAMyO,SAAS,mBAAAzO,CAAQ,EAAR,CAAf;AACA,IAAM+Q,WAAW,mBAAA/Q,CAAQ,EAAR,CAAjB;;eAC8E,mBAAAA,CAAQ,EAAR,C;IAAtEgR,qB,YAAAA,qB;IAAuBC,mB,YAAAA,mB;IAAqBC,qB,YAAAA,qB;;AACpD,IAAMC,gBAAgB,mBAAAnR,CAAQ,EAAR,CAAtB;AACA,IAAMoR,OAAO,mBAAApR,CAAQ,EAAR,CAAb;AACA;AACA,IAAMC,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;AAEA,SAASqR,YAAT,OAAiE;AAAA;;AAAA,MAAxCC,WAAwC,QAAxCA,WAAwC;AAAA,MAA3BC,UAA2B,QAA3BA,UAA2B;AAAA,MAAfC,WAAe,QAAfA,WAAe;;AAC/D,OAAKC,IAAL,GAAY,IAAZ;AACA,OAAKC,KAAL,GAAa,UAACC,SAAD,EAAe;AAC1BzR,YAAQC,GAAR,CAAYwR,SAAZ;AACD,GAFD;AAGA,OAAKC,KAAL,GAAa,YAAM;AACjB,UAAKC,oBAAL;AACA,UAAKC,gBAAL;AACA,UAAKC,YAAL;AACA,UAAKC,eAAL;AACA,UAAKC,WAAL;AACD,GAND;AAOA,OAAKJ,oBAAL,GAA4B,YAAM;AAChC,QAAMK,iBAAiB,mBAAAlS,CAAQ,EAAR,CAAvB;AACAkS,mBAAerJ,SAAf,CAAyByI,WAAzB;AACA,QAAMa,iBAAiB,mBAAAnS,CAAQ,EAAR,CAAvB;AACAmS,mBAAetJ,SAAf,CAAyB2I,WAAzB;AACA;AACAtR,YAAQC,GAAR,CAAY,yBAAZ;AACAH,IAAA,mBAAAA,CAAQ,EAAR,EAAuCkS,cAAvC;AACAlS,IAAA,mBAAAA,CAAQ,EAAR,EAAuCmS,cAAvC;AACD,GATD;AAUA,OAAKL,gBAAL,GAAwB,YAAM;AAC5B9R,IAAA,mBAAAA,CAAQ,EAAR,EAAwCC,MAAxC;AACAD,IAAA,mBAAAA,CAAQ,EAAR,EAAuCC,MAAvC;AACD,GAHD;AAIA,OAAK8R,YAAL,GAAoB,YAAM;AACxB,QAAMK,MAAMzB,SAAZ,CADwB,CACD;;AAEvB;AACAyB,QAAIC,MAAJ,CAAW,aAAX;;AAEA;AACAD,QAAIE,GAAJ,CAAQ7D,QAAR,EAPwB,CAOL;AACnB2D,QAAIE,GAAJ,CAAQ3B,QAAQ4B,MAAR,CAAkBC,SAAlB,aAAR,EARwB,CAQwB;AAChDJ,QAAIE,GAAJ,CAAQ1B,WAAWvR,IAAX,EAAR,EATwB,CASI;AAC5B+S,QAAIE,GAAJ,CAAQ1B,WAAW6B,UAAX,CAAsB,EAAEC,UAAU,IAAZ,EAAtB,CAAR,EAVwB,CAU4B;AACpDN,QAAIE,GAAJ,CAAQ,UAACjE,GAAD,EAAM/B,GAAN,EAAWqG,IAAX,EAAoB;AAAG;AAC7B1S,aAAO2S,OAAP,iBAA6BvE,IAAI7I,WAAjC,cAAqD6I,IAAI9I,EAAzD;AACAoN;AACD,KAHD;;AAKA;AACA5B,aAAS8B,aAAT,CAAuB5B,mBAAvB;AACAF,aAAS+B,eAAT,CAAyB5B,qBAAzB;AACA,QAAM6B,sBAAsB,mBAAA/S,CAAQ,EAAR,CAA5B;AACA,QAAMgT,qBAAqB,mBAAAhT,CAAQ,EAAR,CAA3B;AACA+Q,aAASuB,GAAT,CAAa,cAAb,EAA6BS,mBAA7B;AACAhC,aAASuB,GAAT,CAAa,aAAb,EAA4BU,kBAA5B;AACA;AACAZ,QAAIE,GAAJ,CAAQnB,cAAc;AACpBhZ,YAAQ,SADY;AAEpB2J,YAAQ,CAACyP,WAAW1Z,OAAX,CAAmBC,UAApB,CAFY;AAGpBmb,cAAQ,KAAK,EAAL,GAAU,EAAV,GAAe,IAHH,CAGS;AAHT,KAAd,CAAR;AAKAb,QAAIE,GAAJ,CAAQvB,SAASxB,UAAT,EAAR;AACA6C,QAAIE,GAAJ,CAAQvB,SAASlZ,OAAT,EAAR;;AAEA;AACA,QAAMqb,MAAMrC,kBAAkBjO,MAAlB,CAAyB;AACnCuQ,qBAAe,OADoB;AAEnCC,kBAAetC;AAFoB,KAAzB,CAAZ;AAIAsB,QAAIiB,MAAJ,CAAW,YAAX,EAAyBH,IAAIG,MAA7B;AACAjB,QAAIxC,GAAJ,CAAQ,aAAR,EAAuB,YAAvB;;AAEA;AACAwC,QAAIE,GAAJ,CAAQtB,qBAAR,EAzCwB,CAyCS;;AAEjC;AACAhR,IAAA,mBAAAA,CAAQ,EAAR,EAAmCoS,GAAnC;AACApS,IAAA,mBAAAA,CAAQ,EAAR,EAAkCoS,GAAlC;AACApS,IAAA,mBAAAA,CAAQ,EAAR,EAAmCoS,GAAnC;AACApS,IAAA,mBAAAA,CAAQ,GAAR,EAAoCoS,GAApC;AACApS,IAAA,mBAAAA,CAAQ,GAAR,EAAuCoS,GAAvC;;AAEA,UAAKA,GAAL,GAAWA,GAAX;AACD,GAnDD;AAoDA,OAAKJ,eAAL,GAAuB,YAAM;AAC3B,UAAKsB,MAAL,GAAclC,KAAKmC,MAAL,CAAY,MAAKnB,GAAjB,CAAd;AACD,GAFD;AAGA,OAAKH,WAAL,GAAmB,YAAM;AACvB,QAAM1R,KAAK,mBAAAP,CAAQ,EAAR,CAAX;AACA;AACAO,OAAGC,SAAH,CAAagT,IAAb;AACE;AADF,KAEG5T,IAFH,CAEQ,YAAM;AACV,YAAK0T,MAAL,CAAY3D,MAAZ,CAAmB,MAAK8B,IAAxB,EAA8B,YAAM;AAClCxR,eAAOkB,IAAP,kCAA2C,MAAKsQ,IAAhD;AACD,OAFD;AAGD,KANH,EAOGrQ,KAPH,CAOS,UAACzE,KAAD,EAAW;AAChBsD,aAAOtD,KAAP,mBAA+BA,KAA/B;AACD,KATH;AAUD,GAbD;AAcD;;AAED5D,OAAOC,OAAP,GAAiBqY,YAAjB,C;;;;;;AC9GA,oC;;;;;;ACAA,wC;;;;;;ACAA,+C;;;;;;ACAA,uC;;;;;;ACAA,mC;;;;;;;;;ACAA,IAAMpR,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;AAEAjH,OAAOC,OAAP,GAAiB;AACfgY,uBADe,iCACQ3C,GADR,EACa/B,GADb,EACkBqG,IADlB,EACwB;AACrC,QAAItE,IAAIoF,IAAR,EAAc;AACZxT,aAAOyC,KAAP,CAAa,4BAAb;AACA4J,UAAIoH,MAAJ,CAAWD,IAAX,GAAkB;AAChBxW,YAAgBoR,IAAIoF,IAAJ,CAASxW,EADT;AAEhB0W,kBAAgBtF,IAAIoF,IAAJ,CAASE,QAFT;AAGhBhZ,qBAAgB0T,IAAIoF,IAAJ,CAAS9Y,WAHT;AAIhBwS,wBAAgBkB,IAAIoF,IAAJ,CAAStG,cAJT;AAKhByG,wBAAgBvF,IAAIoF,IAAJ,CAASG;AALT,OAAlB;AAOD;AACDjB;AACD,GAbc;AAcf1B,qBAde,+BAcMwC,IAdN,EAcYI,IAdZ,EAckB;AAAG;AAClC5T,WAAOyC,KAAP,CAAa,kBAAb;AACAmR,SAAK,IAAL,EAAWJ,IAAX;AACD,GAjBc;AAkBfvC,uBAlBe,iCAkBQuC,IAlBR,EAkBcI,IAlBd,EAkBoB;AAAG;AACpC5T,WAAOyC,KAAP,CAAa,oBAAb;AACAmR,SAAK,IAAL,EAAWJ,IAAX;AACD;AArBc,CAAjB,C;;;;;;ACFA,2C;;;;;;ACAA,iC;;;;;;;;;ACAA,IAAMxT,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;AAEAjH,OAAOC,OAAP,GAAiB,UAACqW,MAAD,EAAY;AAC3B;AACA,OAAK,IAAIyE,iBAAT,IAA8BzE,MAA9B,EAAsC;AACpC,QAAIA,OAAO0E,cAAP,CAAsBD,iBAAtB,CAAJ,EAA8C;AAC5C;AACA,UAAME,kBAAkB3E,OAAOyE,iBAAP,CAAxB;AACA,WAAK,IAAIG,YAAT,IAAyBD,eAAzB,EAA0C;AACxC,YAAIA,gBAAgBD,cAAhB,CAA+BE,YAA/B,CAAJ,EAAkD;AAChD;AACAhU,iBAAOyC,KAAP,oBAA8BoR,iBAA9B,SAAmDG,YAAnD,aAAuED,gBAAgBC,YAAhB,CAAvE;AACD;AACF;AACF;AACF;AACF,CAdD,C;;;;;;;;;eCFqB,mBAAAjU,CAAQ,EAAR,C;IAAbkU,Q,YAAAA,Q;;AAERnb,OAAOC,OAAP,GAAiB,UAACmb,OAAD,EAAa;AAC5B;AACAA,UAAQtL,SAAR,CAAkB;AAChBuL,gBAAY,CACV,IAAKD,QAAQC,UAAR,CAAmBC,OAAxB,CAAiC;AAC/BC,aAAiCJ,QADF;AAE/BK,iBAAiC,KAFF;AAG/BC,gBAAiC,IAHF;AAI/BC,mBAAiC,IAJF;AAK/BC,wBAAiC,IALF;AAM/BC,uCAAiC;AANF,KAAjC,CADU;AADI,GAAlB;AAYA;AACAR,UAAQxX,KAAR,CAAc,SAAd;AACAwX,UAAQS,IAAR,CAAa,SAAb;AACAT,UAAQhT,IAAR,CAAa,SAAb;AACAgT,UAAQvB,OAAR,CAAgB,SAAhB;AACAuB,UAAQzR,KAAR,CAAc,SAAd;AACAyR,UAAQU,KAAR,CAAc,SAAd;AACD,CArBD,C;;;;;;;;;ACFA,IAAMC,eAAe;AACnBZ,YAAU,OADS,CACC;AADD,CAArB;;AAIAnb,OAAOC,OAAP,GAAiB8b,YAAjB,C;;;;;;;;;ACJA,IAAMC,sBAAsB,mBAAA/U,CAAQ,EAAR,EAAiCgV,YAA7D;AACA,IAAMxD,cAAc,mBAAAxR,CAAQ,EAAR,CAApB;;AAEAjH,OAAOC,OAAP,GAAiB,UAACmb,OAAD,EAAa;AAAA,MACrBpL,YADqB,GACgCyI,WADhC,CACrBzI,YADqB;AAAA,MACPC,iBADO,GACgCwI,WADhC,CACPxI,iBADO;AAAA,MACYC,gBADZ,GACgCuI,WADhC,CACYvI,gBADZ;;AAE5B,MAAIF,YAAJ,EAAkB;AAChB;AACA,QAAIC,iBAAJ,EAAuB;AACrBmL,cAAQc,GAAR,CAAYF,mBAAZ,EAAiC;AAC/B5c,cAAY,wBADmB;AAE/Bmc,eAAY,MAFmB;AAG/BY,oBAAYnM,YAHmB;AAI/B1O,iBAAY2O,iBAJmB;AAK/B3I,kBAAY,SALmB;AAM/B8U,mBAAY;AANmB,OAAjC;AAQD;AACD,QAAIlM,gBAAJ,EAAsB;AACpBkL,cAAQc,GAAR,CAAYF,mBAAZ,EAAiC;AAC/B5c,cAAY,sBADmB;AAE/Bmc,eAAY,MAFmB;AAG/BY,oBAAYnM,YAHmB;AAI/B1O,iBAAY4O,gBAJmB;AAK/B5I,kBAAY,SALmB;AAM/B8U,mBAAY;AANmB,OAAjC;AAQD;AACD;AACAhB,YAAQxX,KAAR,CAAc,kCAAd;AACAwX,YAAQhT,IAAR,CAAa,iCAAb;AACD,GAzBD,MAyBO;AACLgT,YAAQS,IAAR,CAAa,2EAAb;AACD;AACF,CA9BD,C;;;;;;ACHA,kD;;;;;;;;;;;ACAA,IAAMQ,wBAAwB,mBAAApV,CAAQ,EAAR,EAA0BqV,QAAxD;AACA,IAAMC,UAAU,mBAAAtV,CAAQ,EAAR,CAAhB;AACA,IAAMC,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;AAEAjH,OAAOC,OAAP,GAAiB,UAACuH,EAAD,EAAQ;AACvB,SAAO,IAAI6U,qBAAJ,CACL;AACEG,mBAAe,UADjB;AAEEC,mBAAe;AAFjB,GADK,EAKL,UAACnV,QAAD,EAAWC,QAAX,EAAqBuT,IAArB,EAA8B;AAC5B5T,WAAO2S,OAAP,wCAAoDvS,QAApD,eAAsEC,QAAtE;AACA,QAAImV,WAAW,EAAf;AACA;;AAEA;AACA,WAAOH,QAAQtQ,aAAR,OAA0B3E,QAA1B,EACJT,IADI,CACC,cAAM;AACV;AACA,UAAM8V,WAAW;AACf/B,kBAAUtT,QADK;AAEfC,kBAAUA;AAFK,OAAjB;AAIAL,aAAO2S,OAAP,CAAe,YAAf,EAA6B8C,QAA7B;AACA;AACA,UAAMC,cAAc;AAClBhb,2BAAoB0F,QADF;AAElB8M,wBAAgByI,GAAGC;AAFD,OAApB;AAIA5V,aAAO2S,OAAP,CAAe,eAAf,EAAgC+C,WAAhC;AACA;AACA,UAAMG,kBAAkB;AACtBtY,iBAASoY,GAAGC,QADU;AAEtB1d,oBAAakI;AACb;AAHsB,OAAxB;AAKAJ,aAAO2S,OAAP,CAAe,mBAAf,EAAoCkD,eAApC;AACA;AACA,aAAOjW,QAAQC,GAAR,CAAY,CAACS,GAAGoB,IAAH,CAAQiB,MAAR,CAAe8S,QAAf,CAAD,EAA2BnV,GAAGgB,OAAH,CAAWqB,MAAX,CAAkB+S,WAAlB,CAA3B,EAA2DpV,GAAGe,WAAH,CAAesB,MAAf,CAAsBkT,eAAtB,CAA3D,CAAZ,CAAP;AACD,KAvBI,EAwBJlW,IAxBI,CAwBC,gBAA2C;AAAA;AAAA,UAAzCmW,OAAyC;AAAA,UAAhCC,UAAgC;AAAA,UAApBC,cAAoB;;AAC/ChW,aAAO2S,OAAP,CAAe,2CAAf;AACA;AACA6C,eAAS,IAAT,IAAiBM,QAAQ9Y,EAAzB;AACAwY,eAAS,UAAT,IAAuBM,QAAQpC,QAA/B;AACA8B,eAAS,aAAT,IAA0BO,WAAWrb,WAArC;AACA8a,eAAS,gBAAT,IAA6BO,WAAW7I,cAAxC;AACA;AACA,aAAOtN,QAAQC,GAAR,CAAY,CAACmW,eAAeC,UAAf,CAA0BF,UAA1B,CAAD,EAAwCA,WAAWG,OAAX,CAAmBJ,OAAnB,CAAxC,CAAZ,CAAP;AACD,KAjCI,EAkCJnW,IAlCI,CAkCC,YAAM;AACVK,aAAO2S,OAAP,CAAe,8CAAf;AACA,aAAOrS,GAAGe,WAAH,CAAeuM,kCAAf,CAAkD4H,SAAStI,cAA3D,EAA2EsI,SAAS9a,WAApF,CAAP;AACD,KArCI,EAsCJiF,IAtCI,CAsCC,0BAAkB;AACtB6V,eAAS,gBAAT,IAA6B7B,cAA7B;AACA,aAAOC,KAAK,IAAL,EAAW4B,QAAX,CAAP;AACD,KAzCI,EA0CJrU,KA1CI,CA0CE,iBAAS;AACdnB,aAAOtD,KAAP,CAAa,cAAb,EAA6BA,KAA7B;AACA,aAAOkX,KAAKlX,KAAL,CAAP;AACD,KA7CI,CAAP;AA8CD,GAzDI,CAAP;AA2DD,CA5DD,C;;;;;;ACJA,kC;;;;;;;;;ACAA,IAAMyZ,aAAa;AACjB/S,OAAK;AACHC,aAAS,WADN;AAEHC,aAAS;AAFN;AADY,CAAnB;;AAOAxK,OAAOC,OAAP,GAAiBod,UAAjB,C;;;;;;ACPA,gD;;;;;;;;;ACAA,IAAMhB,wBAAwB,mBAAApV,CAAQ,EAAR,EAA0BqV,QAAxD;AACA,IAAMpV,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;AAEAjH,OAAOC,OAAP,GAAiB,UAACuH,EAAD,EAAQ;AACvB,MAAM8V,2BAA2B,SAA3BA,wBAA2B,CAACC,YAAD,EAAkB;AACjD,WAAO,IAAIzW,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,UAAI4R,WAAW,EAAf;AACAA,eAAS,IAAT,IAAiBa,aAAarZ,EAA9B;AACAwY,eAAS,UAAT,IAAuBa,aAAa3C,QAApC;AACA2C,mBACGC,UADH,GAEG3W,IAFH,CAEQ,gBAAmC;AAAA,YAAjCjF,WAAiC,QAAjCA,WAAiC;AAAA,YAApBwS,cAAoB,QAApBA,cAAoB;;AACvCsI,iBAAS,aAAT,IAA0B9a,WAA1B;AACA8a,iBAAS,gBAAT,IAA6BtI,cAA7B;AACA,eAAO5M,GAAGe,WAAH,CAAeuM,kCAAf,CAAkDV,cAAlD,EAAkExS,WAAlE,CAAP;AACD,OANH,EAOGiF,IAPH,CAOQ,0BAAkB;AACtB6V,iBAAS,gBAAT,IAA6B7B,cAA7B;AACAhQ,gBAAQ6R,QAAR;AACD,OAVH,EAWGrU,KAXH,CAWS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAbH;AAcD,KAlBM,CAAP;AAmBD,GApBD;;AAsBA,SAAO,IAAIyY,qBAAJ,CACL;AACEG,mBAAe,UADjB;AAEEC,mBAAe;AAFjB,GADK,EAKL,UAACnV,QAAD,EAAWC,QAAX,EAAqBuT,IAArB,EAA8B;AAC5B,WAAOtT,GAAGoB,IAAH,CACJY,OADI,CACI;AACPC,aAAO,EAACmR,UAAUtT,QAAX;AADA,KADJ,EAIJT,IAJI,CAIC,gBAAQ;AACZ,UAAI,CAAC6T,IAAL,EAAW;AACTxT,eAAOyC,KAAP,CAAa,eAAb;AACA,eAAOmR,KAAK,IAAL,EAAW,KAAX,EAAkB,EAACrZ,SAAS,gCAAV,EAAlB,CAAP;AACD;AACD,aAAOiZ,KAAK+C,eAAL,CAAqBlW,QAArB,EACJV,IADI,CACC,mBAAW;AACf,YAAI,CAAC6W,OAAL,EAAc;AACZxW,iBAAOyC,KAAP,CAAa,oBAAb;AACA,iBAAOmR,KAAK,IAAL,EAAW,KAAX,EAAkB,EAACrZ,SAAS,gCAAV,EAAlB,CAAP;AACD;AACDyF,eAAOyC,KAAP,CAAa,sCAAb;AACA,eAAO2T,yBAAyB5C,IAAzB,EACJ7T,IADI,CACC,oBAAY;AAChB,iBAAOiU,KAAK,IAAL,EAAW4B,QAAX,CAAP;AACD,SAHI,EAIJrU,KAJI,CAIE,iBAAS;AACd,iBAAOzE,KAAP;AACD,SANI,CAAP;AAOD,OAdI,EAeJyE,KAfI,CAeE,iBAAS;AACd,eAAOzE,KAAP;AACD,OAjBI,CAAP;AAkBD,KA3BI,EA4BJyE,KA5BI,CA4BE,iBAAS;AACd,aAAOyS,KAAKlX,KAAL,CAAP;AACD,KA9BI,CAAP;AA+BD,GArCI,CAAP;AAuCD,CA9DD,C;;;;;;;;;ACHA,IAAMsD,SAAS,mBAAAD,CAAQ,CAAR,CAAf;AACA,IAAM+Q,WAAW,mBAAA/Q,CAAQ,EAAR,CAAjB;;AAEAjH,OAAOC,OAAP,GAAiB,UAACoZ,GAAD,EAAS;AACxB;AACAA,MAAI9N,IAAJ,CAAS,SAAT,EAAoByM,SAAS7P,YAAT,CAAsB,cAAtB,CAApB,EAA2D,UAACmN,GAAD,EAAM/B,GAAN,EAAc;AACvErM,WAAO2S,OAAP,4BAAwCvE,IAAIoF,IAAJ,CAAS9Y,WAAjD;AACA2R,QAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB;AACnBwN,eAAgB,IADG;AAEnBlS,mBAAgB0T,IAAIoF,IAAJ,CAAS9Y,WAFN;AAGnBwS,sBAAgBkB,IAAIoF,IAAJ,CAAStG,cAHN;AAInByG,sBAAgBvF,IAAIoF,IAAJ,CAASG;AAJN,KAArB;AAMD,GARD;AASA;AACAxB,MAAI9N,IAAJ,CAAS,QAAT,EAAmB,UAAC+J,GAAD,EAAM/B,GAAN,EAAWqG,IAAX,EAAoB;AACrC5B,aAAS7P,YAAT,CAAsB,aAAtB,EAAqC,UAACG,GAAD,EAAMoS,IAAN,EAAYtS,IAAZ,EAAqB;AACxDlB,aAAOyC,KAAP,CAAa,OAAb,EAAsBvB,IAAtB;AACA,UAAIE,GAAJ,EAAS;AACP,eAAOsR,KAAKtR,GAAL,CAAP;AACD;AACD,UAAI,CAACoS,IAAL,EAAW;AACT,eAAOnH,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB;AAC1BwN,mBAAS,KADiB;AAE1BrS,mBAAS2G,KAAK3G;AAFY,SAArB,CAAP;AAID;AACDyF,aAAOyC,KAAP,CAAa,kBAAb;AACA2L,UAAIqI,KAAJ,CAAUjD,IAAV,EAAgB,UAACpS,GAAD,EAAS;AACvB,YAAIA,GAAJ,EAAS;AACP,iBAAOsR,KAAKtR,GAAL,CAAP;AACD;AACD,eAAOiL,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB;AAC1BwN,mBAAgB,IADU;AAE1BlS,uBAAgB0T,IAAIoF,IAAJ,CAAS9Y,WAFC;AAG1BwS,0BAAgBkB,IAAIoF,IAAJ,CAAStG,cAHC;AAI1ByG,0BAAgBvF,IAAIoF,IAAJ,CAASG;AAJC,SAArB,CAAP;AAMD,OAVD;AAWD,KAvBD,EAuBGvF,GAvBH,EAuBQ/B,GAvBR,EAuBaqG,IAvBb;AAwBD,GAzBD;AA0BA;AACAP,MAAIuE,GAAJ,CAAQ,SAAR,EAAmB,UAACtI,GAAD,EAAM/B,GAAN,EAAc;AAC/B+B,QAAIuI,MAAJ;AACAtK,QAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,IAAV,EAAgBrS,SAAS,6BAAzB,EAArB;AACD,GAHD;AAIA;AACA4X,MAAIuE,GAAJ,CAAQ,OAAR,EAAiB,UAACtI,GAAD,EAAM/B,GAAN,EAAc;AAC7B,QAAI+B,IAAIoF,IAAR,EAAc;AACZnH,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,IAAV,EAAgB7S,MAAMqU,IAAIoF,IAA1B,EAArB;AACD,KAFD,MAEO;AACLnH,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAAS,uBAA1B,EAArB;AACD;AACF,GAND;AAOD,CAnDD,C;;;;;;;;;;;ACHA,IAAMyF,SAAS,mBAAAD,CAAQ,CAAR,CAAf;AACA,IAAM6W,YAAY,mBAAA7W,CAAQ,EAAR,CAAlB;;eACwB,mBAAAA,CAAQ,CAAR,C;IAAhBjI,K,YAAAA,K;IAAOE,I,YAAAA,I;;AACf,IAAM6e,sBAAsBD,UAAU,EAACE,WAAWhf,MAAMC,eAAlB,EAAV,CAA5B;AACA,IAAMuI,KAAK,mBAAAP,CAAQ,EAAR,CAAX;;gBACoE,mBAAAA,CAAQ,EAAR,C;IAA5DgX,oB,aAAAA,oB;IAAsBC,wB,aAAAA,wB;IAA0B3e,O,aAAAA,O;;gBACT,mBAAA0H,CAAQ,EAAR,C;IAAvC2E,Y,aAAAA,Y;IAAcE,U,aAAAA,U;IAAYL,Q,aAAAA,Q;;gBACmI,mBAAAxE,CAAQ,EAAR,C;IAA7J2L,uB,aAAAA,uB;IAAyBZ,wB,aAAAA,wB;IAA0BS,4B,aAAAA,4B;IAA8BzB,0B,aAAAA,0B;IAA4BM,2B,aAAAA,2B;IAA6B2B,c,aAAAA,c;;AAClJ,IAAMkL,gBAAgB,mBAAAlX,CAAQ,EAAR,CAAtB;;gBAC8B,mBAAAA,CAAQ,EAAR,C;IAAtB0D,iB,aAAAA,iB;;gBACqB,mBAAA1D,CAAQ,EAAR,C;IAArBmX,gB,aAAAA,gB;;gBACiD,mBAAAnX,CAAQ,EAAR,C;IAAjD2N,c,aAAAA,c;IAAgBI,gB,aAAAA,gB;IAAkBb,U,aAAAA,U;;AAE1C,IAAMH,aAAa,YAAnB;AACA,IAAMC,WAAW,UAAjB;;AAEAjU,OAAOC,OAAP,GAAiB,UAACoZ,GAAD,EAAS;AACxB;AACAA,MAAIuE,GAAJ,CAAQ,iCAAR,EAA2C,gBAA8BrK,GAA9B,EAAsC;AAAA,QAAnC/G,EAAmC,QAAnCA,EAAmC;AAAA,QAA/BC,WAA+B,QAA/BA,WAA+B;AAAA,QAAlB/I,MAAkB,QAAlBA,MAAkB;;AAC/Ewa,6BAAyBxa,OAAOtE,IAAhC,EACGyH,IADH,CACQ,kBAAU;AACd,UAAIkE,WAAW,IAAf,EAAqB;AACnBwI,YAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,IAArB;AACD,OAFD,MAEO;AACLiN,YAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,KAArB;AACD;AACF,KAPH,EAQG+B,KARH,CAQS,iBAAS;AACd8V,oBAAc7K,mBAAd,CAAkC7G,WAAlC,EAA+CD,EAA/C,EAAmD5I,KAAnD,EAA0D2P,GAA1D;AACD,KAVH;AAWD,GAZD;AAaA;AACA8F,MAAIuE,GAAJ,CAAQ,qCAAR,EAA+C,iBAA8BrK,GAA9B,EAAsC;AAAA,QAAnC/G,EAAmC,SAAnCA,EAAmC;AAAA,QAA/BC,WAA+B,SAA/BA,WAA+B;AAAA,QAAlB/I,MAAkB,SAAlBA,MAAkB;;AACnF8D,OAAGe,WAAH,CAAeuM,kCAAf,CAAkDpR,OAAOlB,MAAzD,EAAiEkB,OAAOtE,IAAxE,EACGyH,IADH,CACQ,mBAAW;AACf0M,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqBhE,OAArB;AACD,KAHH,EAIG+F,KAJH,CAIS,iBAAS;AACd8V,oBAAc7K,mBAAd,CAAkC7G,WAAlC,EAA+CD,EAA/C,EAAmD5I,KAAnD,EAA0D2P,GAA1D;AACD,KANH;AAOD,GARD;AASA8F,MAAIuE,GAAJ,CAAQ,gDAAR,EAA0D,iBAAoCrK,GAApC,EAA4C;AAAA,QAAzC/G,EAAyC,SAAzCA,EAAyC;AAAA,QAArCC,WAAqC,SAArCA,WAAqC;AAAA,QAAxB4R,IAAwB,SAAxBA,IAAwB;AAAA,QAAlB3a,MAAkB,SAAlBA,MAAkB;;AACpG,QAAM9B,cAAc8B,OAAO9B,WAA3B;AACA,QAAIwS,iBAAiB1Q,OAAO0Q,cAA5B;AACA,QAAIA,mBAAmB,MAAvB,EAA+BA,iBAAiB,IAAjB;AAC/BQ,mBAAehT,WAAf,EAA4BwS,cAA5B,EAA4C,CAA5C,EACGvN,IADH,CACQ,gBAAQ;AACZ,UAAI5F,SAAS+S,UAAb,EAAyB;AACvB,eAAOT,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAAS,+BAA1B,EAArB,CAAP;AACD;AACD8R,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,IAAV,EAAgB7S,UAAhB,EAArB;AACD,KANH,EAOGoH,KAPH,CAOS,iBAAS;AACd8V,oBAAc7K,mBAAd,CAAkC7G,WAAlC,EAA+CD,EAA/C,EAAmD5I,KAAnD,EAA0D2P,GAA1D;AACD,KATH;AAUD,GAdD;AAeA8F,MAAIuE,GAAJ,CAAQ,wDAAR,EAAkE,iBAAoCrK,GAApC,EAA4C;AAAA,QAAzC/G,EAAyC,SAAzCA,EAAyC;AAAA,QAArCC,WAAqC,SAArCA,WAAqC;AAAA,QAAxB4R,IAAwB,SAAxBA,IAAwB;AAAA,QAAlB3a,MAAkB,SAAlBA,MAAkB;;AAC5G,QAAM9B,cAAc8B,OAAO9B,WAA3B;AACA,QAAIwS,iBAAiB1Q,OAAO0Q,cAA5B;AACA,QAAIA,mBAAmB,MAAvB,EAA+BA,iBAAiB,IAAjB;AAC/B,QAAMrP,OAAOrB,OAAOqB,IAApB;AACAiQ,qBAAiBpT,WAAjB,EAA8BwS,cAA9B,EAA8CrP,IAA9C,EACG8B,IADH,CACQ,gBAAQ;AACZ,UAAI5F,SAAS+S,UAAb,EAAyB;AACvB,eAAOT,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAAS,+BAA1B,EAArB,CAAP;AACD;AACD8R,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,IAAV,EAAgB7S,UAAhB,EAArB;AACD,KANH,EAOGoH,KAPH,CAOS,iBAAS;AACd8V,oBAAc7K,mBAAd,CAAkC7G,WAAlC,EAA+CD,EAA/C,EAAmD5I,KAAnD,EAA0D2P,GAA1D;AACD,KATH;AAUD,GAfD;AAgBA;AACA8F,MAAIuE,GAAJ,CAAQ,uBAAR,EAAiC,iBAA8BrK,GAA9B,EAAsC;AAAA,QAAnC/G,EAAmC,SAAnCA,EAAmC;AAAA,QAA/BC,WAA+B,SAA/BA,WAA+B;AAAA,QAAlB/I,MAAkB,SAAlBA,MAAkB;;AACrEkI,iBAAalI,OAAOtE,IAApB,EACGyH,IADH,CACQ,sBAAc;AAClB0M,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqBgY,UAArB;AACD,KAHH,EAIGjW,KAJH,CAIS,iBAAS;AACd8V,oBAAc7K,mBAAd,CAAkC7G,WAAlC,EAA+CD,EAA/C,EAAmD5I,KAAnD,EAA0D2P,GAA1D;AACD,KANH;AAOD,GARD;AASA;AACA8F,MAAIuE,GAAJ,CAAQ,+BAAR,EAAyC,iBAA8BrK,GAA9B,EAAsC;AAAA,QAAnC/G,EAAmC,SAAnCA,EAAmC;AAAA,QAA/BC,WAA+B,SAA/BA,WAA+B;AAAA,QAAlB/I,MAAkB,SAAlBA,MAAkB;;AAC7E,QAAMtE,OAAOsE,OAAOtE,IAApB;AACA,QAAMqF,UAAUf,OAAOe,OAAvB;AACA;AACA+C,OAAGiB,KAAH,CAAS8V,YAAT,CAAsBnf,IAAtB,EAA4BqF,OAA5B,EACGoC,IADH,CACQ,yBAAiB;AACrB;AACA,UAAI,CAAC2X,aAAL,EAAoB;AAClB,cAAM,IAAI/X,KAAJ,CAAU,sCAAV,CAAN;AACD;AACD,UAAIgY,WAAWxL,eAAeuL,aAAf,CAAf;AACA;AACA,aAAO1X,QAAQC,GAAR,CAAY,CAAC0X,QAAD,EAAWhT,SAAYrM,IAAZ,SAAoBqF,OAApB,CAAX,CAAZ,CAAP;AACD,KATH,EAUGoC,IAVH,CAUQ,iBAA6B;AAAA;AAAA,UAA1B4X,QAA0B;AAAA,UAAhB3L,SAAgB;;AACjC2L,iBAAW7L,wBAAwB6L,QAAxB,EAAkC3L,SAAlC,CAAX;AACA,aAAOhM,QAAQC,GAAR,CAAY,CAACS,GAAG2B,MAAH,CAAU3B,GAAGkB,IAAb,EAAmB+V,QAAnB,EAA6B,EAACrf,UAAD,EAAOqF,gBAAP,EAA7B,EAA8C,MAA9C,CAAD,EAAwDqO,SAAxD,CAAZ,CAAP;AACD,KAbH,EAcGjM,IAdH,CAcQ,iBAA0C;AAAA;AAAA,UAAvC6X,UAAuC;AAAA;AAAA,UAA1Bjd,OAA0B,WAA1BA,OAA0B;AAAA,UAAjBkd,SAAiB,WAAjBA,SAAiB;;AAC9CpL,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAAEwN,SAAS,IAAX,EAAiBrS,gBAAjB,EAA0Bkd,oBAA1B,EAArB;AACD,KAhBH,EAiBGtW,KAjBH,CAiBS,iBAAS;AACd8V,oBAAc7K,mBAAd,CAAkC7G,WAAlC,EAA+CD,EAA/C,EAAmD5I,KAAnD,EAA0D2P,GAA1D;AACD,KAnBH;AAoBD,GAxBD;AAyBA;AACA8F,MAAIuE,GAAJ,CAAQ,+BAAR,EAAyC,kBAA8BrK,GAA9B,EAAsC;AAAA,QAAnC/G,EAAmC,UAAnCA,EAAmC;AAAA,QAA/BC,WAA+B,UAA/BA,WAA+B;AAAA,QAAlB/I,MAAkB,UAAlBA,MAAkB;;AAC7Eua,yBAAqBva,OAAOtE,IAA5B,EACGyH,IADH,CACQ,kBAAU;AACd0M,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqByE,MAArB;AACD,KAHH,EAIG1C,KAJH,CAIS,iBAAS;AACd8V,oBAAc7K,mBAAd,CAAkC7G,WAAlC,EAA+CD,EAA/C,EAAmD5I,KAAnD,EAA0D2P,GAA1D;AACD,KANH;AAOD,GARD;AASA;AACA8F,MAAIuE,GAAJ,CAAQ,mCAAR,EAA6C,kBAAuCrK,GAAvC,EAA+C;AAAA,QAA5ChH,OAA4C,UAA5CA,OAA4C;AAAA,QAAnCC,EAAmC,UAAnCA,EAAmC;AAAA,QAA/BC,WAA+B,UAA/BA,WAA+B;AAAA,QAAlB/I,MAAkB,UAAlBA,MAAkB;;AAC1FoI,eAAcpI,OAAOtE,IAArB,SAA6BsE,OAAOe,OAApC,EACGoC,IADH,CACQ,uBAAe;AACnB0M,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqBsY,WAArB;AACD,KAHH,EAIGvW,KAJH,CAIS,iBAAS;AACd8V,oBAAc7K,mBAAd,CAAkC7G,WAAlC,EAA+CD,EAA/C,EAAmD5I,KAAnD,EAA0D2P,GAA1D;AACD,KANH;AAOD,GARD;AASA;AACA8F,MAAI9N,IAAJ,CAAS,oBAAT,EAA+BwS,mBAA/B,EAAoD,kBAAkDxK,GAAlD,EAA0D;AAAA,QAAvD8K,IAAuD,UAAvDA,IAAuD;AAAA,QAAjDrf,KAAiD,UAAjDA,KAAiD;AAAA,QAA1CuN,OAA0C,UAA1CA,OAA0C;AAAA,QAAjCC,EAAiC,UAAjCA,EAAiC;AAAA,QAA7BC,WAA6B,UAA7BA,WAA6B;AAAA,QAAhBiO,IAAgB,UAAhBA,IAAgB;;AAC5GxT,WAAOyC,KAAP,CAAa,6BAAb,EAA4C0U,IAA5C;AACAnX,WAAOyC,KAAP,CAAa,8BAAb,EAA6C3K,KAA7C;AACA;AACA,QAAK4C,oBAAL;AAAA,QAAkBkC,kBAAlB;AAAA,QAA6B+a,wBAA7B;AAAA,QAA8Cvf,oBAA9C;AAAA,QAA2DoS,iBAA3D;AAAA,QAAqEC,iBAArE;AAAA,QAA+EC,iBAA/E;AAAA,QAAyFxG,oBAAzF;AAAA,QAAsG8F,gBAAtG;AAAA,QAA+G9R,aAA/G;AAAA,QAAqH6R,aAArH;AAAA,QAA2HE,kBAA3H;AAAA,QAAsIU,0BAAtI;AAAA,QAAyJC,0BAAzJ;AAAA,QAA4KC,0BAA5K;AAAA,QAA+L5S,cAA/L;AACA;AACAiM,kBAAcC,KAAKC,GAAL,EAAd;AACA;AACA,QAAI;AAAA,kCAEsD0F,2BAA2BqN,IAA3B,CAFtD;AACF;;;AACEjf,UAFA,yBAEAA,IAFA;AAEM6R,UAFN,yBAEMA,IAFN;AAEYC,aAFZ,yBAEYA,OAFZ;AAEqB/R,WAFrB,yBAEqBA,KAFrB;AAE4BG,iBAF5B,yBAE4BA,WAF5B;AAEyC6R,eAFzC,yBAEyCA,SAFzC;;AAAA,mCAGyFG,4BAA4BtS,KAA5B,CAHzF;;AAGA0S,cAHA,0BAGAA,QAHA;AAGUC,cAHV,0BAGUA,QAHV;AAGoBC,cAHpB,0BAGoBA,QAHpB;AAG8BC,uBAH9B,0BAG8BA,iBAH9B;AAGiDC,uBAHjD,0BAGiDA,iBAHjD;AAGoEC,uBAHpE,0BAGoEA,iBAHpE;AAIAnQ,iBAJA,GAI2Cyc,IAJ3C,CAIAzc,WAJA;AAIakC,eAJb,GAI2Cua,IAJ3C,CAIava,SAJb;AAIwB+a,qBAJxB,GAI2CR,IAJ3C,CAIwBQ,eAJxB;AAKH,KALD,CAKE,OAAOjb,KAAP,EAAc;AACd,aAAO2P,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAASmC,MAAMnC,OAAhC,EAArB,CAAP;AACD;AACD;AACAqF,YAAQC,GAAR,CAAY,CACVqX,iBAAiBxc,WAAjB,EAA8BkC,SAA9B,EAAyC+a,eAAzC,EAA0DnE,IAA1D,CADU,EAEVuD,qBAAqB7e,IAArB,CAFU,EAGV4S,yBAAyBL,QAAzB,EAAmCvS,IAAnC,EAAyCD,KAAzC,EAAgDG,WAAhD,EAA6D4R,OAA7D,EAAsED,IAAtE,EAA4EE,SAA5E,CAHU,EAIVsB,6BAA6BX,iBAA7B,EAAgD1S,IAAhD,EAAsD8R,OAAtD,EAA+DD,IAA/D,CAJU,CAAZ,EAMGpK,IANH,CAMQ,kBAAgG;AAAA;AAAA;AAAA,UAA7FjF,WAA6F,WAA7FA,WAA6F;AAAA,UAAhFwS,cAAgF,WAAhFA,cAAgF;AAAA,UAA/D0K,kBAA+D;AAAA,UAA3C3T,aAA2C;AAAA,UAA5B4T,sBAA4B;;AACpG;AACA,UAAInd,eAAewS,cAAnB,EAAmC;AACjCjJ,sBAAc,cAAd,IAAgCvJ,WAAhC;AACAuJ,sBAAc,YAAd,IAA8BiJ,cAA9B;AACD;AACD;AACA,UAAI2K,sBAAJ,EAA4B;AAC1Bxf,gBAAQwf,sBAAR,EAAgClN,iBAAhC,EAAmDE,iBAAnD;AACD;AACD;AACA,aAAOxS,QAAQ4L,aAAR,EAAuBuG,QAAvB,EAAiCE,QAAjC,CAAP;AACD,KAlBH,EAmBG/K,IAnBH,CAmBQ,kBAAU;AACd0M,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB;AACnBwN,iBAAS,IADU;AAEnBrS,iBAAS,gCAFU;AAGnBR,cAAS;AACP7B,oBADO;AAEPqF,mBAASsG,OAAO+R,QAFT;AAGPpW,eAAYxH,KAAKG,IAAjB,SAAyB0L,OAAO+R,QAAhC,SAA4C1d,IAHrC;AAIP4f,kBAASjU;AAJF;AAHU,OAArB;AAUA;AACAJ,wBAAkB,YAAlB,EAAgC,SAAhC,EAA2CiH,QAA3C,EAAqDxG,WAArD,EAAkEC,KAAKC,GAAL,EAAlE;AACD,KAhCH,EAiCGjD,KAjCH,CAiCS,iBAAS;AACd8V,oBAAc7K,mBAAd,CAAkC7G,WAAlC,EAA+CD,EAA/C,EAAmD5I,KAAnD,EAA0D2P,GAA1D;AACD,KAnCH;AAoCD,GArDD;AAsDA;AACA8F,MAAIuE,GAAJ,CAAQ,mCAAR,EAA6C,kBAAoCrK,GAApC,EAA4C;AAAA,QAAzC/G,EAAyC,UAAzCA,EAAyC;AAAA,QAArCC,WAAqC,UAArCA,WAAqC;AAAA,QAAxB4R,IAAwB,UAAxBA,IAAwB;AAAA,QAAlB3a,MAAkB,UAAlBA,MAAkB;;AACvF8D,OAAGiB,KAAH,CAASwW,8BAAT,CAAwCvb,OAAOlB,MAA/C,EAAuDkB,OAAOtE,IAA9D,EACGyH,IADH,CACQ,mBAAW;AACf0M,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,IAAV,EAAgB7S,MAAMqB,OAAtB,EAArB;AACD,KAHH,EAIG+F,KAJH,CAIS,iBAAS;AACd8V,oBAAc7K,mBAAd,CAAkC7G,WAAlC,EAA+CD,EAA/C,EAAmD5I,KAAnD,EAA0D2P,GAA1D;AACD,KANH;AAOD,GARD;AASA8F,MAAI9N,IAAJ,CAAS,oBAAT,EAA+B,kBAAoCgI,GAApC,EAA4C;AAAA,QAAzC/G,EAAyC,UAAzCA,EAAyC;AAAA,QAArCC,WAAqC,UAArCA,WAAqC;AAAA,QAAxB4R,IAAwB,UAAxBA,IAAwB;AAAA,QAAlB3a,MAAkB,UAAlBA,MAAkB;;AACzEwD,WAAOyC,KAAP,CAAa,OAAb,EAAsB0U,IAAtB;AACA,QAAMzc,cAAcyc,KAAKzc,WAAzB;AACA,QAAMwS,iBAAiBiK,KAAKjK,cAA5B;AACA,QAAMvI,YAAYwS,KAAKxS,SAAvB;AACA,QAAMpH,UAAU4Z,KAAK5Z,OAArB;AACA0P,eAAWvS,WAAX,EAAwBwS,cAAxB,EAAwCvI,SAAxC,EAAmDpH,OAAnD,EACGoC,IADH,CACQ,kBAAU;AACd,UAAIkE,WAAWiJ,UAAf,EAA2B;AACzB,eAAOT,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAAS,oCAA1B,EAArB,CAAP;AACD;AACD,UAAIsJ,WAAWkJ,QAAf,EAAyB;AACvB,eAAOV,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAAS,qCAA1B,EAArB,CAAP;AACD;AACD8R,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,IAAV,EAAgB7S,MAAM8J,MAAtB,EAArB;AACD,KATH,EAUG1C,KAVH,CAUS,iBAAS;AACd8V,oBAAc7K,mBAAd,CAAkC7G,WAAlC,EAA+CD,EAA/C,EAAmD5I,KAAnD,EAA0D2P,GAA1D;AACD,KAZH;AAaD,GAnBD;AAoBA8F,MAAIuE,GAAJ,CAAQ,qCAAR,EAA+C,kBAAoCrK,GAApC,EAA4C;AAAA,QAAzC/G,EAAyC,UAAzCA,EAAyC;AAAA,QAArCC,WAAqC,UAArCA,WAAqC;AAAA,QAAxB4R,IAAwB,UAAxBA,IAAwB;AAAA,QAAlB3a,MAAkB,UAAlBA,MAAkB;;AACzF,QAAMmI,YAAYnI,OAAOmI,SAAzB;AACA,QAAIpH,UAAUf,OAAOe,OAArB;AACA,QAAIA,YAAY,MAAhB,EAAwBA,UAAU,IAAV;AACxB+C,OAAGiB,KAAH,CAAS8V,YAAT,CAAsB1S,SAAtB,EAAiCpH,OAAjC,EACGoC,IADH,CACQ,qBAAa;AACjB,UAAI,CAACqY,SAAL,EAAgB;AACd,eAAO3L,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAAS,yBAA1B,EAArB,CAAP;AACD;AACD8R,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,IAAV,EAAgB7S,MAAMie,SAAtB,EAArB;AACD,KANH,EAOG7W,KAPH,CAOS,iBAAS;AACd8V,oBAAc7K,mBAAd,CAAkC7G,WAAlC,EAA+CD,EAA/C,EAAmD5I,KAAnD,EAA0D2P,GAA1D;AACD,KATH;AAUD,GAdD;AAeA;AACA8F,MAAIuE,GAAJ,CAAQ,uCAAR,EAAiD,kBAA8BrK,GAA9B,EAAsC;AAAA,QAAnC/G,EAAmC,UAAnCA,EAAmC;AAAA,QAA/BC,WAA+B,UAA/BA,WAA+B;AAAA,QAAlB/I,MAAkB,UAAlBA,MAAkB;;AACrF,QAAMtE,OAAOsE,OAAOtE,IAApB;AACA,QAAMqF,UAAUf,OAAOe,OAAvB;AACA+C,OAAGkB,IAAH,CAAQc,OAAR,CAAgB,EAACC,OAAO,EAACrK,UAAD,EAAOqF,gBAAP,EAAR,EAAhB,EACGoC,IADH,CACQ,kBAAU;AACd,UAAIkE,MAAJ,EAAY;AACV,eAAOwI,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,IAAV,EAAgB7S,MAAM,IAAtB,EAArB,CAAP;AACD;AACDsS,UAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,IAAV,EAAgB7S,MAAM,KAAtB,EAArB;AACD,KANH,EAOGoH,KAPH,CAOS,iBAAS;AACd8V,oBAAc7K,mBAAd,CAAkC7G,WAAlC,EAA+CD,EAA/C,EAAmD5I,KAAnD,EAA0D2P,GAA1D;AACD,KATH;AAUD,GAbD;AAcD,CAnOD,C;;;;;;AChBA,+C;;;;;;ACAA,sC;;;;;;;;;ACAA,IAAMrM,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;eAC0B,mBAAAA,CAAQ,EAAR,C;IAAlBkJ,a,YAAAA,a;;AAERnQ,OAAOC,OAAP,GAAiB,UAACwH,SAAD,QAA4D;AAAA,MAA9C0X,MAA8C,QAA9CA,MAA8C;AAAA,MAAtCC,OAAsC,QAAtCA,OAAsC;AAAA,MAA7BC,OAA6B,QAA7BA,OAA6B;AAAA,MAApBC,IAAoB,QAApBA,IAAoB;AAAA,MAAdC,OAAc,QAAdA,OAAc;;AAC3E,MAAMhX,cAAcd,UAAU+X,MAAV,CAClB,aADkB,EAElB;AACEpM,aAAS;AACPrS,YAASoe,MADF;AAEPM,eAAS;AAFF,KADX;AAKEtT,YAAQ;AACNpL,YAASwe,QAAQ,EAAR,EAAY,CAAZ,CADH;AAENE,eAAS;AAFH,KALV;AASEhb,aAAS;AACP1D,YAASoe,MADF;AAEPM,eAAS;AAFF,KATX;AAaEC,mBAAe;AACb3e,YAASse,OADI;AAEbI,eAAS;AAFI,KAbjB;AAiBEE,kBAAc;AACZ5e,YAASqe,OADG;AAEZK,eAAS;AAFG,KAjBhB;AAqBEG,WAAO;AACL7e,YAASse,OADJ;AAELI,eAAS;AAFJ,KArBT;AAyBEI,qBAAiB;AACf9e,YAASwe,QAAQ,EAAR,EAAY,CAAZ,CADM;AAEfE,eAAS;AAFM,KAzBnB;AA6BEK,kBAAc;AACZ/e,YAASqe,OADG;AAEZK,eAAS;AAFG,KA7BhB;AAiCEtM,YAAQ;AACNpS,YAASse,OADH;AAENI,eAAS;AAFH,KAjCV;AAqCEM,SAAK;AACHhf,YAASue,KAAK,MAAL,CADN;AAEHG,eAAS;AAFN,KArCP;AAyCErgB,UAAM;AACJ2B,YAASoe,MADL;AAEJM,eAAS;AAFL,KAzCR;AA6CEO,UAAM;AACJjf,YAASse,OADL;AAEJI,eAAS;AAFL,KA7CR;AAiDEQ,UAAM;AACJlf,YAASoe,MADL;AAEJM,eAAS;AAFL,KAjDR;AAqDES,mBAAe;AACbnf,YAASse,OADI;AAEbI,eAAS;AAFI,KArDjB;AAyDEvM,cAAU;AACRnS,YAASoe,MADD;AAERM,eAAS;AAFD,KAzDZ;AA6DEU,kBAAc;AACZpf,YAASoe,MADG;AAEZM,eAAS;AAFG,KA7DhB;AAiEEW,eAAW;AACTrf,YAASoe,MADA;AAETM,eAAS;AAFA,KAjEb;AAqEEY,wBAAoB;AAClBtf,YAASoe,MADS;AAElBM,eAAS;AAFS,KArEtB;AAyEEa,aAAS;AACPvf,YAASoe,MADF;AAEPM,eAAS;AAFF,KAzEX;AA6EEc,eAAW;AACTxf,YAASue,KAAK,MAAL,CADA;AAETG,eAAS;AAFA;AA7Eb,GAFkB,EAoFlB;AACEe,qBAAiB;AADnB,GApFkB,CAApB;;AAyFAjY,cAAYW,SAAZ,GAAwB,cAAM;AAC5BX,gBAAYkY,SAAZ,CAAsBjZ,GAAGgB,OAAzB,EAAkC;AAChCkY,kBAAY;AACVC,mBAAW;AADD;AADoB,KAAlC;AAKD,GAND;;AAQApY,cAAYuM,kCAAZ,GAAiD,UAAUJ,aAAV,EAAyB9S,WAAzB,EAAsC;AAAA;;AACrFsF,WAAOyC,KAAP,yCAAmD/H,WAAnD,SAAkE8S,aAAlE;AACA,WAAO,IAAI5N,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,YACG8V,OADH,CACW;AACPnX,eAAO,EAACrK,MAAMwC,WAAP,EADA;AAEPif,eAAO,CAAC,CAAC,QAAD,EAAW,KAAX,CAAD;AAFA,OADX,EAKGha,IALH,CAKQ,kBAAU;AACd,gBAAQkE,OAAO6F,MAAf;AACE,eAAK,CAAL;AACE,kBAAM,IAAInK,KAAJ,CAAU,4CAAV,CAAN;AACF;AACE,mBAAOoE,QAAQsF,cAAcpF,MAAd,EAAsB2J,aAAtB,CAAR,CAAP;AAJJ;AAMD,OAZH,EAaGrM,KAbH,CAaS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAfH;AAgBD,KAjBM,CAAP;AAkBD,GApBD;;AAsBA2E,cAAYuY,kCAAZ,GAAiD,UAAUlf,WAAV,EAAuBwS,cAAvB,EAAuC;AAAA;;AACtFlN,WAAOyC,KAAP,yCAAmD/H,WAAnD,UAAmEwS,cAAnE;AACA,WAAO,IAAItN,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,aACG8V,OADH,CACW;AACPnX,eAAO;AACLrK,gBAASwC,WADJ;AAEL6C,mBAAS;AACPsc,mBAAU3M,cAAV;AADO;AAFJ,SADA;AAOPyM,eAAO,CAAC,CAAC,QAAD,EAAW,KAAX,CAAD;AAPA,OADX,EAUGha,IAVH,CAUQ,kBAAU;AACd,gBAAQkE,OAAO6F,MAAf;AACE,eAAK,CAAL;AACE,mBAAO/F,QAAQ,IAAR,CAAP;AACF;AAAS;AACP,mBAAOA,QAAQE,OAAO,CAAP,EAAUtG,OAAlB,CAAP;AAJJ;AAMD,OAjBH,EAkBG4D,KAlBH,CAkBS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OApBH;AAqBD,KAtBM,CAAP;AAuBD,GAzBD;;AA2BA2E,cAAYyY,+BAAZ,GAA8C,UAAUpf,WAAV,EAAuB;AAAA;;AACnEsF,WAAOyC,KAAP,sCAAgD/H,WAAhD;AACA,WAAO,IAAIkF,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,aACG8V,OADH,CACW;AACPnX,eAAO,EAAErK,MAAMwC,WAAR,EADA;AAEPif,eAAO,CAAC,CAAC,iBAAD,EAAoB,MAApB,CAAD,EAA8B,CAAC,QAAD,EAAW,KAAX,CAA9B;AAFA,OADX,EAKGha,IALH,CAKQ,kBAAU;AACd,gBAAQkE,OAAO6F,MAAf;AACE,eAAK,CAAL;AACE,mBAAO/F,QAAQ,IAAR,CAAP;AACF;AACE,mBAAOA,QAAQE,OAAO,CAAP,EAAUtG,OAAlB,CAAP;AAJJ;AAMD,OAZH,EAaG4D,KAbH,CAaS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAfH;AAgBD,KAjBM,CAAP;AAkBD,GApBD;;AAsBA2E,cAAY0Y,qBAAZ,GAAoC,UAAU7hB,IAAV,EAAgBqF,OAAhB,EAAyB;AAAA;;AAC3DyC,WAAOyC,KAAP,4BAAsCvK,IAAtC,UAA+CqF,OAA/C;AACA,WAAO,IAAIqC,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,aAAKtB,OAAL,CAAa;AACXC,eAAO,EAACrK,UAAD,EAAOqF,gBAAP;AADI,OAAb,EAGGoC,IAHH,CAGQ,kBAAU;AACd,YAAI,CAACkE,MAAL,EAAa;AACX,iBAAOF,QAAQ,IAAR,CAAP;AACD;AACDA,gBAAQpG,OAAR;AACD,OARH,EASG4D,KATH,CASS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAXH;AAYD,KAbM,CAAP;AAcD,GAhBD;;AAkBA2E,cAAYkM,gBAAZ,GAA+B,UAAU7S,WAAV,EAAuBwS,cAAvB,EAAuC;AACpElN,WAAOyC,KAAP,uBAAiC/H,WAAjC,UAAiDwS,cAAjD;AACA,QAAIA,kBAAmBA,eAAexD,MAAf,KAA0B,EAAjD,EAAsD;AAAG;AACvD,aAAO,KAAKqQ,qBAAL,CAA2Brf,WAA3B,EAAwCwS,cAAxC,CAAP;AACD,KAFD,MAEO,IAAIA,kBAAkBA,eAAexD,MAAf,GAAwB,EAA9C,EAAkD;AAAG;AAC1D,aAAO,KAAKkQ,kCAAL,CAAwClf,WAAxC,EAAqDwS,cAArD,CAAP;AACD,KAFM,MAEA;AACL,aAAO,KAAK4M,+BAAL,CAAqCpf,WAArC,CAAP,CADK,CACsD;AAC5D;AACF,GATD;;AAWA,SAAO2G,WAAP;AACD,CAvMD,C;;;;;;;;;ACHAvI,OAAOC,OAAP,GAAiB,UAACwH,SAAD,QAA2B;AAAA,MAAb0X,MAAa,QAAbA,MAAa;;AAC1C,MAAM3W,UAAUf,UAAU+X,MAAV,CACd,SADc,EAEd;AACE5d,iBAAa;AACXb,YAAWoe,MADA;AAEXwB,iBAAW;AAFA,KADf;AAKEvM,oBAAgB;AACdrT,YAAWoe,MADG;AAEdwB,iBAAW;AAFG;AALlB,GAFc,EAYd;AACEH,qBAAiB;AADnB,GAZc,CAAhB;;AAiBAhY,UAAQU,SAAR,GAAoB,cAAM;AACxBV,YAAQiY,SAAR,CAAkBjZ,GAAGoB,IAArB;AACAJ,YAAQ0Y,MAAR,CAAe1Z,GAAGe,WAAlB;AACD,GAHD;;AAKA,SAAOC,OAAP;AACD,CAxBD,C;;;;;;;;;ACAA,IAAMtB,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;eAC0B,mBAAAA,CAAQ,EAAR,C;IAAlBkJ,a,YAAAA,a;;gBACgB,mBAAAlJ,CAAQ,CAAR,C;IAAhBrH,K,aAAAA,K;IAAOV,I,aAAAA,I;;IACPY,gB,GAAqBF,K,CAArBE,gB;;;AAER,SAASqhB,qCAAT,CAAgD9N,WAAhD,EAA6D;AAC3D,UAAQA,WAAR;AACE,SAAK,YAAL;AACA,SAAK,WAAL;AACE,aAAO,MAAP;AACF,SAAK,WAAL;AACE,aAAO,KAAP;AACF,SAAK,WAAL;AACE,aAAO,KAAP;AACF,SAAK,WAAL;AACE,aAAO,KAAP;AACF;AACEnM,aAAOyC,KAAP,CAAa,kDAAb;AACA,aAAO,MAAP;AAZJ;AAcD;;AAED,SAASyX,kBAAT,CAA6BC,eAA7B,EAA8CvhB,gBAA9C,EAAgE;AAC9D,MAAIuhB,oBAAoB,EAAxB,EAA4B;AAC1B,WAAOvhB,gBAAP;AACD;AACD,SAAOuhB,eAAP;AACD;;AAED,SAASC,gBAAT,CAA2B1hB,KAA3B,EAAkC;AAChC;AACAA,QAAM,WAAN,IAAqBwhB,mBAAmBxhB,MAAMuR,SAAzB,EAAoCrR,gBAApC,CAArB;AACAF,QAAM,SAAN,IAAmBuhB,sCAAsCvhB,MAAMyT,WAA5C,CAAnB;AACAzT,QAAM,MAAN,IAAgBV,KAAKG,IAArB;AACA,SAAOO,KAAP;AACD;;AAEDI,OAAOC,OAAP,GAAiB,UAACwH,SAAD,QAA4D;AAAA,MAA9C0X,MAA8C,QAA9CA,MAA8C;AAAA,MAAtCC,OAAsC,QAAtCA,OAAsC;AAAA,MAA7BC,OAA6B,QAA7BA,OAA6B;AAAA,MAApBC,IAAoB,QAApBA,IAAoB;AAAA,MAAdC,OAAc,QAAdA,OAAc;;AAC3E,MAAM9W,QAAQhB,UAAU+X,MAAV,CACZ,OADY,EAEZ;AACEpM,aAAS;AACPrS,YAASoe,MADF;AAEPM,eAAS;AAFF,KADX;AAKEtT,YAAQ;AACNpL,YAASwe,QAAQ,EAAR,EAAY,CAAZ,CADH;AAENE,eAAS;AAFH,KALV;AASEhb,aAAS;AACP1D,YAASoe,MADF;AAEPM,eAAS;AAFF,KATX;AAaEC,mBAAe;AACb3e,YAASse,OADI;AAEbI,eAAS;AAFI,KAbjB;AAiBEE,kBAAc;AACZ5e,YAASqe,OADG;AAEZK,eAAS;AAFG,KAjBhB;AAqBEG,WAAO;AACL7e,YAASse,OADJ;AAELI,eAAS;AAFJ,KArBT;AAyBEI,qBAAiB;AACf9e,YAASwe,QAAQ,EAAR,EAAY,CAAZ,CADM;AAEfE,eAAS;AAFM,KAzBnB;AA6BEK,kBAAc;AACZ/e,YAASqe,OADG;AAEZK,eAAS;AAFG,KA7BhB;AAiCEtM,YAAQ;AACNpS,YAASse,OADH;AAENI,eAAS;AAFH,KAjCV;AAqCEM,SAAK;AACHhf,YAASue,KAAK,MAAL,CADN;AAEHG,eAAS;AAFN,KArCP;AAyCErgB,UAAM;AACJ2B,YAASoe,MADL;AAEJM,eAAS;AAFL,KAzCR;AA6CEO,UAAM;AACJjf,YAASse,OADL;AAEJI,eAAS;AAFL,KA7CR;AAiDEQ,UAAM;AACJlf,YAASoe,MADL;AAEJM,eAAS;AAFL,KAjDR;AAqDES,mBAAe;AACbnf,YAASse,OADI;AAEbI,eAAS;AAFI,KArDjB;AAyDEvM,cAAU;AACRnS,YAASoe,MADD;AAERM,eAAS;AAFD,KAzDZ;AA6DEW,eAAW;AACTrf,YAASoe,MADA;AAETM,eAAS;AAFA,KA7Db;AAiEE8B,mBAAe;AACbxgB,YAASoe,MADI;AAEbM,eAAS;AAFI,KAjEjB;AAqEEpN,YAAQ;AACNtR,YAASoe,MADH;AAENM,eAAS;AAFH,KArEV;AAyEEngB,iBAAa;AACXyB,YAASue,KAAK,MAAL,CADE;AAEXG,eAAS;AAFE,KAzEf;AA6EEnN,cAAU;AACRvR,YAASoe,MADD;AAERM,eAAS;AAFD,KA7EZ;AAiFEvO,aAAS;AACPnQ,YAASoe,MADF;AAEPM,eAAS;AAFF,KAjFX;AAqFE+B,gBAAY;AACVzgB,YAASoe,MADC;AAEVM,eAAS;AAFC,KArFd;AAyFExO,UAAM;AACJlQ,YAASqe,OADL;AAEJK,eAAS;AAFL,KAzFR;AA6FEgC,aAAS;AACP1gB,YAASoe,MADF;AAEPM,eAAS;AAFF,KA7FX;AAiGEtO,eAAW;AACTpQ,YAASoe,MADA;AAETM,eAAS;AAFA,KAjGb;AAqGEtgB,WAAO;AACL4B,YAASoe,MADJ;AAELM,eAAS;AAFJ,KArGT;AAyGEiC,qBAAiB;AACf3gB,YAASoe,MADM;AAEfM,eAAS;AAFM,KAzGnB;AA6GEpM,iBAAa;AACXtS,YAASoe,MADE;AAEXM,eAAS;AAFE,KA7Gf;AAiHEkC,YAAQ;AACN5gB,YAASoe,MADH;AAENM,eAAS;AAFH,KAjHV;AAqHEmC,gBAAY;AACV7gB,YAASoe,MADC;AAEVM,eAAS;AAFC,KArHd;AAyHEoC,mBAAe;AACb9gB,YAASoe,MADI;AAEbM,eAAS;AAFI,KAzHjB;AA6HEqC,mBAAe;AACb/gB,YAASoe,MADI;AAEbM,eAAS;AAFI,KA7HjB;AAiIEU,kBAAc;AACZpf,YAASoe,MADG;AAEZM,eAAS;AAFG,KAjIhB;AAqIE7d,iBAAa;AACXb,YAAWoe,MADA;AAEXwB,iBAAW,IAFA;AAGXlB,eAAW;AAHA;AArIf,GAFY,EA6IZ;AACEe,qBAAiB;AADnB,GA7IY,CAAd;;AAkJA/X,QAAMS,SAAN,GAAkB,cAAM;AACtBT,UAAMgY,SAAN,CAAgBjZ,GAAGkB,IAAnB,EAAyB;AACvBgY,kBAAY;AACVC,mBAAW;AADD;AADW,KAAzB;AAKD,GAND;;AAQAlY,QAAMwW,8BAAN,GAAuC,UAAUxa,OAAV,EAAmBoH,SAAnB,EAA8B;AAAA;;AACnE3E,WAAOyC,KAAP,+CAAyDkC,SAAzD,SAAsEpH,OAAtE;AACA,WAAO,IAAIqC,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,YACG8V,OADH,CACW;AACPnX,eAAO,EAAErK,MAAMyM,SAAR,EADA;AAEPgV,eAAO,CAAC,CAAC,QAAD,EAAW,KAAX,CAAD;AAFA,OADX,EAKGha,IALH,CAKQ,kBAAU;AACd,gBAAQkE,OAAO6F,MAAf;AACE,eAAK,CAAL;AACE,kBAAM,IAAInK,KAAJ,CAAU,wCAAV,CAAN;AACF;AACEoE,oBAAQsF,cAAcpF,MAAd,EAAsBtG,OAAtB,CAAR;AAJJ;AAMD,OAZH,EAaG4D,KAbH,CAaS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAfH;AAgBD,KAjBM,CAAP;AAkBD,GApBD;;AAsBA6E,QAAMwM,mBAAN,GAA4B,UAAUb,cAAV,EAA0B;AAAA;;AACpDlN,WAAOyC,KAAP,oCAA8CyK,cAA9C;AACA,WAAO,IAAItN,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,aACG8V,OADH,CACW;AACPnX,eAAO,EAAE8X,eAAenN,cAAjB,EADA;AAEPyM,eAAO,CAAC,CAAC,QAAD,EAAW,KAAX,CAAD,CAFA;AAGPkB,aAAO,IAHA,CAGO;AAHP,OADX,EAMGlb,IANH,CAMQ,8BAAsB;AAC1B;AACA,gBAAQqO,mBAAmBtE,MAA3B;AACE,eAAK,CAAL;AACE,mBAAO/F,QAAQ,IAAR,CAAP;AACF;AACEqK,+BAAmBlM,OAAnB,CAA2B,iBAAS;AAClCpJ,oBAAM,SAAN,IAAmBuhB,sCAAsCvhB,MAAMyT,WAA5C,CAAnB;AACAzT,oBAAM,WAAN,IAAqBwhB,mBAAmBxhB,MAAMuR,SAAzB,EAAoCrR,gBAApC,CAArB;AACA,qBAAOF,KAAP;AACD,aAJD;AAKA,mBAAOiL,QAAQqK,kBAAR,CAAP;AATJ;AAWD,OAnBH,EAoBG7M,KApBH,CAoBS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAtBH;AAuBD,KAxBM,CAAP;AAyBD,GA3BD;;AA6BA6E,QAAMkM,yBAAN,GAAkC,UAAUP,cAAV,EAA0BvI,SAA1B,EAAqC;AAAA;;AACrE3E,WAAOyC,KAAP,iCAA2CkC,SAA3C,sBAAqEuI,cAArE;AACA,WAAO,IAAItN,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,aACG8V,OADH,CACW;AACPnX,eAAO,EAAErK,MAAMyM,SAAR,EAAmB0V,eAAenN,cAAlC,EADA;AAEPyM,eAAO,CAAC,CAAC,IAAD,EAAO,KAAP,CAAD;AAFA,OADX,EAKGha,IALH,CAKQ,kBAAU;AACd,gBAAQkE,OAAO6F,MAAf;AACE,eAAK,CAAL;AACE,mBAAO/F,QAAQ,IAAR,CAAP;AACF,eAAK,CAAL;AACE,mBAAOA,QAAQE,OAAO,CAAP,EAAUtG,OAAlB,CAAP;AACF;AACEyC,mBAAOtD,KAAP,CAAgBmH,OAAO6F,MAAvB,4BAAoD/E,SAApD,sBAA8EuI,cAA9E;AACA,mBAAOvJ,QAAQE,OAAO,CAAP,EAAUtG,OAAlB,CAAP;AAPJ;AASD,OAfH,EAgBG4D,KAhBH,CAgBS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAlBH;AAmBD,KApBM,CAAP;AAqBD,GAvBD;;AAyBA6E,QAAMuZ,8BAAN,GAAuC,UAAU5iB,IAAV,EAAgBkD,OAAhB,EAAyB;AAAA;;AAC9D,WAAO,IAAIwE,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,aACG8V,OADH,CACW;AACPnX,eAAO;AACLrK,oBADK;AAELqF,mBAAS;AACPsc,mBAAUze,OAAV;AADO,WAFJ,EADA;AAMPue,eAAO,CAAC,CAAC,QAAD,EAAW,KAAX,CAAD;AANA,OADX,EASGha,IATH,CASQ,kBAAU;AACd,gBAAQkE,OAAO6F,MAAf;AACE,eAAK,CAAL;AACE,mBAAO/F,QAAQ,IAAR,CAAP;AACF;AAAS;AACP,mBAAOA,QAAQE,OAAO,CAAP,EAAUtG,OAAlB,CAAP;AAJJ;AAMD,OAhBH,EAiBG4D,KAjBH,CAiBS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAnBH;AAoBD,KArBM,CAAP;AAsBD,GAvBD;;AAyBA6E,QAAMwZ,4BAAN,GAAqC,UAAU7iB,IAAV,EAAgB;AAAA;;AACnD,WAAO,IAAI0H,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,aACG8V,OADH,CACW;AACPnX,eAAO,EAAErK,UAAF,EADA;AAEPyhB,eAAO,CAAC,CAAC,iBAAD,EAAoB,MAApB,CAAD,EAA8B,CAAC,QAAD,EAAW,KAAX,CAA9B,CAFA,CAEmD;AAFnD,OADX,EAKGha,IALH,CAKQ,kBAAU;AACdK,eAAOyC,KAAP,CAAa,kBAAb,EAAiCoB,OAAO6F,MAAxC;AACA,gBAAQ7F,OAAO6F,MAAf;AACE,eAAK,CAAL;AACE,mBAAO/F,QAAQ,IAAR,CAAP;AACF;AACE,mBAAOA,QAAQE,OAAO,CAAP,EAAUsK,UAAV,CAAqB5Q,OAA7B,CAAP;AAJJ;AAMD,OAbH,EAcG4D,KAdH,CAcS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAhBH;AAiBD,KAlBM,CAAP;AAmBD,GApBD;;AAsBA6E,QAAMyZ,mBAAN,GAA4B,UAAU9iB,IAAV,EAAgBqF,OAAhB,EAAyB;AAAA;;AACnD,WAAO,IAAIqC,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,aAAKtB,OAAL,CAAa;AACXC,eAAO,EAACrK,UAAD,EAAOqF,gBAAP;AADI,OAAb,EAGGoC,IAHH,CAGQ,kBAAU;AACd,YAAI,CAACkE,MAAL,EAAa;AACX,iBAAOF,QAAQ,IAAR,CAAP;AACD;AACDA,gBAAQpG,OAAR;AACD,OARH,EASG4D,KATH,CASS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAXH;AAYD,KAbM,CAAP;AAcD,GAfD;;AAiBA6E,QAAM8L,cAAN,GAAuB,UAAU1I,SAAV,EAAqBpH,OAArB,EAA8B;AACnDyC,WAAOyC,KAAP,qBAA+BkC,SAA/B,UAA6CpH,OAA7C;AACA,QAAIA,WAAYA,QAAQmM,MAAR,KAAmB,EAAnC,EAAwC;AAAG;AACzC,aAAO,KAAKsR,mBAAL,CAAyBrW,SAAzB,EAAoCpH,OAApC,CAAP;AACD,KAFD,MAEO,IAAIA,WAAWA,QAAQmM,MAAR,GAAiB,EAAhC,EAAoC;AACzC,aAAO,KAAKoR,8BAAL,CAAoCnW,SAApC,EAA+CpH,OAA/C,CAAP,CADyC,CACwB;AAClE,KAFM,MAEA;AACL,aAAO,KAAKwd,4BAAL,CAAkCpW,SAAlC,CAAP,CADK,CACiD;AACvD;AACF,GATD;;AAWApD,QAAM8V,YAAN,GAAqB,UAAUnf,IAAV,EAAgBqF,OAAhB,EAAyB;AAAA;;AAC5CyC,WAAOyC,KAAP,0BAAoCvK,IAApC,SAA4CqF,OAA5C;AACA,WAAO,IAAIqC,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,aACG8V,OADH,CACW;AACPnX,eAAO,EAAErK,UAAF,EAAQqF,gBAAR;AADA,OADX,EAIGoC,IAJH,CAIQ,sBAAc;AAClBK,eAAOyC,KAAP,CAAa,0BAAb,EAAyCwY,WAAWvR,MAApD;AACA,gBAAQuR,WAAWvR,MAAnB;AACE,eAAK,CAAL;AACE,mBAAO/F,QAAQ,IAAR,CAAP;AACF,eAAK,CAAL;AACE,mBAAOA,QAAQyW,iBAAiBa,WAAW,CAAX,EAAc9M,UAA/B,CAAR,CAAP;AACF;AACEnO,mBAAOtD,KAAP,6CAAuDxE,IAAvD,uBAA6EqF,OAA7E;AACA,mBAAOoG,QAAQyW,iBAAiBa,WAAW,CAAX,EAAc9M,UAA/B,CAAR,CAAP;AAPJ;AASD,OAfH,EAgBGhN,KAhBH,CAgBS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAlBH;AAmBD,KApBM,CAAP;AAqBD,GAvBD;;AAyBA,SAAO6E,KAAP;AACD,CA5UD,C;;;;;;;;;ACrCAzI,OAAOC,OAAP,GAAiB,UAACwH,SAAD,QAA6C;AAAA,MAA/B0X,MAA+B,QAA/BA,MAA+B;AAAA,MAAvBC,OAAuB,QAAvBA,OAAuB;AAAA,MAAdC,OAAc,QAAdA,OAAc;;AAC5D,MAAM3W,OAAOjB,UAAU+X,MAAV,CACX,MADW,EAEX;AACEpgB,UAAM;AACJ2B,YAAWoe,MADP;AAEJwB,iBAAW;AAFP,KADR;AAKElc,aAAS;AACP1D,YAAWoe,MADJ;AAEPwB,iBAAW;AAFJ,KALX;AASEvN,aAAS;AACPrS,YAAWoe,MADJ;AAEPwB,iBAAW;AAFJ,KATX;AAaEzN,cAAU;AACRnS,YAAWoe,MADH;AAERwB,iBAAW;AAFH,KAbZ;AAiBExN,YAAQ;AACNpS,YAAWse,OADL;AAENsB,iBAAW,KAFL;AAGNlB,eAAW;AAHL,KAjBV;AAsBE/N,cAAU;AACR3Q,YAAWoe,MADH;AAERwB,iBAAW;AAFH,KAtBZ;AA0BEhP,cAAU;AACR5Q,YAAWoe,MADH;AAERwB,iBAAW;AAFH,KA1BZ;AA8BE/O,cAAU;AACR7Q,YAAMoe;AADE,KA9BZ;AAiCElO,UAAM;AACJlQ,YAAcqe,OADV;AAEJuB,iBAAc,KAFV;AAGJyB,oBAAc;AAHV,KAjCR;AAsCEC,sBAAkB;AAChBthB,YAAcqe,OADE;AAEhBuB,iBAAc,KAFE;AAGhByB,oBAAc;AAHE;AAtCpB,GAFW,EA8CX;AACE5B,qBAAiB;AADnB,GA9CW,CAAb;;AAmDA9X,OAAKQ,SAAL,GAAiB,cAAM;AACrBR,SAAK4Z,OAAL,CAAa9a,GAAGmB,OAAhB;AACAD,SAAKwY,MAAL,CAAY1Z,GAAGiB,KAAf;AACD,GAHD;;AAKAC,OAAK6Z,eAAL,GAAuB,YAAY;AACjC,WAAO,KAAK3B,OAAL,CAAa;AAClBnX,aAAO,EAAEwH,MAAM,KAAR,EAAeoR,kBAAkB,IAAjC,EADW;AAElBxB,aAAO,CAAC,CAAC,WAAD,EAAc,MAAd,CAAD,CAFW;AAGlB2B,aAAO;AAHW,KAAb,CAAP;AAKD,GAND;;AAQA,SAAO9Z,IAAP;AACD,CAlED,C;;;;;;;;;ACAA1I,OAAOC,OAAP,GAAiB,UAACwH,SAAD,QAA0C;AAAA,MAA5B0X,MAA4B,QAA5BA,MAA4B;AAAA,MAApBC,OAAoB,QAApBA,OAAoB;AAAA,MAAXE,IAAW,QAAXA,IAAW;;AACzD,MAAM3W,UAAUlB,UAAU+X,MAAV,CACd,SADc,EAEd;AACEiD,YAAQ;AACN1hB,YAAWoe,MADL;AAENwB,iBAAW;AAFL,KADV;AAKEja,SAAK;AACH3F,YAAWoe,MADR;AAEHwB,iBAAW;AAFR,KALP;AASE+B,eAAW;AACT3hB,YAAWoe,MADF;AAETwB,iBAAW;AAFF,KATb;AAaE5V,YAAQ;AACNhK,YAAWue,KAAK,MAAL,CADL;AAENqB,iBAAW,IAFL;AAGNlB,eAAW;AAHL;AAbV,GAFc,EAqBd;AACEe,qBAAiB;AADnB,GArBc,CAAhB;;AA0BA7X,UAAQO,SAAR,GAAoB,cAAM;AACxBP,YAAQ8X,SAAR,CAAkBjZ,GAAGkB,IAArB,EAA2B;AACzBgY,kBAAY;AACVC,mBAAW;AADD;AADa,KAA3B;AAKD,GAND;;AAQA,SAAOhY,OAAP;AACD,CApCD,C;;;;;;;ACAA;;AACA,IAAMga,SAAS,mBAAA1b,CAAQ,EAAR,CAAf;AACA,IAAMC,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;AAEAjH,OAAOC,OAAP,GAAiB,UAACwH,SAAD,QAA2B;AAAA,MAAb0X,MAAa,QAAbA,MAAa;;AAC1C,MAAMvW,OAAOnB,UAAU+X,MAAV,CACX,MADW,EAEX;AACE5E,cAAU;AACR7Z,YAAWoe,MADH;AAERwB,iBAAW;AAFH,KADZ;AAKEpZ,cAAU;AACRxG,YAAWoe,MADH;AAERwB,iBAAW;AAFH;AALZ,GAFW,EAYX;AACEH,qBAAiB;AADnB,GAZW,CAAb;;AAiBA5X,OAAKM,SAAL,GAAiB,cAAM;AACrBN,SAAKsY,MAAL,CAAY1Z,GAAGgB,OAAf;AACD,GAFD;;AAIAI,OAAKga,SAAL,CAAenF,eAAf,GAAiC,UAAUlW,QAAV,EAAoB;AACnD,WAAOob,OAAOE,OAAP,CAAetb,QAAf,EAAyB,KAAKA,QAA9B,CAAP;AACD,GAFD;;AAIAqB,OAAKga,SAAL,CAAeE,cAAf,GAAgC,UAAUC,WAAV,EAAuB;AAAA;;AACrD,WAAO,IAAIjc,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC;AACA6X,aAAOK,OAAP,CAAe,UAACC,SAAD,EAAYC,IAAZ,EAAqB;AAClC,YAAID,SAAJ,EAAe;AACb/b,iBAAOtD,KAAP,CAAa,YAAb,EAA2Bqf,SAA3B;AACAnY,iBAAOmY,SAAP;AACA;AACD;AACD;AACAN,eAAOQ,IAAP,CAAYJ,WAAZ,EAAyBG,IAAzB,EAA+B,UAACE,SAAD,EAAYD,IAAZ,EAAqB;AAClD;AACA,cAAIC,SAAJ,EAAe;AACblc,mBAAOtD,KAAP,CAAa,YAAb,EAA2Bwf,SAA3B;AACAtY,mBAAOsY,SAAP;AACA;AACD;AACD;AACA,gBACGxZ,MADH,CACU,EAACrC,UAAU4b,IAAX,EADV,EAEGtc,IAFH,CAEQ,YAAM;AACVgE;AACD,WAJH,EAKGxC,KALH,CAKS,iBAAS;AACdyC,mBAAOlH,KAAP;AACD,WAPH;AAQD,SAhBD;AAiBD,OAxBD;AAyBD,KA3BM,CAAP;AA4BD,GA7BD;;AA+BA;AACAgF,OAAKya,IAAL,CAAU,cAAV,EAA0B,UAAC3I,IAAD,EAAO/T,OAAP,EAAmB;AAC3CO,WAAOyC,KAAP,CAAa,2BAAb;AACA,WAAO,IAAI7C,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC;AACA6X,aAAOK,OAAP,CAAe,UAACC,SAAD,EAAYC,IAAZ,EAAqB;AAClC,YAAID,SAAJ,EAAe;AACb/b,iBAAOtD,KAAP,CAAa,YAAb,EAA2Bqf,SAA3B;AACAnY,iBAAOmY,SAAP;AACA;AACD;AACD;AACAN,eAAOQ,IAAP,CAAYzI,KAAKnT,QAAjB,EAA2B2b,IAA3B,EAAiC,UAACE,SAAD,EAAYD,IAAZ,EAAqB;AACpD;AACA,cAAIC,SAAJ,EAAe;AACblc,mBAAOtD,KAAP,CAAa,YAAb,EAA2Bwf,SAA3B;AACAtY,mBAAOsY,SAAP;AACA;AACD;AACD;AACA1I,eAAKnT,QAAL,GAAgB4b,IAAhB;AACAtY;AACD,SAVD;AAWD,OAlBD;AAmBD,KArBM,CAAP;AAsBD,GAxBD;;AA0BA,SAAOjC,IAAP;AACD,CArFD,C;;;;;;ACJA,mC;;;;;;;;;;;ACAA,IAAM1B,SAAS,mBAAAD,CAAQ,CAAR,CAAf;AACA,IAAMO,KAAK,mBAAAP,CAAQ,EAAR,CAAX;AACA,IAAMsV,UAAU,mBAAAtV,CAAQ,EAAR,CAAhB;AACA,IAAMqc,iBAAiB,mBAAArc,CAAQ,EAAR,CAAvB;AACA,IAAMqP,SAAS,mBAAArP,CAAQ,CAAR,CAAf;;AAEAjH,OAAOC,OAAP,GAAiB;AACfV,SADe,mBACN4L,aADM,EACSuG,QADT,EACmBE,QADnB,EAC6B;AAC1C,WAAO,IAAI9K,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,UAAIyY,uBAAJ;AAAA,UAAoBhC,sBAApB;AAAA,UAAmC3f,oBAAnC;AACA;AACA,aAAO2a,QAAQrR,YAAR,CAAqBC,aAArB,EACJtE,IADI,CACC,cAAM;AACVK,eAAOkB,IAAP,6BAAsC+C,cAAc/L,IAApD,SAA4DsS,QAA5D,EAAwEmL,EAAxE;AACA0G,yBAAiB1G,EAAjB;AACA;AACA,YAAI1R,cAAce,YAAlB,EAAgC;AAC9BhF,iBAAOyC,KAAP,2CAAqDwB,cAAce,YAAnE;AACA,iBAAO1E,GAAGgB,OAAH,CAAWgB,OAAX,CAAmB,EAACC,OAAO,EAAC7H,aAAauJ,cAAce,YAA5B,EAAR,EAAnB,CAAP;AACD,SAHD,MAGO;AACLhF,iBAAOyC,KAAP,CAAa,2CAAb;AACA,iBAAO,IAAP;AACD;AACF,OAZI,EAaJ9C,IAbI,CAaC,mBAAW;AACjB;AACE0a,wBAAgB,IAAhB;AACA3f,sBAAc,IAAd;AACA,YAAIN,OAAJ,EAAa;AACXigB,0BAAgBjgB,QAAQ8S,cAAxB;AACAxS,wBAAcN,QAAQM,WAAtB;AACD;AACDsF,eAAOyC,KAAP,qBAA+B4X,aAA/B;AACD,OAtBI,EAuBJ1a,IAvBI,CAuBC,YAAM;AACZ;AACE,YAAM6X,aAAa;AACjBtf,gBAAa+L,cAAc/L,IADV;AAEjBqF,mBAAa8e,eAAezG,QAFX;AAGjB3d,iBAAagM,cAAciH,QAAd,CAAuBjT,KAHnB;AAIjBG,uBAAa6L,cAAciH,QAAd,CAAuB9S,WAJnB;AAKjB8T,mBAAajI,cAAcoH,aALV;AAMjBW,oBAAgBqQ,eAAetD,IAA/B,SAAuCsD,eAAevD,IANrC;AAOjB7M,kBAAa,CAPI;AAQjBzB,4BARiB;AASjBC,oBAAaxG,cAAc+G,SATV;AAUjBN,4BAViB;AAWjBX,gBAAa9F,cAAciH,QAAd,CAAuBnB;AAXnB,SAAnB;AAaA;AACA,YAAMuS,cAAc;AAClBpkB,gBAAa+L,cAAc/L,IADT;AAElBqF,mBAAa8e,eAAezG,QAFV;AAGlB3d,iBAAagM,cAAciH,QAAd,CAAuBjT,KAHlB;AAIlBG,uBAAa6L,cAAciH,QAAd,CAAuB9S,WAJlB;AAKlB8T,mBAAajI,cAAcoH,aALT;AAMlBpB,qBAAahG,cAAciH,QAAd,CAAuBjB,SANlB;AAOlB+B,oBAAgBqQ,eAAetD,IAA/B,SAAuCsD,eAAevD,IAPpC;AAQlB7M,kBAAa,CARK;AASlBE,uBAAazB,QATK;AAUlBX,gBAAa9F,cAAciH,QAAd,CAAuBnB,IAVlB;AAWlB9E,kBAAahB,cAAcgH,GAXT;AAYlBoP,sCAZkB;AAalB3f;AAbkB,SAApB;AAeA;AACA,YAAM6hB,iBAAiB;AACrBrkB,gBAAS+L,cAAc/L,IADF;AAErBqF,mBAAS8e,eAAezG;AAFH,SAAvB;AAIA;AACA,eAAOhW,QAAQC,GAAR,CAAY,CAACS,GAAG2B,MAAH,CAAU3B,GAAGkB,IAAb,EAAmBgW,UAAnB,EAA+B+E,cAA/B,EAA+C,MAA/C,CAAD,EAAyDjc,GAAG2B,MAAH,CAAU3B,GAAGiB,KAAb,EAAoB+a,WAApB,EAAiCC,cAAjC,EAAiD,OAAjD,CAAzD,CAAZ,CAAP;AACD,OA7DI,EA8DJ5c,IA9DI,CA8DC,gBAAmB;AAAA;AAAA,YAAjB/F,IAAiB;AAAA,YAAXlB,KAAW;;AACvBsH,eAAOyC,KAAP,CAAa,6CAAb;AACA,eAAO7C,QAAQC,GAAR,CAAY,CAACjG,KAAK4iB,QAAL,CAAc9jB,KAAd,CAAD,EAAuBA,MAAM+jB,OAAN,CAAc7iB,IAAd,CAAvB,CAAZ,CAAP;AACD,OAjEI,EAkEJ+F,IAlEI,CAkEC,YAAM;AACVK,eAAOyC,KAAP,CAAa,gDAAb;AACAkB,gBAAQ0Y,cAAR,EAFU,CAEe;AAC1B,OArEI,EAsEJlb,KAtEI,CAsEE,iBAAS;AACdnB,eAAOtD,KAAP,CAAa,eAAb,EAA8BA,KAA9B;AACA0f,uBAAe5Q,mBAAf,CAAmCvH,cAAc+G,SAAjD,EAFc,CAE+C;AAC7DpH,eAAOlH,KAAP;AACD,OA1EI,CAAP;AA2ED,KA9EM,CAAP;AA+ED,GAjFc;AAkFfqa,sBAlFe,gCAkFO7e,IAlFP,EAkFa;AAC1B;AACA,WAAOoI,GAAGkB,IAAH,CAAQkY,OAAR,CAAgB,EAAEnX,OAAO,EAAErK,UAAF,EAAT,EAAhB,EACJyH,IADI,CACC,kBAAU;AACd,UAAIkE,OAAO6F,MAAP,IAAiB,CAArB,EAAwB;AACtB,YAAMgT,eAAetN,OAAOvF,MAAP,CAAcyB,gBAAnC;AACA;AACA,YAAMqR,iBAAiB9Y,OAAO8F,MAAP,CAAc,UAACjR,KAAD,EAAW;AAC9C,iBAAQA,MAAMwT,OAAN,KAAkBwQ,YAA1B;AACD,SAFsB,CAAvB;AAGA;AACA,YAAIC,eAAejT,MAAf,IAAyB,CAA7B,EAAgC;AAC9B,gBAAM,IAAInK,KAAJ,CAAU,8BAAV,CAAN;AACD;AACD,eAAOrH,IAAP;AACD;AACD,aAAOA,IAAP;AACD,KAfI,CAAP;AAgBD,GApGc;AAqGf8e,0BArGe,oCAqGW9e,IArGX,EAqGiB;AAC9B,WAAO,IAAI0H,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC;AACAtD,SAAGgB,OAAH,CAAWoY,OAAX,CAAmB,EAAEnX,OAAO,EAAE7H,aAAaxC,IAAf,EAAT,EAAnB,EACGyH,IADH,CACQ,kBAAU;AACd,YAAIkE,OAAO6F,MAAP,IAAiB,CAArB,EAAwB;AACtB,iBAAO/F,QAAQ,KAAR,CAAP;AACD;AACDA,gBAAQ,IAAR;AACD,OANH,EAOGxC,KAPH,CAOS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OATH;AAUD,KAZM,CAAP;AAaD;AAnHc,CAAjB,C;;;;;;ACNA,+B;;;;;;;;;ACAA,IAAM4D,KAAK,mBAAAP,CAAQ,EAAR,CAAX;AACA,IAAMC,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;AAEAjH,OAAOC,OAAP,GAAiB;AACfme,kBADe,4BACGxc,WADH,EACgBkC,SADhB,EAC2B+a,eAD3B,EAC4CnE,IAD5C,EACkD;AAC/D;AACA,QAAI,CAAC9Y,WAAD,IAAgB,CAACkC,SAArB,EAAgC;AAC9B,aAAO;AACLlC,qBAAgB,IADX;AAELwS,wBAAgB;AAFX,OAAP;AAID;AACD;AACA,QAAIsG,IAAJ,EAAU;AACR,UAAI9Y,eAAeA,gBAAgB8Y,KAAK9Y,WAAxC,EAAqD;AACnD,cAAM,IAAI6E,KAAJ,CAAU,2DAAV,CAAN;AACD;AACD,UAAI3C,aAAaA,cAAc4W,KAAKtG,cAApC,EAAoD;AAClD,cAAM,IAAI3N,KAAJ,CAAU,yDAAV,CAAN;AACD;AACD,aAAO;AACL7E,qBAAgB8Y,KAAK9Y,WADhB;AAELwS,wBAAgBsG,KAAKtG;AAFhB,OAAP;AAID;AACD;AACA,QAAI,CAACyK,eAAL,EAAsB,MAAM,IAAIpY,KAAJ,CAAU,8BAAV,CAAN;AACtB,WAAOzG,OAAOC,OAAP,CAAe6jB,8BAAf,CAA8CliB,WAA9C,EAA2DkC,SAA3D,EAAsE+a,eAAtE,CAAP;AACD,GAzBc;AA0BfiF,gCA1Be,0CA0BiBliB,WA1BjB,EA0B8BkC,SA1B9B,EA0ByCigB,YA1BzC,EA0BuD;AACpE,WAAO,IAAIjd,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC;AACA,UAAI8R,oBAAJ;AACA;AACA,UAAIoH,oBAAoB,EAAxB;AACA,UAAIpiB,WAAJ,EAAiBoiB,kBAAkB,aAAlB,IAAmCpiB,WAAnC;AACjB,UAAIkC,SAAJ,EAAekgB,kBAAkB,gBAAlB,IAAsClgB,SAAtC;AACf;AACA0D,SAAGgB,OAAH,CACGgB,OADH,CACW;AACPC,eAAOua;AADA,OADX,EAIGnd,IAJH,CAIQ,mBAAW;AACf,YAAI,CAACvF,OAAL,EAAc;AACZ4F,iBAAOyC,KAAP,CAAa,kBAAb;AACA,gBAAM,IAAIlD,KAAJ,CAAU,+DAAV,CAAN;AACD;AACDmW,sBAActb,QAAQsc,GAAR,EAAd;AACA1W,eAAOyC,KAAP,CAAa,eAAb,EAA8BiT,WAA9B;AACA,eAAOpV,GAAGoB,IAAH,CAAQY,OAAR,CAAgB;AACrBC,iBAAO,EAAEmR,UAAUgC,YAAYhb,WAAZ,CAAwB0O,SAAxB,CAAkC,CAAlC,CAAZ;AADc,SAAhB,CAAP;AAGD,OAdH,EAeGzJ,IAfH,CAeQ,gBAAQ;AACZ,YAAI,CAAC6T,IAAL,EAAW;AACTxT,iBAAOyC,KAAP,CAAa,eAAb;AACA,gBAAM,IAAIlD,KAAJ,CAAU,+DAAV,CAAN;AACD;AACD,eAAOiU,KAAK+C,eAAL,CAAqBsG,YAArB,CAAP;AACD,OArBH,EAsBGld,IAtBH,CAsBQ,mBAAW;AACf,YAAI,CAAC6W,OAAL,EAAc;AACZxW,iBAAOyC,KAAP,CAAa,oBAAb;AACA,gBAAM,IAAIlD,KAAJ,CAAU,+DAAV,CAAN;AACD;AACDS,eAAOyC,KAAP,CAAa,4BAAb;AACAkB,gBAAQ+R,WAAR;AACD,OA7BH,EA8BGvU,KA9BH,CA8BS,iBAAS;AACdyC,eAAOlH,KAAP;AACD,OAhCH;AAiCD,KAzCM,CAAP;AA0CD;AArEc,CAAjB,C;;;;;;;;;ACHA,IAAMqgB,kBAAkB,EAAxB;;AAEAjkB,OAAOC,OAAP,GAAiB;AACf8T,8BADe,wCACenS,WADf,EAC4BiT,kBAD5B,EACgDqP,MADhD,EACwDnf,IADxD,EAC8D;AAC3E,QAAMof,aAAankB,OAAOC,OAAP,CAAemkB,mBAAf,CAAmCF,MAAnC,CAAnB;AACA,QAAMG,iBAAiBrkB,OAAOC,OAAP,CAAeqkB,gBAAf,CAAgCvf,IAAhC,CAAvB;AACA,QAAMwf,WAAW;AACf3iB,mBAAoBA,WADL;AAEfiT,0BAAoBA,kBAFL;AAGfqP,cAAoBlkB,OAAOC,OAAP,CAAeukB,qBAAf,CAAqCN,MAArC,EAA6CG,cAA7C,CAHL;AAIfI,oBAAoBzkB,OAAOC,OAAP,CAAeykB,qBAAf,CAAqCL,cAArC,CAJL;AAKfM,mBAAoBN,cALL;AAMfO,gBAAoB5kB,OAAOC,OAAP,CAAe4kB,iBAAf,CAAiCV,UAAjC,EAA6CE,cAA7C,CANL;AAOfF,kBAAoBA,UAPL;AAQfW,oBAAoB9kB,OAAOC,OAAP,CAAe8kB,oBAAf,CAAoCb,MAApC;AARL,KAAjB;AAUA,WAAOK,QAAP;AACD,GAfc;AAgBfD,kBAhBe,4BAgBGvf,IAhBH,EAgBS;AACtB,QAAIA,IAAJ,EAAU;AACR,aAAOigB,SAASjgB,IAAT,CAAP;AACD;AACD,WAAO,CAAP;AACD,GArBc;AAsBfyf,uBAtBe,iCAsBQN,MAtBR,EAsBgBe,UAtBhB,EAsB4B;AACzC,QAAI,CAACf,MAAL,EAAa;AACX,aAAO,EAAP,CADW,CACC;AACb;AACD;AACA;AACA,QAAMgB,kBAAkB,CAACD,aAAa,CAAd,IAAmBhB,eAA3C;AACA,QAAMkB,gBAAgBD,kBAAkBjB,eAAxC;AACA,QAAMmB,eAAelB,OAAOvT,KAAP,CAAauU,eAAb,EAA8BC,aAA9B,CAArB;AACA,WAAOC,YAAP;AACD,GAhCc;AAiCfhB,qBAjCe,+BAiCMF,MAjCN,EAiCc;AAC3B,QAAI,CAACA,MAAL,EAAa;AACX,aAAO,CAAP;AACD,KAFD,MAEO;AACL,UAAMmB,cAAcnB,OAAOtT,MAA3B;AACA,UAAIyU,cAAcpB,eAAlB,EAAmC;AACjC,eAAO,CAAP;AACD;AACD,UAAMqB,YAAYC,KAAKC,KAAL,CAAWH,cAAcpB,eAAzB,CAAlB;AACA,UAAMwB,YAAYJ,cAAcpB,eAAhC;AACA,UAAIwB,cAAc,CAAlB,EAAqB;AACnB,eAAOH,SAAP;AACD;AACD,aAAOA,YAAY,CAAnB;AACD;AACF,GAhDc;AAiDfZ,uBAjDe,iCAiDQC,WAjDR,EAiDqB;AAClC,QAAIA,gBAAgB,CAApB,EAAuB;AACrB,aAAO,IAAP;AACD;AACD,WAAOA,cAAc,CAArB;AACD,GAtDc;AAuDfE,mBAvDe,6BAuDIV,UAvDJ,EAuDgBQ,WAvDhB,EAuD6B;AAC1C,QAAIA,gBAAgBR,UAApB,EAAgC;AAC9B,aAAO,IAAP;AACD;AACD,WAAOQ,cAAc,CAArB;AACD,GA5Dc;AA6DfI,sBA7De,gCA6DOb,MA7DP,EA6De;AAC5B,QAAI,CAACA,MAAL,EAAa;AACX,aAAO,CAAP;AACD;AACD,WAAOA,OAAOtT,MAAd;AACD;AAlEc,CAAjB,C;;;;;;;;;eCFiB,mBAAA3J,CAAQ,CAAR,C;IAAT/H,I,YAAAA,I;;AACR,IAAMwmB,mBAAmB,mBAAAze,CAAQ,EAAR,CAAzB;;AAEAjH,OAAOC,OAAP,GAAiB,UAACoZ,GAAD,EAAS;AACxB;AACAA,MAAIuE,GAAJ,CAAQ,GAAR,EAAa,UAACtI,GAAD,EAAM/B,GAAN,EAAc;AACzBmS,qBAAiBpQ,GAAjB,EAAsB/B,GAAtB;AACD,GAFD;AAGA;AACA8F,MAAIuE,GAAJ,CAAQ,QAAR,EAAkB,UAACtI,GAAD,EAAM/B,GAAN,EAAc;AAC9BmS,qBAAiBpQ,GAAjB,EAAsB/B,GAAtB;AACD,GAFD;AAGA;AACA8F,MAAIuE,GAAJ,CAAQ,QAAR,EAAkB,UAACtI,GAAD,EAAM/B,GAAN,EAAc;AAC9BmS,qBAAiBpQ,GAAjB,EAAsB/B,GAAtB;AACD,GAFD;AAGA;AACA8F,MAAIuE,GAAJ,CAAQ,WAAR,EAAqB,UAACtI,GAAD,EAAM/B,GAAN,EAAc;AACjCA,QAAI/R,MAAJ,CAAW,GAAX,EAAgBoU,QAAhB,CAAyB,UAAzB;AACD,GAFD;AAGAyD,MAAIuE,GAAJ,CAAQ,UAAR,EAAoB,UAACtI,GAAD,EAAM/B,GAAN,EAAc;AAChCmS,qBAAiBpQ,GAAjB,EAAsB/B,GAAtB;AACD,GAFD;AAGA;AACA8F,MAAIuE,GAAJ,CAAQ,MAAR,EAAgB,UAACtI,GAAD,EAAM/B,GAAN,EAAc;AAC5BmS,qBAAiBpQ,GAAjB,EAAsB/B,GAAtB;AACD,GAFD;AAGA;AACA8F,MAAIuE,GAAJ,CAAQ,uBAAR,EAAiC,gBAAarK,GAAb,EAAqB;AAAA,QAAlB7P,MAAkB,QAAlBA,MAAkB;;AACpD,QAAMe,UAAUf,OAAOe,OAAvB;AACA,QAAMrF,OAAOsE,OAAOtE,IAApB;AACA,QAAMC,OAAOH,KAAKG,IAAlB;AACA;AACAkU,QAAI/R,MAAJ,CAAW,GAAX,EAAgBmkB,MAAhB,CAAuB,OAAvB,EAAgC,EAAEC,QAAQ,OAAV,EAAmBvmB,UAAnB,EAAyBoF,gBAAzB,EAAkCrF,UAAlC,EAAhC;AACD,GAND;AAOD,CAhCD,C;;;;;;;;;;;;;kBC4Be,YAAwC;AAAA,MAA9BgL,KAA8B,uEAAtByb,YAAsB;AAAA,MAARpD,MAAQ;;AACrD,UAAQA,OAAO1hB,IAAf;AACE,SAAKF,QAAQG,aAAb;AACE,aAAO8H,OAAOgd,MAAP,CAAc,EAAd,EAAkBD,YAAlB,EAAgC,EAAG;AACxC/kB,cAAM2hB,OAAOxhB;AADwB,OAAhC,CAAP;AAGF,SAAKJ,QAAQK,UAAb;AACE,aAAO2kB,YAAP;AACF,SAAKhlB,QAAQO,eAAb;AACE,aAAO0H,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9BgI,kBAAUtJ,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,MAAMgI,QAAxB,sBACPqQ,OAAOxhB,IAAP,CAAY7B,IADL,EACYqjB,OAAOxhB,IAAP,CAAYE,KADxB;AADoB,OAAzB,CAAP;AAKF,SAAKN,QAAQQ,YAAb;AACE,aAAOyH,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9BxK,eAAO6iB,OAAOxhB;AADgB,OAAzB,CAAP;AAGF,SAAKJ,QAAQU,sBAAb;AACE,aAAOuH,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9B2b,0BAAkBtD,OAAOnhB;AADK,OAAzB,CAAP;AAGF,SAAKT,QAAQa,qBAAb;AACE,aAAOoH,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9B5I,gBAAQihB,OAAOxhB;AADe,OAAzB,CAAP;AAGF,SAAKJ,QAAQc,YAAb;AACE,aAAOmH,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9BxG,eAAOkF,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,MAAMxG,KAAxB,sBACJ6e,OAAOxhB,IAAP,CAAY7B,IADR,EACeqjB,OAAOxhB,IAAP,CAAYE,KAD3B;AADuB,OAAzB,CAAP;AAKF,SAAKN,QAAQgB,uBAAb;AACE,aAAOiH,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9B4b,yBAAiBvD,OAAOxhB;AADM,OAAzB,CAAP;AAGF,SAAKJ,QAAQkB,sBAAb;AACE,aAAO+G,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9BtI,4BAAoB2gB,OAAOxhB;AADG,OAAzB,CAAP;AAGF,SAAKJ,QAAQmB,aAAb;AACE,aAAO8G,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9B+G,mBAAWsR,OAAOxhB;AADY,OAAzB,CAAP;AAGF;AACE,aAAOmJ,KAAP;AA5CJ;AA8CD,C;;AA9ED;;IAAYvJ,O;;AACZ;;;;;;eACoB,mBAAAoG,CAAQ,CAAR,C;IAAZ1H,O,YAAAA,O;;AAER,IAAMsmB,eAAe;AACnBE,oBAAoB,KADD;AAEnBC,uDAFmB;AAGnBlkB,sBAAoB,KAHD;AAInBN,UAAoB;AAClBA,YAAS,IADS;AAElBC,aAAS;AAFS,GAJD;AAQnBmC,SAAO;AACL9C,UAAe,IADV;AAEL4F,SAAe,IAFV;AAGLpF,aAAe,IAHV;AAIL2kB,mBAAe;AAJV,GARY;AAcnBnlB,QAAU,IAdS;AAenBlB,SAAU,EAfS;AAgBnBwS,YAAU;AACRjT,WAAa,EADL;AAERG,iBAAa,EAFL;AAGR4R,aAAa,EAHL;AAIRD,UAAa;AAJL,GAhBS;AAsBnBvR,oBAAoBH,QAAQG,gBAtBT;AAuBnBC,sBAAoBJ,QAAQI,kBAvBT;AAwBnBwR,aAAoB;AAxBD,CAArB,C;;;;;;;;;;;;;kBCMe,YAAwC;AAAA,MAA9B/G,KAA8B,uEAAtByb,YAAsB;AAAA,MAARpD,MAAQ;;AACrD,UAAQA,OAAO1hB,IAAf;AACE,SAAKF,QAAQyN,cAAb;AACE,aAAOxF,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9BhI,yBAAiBqgB,OAAOxhB;AADM,OAAzB,CAAP;AAGF;AACE,aAAOmJ,KAAP;AANJ;AAQD,C;;AAnBD;;IAAYvJ,O;;;;AAEZ,IAAMglB,eAAe;AACnBzjB,mBAAiB;AACfhD,UAAS,IADM;AAEfkD,aAAS,IAFM;AAGfE,YAAS;AAHM;AADE,CAArB,C;;;;;;;;;;;;;kBCgBe,YAAwC;AAAA,MAA9B4H,KAA8B,uEAAtByb,YAAsB;AAAA,MAARpD,MAAQ;;AACrD,UAAQA,OAAO1hB,IAAf;AACE;AACA,SAAKF,QAAQgD,aAAb;AACE,aAAOiF,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9BjE,iBAAS2C,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,MAAMjE,OAAxB,EAAiC;AACxCvC,iBAAO6e,OAAOxhB;AAD0B,SAAjC;AADqB,OAAzB,CAAP;AAKF,SAAKJ,QAAQyD,cAAb;AACE,aAAOwE,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9BjE,iBAAS2C,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,MAAMjE,OAAxB,EAAiC;AACxCpF,gBAAM0hB,OAAOxhB,IAAP,CAAY8C,WADsB;AAExCG,cAAMue,OAAOxhB,IAAP,CAAY+C;AAFsB,SAAjC;AADqB,OAAzB,CAAP;AAMF;AACA,SAAKnD,QAAQ2D,gBAAb;AACE,aAAOsE,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9BJ,qBAAalB,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,MAAMJ,WAAxB,sBACVyY,OAAOxhB,IAAP,CAAYiD,EADF,EACO;AAChBN,iBAAO6e,OAAOxhB,IAAP,CAAY2C,KADH;AAEhBW,eAAOke,OAAOxhB,IAAP,CAAYsD;AAFH,SADP;AADiB,OAAzB,CAAP;AAQF;AACA,SAAK1D,QAAQ8D,SAAb;AACE,aAAOmE,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9BF,mBAAWpB,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,MAAMF,SAAxB,sBACRuY,OAAOxhB,IAAP,CAAYiD,EADJ,EACS;AAChBN,iBAAW6e,OAAOxhB,IAAP,CAAY2C,KADP;AAEhBxE,gBAAWqjB,OAAOxhB,IAAP,CAAY7B,IAFP;AAGhBqF,mBAAWge,OAAOxhB,IAAP,CAAYwD,OAHP;AAIhBnC,mBAAWmgB,OAAOxhB,IAAP,CAAYqB,OAJP;AAKhBoC,qBAAW+d,OAAOxhB,IAAP,CAAYyD;AALP,SADT;AADmB,OAAzB,CAAP;AAWF;AACA,SAAK7D,QAAQgE,WAAb;AACE,aAAOiE,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9B8b,qBAAapd,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,MAAM8b,WAAxB,sBACVzD,OAAOxhB,IAAP,CAAYiD,EADF,EACO;AAChB9E,gBAAYqjB,OAAOxhB,IAAP,CAAY7B,IADR;AAEhBoD,kBAAYigB,OAAOxhB,IAAP,CAAYuB,MAFR;AAGhBF,mBAAYmgB,OAAOxhB,IAAP,CAAYqB,OAHR;AAIhBsC,sBAAY6d,OAAOxhB,IAAP,CAAY2D;AAJR,SADP;AADiB,OAAzB,CAAP;AAUF,SAAK/D,QAAQqE,6BAAb;AACE,aAAO4D,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9B8b,qBAAapd,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,MAAM8b,WAAxB,sBACVzD,OAAOxhB,IAAP,CAAYgE,aADF,EACkB6D,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,MAAM8b,WAAN,CAAkBzD,OAAOxhB,IAAP,CAAYgE,aAA9B,CAAlB,EAAgE;AAC3FL,sBAAY6d,OAAOxhB,IAAP,CAAY2D;AADmE,SAAhE,CADlB;AADiB,OAAzB,CAAP;AAOF;AACA,SAAK/D,QAAQuE,wBAAb;AACE,aAAO0D,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9BmN,sBAAczO,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,MAAMmN,YAAxB,EAAsC;AAClD/V,kBAAQihB,OAAOxhB;AADmC,SAAtC;AADgB,OAAzB,CAAP;AAKF,SAAKJ,QAAQwE,mBAAb;AACE,aAAOyD,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,KAAlB,EAAyB;AAC9BmN,sBAAczO,OAAOgd,MAAP,CAAc,EAAd,EAAkB1b,MAAMmN,YAAxB,EAAsC;AAClD3T,iBAAQ6e,OAAOxhB,IADmC;AAElDO;AAFkD,SAAtC;AADgB,OAAzB,CAAP;AAMF;AACE,aAAO4I,KAAP;AAzEJ;AA2ED,C;;AA9FD;;IAAYvJ,O;;AACZ;;;;;;AAEA,IAAMglB,eAAe;AACnB1f,WAAS;AACPvC,WAAO,IADA;AAEP7C,UAAO,IAFA;AAGPmD,QAAO;AAHA,GADU;AAMnB8F,eAAc,EANK;AAOnBkc,eAAc,EAPK;AAQnBhc,aAAc,EARK;AASnBqN,gBAAc;AACZ3T,WAAQ,IADI;AAEZpC;AAFY;AATK,CAArB,C;;;;;;;;;;;;;kBCGe,YAAwC;AAAA,MAA9B4I,KAA8B,uEAAtByb,YAAsB;AAAA,MAARpD,MAAQ;;AACrD,UAAQA,OAAO1hB,IAAf;AACE;AACE,aAAOqJ,KAAP;AAFJ;AAID,C;;eAXgB,mBAAAnD,CAAQ,CAAR,C;IAAT/H,I,YAAAA,I;;AAER,IAAM2mB,eAAe;AACnBxmB,QAAMH,KAAKG;AADQ,CAArB,C;;;;;;ACFA,qC;;;;;;;;;;;;;;;ACAA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;;;;;IAEM8mB,Q;;;;;;;;;;;6BACM;AACR,aACE;AAAA;AAAA,UAAK,WAAW,sCAAhB;AACE,0DADF;AAEE,6DAFF;AAGE;AAAA;AAAA,YAAK,WAAW,kDAAhB;AACE;AADF;AAHF,OADF;AASD;;;;EAXoB,gBAAMpgB,S;;AAY5B;;kBAEcogB,Q;;;;;;;;;;;;;eCnBwB,mBAAAlf,CAAQ,CAAR,C;IAAhBmf,S,YAAflnB,I,CAAQC,K;;AAET,IAAMknB,4CAAkB,SAAlBA,eAAkB,CAAC7gB,SAAD,EAAe;AAC5C,MAAI,CAACA,SAAL,EAAgB;AACd,gBAAU4gB,SAAV;AACD;AACD,SAAUA,SAAV,WAAyB5gB,SAAzB;AACD,CALM,C;;;;;;;;;;;;;eCFyF,mBAAAyB,CAAQ,CAAR,C;6BAAxF/H,I;IAAQC,K,iBAAAA,K;IAAOE,I,iBAAAA,I;IAAMC,W,iBAAAA,W;8BAAeM,K;IAASE,gB,kBAAAA,gB;IAAkBC,kB,kBAAAA,kB;;AAEvE,IAAMumB,kCAAkC,SAAlCA,+BAAkC,CAACnV,SAAD,EAAe;AACrD,MAAIA,SAAJ,EAAe;AACb,QAAMoV,UAAUpV,UAAUb,SAAV,CAAoBa,UAAUqV,WAAV,CAAsB,GAAtB,CAApB,CAAhB;AACA,YAAQD,OAAR;AACE,WAAK,MAAL;AACA,WAAK,KAAL;AACE,eAAO,YAAP;AACF,WAAK,KAAL;AACE,eAAO,WAAP;AACF,WAAK,KAAL;AACE,eAAO,WAAP;AACF,WAAK,KAAL;AACE,eAAO,WAAP;AACF;AACE,eAAO,YAAP;AAXJ;AAaD;AACD,SAAO,EAAP;AACD,CAlBD;;AAoBA,IAAME,sBAAsB,SAAtBA,mBAAsB,GAAM;AAChC,SAAO,CACL,EAACC,UAAU,UAAX,EAAuBC,SAASxnB,KAAhC,EADK,EAEL,EAACunB,UAAU,QAAX,EAAqBC,SAAStnB,IAA9B,EAFK,EAGL,EAACqnB,UAAU,cAAX,EAA2BC,SAASxnB,KAApC,EAHK,EAIL,EAACunB,UAAU,gBAAX,EAA6BC,SAASrnB,WAAtC,EAJK,EAKL,EAAConB,UAAU,cAAX,EAA2BC,SAAS,UAApC,EALK,EAML,EAACD,UAAU,cAAX,EAA2BC,SAAS,SAApC,EANK,CAAP;AAQD,CATD;;AAWA,IAAMC,wBAAwB,SAAxBA,qBAAwB,CAACtlB,OAAD,EAAa;AAAA,MACjClC,IADiC,GAChBkC,OADgB,CACjClC,IADiC;AAAA,MAC3BoD,MAD2B,GAChBlB,OADgB,CAC3BkB,MAD2B;;AAEzC,SAAO,CACL,EAACkkB,UAAU,UAAX,EAAuBC,SAAYvnB,IAAZ,YAAuBD,KAA9C,EADK,EAEL,EAACunB,UAAU,QAAX,EAAqBC,SAAYtnB,IAAZ,SAAoBD,IAApB,SAA4BoD,MAAjD,EAFK,EAGL,EAACkkB,UAAU,cAAX,EAA2BC,SAASxnB,KAApC,EAHK,EAIL,EAACunB,UAAU,gBAAX,EAA6BC,SAAYvnB,IAAZ,uBAAkCD,KAA/D,EAJK,EAKL,EAACunB,UAAU,cAAX,EAA2BC,SAAS,UAApC,EALK,EAML,EAACD,UAAU,cAAX,EAA2BC,SAAS,SAApC,EANK,CAAP;AAQD,CAVD;;AAYA,IAAME,sBAAsB,SAAtBA,mBAAsB,CAACphB,KAAD,EAAW;AAAA,MAC7Bf,SAD6B,GACfe,KADe,CAC7Bf,SAD6B;AAAA,MAE7B2O,WAF6B,GAEb3O,SAFa,CAE7B2O,WAF6B;;AAGrC,MAAMyT,WAAcznB,IAAd,SAAsBqF,UAAUD,OAAhC,SAA2CC,UAAUtF,IAA3D;AACA,MAAM2nB,UAAa1nB,IAAb,SAAqBqF,UAAUD,OAA/B,SAA0CC,UAAUtF,IAA1D;AACA,MAAMuiB,SAAYtiB,IAAZ,SAAoBqF,UAAUD,OAA9B,SAAyCC,UAAUtF,IAAnD,SAA2DsF,UAAU6hB,OAA3E;AACA,MAAMS,UAAUtiB,UAAUvF,KAAV,IAAmBuF,UAAUtF,IAA7C;AACA,MAAM6nB,gBAAgBviB,UAAUpF,WAAV,IAAyBS,kBAA/C;AACA,MAAMmnB,yBAAyBZ,gCAAgC5hB,UAAUyM,SAA1C,CAA/B;AACA,MAAMgW,cAAcziB,UAAUyM,SAAV,IAAuBrR,gBAA3C;AACA,MAAM6F,WAAW,CACf,EAAC+gB,UAAU,UAAX,EAAuBC,SAASK,OAAhC,EADe,EAEf,EAACN,UAAU,QAAX,EAAqBC,SAASI,OAA9B,EAFe,EAGf,EAACL,UAAU,cAAX,EAA2BC,SAASxnB,KAApC,EAHe,EAIf,EAACunB,UAAU,gBAAX,EAA6BC,SAASM,aAAtC,EAJe,EAKf,EAACP,UAAU,gBAAX,EAA6BC,SAAS,GAAtC,EALe,EAMf,EAACD,UAAU,iBAAX,EAA8BC,SAAS,GAAvC,EANe,EAOf,EAACD,UAAU,cAAX,EAA2BC,SAAS,UAApC,EAPe,CAAjB;AASA,MAAItT,gBAAgB,WAAhB,IAA+BA,gBAAgB,YAAnD,EAAiE;AAC/D1N,aAASuJ,IAAT,CAAc,EAACwX,UAAU,UAAX,EAAuBC,SAAShF,MAAhC,EAAd;AACAhc,aAASuJ,IAAT,CAAc,EAACwX,UAAU,qBAAX,EAAkCC,SAAShF,MAA3C,EAAd;AACAhc,aAASuJ,IAAT,CAAc,EAACwX,UAAU,eAAX,EAA4BC,SAAStT,WAArC,EAAd;AACA1N,aAASuJ,IAAT,CAAc,EAACwX,UAAU,UAAX,EAAuBC,SAASQ,WAAhC,EAAd;AACAxhB,aAASuJ,IAAT,CAAc,EAACwX,UAAU,eAAX,EAA4BC,SAASO,sBAArC,EAAd;AACAvhB,aAASuJ,IAAT,CAAc,EAACwX,UAAU,SAAX,EAAsBC,SAAS,OAA/B,EAAd;AACAhhB,aAASuJ,IAAT,CAAc,EAACwX,UAAU,cAAX,EAA2BC,SAAS,QAApC,EAAd;AACAhhB,aAASuJ,IAAT,CAAc,EAACwX,UAAU,gBAAX,EAA6BC,SAASG,QAAtC,EAAd;AACAnhB,aAASuJ,IAAT,CAAc,EAACwX,UAAU,sBAAX,EAAmCC,SAAS,GAA5C,EAAd;AACAhhB,aAASuJ,IAAT,CAAc,EAACwX,UAAU,2BAAX,EAAwCC,SAAS,GAAjD,EAAd;AACAhhB,aAASuJ,IAAT,CAAc,EAACwX,UAAU,uBAAX,EAAoCC,SAAS,GAA7C,EAAd;AACAhhB,aAASuJ,IAAT,CAAc,EAACwX,UAAU,uBAAX,EAAoCC,SAAShF,MAA7C,EAAd;AACAhc,aAASuJ,IAAT,CAAc,EAACwX,UAAU,oCAAX,EAAiDC,SAAStT,WAA1D,EAAd;AACD,GAdD,MAcO;AACL1N,aAASuJ,IAAT,CAAc,EAACwX,UAAU,UAAX,EAAuBC,SAAShF,MAAhC,EAAd;AACAhc,aAASuJ,IAAT,CAAc,EAACwX,UAAU,eAAX,EAA4BC,SAAStT,WAArC,EAAd;AACA1N,aAASuJ,IAAT,CAAc,EAACwX,UAAU,SAAX,EAAsBC,SAAS,SAA/B,EAAd;AACAhhB,aAASuJ,IAAT,CAAc,EAACwX,UAAU,cAAX,EAA2BC,SAAS,qBAApC,EAAd;AACD;AACD,SAAOhhB,QAAP;AACD,CAxCD;;AA0CO,IAAMyhB,0CAAiB,SAAjBA,cAAiB,CAAC3hB,KAAD,EAAQnE,OAAR,EAAoB;AAChD,MAAImE,KAAJ,EAAW;AACT,WAAOohB,oBAAoBphB,KAApB,CAAP;AACD;AACD,MAAInE,OAAJ,EAAa;AACX,WAAOslB,sBAAsBtlB,OAAtB,CAAP;AACD;AACD,SAAOmlB,qBAAP;AACD,CARM,C;;;;;;;;;;;;;eCvFoB,mBAAAxf,CAAQ,CAAR,C;IAAX5H,I,YAARH,I,CAAQG,I;;AAEhB,IAAMgoB,2BAA2B,SAA3BA,wBAA2B,CAACtiB,IAAD,EAAU;AACzC,MAAI,CAACA,IAAL,EAAW;AACT,gBAAU1F,IAAV;AACD;AACD,SAAUA,IAAV,SAAkB0F,IAAlB;AACD,CALD;;AAOA,IAAMuiB,2BAA2B,SAA3BA,wBAA2B,CAAC7hB,KAAD,EAAW;AAC1C,MAAI7D,oBAAJ;AAAA,MAAiB2f,sBAAjB;AAAA,MAAgCniB,aAAhC;AAAA,MAAsCqF,gBAAtC;AACA,MAAIgB,MAAMf,SAAV,EAAqB;AAAA,2BAC8Be,MAAMf,SADpC;AAChB9C,eADgB,oBAChBA,WADgB;AACH2f,iBADG,oBACHA,aADG;AACYniB,QADZ,oBACYA,IADZ;AACkBqF,WADlB,oBACkBA,OADlB;AAEpB;AACD,MAAI7C,WAAJ,EAAiB;AACf,WAAUvC,IAAV,SAAkBuC,WAAlB,SAAiC2f,aAAjC,SAAkDniB,IAAlD;AACD;AACD,SAAUC,IAAV,SAAkBoF,OAAlB,SAA6BrF,IAA7B;AACD,CATD;;AAWA,IAAMmoB,6BAA6B,SAA7BA,0BAA6B,CAACjmB,OAAD,EAAa;AAAA,MACtClC,IADsC,GACrBkC,OADqB,CACtClC,IADsC;AAAA,MAChCoD,MADgC,GACrBlB,OADqB,CAChCkB,MADgC;;AAE9C,SAAUnD,IAAV,SAAkBD,IAAlB,SAA0BoD,MAA1B;AACD,CAHD;;AAKO,IAAMglB,oDAAsB,SAAtBA,mBAAsB,CAAC/hB,KAAD,EAAQnE,OAAR,EAAiByD,IAAjB,EAA0B;AAC3D,MAAIU,KAAJ,EAAW;AACT,WAAO6hB,yBAAyB7hB,KAAzB,CAAP;AACD;AACD,MAAInE,OAAJ,EAAa;AACX,WAAOimB,2BAA2BjmB,OAA3B,CAAP;AACD;AACD,MAAIyD,IAAJ,EAAU;AACR,WAAOsiB,yBAAyBtiB,IAAzB,CAAP;AACD;AACD,SAAOsiB,0BAAP;AACD,CAXM,C;;;;;;;;;;;;;;;ACzBP;;;;AACA;;AACA;;;;AACA;;;;AACA;;;;;;;;;;;;AAEA,IAAMI,OAAO,MAAb;AACA,IAAMC,SAAS,QAAf;;IAEMC,M;;;AACJ,kBAAapiB,KAAb,EAAoB;AAAA;;AAAA,gHACZA,KADY;;AAElB,UAAKqiB,oBAAL,GAA4B,MAAKA,oBAAL,CAA0BhZ,IAA1B,OAA5B;AACA,UAAKiZ,UAAL,GAAkB,MAAKA,UAAL,CAAgBjZ,IAAhB,OAAlB;AACA,UAAKkZ,eAAL,GAAuB,MAAKA,eAAL,CAAqBlZ,IAArB,OAAvB;AAJkB;AAKnB;;;;wCACoB;AACnB;AACA,WAAKgZ,oBAAL;AACD;;;2CACuB;AAAA;;AACtB,UAAMlkB,SAAS,EAACqkB,aAAa,SAAd,EAAf;AACA,6BAAQ,OAAR,EAAiBrkB,MAAjB,EACGmD,IADH,CACQ,gBAAc;AAAA,YAAX5F,IAAW,QAAXA,IAAW;;AAClB,eAAKsE,KAAL,CAAW7C,cAAX,CAA0BzB,KAAKW,WAA/B,EAA4CX,KAAK4Z,cAAjD,EAAiE5Z,KAAKmT,cAAtE;AACD,OAHH,EAIG/L,KAJH,CAIS,iBAAS;AACdlB,gBAAQC,GAAR,CAAY,cAAZ,EAA4BxD,MAAMnC,OAAlC;AACD,OANH;AAOD;;;iCACa;AAAA;;AACZ,UAAMiC,SAAS,EAACqkB,aAAa,SAAd,EAAf;AACA,6BAAQ,SAAR,EAAmBrkB,MAAnB,EACGmD,IADH,CACQ,YAAM;AACV,eAAKtB,KAAL,CAAW3C,eAAX;AACD,OAHH,EAIGyF,KAJH,CAIS,iBAAS;AACdlB,gBAAQC,GAAR,CAAY,eAAZ,EAA6BxD,MAAMnC,OAAnC;AACD,OANH;AAOD;;;oCACgBuM,K,EAAO;AACtB,UAAM7M,QAAQ6M,MAAMga,MAAN,CAAaC,eAAb,CAA6B,CAA7B,EAAgC9mB,KAA9C;AACA,cAAQA,KAAR;AACE,aAAKumB,MAAL;AACE,eAAKG,UAAL;AACA;AACF,aAAKJ,IAAL;AACE;AACA,eAAKliB,KAAL,CAAWtD,OAAX,CAAmBiN,IAAnB,OAA4B,KAAK3J,KAAL,CAAW3D,WAAvC,SAAsD,KAAK2D,KAAL,CAAWhD,aAAjE;AACA;AACF;AACE;AATJ;AAWD;;;6BACS;AACR,aACE;AAAA;AAAA,UAAK,WAAU,uBAAf;AACE;AAAA;AAAA,YAAK,WAAU,qFAAf;AACE,6DADF;AAEE;AAAA;AAAA,cAAK,WAAU,iBAAf;AACE;AAAA;AAAA,gBAAM,WAAU,iBAAhB;AAAA;AAAA;AADF,WAFF;AAKE;AAAA;AAAA,cAAK,WAAU,gBAAf;AACE;AAAA;AAAA,gBAAS,WAAU,wBAAnB,EAA4C,iBAAgB,kBAA5D,EAA+E,IAAG,GAAlF,EAAsF,WAAtF;AAAA;AAAA,aADF;AAEE;AAAA;AAAA,gBAAS,WAAU,wBAAnB,EAA6C,iBAAgB,kBAA7D,EAAgF,IAAG,QAAnF;AAAA;AAAA,aAFF;AAGI,iBAAKgD,KAAL,CAAW3D,WAAX,GACA;AACE,2BAAa,KAAK2D,KAAL,CAAW3D,WAD1B;AAEE,+BAAiB,KAAKkmB,eAFxB;AAGE,gCAAkB,KAAKviB,KAAL,CAAW3D,WAH/B;AAIE,oBAAM6lB,IAJR;AAKE,sBAAQC;AALV,cADA,GASA;AAAA;AAAA,gBAAS,IAAG,oBAAZ,EAAiC,WAAU,wBAA3C,EAAoE,iBAAgB,kBAApF,EAAuG,IAAG,QAA1G;AAAA;AAAA;AAZJ;AALF;AADF,OADF;AAyBD;;;;EAvEkB,gBAAM3hB,S;;kBA0EZ,gCAAW4hB,MAAX,C;;;;;;;;;;;;;ACnFf;;;;AACA;;;;AAEA,SAASO,IAAT,GAAiB;AACf,SACE;AAAA;AAAA,MAAK,SAAQ,KAAb,EAAmB,IAAG,SAAtB,EAAgC,GAAE,KAAlC,EAAwC,GAAE,KAA1C,EAAgD,QAAO,MAAvD,EAA8D,SAAQ,WAAtE,EAAkF,kBAAiB,eAAnG,EAAmH,WAAU,cAA7H;AACE;AAAA;AAAA,QAAM,IAAG,GAAT;AACE;AAAA;AAAA;AAAA;AAAA,OADF;AAEE;AAAA;AAAA;AAAA;AAAA,OAFF;AAGE;AAAA;AAAA,UAAG,IAAG,OAAN;AACE;AAAA;AAAA,YAAG,IAAG,kCAAN,EAAyC,WAAU,mCAAnD;AACE;AAAA;AAAA,cAAG,IAAG,UAAN,EAAiB,WAAU,iCAA3B;AACE;AAAA;AAAA,gBAAM,WAAU,sBAAhB,EAAuC,UAAS,IAAhD,EAAqD,YAAW,QAAhE;AAAA;AAAA,aADF;AAEE;AAAA;AAAA,gBAAG,IAAG,UAAN,EAAiB,WAAU,gCAA3B;AACE,sDAAM,IAAG,QAAT,EAAkB,MAAK,MAAvB,EAA8B,QAAO,SAArC,EAA+C,aAAY,GAA3D,EAA+D,eAAc,QAA7E,EAAsF,GAAE,aAAxF,GADF;AAEE,sDAAM,IAAG,aAAT,EAAuB,MAAK,MAA5B,EAAmC,QAAO,SAA1C,EAAoD,aAAY,GAAhE,EAAoE,eAAc,QAAlF,EAA2F,GAAE,cAA7F,GAFF;AAGE,sDAAM,IAAG,eAAT,EAAyB,MAAK,MAA9B,EAAqC,QAAO,SAA5C,EAAsD,aAAY,GAAlE,EAAsE,eAAc,QAApF,EAA6F,GAAE,cAA/F,GAHF;AAIE,sDAAM,IAAG,eAAT,EAAyB,MAAK,MAA9B,EAAqC,QAAO,SAA5C,EAAsD,aAAY,GAAlE,EAAsE,eAAc,QAApF,EAA6F,GAAE,cAA/F,GAJF;AAKE,sDAAM,IAAG,eAAT,EAAyB,MAAK,MAA9B,EAAqC,QAAO,SAA5C,EAAsD,aAAY,GAAlE,EAAsE,eAAc,QAApF,EAA6F,GAAE,cAA/F;AALF;AAFF;AADF;AADF;AAHF;AADF,GADF;AAsBD;;kBAEcA,I;;;;;;;;;;;;;AC5Bf;;;;;;AAEA,SAASC,qBAAT,OAAkG;AAAA,MAAhEvmB,WAAgE,QAAhEA,WAAgE;AAAA,MAAnDkmB,eAAmD,QAAnDA,eAAmD;AAAA,MAAlCM,gBAAkC,QAAlCA,gBAAkC;AAAA,MAAhBX,IAAgB,QAAhBA,IAAgB;AAAA,MAAVC,MAAU,QAAVA,MAAU;;AAChG,SACE;AAAA;AAAA,MAAQ,MAAK,MAAb,EAAoB,IAAG,wBAAvB,EAAgD,WAAU,gCAA1D,EAA2F,UAAUI,eAArG,EAAsH,OAAOM,gBAA7H;AACE;AAAA;AAAA,QAAQ,IAAG,uCAAX;AAAoDxmB;AAApD,KADF;AAEE;AAAA;AAAA,QAAQ,OAAO6lB,IAAf;AAAA;AAAA,KAFF;AAGE;AAAA;AAAA,QAAQ,OAAOC,MAAf;AAAA;AAAA;AAHF,GADF;AAOD;;kBAEcS,qB;;;;;;ACZf,iD;;;;;;;;;;;;;ACAA;;AACA;;;;;;AAEA,IAAMhmB,kBAAkB,SAAlBA,eAAkB,OAAiB;AAAA,MAAd5C,OAAc,QAAdA,OAAc;;AACvC,SAAO;AACLuB,UAAQvB,QAAQuB,IADX;AAELU,YAAQjC,QAAQiC,MAAR,CAAeA;AAFlB,GAAP;AAID,CALD;;kBAOe,yBAAQW,eAAR,EAAyB,IAAzB,iB;;;;;;;;;;;;;;;ACVf;;;;AACA;;;;AACA;;;;AACA;;;;;;;;;;;;IAEMkmB,W;;;;;;;;;;;6BACM;AACR,UAAI,KAAK9iB,KAAL,CAAWzE,IAAf,EAAqB;AACnB,YAAI,KAAKyE,KAAL,CAAW/D,MAAf,EAAuB;AACrB,iBACE,4DADF;AAGD,SAJD,MAIO;AACL,iBAAO,6DAAP;AACD;AACF,OARD,MAQO;AACL,eAAO,uDAAP;AACD;AACF;;;;EAbuB,gBAAMuE,S;;AAc/B;;kBAEcsiB,W;;;;;;;;;;;;;;;ACrBf;;;;AACA;;AACA;;;;;;;;;;;;IAEMC,Q;;;AACJ,oBAAa/iB,KAAb,EAAoB;AAAA;;AAAA,oHACZA,KADY;;AAElB,UAAK6E,KAAL,GAAa;AACXme,gBAAY,KADD;AAEXC,iBAAY,KAFD;AAGXC,kBAAY;AAHD,KAAb;AAKA,UAAKC,UAAL,GAAkB,MAAKA,UAAL,CAAgB9Z,IAAhB,OAAlB;AACA,UAAK+Z,cAAL,GAAsB,MAAKA,cAAL,CAAoB/Z,IAApB,OAAtB;AACA,UAAKga,aAAL,GAAqB,MAAKA,aAAL,CAAmBha,IAAnB,OAArB;AACA,UAAKia,eAAL,GAAuB,MAAKA,eAAL,CAAqBja,IAArB,OAAvB;AACA,UAAKka,eAAL,GAAuB,MAAKA,eAAL,CAAqBla,IAArB,OAAvB;AACA,UAAKma,gBAAL,GAAwB,MAAKA,gBAAL,CAAsBna,IAAtB,OAAxB;AACA,UAAKoa,gBAAL,GAAwB,MAAKA,gBAAL,CAAsBpa,IAAtB,OAAxB;AACA,UAAKqa,WAAL,GAAmB,MAAKA,WAAL,CAAiBra,IAAjB,OAAnB;AACA,UAAKsa,eAAL,GAAuB,MAAKA,eAAL,CAAqBta,IAArB,OAAvB;AACA,UAAKua,UAAL,GAAkB,MAAKA,UAAL,CAAgBva,IAAhB,OAAlB;AAhBkB;AAiBnB;;;;+BACWZ,K,EAAO;AACjBA,YAAMob,cAAN;AACA,WAAKha,QAAL,CAAc,EAACmZ,UAAU,KAAX,EAAd;AACA;AACA,UAAMc,KAAKrb,MAAMsb,YAAjB;AACA,UAAID,GAAGE,KAAP,EAAc;AACZ,YAAIF,GAAGE,KAAH,CAAS,CAAT,EAAYC,IAAZ,KAAqB,MAAzB,EAAiC;AAC/B,cAAMC,cAAcJ,GAAGE,KAAH,CAAS,CAAT,EAAYG,SAAZ,EAApB;AACA,eAAKP,UAAL,CAAgBM,WAAhB;AACD;AACF;AACF;;;mCACezb,K,EAAO;AACrBA,YAAMob,cAAN;AACD;;;kCACcpb,K,EAAO;AACpB,UAAIqb,KAAKrb,MAAMsb,YAAf;AACA,UAAID,GAAGE,KAAP,EAAc;AACZ,aAAK,IAAIva,IAAI,CAAb,EAAgBA,IAAIqa,GAAGE,KAAH,CAAS3Y,MAA7B,EAAqC5B,GAArC,EAA0C;AACxCqa,aAAGE,KAAH,CAASI,MAAT,CAAgB3a,CAAhB;AACD;AACF,OAJD,MAIO;AACLhB,cAAMsb,YAAN,CAAmBM,SAAnB;AACD;AACF;;;sCACkB;AACjB,WAAKxa,QAAL,CAAc,EAACmZ,UAAU,IAAX,EAAiBE,YAAY,IAA7B,EAAd;AACD;;;sCACkB;AACjB,WAAKrZ,QAAL,CAAc,EAACmZ,UAAU,KAAX,EAAkBE,YAAY,KAA9B,EAAd;AACD;;;uCACmB;AAClB,WAAKrZ,QAAL,CAAc,EAACoZ,WAAW,IAAZ,EAAkBC,YAAY,IAA9B,EAAd;AACD;;;uCACmB;AAClB,WAAKrZ,QAAL,CAAc,EAACoZ,WAAW,KAAZ,EAAmBC,YAAY,KAA/B,EAAd;AACD;;;gCACYza,K,EAAO;AAClBA,YAAMob,cAAN;AACAS,eAASC,cAAT,CAAwB,YAAxB,EAAsCC,KAAtC;AACD;;;oCACgB/b,K,EAAO;AACtBA,YAAMob,cAAN;AACA,UAAMY,WAAWhc,MAAMga,MAAN,CAAahpB,KAA9B;AACA,WAAKmqB,UAAL,CAAgBa,SAAS,CAAT,CAAhB;AACD;;;+BACWlpB,I,EAAM;AAChB,UAAIA,IAAJ,EAAU;AACR,YAAI;AACF,kCAAaA,IAAb,EADE,CACkB;AACrB,SAFD,CAEE,OAAO8C,KAAP,EAAc;AACd,iBAAO,KAAK2B,KAAL,CAAW4R,YAAX,CAAwBvT,MAAMnC,OAA9B,CAAP;AACD;AACD;AACA,aAAK8D,KAAL,CAAWrF,UAAX,CAAsBY,IAAtB;AACD;AACF;;;6BACS;AACR,aACE;AAAA;AAAA,UAAK,WAAU,sCAAf;AACE;AAAA;AAAA;AACE,mDAAO,WAAU,YAAjB,EAA8B,MAAK,MAAnC,EAA0C,IAAG,YAA7C,EAA0D,MAAK,YAA/D,EAA4E,QAAO,iBAAnF,EAAqG,UAAU,KAAKooB,eAApH,EAAqI,SAAQ,qBAA7I;AADF,SADF;AAIE;AAAA;AAAA,YAAK,IAAG,kBAAR,EAA2B,WAAW,wCAAwC,KAAK9e,KAAL,CAAWme,QAAX,GAAsB,sBAAtB,GAA+C,EAAvF,CAAtC,EAAkI,QAAQ,KAAKG,UAA/I,EAA2J,YAAY,KAAKC,cAA5K,EAA4L,WAAW,KAAKC,aAA5M,EAA2N,aAAa,KAAKC,eAA7O,EAA8P,aAAa,KAAKC,eAAhR,EAAiS,cAAc,KAAKC,gBAApT,EAAsU,cAAc,KAAKC,gBAAzV,EAA2W,SAAS,KAAKC,WAAzX;AACG,eAAK1jB,KAAL,CAAWzE,IAAX,GACC;AAAA;AAAA;AACE;AACE,0BAAY,KAAKsJ,KAAL,CAAWqe,UADzB;AAEE,oBAAM,KAAKljB,KAAL,CAAWzE,IAFnB;AAGE,yBAAW,KAAKyE,KAAL,CAAW4L;AAHxB,cADF;AAME;AAAA;AAAA,gBAAK,IAAG,sBAAR,EAA+B,WAAW,sDAA1C;AACI,mBAAK/G,KAAL,CAAWme,QAAX,GACA;AAAA;AAAA,kBAAK,IAAG,mBAAR;AACE;AAAA;AAAA,oBAAG,WAAU,MAAb;AAAA;AAAA;AADF,eADA,GAKA,IANJ;AAQI,mBAAKne,KAAL,CAAWoe,SAAX,GACA;AAAA;AAAA,kBAAK,IAAG,uBAAR;AACE;AAAA;AAAA,oBAAG,WAAU,gDAAb,EAA8D,IAAG,4BAAjE;AAA+F,uBAAKjjB,KAAL,CAAW2R;AAA1G,iBADF;AAEE;AAAA;AAAA;AAAA;AAAA,iBAFF;AAGE;AAAA;AAAA,oBAAG,WAAU,YAAb;AAAA;AAAA,iBAHF;AAIE;AAAA;AAAA,oBAAG,WAAU,kBAAb;AAAA;AAAA;AAJF,eADA,GAQA;AAhBJ;AANF,WADD,GA4BC;AAAA;AAAA,cAAK,IAAG,sBAAR,EAA+B,WAAW,sDAA1C;AACI,iBAAK9M,KAAL,CAAWme,QAAX,GACA;AAAA;AAAA,gBAAK,IAAG,mBAAR;AACE;AAAA;AAAA,kBAAG,WAAU,MAAb;AAAA;AAAA;AADF,aADA,GAKA;AAAA;AAAA,gBAAK,IAAG,uBAAR;AACE;AAAA;AAAA,kBAAG,WAAU,gDAAb,EAA8D,IAAG,4BAAjE;AAA+F,qBAAKhjB,KAAL,CAAW2R;AAA1G,eADF;AAEE;AAAA;AAAA;AAAA;AAAA,eAFF;AAGE;AAAA;AAAA,kBAAG,WAAU,YAAb;AAAA;AAAA,eAHF;AAIE;AAAA;AAAA,kBAAG,WAAU,kBAAb;AAAA;AAAA;AAJF;AANJ;AA7BJ;AAJF,OADF;AAoDD;;;;EAjIoB,gBAAMnR,S;;AAkI5B;;kBAEcuiB,Q;;;;;;;;;ACxIftoB,OAAOC,OAAP,GAAiB;AACfgqB,cADe,wBACDnpB,IADC,EACK;AAClB,QAAI,CAACA,IAAL,EAAW;AACT,YAAM,IAAI2F,KAAJ,CAAU,kBAAV,CAAN;AACD;AACD,QAAI,IAAI+K,IAAJ,CAAS1Q,KAAK1B,IAAd,CAAJ,EAAyB;AACvB,YAAM,IAAIqH,KAAJ,CAAU,8CAAV,CAAN;AACD;AACD;AACA,YAAQ3F,KAAKC,IAAb;AACE,WAAK,YAAL;AACA,WAAK,WAAL;AACA,WAAK,WAAL;AACE,YAAID,KAAKmO,IAAL,GAAY,QAAhB,EAA0B;AACxB,gBAAM,IAAIxI,KAAJ,CAAU,4CAAV,CAAN;AACD;AACD;AACF,WAAK,WAAL;AACE,YAAI3F,KAAKmO,IAAL,GAAY,QAAhB,EAA0B;AACxB,gBAAM,IAAIxI,KAAJ,CAAU,0CAAV,CAAN;AACD;AACD;AACF,WAAK,WAAL;AACE,YAAI3F,KAAKmO,IAAL,GAAY,QAAhB,EAA0B;AACxB,gBAAM,IAAIxI,KAAJ,CAAU,4CAAV,CAAN;AACD;AACD;AACF;AACE,cAAM,IAAIA,KAAJ,CAAU3F,KAAKC,IAAL,GAAY,iGAAtB,CAAN;AAnBJ;AAqBD;AA9Bc,CAAjB,C;;;;;;;;;;;;;;;ACAA;;;;AACA;;;;;;;;;;;;IAEMmpB,O;;;AACJ,mBAAa3kB,KAAb,EAAoB;AAAA;;AAAA,kHACZA,KADY;;AAElB,UAAK6E,KAAL,GAAa;AACX+f,iBAAkB,EADP;AAEXrqB,wBAAkB;AAFP,KAAb;AAFkB;AAMnB;;;;wCACoB;AACnB,WAAKsqB,qBAAL,CAA2B,KAAK7kB,KAAL,CAAWzE,IAAtC;AACD;;;8CAC0BupB,Q,EAAU;AACnC,UAAIA,SAASvpB,IAAT,KAAkB,KAAKyE,KAAL,CAAWzE,IAAjC,EAAuC;AACrC,aAAKspB,qBAAL,CAA2BC,SAASvpB,IAApC;AACD;AACD,UAAIupB,SAASlZ,SAAT,KAAuB,KAAK5L,KAAL,CAAW4L,SAAtC,EAAiD;AAC/C,YAAIkZ,SAASlZ,SAAb,EAAwB;AACtB,eAAKmZ,6BAAL,CAAmCD,SAASlZ,SAA5C;AACD,SAFD,MAEO;AACL,eAAK/B,QAAL,CAAc,EAAC+a,WAAW,KAAK/f,KAAL,CAAWtK,gBAAvB,EAAd;AACD;AACF;AACF;;;kDAC8BgB,I,EAAM;AAAA;;AACnC,UAAMypB,gBAAgB,IAAIC,UAAJ,EAAtB;AACAD,oBAAcE,aAAd,CAA4B3pB,IAA5B;AACAypB,oBAAcG,SAAd,GAA0B,YAAM;AAC9B,eAAKtb,QAAL,CAAc,EAAC+a,WAAWI,cAAcxf,MAA1B,EAAd;AACD,OAFD;AAGD;;;0CACsBjK,I,EAAM;AAC3B,UAAIA,KAAKC,IAAL,KAAc,WAAlB,EAA+B;AAC7B,aAAKupB,6BAAL,CAAmCxpB,IAAnC;AACD,OAFD,MAEO;AACL,YAAI,KAAKyE,KAAL,CAAW4L,SAAf,EAA0B;AACxB,eAAKmZ,6BAAL,CAAmC,KAAK/kB,KAAL,CAAW4L,SAA9C;AACD;AACD,aAAK/B,QAAL,CAAc,EAAC+a,WAAW,KAAK/f,KAAL,CAAWtK,gBAAvB,EAAd;AACD;AACF;;;6BACS;AACR,aACE;AACE,YAAG,kBADL;AAEE,aAAK,KAAKsK,KAAL,CAAW+f,SAFlB;AAGE,mBAAW,KAAK5kB,KAAL,CAAWkjB,UAAX,GAAwB,KAAxB,GAAgC,EAH7C;AAIE,aAAI;AAJN,QADF;AAQD;;;;EAjDmB,gBAAM1iB,S;;AAkD3B;;AAEDmkB,QAAQlkB,SAAR,GAAoB;AAClByiB,cAAY,oBAAUkC,IAAV,CAAehb,UADT;AAElB7O,QAAY,oBAAUoF,MAAV,CAAiByJ,UAFX;AAGlBwB,aAAY,oBAAUjL;AAHJ,CAApB;;kBAMegkB,O;;;;;;;;;;;;;AC7Df;;AACA;;AACA;;;;;;AAEA,IAAM/nB,kBAAkB,SAAlBA,eAAkB,OAA0B;AAAA,MAAvBb,OAAuB,QAAvBA,OAAuB;AAAA,MAAd/B,OAAc,QAAdA,OAAc;;AAChD,SAAO;AACLuB,UAAMvB,QAAQuB;AADT,GAAP;AAGD,CAJD;;AAMA,IAAM2B,qBAAqB;AACzBtC,+BADyB;AAEzBS;AAFyB,CAA3B;;kBAKe,yBAAQuB,eAAR,EAAyBM,kBAAzB,iB;;;;;;;;;;;;;;;ACff;;;;AACA;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;;;;;IAEMmoB,c;;;AACJ,0BAAarlB,KAAb,EAAoB;AAAA;;AAAA,gIACZA,KADY;;AAElB,UAAKslB,eAAL,GAAuB,MAAKA,eAAL,CAAqBjc,IAArB,OAAvB;AAFkB;AAGnB;;;;sCACkB;AACjB,WAAKrJ,KAAL,CAAW3E,YAAX,CAAwB,KAAK2E,KAAL,CAAWtD,OAAnC;AACD;;;6BACS;AACR,aACE;AAAA;AAAA,UAAK,WAAU,oBAAf;AACE;AAAA;AAAA,YAAK,WAAU,mBAAf;AACE;AADF,SADF;AAKE;AAAA;AAAA,YAAK,WAAU,iCAAf;AACE;AAAA;AAAA,cAAK,WAAU,iBAAf;AACE;AADF;AADF,SALF;AAWE;AAAA;AAAA,YAAK,WAAU,mDAAf;AACE;AAAA;AAAA,cAAK,IAAG,qBAAR,EAA8B,WAAU,iBAAxC;AACE;AAAA;AAAA,gBAAK,WAAU,uCAAf;AACE;AADF,aADF;AAIE;AAAA;AAAA,gBAAK,WAAU,uCAAf;AACE;AADF,aAJF;AAOK,iBAAKsD,KAAL,CAAWzE,IAAX,CAAgBC,IAAhB,KAAyB,WAA1B,IACA;AAAA;AAAA,gBAAK,WAAU,wCAAf;AACE;AADF,aARJ;AAYE;AAAA;AAAA,gBAAK,WAAU,sDAAf;AACE;AADF,aAZF;AAeE;AAAA;AAAA,gBAAK,WAAU,oCAAf;AACE;AAAA;AAAA,kBAAQ,IAAG,gBAAX,EAA4B,WAAU,+BAAtC,EAAsE,SAAS,KAAK8pB,eAApF;AAAA;AAAA;AADF,aAfF;AAkBE;AAAA;AAAA,gBAAK,WAAU,qDAAf;AACE;AAAA;AAAA,kBAAQ,WAAU,gBAAlB,EAAmC,SAAS,KAAKtlB,KAAL,CAAWpF,SAAvD;AAAA;AAAA;AADF,aAlBF;AAqBE;AAAA;AAAA,gBAAK,WAAU,qCAAf;AACE;AAAA;AAAA,kBAAG,WAAU,YAAb;AAAA;AAAuO;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,QAAO,QAApC,EAA6C,MAAK,uBAAlD;AAAA;AAAA;AAAvO;AADF;AArBF;AADF;AAXF,OADF;AAyCD;;;;EAlD0B,gBAAM4F,S;;AAmDlC;;kBAEc,gCAAW6kB,cAAX,C;;;;;;;;;;;;;AC9Df;;AACA;;AACA;;;;;;AAEA,IAAMzoB,kBAAkB,SAAlBA,eAAkB,OAAiB;AAAA,MAAd5C,OAAc,QAAdA,OAAc;;AACvC,SAAO;AACLJ,WAAOI,QAAQ6S,QAAR,CAAiBjT;AADnB,GAAP;AAGD,CAJD;;AAMA,IAAMsD,qBAAqB,SAArBA,kBAAqB,WAAY;AACrC,SAAO;AACLqoB,sBAAkB,0BAAC1rB,IAAD,EAAO+B,KAAP,EAAiB;AACjCwB,eAAS,6BAAevD,IAAf,EAAqB+B,KAArB,CAAT;AACD;AAHI,GAAP;AAKD,CAND;;kBAQe,yBAAQgB,eAAR,EAAyBM,kBAAzB,iB;;;;;;;;;;;;;;;AClBf;;;;;;;;;;;;IAEMsoB,iB;;;AACJ,6BAAaxlB,KAAb,EAAoB;AAAA;;AAAA,sIACZA,KADY;;AAElB,UAAKylB,WAAL,GAAmB,MAAKA,WAAL,CAAiBpc,IAAjB,OAAnB;AAFkB;AAGnB;;;;gCACYqc,C,EAAG;AACd,UAAM7rB,OAAO6rB,EAAEjD,MAAF,CAAS5oB,IAAtB;AACA,UAAM+B,QAAQ8pB,EAAEjD,MAAF,CAAS7mB,KAAvB;AACA,WAAKoE,KAAL,CAAWulB,gBAAX,CAA4B1rB,IAA5B,EAAkC+B,KAAlC;AACD;;;6BACS;AACR,aACE,yCAAO,MAAK,MAAZ,EAAmB,IAAG,eAAtB,EAAsC,WAAU,+CAAhD,EAAgG,MAAK,OAArG,EAA6G,aAAY,2BAAzH,EAAqJ,UAAU,KAAK6pB,WAApK,EAAiL,OAAO,KAAKzlB,KAAL,CAAWpG,KAAnM,GADF;AAGD;;;;EAd6B,gBAAM4G,S;;kBAiBvBglB,iB;;;;;;;;;;;;;ACnBf;;AACA;;AACA;;;;;;AAEA,IAAM5oB,kBAAkB,SAAlBA,eAAkB,OAA0B;AAAA,MAAvBb,OAAuB,QAAvBA,OAAuB;AAAA,MAAd/B,OAAc,QAAdA,OAAc;;AAChD,SAAO;AACL2rB,yBAAwB5pB,QAAQc,eAAR,CAAwBhD,IAD3C;AAEL+rB,4BAAwB7pB,QAAQc,eAAR,CAAwBE,OAF3C;AAGLoP,cAAwBnS,QAAQuB,IAAR,CAAa1B,IAHhC;AAIL2mB,sBAAwBxmB,QAAQwmB,gBAJ3B;AAKLC,qBAAwBzmB,QAAQymB,eAL3B;AAMLpmB,WAAwBL,QAAQK,KAN3B;AAOLwrB,cAAwB7rB,QAAQqE,KAAR,CAAc8C;AAPjC,GAAP;AASD,CAVD;;AAYA,IAAMjE,qBAAqB,SAArBA,kBAAqB,WAAY;AACrC,SAAO;AACL4oB,mBAAe,uBAAClqB,KAAD,EAAW;AACxBwB,eAAS,0BAAYxB,KAAZ,CAAT;AACAwB,eAAS,0BAAY,eAAZ,EAA6B,IAA7B,CAAT;AACD,KAJI;AAKL2oB,gBAAY,oBAACnqB,KAAD,EAAW;AACrBwB,eAAS,0BAAY,KAAZ,EAAmBxB,KAAnB,CAAT;AACD;AAPI,GAAP;AASD,CAVD;;kBAYe,yBAAQgB,eAAR,EAAyBM,kBAAzB,iB;;;;;;;;;;;;;;;AC5Bf;;;;AACA;;;;AACA;;;;;;;;;;;;IAEM8oB,e;;;AACJ,2BAAahmB,KAAb,EAAoB;AAAA;;AAAA,kIACZA,KADY;;AAElB,UAAKylB,WAAL,GAAmB,MAAKA,WAAL,CAAiBpc,IAAjB,OAAnB;AAFkB;AAGnB;;;;wCACoB;AAAA,mBACS,KAAKrJ,KADd;AAAA,UACX3F,KADW,UACXA,KADW;AAAA,UACJ8R,QADI,UACJA,QADI;;AAEnB,UAAI,CAAC9R,KAAL,EAAY;AACV,aAAK4rB,YAAL,CAAkB9Z,QAAlB;AACD;AACF;;;oDAC+C;AAAA,UAAnB9R,KAAmB,QAAnBA,KAAmB;AAAA,UAAZ8R,QAAY,QAAZA,QAAY;;AAC9C;AACA,UAAIA,aAAa,KAAKnM,KAAL,CAAWmM,QAA5B,EAAsC;AACpC,eAAO,KAAK8Z,YAAL,CAAkB9Z,QAAlB,CAAP;AACD;AACD;AACA,UAAI9R,UAAU,KAAK2F,KAAL,CAAW3F,KAAzB,EAAgC;AAC9B,aAAK6rB,aAAL,CAAmB7rB,KAAnB;AACD;AACF;;;gCACYoO,K,EAAO;AAClB,UAAI7M,QAAQ6M,MAAMga,MAAN,CAAa7mB,KAAzB;AACAA,cAAQ,KAAKuqB,YAAL,CAAkBvqB,KAAlB,CAAR;AACA;AACA,WAAKoE,KAAL,CAAW8lB,aAAX,CAAyBlqB,KAAzB;AACD;;;iCACawqB,K,EAAO;AACnBA,cAAQA,MAAM/d,OAAN,CAAc,MAAd,EAAsB,GAAtB,CAAR,CADmB,CACiB;AACpC+d,cAAQA,MAAM/d,OAAN,CAAc,gBAAd,EAAgC,EAAhC,CAAR,CAFmB,CAE2B;AAC9C,aAAO+d,KAAP;AACD;;;iCACaja,Q,EAAU;AACtB,UAAMka,wBAAwBla,SAASpB,SAAT,CAAmB,CAAnB,EAAsBoB,SAAS8U,WAAT,CAAqB,GAArB,CAAtB,CAA9B;AACA,UAAMqF,iBAAiB,KAAKH,YAAL,CAAkBE,qBAAlB,CAAvB;AACA,WAAKrmB,KAAL,CAAW8lB,aAAX,CAAyBQ,cAAzB;AACD;;;kCACcjsB,K,EAAO;AAAA;;AACpB,UAAI,CAACA,KAAL,EAAY;AACV,eAAO,KAAK2F,KAAL,CAAW+lB,UAAX,CAAsB,mBAAtB,CAAP;AACD;AACD,0DAAmC1rB,KAAnC,EACGiH,IADH,CACQ,YAAM;AACV,eAAKtB,KAAL,CAAW+lB,UAAX,CAAsB,IAAtB;AACD,OAHH,EAIGjjB,KAJH,CAIS,UAACzE,KAAD,EAAW;AAChB,eAAK2B,KAAL,CAAW+lB,UAAX,CAAsB1nB,MAAMnC,OAA5B;AACD,OANH;AAOD;;;6BACS;AAAA,oBACoG,KAAK8D,KADzG;AAAA,UACA3F,KADA,WACAA,KADA;AAAA,UACOsrB,mBADP,WACOA,mBADP;AAAA,UAC4BC,sBAD5B,WAC4BA,sBAD5B;AAAA,UACoDpF,gBADpD,WACoDA,gBADpD;AAAA,UACsEC,eADtE,WACsEA,eADtE;AAAA,UACuFoF,QADvF,WACuFA,QADvF;;AAER,aACE;AAAA;AAAA,UAAK,WAAU,kCAAf;AACE;AAAA;AAAA,YAAK,WAAU,oCAAf;AACE;AAAA;AAAA,cAAM,WAAU,qBAAhB;AAAA;AAAA,WADF;AAEE;AACE,8BAAkBrF,gBADpB;AAEE,6BAAiBC,eAFnB;AAGE,iCAAqBkF,mBAHvB;AAIE,oCAAwBC;AAJ1B,YAFF;AAQE,mDAAO,MAAK,MAAZ,EAAmB,IAAG,kBAAtB,EAAyC,WAAU,YAAnD,EAAgE,MAAK,OAArE,EAA6E,aAAY,eAAzF,EAAyG,UAAU,KAAKH,WAAxH,EAAqI,OAAOprB,KAA5I,GARF;AASKA,mBAAS,CAACwrB,QAAX,IAAwB;AAAA;AAAA,cAAM,IAAG,0BAAT,EAAoC,WAAU,sCAA9C;AAAsF;AAAtF,WAT5B;AAUIA,sBAAY;AAAA;AAAA,cAAM,IAAG,4BAAT,EAAsC,WAAU,sCAAhD;AAAwF;AAAxF;AAVhB,SADF;AAaE;AAAA;AAAA;AACIA,qBACA;AAAA;AAAA,cAAG,IAAG,wBAAN,EAA+B,WAAU,uBAAzC;AAAkEA;AAAlE,WADA,GAGA;AAAA;AAAA,cAAG,WAAU,cAAb;AAAA;AAAA;AAJJ;AAbF,OADF;AAuBD;;;;EA1E2B,gBAAMrlB,S;;kBA6ErBwlB,e;;;;;;;;;;;;;ACjFf;;;;AACA;;;;;;AAEA,SAASO,SAAT,OAAsG;AAAA,MAAjF/F,gBAAiF,QAAjFA,gBAAiF;AAAA,MAA/DC,eAA+D,QAA/DA,eAA+D;AAAA,MAA9CkF,mBAA8C,QAA9CA,mBAA8C;AAAA,MAAzBC,sBAAyB,QAAzBA,sBAAyB;;AACpG,MAAIpF,gBAAJ,EAAsB;AACpB,QAAIC,oBAAoBkF,mBAAxB,EAA6C;AAC3C,aAAO;AAAA;AAAA,UAAM,IAAG,aAAT,EAAuB,WAAU,qBAAjC;AAAwDA,2BAAxD;AAAA;AAA8EC,8BAA9E;AAAA;AAAA,OAAP;AACD;AACD,WAAO;AAAA;AAAA,QAAM,IAAG,yBAAT,EAAmC,WAAU,6BAA7C;AAAA;AAAmF;AAAA;AAAA;AACxF,qBAAU,cAD8E;AAAA;AAAA,OAAnF;AAAA;AAAA,KAAP;AAED;AACD,SACE;AAAA;AAAA,MAAM,IAAG,4BAAT,EAAsC,WAAU,6BAAhD;AAAA;AAAiF;AAAA;AAAA,QAAM,WAAU,cAAhB;AAAA;AAAA,KAAjF;AAAA;AAAA,GADF;AAGD;;AAEDW,UAAU9lB,SAAV,GAAsB;AACpB+f,oBAAwB,oBAAU4E,IAAV,CAAehb,UADnB;AAEpBub,uBAAwB,oBAAUjlB,MAFd;AAGpBklB,0BAAwB,oBAAUllB;AAHd,CAAtB;;kBAMe6lB,S;;;;;;;;;;;;;ACtBf;;AACA;;AACA;;;;;;AAEA,IAAM3pB,kBAAkB,SAAlBA,eAAkB,OAA2B;AAAA,MAAbrB,IAAa,QAAxBvB,OAAwB,CAAbuB,IAAa;;AACjD,SAAO;AACLA;AADK,GAAP;AAGD,CAJD;;AAMA,IAAM2B,qBAAqB;AACzB9B;AADyB,CAA3B;;kBAIe,yBAAQwB,eAAR,EAAyBM,kBAAzB,iB;;;;;;;;;;;;;;;ACdf;;;;;;;;;;;;AAEA,SAASspB,aAAT,CAAuBC,OAAvB,EAAgC;AAC9B;AACA,MAAIC,aAAaC,KAAKF,QAAQG,KAAR,CAAc,GAAd,EAAmB,CAAnB,CAAL,CAAjB;AACA;AACA,MAAIC,aAAaJ,QAAQG,KAAR,CAAc,GAAd,EAAmB,CAAnB,EAAsBA,KAAtB,CAA4B,GAA5B,EAAiC,CAAjC,EAAoCA,KAApC,CAA0C,GAA1C,EAA+C,CAA/C,CAAjB;AACA;AACA,MAAIE,KAAK,IAAIC,UAAJ,CAAeL,WAAWrb,MAA1B,CAAT;AACA,OAAK,IAAI5B,IAAI,CAAb,EAAgBA,IAAIid,WAAWrb,MAA/B,EAAuC5B,GAAvC,EAA4C;AAC1Cqd,OAAGrd,CAAH,IAAQid,WAAWM,UAAX,CAAsBvd,CAAtB,CAAR;AACD;AACD,SAAO,IAAIwd,IAAJ,CAAS,CAACH,EAAD,CAAT,EAAe,EAACtrB,MAAMqrB,UAAP,EAAf,CAAP;AACD;;IAEKK,qB;;;AACJ,iCAAalnB,KAAb,EAAoB;AAAA;;AAAA,8IACZA,KADY;;AAElB,UAAK6E,KAAL,GAAa;AACXsiB,mBAAgB,IADL;AAEX9oB,aAAgB,IAFL;AAGX+oB,sBAAgB,CAHL;AAIXC,sBAAgB,IAJL;AAKXC,mBAAgB;AALL,KAAb;AAOA,UAAKC,qBAAL,GAA6B,MAAKA,qBAAL,CAA2Ble,IAA3B,OAA7B;AACA,UAAKme,kBAAL,GAA0B,MAAKA,kBAAL,CAAwBne,IAAxB,OAA1B;AACA,UAAKoe,eAAL,GAAuB,MAAKA,eAAL,CAAqBpe,IAArB,OAAvB;AAXkB;AAYnB;;;;wCACoB;AAAA,UACX9N,IADW,GACF,KAAKyE,KADH,CACXzE,IADW;;AAEnB,WAAKmsB,cAAL,CAAoBnsB,IAApB;AACD;;;8CAC0BosB,S,EAAW;AACpC;AACA,UAAIA,UAAUpsB,IAAV,IAAkBosB,UAAUpsB,IAAV,KAAmB,KAAKyE,KAAL,CAAWzE,IAApD,EAA0D;AAAA,YAChDA,IADgD,GACvCosB,SADuC,CAChDpsB,IADgD;;AAExD,aAAKmsB,cAAL,CAAoBnsB,IAApB;AACD;AACF;;;mCACeA,I,EAAM;AAAA;;AACpB,UAAMypB,gBAAgB,IAAIC,UAAJ,EAAtB;AACAD,oBAAcE,aAAd,CAA4B3pB,IAA5B;AACAypB,oBAAcG,SAAd,GAA0B,YAAM;AAC9B,YAAMyC,UAAU5C,cAAcxf,MAA9B;AACA,YAAMqiB,OAAOrB,cAAcoB,OAAd,CAAb;AACA,YAAMT,cAAcW,IAAIC,eAAJ,CAAoBF,IAApB,CAApB;AACA,eAAKhe,QAAL,CAAc,EAAEsd,wBAAF,EAAd;AACD,OALD;AAMD;;;0CACsB1e,K,EAAO;AAC5B,UAAMX,WAAWW,MAAMga,MAAN,CAAa3a,QAA9B;AACA,UAAMkgB,eAAehI,KAAKC,KAAL,CAAWnY,WAAW,EAAtB,CAArB;AACA,UAAMmgB,eAAejI,KAAKC,KAAL,CAAWnY,WAAW,EAAtB,CAArB;AACA;AACA,WAAK+B,QAAL,CAAc;AACZwd,wBAAgBvf,WAAW,GADf;AAEZwf,qBAAgBxf,WAAW,GAAX,GAAiB,CAFrB;AAGZkgB,kCAHY;AAIZC;AAJY,OAAd;AAMA;AACA,UAAIC,QAAQ5D,SAASC,cAAT,CAAwB,oBAAxB,CAAZ;AACA2D,YAAMC,WAAN,GAAoBrgB,WAAW,CAA/B;AACD;;;uCACmBW,K,EAAO;AACzB,UAAM7M,QAAQ6jB,SAAShX,MAAMga,MAAN,CAAa7mB,KAAtB,CAAd;AACA;AACA,WAAKiO,QAAL,CAAc;AACZyd,qBAAa1rB;AADD,OAAd;AAGA;AACA,UAAIssB,QAAQ5D,SAASC,cAAT,CAAwB,oBAAxB,CAAZ;AACA2D,YAAMC,WAAN,GAAoBvsB,QAAQ,GAA5B;AACD;;;sCACkB;AACjB;AACA,UAAIssB,QAAQ5D,SAASC,cAAT,CAAwB,oBAAxB,CAAZ;AACA,UAAI6D,SAAS9D,SAAS+D,aAAT,CAAuB,QAAvB,CAAb;AACAD,aAAOE,KAAP,GAAeJ,MAAMK,UAArB;AACAH,aAAOxa,MAAP,GAAgBsa,MAAMM,WAAtB;AACAJ,aAAOK,UAAP,CAAkB,IAAlB,EAAwBC,SAAxB,CAAkCR,KAAlC,EAAyC,CAAzC,EAA4C,CAA5C,EAA+CE,OAAOE,KAAtD,EAA6DF,OAAOxa,MAApE;AACA,UAAM+a,UAAUP,OAAOQ,SAAP,EAAhB;AACA,UAAMf,OAAOrB,cAAcmC,OAAd,CAAb;AACA,UAAME,WAAW,IAAI1lB,IAAJ,CAAS,CAAC0kB,IAAD,CAAT,mBAAkC;AACjDrsB,cAAM;AAD2C,OAAlC,CAAjB;AAGA;AACA,UAAIqtB,QAAJ,EAAc;AACZ,aAAK7oB,KAAL,CAAW5E,cAAX,CAA0BytB,QAA1B;AACD;AACF;;;6BACS;AAAA,mBACgG,KAAKhkB,KADrG;AAAA,UACAxG,KADA,UACAA,KADA;AAAA,UACO8oB,WADP,UACOA,WADP;AAAA,UACoBC,cADpB,UACoBA,cADpB;AAAA,UACoCC,cADpC,UACoCA,cADpC;AAAA,UACoDC,WADpD,UACoDA,WADpD;AAAA,UACiEU,YADjE,UACiEA,YADjE;AAAA,UAC+EC,YAD/E,UAC+EA,YAD/E;;AAER,aACE;AAAA;AAAA;AACE;AAAA;AAAA,YAAO,WAAU,OAAjB;AAAA;AAAA,SADF;AAEE;AACE,cAAG,oBADL;AAEE,mBAAQ,UAFV;AAGE,qBAHF;AAIE,iBAAO,EAACa,SAAS,MAAV,EAJT;AAKE,2BALF;AAME,wBAAc,KAAKvB,qBANrB;AAOE,eAAKJ,WAPP;AAQE,oBAAU,KAAKM;AARjB,UAFF;AAaIH,sBACE;AAAA;AAAA;AACE;AAAA;AAAA,cAAK,WAAU,0DAAf,EAA0E,OAAO,EAACgB,OAAO,MAAR,EAAjF;AACE;AAAA;AAAA,gBAAM,WAAU,cAAhB;AAAA;AAAA,aADF;AAEE;AAAA;AAAA,gBAAM,WAAU,cAAhB;AAAgCN,0BAAhC;AAAA;AAA+CC,0BAA/C;AAAA;AAAA;AAFF,WADF;AAKE;AAAA;AAAA;AACE;AACE,oBAAK,OADP;AAEE,mBAAKb,cAFP;AAGE,mBAAKC,cAHP;AAIE,qBAAOC,WAJT;AAKE,yBAAU,QALZ;AAME,wBAAU,KAAKE;AANjB;AADF;AALF,SADF,GAkBE;AAAA;AAAA,YAAG,WAAU,cAAb;AAAA;AAAA,SA/BN;AAkCInpB,gBACA;AAAA;AAAA,YAAG,WAAU,uBAAb;AAAsCA;AAAtC,SADA,GAGA;AAAA;AAAA,YAAG,WAAU,cAAb;AAAA;AAAA;AArCJ,OADF;AA0CD;;;;EAzHiC,gBAAMmC,S;;kBA4H3B0mB,qB;;;;;;;;;;;;;AC3If;;AACA;;AACA;;;;;;AAEA,IAAMtqB,kBAAkB,SAAlBA,eAAkB,OAAiB;AAAA,MAAd5C,OAAc,QAAdA,OAAc;;AACvC,SAAO;AACLuC,wBAAoBvC,QAAQuC,kBADvB;AAELxC,iBAAoBC,QAAQ6S,QAAR,CAAiB9S,WAFhC;AAGL4R,aAAoB3R,QAAQ6S,QAAR,CAAiBlB,OAHhC;AAILD,UAAoB1R,QAAQ6S,QAAR,CAAiBnB;AAJhC,GAAP;AAMD,CAPD;;AASA,IAAMxO,qBAAqB,SAArBA,kBAAqB,WAAY;AACrC,SAAO;AACLqoB,sBAAkB,0BAAC1rB,IAAD,EAAO+B,KAAP,EAAiB;AACjCwB,eAAS,6BAAevD,IAAf,EAAqB+B,KAArB,CAAT;AACD,KAHI;AAILmtB,4BAAwB,gCAACntB,KAAD,EAAW;AACjCwB,eAAS,mCAAqBxB,KAArB,CAAT;AACD;AANI,GAAP;AAQD,CATD;;kBAWe,yBAAQgB,eAAR,EAAyBM,kBAAzB,iB;;;;;;;;;;;;;;;ACxBf;;;;AACA;;;;;;;;;;;;IAEM8rB,qB;;;AACJ,iCAAahpB,KAAb,EAAoB;AAAA;;AAAA,8IACZA,KADY;;AAElB,UAAKipB,gBAAL,GAAwB,MAAKA,gBAAL,CAAsB5f,IAAtB,OAAxB;AACA,UAAKoc,WAAL,GAAmB,MAAKA,WAAL,CAAiBpc,IAAjB,OAAnB;AACA,UAAK6f,YAAL,GAAoB,MAAKA,YAAL,CAAkB7f,IAAlB,OAApB;AAJkB;AAKnB;;;;uCACmB;AAClB,WAAKrJ,KAAL,CAAW+oB,sBAAX,CAAkC,CAAC,KAAK/oB,KAAL,CAAWzD,kBAA9C;AACD;;;gCACYkM,K,EAAO;AAClB,UAAMga,SAASha,MAAMga,MAArB;AACA,UAAM7mB,QAAQ6mB,OAAOjnB,IAAP,KAAgB,UAAhB,GAA6BinB,OAAO0G,OAApC,GAA8C1G,OAAO7mB,KAAnE;AACA,UAAM/B,OAAO4oB,OAAO5oB,IAApB;AACA,WAAKmG,KAAL,CAAWulB,gBAAX,CAA4B1rB,IAA5B,EAAkC+B,KAAlC;AACD;;;iCACa6M,K,EAAO;AACnB,UAAM5O,OAAO4O,MAAMga,MAAN,CAAa5oB,IAA1B;AACA,UAAMuvB,iBAAiB3gB,MAAMga,MAAN,CAAaC,eAAb,CAA6B,CAA7B,EAAgC9mB,KAAvD;AACA,WAAKoE,KAAL,CAAWulB,gBAAX,CAA4B1rB,IAA5B,EAAkCuvB,cAAlC;AACD;;;6BACS;AACR,aACE;AAAA;AAAA,UAAK,IAAG,iBAAR,EAA0B,WAAU,uCAApC;AACG,aAAKppB,KAAL,CAAWzD,kBAAX,IACC;AAAA;AAAA;AACE;AAAA;AAAA,cAAK,WAAU,iBAAf;AACE;AAAA;AAAA,gBAAK,WAAU,mDAAf;AACE;AAAA;AAAA,kBAAO,SAAQ,iBAAf,EAAiC,WAAU,OAA3C;AAAA;AAAA;AADF,aADF;AAGQ;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACJ;AACE,oBAAG,qBADL;AAEE,2BAAU,iDAFZ;AAGE,sBAAM,CAHR;AAIE,2BAAW,IAJb;AAKE,uBAAO,EAAE8sB,WAAW,GAAb,EALT;AAME,sBAAK,aANP;AAOE,6BAAY,sBAPd;AAQE,uBAAO,KAAKrpB,KAAL,CAAWjG,WARpB;AASE,0BAAU,KAAK0rB,WATjB;AADI;AAHR,WADF;AAkBE;AAAA;AAAA,cAAK,WAAU,iBAAf;AACE;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACE;AAAA;AAAA,kBAAO,SAAQ,iBAAf,EAAiC,WAAU,OAA3C;AAAA;AAAA;AADF,aADF;AAGQ;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACJ;AAAA;AAAA,kBAAQ,MAAK,MAAb,EAAoB,MAAK,SAAzB,EAAmC,IAAG,iBAAtC,EAAwD,WAAU,wBAAlE,EAA2F,UAAU,KAAKyD,YAA1G;AACE;AAAA;AAAA,oBAAQ,OAAM,GAAd;AAAA;AAAA,iBADF;AAEE;AAAA;AAAA,oBAAQ,OAAM,eAAd;AAAA;AAAA,iBAFF;AAGE;AAAA;AAAA,oBAAQ,OAAM,kBAAd;AAAA;AAAA;AAHF;AADI;AAHR,WAlBF;AA8BE;AAAA;AAAA,cAAK,WAAU,iBAAf;AACE;AAAA;AAAA,gBAAK,WAAU,kBAAf;AACE;AAAA;AAAA,kBAAO,SAAQ,cAAf,EAA8B,WAAU,OAAxC;AAAA;AAAA;AADF,aADF;AAGQ;AAAA;AAAA,gBAAK,WAAU,kBAAf;AACJ,uDAAO,WAAU,gBAAjB,EAAkC,MAAK,UAAvC,EAAkD,IAAG,cAArD,EAAoE,MAAK,MAAzE,EAAgF,OAAO,KAAKlpB,KAAL,CAAW0L,IAAlG,EAAwG,UAAU,KAAK+Z,WAAvH;AADI;AAHR;AA9BF,SAFJ;AAyCE;AAAA;AAAA,YAAQ,WAAU,mBAAlB,EAAsC,SAAS,KAAKwD,gBAApD;AAAuE,eAAKjpB,KAAL,CAAWzD,kBAAX,GAAgC,MAAhC,GAAyC;AAAhH;AAzCF,OADF;AA6CD;;;;EAnEiC,gBAAMiE,S;;kBAsE3BwoB,qB;;;;;;;;;;;;;;;;;ACzEf;;;;AACA;;;;;;;;;;;;;;IAEMM,iB;;;AACJ,6BAAatpB,KAAb,EAAoB;AAAA;;AAAA,sIACZA,KADY;;AAElB,UAAKupB,aAAL,GAAqB,MAAKA,aAAL,CAAmBlgB,IAAnB,OAArB;AAFkB;AAGnB;;;;wCACoB;AACnB,WAAKmgB,cAAL,CAAoB,EAApB;AACD;;;kCACc/gB,K,EAAO;AAAA,UACZghB,QADY,GACC,KAAKzpB,KADN,CACZypB,QADY;;AAEpB,UAAIA,QAAJ,EAAcA,SAAShhB,KAAT;AACd,WAAK+gB,cAAL,CAAoB/gB,KAApB;AACD;;;yCACqC;AAAA,6BAApBga,MAAoB;AAAA,UAApBA,MAAoB,+BAAX,KAAKiH,EAAM;;AACpCjH,aAAOkH,KAAP,CAAa/b,MAAb,GAAsB,CAAtB;AACA6U,aAAOkH,KAAP,CAAa/b,MAAb,GAAyB6U,OAAOmH,YAAhC;AACD;;;6BACS;AAAA;;AAAA,UACGC,IADH,4BACY,KAAK7pB,KADjB;;AAER,aACE,uDACM6pB,IADN;AAEE,aAAK;AAAA,iBAAK,OAAKH,EAAL,GAAUI,CAAf;AAAA,SAFP;AAGE,kBAAU,KAAKP;AAHjB,SADF;AAOD;;;;;;AAGHD,kBAAkB7oB,SAAlB,GAA8B;AAC5BgpB,YAAU,oBAAUM;AADQ,CAA9B;;kBAIeT,iB;;;;;;;;;;;;;ACpCf;;AACA;;AACA;;;;;;AAEA,IAAM1sB,kBAAkB,SAAlBA,eAAkB,OAA0B;AAAA,MAAvBb,OAAuB,QAAvBA,OAAuB;AAAA,MAAd/B,OAAc,QAAdA,OAAc;;AAChD,SAAO;AACL2rB,yBAAqB5pB,QAAQc,eAAR,CAAwBhD,IADxC;AAEL2mB,sBAAqBxmB,QAAQwmB,gBAFxB;AAGLC,qBAAqBzmB,QAAQymB,eAHxB;AAILuJ,kBAAqBhwB,QAAQqE,KAAR,CAActC;AAJ9B,GAAP;AAMD,CAPD;;AASA,IAAMmB,qBAAqB,SAArBA,kBAAqB,WAAY;AACrC,SAAO;AACL+sB,8BAA0B,kCAACruB,KAAD,EAAW;AACnCwB,eAAS,0BAAY,SAAZ,EAAuB,IAAvB,CAAT;AACAA,eAAS,kCAAoBxB,KAApB,CAAT;AACD,KAJI;AAKLsuB,qBAAiB,yBAACtuB,KAAD,EAAW;AAC1BwB,eAAS,0BAAY,SAAZ,EAAuB,IAAvB,CAAT;AACAA,eAAS,oCAAsBxB,KAAtB,CAAT;AACD;AARI,GAAP;AAUD,CAXD;;kBAae,yBAAQgB,eAAR,EAAyBM,kBAAzB,iB;;;;;;;;;;;;;;;AC1Bf;;;;AACA;;;;AACA;;;;AACA;;IAAYitB,M;;;;;;;;;;;;IAENC,a;;;AACJ,yBAAapqB,KAAb,EAAoB;AAAA;;AAAA,8HACZA,KADY;;AAElB,UAAKqqB,sBAAL,GAA8B,MAAKA,sBAAL,CAA4BhhB,IAA5B,OAA9B;AACA,UAAKkZ,eAAL,GAAuB,MAAKA,eAAL,CAAqBlZ,IAArB,OAAvB;AAHkB;AAInB;;;;2CACuBZ,K,EAAO;AAC7B,UAAM7M,QAAQ6M,MAAMga,MAAN,CAAa7mB,KAA3B;AACA,UAAIA,UAAU,WAAd,EAA2B;AACzB,aAAKoE,KAAL,CAAWiqB,wBAAX,CAAoC,KAApC;AACD,OAFD,MAEO;AACL,aAAKjqB,KAAL,CAAWiqB,wBAAX,CAAoC,IAApC;AACD;AACF;;;oCACgBxhB,K,EAAO;AACtB,UAAM2gB,iBAAiB3gB,MAAMga,MAAN,CAAaC,eAAb,CAA6B,CAA7B,EAAgC9mB,KAAvD;AACA,WAAKoE,KAAL,CAAWkqB,eAAX,CAA2Bd,cAA3B;AACD;;;6BACS;AACR,aACE;AAAA;AAAA;AACE;AAAA;AAAA;AACE;AAAA;AAAA,cAAK,WAAU,iCAAf;AACE,qDAAO,MAAK,OAAZ,EAAoB,MAAK,sBAAzB,EAAgD,IAAG,iBAAnD,EAAqE,WAAU,aAA/E,EAA6F,OAAM,WAAnG,EAA+G,SAAS,CAAC,KAAKppB,KAAL,CAAWwgB,gBAApI,EAAsJ,UAAU,KAAK6J,sBAArK,GADF;AAEE;AAAA;AAAA,gBAAO,WAAU,sBAAjB,EAAwC,SAAQ,iBAAhD;AAAA;AAAA;AAFF,WADF;AAKE;AAAA;AAAA,cAAK,WAAU,iCAAf;AACE,qDAAO,MAAK,OAAZ,EAAoB,MAAK,sBAAzB,EAAgD,IAAG,eAAnD,EAAmE,WAAU,aAA7E,EAA2F,OAAM,cAAjG,EAAgH,SAAS,KAAKrqB,KAAL,CAAWwgB,gBAApI,EAAsJ,UAAU,KAAK6J,sBAArK,GADF;AAEE;AAAA;AAAA,gBAAO,WAAU,sBAAjB,EAAwC,SAAQ,eAAhD;AAAA;AAAA;AAFF,WALF;AASI,eAAKrqB,KAAL,CAAWgqB,YAAX,GACA;AAAA;AAAA,cAAG,WAAU,uBAAb;AAAsC,iBAAKhqB,KAAL,CAAWgqB;AAAjD,WADA,GAGA;AAAA;AAAA,cAAG,WAAU,cAAb;AAAA;AAAA;AAZJ,SADF;AAgBI,aAAKhqB,KAAL,CAAWwgB,gBAAX,IACA;AAAA;AAAA;AACE;AAAA;AAAA,cAAK,WAAU,kBAAf;AACE;AAAA;AAAA,gBAAO,WAAU,OAAjB,EAAyB,SAAQ,qBAAjC;AAAA;AAAA;AADF,WADF;AAGQ;AAAA;AAAA,cAAK,WAAU,kBAAf;AACJ;AAAA;AAAA,gBAAQ,MAAK,MAAb,EAAoB,IAAG,qBAAvB,EAA6C,WAAU,sBAAvD,EAA8E,OAAO,KAAKxgB,KAAL,CAAWygB,eAAhG,EAAiH,UAAU,KAAK8B,eAAhI;AACI,mBAAKviB,KAAL,CAAW2lB,mBAAX,IAAkC;AAAA;AAAA,kBAAQ,OAAO,KAAK3lB,KAAL,CAAW2lB,mBAA1B,EAA+C,IAAG,uCAAlD;AAA2F,qBAAK3lB,KAAL,CAAW2lB;AAAtG,eADtC;AAEE;AAAA;AAAA,kBAAQ,OAAOwE,OAAO1Z,KAAtB;AAAA;AAAA,eAFF;AAGE;AAAA;AAAA,kBAAQ,OAAO0Z,OAAOzZ,MAAtB;AAAA;AAAA;AAHF;AADI,WAHR;AAUK,eAAK1Q,KAAL,CAAWygB,eAAX,KAA+B0J,OAAO1Z,KAAvC,IAAiD,+DAVrD;AAWK,eAAKzQ,KAAL,CAAWygB,eAAX,KAA+B0J,OAAOzZ,MAAvC,IAAkD;AAXtD;AAjBJ,OADF;AAkCD;;;;EArDyB,gBAAMlQ,S;;kBAwDnB4pB,a;;;;;;;;;;;;;;;AC7Df;;;;AACA;;;;;;;;;;;;;;IAEME,gB;;;AACJ,4BAAatqB,KAAb,EAAoB;AAAA;;AAAA,oIACZA,KADY;;AAElB,UAAK6E,KAAL,GAAa;AACXxG,aAAU,IADC;AAEXxE,YAAU,EAFC;AAGXmI,gBAAU;AAHC,KAAb;AAKA,UAAKyjB,WAAL,GAAmB,MAAKA,WAAL,CAAiBpc,IAAjB,OAAnB;AACA,UAAKkhB,cAAL,GAAsB,MAAKA,cAAL,CAAoBlhB,IAApB,OAAtB;AARkB;AASnB;;;;gCACYZ,K,EAAO;AAClB,UAAM5O,OAAO4O,MAAMga,MAAN,CAAa5oB,IAA1B;AACA,UAAM+B,QAAQ6M,MAAMga,MAAN,CAAa7mB,KAA3B;AACA,WAAKiO,QAAL,qBAAgBhQ,IAAhB,EAAuB+B,KAAvB;AACD;;;mCACe6M,K,EAAO;AAAA;;AACrBA,YAAMob,cAAN;AACA,UAAM1lB,SAAS;AACb8H,gBAAS,MADI;AAEb6S,cAASrT,KAAKC,SAAL,CAAe,EAAC3D,UAAU,KAAK8C,KAAL,CAAWhL,IAAtB,EAA4BmI,UAAU,KAAK6C,KAAL,CAAW7C,QAAjD,EAAf,CAFI;AAGbgF,iBAAS,IAAIwjB,OAAJ,CAAY;AACnB,0BAAgB;AADG,SAAZ,CAHI;AAMbhI,qBAAa;AANA,OAAf;AAQA,6BAAQ,OAAR,EAAiBrkB,MAAjB,EACGmD,IADH,CACQ,gBAAqE;AAAA,YAAnEiN,OAAmE,QAAnEA,OAAmE;AAAA,YAA1DlS,WAA0D,QAA1DA,WAA0D;AAAA,YAA7CiZ,cAA6C,QAA7CA,cAA6C;AAAA,YAA7BzG,cAA6B,QAA7BA,cAA6B;AAAA,YAAb3S,OAAa,QAAbA,OAAa;;AACzE,YAAIqS,OAAJ,EAAa;AACX,iBAAKvO,KAAL,CAAW7C,cAAX,CAA0Bd,WAA1B,EAAuCiZ,cAAvC,EAAuDzG,cAAvD;AACD,SAFD,MAEO;AACL,iBAAKhF,QAAL,CAAc,EAAC,SAAS3N,OAAV,EAAd;AACD;AACF,OAPH,EAQG4G,KARH,CAQS,iBAAS;AACd,YAAIzE,MAAMnC,OAAV,EAAmB;AACjB,iBAAK2N,QAAL,CAAc,EAAC,SAASxL,MAAMnC,OAAhB,EAAd;AACD,SAFD,MAEO;AACL,iBAAK2N,QAAL,CAAc,EAAC,SAASxL,KAAV,EAAd;AACD;AACF,OAdH;AAeD;;;6BACS;AACR,aACE;AAAA;AAAA,UAAM,IAAG,oBAAT;AACE;AAAA;AAAA,YAAK,WAAU,0BAAf;AACE;AAAA;AAAA,cAAK,WAAU,iCAAf;AACE;AAAA;AAAA,gBAAO,WAAU,OAAjB,EAAyB,SAAQ,0BAAjC;AAAA;AAAA;AADF,WADF;AAGQ;AAAA;AAAA,cAAK,WAAU,iCAAf;AACJ;AAAA;AAAA,gBAAK,WAAU,qEAAf;AACE;AAAA;AAAA;AAAA;AAAA,eADF;AAEE,uDAAO,MAAK,MAAZ,EAAmB,IAAG,0BAAtB,EAAiD,WAAU,YAA3D,EAAwE,MAAK,MAA7E,EAAoF,aAAY,mBAAhG,EAAoH,OAAO,KAAKwG,KAAL,CAAWxI,WAAtI,EAAmJ,UAAU,KAAKopB,WAAlK;AAFF;AADI;AAHR,SADF;AAWE;AAAA;AAAA,YAAK,WAAU,0BAAf;AACE;AAAA;AAAA,cAAK,WAAU,iCAAf;AACE;AAAA;AAAA,gBAAO,WAAU,OAAjB,EAAyB,SAAQ,8BAAjC;AAAA;AAAA;AADF,WADF;AAGQ;AAAA;AAAA,cAAK,WAAU,iCAAf;AACJ;AAAA;AAAA,gBAAK,WAAU,qBAAf;AACE,uDAAO,MAAK,UAAZ,EAAuB,IAAG,8BAA1B,EAAyD,MAAK,UAA9D,EAAyE,WAAU,YAAnF,EAAgG,aAAY,EAA5G,EAA+G,OAAO,KAAK5gB,KAAL,CAAWyU,eAAjI,EAAkJ,UAAU,KAAKmM,WAAjK;AADF;AADI;AAHR,SAXF;AAoBI,aAAK5gB,KAAL,CAAWxG,KAAX,GACA;AAAA;AAAA,YAAG,WAAU,uBAAb;AAAsC,eAAKwG,KAAL,CAAWxG;AAAjD,SADA,GAGA;AAAA;AAAA,YAAG,WAAU,cAAb;AAAA;AAAA,SAvBJ;AAyBE;AAAA;AAAA,YAAK,WAAU,eAAf;AACE;AAAA;AAAA,cAAQ,WAAU,iBAAlB,EAAoC,SAAS,KAAKksB,cAAlD;AAAA;AAAA;AADF;AAzBF,OADF;AA+BD;;;;EA1E4B,gBAAM/pB,S;;kBA6EtB8pB,gB;;;;;;;;;;;;;;;AChFf;;;;AACA;;;;AACA;;;;;;;;;;;;;;IAEMG,iB;;;AACJ,6BAAazqB,KAAb,EAAoB;AAAA;;AAAA,sIACZA,KADY;;AAElB,UAAK6E,KAAL,GAAa;AACXxG,aAAU,IADC;AAEXtC,eAAU,EAFC;AAGXiG,gBAAU,EAHC;AAIX/F,cAAU;AAJC,KAAb;AAMA,UAAKyuB,kBAAL,GAA0B,MAAKA,kBAAL,CAAwBrhB,IAAxB,OAA1B;AACA,UAAKoc,WAAL,GAAmB,MAAKA,WAAL,CAAiBpc,IAAjB,OAAnB;AACA,UAAK3C,aAAL,GAAqB,MAAKA,aAAL,CAAmB2C,IAAnB,OAArB;AAVkB;AAWnB;;;;wCACoB+c,K,EAAO;AAC1BA,cAAQA,MAAM/d,OAAN,CAAc,MAAd,EAAsB,GAAtB,CAAR,CAD0B,CACU;AACpC+d,cAAQA,MAAM/d,OAAN,CAAc,gBAAd,EAAgC,EAAhC,CAAR,CAF0B,CAEoB;AAC9C,aAAO+d,KAAP;AACD;;;uCACmB3d,K,EAAO;AACzB,UAAI7M,QAAQ6M,MAAMga,MAAN,CAAa7mB,KAAzB;AACAA,cAAQ,KAAK+uB,mBAAL,CAAyB/uB,KAAzB,CAAR;AACA,WAAKiO,QAAL,CAAc,EAAC9N,SAASH,KAAV,EAAd;AACA,UAAIA,KAAJ,EAAW;AACT,aAAKgvB,wBAAL,CAA8BhvB,KAA9B;AACD,OAFD,MAEO;AACL,aAAKiO,QAAL,CAAc,EAACxL,OAAO,6BAAR,EAAd;AACD;AACF;;;gCACYoK,K,EAAO;AAClB,UAAM5O,OAAO4O,MAAMga,MAAN,CAAa5oB,IAA1B;AACA,UAAM+B,QAAQ6M,MAAMga,MAAN,CAAa7mB,KAA3B;AACA,WAAKiO,QAAL,qBAAgBhQ,IAAhB,EAAuB+B,KAAvB;AACD;;;6CACyBG,O,EAAS;AAAA;;AACjC,UAAM8uB,4BAA0B9uB,OAAhC;AACA,4DAAqC8uB,mBAArC,EACGvpB,IADH,CACQ,uBAAe;AACnB,YAAIwpB,WAAJ,EAAiB;AACf,iBAAKjhB,QAAL,CAAc,EAAC,SAAS,IAAV,EAAd;AACD,SAFD,MAEO;AACL,iBAAKA,QAAL,CAAc,EAAC,SAAS,uCAAV,EAAd;AACD;AACF,OAPH,EAQG/G,KARH,CAQS,UAACzE,KAAD,EAAW;AAChB,eAAKwL,QAAL,CAAc,EAAC,SAASxL,MAAMnC,OAAhB,EAAd;AACD,OAVH;AAWD;;;4CACwBH,O,EAAS;AAChC,UAAM8uB,4BAA0B9uB,OAAhC;AACA,aAAO,IAAIwF,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,8DAAqCslB,mBAArC,EACGvpB,IADH,CACQ,uBAAe;AACnB,cAAI,CAACwpB,WAAL,EAAkB;AAChB,mBAAOvlB,OAAO,IAAIrE,KAAJ,CAAU,uCAAV,CAAP,CAAP;AACD;AACDoE;AACD,SANH,EAOGxC,KAPH,CAOS,UAACzE,KAAD,EAAW;AAChBkH,iBAAOlH,KAAP;AACD,SATH;AAUD,OAXM,CAAP;AAYD;;;8CAC0B;AACzB,UAAM2D,WAAW,KAAK6C,KAAL,CAAW7C,QAA5B;AACA,aAAO,IAAIT,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,YAAI,CAACvD,QAAD,IAAaA,SAASqJ,MAAT,GAAkB,CAAnC,EAAsC;AACpC,iBAAO9F,OAAO,IAAIrE,KAAJ,CAAU,2BAAV,CAAP,CAAP;AACD;AACDoE;AACD,OALM,CAAP;AAMD;;;8CAC0BvD,Q,EAAUC,Q,EAAU;AAC7C,UAAM7D,SAAS;AACb8H,gBAAS,MADI;AAEb6S,cAASrT,KAAKC,SAAL,CAAe,EAAC3D,kBAAD,EAAWC,kBAAX,EAAf,CAFI;AAGbgF,iBAAS,IAAIwjB,OAAJ,CAAY;AACnB,0BAAgB;AADG,SAAZ,CAHI;AAMbhI,qBAAa;AANA,OAAf;AAQA,aAAO,IAAIjhB,OAAJ,CAAY,UAAC+D,OAAD,EAAUC,MAAV,EAAqB;AACtC,+BAAQ,SAAR,EAAmBpH,MAAnB,EACGmD,IADH,CACQ,kBAAU;AACd,iBAAOgE,QAAQE,MAAR,CAAP;AACD,SAHH,EAIG1C,KAJH,CAIS,iBAAS;AACdyC,iBAAO,IAAIrE,KAAJ,yGAAgH7C,MAAMnC,OAAtH,CAAP;AACD,SANH;AAOD,OARM,CAAP;AASD;;;kCACcuM,K,EAAO;AAAA;;AACpBA,YAAMob,cAAN;AACA,WAAKkH,uBAAL,GACGzpB,IADH,CACQ,YAAM;AACV,eAAO,OAAK0pB,uBAAL,CAA6B,OAAKnmB,KAAL,CAAW9I,OAAxC,EAAiD,OAAK8I,KAAL,CAAW7C,QAA5D,CAAP;AACD,OAHH,EAIGV,IAJH,CAIQ,YAAM;AACV,eAAKuI,QAAL,CAAc,EAAC5N,QAAQ,mDAAT,EAAd;AACA,eAAO,OAAKgvB,yBAAL,CAA+B,OAAKpmB,KAAL,CAAW9I,OAA1C,EAAmD,OAAK8I,KAAL,CAAW7C,QAA9D,CAAP;AACD,OAPH,EAQGV,IARH,CAQQ,kBAAU;AACd,eAAKuI,QAAL,CAAc,EAAC5N,QAAQ,IAAT,EAAd;AACA,eAAK+D,KAAL,CAAW7C,cAAX,CAA0BqI,OAAOnJ,WAAjC,EAA8CmJ,OAAO8P,cAArD,EAAqE9P,OAAOqJ,cAA5E;AACD,OAXH,EAYG/L,KAZH,CAYS,UAACzE,KAAD,EAAW;AAChB,eAAKwL,QAAL,CAAc,EAAC,SAASxL,MAAMnC,OAAhB,EAAyBD,QAAQ,IAAjC,EAAd;AACD,OAdH;AAeD;;;6BACS;AACR,aACE;AAAA;AAAA;AACI,SAAC,KAAK4I,KAAL,CAAW5I,MAAZ,GACA;AAAA;AAAA,YAAM,IAAG,sBAAT;AACE;AAAA;AAAA,cAAK,WAAU,0BAAf;AACE;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACE;AAAA;AAAA,kBAAO,WAAU,OAAjB,EAAyB,SAAQ,kBAAjC;AAAA;AAAA;AADF,aADF;AAGQ;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACJ;AAAA;AAAA,kBAAK,WAAU,oFAAf;AACE;AAAA;AAAA;AAAA;AAAA,iBADF;AAEE,yDAAO,MAAK,MAAZ,EAAmB,MAAK,SAAxB,EAAkC,IAAG,kBAArC,EAAwD,WAAU,YAAlE,EAA+E,aAAY,oBAA3F,EAAgH,OAAO,KAAK4I,KAAL,CAAW9I,OAAlI,EAA2I,UAAU,KAAK2uB,kBAA1J,GAFF;AAGK,qBAAK7lB,KAAL,CAAW9I,OAAX,IAAsB,CAAC,KAAK8I,KAAL,CAAWxG,KAAnC,IAA6C;AAAA;AAAA,oBAAM,IAAG,4BAAT,EAAsC,WAAU,sCAAhD;AAAwF;AAAxF,iBAHjD;AAII,qBAAKwG,KAAL,CAAWxG,KAAX,IAAoB;AAAA;AAAA,oBAAM,IAAG,4BAAT,EAAsC,WAAU,sCAAhD;AAAwF;AAAxF;AAJxB;AADI;AAHR,WADF;AAaE;AAAA;AAAA,cAAK,WAAU,0BAAf;AACE;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACE;AAAA;AAAA,kBAAO,WAAU,OAAjB,EAAyB,SAAQ,sBAAjC;AAAA;AAAA;AADF,aADF;AAGQ;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACJ;AAAA;AAAA,kBAAK,WAAU,qBAAf;AACE,yDAAO,MAAK,UAAZ,EAAuB,MAAK,UAA5B,EAAuC,IAAG,sBAA1C,EAAiE,WAAU,YAA3E,EAAyF,aAAY,EAArG,EAAwG,OAAO,KAAKwG,KAAL,CAAW7C,QAA1H,EAAoI,UAAU,KAAKyjB,WAAnJ;AADF;AADI;AAHR,WAbF;AAsBG,eAAK5gB,KAAL,CAAWxG,KAAX,GACC;AAAA;AAAA,cAAG,WAAU,uBAAb;AAAsC,iBAAKwG,KAAL,CAAWxG;AAAjD,WADD,GAGC;AAAA;AAAA,cAAG,WAAU,cAAb;AAAA;AAAA,WAzBJ;AA2BE;AAAA;AAAA,cAAK,WAAU,eAAf;AACE;AAAA;AAAA,gBAAQ,WAAU,iBAAlB,EAAoC,SAAS,KAAKqI,aAAlD;AAAA;AAAA;AADF;AA3BF,SADA,GAiCA;AAAA;AAAA;AACE;AAAA;AAAA,cAAG,WAAU,YAAb;AAA2B,iBAAK7B,KAAL,CAAW5I;AAAtC,WADF;AAEE,iEAAa,MAAM,EAAnB;AAFF;AAlCJ,OADF;AA0CD;;;;EAvJ6B,gBAAMuE,S;;kBA0JvBiqB,iB;;;;;;;;;;;;;AC9Jf;;;;;;AAEA,IAAMS,kBAAkB,SAAlBA,eAAkB,GAAM;AAC5B,SAAO;AAAA;AAAA,MAAM,WAAU,mCAAhB;AAAA;AAAA,GAAP;AACD,CAFD;;kBAIeA,e;;;;;;;;;;;;;ACNf;;;;;;AAEA,IAAMC,oBAAoB,SAApBA,iBAAoB,GAAM;AAC9B,SAAO;AAAA;AAAA,MAAM,WAAU,qCAAhB;AAAA;AAAA,GAAP;AACD,CAFD;;kBAIeA,iB;;;;;;;;;;;;;ACNf;;AACA;;AACA;;;;;;AAEA,IAAMvuB,kBAAkB,SAAlBA,eAAkB,OAAiB;AAAA,MAAd5C,OAAc,QAAdA,OAAc;;AACvC,SAAO;AACLiC,YAASjC,QAAQiC,MAAR,CAAeA,MADnB;AAELC,aAASlC,QAAQiC,MAAR,CAAeC;AAFnB,GAAP;AAID,CALD;;AAOA,IAAMgB,qBAAqB;AACzBtC;AADyB,CAA3B;;kBAIe,yBAAQgC,eAAR,EAAyBM,kBAAzB,iB;;;;;;;;;;;;;;;ACff;;;;AACA;;;;AACA;;IAAYkuB,a;;;;;;;;;;;;IAENC,a;;;;;;;;;;;6BACM;AAAA,mBAC+B,KAAKrrB,KADpC;AAAA,UACA/D,MADA,UACAA,MADA;AAAA,UACQC,OADR,UACQA,OADR;AAAA,UACiBtB,SADjB,UACiBA,SADjB;;AAER,aACE;AAAA;AAAA,UAAK,WAAU,oEAAf;AACGqB,mBAAWmvB,cAAcE,UAAzB,IACD;AAAA;AAAA,YAAK,WAAU,0BAAf;AACE;AAAA;AAAA;AAAA;AAAA,WADF;AAEE;AAAA;AAAA,cAAG,WAAU,MAAb;AAAA;AAAA;AAFF,SAFF;AAOGrvB,mBAAWmvB,cAAcG,OAAzB,IACD;AAAA;AAAA;AACE;AAAA;AAAA,cAAK,WAAU,0BAAf;AACE;AAAA;AAAA;AAAA;AAAA,aADF;AAEE;AAAA;AAAA,gBAAG,WAAU,MAAb;AAAqBrvB;AAArB;AAFF;AADF,SARF;AAeGD,mBAAWmvB,cAAcI,UAAzB,IACD;AAAA;AAAA,YAAK,WAAU,0BAAf;AACE;AAAA;AAAA;AAAA;AAAA,WADF;AAEE,iEAAa,MAAM,EAAnB,GAFF;AAGE;AAAA;AAAA;AAAA;AAAyC;AAAA;AAAA,gBAAG,WAAU,eAAb,EAA6B,QAAO,OAApC,EAA4C,MAAK,kCAAjD;AAAA;AAAA;AAAzC;AAHF,SAhBF;AAsBGvvB,mBAAWmvB,cAAcK,OAAzB,IACD;AAAA;AAAA,YAAK,WAAU,0BAAf;AACE;AAAA;AAAA;AAAA;AAAA,WADF;AAEE;AAAA;AAAA;AAAA;AAA4C;AAAA;AAAA,gBAAG,WAAU,eAAb,EAA6B,QAAO,QAApC,EAA6C,MAAMvvB,OAAnD;AAAA;AAAA;AAA5C;AAFF,SAvBF;AA4BGD,mBAAWmvB,cAAcM,MAAzB,IACD;AAAA;AAAA,YAAK,WAAU,0BAAf;AACE;AAAA;AAAA;AAAA;AAAA,WADF;AAEE;AAAA;AAAA;AAAG;AAAA;AAAA;AAASxvB;AAAT;AAAH,WAFF;AAGE;AAAA;AAAA;AAAA;AAAqE;AAAA;AAAA,gBAAG,WAAU,eAAb,EAA6B,MAAK,4BAAlC,EAA+D,QAAO,QAAtE;AAAA;AAAA;AAArE,WAHF;AAIE;AAAA;AAAA,cAAQ,WAAU,mBAAlB,EAAsC,SAAStB,SAA/C;AAAA;AAAA;AAJF;AA7BF,OADF;AAuCD;;;;EA1CyB,gBAAM4F,S;;AA2CjC;;kBAEc6qB,a;;;;;;;;;;;;ACjDR,IAAMC,kCAAa,YAAnB;AACA,IAAMC,4BAAU,SAAhB;AACA,IAAMC,kCAAa,YAAnB;AACA,IAAMC,4BAAU,SAAhB;AACA,IAAMC,0BAAS,QAAf,C;;;;;;;;;;;;;;;ACJP;;;;AACA;;;;AACA;;;;;;;;;;;;IAEMC,S;;;;;;;;;;;6BACM;AACR,aACE;AAAA;AAAA;AACE,uDAAK,WAAW,OAAhB,EAAyB,SAAS,OAAlC,GADF;AAEE,6DAFF;AAGE;AAAA;AAAA,YAAK,WAAU,iBAAf;AACE;AAAA;AAAA,cAAK,WAAU,mDAAf;AACE;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACE;AAAA;AAAA,kBAAG,WAAU,YAAb;AAAA;AAAA,eADF;AAEE;AAAA;AAAA;AAAG;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,QAAO,QAApC,EAA6C,MAAK,6BAAlD;AAAA;AAAA;AAAH,eAFF;AAGE;AAAA;AAAA;AAAG;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,QAAO,QAApC,EAA6C,MAAK,mCAAlD;AAAA;AAAA;AAAH,eAHF;AAIE;AAAA;AAAA;AAAG;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,QAAO,QAApC,EAA6C,MAAK,4BAAlD;AAAA;AAAA;AAAH,eAJF;AAKE;AAAA;AAAA;AAAG;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,QAAO,QAApC,EAA6C,MAAK,yDAAlD;AAAA;AAAA;AAAH;AALF;AADF,WADF;AASQ;AAAA;AAAA,cAAK,WAAU,mDAAf;AACJ;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACE;AAAA;AAAA;AAAA;AAAgF;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,MAAK,iBAAlC;AAAA;AAAA,iBAAhF;AAAA;AAAA,eADF;AAEE;AAAA;AAAA;AAAA;AAAA,eAFF;AAGE;AAAA;AAAA;AAAA;AAAA,eAHF;AAIE;AAAA;AAAA;AAAA;AAA+E;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,MAAK,mCAAlC;AAAA;AAAA,iBAA/E;AAAA;AAAA,eAJF;AAKE;AAAA;AAAA;AAAA;AAA4C;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,MAAK,4BAAlC;AAAA;AAAA,iBAA5C;AAAA;AAAmJ;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,MAAK,0CAAlC;AAAA;AAAA,iBAAnJ;AAAA;AAAA;AALF;AADI;AATR;AAHF,OADF;AAyBD;;;;EA3BqB,gBAAMnrB,S;;AA4B7B;;kBAEcmrB,S;;;;;;;;;;;;;AClCf;;AACA;;;;;;AAEA,IAAM/uB,kBAAkB,SAAlBA,eAAkB,OAAiB;AAAA,MAAdb,OAAc,QAAdA,OAAc;;AACvC,SAAO;AACL4pB,yBAAqB5pB,QAAQc,eAAR,CAAwBhD;AADxC,GAAP;AAGD,CAJD;;kBAMe,yBAAQ+C,eAAR,EAAyB,IAAzB,iB;;;;;;;;;;;;;;;ACTf;;;;AACA;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;;;;;IAEMgvB,S;;;;;;;;;;;8CACuB9G,Q,EAAU;AACnC;AACA,UAAIA,SAASa,mBAAT,KAAiC,KAAK3lB,KAAL,CAAW2lB,mBAAhD,EAAqE;AACnE,aAAK3lB,KAAL,CAAWtD,OAAX,CAAmBiN,IAAnB;AACD;AACF;;;6BACS;AACR,aACE;AAAA;AAAA;AACE,uDAAK,WAAW,OAAhB,EAAyB,SAAS,OAAlC,GADF;AAEE,6DAFF;AAGE;AAAA;AAAA,YAAK,WAAU,iBAAf;AACE;AAAA;AAAA,cAAK,WAAU,mDAAf;AACE;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACE;AAAA;AAAA;AAAA;AAAyM;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,QAAO,QAApC,EAA6C,MAAK,0DAAlD;AAAA;AAAA,iBAAzM;AAAA;AAA0X;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,QAAO,QAApC,EAA6C,MAAK,WAAlD;AAAA;AAAA,iBAA1X;AAAA;AAAA;AADF;AADF,WADF;AAKQ;AAAA;AAAA,cAAK,WAAU,mDAAf;AACJ;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACE;AAAA;AAAA,kBAAI,WAAU,eAAd;AAAA;AAAA,eADF;AAEE,6EAFF;AAGE;AAAA;AAAA,kBAAI,WAAU,eAAd;AAAA;AAAA,eAHF;AAIE;AAJF;AADI;AALR;AAHF,OADF;AAoBD;;;;EA5BqB,gBAAMnJ,S;;AA6B7B;;kBAEc,gCAAWorB,SAAX,C;;;;;;;;;;;;;ACtCf;;AACA;;AACA;;;;;;AAEA,IAAMhvB,kBAAkB,SAAlBA,eAAkB,OAAc;AAAA,MAAX4H,IAAW,QAAXA,IAAW;;AACpC,SAAO;AACLnG,WAAamG,KAAK5D,OAAL,CAAavC,KADrB;AAELG,iBAAagG,KAAK5D,OAAL,CAAapF;AAFrB,GAAP;AAID,CALD;;AAOA,IAAM0B,qBAAqB;AACzBI;AADyB,CAA3B;;kBAIe,yBAAQV,eAAR,EAAyBM,kBAAzB,iB;;;;;;;;;;;;;;;ACff;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AAEA;;;;;;;;;;IAEM2uB,Q;;;;;;;;;;;wCACiB;AACnB,WAAK7rB,KAAL,CAAW1C,mBAAX,CAA+B,KAAK0C,KAAL,CAAW8rB,KAAX,CAAiB3tB,MAAhD;AACD;;;8CAC0BwpB,S,EAAW;AACpC,UAAIA,UAAUmE,KAAV,CAAgB3tB,MAAhB,KAA2B,KAAK6B,KAAL,CAAW8rB,KAAX,CAAiB3tB,MAAhD,EAAwD;AACtD,aAAK6B,KAAL,CAAW1C,mBAAX,CAA+BqqB,UAAUmE,KAAV,CAAgB3tB,MAA/C;AACD;AACF;;;6BACS;AAAA,mBACuB,KAAK6B,KAD5B;AAAA,UACA3B,KADA,UACAA,KADA;AAAA,UACOG,WADP,UACOA,WADP;;AAER,UAAIH,KAAJ,EAAW;AACT,eACE,qDAAW,OAAOA,KAAlB,GADF;AAGD;AACD,cAAQG,WAAR;AACE;AACE,iBAAO,0DAAP;AACF;AACE,iBAAO,4DAAP;AACF;AACE,iBAAO,+DAAP;AACF;AACE,iBAAO;AAAA;AAAA;AAAA;AAAA,WAAP;AARJ;AAUD;;;;EA1BoB,gBAAMgC,S;;AA2B5B;;kBAEcqrB,Q;;;;;;;;;;;;;ACrCf;;AACA;;;;;;AAEA,IAAMjvB,kBAAkB,SAAlBA,eAAkB,OAAc;AAAA,MAAX4H,IAAW,QAAXA,IAAW;;AACpC;AACA,MAAM/F,YAAY+F,KAAK5D,OAAL,CAAajC,EAA/B;AACA;AACA,MAAIuB,cAAJ;AACA,MAAMU,UAAU4D,KAAKC,WAAL,CAAiBhG,SAAjB,KAA+B,IAA/C;AACA,MAAMkG,YAAYH,KAAKG,SAAvB;AACA,MAAI/D,WAAW+D,SAAf,EAA0B;AACxB,QAAMD,WAAW9D,QAAQ5B,GAAzB,CADwB,CACO;AAC/BkB,YAAQyE,UAAUD,QAAV,KAAuB,IAA/B;AACD;AACD;AACA,SAAO;AACLxE;AADK,GAAP;AAGD,CAfD;;kBAiBe,yBAAQtD,eAAR,EAAyB,IAAzB,iB;;;;;;;;;;;;;;;ACpBf;;;;AACA;;;;AACA;;AACA;;;;;;;;;;;;IAEMmvB,Q;;;;;;;;;;;6BACM;AAAA,UACA7rB,KADA,GACU,KAAKF,KADf,CACAE,KADA;;AAER,UAAIA,KAAJ,EAAW;AAAA,+BACiBA,MAAMf,SADvB;AAAA,YACDtF,IADC,oBACDA,IADC;AAAA,YACKqF,OADL,oBACKA,OADL;;AAET,eACE;AAAA;AAAA,YAAK,WAAU,wFAAf;AACE,yDAAK,WAAWrF,IAAhB,EAAsB,OAAOqG,KAA7B,GADF;AAEE,qEAFF;AAGE;AAAA;AAAA,cAAM,IAAG,kBAAT,EAA4B,WAAU,0BAAtC,EAAiE,UAAQhB,OAAR,SAAmBrF,IAApF;AAAA;AAAA;AAHF,SADF;AAQD;AACD,aACE;AAAA;AAAA,UAAK,WAAU,gFAAf;AACE;AAAA;AAAA;AAAA;AAAA;AADF,OADF;AAKD;;;;EAnBoB,gBAAM2G,S;;AAoB5B;;kBAEcurB,Q;;;;;;;;;;;;;;;AC3Bf;;;;AACA;;;;AACA;;;;;;;;;;IAEMC,Y;;;;;;;;;;;wCACiB;AAAA,kCACiC,KAAKhsB,KADtC,CACXE,KADW,CACFf,SADE;AAAA,UACWtF,IADX,yBACWA,IADX;AAAA,UACiBqF,OADjB,yBACiBA,OADjB;;AAEnB,WAAKc,KAAL,CAAWiS,aAAX,CAAyBpY,IAAzB,EAA+BqF,OAA/B;AACD;;;6BACS;AAAA,mBAC4F,KAAKc,KADjG;AAAA,UACA/D,MADA,UACAA,MADA;AAAA,UACQoC,KADR,UACQA,KADR;AAAA,0CACe6B,KADf,CACwBf,SADxB;AAAA,UACqCtF,IADrC,0BACqCA,IADrC;AAAA,UAC2CqF,OAD3C,0BAC2CA,OAD3C;AAAA,UACoD4O,WADpD,0BACoDA,WADpD;AAAA,UACiEkT,OADjE,0BACiEA,OADjE;AAAA,UAC0EpV,SAD1E,0BAC0EA,SAD1E;;AAER,aACE;AAAA;AAAA,UAAK,IAAG,yBAAR;AACI3P,oDAAD,IACD;AAAA;AAAA;AACE;AAAA;AAAA;AAAA;AAAA;AADF,SAFF;AAMIA,oDAAD,IACD;AAAA;AAAA;AACE;AAAA;AAAA;AAAA;AAAA,WADF;AAEE,iEAAa,MAAM,EAAnB,GAFF;AAGE;AAAA;AAAA;AAAA;AAAyC;AAAA;AAAA,gBAAG,WAAU,eAAb,EAA6B,QAAO,OAApC,EAA4C,MAAK,kCAAjD;AAAA;AAAA;AAAzC;AAHF,SAPF;AAaIA,8CAAD,IACD;AAAA;AAAA;AACE;AAAA;AAAA;AAAA;AAA4H;AAAA;AAAA,gBAAG,WAAU,eAAb,EAA6B,MAAK,4BAAlC,EAA+D,QAAO,QAAtE;AAAA;AAAA,aAA5H;AAAA;AAAA,WADF;AAEE;AAAA;AAAA;AAAG;AAAA;AAAA,gBAAG,IAAG,eAAN;AAAuBoC;AAAvB;AAAH;AAFF,SAdF;AAmBIpC,kDAAD,IACA,YAAM;AACL,kBAAQ6R,WAAR;AACE,iBAAK,YAAL;AACA,iBAAK,WAAL;AACA,iBAAK,WAAL;AACE,qBACE;AACE,2BAAU,OADZ;AAEE,2BAAS5O,OAAT,SAAoBrF,IAApB,SAA4BmnB,OAF9B;AAGE,qBAAKnnB,IAHP,GADF;AAMF,iBAAK,WAAL;AACE,qBACE;AACE,2BAAU,OADZ;AAEE,2BAASqF,OAAT,SAAoBrF,IAApB,SAA4BmnB,OAF9B;AAGE,qBAAKnnB;AAHP,gBADF;AAOF,iBAAK,WAAL;AACE,qBACE;AAAA;AAAA,kBAAO,WAAU,aAAjB,EAA+B,cAA/B,EAAwC,QAAQ+R,SAAhD;AACE;AACE,6BAAS1M,OAAT,SAAoBrF,IAApB,SAA4BmnB;AAD9B,kBADF;AAIE;AAAA;AAAA;AAAA;AAAqC;AAAA;AAAA;AAAA;AAAA,mBAArC;AAAA;AAAA;AAJF,eADF;AAQF;AACE,qBACE;AAAA;AAAA;AAAA;AAAA,eADF;AA5BJ;AAgCD,SAjCD;AApBF,OADF;AA0DD;;;;EAjEwB,gBAAMxgB,S;;AAkEhC;;kBAEcwrB,Y;;;;;;;;;;;;;ACxEf;;AACA;;;;;;AAEA,IAAMpvB,kBAAkB,SAAlBA,eAAkB,OAAc;AAAA,MAAX4H,IAAW,QAAXA,IAAW;;AACpC;AACA,MAAM/F,YAAY+F,KAAK5D,OAAL,CAAajC,EAA/B;AACA;AACA,MAAIuB,cAAJ;AACA,MAAMU,UAAU4D,KAAKC,WAAL,CAAiBhG,SAAjB,KAA+B,IAA/C;AACA,MAAMkG,YAAYH,KAAKG,SAAvB;AACA,MAAI/D,WAAW+D,SAAf,EAA0B;AACxB,QAAMD,WAAW9D,QAAQ5B,GAAzB,CADwB,CACO;AAC/BkB,YAAQyE,UAAUD,QAAV,KAAuB,IAA/B;AACD;AACD;AACA,SAAO;AACLxE;AADK,GAAP;AAGD,CAfD;;kBAiBe,yBAAQtD,eAAR,EAAyB,IAAzB,iB;;;;;;;;;;;;;;;ACpBf;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;;;;;IAEMqvB,gB;;;;;;;;;;;6BACM;AAAA,UACA/rB,KADA,GACU,KAAKF,KADf,CACAE,KADA;;AAER,UAAIA,KAAJ,EAAW;AAAA,YACYrG,IADZ,GACuBqG,KADvB,CACDf,SADC,CACYtF,IADZ;;AAET,eACE;AAAA;AAAA;AACE,yDAAK,WAAcA,IAAd,eAAL,EAAqC,OAAOqG,KAA5C,GADF;AAEE,+DAFF;AAGE;AAAA;AAAA,cAAK,WAAU,2BAAf;AACE;AAAA;AAAA,gBAAK,WAAU,mBAAf;AACE;AADF,aADF;AAIE;AAAA;AAAA,gBAAK,WAAU,mDAAf;AACE;AAAA;AAAA,kBAAK,WAAU,wCAAf;AACE;AADF;AADF,aAJF;AAQQ;AAAA;AAAA,gBAAK,WAAU,mDAAf;AACJ;AAAA;AAAA,kBAAK,WAAU,iBAAf;AACE;AADF;AADI;AARR,WAHF;AAAA;AAAA,SADF;AAqBD;AACD,aACE,qDAAW,OAAO,uBAAlB,GADF;AAGD;;;;EA9B4B,gBAAMM,S;;AA+BpC;;kBAEcyrB,gB;;;;;;;;;;;;;ACzCf;;AACA;;;;AACA;;;;AAEA,IAAMrvB,kBAAkB,SAAlBA,eAAkB,OAAc;AAAA,MAAX4H,IAAW,QAAXA,IAAW;;AAAA,qBACH,uBAAYA,IAAZ,CADG;AAAA,MACf5K,KADe,gBAC5BuF,SAD4B,CACfvF,KADe;;AAEpC,SAAO;AACLA;AADK,GAAP;AAGD,CALD;;kBAOe,yBAAQgD,eAAR,EAAyB,IAAzB,iB;;;;;;;;;;;;;ACXf;;;;;;AAEA,IAAMsvB,aAAa,SAAbA,UAAa,OAAe;AAAA,MAAZtyB,KAAY,QAAZA,KAAY;;AAChC,SACE;AAAA;AAAA;AACE;AAAA;AAAA,QAAM,WAAU,aAAhB;AAA+BA;AAA/B;AADF,GADF;AAKD,CAND;;kBAQesyB,U;;;;;;;;;;;;;ACVf;;AACA;;;;AACA;;;;AAEA,IAAMtvB,kBAAkB,SAAlBA,eAAkB,OAAc;AAAA,MAAX4H,IAAW,QAAXA,IAAW;;AACpC;AACA,MAAMtE,QAAQ,uBAAYsE,IAAZ,CAAd;AACA;AACA,SAAO;AACLtE;AADK,GAAP;AAGD,CAPD;;kBASe,yBAAQtD,eAAR,EAAyB,IAAzB,iB;;;;;;;;;;;;;;;ACbf;;;;AACA;;;;;;;;;;IAEMuvB,S;;;AACJ,qBAAansB,KAAb,EAAoB;AAAA;;AAAA,sHACZA,KADY;;AAElB,UAAKosB,eAAL,GAAuB,MAAKA,eAAL,CAAqB/iB,IAArB,OAAvB;AAFkB;AAGnB;;;;oCACgBZ,K,EAAO;AACtB,UAAI4jB,gBAAgB5jB,MAAMga,MAAN,CAAa6J,OAAb,CAAqBC,aAAzC;AACA,UAAIrhB,UAAUoZ,SAASC,cAAT,CAAwB8H,aAAxB,CAAd;AACAnhB,cAAQshB,MAAR;AACA,UAAI;AACFlI,iBAASmI,WAAT,CAAqB,MAArB;AACD,OAFD,CAEE,OAAO1pB,GAAP,EAAY;AACZ,aAAK8G,QAAL,CAAc,EAACxL,OAAO,sBAAR,EAAd;AACD;AACF;;;6BACS;AAAA,yBACsI,KAAK2B,KAD3I,CACAE,KADA;AAAA,UACSnD,OADT,gBACSA,OADT;AAAA,+CACkBoC,SADlB;AAAA,UACgC9C,WADhC,yBACgCA,WADhC;AAAA,UAC6C2f,aAD7C,yBAC6CA,aAD7C;AAAA,UAC4DjiB,WAD5D,yBAC4DA,WAD5D;AAAA,UACyEF,IADzE,yBACyEA,IADzE;AAAA,UAC+EqF,OAD/E,yBAC+EA,OAD/E;AAAA,UACwF8hB,OADxF,yBACwFA,OADxF;AAAA,UACiGlT,WADjG,yBACiGA,WADjG;AAAA,UAC8GlC,SAD9G,yBAC8GA,SAD9G;AAAA,UACyH9R,IADzH,yBACyHA,IADzH;;AAER,aACE;AAAA;AAAA;AACGuC,uBACD;AAAA;AAAA,YAAK,WAAU,uCAAf;AACE;AAAA;AAAA,cAAK,WAAU,iCAAf;AACE;AAAA;AAAA,gBAAM,WAAU,MAAhB;AAAA;AAAA;AADF,WADF;AAIE;AAAA;AAAA,cAAK,WAAU,iCAAf;AACE;AAAA;AAAA,gBAAM,WAAU,MAAhB;AAAuB;AAAA;AAAA,kBAAM,UAAQA,WAAR,SAAuB2f,aAA7B;AAA+C3f;AAA/C;AAAvB;AADF;AAJF,SAFF;AAYGtC,uBACD;AAAA;AAAA,YAAK,WAAU,uCAAf;AACE;AAAA;AAAA,cAAM,WAAU,MAAhB;AAAwBA;AAAxB;AADF,SAbF;AAkBE;AAAA;AAAA,YAAK,IAAG,oBAAR;AACE;AAAA;AAAA,cAAK,WAAU,uCAAf;AACE;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACE;AAAA;AAAA,kBAAM,WAAU,MAAhB;AAAA;AAAA;AADF,aADF;AAIE;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACE;AAAA;AAAA;AACE,6BAAU,wGADZ;AAEE;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,QAAO,QAApC,EAA6C,iDAA+CD,IAA/C,SAAuDiD,OAAvD,SAAkElD,IAA/G;AAAA;AAAA,iBAFF;AAGE;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,QAAO,QAApC,EAA6C,wDAAsDC,IAAtD,SAA8DiD,OAA9D,SAAyElD,IAAtH;AAAA;AAAA,iBAHF;AAIE;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,QAAO,QAApC,EAA6C,6DAA2DC,IAA3D,SAAmEiD,OAAnE,SAA8ElD,IAA3H;AAAA;AAAA,iBAJF;AAKE;AAAA;AAAA,oBAAG,WAAU,eAAb,EAA6B,QAAO,QAApC,EAA6C,6CAA2CC,IAA3C,SAAmDiD,OAAnD,SAA8DlD,IAA9D,eAA4EA,IAAzH;AAAA;AAAA;AALF;AADF;AAJF;AADF,SAlBF;AAmCE;AAAA;AAAA,YAAK,WAAU,uCAAf;AACE;AAAA;AAAA,cAAK,IAAG,iBAAR;AACE;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACE;AAAA;AAAA,kBAAM,WAAU,MAAhB;AAAA;AAAA;AADF,aADF;AAIE;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACE;AAAA;AAAA,kBAAK,WAAU,0BAAf;AACE;AAAA;AAAA,oBAAK,WAAU,kBAAf;AACE;AAAA;AAAA,sBAAK,WAAU,aAAf,EAA6B,IAAG,6BAAhC,EAA8D,QAAO,MAArE;AAAA;AAAA,mBADF;AAEE,2DAAO,MAAK,MAAZ,EAAmB,IAAG,YAAtB,EAAmC,WAAU,uCAA7C,EAAqF,cAArF;AACE,gCAAW,OADb;AAEE,2BAAUC,IAAV,SAAkBiD,OAAlB,SAA6BlD,IAA7B,SAAqCmnB,OAFvC;AAGE,6BAAS,KAAKwL,MAHhB;AAFF,iBADF;AAQE,uDAAK,WAAU,kBAAf,GARF;AASE;AAAA;AAAA,oBAAK,WAAU,kBAAf;AACE;AAAA;AAAA,sBAAQ,WAAU,8BAAlB,EAAiD,sBAAmB,YAApE;AACE,+BAAS,KAAKJ,eADhB;AAAA;AAAA;AADF;AATF;AADF;AAJF,WADF;AAwBE;AAAA;AAAA,cAAK,IAAG,iBAAR;AACE;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACE;AAAA;AAAA,kBAAM,WAAU,MAAhB;AAAA;AAAA;AADF,aADF;AAIE;AAAA;AAAA,gBAAK,WAAU,iCAAf;AACE;AAAA;AAAA,kBAAK,WAAU,0BAAf;AACE;AAAA;AAAA,oBAAK,WAAU,kBAAf;AACE;AAAA;AAAA,sBAAK,WAAU,aAAf,EAA6B,IAAG,6BAAhC,EAA8D,QAAO,MAArE;AAAA;AAAA,mBADF;AAEIte,kCAAgB,WAAjB,GACC,yCAAO,MAAK,MAAZ,EAAmB,IAAG,YAAtB,EAAmC,WAAU,uCAA7C,EAAqF,cAArF;AACE,6BAAS,KAAK0e,MADhB,EACwB,YAAW,OADnC;AAEE,qEAA+C5gB,SAA/C,eAAkE9R,IAAlE,SAA0EoF,OAA1E,SAAqFrF,IAArF,SAA6FmnB,OAA7F,gBAFF,GADD,GAKC,yCAAO,MAAK,MAAZ,EAAmB,IAAG,YAAtB,EAAmC,WAAU,uCAA7C,EAAqF,cAArF;AACE,6BAAS,KAAKwL,MADhB,EACwB,YAAW,OADnC;AAEE,0CAAoB1yB,IAApB,SAA4BoF,OAA5B,SAAuCrF,IAAvC,SAA+CmnB,OAA/C;AAFF;AAPJ,iBADF;AAcE,uDAAK,WAAU,kBAAf,GAdF;AAeE;AAAA;AAAA,oBAAK,WAAU,kBAAf;AACE;AAAA;AAAA,sBAAQ,WAAU,8BAAlB,EAAiD,sBAAmB,YAApE;AACE,+BAAS,KAAKoL,eADhB;AAAA;AAAA;AADF;AAfF;AADF;AAJF;AAxBF,SAnCF;AAyFE;AAAA;AAAA,YAAK,WAAU,0DAAf;AACE;AAAA;AAAA,cAAM,WAAU,eAAhB,EAAgC,UAAQrvB,OAAR,SAAmBlD,IAAnB,SAA2BmnB,OAA3D;AAAsE;AAAA;AAAA;AACpE,2BAAU,MAD0D;AAAA;AAAA;AAAtE,WADF;AAGE;AAAA;AAAA,cAAG,WAAU,eAAb,EAA6B,MAASlnB,IAAT,SAAiBoF,OAAjB,SAA4BrF,IAA5B,SAAoCmnB,OAAjE,EAA4E,UAAUnnB,IAAtF;AAAA;AAAA,WAHF;AAIE;AAAA;AAAA,cAAG,WAAU,eAAb,EAA6B,QAAO,QAApC,EAA6C,MAAK,sBAAlD;AAAA;AAAA;AAJF;AAzFF,OADF;AAmGD;;;;EApHqB,gBAAM2G,S;;AAqH7B;;kBAEc2rB,S;;;;;;;;;;;;;AC1Hf;;AACA;;;;;;AAEA,IAAMvvB,kBAAkB,SAAlBA,eAAkB,OAAc;AAAA,MAAX4H,IAAW,QAAXA,IAAW;;AACpC;AACA,MAAM/F,YAAY+F,KAAK5D,OAAL,CAAajC,EAA/B;AACA;AACA,MAAM+tB,kBAAkBloB,KAAKC,WAAL,CAAiBhG,SAAjB,KAA+B,IAAvD;AACA;AACA,MAAI1C,gBAAJ;AACA,MAAI2wB,eAAJ,EAAqB;AACnB,QAAMntB,aAAamtB,gBAAgB1tB,GAAnC;AACAjD,cAAUyI,KAAKmc,WAAL,CAAiBphB,UAAjB,KAAgC,IAA1C;AACD;AACD,SAAO;AACLxD;AADK,GAAP;AAGD,CAdD;;kBAgBe,yBAAQa,eAAR,EAAyB,IAAzB,iB;;;;;;;;;;;;;;;ACnBf;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;;;;;IAEM+vB,W;;;;;;;;;;;6BACM;AAAA,UACA5wB,OADA,GACY,KAAKiE,KADjB,CACAjE,OADA;;AAER,UAAIA,OAAJ,EAAa;AAAA,YACHlC,IADG,GACuBkC,OADvB,CACHlC,IADG;AAAA,YACGoD,MADH,GACuBlB,OADvB,CACGkB,MADH;AAAA,YACWF,OADX,GACuBhB,OADvB,CACWgB,OADX;;AAEX,eACE;AAAA;AAAA;AACE,yDAAK,WAAWlD,IAAhB,EAAsB,SAASkC,OAA/B,GADF;AAEE,+DAFF;AAGE;AAAA;AAAA,cAAK,WAAU,2BAAf;AACE;AAAA;AAAA,gBAAK,WAAU,mBAAf;AACE;AAAA;AAAA;AAAA;AAAmBlC;AAAnB,eADF;AAEE;AAAA;AAAA,kBAAG,WAAW,YAAd;AAAA;AAA8CoD;AAA9C,eAFF;AAGE;AAAA;AAAA,kBAAG,WAAW,YAAd;AAAA;AAA+CF;AAA/C;AAHF,aADF;AAME;AAAA;AAAA,gBAAK,WAAU,mBAAf;AACE;AADF;AANF;AAHF,SADF;AAgBD;AACD,aACE,qDAAW,OAAO,yBAAlB,GADF;AAGD;;;;EAzBuB,gBAAMyD,S;;AA0B/B;;kBAEcmsB,W;;;;;;;;;;;;;AClCf;;AACA;;AACA;;;;;;AAEA,IAAM/vB,kBAAkB,SAAlBA,eAAkB,OAAc;AAAA,MAAX4H,IAAW,QAAXA,IAAW;;AACpC;AACA,MAAM5D,UAAU4D,KAAKC,WAAL,CAAiBD,KAAK5D,OAAL,CAAajC,EAA9B,CAAhB;AACA,MAAMY,aAAaqB,QAAQ5B,GAA3B;AACA;AACA,MAAMjD,UAAUyI,KAAKmc,WAAL,CAAiBphB,UAAjB,KAAgC,IAAhD;AACA;AACA,SAAO;AACLA,0BADK;AAELxD;AAFK,GAAP;AAID,CAXD;;AAaA,IAAMmB,qBAAqB;AACzBY;AADyB,CAA3B;;kBAIe,yBAAQlB,eAAR,EAAyBM,kBAAzB,iB;;;;;;;;;;;;;;;ACrBf;;;;AACA;;;;;;;;;;;;IAEM0vB,oB;;;AACJ,gCAAa5sB,KAAb,EAAoB;AAAA;;AAAA,4IACZA,KADY;;AAElB,UAAK6sB,mBAAL,GAA2B,MAAKA,mBAAL,CAAyBxjB,IAAzB,OAA3B;AACA,UAAKyjB,uBAAL,GAA+B,MAAKA,uBAAL,CAA6BzjB,IAA7B,OAA/B;AAHkB;AAInB;;;;8CAC0B;AAAA,UACQ+V,WADR,GAC4B,KAAKpf,KADjC,CACjBjE,OADiB,CACNsD,UADM,CACQ+f,WADR;;AAEzB,UAAMF,eAAeO,SAASL,WAAT,IAAwB,CAA7C;AACA,WAAK2N,WAAL,CAAiB7N,YAAjB;AACD;;;0CACsB;AAAA,UACYE,WADZ,GACgC,KAAKpf,KADrC,CACbjE,OADa,CACFsD,UADE,CACY+f,WADZ;;AAErB,UAAMC,WAAWI,SAASL,WAAT,IAAwB,CAAzC;AACA,WAAK2N,WAAL,CAAiB1N,QAAjB;AACD;;;gCACY7f,I,EAAM;AAAA,mBACiC,KAAKQ,KADtC;AAAA,UACTT,UADS,UACTA,UADS;AAAA,kCACGxD,OADH;AAAA,UACclC,IADd,kBACcA,IADd;AAAA,UACoBoD,MADpB,kBACoBA,MADpB;;AAEjB,WAAK+C,KAAL,CAAWlC,qBAAX,CAAiCyB,UAAjC,EAA6C1F,IAA7C,EAAmDoD,MAAnD,EAA2DuC,IAA3D;AACD;;;6BACS;AAAA,kCACiE,KAAKQ,KADtE,CACAjE,OADA,CACWsD,UADX;AAAA,UACyBsf,MADzB,yBACyBA,MADzB;AAAA,UACiCS,WADjC,yBACiCA,WADjC;AAAA,UAC8CR,UAD9C,yBAC8CA,UAD9C;;AAER,aACE;AAAA;AAAA,UAAK,WAAU,eAAf;AACID,eAAOtT,MAAP,GAAgB,CAAjB,GACC;AAAA;AAAA;AACGsT,iBAAO1U,GAAP,CAAW,UAAC5P,KAAD,EAAQ6O,KAAR;AAAA,mBAAkB;AAC5B,yBAAW7O,KADiB;AAE5B,mBAAQA,MAAMR,IAAd,SAAsBqP;AAFM,cAAlB;AAAA,WAAX,CADH;AAKE;AAAA;AAAA;AACIkW,0BAAc,CAAf,IACD;AAAA;AAAA,gBAAQ,WAAW,mBAAnB,EAAwC,SAAS,KAAK0N,uBAAtD;AAAA;AAAA,aAFF;AAII1N,0BAAcR,UAAf,IACD;AAAA;AAAA,gBAAQ,WAAW,mBAAnB,EAAwC,SAAS,KAAKiO,mBAAtD;AAAA;AAAA;AALF;AALF,SADD,GAgBC;AAAA;AAAA;AAAA;AAAA;AAjBJ,OADF;AAsBD;;;;EA5CgC,gBAAMrsB,S;;AA6CxC;;kBAEcosB,oB;;;;;;;;;;;;;AClDf;;;;AACA;;;;eACwC,mBAAAlrB,CAAQ,CAAR,C;IAAvBnH,gB,YAATF,K,CAASE,gB;;AAEjB,IAAMyyB,eAAe,SAAfA,YAAe,OAAuE;AAAA,4BAApE7tB,SAAoE;AAAA,MAAvDtF,IAAuD,kBAAvDA,IAAuD;AAAA,MAAjDqF,OAAiD,kBAAjDA,OAAiD;AAAA,MAAxC8hB,OAAwC,kBAAxCA,OAAwC;AAAA,MAA/BlT,WAA+B,kBAA/BA,WAA+B;AAAA,MAAlBlC,SAAkB,kBAAlBA,SAAkB;;AAC1F,MAAMqhB,mBAAsB/tB,OAAtB,SAAiCrF,IAAjC,SAAyCmnB,OAA/C;AACA,MAAMkM,oBAAkBhuB,OAAlB,SAA6BrF,IAAnC;AACA,SACE;AAAA;AAAA,MAAK,WAAU,cAAf;AACE;AAAA;AAAA,QAAM,IAAIqzB,WAAV;AACI,kBAAM;AACN,gBAAQpf,WAAR;AACE,eAAK,YAAL;AACA,eAAK,WAAL;AACA,eAAK,WAAL;AACA,eAAK,WAAL;AACE,mBACE;AACE,yBAAW,eADb;AAEE,mBAAKmf,gBAFP;AAGE,mBAAKpzB;AAHP,cADF;AAOF,eAAK,WAAL;AACE,mBACE;AACE,yBAAW,qBADb;AAEE,mBAAK+R,aAAarR,gBAFpB;AAGE,mBAAKV;AAHP,cADF;AAOF;AACE,mBACE;AAAA;AAAA;AAAA;AAAA,aADF;AArBJ;AAyBD,OA1BA;AADH;AADF,GADF;AAiCD,CApCD;;kBAsCemzB,Y;;;;;;;;;;;;;;;AC1Cf;;;;AACA;;;;AACA;;;;;;;;;;;;eACkC,mBAAAtrB,CAAQ,CAAR,C;6BAA1B/H,I;IAAQC,K,iBAAAA,K;IAAOE,I,iBAAAA,I;;IAEjBqzB,a;;;;;;;;;;;6BACM;AACR,aACE;AAAA;AAAA;AACE;AAAA;AAAA;AACE;AAAA;AAAA;AAAQvzB,iBAAR;AAAA;AAAA,WADF;AAEE,kDAAM,KAAI,WAAV,EAAsB,MAASE,IAAT,SAAtB;AAFF,SADF;AAKE,6DALF;AAME;AAAA;AAAA,YAAK,WAAU,iBAAf;AACE;AAAA;AAAA;AAAA;AAAA,WADF;AAEE;AAAA;AAAA;AAAA;AAAA;AAFF;AANF,OADF;AAaD;;;;EAfyB,gBAAM0G,S;;AAgBjC;;kBAEc2sB,a;;;;;;;;;;;eCvBc,mBAAAzrB,CAAQ,EAAR,C;IAArBkH,gB,YAAAA,gB;;gBACgH,mBAAAlH,CAAQ,GAAR,C;IAAhH0rB,qB,aAAAA,qB;IAAuBC,2C,aAAAA,2C;IAA6CC,c,aAAAA,c;IAAgBC,uB,aAAAA,uB;;AAC5F,IAAMC,UAAU,mBAAA9rB,CAAQ,GAAR,CAAhB;AACA,IAAM+rB,mBAAmB,mBAAA/rB,CAAQ,GAAR,CAAzB;AACA,IAAMgsB,QAAQ,OAAd;;AAEAjzB,OAAOC,OAAP,GAAiB,UAACoZ,GAAD,EAAS;AACxB;AACAA,MAAIuE,GAAJ,CAAQ,qBAAR,EAA+B,UAACtI,GAAD,EAAM/B,GAAN,EAAc;AAAA,QACnChH,OADmC,GACE+I,GADF,CACnC/I,OADmC;AAAA,QAC1BC,EAD0B,GACE8I,GADF,CAC1B9I,EAD0B;AAAA,QACtBC,WADsB,GACE6I,GADF,CACtB7I,WADsB;AAAA,QACT/I,MADS,GACE4R,GADF,CACT5R,MADS;AAE3C;;AACA,QAAIwvB,yBAAJ;AACA,QAAI;AAAA,kCACsBH,QAAQI,aAAR,CAAsBzvB,OAAO9D,KAA7B,CADtB;;AACCszB,sBADD,yBACCA,gBADD;AAEH,KAFD,CAEE,OAAOtvB,KAAP,EAAc;AACd,aAAO2P,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAASmC,MAAMnC,OAAhC,EAArB,CAAP;AACD;AACD,QAAI2xB,eAAeT,sBAAsBO,gBAAtB,EAAwC3mB,OAAxC,CAAnB;AACA,QAAI6mB,iBAAiBH,KAArB,EAA4B;AAC1B,aAAOD,iBAAiB1d,GAAjB,EAAsB/B,GAAtB,CAAP;AACD;AACD;AACA;AACApF,qBAAiB5B,OAAjB,EAA0BC,EAA1B,EAA8BC,WAA9B;AACA;AACA,QAAIZ,kBAAJ;AACA,QAAI;AAAA,gCACeknB,QAAQM,UAAR,CAAmB3vB,OAAO9D,KAA1B,CADf;;AACCiM,eADD,uBACCA,SADD;AAEH,KAFD,CAEE,OAAOjI,KAAP,EAAc;AACd,aAAO2P,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAASmC,MAAMnC,OAAhC,EAArB,CAAP;AACD;AACD;AACA,QAAI6xB,kBAAJ;AAAA,QAAe1xB,oBAAf;AAAA,QAA4BwS,uBAA5B;AAAA,QAA4C3P,gBAA5C;AACA,QAAI;AAAA,kCACqDsuB,QAAQQ,eAAR,CAAwB7vB,OAAO8vB,UAA/B,CADrD;;AACCF,eADD,yBACCA,SADD;AACY1xB,iBADZ,yBACYA,WADZ;AACyBwS,oBADzB,yBACyBA,cADzB;AACyC3P,aADzC,yBACyCA,OADzC;AAEH,KAFD,CAEE,OAAOb,KAAP,EAAc;AACd,aAAO2P,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAASmC,MAAMnC,OAAhC,EAArB,CAAP;AACD;AACD,QAAI,CAAC6xB,SAAL,EAAgB;AAAA,kCACSV,4CAA4CnuB,OAA5C,EAAqDoH,SAArD,CADT;;AAAA;;AACbpH,aADa;AACJoH,eADI;AAEf;AACD;AACAgnB,mBAAeO,YAAf,EAA6BvnB,SAA7B,EAAwCjK,WAAxC,EAAqD6C,OAArD;AACA;AACAquB,4BAAwBlxB,WAAxB,EAAqCwS,cAArC,EAAqDvI,SAArD,EAAgEpH,OAAhE,EAAyEgI,WAAzE,EAAsFD,EAAtF,EAA0F+G,GAA1F;AACD,GArCD;AAsCA;AACA8F,MAAIuE,GAAJ,CAAQ,SAAR,EAAmB,UAACtI,GAAD,EAAM/B,GAAN,EAAc;AAAA,QACvBhH,OADuB,GACc+I,GADd,CACvB/I,OADuB;AAAA,QACdC,EADc,GACc8I,GADd,CACd9I,EADc;AAAA,QACVC,WADU,GACc6I,GADd,CACV7I,WADU;AAAA,QACG/I,MADH,GACc4R,GADd,CACG5R,MADH;AAE/B;;AACA,QAAIwvB,yBAAJ;AACA,QAAI;AAAA,mCACsBH,QAAQI,aAAR,CAAsBzvB,OAAO9D,KAA7B,CADtB;;AACCszB,sBADD,0BACCA,gBADD;AAEH,KAFD,CAEE,OAAOtvB,KAAP,EAAc;AACd,aAAO2P,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAASmC,MAAMnC,OAAhC,EAArB,CAAP;AACD;AACD,QAAI2xB,eAAeT,sBAAsBO,gBAAtB,EAAwC3mB,OAAxC,CAAnB;AACA,QAAI6mB,iBAAiBH,KAArB,EAA4B;AAC1B,aAAOD,iBAAiB1d,GAAjB,EAAsB/B,GAAtB,CAAP;AACD;AACD;AACA;AACApF,qBAAiB5B,OAAjB,EAA0BC,EAA1B,EAA8BC,WAA9B;AACA;AACA,QAAIZ,kBAAJ;AACA,QAAI;AAAA,iCACaknB,QAAQM,UAAR,CAAmB3vB,OAAO9D,KAA1B,CADb;;AACAiM,eADA,wBACAA,SADA;AAEH,KAFD,CAEE,OAAOjI,KAAP,EAAc;AACd,aAAO2P,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAASmC,MAAMnC,OAAhC,EAArB,CAAP;AACD;AACD;AACAoxB,mBAAeO,YAAf,EAA6BvnB,SAA7B,EAAwC,IAAxC,EAA8C,IAA9C;AACA;AACAinB,4BAAwB,IAAxB,EAA8B,IAA9B,EAAoCjnB,SAApC,EAA+C,IAA/C,EAAqDY,WAArD,EAAkED,EAAlE,EAAsE+G,GAAtE;AACD,GA3BD;AA4BD,CArED,C;;;;;;;;;ACNA,IAAMrM,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;eAC2C,mBAAAA,CAAQ,EAAR,C;IAAnCkN,U,YAAAA,U;IAAYiB,kB,YAAAA,kB;;gBACY,mBAAAnO,CAAQ,EAAR,C;IAAxBqM,mB,aAAAA,mB;;AAER,IAAM2f,QAAQ,OAAd;AACA,IAAMQ,OAAO,MAAb;AACA,IAAMvf,UAAU,SAAhB;AACA,IAAMF,aAAa,YAAnB;AACA,IAAMC,WAAW,UAAjB;;AAEA,SAASyf,iBAAT,OAAsC;AAAA,MAATC,MAAS,QAATA,MAAS;;AACpC,SAAOA,UAAUA,OAAOtC,KAAP,CAAa,YAAb,CAAjB;AACD;;AAED,SAASuC,oBAAT,CAA+BrnB,OAA/B,EAAwC;AACtC,SAAOA,QAAQ,YAAR,KAAyBA,QAAQ,YAAR,EAAsB8kB,KAAtB,CAA4B,SAA5B,CAAhC;AACD;;AAED,SAASwC,gBAAT,QAA4C;AAAA,MAAhBF,MAAgB,SAAhBA,MAAgB;AAAA,MAARG,KAAQ,SAARA,KAAQ;;AAC1C,MAAMC,gBAAgBJ,UAAUA,OAAOtC,KAAP,CAAa,WAAb,CAAV,IAAuC,CAACsC,OAAOtC,KAAP,CAAa,YAAb,CAAxC,IAAsE,CAACsC,OAAOtC,KAAP,CAAa,UAAb,CAA7F;AACA,MAAM2C,gBAAgBL,UAAUG,KAAhC;AACA,SAAOC,iBAAiBC,aAAxB;AACD;;AAED,SAASC,cAAT,CAAyBxvB,OAAzB,EAAkC;AAChC,SAASA,QAAQmM,MAAR,KAAmB,EAApB,IAA2B,CAAC,gBAAgBY,IAAhB,CAAqB/M,OAArB,CAApC;AACD;;AAED,SAASyvB,cAAT,CAAyBzvB,OAAzB,EAAkC;AAChC,SAAOA,QAAQmM,MAAR,KAAmB,CAA1B,CADgC,CACF;AAC/B;;AAED,SAASujB,uBAAT,CAAkCxI,KAAlC,EAAyC;AACvC,SAAQsI,eAAetI,KAAf,KAAyBuI,eAAevI,KAAf,CAAjC;AACD;;AAED,SAASyI,kBAAT,CAA6B3vB,OAA7B,EAAsCrF,IAAtC,EAA4CmU,GAA5C,EAAiD;AAC/C,SAAO6B,mBAAmB3Q,OAAnB,EAA4BrF,IAA5B,EACJyH,IADI,CACC,sBAAc;AAClB;AACA,QAAI6X,eAAexK,OAAnB,EAA4B;AAC1B,aAAOX,IAAI/R,MAAJ,CAAW,GAAX,EAAgBoU,QAAhB,qBAA2CxW,IAA3C,SAAmDqF,OAAnD,CAAP;AACD;AACD;AALkB,QAMXkN,QANW,GAMW+M,UANX,CAMX/M,QANW;AAAA,QAMDC,QANC,GAMW8M,UANX,CAMD9M,QANC;;AAOlB1K,WAAO2S,OAAP,oBAAgClI,QAAhC;AACA,QAAM0iB,kBAAkB;AACtB9nB,eAAS;AACP,kCAA0B,SADnB;AAEP,wBAA0BqF,YAAY;AAF/B;AADa,KAAxB;AAMA2B,QAAI/R,MAAJ,CAAW,GAAX,EAAgB8yB,QAAhB,CAAyB3iB,QAAzB,EAAmC0iB,eAAnC;AACD,GAhBI,EAiBJhsB,KAjBI,CAiBE,iBAAS;AACd,UAAMzE,KAAN;AACD,GAnBI,CAAP;AAoBD;;AAED5D,OAAOC,OAAP,GAAiB;AACf6yB,yBADe,mCACUlxB,WADV,EACuBwS,cADvB,EACuCvI,SADvC,EACkDpH,OADlD,EAC2DgI,WAD3D,EACwED,EADxE,EAC4E+G,GAD5E,EACiF;AAC9F;AACAY,eAAWvS,WAAX,EAAwBwS,cAAxB,EAAwCvI,SAAxC,EAAmDpH,OAAnD,EACGoC,IADH,CACQ,uBAAe;AACnB,UAAI0tB,gBAAgBtgB,QAApB,EAA8B;AAC5B,eAAOV,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAAS,4BAA1B,EAArB,CAAP;AACD,OAFD,MAEO,IAAI8yB,gBAAgBvgB,UAApB,EAAgC;AACrC,eAAOT,IAAI/R,MAAJ,CAAW,GAAX,EAAgB8E,IAAhB,CAAqB,EAACwN,SAAS,KAAV,EAAiBrS,SAAS,8BAA1B,EAArB,CAAP;AACD;AACD2yB,yBAAmBG,WAAnB,EAAgC1oB,SAAhC,EAA2C0H,GAA3C;AACA;AACD,KATH,EAUGlL,KAVH,CAUS,iBAAS;AACdiL,0BAAoB7G,WAApB,EAAiCD,EAAjC,EAAqC5I,KAArC,EAA4C2P,GAA5C;AACA;AACD,KAbH;AAcD,GAjBc;AAkBfof,uBAlBe,iCAkBQO,gBAlBR,EAkB0B3mB,OAlB1B,EAkBmC;AAChD,QAAI6mB,qBAAJ;AACA,QAAIF,gBAAJ,EAAsB;AACpBE,qBAAeH,KAAf,CADoB,CACG;AACvB,UAAIS,kBAAkBnnB,OAAlB,CAAJ,EAAgC;AAAG;AACjC6mB,uBAAeK,IAAf;AACD;AACF,KALD,MAKO;AACLL,qBAAeK,IAAf;AACA,UAAII,iBAAiBtnB,OAAjB,KAA6BqnB,qBAAqBrnB,OAArB,CAAjC,EAAgE;AAAG;AACjErF,eAAOyC,KAAP,CAAa,wFAAb;AACAypB,uBAAeH,KAAf;AACD;AACF;AACD,WAAOG,YAAP;AACD,GAjCc;AAkCfR,6CAlCe,uDAkC8BY,UAlC9B,EAkC0Cp0B,IAlC1C,EAkCgD;AAC7D;AACA,QAAI+0B,wBAAwB/0B,IAAxB,KAAiC,CAAC+0B,wBAAwBX,UAAxB,CAAtC,EAA2E;AACzE,UAAMgB,WAAWp1B,IAAjB;AACAA,aAAOo0B,UAAP;AACAA,mBAAagB,QAAb;AACD;AACD,WAAO,CAAChB,UAAD,EAAap0B,IAAb,CAAP;AACD,GA1Cc;AA2CfyzB,gBA3Ce,0BA2CCO,YA3CD,EA2CevnB,SA3Cf,EA2C0BjK,WA3C1B,EA2CuC6C,OA3CvC,EA2CgD;AAC7DyC,WAAOyC,KAAP,CAAa,kBAAb,EAAiCypB,YAAjC;AACAlsB,WAAOyC,KAAP,CAAa,iBAAb,EAAgCkC,SAAhC;AACA3E,WAAOyC,KAAP,CAAa,kBAAb,EAAiC/H,WAAjC;AACAsF,WAAOyC,KAAP,CAAa,cAAb,EAA6BlF,OAA7B;AACD;AAhDc,CAAjB,C;;;;;;;;;;;AC3DA,IAAMyC,SAAS,mBAAAD,CAAQ,CAAR,CAAf;;AAEAjH,OAAOC,OAAP,GAAiB;AACfw0B,wBAAwB,gBADT;AAEfC,0BAAwB,iBAFT;AAGfC,kBAAwB,yCAHT;AAIfC,gBAAwB,GAJT;AAKfrB,mBAAwB,yBAAUC,UAAV,EAAsB;AAC5CtsB,WAAOyC,KAAP,CAAa,qBAAb,EAAoC6pB,UAApC;AACA,QAAMqB,kBAAkB,IAAIC,MAAJ,CACtB,eAAe;AACf,qBAFsB,CAEJ;AAFI,KAAxB;;AAF4C,gCAMQD,gBACjDxjB,IADiD,CAC5CmiB,UAD4C,EAEjDhkB,GAFiD,CAE7C;AAAA,aAAS6hB,SAAS,IAAlB;AAAA,KAF6C,CANR;AAAA;AAAA,QAMrC0D,KANqC;AAAA,QAM9B5zB,KAN8B;AAAA,QAMvB6zB,iBANuB;AAAA,QAMJ3wB,QANI;;AAS5C6C,WAAOyC,KAAP,CAAgBorB,KAAhB,UAA0B5zB,KAA1B,UAAoC6zB,iBAApC,UAA0D3wB,QAA1D;;AAEA;AACA,QAAI,CAAClD,KAAL,EAAY;AACV,YAAM,IAAIsF,KAAJ,wDAA+DuuB,iBAA/D,OAAN;AACD;AACD,QAAM1B,YAAYnyB,MAAM8zB,UAAN,CAAiBj1B,OAAOC,OAAP,CAAe20B,YAAhC,CAAlB;AACA,QAAMhzB,cAAc0xB,YAAYnyB,KAAZ,GAAoB,IAAxC;AACA,QAAIsD,gBAAJ;AACA,QAAI6uB,SAAJ,EAAe;AACb,UAAI,CAAC1xB,WAAL,EAAkB;AAChB,cAAM,IAAI6E,KAAJ,CAAU,0BAAV,CAAN;AACD;AACD,UAAMyuB,eAAgBtzB,WAAD,CAAcyvB,KAAd,CAAoBrxB,OAAOC,OAAP,CAAey0B,sBAAnC,CAArB;AACA,UAAIQ,YAAJ,EAAkB;AAChB,cAAM,IAAIzuB,KAAJ,0CAAiDyuB,aAAaC,IAAb,CAAkB,IAAlB,CAAjD,OAAN;AACD;AACF,KARD,MAQO;AACL1wB,gBAAUtD,KAAV;AACD;;AAED;AACA,QAAIiT,uBAAJ;AACA,QAAI4gB,iBAAJ,EAAuB;AACrB,UAAI,CAAC3wB,QAAL,EAAe;AACb,cAAM,IAAIoC,KAAJ,4CAAmDuuB,iBAAnD,OAAN;AACD;;AAED,UAAIA,sBAAsB,GAA1B,EAA+B;AAC7B5gB,yBAAiB/P,QAAjB;AACD,OAFD,MAEO;AACL,cAAM,IAAIoC,KAAJ,WAAkBuuB,iBAAlB,2CAAN;AACD;AACF;AACD,WAAO;AACL1B,0BADK;AAEL1xB,8BAFK;AAGLwS,oCAHK;AAIL3P;AAJK,KAAP;AAMD,GAtDc;AAuDf4uB,cAAY,oBAAUzzB,KAAV,EAAiB;AAC3BsH,WAAOyC,KAAP,CAAa,eAAb,EAA8B/J,KAA9B;AACA,QAAMi1B,kBAAkB,IAAIC,MAAJ,CACtB,gBAAgB;AAChB,sBAFsB,CAEH;AAFG,KAAxB;;AAF2B,iCAM6BD,gBACrDxjB,IADqD,CAChDzR,KADgD,EAErD4P,GAFqD,CAEjD;AAAA,aAAS6hB,SAAS,IAAlB;AAAA,KAFiD,CAN7B;AAAA;AAAA,QAMpB0D,KANoB;AAAA,QAMblpB,SANa;AAAA,QAMFmpB,iBANE;AAAA,QAMiB3wB,QANjB;;AAS3B6C,WAAOyC,KAAP,CAAgBorB,KAAhB,UAA0BlpB,SAA1B,UAAwCmpB,iBAAxC,UAA8D3wB,QAA9D;;AAEA;AACA,QAAI,CAACwH,SAAL,EAAgB;AACd,YAAM,IAAIpF,KAAJ,CAAU,iCAAV,CAAN;AACD;AACD,QAAMyuB,eAAgBrpB,SAAD,CAAYwlB,KAAZ,CAAkBrxB,OAAOC,OAAP,CAAew0B,oBAAjC,CAArB;AACA,QAAIS,YAAJ,EAAkB;AAChB,YAAM,IAAIzuB,KAAJ,wCAA+CyuB,aAAaC,IAAb,CAAkB,IAAlB,CAA/C,OAAN;AACD;AACD;AACA,QAAIH,iBAAJ,EAAuB;AACrB,UAAI,CAAC3wB,QAAL,EAAe;AACb,cAAM,IAAIoC,KAAJ,iDAAwDuuB,iBAAxD,OAAN;AACD;AACD,UAAIA,sBAAsB,GAA1B,EAA+B;AAC7B,cAAM,IAAIvuB,KAAJ,UAAiBuuB,iBAAjB,kDAAN;AACD;AACF;AACD;AACA,WAAO;AACLnpB;AADK,KAAP;AAGD,GAvFc;AAwFfsnB,iBAAe,uBAAUvzB,KAAV,EAAiB;AAC9BsH,WAAOyC,KAAP,CAAa,mBAAb,EAAkC/J,KAAlC;AACA,QAAMi1B,kBAAkB,IAAIC,MAAJ,CACtB,gBAAgB;AAChB,sBAFsB,CAEH;AAFG,KAAxB;;AAF8B,iCAM0BD,gBACrDxjB,IADqD,CAChDzR,KADgD,EAErD4P,GAFqD,CAEjD;AAAA,aAAS6hB,SAAS,IAAlB;AAAA,KAFiD,CAN1B;AAAA;AAAA,QAMvB0D,KANuB;AAAA,QAMhBlpB,SANgB;AAAA,QAMLmpB,iBANK;AAAA,QAMc3wB,QANd;;AAS9B6C,WAAOyC,KAAP,CAAgBorB,KAAhB,UAA0BlpB,SAA1B,UAAwCmpB,iBAAxC,UAA8D3wB,QAA9D;AACA;AACA,QAAI6uB,mBAAmB,KAAvB;AACA,QAAI8B,iBAAJ,EAAuB;AACrB9B,yBAAmB,IAAnB;AACD;AACD,WAAO;AACLA;AADK,KAAP;AAGD;AA1Gc,CAAjB,C;;;;;;;;;ACFA;;;;AACA;;AACA;;AACA;;;;AACA;;AACA;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;AACA;;AACA;;AAEA;;;;;;AAEA,IAAMkC,uBAAuB,SAAvBA,oBAAuB,CAACC,IAAD,EAAO3xB,MAAP,EAAkB;AAC7C,+CAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBACC,mBAAK2xB,IAAL,EAAW3xB,MAAX,CADD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAP;AAAA;AAGD,CAJD;;AAMA1D,OAAOC,OAAP,GAAiB,UAACqV,GAAD,EAAM/B,GAAN,EAAc;AAC7B,MAAIgC,UAAU,EAAd;;AAEA;AACA,MAAM+f,iBAAiB,0BAAvB;AACA,MAAMC,aAAa,4BAAgBD,cAAhB,CAAnB;;AAEA;AACA,MAAM9f,QAAQ,4CAAqB+f,UAArB,CAAd;;AAEA;AACA,MAAM9S,SAAS,+BAAoBnN,IAAI5R,MAAxB,CAAf;AACA,MAAM2xB,OAAOD,kDAAwC3S,MAAxC,CAAb;;AAEA;AACA6S,iBACGE,GADH,CACOH,IADP,EAEGva,IAFH,CAGGjU,IAHH,CAGQ,YAAM;AACV;AACA,QAAM4O,OAAO,4BACX;AAAA;AAAA,QAAU,OAAOD,KAAjB;AACE;AAAA;AAAA,UAAc,UAAUF,IAAI5O,GAA5B,EAAiC,SAAS6O,OAA1C;AACE;AAAA;AAAA;AACE;AADF;AADF;AADF,KADW,CAAb;;AAUA;AACA,QAAMG,SAAS,sBAAOC,YAAP,EAAf;;AAEA;AACA,QAAIJ,QAAQ7O,GAAZ,EAAiB;AACf,aAAO6M,IAAIqC,QAAJ,CAAa,GAAb,EAAkBL,QAAQ7O,GAA1B,CAAP;AACD;;AAED;AACA,QAAMmP,iBAAiBL,MAAMM,QAAN,EAAvB;;AAEA;AACAvC,QAAIwC,IAAJ,CAAS,8BAAeL,MAAf,EAAuBD,IAAvB,EAA6BI,cAA7B,CAAT;AACD,GA5BH;AA6BD,CA5CD,C;;;;;;ACtBA,uC;;;;;;;;;;;;QCgDkB4f,iB,GAAAA,iB;QAQAC,sB,GAAAA,sB;;AAxDlB;;AACA;;IAAY70B,O;;AACZ;;AACA;;AACA;;AACA;;;;;;;;mDAEW80B,gC;oDAiBAC,uB;oDAwBOH,iB;oDAQAC,sB;;AAjDlB,SAAWC,gCAAX,CAA6CtxB,QAA7C,EAAuDzE,KAAvD;AAAA;;AAAA;AAAA;AAAA;AAAA;AACE;AACA;AACA;AACI0zB,mBAJN,WAIiB1xB,WAJjB,WAI8BwS,cAJ9B,WAI8C3P,OAJ9C,WAIuDoH,SAJvD,WAIkE1H,SAJlE;AAAA;AAAA,kCAM2D,kBAAQovB,eAAR,CAAwBlvB,QAAxB,CAN3D;AAMOivB,mBANP,yBAMOA,SANP;AAMkB1xB,qBANlB,yBAMkBA,WANlB;AAM+BwS,wBAN/B,yBAM+BA,cAN/B;AAM+C3P,iBAN/C,yBAM+CA,OAN/C;AAAA,gCAOgC,kBAAQ4uB,UAAR,CAAmBzzB,KAAnB,CAPhC;AAOOiM,mBAPP,uBAOOA,SAPP;AAOkB1H,mBAPlB,uBAOkBA,SAPlB;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,iBASiB,kBAAI,0BAAe,YAAM1C,OAArB,CAAJ,CATjB;;AAAA;AAAA;;AAAA;AAAA,eAYM6xB,SAZN;AAAA;AAAA;AAAA;;AAAA;AAAA,iBAaiB,gDAAsB,6BAAkBznB,SAAlB,EAA6B,IAA7B,EAAmCjK,WAAnC,EAAgDwS,cAAhD,EAAgEjQ,SAAhE,CAAtB,CAbjB;;AAAA;AAAA;;AAAA;AAcG;AAdH;AAAA,iBAeQ,gDAAsB,6BAAkB0H,SAAlB,EAA6BpH,OAA7B,EAAsC,IAAtC,EAA4C,IAA5C,EAAkDN,SAAlD,CAAtB,CAfR;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,SAAWyxB,uBAAX,CAAoCh2B,KAApC;AAAA;;AAAA;AAAA;AAAA;AAAA;AACE;AACA;AACI0zB,mBAHN,WAGiB1xB,WAHjB,WAG8BwS,cAH9B;AAAA;AAAA,mCAKkD,kBAAQmf,eAAR,CAAwB3zB,KAAxB,CALlD;AAKO0zB,mBALP,0BAKOA,SALP;AAKkB1xB,qBALlB,0BAKkBA,WALlB;AAK+BwS,wBAL/B,0BAK+BA,cAL/B;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,iBAOiB,kBAAI,0BAAe,aAAM3S,OAArB,CAAJ,CAPjB;;AAAA;AAAA;;AAAA;AAAA,eAWM6xB,SAXN;AAAA;AAAA;AAAA;;AAAA;AAAA,iBAYiB,oDAAwB,+BAAoB1xB,WAApB,EAAiCwS,cAAjC,CAAxB,CAZjB;;AAAA;AAAA;;AAAA;AAcE;AACIvI,mBAfN,WAeiB1H,SAfjB;AAAA;AAAA,iCAiB8B,kBAAQkvB,UAAR,CAAmBzzB,KAAnB,CAjB9B;AAiBMiM,mBAjBN,wBAiBMA,SAjBN;AAiBiB1H,mBAjBjB,wBAiBiBA,SAjBjB;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,iBAmBiB,kBAAI,0BAAe,aAAM1C,OAArB,CAAJ,CAnBjB;;AAAA;AAAA;;AAAA;AAAA;AAAA,iBAqBQ,gDAAsB,6BAAkBoK,SAAlB,EAA6B,IAA7B,EAAmC,IAAnC,EAAyC,IAAzC,EAA+C1H,SAA/C,CAAtB,CArBR;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAwBO,SAAWsxB,iBAAX,CAA8BhT,MAA9B;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,yBACyBA,OAAOxhB,IADhC,EACGuyB,UADH,gBACGA,UADH,EACe5zB,KADf,gBACeA,KADf;;AAAA,eAED4zB,UAFC;AAAA;AAAA;AAAA;;AAAA;AAAA,iBAGU,mBAAKmC,gCAAL,EAAuCnC,UAAvC,EAAmD5zB,KAAnD,CAHV;;AAAA;AAAA;;AAAA;AAAA;AAAA,iBAKC,mBAAKg2B,uBAAL,EAA8Bh2B,KAA9B,CALD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,CAMN;;AAEM,SAAW81B,sBAAX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBACC,yBAAW70B,QAAQ8C,eAAnB,EAAoC8xB,iBAApC,CADD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,CAEN,C;;;;;;;;;;;;QCpDiBI,e,GAAAA,e;QA4CAC,oB,GAAAA,oB;;AAlDlB;;AACA;;IAAYj1B,O;;AACZ;;AACA;;AACA;;;;mDAEkBg1B,e;oDA4CAC,oB;;AA5CX,SAAWD,eAAX,CAA4BpT,MAA5B;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,yBAC8CA,OAAOxhB,IADrD,EACG8C,WADH,gBACGA,WADH,EACgBC,SADhB,gBACgBA,SADhB,EAC2B5E,IAD3B,gBAC2BA,IAD3B,EACiCiF,QADjC,gBACiCA,QADjC;AAEL;;AAFK;AAAA,iBAGC,kBAAI,2BAAgBN,WAAhB,EAA6BC,SAA7B,CAAJ,CAHD;;AAAA;AAAA;AAAA,iBAMe,4CANf;;AAAA;AAMCoG,eAND;;AAAA,eAODA,MAAMJ,WAAN,CAAkBhG,SAAlB,CAPC;AAAA;AAAA;AAAA;;AAAA,2CAQI,IARJ;;AAAA;AAUL;AACIxB,gBAXC;AAAA;AAAA;AAAA,iBAaqB,6CAAqBpD,IAArB,EAA2BiF,QAA3B,CAbrB;;AAAA;AAAA;AAaK7B,gBAbL,QAaDvB,IAbC;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,iBAeU,kBAAI,0BAAe,YAAMQ,OAArB,CAAJ,CAfV;;AAAA;AAAA;;AAAA;AAiBCwI,kBAjBD,UAiBiB7K,IAjBjB,SAiByBoD,MAjBzB;AAAA;AAAA,iBAkBC,kBAAI,mCAAwBwB,SAAxB,EAAmC,IAAnC,EAAyCiG,QAAzC,CAAJ,CAlBD;;AAAA;AAAA,eAqBDG,MAAMF,SAAN,CAAgBD,QAAhB,CArBC;AAAA;AAAA;AAAA;;AAAA,2CAsBI,IAtBJ;;AAAA;AAwBL;AACI3H,iBAzBC;AAAA;AAAA;AAAA,iBA2BsB,yCAAiBlD,IAAjB,EAAuBoD,MAAvB,CA3BtB;;AAAA;AAAA;AA2BKF,iBA3BL,SA2BDrB,IA3BC;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,iBA6BU,kBAAI,0BAAe,YAAMQ,OAArB,CAAJ,CA7BV;;AAAA;AAAA;;AAAA;AA+BL;AACIiD,mBAhCC;AAAA;AAAA;AAAA,iBAkCwB,2CAAmBtF,IAAnB,EAAyBoD,MAAzB,CAlCxB;;AAAA;AAAA;AAkCKkC,mBAlCL,SAkCDzD,IAlCC;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,iBAoCU,kBAAI,0BAAe,YAAMQ,OAArB,CAAJ,CApCV;;AAAA;AAAA;;AAAA;AAAA;AAAA,iBAuCC,kBAAI,+BAAoBwI,QAApB,EAA8B,IAA9B,EAAoC7K,IAApC,EAA0CoD,MAA1C,EAAkDF,OAAlD,EAA2DoC,SAA3D,CAAJ,CAvCD;;AAAA;AAAA;AAAA,iBAyCC,kBAAI,0BAAe,IAAf,CAAJ,CAzCD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,CA0CN;;AAEM,SAAWoxB,oBAAX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBACC,yBAAWj1B,QAAQuD,iBAAnB,EAAsCyxB,eAAtC,CADD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,CAEN,C;;;;;;;;;;;;QCjDethB,c,GAAAA,c;QAuBAwhB,U,GAAAA,U;QAKAC,Y,GAAAA,Y;;AA/BhB;;;;;;eAC2B,mBAAA/uB,CAAQ,CAAR,C;IAAX5H,I,YAARH,I,CAAQG,I;;AAET,SAASkV,cAAT,CAAyBnV,IAAzB,EAA+BiF,QAA/B,EAAyC;AAC9C,MAAIga,OAAO,EAAX;AACA;AACA,MAAIha,QAAJ,EAAc;AACZ,QAAIA,SAASH,EAAb,EAAiB;AACfma,WAAK,SAAL,IAAkBha,SAASH,EAA3B;AACD,KAFD,MAEO;AACLma,WAAK,aAAL,IAAsBha,SAAS/C,OAAT,CAAiBlC,IAAvC;AACAif,WAAK,gBAAL,IAAyBha,SAAS/C,OAAT,CAAiB4C,EAA1C;AACD;AACF;AACDma,OAAK,WAAL,IAAoBjf,IAApB;AACA,MAAMsE,SAAS;AACb8H,YAAS,MADI;AAEbe,aAAS,EAAE,gBAAgB,kBAAlB,EAFI;AAGb8R,UAASrT,KAAKC,SAAL,CAAeoT,IAAf;AAHI,GAAf;AAKA;AACA,MAAM3X,MAASrH,IAAT,uBAAN;AACA;AACA,SAAO,uBAAQqH,GAAR,EAAahD,MAAb,CAAP;AACD;;AAEM,SAASqyB,UAAT,CAAqB32B,IAArB,EAA2BqF,OAA3B,EAAoC;AACzC,MAAMiC,MAASrH,IAAT,4BAAoCoF,OAApC,SAA+CrF,IAArD;AACA,SAAO,uBAAQsH,GAAR,CAAP;AACD;;AAEM,SAASsvB,YAAT,CAAuB52B,IAAvB,EAA6BqF,OAA7B,EAAsC;AAC3C,MAAMiC,MAASrH,IAAT,wBAAgCD,IAAhC,SAAwCqF,OAA9C;AACA,SAAO,uBAAQiC,GAAR,CAAP;AACD,E;;;;;;;;;;;;QC5BiBuvB,iB,GAAAA,iB;QAsCAC,sB,GAAAA,sB;QAeAC,wB,GAAAA,wB;;AA3DlB;;AACA;;IAAYt1B,O;;AACZ;;AACA;;AACA;;;;mDAEkBo1B,iB;oDAsCAC,sB;oDAIPE,4B;oDAWOD,wB;;AArDX,SAAWF,iBAAX,CAA8BxT,MAA9B;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,yBACsDA,OAAOxhB,IAD7D,EACG8C,WADH,gBACGA,WADH,EACgBC,SADhB,gBACgBA,SADhB,EAC2BpC,WAD3B,gBAC2BA,WAD3B,EACwCkC,SADxC,gBACwCA,SADxC;AAEL;;AAFK;AAAA,iBAGC,kBAAI,2BAAgBC,WAAhB,EAA6BC,SAA7B,CAAJ,CAHD;;AAAA;AAAA;AAAA,iBAMe,4CANf;;AAAA;AAMCoG,eAND;;AAAA,eAODA,MAAMJ,WAAN,CAAkBhG,SAAlB,CAPC;AAAA;AAAA;AAAA;;AAAA,2CAQI,IARJ;;AAAA;AAUL;AACIxB,gBAXC,WAWOF,OAXP;AAAA;AAAA;AAAA,iBAa2E,+CAAqBV,WAArB,EAAkCkC,SAAlC,CAb3E;;AAAA;AAAA;AAAA,2BAaA7C,IAbA;AAa2BuB,gBAb3B,aAaOqS,kBAbP;AAawDvS,iBAbxD,aAamCyS,mBAbnC;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,iBAeU,kBAAI,0BAAe,YAAMtT,OAArB,CAAJ,CAfV;;AAAA;AAAA;;AAAA;AAiBL;AACMqD,oBAlBD,UAkBmBlD,WAlBnB,SAkBkCY,MAlBlC;AAAA;AAAA,iBAmBC,kBAAI,mCAAwBwB,SAAxB,EAAmC,IAAnC,EAAyCc,UAAzC,CAAJ,CAnBD;;AAAA;AAAA,eAsBDsF,MAAM8b,WAAN,CAAkBphB,UAAlB,CAtBC;AAAA;AAAA;AAAA;;AAAA,2CAuBI,IAvBJ;;AAAA;AAyBL;AACIF,oBA1BC;AAAA;AAAA;AAAA,iBA4B2B,iDAAuBhD,WAAvB,EAAoCY,MAApC,EAA4C,CAA5C,CA5B3B;;AAAA;AAAA;AA4BMoC,oBA5BN,SA4BA3D,IA5BA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,iBA8BU,kBAAI,0BAAe,YAAMQ,OAArB,CAAJ,CA9BV;;AAAA;AAAA;;AAAA;AAAA;AAAA,iBAiCC,kBAAI,sCAA2BqD,UAA3B,EAAuClD,WAAvC,EAAoDU,OAApD,EAA6DE,MAA7D,EAAqEoC,UAArE,CAAJ,CAjCD;;AAAA;AAAA;AAAA,iBAmCC,kBAAI,0BAAe,IAAf,CAAJ,CAnCD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAsCA,SAAWsxB,sBAAX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBACC,yBAAWr1B,QAAQoD,mBAAnB,EAAwCgyB,iBAAxC,CADD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,CAEN;;AAED,SAAWG,4BAAX,CAAyC3T,MAAzC;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,0BAC6CA,OAAOxhB,IADpD,EACU6D,UADV,iBACUA,UADV,EACsB1F,IADtB,iBACsBA,IADtB,EAC4BoD,MAD5B,iBAC4BA,MAD5B,EACoCuC,IADpC,iBACoCA,IADpC;AAEMH,oBAFN;AAAA;AAAA;AAAA,iBAIkC,iDAAuBxF,IAAvB,EAA6BoD,MAA7B,EAAqCuC,IAArC,CAJlC;;AAAA;AAAA;AAIaH,oBAJb,SAIO3D,IAJP;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA,iBAMiB,kBAAI,0BAAe,aAAMQ,OAArB,CAAJ,CANjB;;AAAA;AAAA;;AAAA;AAAA;AAAA,iBAQQ,kBAAI,+BAAoBqD,UAApB,EAAgCF,UAAhC,CAAJ,CARR;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAWO,SAAWuxB,wBAAX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBACC,yBAAWt1B,QAAQmE,2BAAnB,EAAgDoxB,4BAAhD,CADD;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,C;;;;;;;;;;;;QCxDSxhB,c,GAAAA,c;QAMAI,gB,GAAAA,gB;;AAThB;;;;;;eAC2B,mBAAA/N,CAAQ,CAAR,C;IAAX5H,I,YAARH,I,CAAQG,I;;AAET,SAASuV,cAAT,CAAyBxV,IAAzB,EAA+B8E,EAA/B,EAAmC;AACxC,MAAI,CAACA,EAAL,EAASA,KAAK,MAAL;AACT,MAAMwC,MAASrH,IAAT,0BAAkCD,IAAlC,SAA0C8E,EAAhD;AACA,SAAO,uBAAQwC,GAAR,CAAP;AACD;;AAEM,SAASsO,gBAAT,CAA2B5V,IAA3B,EAAiCoD,MAAjC,EAAyCuC,IAAzC,EAA+C;AACpD,MAAI,CAACA,IAAL,EAAWA,OAAO,CAAP;AACX,MAAM2B,MAASrH,IAAT,4BAAoCD,IAApC,SAA4CoD,MAA5C,SAAsDuC,IAA5D;AACA,SAAO,uBAAQ2B,GAAR,CAAP;AACD,E;;;;;;;;;;;ACbD1G,OAAOC,OAAP,GAAiB;AACfw0B,wBAAwB,gBADT;AAEfC,0BAAwB,iBAFT;AAGfC,kBAAwB,yCAHT;AAIfC,gBAAwB,GAJT;AAKfrB,mBAAwB,yBAAUC,UAAV,EAAsB;AAC5C,QAAMqB,kBAAkB,IAAIC,MAAJ,CACtB,eAAe;AACf,qBAFsB,CAEJ;AAFI,KAAxB;;AAD4C,gCAKQD,gBAAiB;AAAjB,KACjDxjB,IADiD,CAC5CmiB,UAD4C,EAEjDhkB,GAFiD,CAE7C;AAAA,aAAS6hB,SAAS,IAAlB;AAAA,KAF6C,CALR;AAAA;AAAA,QAKrC0D,KALqC;AAAA,QAK9B5zB,KAL8B;AAAA,QAKvB6zB,iBALuB;AAAA,QAKJ3wB,QALI;;AAS5C;;;AACA,QAAI,CAAClD,KAAL,EAAY;AACV,YAAM,IAAIsF,KAAJ,wDAA+DuuB,iBAA/D,OAAN;AACD;AACD,QAAM1B,YAAYnyB,MAAM8zB,UAAN,CAAiBj1B,OAAOC,OAAP,CAAe20B,YAAhC,CAAlB;AACA,QAAMhzB,cAAc0xB,YAAYnyB,KAAZ,GAAoB,IAAxC;AACA,QAAIsD,gBAAJ;AACA,QAAI6uB,SAAJ,EAAe;AACb,UAAI,CAAC1xB,WAAL,EAAkB;AAChB,cAAM,IAAI6E,KAAJ,CAAU,6CAAV,CAAN;AACD;AACD,UAAMyuB,eAAgBtzB,WAAD,CAAcyvB,KAAd,CAAoBrxB,OAAOC,OAAP,CAAey0B,sBAAnC,CAArB;AACA,UAAIQ,YAAJ,EAAkB;AAChB,cAAM,IAAIzuB,KAAJ,4DAAmEyuB,aAAaC,IAAb,CAAkB,IAAlB,CAAnE,QAAN;AACD;AACF,KARD,MAQO;AACL1wB,gBAAUtD,KAAV;AACD;;AAED;AACA,QAAIiT,uBAAJ;AACA,QAAI4gB,iBAAJ,EAAuB;AACrB,UAAI,CAAC3wB,QAAL,EAAe;AACb,cAAM,IAAIoC,KAAJ,6DAAoEuuB,iBAApE,OAAN;AACD;;AAED,UAAIA,sBAAsB,GAA1B,EAA+B;AAC7B5gB,yBAAiB/P,QAAjB;AACD,OAFD,MAEO;AACL,cAAM,IAAIoC,KAAJ,4BAAmCuuB,iBAAnC,2CAAN;AACD;AACF;AACD,WAAO;AACL1B,0BADK;AAEL1xB,8BAFK;AAGLwS,sBAAgBA,kBAAkB,IAH7B;AAIL3P,eAAgBA,WAAW;AAJtB,KAAP;AAMD,GApDc;AAqDf4uB,cAAY,oBAAUj0B,IAAV,EAAgB;AAC1B,QAAMy1B,kBAAkB,IAAIC,MAAJ,CACtB,gBAAgB;AAChB,sBAFsB,CAEH;AAFG,KAAxB;;AAD0B,iCAKgCD,gBAAgB;AAAhB,KACvDxjB,IADuD,CAClDjS,IADkD,EAEvDoQ,GAFuD,CAEnD;AAAA,aAAS6hB,SAAS,IAAlB;AAAA,KAFmD,CALhC;AAAA;AAAA,QAKnB0D,KALmB;AAAA,QAKZlpB,SALY;AAAA,QAKDwqB,kBALC;AAAA,QAKmBlyB,SALnB;;AAS1B;;;AACA,QAAI,CAAC0H,SAAL,EAAgB;AACd,YAAM,IAAIpF,KAAJ,CAAU,oDAAV,CAAN;AACD;AACD,QAAMyuB,eAAgBrpB,SAAD,CAAYwlB,KAAZ,CAAkBrxB,OAAOC,OAAP,CAAew0B,oBAAjC,CAArB;AACA,QAAIS,YAAJ,EAAkB;AAChB,YAAM,IAAIzuB,KAAJ,0DAAiEyuB,aAAaC,IAAb,CAAkB,IAAlB,CAAjE,QAAN;AACD;AACD;AACA,QAAIkB,kBAAJ,EAAwB;AACtB,UAAI,CAAClyB,SAAL,EAAgB;AACd,cAAM,IAAIsC,KAAJ,mEAA0E4vB,kBAA1E,QAAN;AACD;AACD,UAAIA,uBAAuB,GAA3B,EAAgC;AAC9B,cAAM,IAAI5vB,KAAJ,4BAAmC4vB,kBAAnC,qDAAN;AACD;AACF;AACD,WAAO;AACLxqB,0BADK;AAEL1H,iBAAWA,aAAa;AAFnB,KAAP;AAID;AAnFc,CAAjB,C;;;;;;;;;ACAA,IAAMuhB,mBAAmB,mBAAAze,CAAQ,EAAR,CAAzB;;AAEAjH,OAAOC,OAAP,GAAiB,eAAO;AACtB;AACAoZ,MAAIE,GAAJ,CAAQ,GAAR,EAAa,UAACjE,GAAD,EAAM/B,GAAN,EAAc;AACzB;AACAmS,qBAAiBpQ,GAAjB,EAAsB/B,GAAtB;AACD,GAHD;AAID,CAND,C","file":"index.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 45);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap ccaf8d6da25f6866aa0d","module.exports = require(\"react\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"react\"\n// module id = 0\n// module chunks = 0","module.exports = require(\"react-redux\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"react-redux\"\n// module id = 1\n// module chunks = 0","module.exports = require(\"winston\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"winston\"\n// module id = 2\n// module chunks = 0","const speechConfig = {\n  analytics: {\n    googleId: 'UA-60403362-6', // google id for analytics tracking; leave `null` if not applicable\n  },\n  session: {\n    sessionKey: 'nans$#kfjanwe234rydns',  // enter a secret key to be used for session encryption\n  },\n  files: {\n    uploadDirectory: '/home/lbry/Uploads',  // enter file path to where uploads/publishes should be stored\n  },\n  site: {\n    title      : 'dev1.Spee.ch',\n    name       : 'dev1.Spee.ch',\n    host       : 'https://dev1.spee.ch',\n    description: 'Open-source, decentralized image and video sharing.',\n  },\n  publish: {\n    primaryClaimAddress     : 'bDZ2wPwtULUGxT7GXuNLpQhXmdPRUTUkcL',\n    additionalClaimAddresses: ['banpwixPosfVDWnGvXqU2af36Qpsd7buGd'],\n    thumbnailChannel        : '@dev1thumbs',  // create a channel to use for thumbnail images\n    thumbnailChannelId      : 'aeb625ff6f66c3eeeb42885070f4e53876033626',  // the channel_id (claim id) for the channel above\n  },\n  claim: {\n    defaultTitle      : 'dev1 Spee.ch',\n    defaultThumbnail  : 'https://spee.ch/assets/img/video_thumb_default.png',\n    defaultDescription: 'Open-source, decentralized image and video sharing.',\n  },\n};\n\nmodule.exports = speechConfig;\n\n\n\n// WEBPACK FOOTER //\n// ./config/speechConfig.js","module.exports = require(\"react-router-dom\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"react-router-dom\"\n// module id = 4\n// module chunks = 0","import * as actions from 'constants/publish_action_types';\n\n// export action creators\nexport function selectFile (file) {\n  return {\n    type: actions.FILE_SELECTED,\n    data: file,\n  };\n};\n\nexport function clearFile () {\n  return {\n    type: actions.FILE_CLEAR,\n  };\n};\n\nexport function updateMetadata (name, value) {\n  return {\n    type: actions.METADATA_UPDATE,\n    data: {\n      name,\n      value,\n    },\n  };\n};\n\nexport function updateClaim (value) {\n  return {\n    type: actions.CLAIM_UPDATE,\n    data: value,\n  };\n};\n\nexport function setPublishInChannel (channel) {\n  return {\n    type: actions.SET_PUBLISH_IN_CHANNEL,\n    channel,\n  };\n};\n\nexport function updatePublishStatus (status, message) {\n  return {\n    type: actions.PUBLISH_STATUS_UPDATE,\n    data: {\n      status,\n      message,\n    },\n  };\n};\n\nexport function updateError (name, value) {\n  return {\n    type: actions.ERROR_UPDATE,\n    data: {\n      name,\n      value,\n    },\n  };\n};\n\nexport function updateSelectedChannel (channelName) {\n  return {\n    type: actions.SELECTED_CHANNEL_UPDATE,\n    data: channelName,\n  };\n};\n\nexport function toggleMetadataInputs (showMetadataInputs) {\n  return {\n    type: actions.TOGGLE_METADATA_INPUTS,\n    data: showMetadataInputs,\n  };\n};\n\nexport function onNewThumbnail (file) {\n  return {\n    type: actions.THUMBNAIL_NEW,\n    data: file,\n  };\n};\n\nexport function startPublish (history) {\n  return {\n    type: actions.PUBLISH_START,\n    data: { history },\n  };\n}\n\n\n\n// WEBPACK FOOTER //\n// ./react/actions/publish.js","import { connect } from 'react-redux';\nimport { updateLoggedInChannel } from 'actions/channel';\nimport View from './view';\nimport {updateSelectedChannel} from '../../actions/publish';\n\nconst mapStateToProps = ({ channel }) => {\n  return {\n    channelName   : channel.loggedInChannel.name,\n    channelShortId: channel.loggedInChannel.shortId,\n    channelLongId : channel.loggedInChannel.longId,\n  };\n};\n\nconst mapDispatchToProps = dispatch => {\n  return {\n    onChannelLogin: (name, shortId, longId) => {\n      dispatch(updateLoggedInChannel(name, shortId, longId));\n      dispatch(updateSelectedChannel(name));\n    },\n    onChannelLogout: () => {\n      dispatch(updateLoggedInChannel(null, null, null));\n    },\n  };\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/NavBar/index.js","import * as actions from 'constants/show_action_types';\n\nimport { CHANNEL, ASSET_LITE, ASSET_DETAILS } from 'constants/show_request_types';\n\n// basic request parsing\nexport function onHandleShowPageUri (params) {\n  return {\n    type: actions.HANDLE_SHOW_URI,\n    data: params,\n  };\n};\n\nexport function onRequestError (error) {\n  return {\n    type: actions.REQUEST_ERROR,\n    data: error,\n  };\n};\n\nexport function onNewChannelRequest (channelName, channelId) {\n  const requestType = CHANNEL;\n  const requestId = `cr#${channelName}#${channelId}`;\n  return {\n    type: actions.CHANNEL_REQUEST_NEW,\n    data: { requestType, requestId, channelName, channelId },\n  };\n};\n\nexport function onNewAssetRequest (name, id, channelName, channelId, extension) {\n  const requestType = extension ? ASSET_LITE : ASSET_DETAILS;\n  const requestId = `ar#${name}#${id}#${channelName}#${channelId}`;\n  return {\n    type: actions.ASSET_REQUEST_NEW,\n    data: {\n      requestType,\n      requestId,\n      name,\n      modifier: {\n        id,\n        channel: {\n          name: channelName,\n          id  : channelId,\n        },\n      },\n    },\n  };\n};\n\nexport function onRequestUpdate (requestType, requestId) {\n  return {\n    type: actions.REQUEST_UPDATE,\n    data: {\n      requestType,\n      requestId,\n    },\n  };\n};\n\nexport function addRequestToRequestList (id, error, key) {\n  return {\n    type: actions.REQUEST_LIST_ADD,\n    data: { id, error, key },\n  };\n};\n\n// asset actions\n\nexport function addAssetToAssetList (id, error, name, claimId, shortId, claimData) {\n  return {\n    type: actions.ASSET_ADD,\n    data: { id, error, name, claimId, shortId, claimData },\n  };\n}\n\n// channel actions\n\nexport function addNewChannelToChannelList (id, name, shortId, longId, claimsData) {\n  return {\n    type: actions.CHANNEL_ADD,\n    data: { id, name, shortId, longId, claimsData },\n  };\n};\n\nexport function onUpdateChannelClaims (channelKey, name, longId, page) {\n  return {\n    type: actions.CHANNEL_CLAIMS_UPDATE_ASYNC,\n    data: {channelKey, name, longId, page},\n  };\n};\n\nexport function updateChannelClaims (channelListId, claimsData) {\n  return {\n    type: actions.CHANNEL_CLAIMS_UPDATE_SUCCESS,\n    data: {channelListId, claimsData},\n  };\n};\n\n// display a file\n\nexport function fileRequested (name, claimId) {\n  return {\n    type: actions.FILE_REQUESTED,\n    data: { name, claimId },\n  };\n};\n\nexport function updateFileAvailability (status) {\n  return {\n    type: actions.FILE_AVAILABILITY_UPDATE,\n    data: status,\n  };\n};\n\nexport function updateDisplayAssetError (error) {\n  return {\n    type: actions.DISPLAY_ASSET_ERROR,\n    data: error,\n  };\n};\n\n\n\n// WEBPACK FOOTER //\n// ./react/actions/show.js","import React from 'react';\nimport Helmet from 'react-helmet';\nimport PropTypes from 'prop-types';\n\nimport { createPageTitle } from 'utils/pageTitle';\nimport { createMetaTags } from 'utils/metaTags';\nimport { createCanonicalLink } from 'utils/canonicalLink';\n\nclass SEO extends React.Component {\n  render () {\n    let { pageTitle, asset, channel, pageUri } = this.props;\n    pageTitle = createPageTitle(pageTitle);\n    const metaTags = createMetaTags(asset, channel);\n    const canonicalLink = createCanonicalLink(asset, channel, pageUri);\n    return (\n      <Helmet\n        title={pageTitle}\n        meta={metaTags}\n        link={[{rel: 'canonical', href: canonicalLink}]}\n      />\n    );\n  }\n};\n\nSEO.propTypes = {\n  pageTitle: PropTypes.string,\n  pageUri  : PropTypes.string,\n  channel  : PropTypes.object,\n  asset    : PropTypes.object,\n};\n\nexport default SEO;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/SEO/index.jsx","module.exports = require(\"prop-types\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"prop-types\"\n// module id = 9\n// module chunks = 0","import 'cross-fetch/polyfill';\n\n/**\n * Parses the JSON returned by a network request\n *\n * @param  {object} response A response from a network request\n *\n * @return {object}          The parsed JSON from the request\n */\nfunction parseJSON (response) {\n  if (response.status === 204 || response.status === 205) {\n    return null;\n  }\n  return response.json();\n}\n\n/**\n * Parses the status returned by a network request\n *\n * @param  {object} response   A response from a network request\n * @param  {object} response   The parsed JSON from the network request\n *\n * @return {object | undefined} Returns object with status and statusText, or undefined\n */\nfunction checkStatus (response, jsonResponse) {\n  if (response.status >= 200 && response.status < 300) {\n    return jsonResponse;\n  }\n  const error = new Error(jsonResponse.message);\n  error.response = response;\n  throw error;\n}\n\n/**\n * Requests a URL, returning a promise\n *\n * @param  {string} url       The URL we want to request\n * @param  {object} [options] The options we want to pass to \"fetch\"\n *\n * @return {object}           The response data\n */\n\nexport default function request (url, options) {\n  return fetch(url, options)\n    .then(response => {\n      return Promise.all([response, parseJSON(response)]);\n    })\n    .then(([response, jsonResponse]) => {\n      return checkStatus(response, jsonResponse);\n    });\n}\n\n\n\n// WEBPACK FOOTER //\n// ./react/utils/request.js","const Sequelize = require('sequelize');\nconst logger = require('winston');\n\nconsole.log('exporting sequelize models');\nconst { database, username, password } = require('../config/mysqlConfig');\nconst db = {};\n// set sequelize options\nconst sequelize = new Sequelize(database, username, password, {\n  host          : 'localhost',\n  dialect       : 'mysql',\n  dialectOptions: {decimalNumbers: true}, // fix to ensure DECIMAL will not be stored as a string\n  logging       : false,\n  pool          : {\n    max    : 5,\n    min    : 0,\n    idle   : 10000,\n    acquire: 10000,\n  },\n});\n\n// establish mysql connection\nsequelize\n  .authenticate()\n  .then(() => {\n    logger.info('Sequelize has established mysql connection successfully.');\n  })\n  .catch(err => {\n    logger.error('Sequelize was unable to connect to the database:', err);\n  });\n\n// manually add each model to the db object\nconst Certificate = require('./certificate.js');\nconst Channel = require('./channel.js');\nconst Claim = require('./claim.js');\nconst File = require('./file.js');\nconst Request = require('./request.js');\nconst User = require('./user.js');\ndb['Certificate'] = sequelize.import('Certificate', Certificate);\ndb['Channel'] = sequelize.import('Channel', Channel);\ndb['Claim'] = sequelize.import('Claim', Claim);\ndb['File'] = sequelize.import('File', File);\ndb['Request'] = sequelize.import('Request', Request);\ndb['User'] = sequelize.import('User', User);\n\n// run model.association for each model in the db object that has an association\nObject.keys(db).forEach(modelName => {\n  if (db[modelName].associate) {\n    logger.info('Associating model:', modelName);\n    db[modelName].associate(db);\n  }\n});\n\ndb.sequelize = sequelize;\ndb.Sequelize = Sequelize;\n\n// add an 'upsert' method to the db object\ndb.upsert = (Model, values, condition, tableName) => {\n  return Model\n    .findOne({\n      where: condition,\n    })\n    .then(obj => {\n      if (obj) {  // update\n        logger.debug(`updating record in db.${tableName}`);\n        return obj.update(values);\n      } else {  // insert\n        logger.debug(`creating record in db.${tableName}`);\n        return Model.create(values);\n      }\n    })\n    .catch(function (error) {\n      logger.error(`${tableName}.upsert error`, error);\n      throw error;\n    });\n};\n\nmodule.exports = db;\n\n\n\n// WEBPACK FOOTER //\n// ./models/index.js","// request actions\nexport const HANDLE_SHOW_URI = 'HANDLE_SHOW_URI';\nexport const REQUEST_ERROR = 'REQUEST_ERROR';\nexport const REQUEST_UPDATE = 'REQUEST_UPDATE';\nexport const ASSET_REQUEST_NEW = 'ASSET_REQUEST_NEW';\nexport const CHANNEL_REQUEST_NEW = 'CHANNEL_REQUEST_NEW';\nexport const REQUEST_LIST_ADD = 'REQUEST_LIST_ADD';\n\n// asset actions\nexport const ASSET_ADD = `ASSET_ADD`;\n\n// channel actions\nexport const CHANNEL_ADD = 'CHANNEL_ADD';\n\nexport const CHANNEL_CLAIMS_UPDATE_ASYNC = 'CHANNEL_CLAIMS_UPDATE_ASYNC';\nexport const CHANNEL_CLAIMS_UPDATE_SUCCESS = 'CHANNEL_CLAIMS_UPDATE_SUCCESS';\n\n// asset/file display actions\nexport const FILE_REQUESTED = 'FILE_REQUESTED';\nexport const FILE_AVAILABILITY_UPDATE = 'FILE_AVAILABILITY_UPDATE';\nexport const DISPLAY_ASSET_ERROR = 'DISPLAY_ASSET_ERROR';\n\n\n\n// WEBPACK FOOTER //\n// ./react/constants/show_action_types.js","export const selectAsset = (show) => {\n  const request = show.requestList[show.request.id];\n  const assetKey = request.key;\n  return show.assetList[assetKey];\n};\n\nexport const selectShowState = (state) => {\n  return state.show;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./react/selectors/show.js","module.exports = require(\"react-helmet\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"react-helmet\"\n// module id = 14\n// module chunks = 0","module.exports = require(\"redux-saga/effects\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"redux-saga/effects\"\n// module id = 15\n// module chunks = 0","const axios = require('axios');\nconst logger = require('winston');\nconst { api: { apiHost, apiPort } } = require('../config/lbryConfig.js');\nconst lbryApiUri = 'http://' + apiHost + ':' + apiPort;\nconst { chooseGaLbrynetPublishLabel, sendGATimingEvent } = require('./googleAnalytics.js');\n\nconst handleLbrynetResponse = ({ data }, resolve, reject) => {\n  logger.debug('lbry api data:', data);\n  if (data.result) {\n    // check for an error\n    if (data.result.error) {\n      logger.debug('Lbrynet api error:', data.result.error);\n      reject(new Error(data.result.error));\n      return;\n    };\n    resolve(data.result);\n    return;\n  }\n  // fallback in case it just timed out\n  reject(JSON.stringify(data));\n};\n\nmodule.exports = {\n  publishClaim (publishParams) {\n    logger.debug(`lbryApi >> Publishing claim to \"${publishParams.name}\"`);\n    const gaStartTime = Date.now();\n    return new Promise((resolve, reject) => {\n      axios\n        .post(lbryApiUri, {\n          method: 'publish',\n          params: publishParams,\n        })\n        .then(response => {\n          sendGATimingEvent('lbrynet', 'publish', chooseGaLbrynetPublishLabel(publishParams), gaStartTime, Date.now());\n          handleLbrynetResponse(response, resolve, reject);\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  },\n  getClaim (uri) {\n    logger.debug(`lbryApi >> Getting Claim for \"${uri}\"`);\n    const gaStartTime = Date.now();\n    return new Promise((resolve, reject) => {\n      axios\n        .post(lbryApiUri, {\n          method: 'get',\n          params: { uri, timeout: 20 },\n        })\n        .then(response => {\n          sendGATimingEvent('lbrynet', 'getClaim', 'GET', gaStartTime, Date.now());\n          handleLbrynetResponse(response, resolve, reject);\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  },\n  getClaimList (claimName) {\n    logger.debug(`lbryApi >> Getting claim_list for \"${claimName}\"`);\n    const gaStartTime = Date.now();\n    return new Promise((resolve, reject) => {\n      axios\n        .post(lbryApiUri, {\n          method: 'claim_list',\n          params: { name: claimName },\n        })\n        .then(response => {\n          sendGATimingEvent('lbrynet', 'getClaimList', 'CLAIM_LIST', gaStartTime, Date.now());\n          handleLbrynetResponse(response, resolve, reject);\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  },\n  resolveUri (uri) {\n    logger.debug(`lbryApi >> Resolving URI for \"${uri}\"`);\n    const gaStartTime = Date.now();\n    return new Promise((resolve, reject) => {\n      axios\n        .post(lbryApiUri, {\n          method: 'resolve',\n          params: { uri },\n        })\n        .then(({ data }) => {\n          sendGATimingEvent('lbrynet', 'resolveUri', 'RESOLVE', gaStartTime, Date.now());\n          if (data.result[uri].error) {  // check for errors\n            reject(data.result[uri].error);\n          } else {  // if no errors, resolve\n            resolve(data.result[uri]);\n          }\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  },\n  getDownloadDirectory () {\n    logger.debug('lbryApi >> Retrieving the download directory path from lbry daemon...');\n    const gaStartTime = Date.now();\n    return new Promise((resolve, reject) => {\n      axios\n        .post(lbryApiUri, {\n          method: 'settings_get',\n        })\n        .then(({ data }) => {\n          sendGATimingEvent('lbrynet', 'getDownloadDirectory', 'SETTINGS_GET', gaStartTime, Date.now());\n          if (data.result) {\n            resolve(data.result.download_directory);\n          } else {\n            return new Error('Successfully connected to lbry daemon, but unable to retrieve the download directory.');\n          }\n        })\n        .catch(error => {\n          logger.error('Lbrynet Error:', error);\n          resolve('/home/lbry/Downloads/');\n        });\n    });\n  },\n  createChannel (name) {\n    logger.debug(`lbryApi >> Creating channel for ${name}...`);\n    const gaStartTime = Date.now();\n    return new Promise((resolve, reject) => {\n      axios\n        .post(lbryApiUri, {\n          method: 'channel_new',\n          params: {\n            channel_name: name,\n            amount      : 0.1,\n          },\n        })\n        .then(response => {\n          sendGATimingEvent('lbrynet', 'createChannel', 'CHANNEL_NEW', gaStartTime, Date.now());\n          handleLbrynetResponse(response, resolve, reject);\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/lbryApi.js","const logger = require('winston');\nconst ua = require('universal-analytics');\nconst { analytics : { googleId }, site: { name: siteName } } = require('../config/speechConfig.js');\n\nfunction createServeEventParams (headers, ip, originalUrl) {\n  return {\n    eventCategory    : 'client requests',\n    eventAction      : 'serve request',\n    eventLabel       : originalUrl,\n    ipOverride       : ip,\n    userAgentOverride: headers['user-agent'],\n  };\n};\n\nfunction createPublishTimingEventParams (category, variable, label, startTime, endTime) {\n  const duration = endTime - startTime;\n  return {\n    userTimingCategory    : category,\n    userTimingVariableName: variable,\n    userTimingTime        : duration,\n    userTimingLabel       : label,\n  };\n};\n\nfunction sendGoogleAnalyticsEvent (ip, params) {\n  const visitorId = ip.replace(/\\./g, '-');\n  const visitor = ua(googleId, visitorId, { strictCidFormat: false, https: true });\n  visitor.event(params, (err) => {\n    if (err) {\n      logger.error('Google Analytics Event Error >>', err);\n    }\n  });\n};\n\nfunction sendGoogleAnalyticsTiming (visitorId, params) {\n  const visitor = ua(googleId, visitorId, { strictCidFormat: false, https: true });\n  visitor.timing(params, (err) => {\n    if (err) {\n      logger.error('Google Analytics Event Error >>', err);\n    }\n    logger.debug(`Timing event successfully sent to google analytics`);\n  });\n};\n\nmodule.exports = {\n  sendGAServeEvent (headers, ip, originalUrl) {\n    const params = createServeEventParams(headers, ip, originalUrl);\n    sendGoogleAnalyticsEvent(ip, params);\n  },\n  sendGATimingEvent (category, variable, label, startTime, endTime) {\n    const params = createPublishTimingEventParams(category, variable, label, startTime, endTime);\n    sendGoogleAnalyticsTiming(siteName, params);\n  },\n  chooseGaLbrynetPublishLabel ({ channel_name: channelName, channel_id: channelId }) {\n    return (channelName || channelId ? 'PUBLISH_IN_CHANNEL_CLAIM' : 'PUBLISH_ANONYMOUS_CLAIM');\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/googleAnalytics.js","module.exports = require(\"redux\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"redux\"\n// module id = 18\n// module chunks = 0","import * as actions from 'constants/channel_action_types';\n\n// export action creators\n\nexport function updateLoggedInChannel (name, shortId, longId) {\n  return {\n    type: actions.CHANNEL_UPDATE,\n    data: {\n      name,\n      shortId,\n      longId,\n    },\n  };\n};\n\n\n\n// WEBPACK FOOTER //\n// ./react/actions/channel.js","import React from 'react';\nimport PropTypes from 'prop-types';\nimport ActiveStatusBar from 'components/ActiveStatusBar';\nimport InactiveStatusBar from 'components/InactiveStatusBar';\n\nclass ProgressBar extends React.Component {\n  constructor (props) {\n    super(props);\n    this.state = {\n      bars       : [],\n      index      : 0,\n      incrementer: 1,\n    };\n    this.createBars = this.createBars.bind(this);\n    this.startProgressBar = this.startProgressBar.bind(this);\n    this.updateProgressBar = this.updateProgressBar.bind(this);\n    this.stopProgressBar = this.stopProgressBar.bind(this);\n  }\n  componentDidMount () {\n    this.createBars();\n    this.startProgressBar();\n  }\n  componentWillUnmount () {\n    this.stopProgressBar();\n  }\n  createBars () {\n    const bars = [];\n    for (let i = 0; i <= this.props.size; i++) {\n      bars.push({isActive: false});\n    }\n    this.setState({ bars });\n  }\n  startProgressBar () {\n    this.updateInterval = setInterval(this.updateProgressBar.bind(this), 300);\n  };\n  updateProgressBar () {\n    let index = this.state.index;\n    let incrementer = this.state.incrementer;\n    let bars = this.state.bars;\n    // flip incrementer if necessary, to stay in bounds\n    if ((index < 0) || (index > this.props.size)) {\n      incrementer = incrementer * -1;\n      index += incrementer;\n    }\n    // update the indexed bar\n    if (incrementer > 0) {\n      bars[index].isActive = true;\n    } else {\n      bars[index].isActive = false;\n    };\n    // increment index\n    index += incrementer;\n    // update state\n    this.setState({\n      bars,\n      incrementer,\n      index,\n    });\n  };\n  stopProgressBar () {\n    clearInterval(this.updateInterval);\n  };\n  render () {\n    return (\n      <div>\n        {this.state.bars.map((bar, index) => bar.isActive ? <ActiveStatusBar key={index} /> : <InactiveStatusBar key={index}/>)}\n      </div>\n    );\n  }\n};\n\nProgressBar.propTypes = {\n  size: PropTypes.number.isRequired,\n};\n\nexport default ProgressBar;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/ProgressBar/index.jsx","import React from 'react';\nimport PropTypes from 'prop-types';\nimport NavBar from 'containers/NavBar';\n\nclass ErrorPage extends React.Component {\n  render () {\n    const { error } = this.props;\n    return (\n      <div>\n        <NavBar />\n        <div className='row row--padded'>\n          <p>{error}</p>\n        </div>\n      </div>\n    );\n  }\n};\n\nErrorPage.propTypes = {\n  error: PropTypes.string.isRequired,\n};\n\nexport default ErrorPage;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/ErrorPage/index.jsx","module.exports = require(\"passport\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"passport\"\n// module id = 22\n// module chunks = 0","function MysqlConfig () {\r\n  this.database = 'default';\r\n  this.username = 'default';\r\n  this.password = 'default';\r\n  this.configure = ({database, username, password}) => {\r\n    if (database) this.database = database;\r\n    if (username) this.username = username;\r\n    if (password) this.password = password;\r\n  };\r\n};\r\n\r\nmodule.exports = new MysqlConfig();\r\n\n\n\n// WEBPACK FOOTER //\n// ./config/mysqlConfig.js","function SlackConfig () {\n  this.slackWebHook      = 'default';\n  this.slackErrorChannel = 'default';\n  this.slackInfoChannel  = 'default';\n  this.configure = ({slackWebHook, slackErrorChannel, slackInfoChannel}) => {\n    if (slackWebHook) this.slackWebHook = slackWebHook;\n    if (slackErrorChannel) this.slackErrorChannel = slackErrorChannel;\n    if (slackInfoChannel) this.slackInfoChannel = slackInfoChannel;\n  };\n};\n\nmodule.exports = new SlackConfig();\n\n\n\n// WEBPACK FOOTER //\n// ./config/slackConfig.js","module.exports = require(\"passport-local\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"passport-local\"\n// module id = 25\n// module chunks = 0","module.exports = {\n  returnShortId: function (claimsArray, longId) {\n    let claimIndex;\n    let shortId = longId.substring(0, 1); // default short id is the first letter\n    let shortIdLength = 0;\n    // find the index of this claim id\n    claimIndex = claimsArray.findIndex(element => {\n      return element.claimId === longId;\n    });\n    if (claimIndex < 0) {\n      throw new Error('claim id not found in claims list');\n    }\n    // get an array of all claims with lower height\n    let possibleMatches = claimsArray.slice(0, claimIndex);\n    // remove certificates with the same prefixes until none are left.\n    while (possibleMatches.length > 0) {\n      shortIdLength += 1;\n      shortId = longId.substring(0, shortIdLength);\n      possibleMatches = possibleMatches.filter(element => {\n        return (element.claimId && (element.claimId.substring(0, shortIdLength) === shortId));\n      });\n    }\n    return shortId;\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/sequelizeHelpers.js","const logger = require('winston');\nconst fs = require('fs');\nconst { site, wallet, publish } = require('../config/speechConfig.js');\n\nmodule.exports = {\n  parsePublishApiRequestBody ({name, nsfw, license, title, description, thumbnail}) {\n    // validate name\n    if (!name) {\n      throw new Error('no name field found in request');\n    }\n    const invalidNameCharacters = /[^A-Za-z0-9,-]/.exec(name);\n    if (invalidNameCharacters) {\n      throw new Error('The claim name you provided is not allowed.  Only the following characters are allowed: A-Z, a-z, 0-9, and \"-\"');\n    }\n    // optional parameters\n    nsfw = (nsfw === 'true');\n    license = license || null;\n    title = title || null;\n    description = description || null;\n    thumbnail = thumbnail || null;\n    // return results\n    return {\n      name,\n      nsfw,\n      license,\n      title,\n      description,\n      thumbnail,\n    };\n  },\n  parsePublishApiRequestFiles ({file, thumbnail}) {\n    // make sure a file was provided\n    if (!file) {\n      throw new Error('no file with key of [file] found in request');\n    }\n    if (!file.path) {\n      throw new Error('no file path found');\n    }\n    if (!file.type) {\n      throw new Error('no file type found');\n    }\n    if (!file.size) {\n      throw new Error('no file type found');\n    }\n    // validate the file name\n    if (/'/.test(file.name)) {\n      throw new Error('apostrophes are not allowed in the file name');\n    }\n    // validate the file\n    module.exports.validateFileTypeAndSize(file);\n    // return results\n    return {\n      fileName         : file.name,\n      filePath         : file.path,\n      fileType         : file.type,\n      thumbnailFileName: (thumbnail ? thumbnail.name : null),\n      thumbnailFilePath: (thumbnail ? thumbnail.path : null),\n      thumbnailFileType: (thumbnail ? thumbnail.type : null),\n    };\n  },\n  validateFileTypeAndSize (file) {\n    // check file type and size\n    switch (file.type) {\n      case 'image/jpeg':\n      case 'image/jpg':\n      case 'image/png':\n        if (file.size > 10000000) {\n          logger.debug('publish > file validation > .jpeg/.jpg/.png was too big');\n          throw new Error('Sorry, images are limited to 10 megabytes.');\n        }\n        break;\n      case 'image/gif':\n        if (file.size > 50000000) {\n          logger.debug('publish > file validation > .gif was too big');\n          throw new Error('Sorry, .gifs are limited to 50 megabytes.');\n        }\n        break;\n      case 'video/mp4':\n        if (file.size > 50000000) {\n          logger.debug('publish > file validation > .mp4 was too big');\n          throw new Error('Sorry, videos are limited to 50 megabytes.');\n        }\n        break;\n      default:\n        logger.debug('publish > file validation > unrecognized file type');\n        throw new Error('The ' + file.type + ' content type is not supported.  Only, .jpeg, .png, .gif, and .mp4 files are currently supported.');\n    }\n    return file;\n  },\n  createBasicPublishParams (filePath, name, title, description, license, nsfw, thumbnail) {\n    logger.debug(`Creating Publish Parameters`);\n    // provide defaults for title\n    if (title === null || title.trim() === '') {\n      title = name;\n    }\n    // provide default for description\n    if (description === null || description.trim() === '') {\n      description = '';\n    }\n    // provide default for license\n    if (license === null || license.trim() === '') {\n      license = ' ';  // default to empty string\n    }\n    // create the publish params\n    const publishParams = {\n      name,\n      file_path: filePath,\n      bid      : 0.01,\n      metadata : {\n        description,\n        title,\n        author  : site.title,\n        language: 'en',\n        license,\n        nsfw,\n      },\n      claim_address: wallet.lbryClaimAddress,\n    };\n    // add thumbnail to channel if video\n    if (thumbnail) {\n      publishParams['metadata']['thumbnail'] = thumbnail;\n    }\n    return publishParams;\n  },\n  createThumbnailPublishParams (thumbnailFilePath, claimName, license, nsfw) {\n    if (!thumbnailFilePath) {\n      return;\n    }\n    logger.debug(`Creating Thumbnail Publish Parameters`);\n    // create the publish params\n    return {\n      name     : `${claimName}-thumb`,\n      file_path: thumbnailFilePath,\n      bid      : 0.01,\n      metadata : {\n        title      : `${claimName} thumbnail`,\n        description: `a thumbnail for ${claimName}`,\n        author     : site.title,\n        language   : 'en',\n        license,\n        nsfw,\n      },\n      claim_address: wallet.lbryClaimAddress,\n      channel_name : publish.thumbnailChannel,\n      channel_id   : publish.thumbnailChannelId,\n    };\n  },\n  deleteTemporaryFile (filePath) {\n    fs.unlink(filePath, err => {\n      if (err) {\n        logger.error(`error deleting temporary file ${filePath}`);\n        throw err;\n      }\n      logger.debug(`successfully deleted ${filePath}`);\n    });\n  },\n  addGetResultsToFileData (fileInfo, getResult) {\n    fileInfo.fileName = getResult.file_name;\n    fileInfo.filePath = getResult.download_path;\n    return fileInfo;\n  },\n  createFileData ({ name, claimId, outpoint, height, address, nsfw, contentType }) {\n    return {\n      name,\n      claimId,\n      outpoint,\n      height,\n      address,\n      fileName: '',\n      filePath: '',\n      fileType: contentType,\n      nsfw,\n    };\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/publishHelpers.js","const logger = require('winston');\n\nmodule.exports = {\n  handleErrorResponse: function (originalUrl, ip, error, res) {\n    logger.error(`Error on ${originalUrl}`, module.exports.useObjectPropertiesIfNoKeys(error));\n    const [status, message] = module.exports.returnErrorMessageAndStatus(error);\n    res\n      .status(status)\n      .json(module.exports.createErrorResponsePayload(status, message));\n  },\n  returnErrorMessageAndStatus: function (error) {\n    let status, message;\n    // check for daemon being turned off\n    if (error.code === 'ECONNREFUSED') {\n      status = 503;\n      message = 'Connection refused.  The daemon may not be running.';\n      // fallback for everything else\n    } else {\n      status = 400;\n      if (error.message) {\n        message = error.message;\n      } else {\n        message = error;\n      };\n    };\n    return [status, message];\n  },\n  useObjectPropertiesIfNoKeys: function (err) {\n    if (Object.keys(err).length === 0) {\n      let newErrorObject = {};\n      Object.getOwnPropertyNames(err).forEach((key) => {\n        newErrorObject[key] = err[key];\n      });\n      return newErrorObject;\n    }\n    return err;\n  },\n  createErrorResponsePayload (status, message) {\n    return {\n      status,\n      success: false,\n      message,\n    };\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/errorHandlers.js","const db = require('../models');\nconst logger = require('winston');\nconst { returnPaginatedChannelClaims } = require('../helpers/channelPagination.js');\n\nconst NO_CHANNEL = 'NO_CHANNEL';\nconst NO_CLAIM = 'NO_CLAIM';\nconst NO_FILE = 'NO_FILE';\n\nmodule.exports = {\n  getClaimId (channelName, channelClaimId, name, claimId) {\n    if (channelName) {\n      return module.exports.getClaimIdByChannel(channelName, channelClaimId, name);\n    } else {\n      return module.exports.getClaimIdByClaim(name, claimId);\n    }\n  },\n  getClaimIdByClaim (claimName, claimId) {\n    logger.debug(`getClaimIdByClaim(${claimName}, ${claimId})`);\n    return new Promise((resolve, reject) => {\n      db.Claim.getLongClaimId(claimName, claimId)\n        .then(longClaimId => {\n          if (!longClaimId) {\n            resolve(NO_CLAIM);\n          }\n          resolve(longClaimId);\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  },\n  getClaimIdByChannel (channelName, channelClaimId, claimName) {\n    logger.debug(`getClaimIdByChannel(${channelName}, ${channelClaimId}, ${claimName})`);\n    return new Promise((resolve, reject) => {\n      db.Certificate.getLongChannelId(channelName, channelClaimId) // 1. get the long channel id\n        .then(longChannelId => {\n          if (!longChannelId) {\n            return [null, null];\n          }\n          return Promise.all([longChannelId, db.Claim.getClaimIdByLongChannelId(longChannelId, claimName)]);  // 2. get the long claim id\n        })\n        .then(([longChannelId, longClaimId]) => {\n          if (!longChannelId) {\n            return resolve(NO_CHANNEL);\n          }\n          if (!longClaimId) {\n            return resolve(NO_CLAIM);\n          }\n          resolve(longClaimId);\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  },\n  getChannelData (channelName, channelClaimId, page) {\n    return new Promise((resolve, reject) => {\n      // 1. get the long channel Id (make sure channel exists)\n      db.Certificate.getLongChannelId(channelName, channelClaimId)\n        .then(longChannelClaimId => {\n          if (!longChannelClaimId) {\n            return [null, null, null];\n          }\n          // 2. get the short ID and all claims for that channel\n          return Promise.all([longChannelClaimId, db.Certificate.getShortChannelIdFromLongChannelId(longChannelClaimId, channelName)]);\n        })\n        .then(([longChannelClaimId, shortChannelClaimId]) => {\n          if (!longChannelClaimId) {\n            return resolve(NO_CHANNEL);\n          }\n          // 3. return all the channel information\n          resolve({\n            channelName,\n            longChannelClaimId,\n            shortChannelClaimId,\n          });\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  },\n  getChannelClaims (channelName, channelClaimId, page) {\n    return new Promise((resolve, reject) => {\n      // 1. get the long channel Id (make sure channel exists)\n      db.Certificate.getLongChannelId(channelName, channelClaimId)\n        .then(longChannelClaimId => {\n          if (!longChannelClaimId) {\n            return [null, null, null];\n          }\n          // 2. get the short ID and all claims for that channel\n          return Promise.all([longChannelClaimId, db.Claim.getAllChannelClaims(longChannelClaimId)]);\n        })\n        .then(([longChannelClaimId, channelClaimsArray]) => {\n          if (!longChannelClaimId) {\n            return resolve(NO_CHANNEL);\n          }\n          // 3. format the data for the view, including pagination\n          let paginatedChannelViewData = returnPaginatedChannelClaims(channelName, longChannelClaimId, channelClaimsArray, page);\n          // 4. return all the channel information and contents\n          resolve(paginatedChannelViewData);\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  },\n  getLocalFileRecord (claimId, name) {\n    return db.File.findOne({where: {claimId, name}})\n      .then(file => {\n        if (!file) {\n          return NO_FILE;\n        }\n        return file.dataValues;\n      });\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./controllers/serveController.js","import React from 'react';\nimport { renderToString } from 'react-dom/server';\nimport { createStore } from 'redux';\nimport Reducer from '../react/reducers';\nimport { Provider } from 'react-redux';\nimport { StaticRouter } from 'react-router-dom';\nimport GAListener from '../react/components/GAListener';\nimport App from '../react/app';\nimport renderFullPage from './renderFullPage.js';\nimport Helmet from 'react-helmet';\n\nmodule.exports = (req, res) => {\n  let context = {};\n\n  // create a new Redux store instance\n  const store = createStore(Reducer);\n\n  // render component to a string\n  const html = renderToString(\n    <Provider store={store}>\n      <StaticRouter location={req.url} context={context}>\n        <GAListener>\n          <App />\n        </GAListener>\n      </StaticRouter>\n    </Provider>\n  );\n\n  // get head tags from helmet\n  const helmet = Helmet.renderStatic();\n\n  // check for a redirect\n  if (context.url) {\n    // Somewhere a `<Redirect>` was rendered\n    return res.redirect(301, context.url);\n  } else {\n    // we're good, send the response\n  }\n\n  // get the initial state from our Redux store\n  const preloadedState = store.getState();\n\n  // send the rendered page back to the client\n  res.send(renderFullPage(helmet, html, preloadedState));\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/handlePageRender.jsx","module.exports = require(\"react-dom/server\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"react-dom/server\"\n// module id = 31\n// module chunks = 0","import { combineReducers } from 'redux';\nimport PublishReducer from 'reducers/publish';\nimport ChannelReducer from 'reducers/channel';\nimport ShowReducer from 'reducers/show';\nimport SiteReducer from 'reducers/site';\n\nexport default combineReducers({\n  channel: ChannelReducer,\n  publish: PublishReducer,\n  show   : ShowReducer,\n  site   : SiteReducer,\n});\n\n\n\n// WEBPACK FOOTER //\n// ./react/reducers/index.js","export const FILE_SELECTED = 'FILE_SELECTED';\nexport const FILE_CLEAR = 'FILE_CLEAR';\nexport const METADATA_UPDATE = 'METADATA_UPDATE';\nexport const CLAIM_UPDATE = 'CLAIM_UPDATE';\nexport const SET_PUBLISH_IN_CHANNEL = 'SET_PUBLISH_IN_CHANNEL';\nexport const PUBLISH_STATUS_UPDATE = 'PUBLISH_STATUS_UPDATE';\nexport const ERROR_UPDATE = 'ERROR_UPDATE';\nexport const SELECTED_CHANNEL_UPDATE = 'SELECTED_CHANNEL_UPDATE';\nexport const TOGGLE_METADATA_INPUTS = 'TOGGLE_METADATA_INPUTS';\nexport const THUMBNAIL_NEW = 'THUMBNAIL_NEW';\nexport const PUBLISH_START = 'PUBLISH_START';\n\n\n\n// WEBPACK FOOTER //\n// ./react/constants/publish_action_types.js","export const LOGIN = 'Existing';\nexport const CREATE = 'New';\n\n\n\n// WEBPACK FOOTER //\n// ./react/constants/publish_channel_select_states.js","export const CHANNEL_UPDATE = 'CHANNEL_UPDATE';\n\n\n\n// WEBPACK FOOTER //\n// ./react/constants/channel_action_types.js","export const LOCAL_CHECK = 'LOCAL_CHECK';\nexport const UNAVAILABLE = 'UNAVAILABLE';\nexport const ERROR = 'ERROR';\nexport const AVAILABLE = 'AVAILABLE';\n\n\n\n// WEBPACK FOOTER //\n// ./react/constants/asset_display_states.js","import React from 'react';\nimport GoogleAnalytics from 'react-ga';\nimport { withRouter } from 'react-router-dom';\nconst config = require('../../../config/speechConfig.js');\nconst googleApiKey = config.analytics.googleId;\n\nGoogleAnalytics.initialize(googleApiKey);\n\nclass GAListener extends React.Component {\n  componentDidMount () {\n    this.sendPageView(this.props.history.location);\n    this.props.history.listen(this.sendPageView);\n  }\n\n  sendPageView (location) {\n    GoogleAnalytics.set({ page: location.pathname });\n    GoogleAnalytics.pageview(location.pathname);\n  }\n\n  render () {\n    return this.props.children;\n  }\n}\n\nexport default withRouter(GAListener);\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/GAListener/index.jsx","import React from 'react';\nimport { Route, Switch } from 'react-router-dom';\nimport HomePage from 'components/HomePage';\nimport AboutPage from 'components/AboutPage';\nimport LoginPage from 'containers/LoginPage';\nimport ShowPage from 'containers/ShowPage';\nimport FourOhFourPage from 'components/FourOhFourPage';\n\nconst App = () => {\n  return (\n    <Switch>\n      <Route exact path='/' component={HomePage} />\n      <Route exact path='/about' component={AboutPage} />\n      <Route exact path='/login' component={LoginPage} />\n      <Route exact path='/:identifier/:claim' component={ShowPage} />\n      <Route exact path='/:claim' component={ShowPage} />\n      <Route component={FourOhFourPage} />\n    </Switch>\n  );\n};\n\nexport default App;\n\n\n\n// WEBPACK FOOTER //\n// ./react/app.js","import { connect } from 'react-redux';\nimport { selectFile, updateError, clearFile } from 'actions/publish';\nimport View from './view';\n\nconst mapStateToProps = ({ publish }) => {\n  return {\n    file     : publish.file,\n    thumbnail: publish.thumbnail,\n    fileError: publish.error.file,\n  };\n};\n\nconst mapDispatchToProps = dispatch => {\n  return {\n    selectFile: (file) => {\n      dispatch(selectFile(file));\n    },\n    setFileError: (value) => {\n      dispatch(clearFile());\n      dispatch(updateError('file', value));\n    },\n  };\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/Dropzone/index.js","import { connect } from 'react-redux';\nimport { updateLoggedInChannel } from 'actions/channel';\nimport View from './view';\nimport {updateSelectedChannel} from '../../actions/publish';\n\nconst mapDispatchToProps = dispatch => {\n  return {\n    onChannelLogin: (name, shortId, longId) => {\n      dispatch(updateLoggedInChannel(name, shortId, longId));\n      dispatch(updateSelectedChannel(name));\n    },\n  };\n};\n\nexport default connect(null, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ChannelLoginForm/index.js","import { connect } from 'react-redux';\nimport { updateLoggedInChannel } from 'actions/channel';\nimport View from './view';\nimport {updateSelectedChannel} from 'actions/publish';\n\nconst mapDispatchToProps = dispatch => {\n  return {\n    onChannelLogin: (name, shortId, longId) => {\n      dispatch(updateLoggedInChannel(name, shortId, longId));\n      dispatch(updateSelectedChannel(name));\n    },\n  };\n};\n\nexport default connect(null, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ChannelCreateForm/index.js","export const CHANNEL = 'CHANNEL';\nexport const ASSET_LITE = 'ASSET_LITE';\nexport const ASSET_DETAILS = 'ASSET_DETAILS';\n\n\n\n// WEBPACK FOOTER //\n// ./react/constants/show_request_types.js","import { connect } from 'react-redux';\nimport View from './view';\nimport { fileRequested } from 'actions/show';\nimport { selectAsset } from 'selectors/show';\n\nconst mapStateToProps = ({ show }) => {\n  // select error and status\n  const error  = show.displayAsset.error;\n  const status = show.displayAsset.status;\n  // select asset\n  const asset = selectAsset(show);\n  //  return props\n  return {\n    error,\n    status,\n    asset,\n  };\n};\n\nconst mapDispatchToProps = dispatch => {\n  return {\n    onFileRequest: (name, claimId) => {\n      dispatch(fileRequested(name, claimId));\n    },\n  };\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/AssetDisplay/index.js","module.exports = (helmet, html, preloadedState) => {\n  // take the html and preloadedState and return the full page\n  return `\n    <!DOCTYPE html>\n    <html lang=\"en\" prefix=\"og: http://ogp.me/ns# fb: http://ogp.me/ns/fb#\">\n        <head>\n            <meta charset=\"UTF-8\">\n            <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0, maximum-scale=1, user-scalable=no\">\n            <meta http-equiv=\"X-UA-Compatible\" content=\"ie=edge\">\n            <!--helmet-->\n            ${helmet.title.toString()}\n            ${helmet.meta.toString()}\n            ${helmet.link.toString()}\n            <!--style sheets-->\n            <link rel=\"stylesheet\" href=\"/assets/css/reset.css\" type=\"text/css\">\n            <link rel=\"stylesheet\" href=\"/assets/css/general.css\" type=\"text/css\">\n            <link rel=\"stylesheet\" href=\"/assets/css/mediaQueries.css\" type=\"text/css\">\n            <!--google font-->\n            <link href=\"https://fonts.googleapis.com/css?family=Roboto:300\" rel=\"stylesheet\">\n        </head>\n        <body id=\"main-body\">\n            <div class=\"row row--tall flex-container--column\">\n                <div id=\"react-app\" class=\"row row--tall flex-container--column\">${html}</div>\n            </div>\n            <script>\n                window.__PRELOADED_STATE__ = ${JSON.stringify(preloadedState).replace(/</g, '\\\\\\u003c')}\n            </script>\n            <script src=\"/bundle/bundle.js\"></script>\n        </body>\n    </html>\n  `;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/renderFullPage.js","module.exports = require(\"babel-polyfill\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"babel-polyfill\"\n// module id = 46\n// module chunks = 0","module.exports = require(\"whatwg-fetch\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"whatwg-fetch\"\n// module id = 47\n// module chunks = 0","// app dependencies\nconst express = require('express');\nconst bodyParser = require('body-parser');\nconst expressHandlebars = require('express-handlebars');\nconst Handlebars = require('handlebars');\nconst helmet = require('helmet');\nconst passport = require('passport');\nconst { populateLocalsDotUser, serializeSpeechUser, deserializeSpeechUser } = require('./helpers/authHelpers.js');\nconst cookieSession = require('cookie-session');\nconst http = require('http');\n// logging dependencies\nconst logger = require('winston');\n\nfunction SpeechServer ({ mysqlConfig, siteConfig, slackConfig }) {\n  this.PORT = 3000;\n  this.speak = (something) => {\n    console.log(something);\n  };\n  this.start = () => {\n    this.configureConfigFiles();\n    this.configureLogging();\n    this.configureApp();\n    this.configureServer();\n    this.startServer();\n  };\n  this.configureConfigFiles = () => {\n    const mysqlAppConfig = require('./config/mysqlConfig.js');\n    mysqlAppConfig.configure(mysqlConfig);\n    const slackAppConfig = require('./config/slackConfig.js');\n    slackAppConfig.configure(slackConfig);\n    // print the config variables\n    console.log('configured config files');\n    require('./helpers/configVarCheck.js')(mysqlAppConfig);\n    require('./helpers/configVarCheck.js')(slackAppConfig);\n  };\n  this.configureLogging = () => {\n    require('./helpers/configureLogger.js')(logger);\n    require('./helpers/configureSlack.js')(logger);\n  };\n  this.configureApp = () => {\n    const app = express(); // create an Express application\n\n    // trust the proxy to get ip address for us\n    app.enable('trust proxy');\n\n    // add middleware\n    app.use(helmet()); // set HTTP headers to protect against well-known web vulnerabilties\n    app.use(express.static(`${__dirname}/public`)); // 'express.static' to serve static files from public directory\n    app.use(bodyParser.json()); // 'body parser' for parsing application/json\n    app.use(bodyParser.urlencoded({ extended: true })); // 'body parser' for parsing application/x-www-form-urlencoded\n    app.use((req, res, next) => {  // custom logging middleware to log all incoming http requests\n      logger.verbose(`Request on ${req.originalUrl} from ${req.ip}`);\n      next();\n    });\n\n    // configure passport\n    passport.serializeUser(serializeSpeechUser);\n    passport.deserializeUser(deserializeSpeechUser);\n    const localSignupStrategy = require('./passport/local-signup.js');\n    const localLoginStrategy = require('./passport/local-login.js');\n    passport.use('local-signup', localSignupStrategy);\n    passport.use('local-login', localLoginStrategy);\n    // initialize passport\n    app.use(cookieSession({\n      name  : 'session',\n      keys  : [siteConfig.session.sessionKey],\n      maxAge: 24 * 60 * 60 * 1000, // i.e. 24 hours\n    }));\n    app.use(passport.initialize());\n    app.use(passport.session());\n\n    // configure handlebars & register it with express app\n    const hbs = expressHandlebars.create({\n      defaultLayout: 'embed',\n      handlebars   : Handlebars,\n    });\n    app.engine('handlebars', hbs.engine);\n    app.set('view engine', 'handlebars');\n\n    // middleware to pass user info back to client (for handlebars access), if user is logged in\n    app.use(populateLocalsDotUser);  // note: I don't think I need this any more?\n\n    // set the routes on the app\n    require('./routes/auth-routes.js')(app);\n    require('./routes/api-routes.js')(app);\n    require('./routes/page-routes.js')(app);\n    require('./routes/serve-routes.js')(app);\n    require('./routes/fallback-routes.js')(app);\n\n    this.app = app;\n  };\n  this.configureServer = () => {\n    this.server = http.Server(this.app);\n  };\n  this.startServer = () => {\n    const db = require('./models');\n    // sync sequelize\n    db.sequelize.sync()\n      // start the server\n      .then(() => {\n        this.server.listen(this.PORT, () => {\n          logger.info(`Server is listening on PORT ${this.PORT}`);\n        });\n      })\n      .catch((error) => {\n        logger.error(`Startup Error:`, error);\n      });\n  };\n};\n\nmodule.exports = SpeechServer;\n\n\n\n// WEBPACK FOOTER //\n// ./server.js","module.exports = require(\"express\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"express\"\n// module id = 49\n// module chunks = 0","module.exports = require(\"body-parser\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"body-parser\"\n// module id = 50\n// module chunks = 0","module.exports = require(\"express-handlebars\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"express-handlebars\"\n// module id = 51\n// module chunks = 0","module.exports = require(\"handlebars\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"handlebars\"\n// module id = 52\n// module chunks = 0","module.exports = require(\"helmet\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"helmet\"\n// module id = 53\n// module chunks = 0","const logger = require('winston');\n\nmodule.exports = {\n  populateLocalsDotUser (req, res, next) {\n    if (req.user) {\n      logger.debug('populating res.locals.user');\n      res.locals.user = {\n        id            : req.user.id,\n        userName      : req.user.userName,\n        channelName   : req.user.channelName,\n        channelClaimId: req.user.channelClaimId,\n        shortChannelId: req.user.shortChannelId,\n      };\n    }\n    next();\n  },\n  serializeSpeechUser (user, done) {  // returns user data to be serialized into session\n    logger.debug('serializing user');\n    done(null, user);\n  },\n  deserializeSpeechUser (user, done) {  // deserializes session and populates additional info to req.user\n    logger.debug('deserializing user');\n    done(null, user);\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/authHelpers.js","module.exports = require(\"cookie-session\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"cookie-session\"\n// module id = 55\n// module chunks = 0","module.exports = require(\"http\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"http\"\n// module id = 56\n// module chunks = 0","const logger = require('winston');\n\nmodule.exports = (config) => {\n  // get the config file\n  for (let configCategoryKey in config) {\n    if (config.hasOwnProperty(configCategoryKey)) {\n      // get the final variables for each config category\n      const configVariables = config[configCategoryKey];\n      for (let configVarKey in configVariables) {\n        if (configVariables.hasOwnProperty(configVarKey)) {\n          // print each variable\n          logger.debug(`CONFIG CHECK: ${configCategoryKey}.${configVarKey} === ${configVariables[configVarKey]}`);\n        }\n      }\n    }\n  }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/configVarCheck.js","const { logLevel } = require('../config/loggerConfig');\n\nmodule.exports = (winston) => {\n  // configure\n  winston.configure({\n    transports: [\n      new (winston.transports.Console)({\n        level                          : logLevel,\n        timestamp                      : false,\n        colorize                       : true,\n        prettyPrint                    : true,\n        handleExceptions               : true,\n        humanReadableUnhandledException: true,\n      }),\n    ],\n  });\n  // test all the log levels\n  winston.error('Level 0');\n  winston.warn('Level 1');\n  winston.info('Level 2');\n  winston.verbose('Level 3');\n  winston.debug('Level 4');\n  winston.silly('Level 5');\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/configureLogger.js","const loggerConfig = {\n  logLevel: 'debug',  // options: silly, debug, verbose, info\n};\n\nmodule.exports = loggerConfig;\n\n\n\n// WEBPACK FOOTER //\n// ./config/loggerConfig.js","const winstonSlackWebHook = require('winston-slack-webhook').SlackWebHook;\nconst slackConfig = require('../config/slackConfig.js');\n\nmodule.exports = (winston) => {\n  const {slackWebHook, slackErrorChannel, slackInfoChannel} = slackConfig;\n  if (slackWebHook) {\n    // add a transport for errors to slack\n    if (slackErrorChannel) {\n      winston.add(winstonSlackWebHook, {\n        name      : 'slack-errors-transport',\n        level     : 'warn',\n        webhookUrl: slackWebHook,\n        channel   : slackErrorChannel,\n        username  : 'spee.ch',\n        iconEmoji : ':face_with_head_bandage:',\n      });\n    };\n    if (slackInfoChannel) {\n      winston.add(winstonSlackWebHook, {\n        name      : 'slack-info-transport',\n        level     : 'info',\n        webhookUrl: slackWebHook,\n        channel   : slackInfoChannel,\n        username  : 'spee.ch',\n        iconEmoji : ':nerd_face:',\n      });\n    };\n    // send test message\n    winston.error('Slack \"error\" logging is online.');\n    winston.info('Slack \"info\" logging is online.');\n  } else {\n    winston.warn('Slack logging is not enabled because no slackWebHook config var provided.');\n  }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/configureSlack.js","module.exports = require(\"winston-slack-webhook\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"winston-slack-webhook\"\n// module id = 61\n// module chunks = 0","const PassportLocalStrategy = require('passport-local').Strategy;\nconst lbryApi = require('../helpers/lbryApi.js');\nconst logger = require('winston');\n\nmodule.exports = (db) => {\n  return new PassportLocalStrategy(\n    {\n      usernameField: 'username',\n      passwordField: 'password',\n    },\n    (username, password, done) => {\n      logger.verbose(`new channel signup request. user: ${username} pass: ${password} .`);\n      let userInfo = {};\n      // server-side validaton of inputs (username, password)\n\n      // create the channel and retrieve the metadata\n      return lbryApi.createChannel(`@${username}`)\n        .then(tx => {\n          // create user record\n          const userData = {\n            userName: username,\n            password: password,\n          };\n          logger.verbose('userData >', userData);\n          // create user record\n          const channelData = {\n            channelName   : `@${username}`,\n            channelClaimId: tx.claim_id,\n          };\n          logger.verbose('channelData >', channelData);\n          // create certificate record\n          const certificateData = {\n            claimId: tx.claim_id,\n            name   : `@${username}`,\n            // address,\n          };\n          logger.verbose('certificateData >', certificateData);\n          // save user and certificate to db\n          return Promise.all([db.User.create(userData), db.Channel.create(channelData), db.Certificate.create(certificateData)]);\n        })\n        .then(([newUser, newChannel, newCertificate]) => {\n          logger.verbose('user and certificate successfully created');\n          // store the relevant newUser info to be passed back for req.User\n          userInfo['id'] = newUser.id;\n          userInfo['userName'] = newUser.userName;\n          userInfo['channelName'] = newChannel.channelName;\n          userInfo['channelClaimId'] = newChannel.channelClaimId;\n          // associate the instances\n          return Promise.all([newCertificate.setChannel(newChannel), newChannel.setUser(newUser)]);\n        })\n        .then(() => {\n          logger.verbose('user and certificate successfully associated');\n          return db.Certificate.getShortChannelIdFromLongChannelId(userInfo.channelClaimId, userInfo.channelName);\n        })\n        .then(shortChannelId => {\n          userInfo['shortChannelId'] = shortChannelId;\n          return done(null, userInfo);\n        })\n        .catch(error => {\n          logger.error('signup error', error);\n          return done(error);\n        });\n    }\n  );\n};\n\n\n\n// WEBPACK FOOTER //\n// ./passport/local-signup.js","module.exports = require(\"axios\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"axios\"\n// module id = 63\n// module chunks = 0","const lbryConfig = {\n  api: {\n    apiHost: 'localhost',\n    apiPort: '5279',\n  },\n};\n\nmodule.exports = lbryConfig;\n\n\n\n// WEBPACK FOOTER //\n// ./config/lbryConfig.js","module.exports = require(\"universal-analytics\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"universal-analytics\"\n// module id = 65\n// module chunks = 0","const PassportLocalStrategy = require('passport-local').Strategy;\nconst logger = require('winston');\n\nmodule.exports = (db) => {\n  const returnUserAndChannelInfo = (userInstance) => {\n    return new Promise((resolve, reject) => {\n      let userInfo = {};\n      userInfo['id'] = userInstance.id;\n      userInfo['userName'] = userInstance.userName;\n      userInstance\n        .getChannel()\n        .then(({channelName, channelClaimId}) => {\n          userInfo['channelName'] = channelName;\n          userInfo['channelClaimId'] = channelClaimId;\n          return db.Certificate.getShortChannelIdFromLongChannelId(channelClaimId, channelName);\n        })\n        .then(shortChannelId => {\n          userInfo['shortChannelId'] = shortChannelId;\n          resolve(userInfo);\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  };\n\n  return new PassportLocalStrategy(\n    {\n      usernameField: 'username',\n      passwordField: 'password',\n    },\n    (username, password, done) => {\n      return db.User\n        .findOne({\n          where: {userName: username},\n        })\n        .then(user => {\n          if (!user) {\n            logger.debug('no user found');\n            return done(null, false, {message: 'Incorrect username or password'});\n          }\n          return user.comparePassword(password)\n            .then(isMatch => {\n              if (!isMatch) {\n                logger.debug('incorrect password');\n                return done(null, false, {message: 'Incorrect username or password'});\n              }\n              logger.debug('Password was a match, returning User');\n              return returnUserAndChannelInfo(user)\n                .then(userInfo => {\n                  return done(null, userInfo);\n                })\n                .catch(error => {\n                  return error;\n                });\n            })\n            .catch(error => {\n              return error;\n            });\n        })\n        .catch(error => {\n          return done(error);\n        });\n    },\n  );\n};\n\n\n\n// WEBPACK FOOTER //\n// ./passport/local-login.js","const logger = require('winston');\nconst passport = require('passport');\n\nmodule.exports = (app) => {\n  // route for sign up\n  app.post('/signup', passport.authenticate('local-signup'), (req, res) => {\n    logger.verbose(`successful signup for ${req.user.channelName}`);\n    res.status(200).json({\n      success       : true,\n      channelName   : req.user.channelName,\n      channelClaimId: req.user.channelClaimId,\n      shortChannelId: req.user.shortChannelId,\n    });\n  });\n  // route for log in\n  app.post('/login', (req, res, next) => {\n    passport.authenticate('local-login', (err, user, info) => {\n      logger.debug('info:', info);\n      if (err) {\n        return next(err);\n      }\n      if (!user) {\n        return res.status(400).json({\n          success: false,\n          message: info.message,\n        });\n      }\n      logger.debug('successful login');\n      req.logIn(user, (err) => {\n        if (err) {\n          return next(err);\n        }\n        return res.status(200).json({\n          success       : true,\n          channelName   : req.user.channelName,\n          channelClaimId: req.user.channelClaimId,\n          shortChannelId: req.user.shortChannelId,\n        });\n      });\n    })(req, res, next);\n  });\n  // route to log out\n  app.get('/logout', (req, res) => {\n    req.logout();\n    res.status(200).json({success: true, message: 'you successfully logged out'});\n  });\n  // see if user is authenticated, and return credentials if so\n  app.get('/user', (req, res) => {\n    if (req.user) {\n      res.status(200).json({success: true, data: req.user});\n    } else {\n      res.status(401).json({success: false, message: 'user is not logged in'});\n    }\n  });\n};\n\n\n\n// WEBPACK FOOTER //\n// ./routes/auth-routes.js","const logger = require('winston');\nconst multipart = require('connect-multiparty');\nconst { files, site } = require('../config/speechConfig.js');\nconst multipartMiddleware = multipart({uploadDir: files.uploadDirectory});\nconst db = require('../models');\nconst { claimNameIsAvailable, checkChannelAvailability, publish } = require('../controllers/publishController.js');\nconst { getClaimList, resolveUri, getClaim } = require('../helpers/lbryApi.js');\nconst { addGetResultsToFileData, createBasicPublishParams, createThumbnailPublishParams, parsePublishApiRequestBody, parsePublishApiRequestFiles, createFileData } = require('../helpers/publishHelpers.js');\nconst errorHandlers = require('../helpers/errorHandlers.js');\nconst { sendGATimingEvent } = require('../helpers/googleAnalytics.js');\nconst { authenticateUser } = require('../auth/authentication.js');\nconst { getChannelData, getChannelClaims, getClaimId } = require('../controllers/serveController.js');\n\nconst NO_CHANNEL = 'NO_CHANNEL';\nconst NO_CLAIM = 'NO_CLAIM';\n\nmodule.exports = (app) => {\n  // route to check whether site has published to a channel\n  app.get('/api/channel/availability/:name', ({ ip, originalUrl, params }, res) => {\n    checkChannelAvailability(params.name)\n      .then(result => {\n        if (result === true) {\n          res.status(200).json(true);\n        } else {\n          res.status(200).json(false);\n        }\n      })\n      .catch(error => {\n        errorHandlers.handleErrorResponse(originalUrl, ip, error, res);\n      });\n  });\n  // route to get a short channel id from long channel Id\n  app.get('/api/channel/short-id/:longId/:name', ({ ip, originalUrl, params }, res) => {\n    db.Certificate.getShortChannelIdFromLongChannelId(params.longId, params.name)\n      .then(shortId => {\n        res.status(200).json(shortId);\n      })\n      .catch(error => {\n        errorHandlers.handleErrorResponse(originalUrl, ip, error, res);\n      });\n  });\n  app.get('/api/channel/data/:channelName/:channelClaimId', ({ ip, originalUrl, body, params }, res) => {\n    const channelName = params.channelName;\n    let channelClaimId = params.channelClaimId;\n    if (channelClaimId === 'none') channelClaimId = null;\n    getChannelData(channelName, channelClaimId, 0)\n      .then(data => {\n        if (data === NO_CHANNEL) {\n          return res.status(404).json({success: false, message: 'No matching channel was found'});\n        }\n        res.status(200).json({success: true, data});\n      })\n      .catch(error => {\n        errorHandlers.handleErrorResponse(originalUrl, ip, error, res);\n      });\n  });\n  app.get('/api/channel/claims/:channelName/:channelClaimId/:page', ({ ip, originalUrl, body, params }, res) => {\n    const channelName = params.channelName;\n    let channelClaimId = params.channelClaimId;\n    if (channelClaimId === 'none') channelClaimId = null;\n    const page = params.page;\n    getChannelClaims(channelName, channelClaimId, page)\n      .then(data => {\n        if (data === NO_CHANNEL) {\n          return res.status(404).json({success: false, message: 'No matching channel was found'});\n        }\n        res.status(200).json({success: true, data});\n      })\n      .catch(error => {\n        errorHandlers.handleErrorResponse(originalUrl, ip, error, res);\n      });\n  });\n  // route to run a claim_list request on the daemon\n  app.get('/api/claim/list/:name', ({ ip, originalUrl, params }, res) => {\n    getClaimList(params.name)\n      .then(claimsList => {\n        res.status(200).json(claimsList);\n      })\n      .catch(error => {\n        errorHandlers.handleErrorResponse(originalUrl, ip, error, res);\n      });\n  });\n  // route to get an asset\n  app.get('/api/claim/get/:name/:claimId', ({ ip, originalUrl, params }, res) => {\n    const name = params.name;\n    const claimId = params.claimId;\n    // resolve the claim\n    db.Claim.resolveClaim(name, claimId)\n      .then(resolveResult => {\n        // make sure a claim actually exists at that uri\n        if (!resolveResult) {\n          throw new Error('No matching uri found in Claim table');\n        }\n        let fileData = createFileData(resolveResult);\n        // get the claim\n        return Promise.all([fileData, getClaim(`${name}#${claimId}`)]);\n      })\n      .then(([ fileData, getResult ]) => {\n        fileData = addGetResultsToFileData(fileData, getResult);\n        return Promise.all([db.upsert(db.File, fileData, {name, claimId}, 'File'), getResult]);\n      })\n      .then(([ fileRecord, {message, completed} ]) => {\n        res.status(200).json({ success: true, message, completed });\n      })\n      .catch(error => {\n        errorHandlers.handleErrorResponse(originalUrl, ip, error, res);\n      });\n  });\n  // route to check whether this site published to a claim\n  app.get('/api/claim/availability/:name', ({ ip, originalUrl, params }, res) => {\n    claimNameIsAvailable(params.name)\n      .then(result => {\n        res.status(200).json(result);\n      })\n      .catch(error => {\n        errorHandlers.handleErrorResponse(originalUrl, ip, error, res);\n      });\n  });\n  // route to run a resolve request on the daemon\n  app.get('/api/claim/resolve/:name/:claimId', ({ headers, ip, originalUrl, params }, res) => {\n    resolveUri(`${params.name}#${params.claimId}`)\n      .then(resolvedUri => {\n        res.status(200).json(resolvedUri);\n      })\n      .catch(error => {\n        errorHandlers.handleErrorResponse(originalUrl, ip, error, res);\n      });\n  });\n  // route to run a publish request on the daemon\n  app.post('/api/claim/publish', multipartMiddleware, ({ body, files, headers, ip, originalUrl, user }, res) => {\n    logger.debug('api/claim/publish req.body:', body);\n    logger.debug('api/claim/publish req.files:', files);\n    // define variables\n    let  channelName, channelId, channelPassword, description, fileName, filePath, fileType, gaStartTime, license, name, nsfw, thumbnail, thumbnailFileName, thumbnailFilePath, thumbnailFileType, title;\n    // record the start time of the request\n    gaStartTime = Date.now();\n    // validate the body and files of the request\n    try {\n      // validateApiPublishRequest(body, files);\n      ({name, nsfw, license, title, description, thumbnail} = parsePublishApiRequestBody(body));\n      ({fileName, filePath, fileType, thumbnailFileName, thumbnailFilePath, thumbnailFileType} = parsePublishApiRequestFiles(files));\n      ({channelName, channelId, channelPassword} = body);\n    } catch (error) {\n      return res.status(400).json({success: false, message: error.message});\n    }\n    // check channel authorization\n    Promise.all([\n      authenticateUser(channelName, channelId, channelPassword, user),\n      claimNameIsAvailable(name),\n      createBasicPublishParams(filePath, name, title, description, license, nsfw, thumbnail),\n      createThumbnailPublishParams(thumbnailFilePath, name, license, nsfw),\n    ])\n      .then(([{channelName, channelClaimId}, validatedClaimName, publishParams, thumbnailPublishParams]) => {\n        // add channel details to the publish params\n        if (channelName && channelClaimId) {\n          publishParams['channel_name'] = channelName;\n          publishParams['channel_id'] = channelClaimId;\n        }\n        // publish the thumbnail\n        if (thumbnailPublishParams) {\n          publish(thumbnailPublishParams, thumbnailFileName, thumbnailFileType);\n        }\n        // publish the asset\n        return publish(publishParams, fileName, fileType);\n      })\n      .then(result => {\n        res.status(200).json({\n          success: true,\n          message: 'publish completed successfully',\n          data   : {\n            name,\n            claimId: result.claim_id,\n            url    : `${site.host}/${result.claim_id}/${name}`,\n            lbryTx : result,\n          },\n        });\n        // record the publish end time and send to google analytics\n        sendGATimingEvent('end-to-end', 'publish', fileType, gaStartTime, Date.now());\n      })\n      .catch(error => {\n        errorHandlers.handleErrorResponse(originalUrl, ip, error, res);\n      });\n  });\n  // route to get a short claim id from long claim Id\n  app.get('/api/claim/short-id/:longId/:name', ({ ip, originalUrl, body, params }, res) => {\n    db.Claim.getShortClaimIdFromLongClaimId(params.longId, params.name)\n      .then(shortId => {\n        res.status(200).json({success: true, data: shortId});\n      })\n      .catch(error => {\n        errorHandlers.handleErrorResponse(originalUrl, ip, error, res);\n      });\n  });\n  app.post('/api/claim/long-id', ({ ip, originalUrl, body, params }, res) => {\n    logger.debug('body:', body);\n    const channelName = body.channelName;\n    const channelClaimId = body.channelClaimId;\n    const claimName = body.claimName;\n    const claimId = body.claimId;\n    getClaimId(channelName, channelClaimId, claimName, claimId)\n      .then(result => {\n        if (result === NO_CHANNEL) {\n          return res.status(404).json({success: false, message: 'No matching channel could be found'});\n        }\n        if (result === NO_CLAIM) {\n          return res.status(404).json({success: false, message: 'No matching claim id could be found'});\n        }\n        res.status(200).json({success: true, data: result});\n      })\n      .catch(error => {\n        errorHandlers.handleErrorResponse(originalUrl, ip, error, res);\n      });\n  });\n  app.get('/api/claim/data/:claimName/:claimId', ({ ip, originalUrl, body, params }, res) => {\n    const claimName = params.claimName;\n    let claimId = params.claimId;\n    if (claimId === 'none') claimId = null;\n    db.Claim.resolveClaim(claimName, claimId)\n      .then(claimInfo => {\n        if (!claimInfo) {\n          return res.status(404).json({success: false, message: 'No claim could be found'});\n        }\n        res.status(200).json({success: true, data: claimInfo});\n      })\n      .catch(error => {\n        errorHandlers.handleErrorResponse(originalUrl, ip, error, res);\n      });\n  });\n  // route to see if asset is available locally\n  app.get('/api/file/availability/:name/:claimId', ({ ip, originalUrl, params }, res) => {\n    const name = params.name;\n    const claimId = params.claimId;\n    db.File.findOne({where: {name, claimId}})\n      .then(result => {\n        if (result) {\n          return res.status(200).json({success: true, data: true});\n        }\n        res.status(200).json({success: true, data: false});\n      })\n      .catch(error => {\n        errorHandlers.handleErrorResponse(originalUrl, ip, error, res);\n      });\n  });\n};\n\n\n\n// WEBPACK FOOTER //\n// ./routes/api-routes.js","module.exports = require(\"connect-multiparty\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"connect-multiparty\"\n// module id = 69\n// module chunks = 0","module.exports = require(\"sequelize\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"sequelize\"\n// module id = 70\n// module chunks = 0","const logger = require('winston');\nconst { returnShortId } = require('../helpers/sequelizeHelpers.js');\n\nmodule.exports = (sequelize, { STRING, BOOLEAN, INTEGER, TEXT, DECIMAL }) => {\n  const Certificate = sequelize.define(\n    'Certificate',\n    {\n      address: {\n        type   : STRING,\n        default: null,\n      },\n      amount: {\n        type   : DECIMAL(19, 8),\n        default: null,\n      },\n      claimId: {\n        type   : STRING,\n        default: null,\n      },\n      claimSequence: {\n        type   : INTEGER,\n        default: null,\n      },\n      decodedClaim: {\n        type   : BOOLEAN,\n        default: null,\n      },\n      depth: {\n        type   : INTEGER,\n        default: null,\n      },\n      effectiveAmount: {\n        type   : DECIMAL(19, 8),\n        default: null,\n      },\n      hasSignature: {\n        type   : BOOLEAN,\n        default: null,\n      },\n      height: {\n        type   : INTEGER,\n        default: null,\n      },\n      hex: {\n        type   : TEXT('long'),\n        default: null,\n      },\n      name: {\n        type   : STRING,\n        default: null,\n      },\n      nout: {\n        type   : INTEGER,\n        default: null,\n      },\n      txid: {\n        type   : STRING,\n        default: null,\n      },\n      validAtHeight: {\n        type   : INTEGER,\n        default: null,\n      },\n      outpoint: {\n        type   : STRING,\n        default: null,\n      },\n      valueVersion: {\n        type   : STRING,\n        default: null,\n      },\n      claimType: {\n        type   : STRING,\n        default: null,\n      },\n      certificateVersion: {\n        type   : STRING,\n        default: null,\n      },\n      keyType: {\n        type   : STRING,\n        default: null,\n      },\n      publicKey: {\n        type   : TEXT('long'),\n        default: null,\n      },\n    },\n    {\n      freezeTableName: true,\n    }\n  );\n\n  Certificate.associate = db => {\n    Certificate.belongsTo(db.Channel, {\n      foreignKey: {\n        allowNull: true,\n      },\n    });\n  };\n\n  Certificate.getShortChannelIdFromLongChannelId = function (longChannelId, channelName) {\n    logger.debug(`getShortChannelIdFromLongChannelId ${channelName}:${longChannelId}`);\n    return new Promise((resolve, reject) => {\n      this\n        .findAll({\n          where: {name: channelName},\n          order: [['height', 'ASC']],\n        })\n        .then(result => {\n          switch (result.length) {\n            case 0:\n              throw new Error('No channel(s) found with that channel name');\n            default:\n              return resolve(returnShortId(result, longChannelId));\n          }\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  };\n\n  Certificate.getLongChannelIdFromShortChannelId = function (channelName, channelClaimId) {\n    logger.debug(`getLongChannelIdFromShortChannelId(${channelName}, ${channelClaimId})`);\n    return new Promise((resolve, reject) => {\n      this\n        .findAll({\n          where: {\n            name   : channelName,\n            claimId: {\n              $like: `${channelClaimId}%`,\n            },\n          },\n          order: [['height', 'ASC']],\n        })\n        .then(result => {\n          switch (result.length) {\n            case 0:\n              return resolve(null);\n            default: // note results must be sorted\n              return resolve(result[0].claimId);\n          }\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  };\n\n  Certificate.getLongChannelIdFromChannelName = function (channelName) {\n    logger.debug(`getLongChannelIdFromChannelName(${channelName})`);\n    return new Promise((resolve, reject) => {\n      this\n        .findAll({\n          where: { name: channelName },\n          order: [['effectiveAmount', 'DESC'], ['height', 'ASC']],\n        })\n        .then(result => {\n          switch (result.length) {\n            case 0:\n              return resolve(null);\n            default:\n              return resolve(result[0].claimId);\n          }\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  };\n\n  Certificate.validateLongChannelId = function (name, claimId) {\n    logger.debug(`validateLongChannelId(${name}, ${claimId})`);\n    return new Promise((resolve, reject) => {\n      this.findOne({\n        where: {name, claimId},\n      })\n        .then(result => {\n          if (!result) {\n            return resolve(null);\n          };\n          resolve(claimId);\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  };\n\n  Certificate.getLongChannelId = function (channelName, channelClaimId) {\n    logger.debug(`getLongChannelId(${channelName}, ${channelClaimId})`);\n    if (channelClaimId && (channelClaimId.length === 40)) {  // if a full channel id is provided\n      return this.validateLongChannelId(channelName, channelClaimId);\n    } else if (channelClaimId && channelClaimId.length < 40) {  // if a short channel id is provided\n      return this.getLongChannelIdFromShortChannelId(channelName, channelClaimId);\n    } else {\n      return this.getLongChannelIdFromChannelName(channelName);  // if no channel id provided\n    }\n  };\n\n  return Certificate;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./models/certificate.js","module.exports = (sequelize, { STRING }) => {\n  const Channel = sequelize.define(\n    'Channel',\n    {\n      channelName: {\n        type     : STRING,\n        allowNull: false,\n      },\n      channelClaimId: {\n        type     : STRING,\n        allowNull: false,\n      },\n    },\n    {\n      freezeTableName: true,\n    }\n  );\n\n  Channel.associate = db => {\n    Channel.belongsTo(db.User);\n    Channel.hasOne(db.Certificate);\n  };\n\n  return Channel;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./models/channel.js","const logger = require('winston');\nconst { returnShortId } = require('../helpers/sequelizeHelpers.js');\nconst { claim, site } = require('../config/speechConfig.js');\nconst { defaultThumbnail } = claim;\n\nfunction determineFileExtensionFromContentType (contentType) {\n  switch (contentType) {\n    case 'image/jpeg':\n    case 'image/jpg':\n      return 'jpeg';\n    case 'image/png':\n      return 'png';\n    case 'image/gif':\n      return 'gif';\n    case 'video/mp4':\n      return 'mp4';\n    default:\n      logger.debug('setting unknown file type as file extension jpeg');\n      return 'jpeg';\n  }\n};\n\nfunction determineThumbnail (storedThumbnail, defaultThumbnail) {\n  if (storedThumbnail === '') {\n    return defaultThumbnail;\n  }\n  return storedThumbnail;\n};\n\nfunction prepareClaimData (claim) {\n  // logger.debug('preparing claim data based on resolved data:', claim);\n  claim['thumbnail'] = determineThumbnail(claim.thumbnail, defaultThumbnail);\n  claim['fileExt'] = determineFileExtensionFromContentType(claim.contentType);\n  claim['host'] = site.host;\n  return claim;\n};\n\nmodule.exports = (sequelize, { STRING, BOOLEAN, INTEGER, TEXT, DECIMAL }) => {\n  const Claim = sequelize.define(\n    'Claim',\n    {\n      address: {\n        type   : STRING,\n        default: null,\n      },\n      amount: {\n        type   : DECIMAL(19, 8),\n        default: null,\n      },\n      claimId: {\n        type   : STRING,\n        default: null,\n      },\n      claimSequence: {\n        type   : INTEGER,\n        default: null,\n      },\n      decodedClaim: {\n        type   : BOOLEAN,\n        default: null,\n      },\n      depth: {\n        type   : INTEGER,\n        default: null,\n      },\n      effectiveAmount: {\n        type   : DECIMAL(19, 8),\n        default: null,\n      },\n      hasSignature: {\n        type   : BOOLEAN,\n        default: null,\n      },\n      height: {\n        type   : INTEGER,\n        default: null,\n      },\n      hex: {\n        type   : TEXT('long'),\n        default: null,\n      },\n      name: {\n        type   : STRING,\n        default: null,\n      },\n      nout: {\n        type   : INTEGER,\n        default: null,\n      },\n      txid: {\n        type   : STRING,\n        default: null,\n      },\n      validAtHeight: {\n        type   : INTEGER,\n        default: null,\n      },\n      outpoint: {\n        type   : STRING,\n        default: null,\n      },\n      claimType: {\n        type   : STRING,\n        default: null,\n      },\n      certificateId: {\n        type   : STRING,\n        default: null,\n      },\n      author: {\n        type   : STRING,\n        default: null,\n      },\n      description: {\n        type   : TEXT('long'),\n        default: null,\n      },\n      language: {\n        type   : STRING,\n        default: null,\n      },\n      license: {\n        type   : STRING,\n        default: null,\n      },\n      licenseUrl: {\n        type   : STRING,\n        default: null,\n      },\n      nsfw: {\n        type   : BOOLEAN,\n        default: null,\n      },\n      preview: {\n        type   : STRING,\n        default: null,\n      },\n      thumbnail: {\n        type   : STRING,\n        default: null,\n      },\n      title: {\n        type   : STRING,\n        default: null,\n      },\n      metadataVersion: {\n        type   : STRING,\n        default: null,\n      },\n      contentType: {\n        type   : STRING,\n        default: null,\n      },\n      source: {\n        type   : STRING,\n        default: null,\n      },\n      sourceType: {\n        type   : STRING,\n        default: null,\n      },\n      sourceVersion: {\n        type   : STRING,\n        default: null,\n      },\n      streamVersion: {\n        type   : STRING,\n        default: null,\n      },\n      valueVersion: {\n        type   : STRING,\n        default: null,\n      },\n      channelName: {\n        type     : STRING,\n        allowNull: true,\n        default  : null,\n      },\n    },\n    {\n      freezeTableName: true,\n    }\n  );\n\n  Claim.associate = db => {\n    Claim.belongsTo(db.File, {\n      foreignKey: {\n        allowNull: true,\n      },\n    });\n  };\n\n  Claim.getShortClaimIdFromLongClaimId = function (claimId, claimName) {\n    logger.debug(`Claim.getShortClaimIdFromLongClaimId for ${claimName}#${claimId}`);\n    return new Promise((resolve, reject) => {\n      this\n        .findAll({\n          where: { name: claimName },\n          order: [['height', 'ASC']],\n        })\n        .then(result => {\n          switch (result.length) {\n            case 0:\n              throw new Error('No claim(s) found with that claim name');\n            default:\n              resolve(returnShortId(result, claimId));\n          }\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  };\n\n  Claim.getAllChannelClaims = function (channelClaimId) {\n    logger.debug(`Claim.getAllChannelClaims for ${channelClaimId}`);\n    return new Promise((resolve, reject) => {\n      this\n        .findAll({\n          where: { certificateId: channelClaimId },\n          order: [['height', 'ASC']],\n          raw  : true,  // returns an array of only data, not an array of instances\n        })\n        .then(channelClaimsArray => {\n          // logger.debug('channelclaimsarray length:', channelClaimsArray.length);\n          switch (channelClaimsArray.length) {\n            case 0:\n              return resolve(null);\n            default:\n              channelClaimsArray.forEach(claim => {\n                claim['fileExt'] = determineFileExtensionFromContentType(claim.contentType);\n                claim['thumbnail'] = determineThumbnail(claim.thumbnail, defaultThumbnail);\n                return claim;\n              });\n              return resolve(channelClaimsArray);\n          }\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  };\n\n  Claim.getClaimIdByLongChannelId = function (channelClaimId, claimName) {\n    logger.debug(`finding claim id for claim ${claimName} from channel ${channelClaimId}`);\n    return new Promise((resolve, reject) => {\n      this\n        .findAll({\n          where: { name: claimName, certificateId: channelClaimId },\n          order: [['id', 'ASC']],\n        })\n        .then(result => {\n          switch (result.length) {\n            case 0:\n              return resolve(null);\n            case 1:\n              return resolve(result[0].claimId);\n            default:\n              logger.error(`${result.length} records found for \"${claimName}\" in channel \"${channelClaimId}\"`);\n              return resolve(result[0].claimId);\n          }\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  };\n\n  Claim.getLongClaimIdFromShortClaimId = function (name, shortId) {\n    return new Promise((resolve, reject) => {\n      this\n        .findAll({\n          where: {\n            name,\n            claimId: {\n              $like: `${shortId}%`,\n            }},\n          order: [['height', 'ASC']],\n        })\n        .then(result => {\n          switch (result.length) {\n            case 0:\n              return resolve(null);\n            default: // note results must be sorted\n              return resolve(result[0].claimId);\n          }\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  };\n\n  Claim.getTopFreeClaimIdByClaimName = function (name) {\n    return new Promise((resolve, reject) => {\n      this\n        .findAll({\n          where: { name },\n          order: [['effectiveAmount', 'DESC'], ['height', 'ASC']],  // note: maybe height and effective amount need to switch?\n        })\n        .then(result => {\n          logger.debug('length of result', result.length);\n          switch (result.length) {\n            case 0:\n              return resolve(null);\n            default:\n              return resolve(result[0].dataValues.claimId);\n          }\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  };\n\n  Claim.validateLongClaimId = function (name, claimId) {\n    return new Promise((resolve, reject) => {\n      this.findOne({\n        where: {name, claimId},\n      })\n        .then(result => {\n          if (!result) {\n            return resolve(null);\n          };\n          resolve(claimId);\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  };\n\n  Claim.getLongClaimId = function (claimName, claimId) {\n    logger.debug(`getLongClaimId(${claimName}, ${claimId})`);\n    if (claimId && (claimId.length === 40)) {  // if a full claim id is provided\n      return this.validateLongClaimId(claimName, claimId);\n    } else if (claimId && claimId.length < 40) {\n      return this.getLongClaimIdFromShortClaimId(claimName, claimId);  // if a short claim id is provided\n    } else {\n      return this.getTopFreeClaimIdByClaimName(claimName);  // if no claim id is provided\n    }\n  };\n\n  Claim.resolveClaim = function (name, claimId) {\n    logger.debug(`Claim.resolveClaim: ${name} ${claimId}`);\n    return new Promise((resolve, reject) => {\n      this\n        .findAll({\n          where: { name, claimId },\n        })\n        .then(claimArray => {\n          logger.debug('claims found on resolve:', claimArray.length);\n          switch (claimArray.length) {\n            case 0:\n              return resolve(null);\n            case 1:\n              return resolve(prepareClaimData(claimArray[0].dataValues));\n            default:\n              logger.error(`more than one entry matches that name (${name}) and claimID (${claimId})`);\n              return resolve(prepareClaimData(claimArray[0].dataValues));\n          }\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  };\n\n  return Claim;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./models/claim.js","module.exports = (sequelize, { STRING, BOOLEAN, INTEGER }) => {\n  const File = sequelize.define(\n    'File',\n    {\n      name: {\n        type     : STRING,\n        allowNull: false,\n      },\n      claimId: {\n        type     : STRING,\n        allowNull: false,\n      },\n      address: {\n        type     : STRING,\n        allowNull: false,\n      },\n      outpoint: {\n        type     : STRING,\n        allowNull: false,\n      },\n      height: {\n        type     : INTEGER,\n        allowNull: false,\n        default  : 0,\n      },\n      fileName: {\n        type     : STRING,\n        allowNull: false,\n      },\n      filePath: {\n        type     : STRING,\n        allowNull: false,\n      },\n      fileType: {\n        type: STRING,\n      },\n      nsfw: {\n        type        : BOOLEAN,\n        allowNull   : false,\n        defaultValue: false,\n      },\n      trendingEligible: {\n        type        : BOOLEAN,\n        allowNull   : false,\n        defaultValue: true,\n      },\n    },\n    {\n      freezeTableName: true,\n    }\n  );\n\n  File.associate = db => {\n    File.hasMany(db.Request);\n    File.hasOne(db.Claim);\n  };\n\n  File.getRecentClaims = function () {\n    return this.findAll({\n      where: { nsfw: false, trendingEligible: true },\n      order: [['createdAt', 'DESC']],\n      limit: 25,\n    });\n  };\n\n  return File;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./models/file.js","module.exports = (sequelize, { STRING, BOOLEAN, TEXT }) => {\n  const Request = sequelize.define(\n    'Request',\n    {\n      action: {\n        type     : STRING,\n        allowNull: false,\n      },\n      url: {\n        type     : STRING,\n        allowNull: false,\n      },\n      ipAddress: {\n        type     : STRING,\n        allowNull: true,\n      },\n      result: {\n        type     : TEXT('long'),\n        allowNull: true,\n        default  : null,\n      },\n    },\n    {\n      freezeTableName: true,\n    }\n  );\n\n  Request.associate = db => {\n    Request.belongsTo(db.File, {\n      foreignKey: {\n        allowNull: true,\n      },\n    });\n  };\n\n  return Request;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./models/request.js","'use strict';\nconst bcrypt = require('bcrypt');\nconst logger = require('winston');\n\nmodule.exports = (sequelize, { STRING }) => {\n  const User = sequelize.define(\n    'User',\n    {\n      userName: {\n        type     : STRING,\n        allowNull: false,\n      },\n      password: {\n        type     : STRING,\n        allowNull: false,\n      },\n    },\n    {\n      freezeTableName: true,\n    }\n  );\n\n  User.associate = db => {\n    User.hasOne(db.Channel);\n  };\n\n  User.prototype.comparePassword = function (password) {\n    return bcrypt.compare(password, this.password);\n  };\n\n  User.prototype.changePassword = function (newPassword) {\n    return new Promise((resolve, reject) => {\n      // generate a salt string to use for hashing\n      bcrypt.genSalt((saltError, salt) => {\n        if (saltError) {\n          logger.error('salt error', saltError);\n          reject(saltError);\n          return;\n        }\n        // generate a hashed version of the user's password\n        bcrypt.hash(newPassword, salt, (hashError, hash) => {\n          // if there is an error with the hash generation return the error\n          if (hashError) {\n            logger.error('hash error', hashError);\n            reject(hashError);\n            return;\n          }\n          // replace the current password with the new hash\n          this\n            .update({password: hash})\n            .then(() => {\n              resolve();\n            })\n            .catch(error => {\n              reject(error);\n            });\n        });\n      });\n    });\n  };\n\n  // pre-save hook method to hash the user's password before the user's info is saved to the db.\n  User.hook('beforeCreate', (user, options) => {\n    logger.debug('User.beforeCreate hook...');\n    return new Promise((resolve, reject) => {\n      // generate a salt string to use for hashing\n      bcrypt.genSalt((saltError, salt) => {\n        if (saltError) {\n          logger.error('salt error', saltError);\n          reject(saltError);\n          return;\n        }\n        // generate a hashed version of the user's password\n        bcrypt.hash(user.password, salt, (hashError, hash) => {\n          // if there is an error with the hash generation return the error\n          if (hashError) {\n            logger.error('hash error', hashError);\n            reject(hashError);\n            return;\n          }\n          // replace the password string with the hash password value\n          user.password = hash;\n          resolve();\n        });\n      });\n    });\n  });\n\n  return User;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./models/user.js","module.exports = require(\"bcrypt\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"bcrypt\"\n// module id = 77\n// module chunks = 0","const logger = require('winston');\nconst db = require('../models');\nconst lbryApi = require('../helpers/lbryApi.js');\nconst publishHelpers = require('../helpers/publishHelpers.js');\nconst config = require('../config/speechConfig.js');\n\nmodule.exports = {\n  publish (publishParams, fileName, fileType) {\n    return new Promise((resolve, reject) => {\n      let publishResults, certificateId, channelName;\n      // publish the file\n      return lbryApi.publishClaim(publishParams)\n        .then(tx => {\n          logger.info(`Successfully published ${publishParams.name} ${fileName}`, tx);\n          publishResults = tx;\n          // get the channel information\n          if (publishParams.channel_name) {\n            logger.debug(`this claim was published in channel: ${publishParams.channel_name}`);\n            return db.Channel.findOne({where: {channelName: publishParams.channel_name}});\n          } else {\n            logger.debug('this claim was not published in a channel');\n            return null;\n          }\n        })\n        .then(channel => {\n        // set channel information\n          certificateId = null;\n          channelName = null;\n          if (channel) {\n            certificateId = channel.channelClaimId;\n            channelName = channel.channelName;\n          }\n          logger.debug(`certificateId: ${certificateId}`);\n        })\n        .then(() => {\n        // create the File record\n          const fileRecord = {\n            name       : publishParams.name,\n            claimId    : publishResults.claim_id,\n            title      : publishParams.metadata.title,\n            description: publishParams.metadata.description,\n            address    : publishParams.claim_address,\n            outpoint   : `${publishResults.txid}:${publishResults.nout}`,\n            height     : 0,\n            fileName,\n            filePath   : publishParams.file_path,\n            fileType,\n            nsfw       : publishParams.metadata.nsfw,\n          };\n          // create the Claim record\n          const claimRecord = {\n            name       : publishParams.name,\n            claimId    : publishResults.claim_id,\n            title      : publishParams.metadata.title,\n            description: publishParams.metadata.description,\n            address    : publishParams.claim_address,\n            thumbnail  : publishParams.metadata.thumbnail,\n            outpoint   : `${publishResults.txid}:${publishResults.nout}`,\n            height     : 0,\n            contentType: fileType,\n            nsfw       : publishParams.metadata.nsfw,\n            amount     : publishParams.bid,\n            certificateId,\n            channelName,\n          };\n          // upsert criteria\n          const upsertCriteria = {\n            name   : publishParams.name,\n            claimId: publishResults.claim_id,\n          };\n          // upsert the records\n          return Promise.all([db.upsert(db.File, fileRecord, upsertCriteria, 'File'), db.upsert(db.Claim, claimRecord, upsertCriteria, 'Claim')]);\n        })\n        .then(([file, claim]) => {\n          logger.debug('File and Claim records successfully created');\n          return Promise.all([file.setClaim(claim), claim.setFile(file)]);\n        })\n        .then(() => {\n          logger.debug('File and Claim records successfully associated');\n          resolve(publishResults); // resolve the promise with the result from lbryApi.publishClaim;\n        })\n        .catch(error => {\n          logger.error('PUBLISH ERROR', error);\n          publishHelpers.deleteTemporaryFile(publishParams.file_path); // delete the local file\n          reject(error);\n        });\n    });\n  },\n  claimNameIsAvailable (name) {\n    // find any records where the name is used\n    return db.File.findAll({ where: { name } })\n      .then(result => {\n        if (result.length >= 1) {\n          const claimAddress = config.wallet.lbryClaimAddress;\n          // filter out any results that were not published from spee.ch's wallet address\n          const filteredResult = result.filter((claim) => {\n            return (claim.address === claimAddress);\n          });\n          // return based on whether any non-spee.ch claims were left\n          if (filteredResult.length >= 1) {\n            throw new Error('That claim is already in use');\n          };\n          return name;\n        };\n        return name;\n      });\n  },\n  checkChannelAvailability (name) {\n    return new Promise((resolve, reject) => {\n      // find any records where the name is used\n      db.Channel.findAll({ where: { channelName: name } })\n        .then(result => {\n          if (result.length >= 1) {\n            return resolve(false);\n          }\n          resolve(true);\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./controllers/publishController.js","module.exports = require(\"fs\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"fs\"\n// module id = 79\n// module chunks = 0","const db = require('../models');\nconst logger = require('winston');\n\nmodule.exports = {\n  authenticateUser (channelName, channelId, channelPassword, user) {\n    // case: no channelName or channel Id are provided (anonymous), regardless of whether user token is provided\n    if (!channelName && !channelId) {\n      return {\n        channelName   : null,\n        channelClaimId: null,\n      };\n    }\n    // case: channelName or channel Id are provided with user token\n    if (user) {\n      if (channelName && channelName !== user.channelName) {\n        throw new Error('the provided channel name does not match user credentials');\n      }\n      if (channelId && channelId !== user.channelClaimId) {\n        throw new Error('the provided channel id does not match user credentials');\n      }\n      return {\n        channelName   : user.channelName,\n        channelClaimId: user.channelClaimId,\n      };\n    }\n    // case: channelName or channel Id are provided with password instead of user token\n    if (!channelPassword) throw new Error('no channel password provided');\n    return module.exports.authenticateChannelCredentials(channelName, channelId, channelPassword);\n  },\n  authenticateChannelCredentials (channelName, channelId, userPassword) {\n    return new Promise((resolve, reject) => {\n      // hoisted variables\n      let channelData;\n      // build the params for finding the channel\n      let channelFindParams = {};\n      if (channelName) channelFindParams['channelName'] = channelName;\n      if (channelId) channelFindParams['channelClaimId'] = channelId;\n      // find the channel\n      db.Channel\n        .findOne({\n          where: channelFindParams,\n        })\n        .then(channel => {\n          if (!channel) {\n            logger.debug('no channel found');\n            throw new Error('Authentication failed, you do not have access to that channel');\n          }\n          channelData = channel.get();\n          logger.debug('channel data:', channelData);\n          return db.User.findOne({\n            where: { userName: channelData.channelName.substring(1) },\n          });\n        })\n        .then(user => {\n          if (!user) {\n            logger.debug('no user found');\n            throw new Error('Authentication failed, you do not have access to that channel');\n          }\n          return user.comparePassword(userPassword);\n        })\n        .then(isMatch => {\n          if (!isMatch) {\n            logger.debug('incorrect password');\n            throw new Error('Authentication failed, you do not have access to that channel');\n          }\n          logger.debug('...password was a match...');\n          resolve(channelData);\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./auth/authentication.js","const CLAIMS_PER_PAGE = 12;\n\nmodule.exports = {\n  returnPaginatedChannelClaims (channelName, longChannelClaimId, claims, page) {\n    const totalPages = module.exports.determineTotalPages(claims);\n    const paginationPage = module.exports.getPageFromQuery(page);\n    const viewData = {\n      channelName       : channelName,\n      longChannelClaimId: longChannelClaimId,\n      claims            : module.exports.extractPageFromClaims(claims, paginationPage),\n      previousPage      : module.exports.determinePreviousPage(paginationPage),\n      currentPage       : paginationPage,\n      nextPage          : module.exports.determineNextPage(totalPages, paginationPage),\n      totalPages        : totalPages,\n      totalResults      : module.exports.determineTotalClaims(claims),\n    };\n    return viewData;\n  },\n  getPageFromQuery (page) {\n    if (page) {\n      return parseInt(page);\n    }\n    return 1;\n  },\n  extractPageFromClaims (claims, pageNumber) {\n    if (!claims) {\n      return [];  // if no claims, return this default\n    }\n    // logger.debug('claims is array?', Array.isArray(claims));\n    // logger.debug(`pageNumber ${pageNumber} is number?`, Number.isInteger(pageNumber));\n    const claimStartIndex = (pageNumber - 1) * CLAIMS_PER_PAGE;\n    const claimEndIndex = claimStartIndex + CLAIMS_PER_PAGE;\n    const pageOfClaims = claims.slice(claimStartIndex, claimEndIndex);\n    return pageOfClaims;\n  },\n  determineTotalPages (claims) {\n    if (!claims) {\n      return 0;\n    } else {\n      const totalClaims = claims.length;\n      if (totalClaims < CLAIMS_PER_PAGE) {\n        return 1;\n      }\n      const fullPages = Math.floor(totalClaims / CLAIMS_PER_PAGE);\n      const remainder = totalClaims % CLAIMS_PER_PAGE;\n      if (remainder === 0) {\n        return fullPages;\n      }\n      return fullPages + 1;\n    }\n  },\n  determinePreviousPage (currentPage) {\n    if (currentPage === 1) {\n      return null;\n    }\n    return currentPage - 1;\n  },\n  determineNextPage (totalPages, currentPage) {\n    if (currentPage === totalPages) {\n      return null;\n    }\n    return currentPage + 1;\n  },\n  determineTotalClaims (claims) {\n    if (!claims) {\n      return 0;\n    }\n    return claims.length;\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/channelPagination.js","const { site } = require('../config/speechConfig.js');\nconst handlePageRender = require('../helpers/handlePageRender.jsx');\n\nmodule.exports = (app) => {\n  // route for the home page\n  app.get('/', (req, res) => {\n    handlePageRender(req, res);\n  });\n  // route to display login page\n  app.get('/login', (req, res) => {\n    handlePageRender(req, res);\n  });\n  // route to show 'about' page\n  app.get('/about', (req, res) => {\n    handlePageRender(req, res);\n  });\n  // route to display a list of the trending images\n  app.get('/trending', (req, res) => {\n    res.status(301).redirect('/popular');\n  });\n  app.get('/popular', (req, res) => {\n    handlePageRender(req, res);\n  });\n  // route to display a list of the trending images\n  app.get('/new', (req, res) => {\n    handlePageRender(req, res);\n  });\n  // route to send embedable video player (for twitter)\n  app.get('/embed/:claimId/:name', ({ params }, res) => {\n    const claimId = params.claimId;\n    const name = params.name;\n    const host = site.host;\n    // get and render the content\n    res.status(200).render('embed', { layout: 'embed', host, claimId, name });\n  });\n};\n\n\n\n// WEBPACK FOOTER //\n// ./routes/page-routes.js","import * as actions from 'constants/publish_action_types';\nimport { LOGIN } from 'constants/publish_channel_select_states';\nconst { publish } = require('../../config/speechConfig.js');\n\nconst initialState = {\n  publishInChannel  : false,\n  selectedChannel   : LOGIN,\n  showMetadataInputs: false,\n  status            : {\n    status : null,\n    message: null,\n  },\n  error: {\n    file         : null,\n    url          : null,\n    channel      : null,\n    publishSubmit: null,\n  },\n  file    : null,\n  claim   : '',\n  metadata: {\n    title      : '',\n    description: '',\n    license    : '',\n    nsfw       : false,\n  },\n  thumbnailChannel  : publish.thumbnailChannel,\n  thumbnailChannelId: publish.thumbnailChannelId,\n  thumbnail         : null,\n};\n\nexport default function (state = initialState, action) {\n  switch (action.type) {\n    case actions.FILE_SELECTED:\n      return Object.assign({}, initialState, {  // note: clears to initial state\n        file: action.data,\n      });\n    case actions.FILE_CLEAR:\n      return initialState;\n    case actions.METADATA_UPDATE:\n      return Object.assign({}, state, {\n        metadata: Object.assign({}, state.metadata, {\n          [action.data.name]: action.data.value,\n        }),\n      });\n    case actions.CLAIM_UPDATE:\n      return Object.assign({}, state, {\n        claim: action.data,\n      });\n    case actions.SET_PUBLISH_IN_CHANNEL:\n      return Object.assign({}, state, {\n        publishInChannel: action.channel,\n      });\n    case actions.PUBLISH_STATUS_UPDATE:\n      return Object.assign({}, state, {\n        status: action.data,\n      });\n    case actions.ERROR_UPDATE:\n      return Object.assign({}, state, {\n        error: Object.assign({}, state.error, {\n          [action.data.name]: action.data.value,\n        }),\n      });\n    case actions.SELECTED_CHANNEL_UPDATE:\n      return Object.assign({}, state, {\n        selectedChannel: action.data,\n      });\n    case actions.TOGGLE_METADATA_INPUTS:\n      return Object.assign({}, state, {\n        showMetadataInputs: action.data,\n      });\n    case actions.THUMBNAIL_NEW:\n      return Object.assign({}, state, {\n        thumbnail: action.data,\n      });\n    default:\n      return state;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./react/reducers/publish.js","import * as actions from 'constants/channel_action_types';\n\nconst initialState = {\n  loggedInChannel: {\n    name   : null,\n    shortId: null,\n    longId : null,\n  },\n};\n\nexport default function (state = initialState, action) {\n  switch (action.type) {\n    case actions.CHANNEL_UPDATE:\n      return Object.assign({}, state, {\n        loggedInChannel: action.data,\n      });\n    default:\n      return state;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./react/reducers/channel.js","import * as actions from 'constants/show_action_types';\nimport { LOCAL_CHECK, ERROR } from 'constants/asset_display_states';\n\nconst initialState = {\n  request: {\n    error: null,\n    type : null,\n    id   : null,\n  },\n  requestList : {},\n  channelList : {},\n  assetList   : {},\n  displayAsset: {\n    error : null,\n    status: LOCAL_CHECK,\n  },\n};\n\nexport default function (state = initialState, action) {\n  switch (action.type) {\n    // handle request\n    case actions.REQUEST_ERROR:\n      return Object.assign({}, state, {\n        request: Object.assign({}, state.request, {\n          error: action.data,\n        }),\n      });\n    case actions.REQUEST_UPDATE:\n      return Object.assign({}, state, {\n        request: Object.assign({}, state.request, {\n          type: action.data.requestType,\n          id  : action.data.requestId,\n        }),\n      });\n    // store requests\n    case actions.REQUEST_LIST_ADD:\n      return Object.assign({}, state, {\n        requestList: Object.assign({}, state.requestList, {\n          [action.data.id]: {\n            error: action.data.error,\n            key  : action.data.key,\n          },\n        }),\n      });\n    // asset data\n    case actions.ASSET_ADD:\n      return Object.assign({}, state, {\n        assetList: Object.assign({}, state.assetList, {\n          [action.data.id]: {\n            error    : action.data.error,\n            name     : action.data.name,\n            claimId  : action.data.claimId,\n            shortId  : action.data.shortId,\n            claimData: action.data.claimData,\n          },\n        }),\n      });\n    // channel data\n    case actions.CHANNEL_ADD:\n      return Object.assign({}, state, {\n        channelList: Object.assign({}, state.channelList, {\n          [action.data.id]: {\n            name      : action.data.name,\n            longId    : action.data.longId,\n            shortId   : action.data.shortId,\n            claimsData: action.data.claimsData,\n          },\n        }),\n      });\n    case actions.CHANNEL_CLAIMS_UPDATE_SUCCESS:\n      return Object.assign({}, state, {\n        channelList: Object.assign({}, state.channelList, {\n          [action.data.channelListId]: Object.assign({}, state.channelList[action.data.channelListId], {\n            claimsData: action.data.claimsData,\n          }),\n        }),\n      });\n    // display an asset\n    case actions.FILE_AVAILABILITY_UPDATE:\n      return Object.assign({}, state, {\n        displayAsset: Object.assign({}, state.displayAsset, {\n          status: action.data,\n        }),\n      });\n    case actions.DISPLAY_ASSET_ERROR:\n      return Object.assign({}, state, {\n        displayAsset: Object.assign({}, state.displayAsset, {\n          error : action.data,\n          status: ERROR,\n        }),\n      });\n    default:\n      return state;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./react/reducers/show.js","const { site } = require('../../config/speechConfig.js');\n\nconst initialState = {\n  host: site.host,\n};\n\nexport default function (state = initialState, action) {\n  switch (action.type) {\n    default:\n      return state;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./react/reducers/site.js","module.exports = require(\"react-ga\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"react-ga\"\n// module id = 87\n// module chunks = 0","import React from 'react';\nimport SEO from 'components/SEO';\nimport NavBar from 'containers/NavBar';\nimport PublishTool from 'containers/PublishTool';\n\nclass HomePage extends React.Component {\n  render () {\n    return (\n      <div className={'row row--tall flex-container--column'}>\n        <SEO />\n        <NavBar />\n        <div className={'row row--tall row--padded flex-container--column'}>\n          <PublishTool />\n        </div>\n      </div>\n    );\n  }\n};\n\nexport default HomePage;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/HomePage/index.jsx","const { site: { title: siteTitle } } = require('../../config/speechConfig.js');\n\nexport const createPageTitle = (pageTitle) => {\n  if (!pageTitle) {\n    return `${siteTitle}`;\n  }\n  return `${siteTitle} - ${pageTitle}`;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./react/utils/pageTitle.js","const { site: { title, host, description }, claim: { defaultThumbnail, defaultDescription } } = require('../../config/speechConfig.js');\n\nconst determineOgThumbnailContentType = (thumbnail) => {\n  if (thumbnail) {\n    const fileExt = thumbnail.substring(thumbnail.lastIndexOf('.'));\n    switch (fileExt) {\n      case 'jpeg':\n      case 'jpg':\n        return 'image/jpeg';\n      case 'png':\n        return 'image/png';\n      case 'gif':\n        return 'image/gif';\n      case 'mp4':\n        return 'video/mp4';\n      default:\n        return 'image/jpeg';\n    }\n  }\n  return '';\n};\n\nconst createBasicMetaTags = () => {\n  return [\n    {property: 'og:title', content: title},\n    {property: 'og:url', content: host},\n    {property: 'og:site_name', content: title},\n    {property: 'og:description', content: description},\n    {property: 'twitter:site', content: '@spee_ch'},\n    {property: 'twitter:card', content: 'summary'},\n  ];\n};\n\nconst createChannelMetaTags = (channel) => {\n  const { name, longId } = channel;\n  return [\n    {property: 'og:title', content: `${name} on ${title}`},\n    {property: 'og:url', content: `${host}/${name}:${longId}`},\n    {property: 'og:site_name', content: title},\n    {property: 'og:description', content: `${name}, a channel on ${title}`},\n    {property: 'twitter:site', content: '@spee_ch'},\n    {property: 'twitter:card', content: 'summary'},\n  ];\n};\n\nconst createAssetMetaTags = (asset) => {\n  const { claimData } = asset;\n  const { contentType } = claimData;\n  const embedUrl = `${host}/${claimData.claimId}/${claimData.name}`;\n  const showUrl = `${host}/${claimData.claimId}/${claimData.name}`;\n  const source = `${host}/${claimData.claimId}/${claimData.name}.${claimData.fileExt}`;\n  const ogTitle = claimData.title || claimData.name;\n  const ogDescription = claimData.description || defaultDescription;\n  const ogThumbnailContentType = determineOgThumbnailContentType(claimData.thumbnail);\n  const ogThumbnail = claimData.thumbnail || defaultThumbnail;\n  const metaTags = [\n    {property: 'og:title', content: ogTitle},\n    {property: 'og:url', content: showUrl},\n    {property: 'og:site_name', content: title},\n    {property: 'og:description', content: ogDescription},\n    {property: 'og:image:width', content: 600},\n    {property: 'og:image:height', content: 315},\n    {property: 'twitter:site', content: '@spee_ch'},\n  ];\n  if (contentType === 'video/mp4' || contentType === 'video/webm') {\n    metaTags.push({property: 'og:video', content: source});\n    metaTags.push({property: 'og:video:secure_url', content: source});\n    metaTags.push({property: 'og:video:type', content: contentType});\n    metaTags.push({property: 'og:image', content: ogThumbnail});\n    metaTags.push({property: 'og:image:type', content: ogThumbnailContentType});\n    metaTags.push({property: 'og:type', content: 'video'});\n    metaTags.push({property: 'twitter:card', content: 'player'});\n    metaTags.push({property: 'twitter:player', content: embedUrl});\n    metaTags.push({property: 'twitter:player:width', content: 600});\n    metaTags.push({property: 'twitter:text:player_width', content: 600});\n    metaTags.push({property: 'twitter:player:height', content: 337});\n    metaTags.push({property: 'twitter:player:stream', content: source});\n    metaTags.push({property: 'twitter:player:stream:content_type', content: contentType});\n  } else {\n    metaTags.push({property: 'og:image', content: source});\n    metaTags.push({property: 'og:image:type', content: contentType});\n    metaTags.push({property: 'og:type', content: 'article'});\n    metaTags.push({property: 'twitter:card', content: 'summary_large_image'});\n  }\n  return metaTags;\n};\n\nexport const createMetaTags = (asset, channel) => {\n  if (asset) {\n    return createAssetMetaTags(asset);\n  };\n  if (channel) {\n    return createChannelMetaTags(channel);\n  };\n  return createBasicMetaTags();\n};\n\n\n\n// WEBPACK FOOTER //\n// ./react/utils/metaTags.js","const { site: { host } } = require('../../config/speechConfig.js');\n\nconst createBasicCanonicalLink = (page) => {\n  if (!page) {\n    return `${host}`;\n  };\n  return `${host}/${page}`;\n};\n\nconst createAssetCanonicalLink = (asset) => {\n  let channelName, certificateId, name, claimId;\n  if (asset.claimData) {\n    ({ channelName, certificateId, name, claimId } = asset.claimData);\n  };\n  if (channelName) {\n    return `${host}/${channelName}:${certificateId}/${name}`;\n  };\n  return `${host}/${claimId}/${name}`;\n};\n\nconst createChannelCanonicalLink = (channel) => {\n  const { name, longId } = channel;\n  return `${host}/${name}:${longId}`;\n};\n\nexport const createCanonicalLink = (asset, channel, page) => {\n  if (asset) {\n    return createAssetCanonicalLink(asset);\n  }\n  if (channel) {\n    return createChannelCanonicalLink(channel);\n  }\n  if (page) {\n    return createBasicCanonicalLink(page);\n  }\n  return createBasicCanonicalLink();\n};\n\n\n\n// WEBPACK FOOTER //\n// ./react/utils/canonicalLink.js","import React from 'react';\nimport { NavLink, withRouter } from 'react-router-dom';\nimport Logo from 'components/Logo';\nimport NavBarChannelDropdown from 'components/NavBarChannelOptionsDropdown';\nimport request from 'utils/request';\n\nconst VIEW = 'VIEW';\nconst LOGOUT = 'LOGOUT';\n\nclass NavBar extends React.Component {\n  constructor (props) {\n    super(props);\n    this.checkForLoggedInUser = this.checkForLoggedInUser.bind(this);\n    this.logoutUser = this.logoutUser.bind(this);\n    this.handleSelection = this.handleSelection.bind(this);\n  }\n  componentDidMount () {\n    // check to see if the user is already logged in\n    this.checkForLoggedInUser();\n  }\n  checkForLoggedInUser () {\n    const params = {credentials: 'include'};\n    request('/user', params)\n      .then(({ data }) => {\n        this.props.onChannelLogin(data.channelName, data.shortChannelId, data.channelClaimId);\n      })\n      .catch(error => {\n        console.log('/user error:', error.message);\n      });\n  }\n  logoutUser () {\n    const params = {credentials: 'include'};\n    request('/logout', params)\n      .then(() => {\n        this.props.onChannelLogout();\n      })\n      .catch(error => {\n        console.log('/logout error', error.message);\n      });\n  }\n  handleSelection (event) {\n    const value = event.target.selectedOptions[0].value;\n    switch (value) {\n      case LOGOUT:\n        this.logoutUser();\n        break;\n      case VIEW:\n        // redirect to channel page\n        this.props.history.push(`/${this.props.channelName}:${this.props.channelLongId}`);\n        break;\n      default:\n        break;\n    }\n  }\n  render () {\n    return (\n      <div className='row row--wide nav-bar'>\n        <div className='row row--padded row--short flex-container--row flex-container--space-between-center'>\n          <Logo />\n          <div className='nav-bar--center'>\n            <span className='nav-bar-tagline'>Open-source, decentralized image and video sharing.</span>\n          </div>\n          <div className='nav-bar--right'>\n            <NavLink className='nav-bar-link link--nav' activeClassName='link--nav-active' to='/' exact>Publish</NavLink>\n            <NavLink className='nav-bar-link link--nav'  activeClassName='link--nav-active' to='/about'>About</NavLink>\n            { this.props.channelName ? (\n              <NavBarChannelDropdown\n                channelName={this.props.channelName}\n                handleSelection={this.handleSelection}\n                defaultSelection={this.props.channelName}\n                VIEW={VIEW}\n                LOGOUT={LOGOUT}\n              />\n            ) : (\n              <NavLink id='nav-bar-login-link' className='nav-bar-link link--nav' activeClassName='link--nav-active' to='/login'>Channel</NavLink>\n            )}\n          </div>\n        </div>\n      </div>\n    );\n  }\n}\n\nexport default withRouter(NavBar);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/NavBar/view.jsx","import React from 'react';\nimport { Link } from 'react-router-dom';\n\nfunction Logo () {\n  return (\n    <svg version='1.1' id='Layer_1' x='0px' y='0px' height='24px' viewBox='0 0 80 31' enableBackground='new 0 0 80 31' className='nav-bar-logo'>\n      <Link to='/'>\n        <title>Logo</title>\n        <desc>Spee.ch logo</desc>\n        <g id='About'>\n          <g id='Publish-Form-V2-_x28_filled_x29_' transform='translate(-42.000000, -23.000000)'>\n            <g id='Group-17' transform='translate(42.000000, 22.000000)'>\n              <text transform='matrix(1 0 0 1 0 20)' fontSize='25' fontFamily='Roboto'>Spee&lt;h</text>\n              <g id='Group-16' transform='translate(0.000000, 30.000000)'>\n                <path id='Line-8' fill='none' stroke='#09F911' strokeWidth='1' strokeLinecap='square' d='M0.5,1.5h15' />\n                <path id='Line-8-Copy' fill='none' stroke='#029D74' strokeWidth='1' strokeLinecap='square' d='M16.5,1.5h15' />\n                <path id='Line-8-Copy-2' fill='none' stroke='#E35BD8' strokeWidth='1' strokeLinecap='square' d='M32.5,1.5h15' />\n                <path id='Line-8-Copy-3' fill='none' stroke='#4156C5' strokeWidth='1' strokeLinecap='square' d='M48.5,1.5h15' />\n                <path id='Line-8-Copy-4' fill='none' stroke='#635688' strokeWidth='1' strokeLinecap='square' d='M64.5,1.5h15' />\n              </g>\n            </g>\n          </g>\n        </g>\n      </Link>\n    </svg>\n  );\n};\n\nexport default Logo;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/Logo/index.jsx","import React from 'react';\n\nfunction NavBarChannelDropdown ({ channelName, handleSelection, defaultSelection, VIEW, LOGOUT }) {\n  return (\n    <select type='text' id='nav-bar-channel-select' className='select select--arrow link--nav' onChange={handleSelection} value={defaultSelection}>\n      <option id='nav-bar-channel-select-channel-option'>{channelName}</option>\n      <option value={VIEW}>View</option>\n      <option value={LOGOUT}>Logout</option>\n    </select>\n  );\n};\n\nexport default NavBarChannelDropdown;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/NavBarChannelOptionsDropdown/index.jsx","module.exports = require(\"cross-fetch/polyfill\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"cross-fetch/polyfill\"\n// module id = 95\n// module chunks = 0","import {connect} from 'react-redux';\nimport View from './view';\n\nconst mapStateToProps = ({ publish }) => {\n  return {\n    file  : publish.file,\n    status: publish.status.status,\n  };\n};\n\nexport default connect(mapStateToProps, null)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishTool/index.js","import React from 'react';\nimport Dropzone from 'containers/Dropzone';\nimport PublishDetails from 'containers/PublishDetails';\nimport PublishStatus from 'containers/PublishStatus';\n\nclass PublishTool extends React.Component {\n  render () {\n    if (this.props.file) {\n      if (this.props.status) {\n        return (\n          <PublishStatus />\n        );\n      } else {\n        return <PublishDetails />;\n      }\n    } else {\n      return <Dropzone />;\n    }\n  }\n};\n\nexport default PublishTool;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishTool/view.jsx","import React from 'react';\nimport { validateFile } from 'utils/file';\nimport Preview from 'components/Preview';\n\nclass Dropzone extends React.Component {\n  constructor (props) {\n    super(props);\n    this.state = {\n      dragOver  : false,\n      mouseOver : false,\n      dimPreview: false,\n    };\n    this.handleDrop = this.handleDrop.bind(this);\n    this.handleDragOver = this.handleDragOver.bind(this);\n    this.handleDragEnd = this.handleDragEnd.bind(this);\n    this.handleDragEnter = this.handleDragEnter.bind(this);\n    this.handleDragLeave = this.handleDragLeave.bind(this);\n    this.handleMouseEnter = this.handleMouseEnter.bind(this);\n    this.handleMouseLeave = this.handleMouseLeave.bind(this);\n    this.handleClick = this.handleClick.bind(this);\n    this.handleFileInput = this.handleFileInput.bind(this);\n    this.chooseFile = this.chooseFile.bind(this);\n  }\n  handleDrop (event) {\n    event.preventDefault();\n    this.setState({dragOver: false});\n    // if dropped items aren't files, reject them\n    const dt = event.dataTransfer;\n    if (dt.items) {\n      if (dt.items[0].kind === 'file') {\n        const droppedFile = dt.items[0].getAsFile();\n        this.chooseFile(droppedFile);\n      }\n    }\n  }\n  handleDragOver (event) {\n    event.preventDefault();\n  }\n  handleDragEnd (event) {\n    var dt = event.dataTransfer;\n    if (dt.items) {\n      for (var i = 0; i < dt.items.length; i++) {\n        dt.items.remove(i);\n      }\n    } else {\n      event.dataTransfer.clearData();\n    }\n  }\n  handleDragEnter () {\n    this.setState({dragOver: true, dimPreview: true});\n  }\n  handleDragLeave () {\n    this.setState({dragOver: false, dimPreview: false});\n  }\n  handleMouseEnter () {\n    this.setState({mouseOver: true, dimPreview: true});\n  }\n  handleMouseLeave () {\n    this.setState({mouseOver: false, dimPreview: false});\n  }\n  handleClick (event) {\n    event.preventDefault();\n    document.getElementById('file_input').click();\n  }\n  handleFileInput (event) {\n    event.preventDefault();\n    const fileList = event.target.files;\n    this.chooseFile(fileList[0]);\n  }\n  chooseFile (file) {\n    if (file) {\n      try {\n        validateFile(file); // validate the file's name, type, and size\n      } catch (error) {\n        return this.props.setFileError(error.message);\n      }\n      // stage it so it will be ready when the publish button is clicked\n      this.props.selectFile(file);\n    }\n  }\n  render () {\n    return (\n      <div className='row row--tall flex-container--column'>\n        <form>\n          <input className='input-file' type='file' id='file_input' name='file_input' accept='video/*,image/*' onChange={this.handleFileInput} encType='multipart/form-data' />\n        </form>\n        <div id='preview-dropzone' className={'row row--padded row--tall dropzone' + (this.state.dragOver ? ' dropzone--drag-over' : '')} onDrop={this.handleDrop} onDragOver={this.handleDragOver} onDragEnd={this.handleDragEnd} onDragEnter={this.handleDragEnter} onDragLeave={this.handleDragLeave} onMouseEnter={this.handleMouseEnter} onMouseLeave={this.handleMouseLeave} onClick={this.handleClick}>\n          {this.props.file ? (\n            <div>\n              <Preview\n                dimPreview={this.state.dimPreview}\n                file={this.props.file}\n                thumbnail={this.props.thumbnail}\n              />\n              <div id='dropzone-text-holder' className={'flex-container--column flex-container--center-center'}>\n                { this.state.dragOver ? (\n                  <div id='dropzone-dragover'>\n                    <p className='blue'>Drop it.</p>\n                  </div>\n                ) : (\n                  null\n                )}\n                { this.state.mouseOver ? (\n                  <div id='dropzone-instructions'>\n                    <p className='info-message-placeholder info-message--failure' id='input-error-file-selection'>{this.props.fileError}</p>\n                    <p>Drag & drop image or video here to publish</p>\n                    <p className='fine-print'>OR</p>\n                    <p className='blue--underlined'>CHOOSE FILE</p>\n                  </div>\n                ) : (\n                  null\n                )}\n              </div>\n            </div>\n          ) : (\n            <div id='dropzone-text-holder' className={'flex-container--column flex-container--center-center'}>\n              { this.state.dragOver ? (\n                <div id='dropzone-dragover'>\n                  <p className='blue'>Drop it.</p>\n                </div>\n              ) : (\n                <div id='dropzone-instructions'>\n                  <p className='info-message-placeholder info-message--failure' id='input-error-file-selection'>{this.props.fileError}</p>\n                  <p>Drag & drop image or video here to publish</p>\n                  <p className='fine-print'>OR</p>\n                  <p className='blue--underlined'>CHOOSE FILE</p>\n                </div>\n              )}\n            </div>\n          )}\n        </div>\n      </div>\n    );\n  }\n};\n\nexport default Dropzone;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/Dropzone/view.jsx","module.exports = {\n  validateFile (file) {\n    if (!file) {\n      throw new Error('no file provided');\n    }\n    if (/'/.test(file.name)) {\n      throw new Error('apostrophes are not allowed in the file name');\n    }\n    // validate size and type\n    switch (file.type) {\n      case 'image/jpeg':\n      case 'image/jpg':\n      case 'image/png':\n        if (file.size > 10000000) {\n          throw new Error('Sorry, images are limited to 10 megabytes.');\n        }\n        break;\n      case 'image/gif':\n        if (file.size > 50000000) {\n          throw new Error('Sorry, GIFs are limited to 50 megabytes.');\n        }\n        break;\n      case 'video/mp4':\n        if (file.size > 50000000) {\n          throw new Error('Sorry, videos are limited to 50 megabytes.');\n        }\n        break;\n      default:\n        throw new Error(file.type + ' is not a supported file type. Only, .jpeg, .png, .gif, and .mp4 files are currently supported.');\n    }\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./react/utils/file.js","import React from 'react';\nimport PropTypes from 'prop-types';\n\nclass Preview extends React.Component {\n  constructor (props) {\n    super(props);\n    this.state = {\n      imgSource       : '',\n      defaultThumbnail: '/assets/img/video_thumb_default.png',\n    };\n  }\n  componentDidMount () {\n    this.setPreviewImageSource(this.props.file);\n  }\n  componentWillReceiveProps (newProps) {\n    if (newProps.file !== this.props.file) {\n      this.setPreviewImageSource(newProps.file);\n    }\n    if (newProps.thumbnail !== this.props.thumbnail) {\n      if (newProps.thumbnail) {\n        this.setPreviewImageSourceFromFile(newProps.thumbnail);\n      } else {\n        this.setState({imgSource: this.state.defaultThumbnail});\n      }\n    }\n  }\n  setPreviewImageSourceFromFile (file) {\n    const previewReader = new FileReader();\n    previewReader.readAsDataURL(file);\n    previewReader.onloadend = () => {\n      this.setState({imgSource: previewReader.result});\n    };\n  }\n  setPreviewImageSource (file) {\n    if (file.type !== 'video/mp4') {\n      this.setPreviewImageSourceFromFile(file);\n    } else {\n      if (this.props.thumbnail) {\n        this.setPreviewImageSourceFromFile(this.props.thumbnail);\n      }\n      this.setState({imgSource: this.state.defaultThumbnail});\n    }\n  }\n  render () {\n    return (\n      <img\n        id='dropzone-preview'\n        src={this.state.imgSource}\n        className={this.props.dimPreview ? 'dim' : ''}\n        alt='publish preview'\n      />\n    );\n  }\n};\n\nPreview.propTypes = {\n  dimPreview: PropTypes.bool.isRequired,\n  file      : PropTypes.object.isRequired,\n  thumbnail : PropTypes.object,\n};\n\nexport default Preview;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/Preview/index.jsx","import {connect} from 'react-redux';\nimport {clearFile, startPublish} from 'actions/publish';\nimport View from './view';\n\nconst mapStateToProps = ({ channel, publish }) => {\n  return {\n    file: publish.file,\n  };\n};\n\nconst mapDispatchToProps = {\n  clearFile,\n  startPublish,\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishDetails/index.js","import React from 'react';\nimport { withRouter } from 'react-router-dom';\nimport Dropzone from 'containers/Dropzone';\nimport PublishTitleInput from 'containers/PublishTitleInput';\nimport PublishUrlInput from 'containers/PublishUrlInput';\nimport PublishThumbnailInput from 'containers/PublishThumbnailInput';\nimport PublishMetadataInputs from 'containers/PublishMetadataInputs';\nimport ChannelSelect from 'containers/ChannelSelect';\n\nclass PublishDetails extends React.Component {\n  constructor (props) {\n    super(props)\n    this.onPublishSubmit = this.onPublishSubmit.bind(this);\n  }\n  onPublishSubmit () {\n    this.props.startPublish(this.props.history);\n  }\n  render () {\n    return (\n      <div className='row row--no-bottom'>\n        <div className='column column--10'>\n          <PublishTitleInput />\n        </div>\n        {/* left column */}\n        <div className='column column--5 column--sml-10' >\n          <div className='row row--padded'>\n            <Dropzone />\n          </div>\n        </div>\n        {/* right column */}\n        <div className='column column--5 column--sml-10 align-content-top'>\n          <div id='publish-active-area' className='row row--padded'>\n            <div className='row row--padded row--no-top row--wide'>\n              <PublishUrlInput />\n            </div>\n            <div className='row row--padded row--no-top row--wide'>\n              <ChannelSelect />\n            </div>\n            { (this.props.file.type === 'video/mp4') && (\n              <div className='row row--padded row--no-top row--wide '>\n                <PublishThumbnailInput />\n              </div>\n            )}\n            <div className='row row--padded row--no-top row--no-bottom row--wide'>\n              <PublishMetadataInputs />\n            </div>\n            <div className='row row--wide align-content-center'>\n              <button id='publish-submit' className='button--primary button--large' onClick={this.onPublishSubmit}>Publish</button>\n            </div>\n            <div className='row row--padded row--no-bottom align-content-center'>\n              <button className='button--cancel' onClick={this.props.clearFile}>Cancel</button>\n            </div>\n            <div className='row row--short align-content-center'>\n              <p className='fine-print'>By clicking 'Publish', you affirm that you have the rights to publish this content to the LBRY network, and that you understand the properties of publishing it to a decentralized, user-controlled network. <a className='link--primary' target='_blank' href='https://lbry.io/learn'>Read more.</a></p>\n            </div>\n          </div>\n        </div>\n      </div>\n    );\n  }\n};\n\nexport default withRouter(PublishDetails);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishDetails/view.jsx","import {connect} from 'react-redux';\nimport {updateMetadata} from 'actions/publish';\nimport View from './view';\n\nconst mapStateToProps = ({ publish }) => {\n  return {\n    title: publish.metadata.title,\n  };\n};\n\nconst mapDispatchToProps = dispatch => {\n  return {\n    onMetadataChange: (name, value) => {\n      dispatch(updateMetadata(name, value));\n    },\n  };\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishTitleInput/index.js","import React from 'react';\n\nclass PublishTitleInput extends React.Component {\n  constructor (props) {\n    super(props);\n    this.handleInput = this.handleInput.bind(this);\n  }\n  handleInput (e) {\n    const name = e.target.name;\n    const value = e.target.value;\n    this.props.onMetadataChange(name, value);\n  }\n  render () {\n    return (\n      <input type='text' id='publish-title' className='input-text text--large input-text--full-width' name='title' placeholder='Give your post a title...' onChange={this.handleInput} value={this.props.title} />\n    );\n  }\n}\n\nexport default PublishTitleInput;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishTitleInput/view.jsx","import {updateClaim, updateError} from 'actions/publish';\nimport {connect} from 'react-redux';\nimport View from './view';\n\nconst mapStateToProps = ({ channel, publish }) => {\n  return {\n    loggedInChannelName   : channel.loggedInChannel.name,\n    loggedInChannelShortId: channel.loggedInChannel.shortId,\n    fileName              : publish.file.name,\n    publishInChannel      : publish.publishInChannel,\n    selectedChannel       : publish.selectedChannel,\n    claim                 : publish.claim,\n    urlError              : publish.error.url,\n  };\n};\n\nconst mapDispatchToProps = dispatch => {\n  return {\n    onClaimChange: (value) => {\n      dispatch(updateClaim(value));\n      dispatch(updateError('publishSubmit', null));\n    },\n    onUrlError: (value) => {\n      dispatch(updateError('url', value));\n    },\n  };\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishUrlInput/index.js","import React from 'react';\nimport request from 'utils/request';\nimport UrlMiddle from 'components/PublishUrlMiddleDisplay';\n\nclass PublishUrlInput extends React.Component {\n  constructor (props) {\n    super(props);\n    this.handleInput = this.handleInput.bind(this);\n  }\n  componentDidMount () {\n    const { claim, fileName } = this.props;\n    if (!claim) {\n      this.setClaimName(fileName);\n    }\n  }\n  componentWillReceiveProps ({ claim, fileName }) {\n    // if a new file was chosen, update the claim name\n    if (fileName !== this.props.fileName) {\n      return this.setClaimName(fileName);\n    }\n    // if the claim has updated, check its availability\n    if (claim !== this.props.claim) {\n      this.validateClaim(claim);\n    }\n  }\n  handleInput (event) {\n    let value = event.target.value;\n    value = this.cleanseInput(value);\n    // update the state\n    this.props.onClaimChange(value);\n  }\n  cleanseInput (input) {\n    input = input.replace(/\\s+/g, '-'); // replace spaces with dashes\n    input = input.replace(/[^A-Za-z0-9-]/g, '');  // remove all characters that are not A-Z, a-z, 0-9, or '-'\n    return input;\n  }\n  setClaimName (fileName) {\n    const fileNameWithoutEnding = fileName.substring(0, fileName.lastIndexOf('.'));\n    const cleanClaimName = this.cleanseInput(fileNameWithoutEnding);\n    this.props.onClaimChange(cleanClaimName);\n  }\n  validateClaim (claim) {\n    if (!claim) {\n      return this.props.onUrlError('Enter a url above');\n    }\n    request(`/api/claim/availability/${claim}`)\n      .then(() => {\n        this.props.onUrlError(null);\n      })\n      .catch((error) => {\n        this.props.onUrlError(error.message);\n      });\n  }\n  render () {\n    const { claim, loggedInChannelName, loggedInChannelShortId, publishInChannel, selectedChannel, urlError } = this.props;\n    return (\n      <div className='column column--10 column--sml-10'>\n        <div className='input-text--primary span--relative'>\n          <span className='url-text--secondary'>spee.ch / </span>\n          <UrlMiddle\n            publishInChannel={publishInChannel}\n            selectedChannel={selectedChannel}\n            loggedInChannelName={loggedInChannelName}\n            loggedInChannelShortId={loggedInChannelShortId}\n          />\n          <input type='text' id='claim-name-input' className='input-text' name='claim' placeholder='your-url-here' onChange={this.handleInput} value={claim} />\n          { (claim && !urlError) && <span id='input-success-claim-name' className='info-message--success span--absolute'>{'\\u2713'}</span> }\n          { urlError && <span id='input-success-channel-name' className='info-message--failure span--absolute'>{'\\u2716'}</span> }\n        </div>\n        <div>\n          { urlError ? (\n            <p id='input-error-claim-name' className='info-message--failure'>{urlError}</p>\n          ) : (\n            <p className='info-message'>Choose a custom url</p>\n          )}\n        </div>\n      </div>\n    );\n  }\n}\n\nexport default PublishUrlInput;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishUrlInput/view.jsx","import React from 'react';\nimport PropTypes from 'prop-types';\n\nfunction UrlMiddle ({publishInChannel, selectedChannel, loggedInChannelName, loggedInChannelShortId}) {\n  if (publishInChannel) {\n    if (selectedChannel === loggedInChannelName) {\n      return <span id='url-channel' className='url-text--secondary'>{loggedInChannelName}:{loggedInChannelShortId} /</span>;\n    }\n    return <span id='url-channel-placeholder' className='url-text--secondary tooltip'>@channel<span\n      className='tooltip-text'>Select a channel below</span> /</span>;\n  }\n  return (\n    <span id='url-no-channel-placeholder' className='url-text--secondary tooltip'>xyz<span className='tooltip-text'>This will be a random id</span> /</span>\n  );\n}\n\nUrlMiddle.propTypes = {\n  publishInChannel      : PropTypes.bool.isRequired,\n  loggedInChannelName   : PropTypes.string,\n  loggedInChannelShortId: PropTypes.string,\n};\n\nexport default UrlMiddle;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/PublishUrlMiddleDisplay/index.jsx","import { connect } from 'react-redux';\nimport { onNewThumbnail } from 'actions/publish';\nimport View from './view';\n\nconst mapStateToProps = ({ publish: { file } }) => {\n  return {\n    file,\n  };\n};\n\nconst mapDispatchToProps = {\n  onNewThumbnail,\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishThumbnailInput/index.js","import React from 'react';\n\nfunction dataURItoBlob(dataURI) {\n  // convert base64/URLEncoded data component to raw binary data held in a string\n  let byteString = atob(dataURI.split(',')[1]);\n  // separate out the mime component\n  let mimeString = dataURI.split(',')[0].split(':')[1].split(';')[0];\n  // write the bytes of the string to a typed array\n  let ia = new Uint8Array(byteString.length);\n  for (let i = 0; i < byteString.length; i++) {\n    ia[i] = byteString.charCodeAt(i);\n  }\n  return new Blob([ia], {type: mimeString});\n}\n\nclass PublishThumbnailInput extends React.Component {\n  constructor (props) {\n    super(props);\n    this.state = {\n      videoSource   : null,\n      error         : null,\n      sliderMinRange: 1,\n      sliderMaxRange: null,\n      sliderValue   : null,\n    };\n    this.handleVideoLoadedData = this.handleVideoLoadedData.bind(this);\n    this.handleSliderChange = this.handleSliderChange.bind(this);\n    this.createThumbnail = this.createThumbnail.bind(this);\n  }\n  componentDidMount () {\n    const { file } = this.props;\n    this.setVideoSource(file);\n  }\n  componentWillReceiveProps (nextProps) {\n    // if file changes\n    if (nextProps.file && nextProps.file !== this.props.file) {\n      const { file } = nextProps;\n      this.setVideoSource(file);\n    };\n  }\n  setVideoSource (file) {\n    const previewReader = new FileReader();\n    previewReader.readAsDataURL(file);\n    previewReader.onloadend = () => {\n      const dataUri = previewReader.result;\n      const blob = dataURItoBlob(dataUri);\n      const videoSource = URL.createObjectURL(blob);\n      this.setState({ videoSource });\n    };\n  }\n  handleVideoLoadedData (event) {\n    const duration = event.target.duration;\n    const totalMinutes = Math.floor(duration / 60);\n    const totalSeconds = Math.floor(duration % 60);\n    // set the slider\n    this.setState({\n      sliderMaxRange: duration * 100,\n      sliderValue   : duration * 100 / 2,\n      totalMinutes,\n      totalSeconds,\n    });\n    // update the current time of the video\n    let video = document.getElementById('video-thumb-player');\n    video.currentTime = duration / 2;\n  }\n  handleSliderChange (event) {\n    const value = parseInt(event.target.value);\n    // update the slider value\n    this.setState({\n      sliderValue: value,\n    });\n    // update the current time of the video\n    let video = document.getElementById('video-thumb-player');\n    video.currentTime = value / 100;\n  }\n  createThumbnail () {\n    // take a snapshot\n    let video = document.getElementById('video-thumb-player');\n    let canvas = document.createElement('canvas');\n    canvas.width = video.videoWidth;\n    canvas.height = video.videoHeight;\n    canvas.getContext('2d').drawImage(video, 0, 0, canvas.width, canvas.height);\n    const dataUrl = canvas.toDataURL();\n    const blob = dataURItoBlob(dataUrl);\n    const snapshot = new File([blob], `thumbnail.png`, {\n      type: 'image/png',\n    });\n    // set the thumbnail in redux store\n    if (snapshot) {\n      this.props.onNewThumbnail(snapshot);\n    }\n  }\n  render () {\n    const { error, videoSource, sliderMinRange, sliderMaxRange, sliderValue, totalMinutes, totalSeconds } = this.state;\n    return (\n      <div>\n        <label className='label'>Thumbnail:</label>\n        <video\n          id='video-thumb-player'\n          preload='metadata'\n          muted\n          style={{display: 'none'}}\n          playsInline\n          onLoadedData={this.handleVideoLoadedData}\n          src={videoSource}\n          onSeeked={this.createThumbnail}\n        />\n        {\n          sliderValue ? (\n            <div>\n              <div className='flex-container--row flex-container--space-between-center' style={{width: '100%'}}>\n                <span className='info-message'>0'00\"</span>\n                <span className='info-message'>{totalMinutes}'{totalSeconds}\"</span>\n              </div>\n              <div>\n                <input\n                  type='range'\n                  min={sliderMinRange}\n                  max={sliderMaxRange}\n                  value={sliderValue}\n                  className='slider'\n                  onChange={this.handleSliderChange}\n                />\n              </div>\n            </div>\n          ) : (\n            <p className='info-message' >loading... </p>\n          )\n        }\n        { error ? (\n          <p className='info-message--failure'>{error}</p>\n        ) : (\n          <p className='info-message'>Use slider to set thumbnail</p>\n        )}\n      </div>\n    );\n  }\n}\n\nexport default PublishThumbnailInput;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishThumbnailInput/view.jsx","import {connect} from 'react-redux';\nimport {updateMetadata, toggleMetadataInputs} from 'actions/publish';\nimport View from './view';\n\nconst mapStateToProps = ({ publish }) => {\n  return {\n    showMetadataInputs: publish.showMetadataInputs,\n    description       : publish.metadata.description,\n    license           : publish.metadata.license,\n    nsfw              : publish.metadata.nsfw,\n  };\n};\n\nconst mapDispatchToProps = dispatch => {\n  return {\n    onMetadataChange: (name, value) => {\n      dispatch(updateMetadata(name, value));\n    },\n    onToggleMetadataInputs: (value) => {\n      dispatch(toggleMetadataInputs(value));\n    },\n  };\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishMetadataInputs/index.js","import React from 'react';\nimport ExpandingTextArea from 'components/ExpandingTextArea';\n\nclass PublishMetadataInputs extends React.Component {\n  constructor (props) {\n    super(props);\n    this.toggleShowInputs = this.toggleShowInputs.bind(this);\n    this.handleInput = this.handleInput.bind(this);\n    this.handleSelect = this.handleSelect.bind(this);\n  }\n  toggleShowInputs () {\n    this.props.onToggleMetadataInputs(!this.props.showMetadataInputs);\n  }\n  handleInput (event) {\n    const target = event.target;\n    const value = target.type === 'checkbox' ? target.checked : target.value;\n    const name = target.name;\n    this.props.onMetadataChange(name, value);\n  }\n  handleSelect (event) {\n    const name = event.target.name;\n    const selectedOption = event.target.selectedOptions[0].value;\n    this.props.onMetadataChange(name, selectedOption);\n  }\n  render () {\n    return (\n      <div id='publish-details' className='row row--padded row--no-top row--wide'>\n        {this.props.showMetadataInputs && (\n          <div>\n            <div className='row row--no-top'>\n              <div className='column column--3 column--med-10 align-content-top'>\n                <label htmlFor='publish-license' className='label'>Description:</label>\n              </div><div className='column column--7 column--sml-10'>\n                <ExpandingTextArea\n                  id='publish-description'\n                  className='textarea textarea--primary textarea--full-width'\n                  rows={1}\n                  maxLength={2000}\n                  style={{ maxHeight: 200 }}\n                  name='description'\n                  placeholder='Optional description'\n                  value={this.props.description}\n                  onChange={this.handleInput} />\n              </div>\n            </div>\n\n            <div className='row row--no-top'>\n              <div className='column column--3 column--med-10'>\n                <label htmlFor='publish-license' className='label'>License:</label>\n              </div><div className='column column--7 column--sml-10'>\n                <select type='text' name='license' id='publish-license' className='select select--primary' onChange={this.handleSelect}>\n                  <option value=' '>Unspecified</option>\n                  <option value='Public Domain'>Public Domain</option>\n                  <option value='Creative Commons'>Creative Commons</option>\n                </select>\n              </div>\n            </div>\n\n            <div className='row row--no-top'>\n              <div className='column column--3'>\n                <label htmlFor='publish-nsfw' className='label'>Mature:</label>\n              </div><div className='column column--7'>\n                <input className='input-checkbox' type='checkbox' id='publish-nsfw' name='nsfw' value={this.props.nsfw} onChange={this.handleInput} />\n              </div>\n            </div>\n          </div>\n        )}\n        <button className='button--secondary' onClick={this.toggleShowInputs}>{this.props.showMetadataInputs ? 'less' : 'more'}</button>\n      </div>\n    );\n  }\n}\n\nexport default PublishMetadataInputs;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishMetadataInputs/view.jsx","import React, { Component } from 'react';\nimport PropTypes from 'prop-types';\n\nclass ExpandingTextarea extends Component {\n  constructor (props) {\n    super(props);\n    this._handleChange = this._handleChange.bind(this);\n  }\n  componentDidMount () {\n    this.adjustTextarea({});\n  }\n  _handleChange (event) {\n    const { onChange } = this.props;\n    if (onChange) onChange(event);\n    this.adjustTextarea(event);\n  }\n  adjustTextarea ({ target = this.el }) {\n    target.style.height = 0;\n    target.style.height = `${target.scrollHeight}px`;\n  }\n  render () {\n    const { ...rest } = this.props;\n    return (\n      <textarea\n        {...rest}\n        ref={x => this.el = x}\n        onChange={this._handleChange}\n      />\n    );\n  }\n}\n\nExpandingTextarea.propTypes = {\n  onChange: PropTypes.func,\n};\n\nexport default ExpandingTextarea;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/ExpandingTextArea/index.jsx","import {connect} from 'react-redux';\nimport {setPublishInChannel, updateSelectedChannel, updateError} from 'actions/publish';\nimport View from './view';\n\nconst mapStateToProps = ({ channel, publish }) => {\n  return {\n    loggedInChannelName: channel.loggedInChannel.name,\n    publishInChannel   : publish.publishInChannel,\n    selectedChannel    : publish.selectedChannel,\n    channelError       : publish.error.channel,\n  };\n};\n\nconst mapDispatchToProps = dispatch => {\n  return {\n    onPublishInChannelChange: (value) => {\n      dispatch(updateError('channel', null));\n      dispatch(setPublishInChannel(value));\n    },\n    onChannelSelect: (value) => {\n      dispatch(updateError('channel', null));\n      dispatch(updateSelectedChannel(value));\n    },\n  };\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ChannelSelect/index.js","import React from 'react';\nimport ChannelLoginForm from 'containers/ChannelLoginForm';\nimport ChannelCreateForm from 'containers/ChannelCreateForm';\nimport * as states from 'constants/publish_channel_select_states';\n\nclass ChannelSelect extends React.Component {\n  constructor (props) {\n    super(props);\n    this.toggleAnonymousPublish = this.toggleAnonymousPublish.bind(this);\n    this.handleSelection = this.handleSelection.bind(this);\n  }\n  toggleAnonymousPublish (event) {\n    const value = event.target.value;\n    if (value === 'anonymous') {\n      this.props.onPublishInChannelChange(false);\n    } else {\n      this.props.onPublishInChannelChange(true);\n    }\n  }\n  handleSelection (event) {\n    const selectedOption = event.target.selectedOptions[0].value;\n    this.props.onChannelSelect(selectedOption);\n  }\n  render () {\n    return (\n      <div>\n        <form>\n          <div className='column column--3 column--med-10'>\n            <input type='radio' name='anonymous-or-channel' id='anonymous-radio' className='input-radio' value='anonymous' checked={!this.props.publishInChannel} onChange={this.toggleAnonymousPublish} />\n            <label className='label label--pointer' htmlFor='anonymous-radio'>Anonymous</label>\n          </div>\n          <div className='column column--7 column--med-10'>\n            <input type='radio' name='anonymous-or-channel' id='channel-radio' className='input-radio' value='in a channel' checked={this.props.publishInChannel} onChange={this.toggleAnonymousPublish} />\n            <label className='label label--pointer' htmlFor='channel-radio'>In a channel</label>\n          </div>\n          { this.props.channelError ? (\n            <p className='info-message--failure'>{this.props.channelError}</p>\n          ) : (\n            <p className='info-message'>Publish anonymously or in a channel</p>\n          )}\n        </form>\n        { this.props.publishInChannel && (\n          <div>\n            <div className='column column--3'>\n              <label className='label' htmlFor='channel-name-select'>Channel:</label>\n            </div><div className='column column--7'>\n              <select type='text' id='channel-name-select' className='select select--arrow' value={this.props.selectedChannel} onChange={this.handleSelection}>\n                { this.props.loggedInChannelName && <option value={this.props.loggedInChannelName} id='publish-channel-select-channel-option'>{this.props.loggedInChannelName}</option> }\n                <option value={states.LOGIN}>Existing</option>\n                <option value={states.CREATE}>New</option>\n              </select>\n            </div>\n            { (this.props.selectedChannel === states.LOGIN) && <ChannelLoginForm /> }\n            { (this.props.selectedChannel === states.CREATE) && <ChannelCreateForm /> }\n          </div>\n        )}\n      </div>\n    );\n  }\n}\n\nexport default ChannelSelect;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ChannelSelect/view.jsx","import React from 'react';\nimport request from 'utils/request';\n\nclass ChannelLoginForm extends React.Component {\n  constructor (props) {\n    super(props);\n    this.state = {\n      error   : null,\n      name    : '',\n      password: '',\n    };\n    this.handleInput = this.handleInput.bind(this);\n    this.loginToChannel = this.loginToChannel.bind(this);\n  }\n  handleInput (event) {\n    const name = event.target.name;\n    const value = event.target.value;\n    this.setState({[name]: value});\n  }\n  loginToChannel (event) {\n    event.preventDefault();\n    const params = {\n      method : 'POST',\n      body   : JSON.stringify({username: this.state.name, password: this.state.password}),\n      headers: new Headers({\n        'Content-Type': 'application/json',\n      }),\n      credentials: 'include',\n    };\n    request('login', params)\n      .then(({success, channelName, shortChannelId, channelClaimId, message}) => {\n        if (success) {\n          this.props.onChannelLogin(channelName, shortChannelId, channelClaimId);\n        } else {\n          this.setState({'error': message});\n        };\n      })\n      .catch(error => {\n        if (error.message) {\n          this.setState({'error': error.message});\n        } else {\n          this.setState({'error': error});\n        }\n      });\n  }\n  render () {\n    return (\n      <form id='channel-login-form'>\n        <div className='row row--wide row--short'>\n          <div className='column column--3 column--sml-10'>\n            <label className='label' htmlFor='channel-login-name-input'>Name:</label>\n          </div><div className='column column--6 column--sml-10'>\n            <div className='input-text--primary flex-container--row flex-container--left-bottom'>\n              <span>@</span>\n              <input type='text' id='channel-login-name-input' className='input-text' name='name' placeholder='Your Channel Name' value={this.state.channelName} onChange={this.handleInput} />\n            </div>\n          </div>\n        </div>\n        <div className='row row--wide row--short'>\n          <div className='column column--3 column--sml-10'>\n            <label className='label' htmlFor='channel-login-password-input' >Password:</label>\n          </div><div className='column column--6 column--sml-10'>\n            <div className='input-text--primary'>\n              <input type='password' id='channel-login-password-input' name='password' className='input-text' placeholder='' value={this.state.channelPassword} onChange={this.handleInput} />\n            </div>\n          </div>\n        </div>\n        { this.state.error ? (\n          <p className='info-message--failure'>{this.state.error}</p>\n        ) : (\n          <p className='info-message'>Enter the name and password for your channel</p>\n        )}\n        <div className='row row--wide'>\n          <button className='button--primary' onClick={this.loginToChannel}>Authenticate</button>\n        </div>\n      </form>\n    );\n  }\n}\n\nexport default ChannelLoginForm;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ChannelLoginForm/view.jsx","import React from 'react';\nimport ProgressBar from 'components/ProgressBar';\nimport request from 'utils/request';\n\nclass ChannelCreateForm extends React.Component {\n  constructor (props) {\n    super(props);\n    this.state = {\n      error   : null,\n      channel : '',\n      password: '',\n      status  : null,\n    };\n    this.handleChannelInput = this.handleChannelInput.bind(this);\n    this.handleInput = this.handleInput.bind(this);\n    this.createChannel = this.createChannel.bind(this);\n  }\n  cleanseChannelInput (input) {\n    input = input.replace(/\\s+/g, '-'); // replace spaces with dashes\n    input = input.replace(/[^A-Za-z0-9-]/g, '');  // remove all characters that are not A-Z, a-z, 0-9, or '-'\n    return input;\n  }\n  handleChannelInput (event) {\n    let value = event.target.value;\n    value = this.cleanseChannelInput(value);\n    this.setState({channel: value});\n    if (value) {\n      this.updateIsChannelAvailable(value);\n    } else {\n      this.setState({error: 'Please enter a channel name'});\n    }\n  }\n  handleInput (event) {\n    const name = event.target.name;\n    const value = event.target.value;\n    this.setState({[name]: value});\n  }\n  updateIsChannelAvailable (channel) {\n    const channelWithAtSymbol = `@${channel}`;\n    request(`/api/channel/availability/${channelWithAtSymbol}`)\n      .then(isAvailable => {\n        if (isAvailable) {\n          this.setState({'error': null});\n        } else {\n          this.setState({'error': 'That channel has already been claimed'});\n        }\n      })\n      .catch((error) => {\n        this.setState({'error': error.message});\n      });\n  }\n  checkIsChannelAvailable (channel) {\n    const channelWithAtSymbol = `@${channel}`;\n    return new Promise((resolve, reject) => {\n      request(`/api/channel/availability/${channelWithAtSymbol}`)\n        .then(isAvailable => {\n          if (!isAvailable) {\n            return reject(new Error('That channel has already been claimed'));\n          }\n          resolve();\n        })\n        .catch((error) => {\n          reject(error);\n        });\n    });\n  }\n  checkIsPasswordProvided () {\n    const password = this.state.password;\n    return new Promise((resolve, reject) => {\n      if (!password || password.length < 1) {\n        return reject(new Error('Please provide a password'));\n      }\n      resolve();\n    });\n  }\n  makePublishChannelRequest (username, password) {\n    const params = {\n      method : 'POST',\n      body   : JSON.stringify({username, password}),\n      headers: new Headers({\n        'Content-Type': 'application/json',\n      }),\n      credentials: 'include',\n    };\n    return new Promise((resolve, reject) => {\n      request('/signup', params)\n        .then(result => {\n          return resolve(result);\n        })\n        .catch(error => {\n          reject(new Error(`Unfortunately, we encountered an error while creating your channel. Please let us know in Discord! ${error.message}`));\n        });\n    });\n  }\n  createChannel (event) {\n    event.preventDefault();\n    this.checkIsPasswordProvided()\n      .then(() => {\n        return this.checkIsChannelAvailable(this.state.channel, this.state.password);\n      })\n      .then(() => {\n        this.setState({status: 'We are publishing your new channel.  Sit tight...'});\n        return this.makePublishChannelRequest(this.state.channel, this.state.password);\n      })\n      .then(result => {\n        this.setState({status: null});\n        this.props.onChannelLogin(result.channelName, result.shortChannelId, result.channelClaimId);\n      })\n      .catch((error) => {\n        this.setState({'error': error.message, status: null});\n      });\n  }\n  render () {\n    return (\n      <div>\n        { !this.state.status ? (\n          <form id='publish-channel-form'>\n            <div className='row row--wide row--short'>\n              <div className='column column--3 column--sml-10'>\n                <label className='label' htmlFor='new-channel-name'>Name:</label>\n              </div><div className='column column--6 column--sml-10'>\n                <div className='input-text--primary flex-container--row flex-container--left-bottom span--relative'>\n                  <span>@</span>\n                  <input type='text' name='channel' id='new-channel-name' className='input-text' placeholder='exampleChannelName' value={this.state.channel} onChange={this.handleChannelInput} />\n                  { (this.state.channel && !this.state.error) && <span id='input-success-channel-name' className='info-message--success span--absolute'>{'\\u2713'}</span> }\n                  { this.state.error && <span id='input-success-channel-name' className='info-message--failure span--absolute'>{'\\u2716'}</span> }\n                </div>\n              </div>\n            </div>\n            <div className='row row--wide row--short'>\n              <div className='column column--3 column--sml-10'>\n                <label className='label' htmlFor='new-channel-password'>Password:</label>\n              </div><div className='column column--6 column--sml-10'>\n                <div className='input-text--primary'>\n                  <input type='password' name='password' id='new-channel-password' className='input-text'  placeholder='' value={this.state.password} onChange={this.handleInput} />\n                </div>\n              </div>\n            </div>\n            {this.state.error ? (\n              <p className='info-message--failure'>{this.state.error}</p>\n            ) : (\n              <p className='info-message'>Choose a name and password for your channel</p>\n            )}\n            <div className='row row--wide'>\n              <button className='button--primary' onClick={this.createChannel}>Create Channel</button>\n            </div>\n          </form>\n        ) : (\n          <div>\n            <p className='fine-print'>{this.state.status}</p>\n            <ProgressBar size={12} />\n          </div>\n        )}\n      </div>\n    );\n  }\n}\n\nexport default ChannelCreateForm;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ChannelCreateForm/view.jsx","import React from 'react';\n\nconst ActiveStatusBar = () => {\n  return <span className='progress-bar progress-bar--active'>| </span>;\n};\n\nexport default ActiveStatusBar;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/ActiveStatusBar/index.jsx","import React from 'react';\n\nconst InactiveStatusBar = () => {\n  return <span className='progress-bar progress-bar--inactive'>| </span>;\n};\n\nexport default InactiveStatusBar;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/InactiveStatusBar/index.jsx","import {connect} from 'react-redux';\nimport {clearFile} from 'actions/publish';\nimport View from './view';\n\nconst mapStateToProps = ({ publish }) => {\n  return {\n    status : publish.status.status,\n    message: publish.status.message,\n  };\n};\n\nconst mapDispatchToProps = {\n  clearFile,\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishStatus/index.js","import React from 'react';\nimport ProgressBar from 'components/ProgressBar';\nimport * as publishStates from 'constants/publish_claim_states';\n\nclass PublishStatus extends React.Component {\n  render () {\n    const { status, message, clearFile } = this.props;\n    return (\n      <div className='row row--tall flex-container--column flex-container--center-center'>\n        {status === publishStates.LOAD_START &&\n        <div className='row align-content-center'>\n          <p>File is loading to server</p>\n          <p className='blue'>0%</p>\n        </div>\n        }\n        {status === publishStates.LOADING &&\n        <div>\n          <div className='row align-content-center'>\n            <p>File is loading to server</p>\n            <p className='blue'>{message}</p>\n          </div>\n        </div>\n        }\n        {status === publishStates.PUBLISHING &&\n        <div className='row align-content-center'>\n          <p>Upload complete.  Your file is now being published on the blockchain...</p>\n          <ProgressBar size={12} />\n          <p>Curious what magic is happening here? <a className='link--primary' target='blank' href='https://lbry.io/faq/what-is-lbry'>Learn more.</a></p>\n        </div>\n        }\n        {status === publishStates.SUCCESS &&\n        <div className='row align-content-center'>\n          <p>Your publish is complete! You are being redirected to it now.</p>\n          <p>If you are not automatically redirected, <a className='link--primary' target='_blank' href={message}>click here.</a></p>\n        </div>\n        }\n        {status === publishStates.FAILED &&\n        <div className='row align-content-center'>\n          <p>Something went wrong...</p>\n          <p><strong>{message}</strong></p>\n          <p>For help, post the above error text in the #speech channel on the <a className='link--primary' href='https://discord.gg/YjYbwhS' target='_blank'>lbry discord</a></p>\n          <button className='button--secondary' onClick={clearFile}>Reset</button>\n        </div>\n        }\n      </div>\n    );\n  }\n};\n\nexport default PublishStatus;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/PublishStatus/view.jsx","export const LOAD_START = 'LOAD_START';\nexport const LOADING = 'LOADING';\nexport const PUBLISHING = 'PUBLISHING';\nexport const SUCCESS = 'SUCCESS';\nexport const FAILED = 'FAILED';\n\n\n\n// WEBPACK FOOTER //\n// ./react/constants/publish_claim_states.js","import React from 'react';\nimport NavBar from 'containers/NavBar';\nimport SEO from 'components/SEO';\n\nclass AboutPage extends React.Component {\n  render () {\n    return (\n      <div>\n        <SEO pageTitle={'About'} pageUri={'about'} />\n        <NavBar />\n        <div className='row row--padded'>\n          <div className='column column--5 column--med-10 align-content-top'>\n            <div className='column column--8 column--med-10'>\n              <p className='pull-quote'>Spee.ch is an open-source project.  Please contribute to the existing site, or fork it and make your own.</p>\n              <p><a className='link--primary' target='_blank' href='https://twitter.com/spee_ch'>TWITTER</a></p>\n              <p><a className='link--primary' target='_blank' href='https://github.com/lbryio/spee.ch'>GITHUB</a></p>\n              <p><a className='link--primary' target='_blank' href='https://discord.gg/YjYbwhS'>DISCORD CHANNEL</a></p>\n              <p><a className='link--primary' target='_blank' href='https://github.com/lbryio/spee.ch/blob/master/README.md'>DOCUMENTATION</a></p>\n            </div>\n          </div><div className='column column--5 column--med-10 align-content-top'>\n            <div className='column column--8 column--med-10'>\n              <p>Spee.ch is a media-hosting site that reads from and publishes content to the <a className='link--primary' href='https://lbry.io'>LBRY</a> blockchain.</p>\n              <p>Spee.ch is a hosting service, but with the added benefit that it stores your content on a decentralized network of computers -- the LBRY network.  This means that your images are stored in multiple locations without a single point of failure.</p>\n              <h3>Contribute</h3>\n              <p>If you have an idea for your own spee.ch-like site on top of LBRY, fork our <a className='link--primary' href='https://github.com/lbryio/spee.ch'>github repo</a> and go to town!</p>\n              <p>If you want to improve spee.ch, join our <a className='link--primary' href='https://discord.gg/YjYbwhS'>discord channel</a> or solve one of our <a className='link--primary' href='https://github.com/lbryio/spee.ch/issues'>github issues</a>.</p>\n            </div>\n          </div>\n        </div>\n      </div>\n    );\n  }\n};\n\nexport default AboutPage;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/AboutPage/index.jsx","import {connect} from 'react-redux';\nimport View from './view';\n\nconst mapStateToProps = ({ channel }) => {\n  return {\n    loggedInChannelName: channel.loggedInChannel.name,\n  };\n};\n\nexport default connect(mapStateToProps, null)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/LoginPage/index.js","import React from 'react';\nimport { withRouter } from 'react-router-dom';\nimport SEO from 'components/SEO';\nimport NavBar from 'containers/NavBar';\nimport ChannelLoginForm from 'containers/ChannelLoginForm';\nimport ChannelCreateForm from 'containers/ChannelCreateForm';\n\nclass LoginPage extends React.Component {\n  componentWillReceiveProps (newProps) {\n    // re-route the user to the homepage if the user is logged in\n    if (newProps.loggedInChannelName !== this.props.loggedInChannelName) {\n      this.props.history.push(`/`);\n    }\n  }\n  render () {\n    return (\n      <div>\n        <SEO pageTitle={'Login'} pageUri={'login'} />\n        <NavBar />\n        <div className='row row--padded'>\n          <div className='column column--5 column--med-10 align-content-top'>\n            <div className='column column--8 column--med-10'>\n              <p>Channels allow you to publish and group content under an identity. You can create a channel for yourself, or share one with like-minded friends.  You can create 1 channel, or 100, so whether you're <a className='link--primary' target='_blank' href='/@catalonia2017:43dcf47163caa21d8404d9fe9b30f78ef3e146a8'>documenting important events</a>, or making a public repository for <a className='link--primary' target='_blank' href='/@catGifs'>cat gifs</a> (password: '1234'), try creating a channel for it!</p>\n            </div>\n          </div><div className='column column--5 column--med-10 align-content-top'>\n            <div className='column column--8 column--med-10'>\n              <h3 className='h3--no-bottom'>Log in to an existing channel:</h3>\n              <ChannelLoginForm />\n              <h3 className='h3--no-bottom'>Create a brand new channel:</h3>\n              <ChannelCreateForm />\n            </div>\n          </div>\n        </div>\n      </div>\n    );\n  }\n};\n\nexport default withRouter(LoginPage);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/LoginPage/view.jsx","import { connect } from 'react-redux';\nimport { onHandleShowPageUri } from 'actions/show';\nimport View from './view';\n\nconst mapStateToProps = ({ show }) => {\n  return {\n    error      : show.request.error,\n    requestType: show.request.type,\n  };\n};\n\nconst mapDispatchToProps = {\n  onHandleShowPageUri,\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ShowPage/index.js","import React from 'react';\nimport ErrorPage from 'components/ErrorPage';\nimport ShowAssetLite from 'containers/ShowAssetLite';\nimport ShowAssetDetails from 'containers/ShowAssetDetails';\nimport ShowChannel from 'containers/ShowChannel';\n\nimport { CHANNEL, ASSET_LITE, ASSET_DETAILS } from 'constants/show_request_types';\n\nclass ShowPage extends React.Component {\n  componentDidMount () {\n    this.props.onHandleShowPageUri(this.props.match.params);\n  }\n  componentWillReceiveProps (nextProps) {\n    if (nextProps.match.params !== this.props.match.params) {\n      this.props.onHandleShowPageUri(nextProps.match.params);\n    }\n  }\n  render () {\n    const { error, requestType } = this.props;\n    if (error) {\n      return (\n        <ErrorPage error={error} />\n      );\n    }\n    switch (requestType) {\n      case CHANNEL:\n        return <ShowChannel />;\n      case ASSET_LITE:\n        return <ShowAssetLite />;\n      case ASSET_DETAILS:\n        return <ShowAssetDetails />;\n      default:\n        return <p>loading...</p>;\n    }\n  }\n};\n\nexport default ShowPage;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ShowPage/view.jsx","import { connect } from 'react-redux';\nimport View from './view';\n\nconst mapStateToProps = ({ show }) => {\n  // select request info\n  const requestId = show.request.id;\n  // select asset info\n  let asset;\n  const request = show.requestList[requestId] || null;\n  const assetList = show.assetList;\n  if (request && assetList) {\n    const assetKey = request.key;  // note: just store this in the request\n    asset = assetList[assetKey] || null;\n  };\n  // return props\n  return {\n    asset,\n  };\n};\n\nexport default connect(mapStateToProps, null)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ShowAssetLite/index.js","import React from 'react';\nimport SEO from 'components/SEO';\nimport { Link } from 'react-router-dom';\nimport AssetDisplay from 'containers/AssetDisplay';\n\nclass ShowLite extends React.Component {\n  render () {\n    const { asset } = this.props;\n    if (asset) {\n      const { name, claimId } = asset.claimData;\n      return (\n        <div className='row row--tall flex-container--column flex-container--center-center show-lite-container'>\n          <SEO pageTitle={name} asset={asset} />\n          <AssetDisplay />\n          <Link id='asset-boilerpate' className='link--primary fine-print' to={`/${claimId}/${name}`}>hosted\n            via Spee.ch</Link>\n        </div>\n      );\n    }\n    return (\n      <div className='row row--tall row--padded flex-container--column flex-container--center-center'>\n        <p>loading asset data...</p>\n      </div>\n    );\n  }\n};\n\nexport default ShowLite;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ShowAssetLite/view.jsx","import React from 'react';\nimport ProgressBar from 'components/ProgressBar';\nimport { LOCAL_CHECK, UNAVAILABLE, ERROR, AVAILABLE } from 'constants/asset_display_states';\n\nclass AssetDisplay extends React.Component {\n  componentDidMount () {\n    const { asset: { claimData: { name, claimId } } } = this.props;\n    this.props.onFileRequest(name, claimId);\n  }\n  render () {\n    const { status, error, asset: { claimData: { name, claimId, contentType, fileExt, thumbnail } } } = this.props;\n    return (\n      <div id='asset-display-component'>\n        {(status === LOCAL_CHECK) &&\n        <div>\n          <p>Checking to see if Spee.ch has your asset locally...</p>\n        </div>\n        }\n        {(status === UNAVAILABLE) &&\n        <div>\n          <p>Sit tight, we're searching the LBRY blockchain for your asset!</p>\n          <ProgressBar size={12} />\n          <p>Curious what magic is happening here? <a className='link--primary' target='blank' href='https://lbry.io/faq/what-is-lbry'>Learn more.</a></p>\n        </div>\n        }\n        {(status === ERROR) &&\n        <div>\n          <p>Unfortunately, we couldn't download your asset from LBRY.  You can help us out by sharing the below error message in the <a className='link--primary' href='https://discord.gg/YjYbwhS' target='_blank'>LBRY discord</a>.</p>\n          <i><p id='error-message'>{error}</p></i>\n        </div>\n        }\n        {(status === AVAILABLE) &&\n        (() => {\n          switch (contentType) {\n            case 'image/jpeg':\n            case 'image/jpg':\n            case 'image/png':\n              return (\n                <img\n                  className='asset'\n                  src={`/${claimId}/${name}.${fileExt}`}\n                  alt={name} />\n              );\n            case 'image/gif':\n              return (\n                <img\n                  className='asset'\n                  src={`/${claimId}/${name}.${fileExt}`}\n                  alt={name}\n                />\n              );\n            case 'video/mp4':\n              return (\n                <video className='asset video' controls poster={thumbnail}>\n                  <source\n                    src={`/${claimId}/${name}.${fileExt}`}\n                  />\n                  <p>Your browser does not support the <code>video</code> element.</p>\n                </video>\n              );\n            default:\n              return (\n                <p>Unsupported file type</p>\n              );\n          }\n        })()\n        }\n      </div>\n    );\n  }\n};\n\nexport default AssetDisplay;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/AssetDisplay/view.jsx","import { connect } from 'react-redux';\nimport View from './view';\n\nconst mapStateToProps = ({ show }) => {\n  // select request info\n  const requestId = show.request.id;\n  // select asset info\n  let asset;\n  const request = show.requestList[requestId] || null;\n  const assetList = show.assetList;\n  if (request && assetList) {\n    const assetKey = request.key;  // note: just store this in the request\n    asset = assetList[assetKey] || null;\n  };\n  // return props\n  return {\n    asset,\n  };\n};\n\nexport default connect(mapStateToProps, null)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ShowAssetDetails/index.js","import React from 'react';\nimport SEO from 'components/SEO';\nimport NavBar from 'containers/NavBar';\nimport ErrorPage from 'components/ErrorPage';\nimport AssetTitle from 'containers/AssetTitle';\nimport AssetDisplay from 'containers/AssetDisplay';\nimport AssetInfo from 'containers/AssetInfo';\n\nclass ShowAssetDetails extends React.Component {\n  render () {\n    const { asset } = this.props;\n    if (asset) {\n      const { claimData: { name } } = asset;\n      return (\n        <div>\n          <SEO pageTitle={`${name} - details`} asset={asset} />\n          <NavBar />\n          <div className='row row--tall row--padded'>\n            <div className='column column--10'>\n              <AssetTitle />\n            </div>\n            <div className='column column--5 column--sml-10 align-content-top'>\n              <div className='row row--padded show-details-container'>\n                <AssetDisplay />\n              </div>\n            </div><div className='column column--5 column--sml-10 align-content-top'>\n              <div className='row row--padded'>\n                <AssetInfo />\n              </div>\n            </div>\n          </div>\n          }\n        </div>\n      );\n    };\n    return (\n      <ErrorPage error={'loading asset data...'} />\n    );\n  }\n};\n\nexport default ShowAssetDetails;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ShowAssetDetails/view.jsx","import { connect } from 'react-redux';\nimport View from './view';\nimport { selectAsset } from 'selectors/show';\n\nconst mapStateToProps = ({ show }) => {\n  const { claimData: { title } } = selectAsset(show);\n  return {\n    title,\n  };\n};\n\nexport default connect(mapStateToProps, null)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/AssetTitle/index.js","import React from 'react';\n\nconst AssetTitle = ({ title }) => {\n  return (\n    <div>\n      <span className='text--large'>{title}</span>\n    </div>\n  );\n};\n\nexport default AssetTitle;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/AssetTitle/view.jsx","import { connect } from 'react-redux';\nimport View from './view';\nimport { selectAsset } from 'selectors/show';\n\nconst mapStateToProps = ({ show }) => {\n  // select asset\n  const asset = selectAsset(show);\n  //  return props\n  return {\n    asset,\n  };\n};\n\nexport default connect(mapStateToProps, null)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/AssetInfo/index.js","import React from 'react';\nimport { Link } from 'react-router-dom';\n\nclass AssetInfo extends React.Component {\n  constructor (props) {\n    super(props);\n    this.copyToClipboard = this.copyToClipboard.bind(this);\n  }\n  copyToClipboard (event) {\n    var elementToCopy = event.target.dataset.elementtocopy;\n    var element = document.getElementById(elementToCopy);\n    element.select();\n    try {\n      document.execCommand('copy');\n    } catch (err) {\n      this.setState({error: 'Oops, unable to copy'});\n    }\n  }\n  render () {\n    const { asset: { shortId, claimData : { channelName, certificateId, description, name, claimId, fileExt, contentType, thumbnail, host } } } = this.props;\n    return (\n      <div>\n        {channelName &&\n        <div className='row row--padded row--wide row--no-top'>\n          <div className='column column--2 column--med-10'>\n            <span className='text'>Channel:</span>\n          </div>\n          <div className='column column--8 column--med-10'>\n            <span className='text'><Link to={`/${channelName}:${certificateId}`}>{channelName}</Link></span>\n          </div>\n        </div>\n        }\n\n        {description &&\n        <div className='row row--padded row--wide row--no-top'>\n          <span className='text'>{description}</span>\n        </div>\n        }\n\n        <div id='show-share-buttons'>\n          <div className='row row--padded row--wide row--no-top'>\n            <div className='column column--2 column--med-10'>\n              <span className='text'>Share:</span>\n            </div>\n            <div className='column column--8 column--med-10'>\n              <div\n                className='row row--short row--wide flex-container--row flex-container--space-between-bottom flex-container--wrap'>\n                <a className='link--primary' target='_blank' href={`https://twitter.com/intent/tweet?text=${host}/${shortId}/${name}`}>twitter</a>\n                <a className='link--primary' target='_blank' href={`https://www.facebook.com/sharer/sharer.php?u=${host}/${shortId}/${name}`}>facebook</a>\n                <a className='link--primary' target='_blank' href={`http://tumblr.com/widgets/share/tool?canonicalUrl=${host}/${shortId}/${name}`}>tumblr</a>\n                <a className='link--primary' target='_blank' href={`https://www.reddit.com/submit?url=${host}/${shortId}/${name}&title=${name}`}>reddit</a>\n              </div>\n            </div>\n          </div>\n        </div>\n\n        <div className='row row--padded row--wide row--no-top'>\n          <div id='show-short-link'>\n            <div className='column column--2 column--med-10'>\n              <span className='text'>Link:</span>\n            </div>\n            <div className='column column--8 column--med-10'>\n              <div className='row row--short row--wide'>\n                <div className='column column--7'>\n                  <div className='input-error' id='input-error-copy-short-link' hidden='true'>error here</div>\n                  <input type='text' id='short-link' className='input-disabled input-text--full-width' readOnly\n                    spellCheck='false'\n                    value={`${host}/${shortId}/${name}.${fileExt}`}\n                    onClick={this.select} />\n                </div>\n                <div className='column column--1' />\n                <div className='column column--2'>\n                  <button className='button--primary button--wide' data-elementtocopy='short-link'\n                    onClick={this.copyToClipboard}>copy\n                  </button>\n                </div>\n              </div>\n            </div>\n          </div>\n\n          <div id='show-embed-code'>\n            <div className='column column--2 column--med-10'>\n              <span className='text'>Embed:</span>\n            </div>\n            <div className='column column--8 column--med-10'>\n              <div className='row row--short row--wide'>\n                <div className='column column--7'>\n                  <div className='input-error' id='input-error-copy-embed-text' hidden='true'>error here</div>\n                  {(contentType === 'video/mp4') ? (\n                    <input type='text' id='embed-text' className='input-disabled input-text--full-width' readOnly\n                      onClick={this.select} spellCheck='false'\n                      value={`<video width=\"100%\" controls poster=\"${thumbnail}\" src=\"${host}/${claimId}/${name}.${fileExt}\"/></video>`} />\n                  ) : (\n                    <input type='text' id='embed-text' className='input-disabled input-text--full-width' readOnly\n                      onClick={this.select} spellCheck='false'\n                      value={`<img src=\"${host}/${claimId}/${name}.${fileExt}\"/>`}\n                    />\n                  )}\n                </div>\n                <div className='column column--1' />\n                <div className='column column--2'>\n                  <button className='button--primary button--wide' data-elementtocopy='embed-text'\n                    onClick={this.copyToClipboard}>copy\n                  </button>\n                </div>\n              </div>\n            </div>\n          </div>\n        </div>\n\n        <div className='flex-container--row flex-container--space-between-bottom'>\n          <Link className='link--primary' to={`/${shortId}/${name}.${fileExt}`}><span\n            className='text'>Direct Link</span></Link>\n          <a className='link--primary' href={`${host}/${claimId}/${name}.${fileExt}`} download={name}>Download</a>\n          <a className='link--primary' target='_blank' href='https://lbry.io/dmca'>Report</a>\n        </div>\n\n      </div>\n    );\n  }\n};\n\nexport default AssetInfo;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/AssetInfo/view.jsx","import { connect } from 'react-redux';\nimport View from './view';\n\nconst mapStateToProps = ({ show }) => {\n  // select request info\n  const requestId = show.request.id;\n  // select request\n  const previousRequest = show.requestList[requestId] || null;\n  // select channel\n  let channel;\n  if (previousRequest) {\n    const channelKey = previousRequest.key;\n    channel = show.channelList[channelKey] || null;\n  }\n  return {\n    channel,\n  };\n};\n\nexport default connect(mapStateToProps, null)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ShowChannel/index.js","import React from 'react';\nimport SEO from 'components/SEO';\nimport ErrorPage from 'components/ErrorPage';\nimport NavBar from 'containers/NavBar';\nimport ChannelClaimsDisplay from 'containers/ChannelClaimsDisplay';\n\nclass ShowChannel extends React.Component {\n  render () {\n    const { channel } = this.props;\n    if (channel) {\n      const { name, longId, shortId } = channel;\n      return (\n        <div>\n          <SEO pageTitle={name} channel={channel} />\n          <NavBar />\n          <div className='row row--tall row--padded'>\n            <div className='column column--10'>\n              <h2>channel name: {name}</h2>\n              <p className={'fine-print'}>full channel id: {longId}</p>\n              <p className={'fine-print'}>short channel id: {shortId}</p>\n            </div>\n            <div className='column column--10'>\n              <ChannelClaimsDisplay />\n            </div>\n          </div>\n        </div>\n      );\n    };\n    return (\n      <ErrorPage error={'loading channel data...'} />\n    );\n  }\n};\n\nexport default ShowChannel;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ShowChannel/view.jsx","import { connect } from 'react-redux';\nimport { onUpdateChannelClaims } from 'actions/show';\nimport View from './view';\n\nconst mapStateToProps = ({ show }) => {\n  // select channel key\n  const request = show.requestList[show.request.id];\n  const channelKey = request.key;\n  // select channel claims\n  const channel = show.channelList[channelKey] || null;\n  // return props\n  return {\n    channelKey,\n    channel,\n  };\n};\n\nconst mapDispatchToProps = {\n  onUpdateChannelClaims,\n};\n\nexport default connect(mapStateToProps, mapDispatchToProps)(View);\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ChannelClaimsDisplay/index.js","import React from 'react';\nimport AssetPreview from 'components/AssetPreview';\n\nclass ChannelClaimsDisplay extends React.Component {\n  constructor (props) {\n    super(props);\n    this.showNextResultsPage = this.showNextResultsPage.bind(this);\n    this.showPreviousResultsPage = this.showPreviousResultsPage.bind(this);\n  }\n  showPreviousResultsPage () {\n    const { channel: { claimsData: { currentPage } } } = this.props;\n    const previousPage = parseInt(currentPage) - 1;\n    this.showNewPage(previousPage);\n  }\n  showNextResultsPage () {\n    const { channel: { claimsData: { currentPage } } } = this.props;\n    const nextPage = parseInt(currentPage) + 1;\n    this.showNewPage(nextPage);\n  }\n  showNewPage (page) {\n    const { channelKey, channel: { name, longId } } = this.props;\n    this.props.onUpdateChannelClaims(channelKey, name, longId, page);\n  }\n  render () {\n    const { channel: { claimsData: { claims, currentPage, totalPages } } } = this.props;\n    return (\n      <div className='row row--tall'>\n        {(claims.length > 0) ? (\n          <div>\n            {claims.map((claim, index) => <AssetPreview\n              claimData={claim}\n              key={`${claim.name}-${index}`}\n            />)}\n            <div>\n              {(currentPage > 1) &&\n              <button className={'button--secondary'} onClick={this.showPreviousResultsPage}>Previous Page</button>\n              }\n              {(currentPage < totalPages) &&\n              <button className={'button--secondary'} onClick={this.showNextResultsPage}>Next Page</button>\n              }\n            </div>\n          </div>\n        ) : (\n          <p>There are no claims in this channel</p>\n        )}\n      </div>\n    );\n  }\n};\n\nexport default ChannelClaimsDisplay;\n\n\n\n// WEBPACK FOOTER //\n// ./react/containers/ChannelClaimsDisplay/view.jsx","import React from 'react';\nimport { Link } from 'react-router-dom';\nconst { claim: { defaultThumbnail } } = require('../../../config/speechConfig.js');\n\nconst AssetPreview = ({ claimData: { name, claimId, fileExt, contentType, thumbnail } }) => {\n  const directSourceLink = `${claimId}/${name}.${fileExt}`;\n  const showUrlLink = `/${claimId}/${name}`;\n  return (\n    <div className='asset-holder'>\n      <Link to={showUrlLink} >\n        {(() => {\n          switch (contentType) {\n            case 'image/jpeg':\n            case 'image/jpg':\n            case 'image/png':\n            case 'image/gif':\n              return (\n                <img\n                  className={'asset-preview'}\n                  src={directSourceLink}\n                  alt={name}\n                />\n              );\n            case 'video/mp4':\n              return (\n                <img\n                  className={'asset-preview video'}\n                  src={thumbnail || defaultThumbnail}\n                  alt={name}\n                />\n              );\n            default:\n              return (\n                <p>unsupported file type</p>\n              );\n          }\n        })()}\n      </Link>\n    </div>\n  );\n};\n\nexport default AssetPreview;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/AssetPreview/index.jsx","import React from 'react';\nimport NavBar from 'containers/NavBar';\nimport Helmet from 'react-helmet';\nconst { site: { title, host } } = require('../../../config/speechConfig.js');\n\nclass FourOhForPage extends React.Component {\n  render () {\n    return (\n      <div>\n        <Helmet>\n          <title>{title} - 404</title>\n          <link rel='canonical' href={`${host}/404`} />\n        </Helmet>\n        <NavBar />\n        <div className='row row--padded'>\n          <h2>404</h2>\n          <p>That page does not exist</p>\n        </div>\n      </div>\n    );\n  }\n};\n\nexport default FourOhForPage;\n\n\n\n// WEBPACK FOOTER //\n// ./react/components/FourOhFourPage/index.jsx","const { sendGAServeEvent } = require('../helpers/googleAnalytics');\nconst { determineResponseType, flipClaimNameAndIdForBackwardsCompatibility, logRequestData, getClaimIdAndServeAsset } = require('../helpers/serveHelpers.js');\nconst lbryUri = require('../helpers/lbryUri.js');\nconst handleShowRender = require('../helpers/handleShowRender.jsx');\nconst SERVE = 'SERVE';\n\nmodule.exports = (app) => {\n  // route to serve a specific asset using the channel or claim id\n  app.get('/:identifier/:claim', (req, res) => {\n    const { headers, ip, originalUrl, params } = req;\n    // decide if this is a show request\n    let hasFileExtension;\n    try {\n      ({ hasFileExtension } = lbryUri.parseModifier(params.claim));\n    } catch (error) {\n      return res.status(400).json({success: false, message: error.message});\n    }\n    let responseType = determineResponseType(hasFileExtension, headers);\n    if (responseType !== SERVE) {\n      return handleShowRender(req, res);\n    }\n    // handle serve request\n    // send google analytics\n    sendGAServeEvent(headers, ip, originalUrl);\n    // parse the claim\n    let claimName;\n    try {\n      ({ claimName } = lbryUri.parseClaim(params.claim));\n    } catch (error) {\n      return res.status(400).json({success: false, message: error.message});\n    }\n    // parse the identifier\n    let isChannel, channelName, channelClaimId, claimId;\n    try {\n      ({ isChannel, channelName, channelClaimId, claimId } = lbryUri.parseIdentifier(params.identifier));\n    } catch (error) {\n      return res.status(400).json({success: false, message: error.message});\n    }\n    if (!isChannel) {\n      [claimId, claimName] = flipClaimNameAndIdForBackwardsCompatibility(claimId, claimName);\n    }\n    // log the request data for debugging\n    logRequestData(responseType, claimName, channelName, claimId);\n    // get the claim Id and then serve the asset\n    getClaimIdAndServeAsset(channelName, channelClaimId, claimName, claimId, originalUrl, ip, res);\n  });\n  // route to serve the winning asset at a claim or a channel page\n  app.get('/:claim', (req, res) => {\n    const { headers, ip, originalUrl, params } = req;\n    // decide if this is a show request\n    let hasFileExtension;\n    try {\n      ({ hasFileExtension } = lbryUri.parseModifier(params.claim));\n    } catch (error) {\n      return res.status(400).json({success: false, message: error.message});\n    }\n    let responseType = determineResponseType(hasFileExtension, headers);\n    if (responseType !== SERVE) {\n      return handleShowRender(req, res);\n    }\n    // handle serve request\n    // send google analytics\n    sendGAServeEvent(headers, ip, originalUrl);\n    // parse the claim\n    let claimName;\n    try {\n      ({claimName} = lbryUri.parseClaim(params.claim));\n    } catch (error) {\n      return res.status(400).json({success: false, message: error.message});\n    }\n    // log the request data for debugging\n    logRequestData(responseType, claimName, null, null);\n    // get the claim Id and then serve the asset\n    getClaimIdAndServeAsset(null, null, claimName, null, originalUrl, ip, res);\n  });\n};\n\n\n\n// WEBPACK FOOTER //\n// ./routes/serve-routes.js","const logger = require('winston');\nconst { getClaimId, getLocalFileRecord } = require('../controllers/serveController.js');\nconst { handleErrorResponse } = require('../helpers/errorHandlers.js');\n\nconst SERVE = 'SERVE';\nconst SHOW = 'SHOW';\nconst NO_FILE = 'NO_FILE';\nconst NO_CHANNEL = 'NO_CHANNEL';\nconst NO_CLAIM = 'NO_CLAIM';\n\nfunction clientAcceptsHtml ({accept}) {\n  return accept && accept.match(/text\\/html/);\n};\n\nfunction requestIsFromBrowser (headers) {\n  return headers['user-agent'] && headers['user-agent'].match(/Mozilla/);\n};\n\nfunction clientWantsAsset ({accept, range}) {\n  const imageIsWanted = accept && accept.match(/image\\/.*/) && !accept.match(/text\\/html/) && !accept.match(/text\\/\\*/);\n  const videoIsWanted = accept && range;\n  return imageIsWanted || videoIsWanted;\n};\n\nfunction isValidClaimId (claimId) {\n  return ((claimId.length === 40) && !/[^A-Za-z0-9]/g.test(claimId));\n};\n\nfunction isValidShortId (claimId) {\n  return claimId.length === 1;  // it should really evaluate the short url itself\n};\n\nfunction isValidShortIdOrClaimId (input) {\n  return (isValidClaimId(input) || isValidShortId(input));\n};\n\nfunction serveAssetToClient (claimId, name, res) {\n  return getLocalFileRecord(claimId, name)\n    .then(fileRecord => {\n      // check that a local record was found\n      if (fileRecord === NO_FILE) {\n        return res.status(307).redirect(`/api/claim/get/${name}/${claimId}`);\n      }\n      // serve the file\n      const {filePath, fileType} = fileRecord;\n      logger.verbose(`serving file: ${filePath}`);\n      const sendFileOptions = {\n        headers: {\n          'X-Content-Type-Options': 'nosniff',\n          'Content-Type'          : fileType || 'image/jpeg',\n        },\n      };\n      res.status(200).sendFile(filePath, sendFileOptions);\n    })\n    .catch(error => {\n      throw error;\n    });\n};\n\nmodule.exports = {\n  getClaimIdAndServeAsset (channelName, channelClaimId, claimName, claimId, originalUrl, ip, res) {\n    // get the claim Id and then serve the asset\n    getClaimId(channelName, channelClaimId, claimName, claimId)\n      .then(fullClaimId => {\n        if (fullClaimId === NO_CLAIM) {\n          return res.status(404).json({success: false, message: 'no claim id could be found'});\n        } else if (fullClaimId === NO_CHANNEL) {\n          return res.status(404).json({success: false, message: 'no channel id could be found'});\n        }\n        serveAssetToClient(fullClaimId, claimName, res);\n        // postToStats(responseType, originalUrl, ip, claimName, fullClaimId, 'success');\n      })\n      .catch(error => {\n        handleErrorResponse(originalUrl, ip, error, res);\n        // postToStats(responseType, originalUrl, ip, claimName, fullClaimId, 'fail');\n      });\n  },\n  determineResponseType (hasFileExtension, headers) {\n    let responseType;\n    if (hasFileExtension) {\n      responseType = SERVE;  // assume a serve request if file extension is present\n      if (clientAcceptsHtml(headers)) {  // if the request comes from a browser, change it to a show request\n        responseType = SHOW;\n      }\n    } else {\n      responseType = SHOW;\n      if (clientWantsAsset(headers) && requestIsFromBrowser(headers)) {  // this is in case someone embeds a show url\n        logger.debug('Show request came from browser but wants an image/video. Changing response to serve...');\n        responseType = SERVE;\n      }\n    }\n    return responseType;\n  },\n  flipClaimNameAndIdForBackwardsCompatibility (identifier, name) {\n    // this is a patch for backwards compatability with '/name/claim_id' url format\n    if (isValidShortIdOrClaimId(name) && !isValidShortIdOrClaimId(identifier)) {\n      const tempName = name;\n      name = identifier;\n      identifier = tempName;\n    }\n    return [identifier, name];\n  },\n  logRequestData (responseType, claimName, channelName, claimId) {\n    logger.debug('responseType ===', responseType);\n    logger.debug('claim name === ', claimName);\n    logger.debug('channel name ===', channelName);\n    logger.debug('claim id ===', claimId);\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/serveHelpers.js","const logger = require('winston');\n\nmodule.exports = {\n  REGEXP_INVALID_CLAIM  : /[^A-Za-z0-9-]/g,\n  REGEXP_INVALID_CHANNEL: /[^A-Za-z0-9-@]/g,\n  REGEXP_ADDRESS        : /^b(?=[^0OIl]{32,33})[0-9A-Za-z]{32,33}$/,\n  CHANNEL_CHAR          : '@',\n  parseIdentifier       : function (identifier) {\n    logger.debug('parsing identifier:', identifier);\n    const componentsRegex = new RegExp(\n      '([^:$#/]*)' + // value (stops at the first separator or end)\n      '([:$#]?)([^/]*)' // modifier separator, modifier (stops at the first path separator or end)\n    );\n    const [proto, value, modifierSeperator, modifier] = componentsRegex\n      .exec(identifier)\n      .map(match => match || null);\n    logger.debug(`${proto}, ${value}, ${modifierSeperator}, ${modifier}`);\n\n    // Validate and process name\n    if (!value) {\n      throw new Error(`Check your url.  No channel name provided before \"${modifierSeperator}\"`);\n    }\n    const isChannel = value.startsWith(module.exports.CHANNEL_CHAR);\n    const channelName = isChannel ? value : null;\n    let claimId;\n    if (isChannel) {\n      if (!channelName) {\n        throw new Error('No channel name after @.');\n      }\n      const nameBadChars = (channelName).match(module.exports.REGEXP_INVALID_CHANNEL);\n      if (nameBadChars) {\n        throw new Error(`Invalid characters in channel name: ${nameBadChars.join(', ')}.`);\n      }\n    } else {\n      claimId = value;\n    }\n\n    // Validate and process modifier\n    let channelClaimId;\n    if (modifierSeperator) {\n      if (!modifier) {\n        throw new Error(`No modifier provided after separator \"${modifierSeperator}\"`);\n      }\n\n      if (modifierSeperator === ':') {\n        channelClaimId = modifier;\n      } else {\n        throw new Error(`The \"${modifierSeperator}\" modifier is not currently supported`);\n      }\n    }\n    return {\n      isChannel,\n      channelName,\n      channelClaimId,\n      claimId,\n    };\n  },\n  parseClaim: function (claim) {\n    logger.debug('parsing name:', claim);\n    const componentsRegex = new RegExp(\n      '([^:$#/.]*)' + // name (stops at the first modifier)\n      '([:$#.]?)([^/]*)' // modifier separator, modifier (stops at the first path separator or end)\n    );\n    const [proto, claimName, modifierSeperator, modifier] = componentsRegex\n      .exec(claim)\n      .map(match => match || null);\n    logger.debug(`${proto}, ${claimName}, ${modifierSeperator}, ${modifier}`);\n\n    // Validate and process name\n    if (!claimName) {\n      throw new Error('No claim name provided before .');\n    }\n    const nameBadChars = (claimName).match(module.exports.REGEXP_INVALID_CLAIM);\n    if (nameBadChars) {\n      throw new Error(`Invalid characters in claim name: ${nameBadChars.join(', ')}.`);\n    }\n    // Validate and process modifier\n    if (modifierSeperator) {\n      if (!modifier) {\n        throw new Error(`No file extension provided after separator ${modifierSeperator}.`);\n      }\n      if (modifierSeperator !== '.') {\n        throw new Error(`The ${modifierSeperator} modifier is not supported in the claim name`);\n      }\n    }\n    // return results\n    return {\n      claimName,\n    };\n  },\n  parseModifier: function (claim) {\n    logger.debug('parsing modifier:', claim);\n    const componentsRegex = new RegExp(\n      '([^:$#/.]*)' + // name (stops at the first modifier)\n      '([:$#.]?)([^/]*)' // modifier separator, modifier (stops at the first path separator or end)\n    );\n    const [proto, claimName, modifierSeperator, modifier] = componentsRegex\n      .exec(claim)\n      .map(match => match || null);\n    logger.debug(`${proto}, ${claimName}, ${modifierSeperator}, ${modifier}`);\n    // Validate and process modifier\n    let hasFileExtension = false;\n    if (modifierSeperator) {\n      hasFileExtension = true;\n    }\n    return {\n      hasFileExtension,\n    };\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/lbryUri.js","import React from 'react';\nimport { renderToString } from 'react-dom/server';\nimport { createStore, applyMiddleware } from 'redux';\nimport Reducer from '../react/reducers';\nimport { Provider } from 'react-redux';\nimport { StaticRouter } from 'react-router-dom';\nimport GAListener from '../react/components/GAListener';\nimport App from '../react/app';\nimport renderFullPage from './renderFullPage';\nimport createSagaMiddleware from 'redux-saga';\nimport { call } from 'redux-saga/effects';\nimport { handleShowPageUri } from '../react/sagas/show_uri';\nimport { onHandleShowPageUri } from '../react/actions/show';\n\nimport Helmet from 'react-helmet';\n\nconst returnSagaWithParams = (saga, params) => {\n  return function * () {\n    yield call(saga, params);\n  };\n};\n\nmodule.exports = (req, res) => {\n  let context = {};\n\n  // create and apply middleware\n  const sagaMiddleware = createSagaMiddleware();\n  const middleware = applyMiddleware(sagaMiddleware);\n\n  // create a new Redux store instance\n  const store = createStore(Reducer, middleware);\n\n  // create saga\n  const action = onHandleShowPageUri(req.params);\n  const saga = returnSagaWithParams(handleShowPageUri, action);\n\n  // run the saga middleware\n  sagaMiddleware\n    .run(saga)\n    .done\n    .then(() => {\n      // render component to a string\n      const html = renderToString(\n        <Provider store={store}>\n          <StaticRouter location={req.url} context={context}>\n            <GAListener>\n              <App />\n            </GAListener>\n          </StaticRouter>\n        </Provider>\n      );\n\n      // get head tags from helmet\n      const helmet = Helmet.renderStatic();\n\n      // check for a redirect\n      if (context.url) {\n        return res.redirect(301, context.url);\n      }\n\n      // get the initial state from our Redux store\n      const preloadedState = store.getState();\n\n      // send the rendered page back to the client\n      res.send(renderFullPage(helmet, html, preloadedState));\n    });\n};\n\n\n\n// WEBPACK FOOTER //\n// ./helpers/handleShowRender.jsx","module.exports = require(\"redux-saga\");\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"redux-saga\"\n// module id = 146\n// module chunks = 0","import { call, put, takeLatest } from 'redux-saga/effects';\nimport * as actions from 'constants/show_action_types';\nimport { onRequestError, onNewChannelRequest, onNewAssetRequest } from 'actions/show';\nimport { newAssetRequest } from 'sagas/show_asset';\nimport { newChannelRequest } from 'sagas/show_channel';\nimport lbryUri from 'utils/lbryUri';\n\nfunction * parseAndUpdateIdentifierAndClaim (modifier, claim) {\n  // this is a request for an asset\n  // claim will be an asset claim\n  // the identifier could be a channel or a claim id\n  let isChannel, channelName, channelClaimId, claimId, claimName, extension;\n  try {\n    ({ isChannel, channelName, channelClaimId, claimId } = lbryUri.parseIdentifier(modifier));\n    ({ claimName, extension } = lbryUri.parseClaim(claim));\n  } catch (error) {\n    return yield put(onRequestError(error.message));\n  }\n  // trigger an new action to update the store\n  if (isChannel) {\n    return yield call(newAssetRequest, onNewAssetRequest(claimName, null, channelName, channelClaimId, extension));\n  };\n  yield call(newAssetRequest, onNewAssetRequest(claimName, claimId, null, null, extension));\n}\nfunction * parseAndUpdateClaimOnly (claim) {\n  // this could be a request for an asset or a channel page\n  // claim could be an asset claim or a channel claim\n  let isChannel, channelName, channelClaimId;\n  try {\n    ({ isChannel, channelName, channelClaimId } = lbryUri.parseIdentifier(claim));\n  } catch (error) {\n    return yield put(onRequestError(error.message));\n  }\n  // trigger an new action to update the store\n  // return early if this request is for a channel\n  if (isChannel) {\n    return yield call(newChannelRequest, onNewChannelRequest(channelName, channelClaimId));\n  }\n  // if not for a channel, parse the claim request\n  let claimName, extension;\n  try {\n    ({claimName, extension} = lbryUri.parseClaim(claim));\n  } catch (error) {\n    return yield put(onRequestError(error.message));\n  }\n  yield call(newAssetRequest, onNewAssetRequest(claimName, null, null, null, extension));\n}\n\nexport function * handleShowPageUri (action) {\n  const { identifier, claim } = action.data;\n  if (identifier) {\n    return yield call(parseAndUpdateIdentifierAndClaim, identifier, claim);\n  }\n  yield call(parseAndUpdateClaimOnly, claim);\n};\n\nexport function * watchHandleShowPageUri () {\n  yield takeLatest(actions.HANDLE_SHOW_URI, handleShowPageUri);\n};\n\n\n\n// WEBPACK FOOTER //\n// ./react/sagas/show_uri.js","import { call, put, select, takeLatest } from 'redux-saga/effects';\nimport * as actions from 'constants/show_action_types';\nimport { addRequestToRequestList, onRequestError, onRequestUpdate, addAssetToAssetList } from 'actions/show';\nimport { getLongClaimId, getShortId, getClaimData } from 'api/assetApi';\nimport { selectShowState } from 'selectors/show';\n\nexport function * newAssetRequest (action) {\n  const { requestType, requestId, name, modifier } = action.data;\n  // put an action to update the request in redux\n  yield put(onRequestUpdate(requestType, requestId));\n  // is this an existing request?\n  // If this uri is in the request list, it's already been fetched\n  const state = yield select(selectShowState);\n  if (state.requestList[requestId]) {\n    return null;\n  }\n  // get long id && add request to request list\n  let longId;\n  try {\n    ({data: longId} = yield call(getLongClaimId, name, modifier));\n  } catch (error) {\n    return yield put(onRequestError(error.message));\n  }\n  const assetKey = `a#${name}#${longId}`;\n  yield put(addRequestToRequestList(requestId, null, assetKey));\n  // is this an existing asset?\n  // If this asset is in the asset list, it's already been fetched\n  if (state.assetList[assetKey]) {\n    return null;\n  }\n  // get short Id\n  let shortId;\n  try {\n    ({data: shortId} = yield call(getShortId, name, longId));\n  } catch (error) {\n    return yield put(onRequestError(error.message));\n  }\n  // get asset claim data\n  let claimData;\n  try {\n    ({data: claimData} = yield call(getClaimData, name, longId));\n  } catch (error) {\n    return yield put(onRequestError(error.message));\n  }\n  // add asset to asset list\n  yield put(addAssetToAssetList(assetKey, null, name, longId, shortId, claimData));\n  // clear any errors in request error\n  yield put(onRequestError(null));\n};\n\nexport function * watchNewAssetRequest () {\n  yield takeLatest(actions.ASSET_REQUEST_NEW, newAssetRequest);\n};\n\n\n\n// WEBPACK FOOTER //\n// ./react/sagas/show_asset.js","import Request from 'utils/request';\nconst { site: { host } } = require('../../config/speechConfig.js');\n\nexport function getLongClaimId (name, modifier) {\n  let body = {};\n  // create request params\n  if (modifier) {\n    if (modifier.id) {\n      body['claimId'] = modifier.id;\n    } else {\n      body['channelName'] = modifier.channel.name;\n      body['channelClaimId'] = modifier.channel.id;\n    }\n  }\n  body['claimName'] = name;\n  const params = {\n    method : 'POST',\n    headers: { 'Content-Type': 'application/json' },\n    body   : JSON.stringify(body),\n  };\n  // create url\n  const url = `${host}/api/claim/long-id`;\n  // return the request promise\n  return Request(url, params);\n};\n\nexport function getShortId (name, claimId) {\n  const url = `${host}/api/claim/short-id/${claimId}/${name}`;\n  return Request(url);\n};\n\nexport function getClaimData (name, claimId) {\n  const url = `${host}/api/claim/data/${name}/${claimId}`;\n  return Request(url);\n};\n\n\n\n// WEBPACK FOOTER //\n// ./react/api/assetApi.js","import {call, put, select, takeLatest} from 'redux-saga/effects';\nimport * as actions from 'constants/show_action_types';\nimport { addNewChannelToChannelList, addRequestToRequestList, onRequestError, onRequestUpdate, updateChannelClaims } from 'actions/show';\nimport { getChannelClaims, getChannelData } from 'api/channelApi';\nimport { selectShowState } from 'selectors/show';\n\nexport function * newChannelRequest (action) {\n  const { requestType, requestId, channelName, channelId } = action.data;\n  // put an action to update the request in redux\n  yield put(onRequestUpdate(requestType, requestId));\n  // is this an existing request?\n  // If this uri is in the request list, it's already been fetched\n  const state = yield select(selectShowState);\n  if (state.requestList[requestId]) {\n    return null;\n  }\n  // get channel long id\n  let longId, shortId;\n  try {\n    ({ data: {longChannelClaimId: longId, shortChannelClaimId: shortId} } = yield call(getChannelData, channelName, channelId));\n  } catch (error) {\n    return yield put(onRequestError(error.message));\n  }\n  // store the request in the channel requests list\n  const channelKey = `c#${channelName}#${longId}`;\n  yield put(addRequestToRequestList(requestId, null, channelKey));\n  // is this an existing channel?\n  // If this channel is in the channel list, it's already been fetched\n  if (state.channelList[channelKey]) {\n    return null;\n  }\n  // get channel claims data\n  let claimsData;\n  try {\n    ({ data: claimsData } = yield call(getChannelClaims, channelName, longId, 1));\n  } catch (error) {\n    return yield put(onRequestError(error.message));\n  }\n  // store the channel data in the channel list\n  yield put(addNewChannelToChannelList(channelKey, channelName, shortId, longId, claimsData));\n  // clear any request errors\n  yield put(onRequestError(null));\n}\n\nexport function * watchNewChannelRequest () {\n  yield takeLatest(actions.CHANNEL_REQUEST_NEW, newChannelRequest);\n};\n\nfunction * getNewClaimsAndUpdateChannel (action) {\n  const { channelKey, name, longId, page } = action.data;\n  let claimsData;\n  try {\n    ({ data: claimsData } = yield call(getChannelClaims, name, longId, page));\n  } catch (error) {\n    return yield put(onRequestError(error.message));\n  }\n  yield put(updateChannelClaims(channelKey, claimsData));\n}\n\nexport function * watchUpdateChannelClaims () {\n  yield takeLatest(actions.CHANNEL_CLAIMS_UPDATE_ASYNC, getNewClaimsAndUpdateChannel);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./react/sagas/show_channel.js","import Request from 'utils/request';\nconst { site: { host } } = require('../../config/speechConfig.js');\n\nexport function getChannelData (name, id) {\n  if (!id) id = 'none';\n  const url = `${host}/api/channel/data/${name}/${id}`;\n  return Request(url);\n};\n\nexport function getChannelClaims (name, longId, page) {\n  if (!page) page = 1;\n  const url = `${host}/api/channel/claims/${name}/${longId}/${page}`;\n  return Request(url);\n};\n\n\n\n// WEBPACK FOOTER //\n// ./react/api/channelApi.js","module.exports = {\n  REGEXP_INVALID_CLAIM  : /[^A-Za-z0-9-]/g,\n  REGEXP_INVALID_CHANNEL: /[^A-Za-z0-9-@]/g,\n  REGEXP_ADDRESS        : /^b(?=[^0OIl]{32,33})[0-9A-Za-z]{32,33}$/,\n  CHANNEL_CHAR          : '@',\n  parseIdentifier       : function (identifier) {\n    const componentsRegex = new RegExp(\n      '([^:$#/]*)' + // value (stops at the first separator or end)\n      '([:$#]?)([^/]*)' // modifier separator, modifier (stops at the first path separator or end)\n    );\n    const [proto, value, modifierSeperator, modifier] = componentsRegex  // eslint-disable-line no-unused-vars\n      .exec(identifier)\n      .map(match => match || null);\n\n    // Validate and process name\n    if (!value) {\n      throw new Error(`Check your URL.  No channel name provided before \"${modifierSeperator}\"`);\n    }\n    const isChannel = value.startsWith(module.exports.CHANNEL_CHAR);\n    const channelName = isChannel ? value : null;\n    let claimId;\n    if (isChannel) {\n      if (!channelName) {\n        throw new Error('Check your URL.  No channel name after \"@\".');\n      }\n      const nameBadChars = (channelName).match(module.exports.REGEXP_INVALID_CHANNEL);\n      if (nameBadChars) {\n        throw new Error(`Check your URL.  Invalid characters in channel name: \"${nameBadChars.join(', ')}\".`);\n      }\n    } else {\n      claimId = value;\n    }\n\n    // Validate and process modifier\n    let channelClaimId;\n    if (modifierSeperator) {\n      if (!modifier) {\n        throw new Error(`Check your URL.  No modifier provided after separator \"${modifierSeperator}\"`);\n      }\n\n      if (modifierSeperator === ':') {\n        channelClaimId = modifier;\n      } else {\n        throw new Error(`Check your URL.  The \"${modifierSeperator}\" modifier is not currently supported`);\n      }\n    }\n    return {\n      isChannel,\n      channelName,\n      channelClaimId: channelClaimId || null,\n      claimId       : claimId || null,\n    };\n  },\n  parseClaim: function (name) {\n    const componentsRegex = new RegExp(\n      '([^:$#/.]*)' + // name (stops at the first extension)\n      '([:$#.]?)([^/]*)' // extension separator, extension (stops at the first path separator or end)\n    );\n    const [proto, claimName, extensionSeperator, extension] = componentsRegex // eslint-disable-line no-unused-vars\n      .exec(name)\n      .map(match => match || null);\n\n    // Validate and process name\n    if (!claimName) {\n      throw new Error('Check your URL.  No claim name provided before \".\"');\n    }\n    const nameBadChars = (claimName).match(module.exports.REGEXP_INVALID_CLAIM);\n    if (nameBadChars) {\n      throw new Error(`Check your URL.  Invalid characters in claim name: \"${nameBadChars.join(', ')}\".`);\n    }\n    // Validate and process extension\n    if (extensionSeperator) {\n      if (!extension) {\n        throw new Error(`Check your URL.  No file extension provided after separator \"${extensionSeperator}\".`);\n      }\n      if (extensionSeperator !== '.') {\n        throw new Error(`Check your URL.  The \"${extensionSeperator}\" separator is not supported in the claim name.`);\n      }\n    }\n    return {\n      claimName,\n      extension: extension || null,\n    };\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./react/utils/lbryUri.js","const handlePageRender = require('../helpers/handlePageRender.jsx');\n\nmodule.exports = app => {\n  // a catch-all route if someone visits a page that does not exist\n  app.use('*', (req, res) => {\n    // send response\n    handlePageRender(req, res);\n  });\n};\n\n\n\n// WEBPACK FOOTER //\n// ./routes/fallback-routes.js"],"sourceRoot":""}
|