npm - @datagrok/helm - Versions diffs - 2.3.2 → 2.3.4 - Mend

@datagrok/helm 2.3.2 → 2.3.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (324) hide show

package/vendor/dojo-1.10.10/dijit/place.js.uncompressed.js ADDED Viewed

@@ -0,0 +1,407 @@
+define("dijit/place", [
+	"dojo/_base/array", // array.forEach array.map array.some
+	"dojo/dom-geometry", // domGeometry.position
+	"dojo/dom-style", // domStyle.getComputedStyle
+	"dojo/_base/kernel", // kernel.deprecated
+	"dojo/_base/window", // win.body
+	"./Viewport", // getEffectiveBox
+	"./main"	// dijit (defining dijit.place to match API doc)
+], function(array, domGeometry, domStyle, kernel, win, Viewport, dijit){
+	// module:
+	//		dijit/place
+	function _place(/*DomNode*/ node, choices, layoutNode, aroundNodeCoords){
+		// summary:
+		//		Given a list of spots to put node, put it at the first spot where it fits,
+		//		of if it doesn't fit anywhere then the place with the least overflow
+		// choices: Array
+		//		Array of elements like: {corner: 'TL', pos: {x: 10, y: 20} }
+		//		Above example says to put the top-left corner of the node at (10,20)
+		// layoutNode: Function(node, aroundNodeCorner, nodeCorner, size)
+		//		for things like tooltip, they are displayed differently (and have different dimensions)
+		//		based on their orientation relative to the parent.	 This adjusts the popup based on orientation.
+		//		It also passes in the available size for the popup, which is useful for tooltips to
+		//		tell them that their width is limited to a certain amount.	 layoutNode() may return a value expressing
+		//		how much the popup had to be modified to fit into the available space.	 This is used to determine
+		//		what the best placement is.
+		// aroundNodeCoords: Object
+		//		Size of aroundNode, ex: {w: 200, h: 50}
+		// get {x: 10, y: 10, w: 100, h:100} type obj representing position of
+		// viewport over document
+		var view = Viewport.getEffectiveBox(node.ownerDocument);
+		// This won't work if the node is inside a <div style="position: relative">,
+		// so reattach it to <body>.	 (Otherwise, the positioning will be wrong
+		// and also it might get cutoff.)
+		if(!node.parentNode || String(node.parentNode.tagName).toLowerCase() != "body"){
+			win.body(node.ownerDocument).appendChild(node);
+		}
+		var best = null;
+		array.some(choices, function(choice){
+			var corner = choice.corner;
+			var pos = choice.pos;
+			var overflow = 0;
+			// calculate amount of space available given specified position of node
+			var spaceAvailable = {
+				w: {
+					'L': view.l + view.w - pos.x,
+					'R': pos.x - view.l,
+					'M': view.w
+				}[corner.charAt(1)],
+				h: {
+					'T': view.t + view.h - pos.y,
+					'B': pos.y - view.t,
+					'M': view.h
+				}[corner.charAt(0)]
+			};
+			// Clear left/right position settings set earlier so they don't interfere with calculations,
+			// specifically when layoutNode() (a.k.a. Tooltip.orient()) measures natural width of Tooltip
+			var s = node.style;
+			s.left = s.right = "auto";
+			// configure node to be displayed in given position relative to button
+			// (need to do this in order to get an accurate size for the node, because
+			// a tooltip's size changes based on position, due to triangle)
+			if(layoutNode){
+				var res = layoutNode(node, choice.aroundCorner, corner, spaceAvailable, aroundNodeCoords);
+				overflow = typeof res == "undefined" ? 0 : res;
+			}
+			// get node's size
+			var style = node.style;
+			var oldDisplay = style.display;
+			var oldVis = style.visibility;
+			if(style.display == "none"){
+				style.visibility = "hidden";
+				style.display = "";
+			}
+			var bb = domGeometry.position(node);
+			style.display = oldDisplay;
+			style.visibility = oldVis;
+			// coordinates and size of node with specified corner placed at pos,
+			// and clipped by viewport
+			var
+				startXpos = {
+					'L': pos.x,
+					'R': pos.x - bb.w,
+					'M': Math.max(view.l, Math.min(view.l + view.w, pos.x + (bb.w >> 1)) - bb.w) // M orientation is more flexible
+				}[corner.charAt(1)],
+				startYpos = {
+					'T': pos.y,
+					'B': pos.y - bb.h,
+					'M': Math.max(view.t, Math.min(view.t + view.h, pos.y + (bb.h >> 1)) - bb.h)
+				}[corner.charAt(0)],
+				startX = Math.max(view.l, startXpos),
+				startY = Math.max(view.t, startYpos),
+				endX = Math.min(view.l + view.w, startXpos + bb.w),
+				endY = Math.min(view.t + view.h, startYpos + bb.h),
+				width = endX - startX,
+				height = endY - startY;
+			overflow += (bb.w - width) + (bb.h - height);
+			if(best == null || overflow < best.overflow){
+				best = {
+					corner: corner,
+					aroundCorner: choice.aroundCorner,
+					x: startX,
+					y: startY,
+					w: width,
+					h: height,
+					overflow: overflow,
+					spaceAvailable: spaceAvailable
+				};
+			}
+			return !overflow;
+		});
+		// In case the best position is not the last one we checked, need to call
+		// layoutNode() again.
+		if(best.overflow && layoutNode){
+			layoutNode(node, best.aroundCorner, best.corner, best.spaceAvailable, aroundNodeCoords);
+		}
+		// And then position the node.  Do this last, after the layoutNode() above
+		// has sized the node, due to browser quirks when the viewport is scrolled
+		// (specifically that a Tooltip will shrink to fit as though the window was
+		// scrolled to the left).
+		var top = best.y,
+			side = best.x,
+			body = win.body(node.ownerDocument);
+		if(/relative|absolute/.test(domStyle.get(body, "position"))){
+			// compensate for margin on <body>, see #16148
+			top -= domStyle.get(body, "marginTop");
+			side -= domStyle.get(body, "marginLeft");
+		}
+		var s = node.style;
+		s.top = top + "px";
+		s.left = side + "px";
+		s.right = "auto";	// needed for FF or else tooltip goes to far left
+		return best;
+	}
+	var reverse = {
+		// Map from corner to kitty-corner
+		"TL": "BR",
+		"TR": "BL",
+		"BL": "TR",
+		"BR": "TL"
+	};
+	var place = {
+		// summary:
+		//		Code to place a DOMNode relative to another DOMNode.
+		//		Load using require(["dijit/place"], function(place){ ... }).
+		at: function(node, pos, corners, padding, layoutNode){
+			// summary:
+			//		Positions node kitty-corner to the rectangle centered at (pos.x, pos.y) with width and height of
+			//		padding.x * 2 and padding.y * 2, or zero if padding not specified.  Picks first corner in corners[]
+			//		where node is fully visible, or the corner where it's most visible.
+			//
+			//		Node is assumed to be absolutely or relatively positioned.
+			// node: DOMNode
+			//		The node to position
+			// pos: dijit/place.__Position
+			//		Object like {x: 10, y: 20}
+			// corners: String[]
+			//		Array of Strings representing order to try corners of the node in, like ["TR", "BL"].
+			//		Possible values are:
+			//
+			//		- "BL" - bottom left
+			//		- "BR" - bottom right
+			//		- "TL" - top left
+			//		- "TR" - top right
+			// padding: dijit/place.__Position?
+			//		Optional param to set padding, to put some buffer around the element you want to position.
+			//		Defaults to zero.
+			// layoutNode: Function(node, aroundNodeCorner, nodeCorner)
+			//		For things like tooltip, they are displayed differently (and have different dimensions)
+			//		based on their orientation relative to the parent.  This adjusts the popup based on orientation.
+			// example:
+			//		Try to place node's top right corner at (10,20).
+			//		If that makes node go (partially) off screen, then try placing
+			//		bottom left corner at (10,20).
+			//	|	place(node, {x: 10, y: 20}, ["TR", "BL"])
+			var choices = array.map(corners, function(corner){
+				var c = {
+					corner: corner,
+					aroundCorner: reverse[corner],	// so TooltipDialog.orient() gets aroundCorner argument set
+					pos: {x: pos.x,y: pos.y}
+				};
+				if(padding){
+					c.pos.x += corner.charAt(1) == 'L' ? padding.x : -padding.x;
+					c.pos.y += corner.charAt(0) == 'T' ? padding.y : -padding.y;
+				}
+				return c;
+			});
+			return _place(node, choices, layoutNode);
+		},
+		around: function(
+			/*DomNode*/		node,
+			/*DomNode|dijit/place.__Rectangle*/ anchor,
+			/*String[]*/	positions,
+			/*Boolean*/		leftToRight,
+			/*Function?*/	layoutNode){
+			// summary:
+			//		Position node adjacent or kitty-corner to anchor
+			//		such that it's fully visible in viewport.
+			// description:
+			//		Place node such that corner of node touches a corner of
+			//		aroundNode, and that node is fully visible.
+			// anchor:
+			//		Either a DOMNode or a rectangle (object with x, y, width, height).
+			// positions:
+			//		Ordered list of positions to try matching up.
+			//
+			//		- before: places drop down to the left of the anchor node/widget, or to the right in the case
+			//			of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down
+			//			with the top of the anchor, or the bottom of the drop down with bottom of the anchor.
+			//		- after: places drop down to the right of the anchor node/widget, or to the left in the case
+			//			of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down
+			//			with the top of the anchor, or the bottom of the drop down with bottom of the anchor.
+			//		- before-centered: centers drop down to the left of the anchor node/widget, or to the right
+			//			in the case of RTL scripts like Hebrew and Arabic
+			//		- after-centered: centers drop down to the right of the anchor node/widget, or to the left
+			//			in the case of RTL scripts like Hebrew and Arabic
+			//		- above-centered: drop down is centered above anchor node
+			//		- above: drop down goes above anchor node, left sides aligned
+			//		- above-alt: drop down goes above anchor node, right sides aligned
+			//		- below-centered: drop down is centered above anchor node
+			//		- below: drop down goes below anchor node
+			//		- below-alt: drop down goes below anchor node, right sides aligned
+			// layoutNode: Function(node, aroundNodeCorner, nodeCorner)
+			//		For things like tooltip, they are displayed differently (and have different dimensions)
+			//		based on their orientation relative to the parent.	 This adjusts the popup based on orientation.
+			// leftToRight:
+			//		True if widget is LTR, false if widget is RTL.   Affects the behavior of "above" and "below"
+			//		positions slightly.
+			// example:
+			//	|	placeAroundNode(node, aroundNode, {'BL':'TL', 'TR':'BR'});
+			//		This will try to position node such that node's top-left corner is at the same position
+			//		as the bottom left corner of the aroundNode (ie, put node below
+			//		aroundNode, with left edges aligned).	If that fails it will try to put
+			//		the bottom-right corner of node where the top right corner of aroundNode is
+			//		(ie, put node above aroundNode, with right edges aligned)
+			//
+			// If around is a DOMNode (or DOMNode id), convert to coordinates.
+			var aroundNodePos;
+			if(typeof anchor == "string" || "offsetWidth" in anchor || "ownerSVGElement" in anchor){
+				aroundNodePos = domGeometry.position(anchor, true);
+				// For above and below dropdowns, subtract width of border so that popup and aroundNode borders
+				// overlap, preventing a double-border effect.  Unfortunately, difficult to measure the border
+				// width of either anchor or popup because in both cases the border may be on an inner node.
+				if(/^(above|below)/.test(positions[0])){
+					var anchorBorder = domGeometry.getBorderExtents(anchor),
+						anchorChildBorder = anchor.firstChild ? domGeometry.getBorderExtents(anchor.firstChild) : {t:0,l:0,b:0,r:0},
+						nodeBorder =  domGeometry.getBorderExtents(node),
+						nodeChildBorder = node.firstChild ? domGeometry.getBorderExtents(node.firstChild) : {t:0,l:0,b:0,r:0};
+					aroundNodePos.y += Math.min(anchorBorder.t + anchorChildBorder.t, nodeBorder.t + nodeChildBorder.t);
+					aroundNodePos.h -=  Math.min(anchorBorder.t + anchorChildBorder.t, nodeBorder.t+ nodeChildBorder.t) +
+						Math.min(anchorBorder.b + anchorChildBorder.b, nodeBorder.b + nodeChildBorder.b);
+				}
+			}else{
+				aroundNodePos = anchor;
+			}
+			// Compute position and size of visible part of anchor (it may be partially hidden by ancestor nodes w/scrollbars)
+			if(anchor.parentNode){
+				// ignore nodes between position:relative and position:absolute
+				var sawPosAbsolute = domStyle.getComputedStyle(anchor).position == "absolute";
+				var parent = anchor.parentNode;
+				while(parent && parent.nodeType == 1 && parent.nodeName != "BODY"){  //ignoring the body will help performance
+					var parentPos = domGeometry.position(parent, true),
+						pcs = domStyle.getComputedStyle(parent);
+					if(/relative|absolute/.test(pcs.position)){
+						sawPosAbsolute = false;
+					}
+					if(!sawPosAbsolute && /hidden|auto|scroll/.test(pcs.overflow)){
+						var bottomYCoord = Math.min(aroundNodePos.y + aroundNodePos.h, parentPos.y + parentPos.h);
+						var rightXCoord = Math.min(aroundNodePos.x + aroundNodePos.w, parentPos.x + parentPos.w);
+						aroundNodePos.x = Math.max(aroundNodePos.x, parentPos.x);
+						aroundNodePos.y = Math.max(aroundNodePos.y, parentPos.y);
+						aroundNodePos.h = bottomYCoord - aroundNodePos.y;
+						aroundNodePos.w = rightXCoord - aroundNodePos.x;
+					}
+					if(pcs.position == "absolute"){
+						sawPosAbsolute = true;
+					}
+					parent = parent.parentNode;
+				}
+			}
+			var x = aroundNodePos.x,
+				y = aroundNodePos.y,
+				width = "w" in aroundNodePos ? aroundNodePos.w : (aroundNodePos.w = aroundNodePos.width),
+				height = "h" in aroundNodePos ? aroundNodePos.h : (kernel.deprecated("place.around: dijit/place.__Rectangle: { x:"+x+", y:"+y+", height:"+aroundNodePos.height+", width:"+width+" } has been deprecated.  Please use { x:"+x+", y:"+y+", h:"+aroundNodePos.height+", w:"+width+" }", "", "2.0"), aroundNodePos.h = aroundNodePos.height);
+			// Convert positions arguments into choices argument for _place()
+			var choices = [];
+			function push(aroundCorner, corner){
+				choices.push({
+					aroundCorner: aroundCorner,
+					corner: corner,
+					pos: {
+						x: {
+							'L': x,
+							'R': x + width,
+							'M': x + (width >> 1)
+						}[aroundCorner.charAt(1)],
+						y: {
+							'T': y,
+							'B': y + height,
+							'M': y + (height >> 1)
+						}[aroundCorner.charAt(0)]
+					}
+				})
+			}
+			array.forEach(positions, function(pos){
+				var ltr =  leftToRight;
+				switch(pos){
+					case "above-centered":
+						push("TM", "BM");
+						break;
+					case "below-centered":
+						push("BM", "TM");
+						break;
+					case "after-centered":
+						ltr = !ltr;
+						// fall through
+					case "before-centered":
+						push(ltr ? "ML" : "MR", ltr ? "MR" : "ML");
+						break;
+					case "after":
+						ltr = !ltr;
+						// fall through
+					case "before":
+						push(ltr ? "TL" : "TR", ltr ? "TR" : "TL");
+						push(ltr ? "BL" : "BR", ltr ? "BR" : "BL");
+						break;
+					case "below-alt":
+						ltr = !ltr;
+						// fall through
+					case "below":
+						// first try to align left borders, next try to align right borders (or reverse for RTL mode)
+						push(ltr ? "BL" : "BR", ltr ? "TL" : "TR");
+						push(ltr ? "BR" : "BL", ltr ? "TR" : "TL");
+						break;
+					case "above-alt":
+						ltr = !ltr;
+						// fall through
+					case "above":
+						// first try to align left borders, next try to align right borders (or reverse for RTL mode)
+						push(ltr ? "TL" : "TR", ltr ? "BL" : "BR");
+						push(ltr ? "TR" : "TL", ltr ? "BR" : "BL");
+						break;
+					default:
+						// To assist dijit/_base/place, accept arguments of type {aroundCorner: "BL", corner: "TL"}.
+						// Not meant to be used directly.  Remove for 2.0.
+						push(pos.aroundCorner, pos.corner);
+				}
+			});
+			var position = _place(node, choices, layoutNode, {w: width, h: height});
+			position.aroundNodePos = aroundNodePos;
+			return position;
+		}
+	};
+	/*=====
+	place.__Position = {
+		// x: Integer
+		//		horizontal coordinate in pixels, relative to document body
+		// y: Integer
+		//		vertical coordinate in pixels, relative to document body
+	};
+	place.__Rectangle = {
+		// x: Integer
+		//		horizontal offset in pixels, relative to document body
+		// y: Integer
+		//		vertical offset in pixels, relative to document body
+		// w: Integer
+		//		width in pixels.   Can also be specified as "width" for backwards-compatibility.
+		// h: Integer
+		//		height in pixels.   Can also be specified as "height" for backwards-compatibility.
+	};
+	=====*/
+	return dijit.place = place;	// setting dijit.place for back-compat, remove for 2.0
+});

package/vendor/dojo-1.10.10/dijit/popup.js ADDED Viewed

@@ -0,0 +1,162 @@
+//>>built
+define("dijit/popup",["dojo/_base/array","dojo/aspect","dojo/_base/declare","dojo/dom","dojo/dom-attr","dojo/dom-construct","dojo/dom-geometry","dojo/dom-style","dojo/has","dojo/keys","dojo/_base/lang","dojo/on","./place","./BackgroundIframe","./Viewport","./main","dojo/touch"],function(_1,_2,_3,_4,_5,_6,_7,_8,_9,_a,_b,on,_c,_d,_e,_f){
+function _10(){
+if(this._popupWrapper){
+_6.destroy(this._popupWrapper);
+delete this._popupWrapper;
+}
+};
+var _11=_3(null,{_stack:[],_beginZIndex:1000,_idGen:1,_repositionAll:function(){
+if(this._firstAroundNode){
+var _12=this._firstAroundPosition,_13=_7.position(this._firstAroundNode,true),dx=_13.x-_12.x,dy=_13.y-_12.y;
+if(dx||dy){
+this._firstAroundPosition=_13;
+for(var i=0;i<this._stack.length;i++){
+var _14=this._stack[i].wrapper.style;
+_14.top=(parseFloat(_14.top)+dy)+"px";
+if(_14.right=="auto"){
+_14.left=(parseFloat(_14.left)+dx)+"px";
+}else{
+_14.right=(parseFloat(_14.right)-dx)+"px";
+}
+}
+}
+this._aroundMoveListener=setTimeout(_b.hitch(this,"_repositionAll"),dx||dy?10:50);
+}
+},_createWrapper:function(_15){
+var _16=_15._popupWrapper,_17=_15.domNode;
+if(!_16){
+_16=_6.create("div",{"class":"dijitPopup",style:{display:"none"},role:"region","aria-label":_15["aria-label"]||_15.label||_15.name||_15.id},_15.ownerDocumentBody);
+_16.appendChild(_17);
+var s=_17.style;
+s.display="";
+s.visibility="";
+s.position="";
+s.top="0px";
+_15._popupWrapper=_16;
+_2.after(_15,"destroy",_10,true);
+if("ontouchend" in document){
+on(_16,"touchend",function(evt){
+if(!/^(input|button|textarea)$/i.test(evt.target.tagName)){
+evt.preventDefault();
+}
+});
+}
+_16.dojoClick=true;
+}
+return _16;
+},moveOffScreen:function(_18){
+var _19=this._createWrapper(_18);
+var ltr=_7.isBodyLtr(_18.ownerDocument),_1a={visibility:"hidden",top:"-9999px",display:""};
+_1a[ltr?"left":"right"]="-9999px";
+_1a[ltr?"right":"left"]="auto";
+_8.set(_19,_1a);
+return _19;
+},hide:function(_1b){
+var _1c=this._createWrapper(_1b);
+_8.set(_1c,{display:"none",height:"auto",overflowY:"visible",border:""});
+var _1d=_1b.domNode;
+if("_originalStyle" in _1d){
+_1d.style.cssText=_1d._originalStyle;
+}
+},getTopPopup:function(){
+var _1e=this._stack;
+for(var pi=_1e.length-1;pi>0&&_1e[pi].parent===_1e[pi-1].widget;pi--){
+}
+return _1e[pi];
+},open:function(_1f){
+var _20=this._stack,_21=_1f.popup,_22=_21.domNode,_23=_1f.orient||["below","below-alt","above","above-alt"],ltr=_1f.parent?_1f.parent.isLeftToRight():_7.isBodyLtr(_21.ownerDocument),_24=_1f.around,id=(_1f.around&&_1f.around.id)?(_1f.around.id+"_dropdown"):("popup_"+this._idGen++);
+while(_20.length&&(!_1f.parent||!_4.isDescendant(_1f.parent.domNode,_20[_20.length-1].widget.domNode))){
+this.close(_20[_20.length-1].widget);
+}
+var _25=this.moveOffScreen(_21);
+if(_21.startup&&!_21._started){
+_21.startup();
+}
+var _26,_27=_7.position(_22);
+if("maxHeight" in _1f&&_1f.maxHeight!=-1){
+_26=_1f.maxHeight||Infinity;
+}else{
+var _28=_e.getEffectiveBox(this.ownerDocument),_29=_24?_7.position(_24,false):{y:_1f.y-(_1f.padding||0),h:(_1f.padding||0)*2};
+_26=Math.floor(Math.max(_29.y,_28.h-(_29.y+_29.h)));
+}
+if(_27.h>_26){
+var cs=_8.getComputedStyle(_22),_2a=cs.borderLeftWidth+" "+cs.borderLeftStyle+" "+cs.borderLeftColor;
+_8.set(_25,{overflowY:"scroll",height:_26+"px",border:_2a});
+_22._originalStyle=_22.style.cssText;
+_22.style.border="none";
+}
+_5.set(_25,{id:id,style:{zIndex:this._beginZIndex+_20.length},"class":"dijitPopup "+(_21.baseClass||_21["class"]||"").split(" ")[0]+"Popup",dijitPopupParent:_1f.parent?_1f.parent.id:""});
+if(_20.length==0&&_24){
+this._firstAroundNode=_24;
+this._firstAroundPosition=_7.position(_24,true);
+this._aroundMoveListener=setTimeout(_b.hitch(this,"_repositionAll"),50);
+}
+if(_9("config-bgIframe")&&!_21.bgIframe){
+_21.bgIframe=new _d(_25);
+}
+var _2b=_21.orient?_b.hitch(_21,"orient"):null,_2c=_24?_c.around(_25,_24,_23,ltr,_2b):_c.at(_25,_1f,_23=="R"?["TR","BR","TL","BL"]:["TL","BL","TR","BR"],_1f.padding,_2b);
+_25.style.visibility="visible";
+_22.style.visibility="visible";
+var _2d=[];
+_2d.push(on(_25,"keydown",_b.hitch(this,function(evt){
+if(evt.keyCode==_a.ESCAPE&&_1f.onCancel){
+evt.stopPropagation();
+evt.preventDefault();
+_1f.onCancel();
+}else{
+if(evt.keyCode==_a.TAB){
+evt.stopPropagation();
+evt.preventDefault();
+var _2e=this.getTopPopup();
+if(_2e&&_2e.onCancel){
+_2e.onCancel();
+}
+}
+}
+})));
+if(_21.onCancel&&_1f.onCancel){
+_2d.push(_21.on("cancel",_1f.onCancel));
+}
+_2d.push(_21.on(_21.onExecute?"execute":"change",_b.hitch(this,function(){
+var _2f=this.getTopPopup();
+if(_2f&&_2f.onExecute){
+_2f.onExecute();
+}
+})));
+_20.push({widget:_21,wrapper:_25,parent:_1f.parent,onExecute:_1f.onExecute,onCancel:_1f.onCancel,onClose:_1f.onClose,handlers:_2d});
+if(_21.onOpen){
+_21.onOpen(_2c);
+}
+return _2c;
+},close:function(_30){
+var _31=this._stack;
+while((_30&&_1.some(_31,function(_32){
+return _32.widget==_30;
+}))||(!_30&&_31.length)){
+var top=_31.pop(),_33=top.widget,_34=top.onClose;
+if(_33.bgIframe){
+_33.bgIframe.destroy();
+delete _33.bgIframe;
+}
+if(_33.onClose){
+_33.onClose();
+}
+var h;
+while(h=top.handlers.pop()){
+h.remove();
+}
+if(_33&&_33.domNode){
+this.hide(_33);
+}
+if(_34){
+_34();
+}
+}
+if(_31.length==0&&this._aroundMoveListener){
+clearTimeout(this._aroundMoveListener);
+this._firstAroundNode=this._firstAroundPosition=this._aroundMoveListener=null;
+}
+}});
+return (_f.popup=new _11());
+});