PageSourceSearch

https://www.aliyamumbaiescort.in/js/jquery_003.js

js aliyamumbaiescort.in collected 2026-09-26 13:26:05 UTC 15,019 bytes, 360 lines download raw bytes

1var _____WB$wombat$assign$function_____=function(name){return (self._wb_wombat && self._wb_wombat.local_init && self._wb_wombat.local_init(name))||self[name];};if(!self.__WB_pmw){self.__WB_pmw=function(obj){this.__WB_source=obj;return this;}}{
2let window = _____WB$wombat$assign$function_____("window");
3let self = _____WB$wombat$assign$function_____("self");
4let document = _____WB$wombat$assign$function_____("document");
5let location = _____WB$wombat$assign$function_____("location");
6let top = _____WB$wombat$assign$function_____("top");
7let parent = _____WB$wombat$assign$function_____("parent");
8let frames = _____WB$wombat$assign$function_____("frames");
9let opens = _____WB$wombat$assign$function_____("opens");
10/*
11 * File: jquery.flexisel.js
12 * Version: 1.0.2
13 * Description: Responsive carousel jQuery plugin
14 * Author: 9bit Studios
15 * Copyright 2012, 9bit Studios
16 * http://www.9bitstudios.com
17 * Free to use and abuse under the MIT license.
18 * http://www.opensource.org/licenses/mit-license.php
19 */
20(function ($) {
21    $.fn.flexisel = function(options) {
22	
23        var defaults = $.extend({
24            visibleItems : 4,
25            animationSpeed : 200,
26            autoPlay : false,
27            autoPlaySpeed : 3000,
28            pauseOnHover : true,
29            setMaxWidthAndHeight : false,
30            enableResponsiveBreakpoints : true,
31            flipPage: false,
32            clone : true,
33            responsiveBreakpoints : {
34                portrait: { 
35                    changePoint:480,
36                    visibleItems: 1
37                }, 
38                landscape: { 
39                    changePoint:640,
40                    visibleItems: 2
41                },
42                tablet: { 
43                    changePoint:768,
44                    visibleItems: 3
45                }
46            }
47        }, options);
48        
49        /******************************
50        Private Variables
51         *******************************/
52         
53        var object = $(this);
54        var settings = $.extend(defaults, options);
55        var itemsWidth; // Declare the global width of each item in carousel
56        var canNavigate = true;
57        var itemsVisible = settings.visibleItems; // Get visible items
58        var totalItems = object.children().length; // Get number of elements
59        var responsivePoints = [];
60        
61        /******************************
62        Public Methods
63        *******************************/
64        var methods = {
65            init : function() {
66                return this.each(function() {
67                    methods.appendHTML();
68                    methods.setEventHandlers();
69                    methods.initializeItems();
70                });
71            },
72		    
73            /******************************
74            Initialize Items
75            Fully initialize everything. Plugin is loaded and ready after finishing execution
76	    *******************************/
77            initializeItems : function() {
78
79                var listParent = object.parent();
80                var innerHeight = listParent.height();
81                var childSet = object.children();
82                methods.sortResponsiveObject(settings.responsiveBreakpoints);
83                
84                var innerWidth = listParent.width(); // Set widths
85                itemsWidth = (innerWidth) / itemsVisible;
86                childSet.width(itemsWidth);        
87                if (settings.clone) {
88                    childSet.last().insertBefore(childSet.first());
89                    childSet.last().insertBefore(childSet.first());
90                    object.css({
91                        'left' : -itemsWidth
92                    });
93                }
94
95                object.fadeIn();
96                $(window).trigger("resize"); // needed to position arrows correctly
97
98            },
99            
100	    /******************************
101            Append HTML
102            Add additional markup needed by plugin to the DOM
103	    *******************************/
104            appendHTML : function() {
105                object.addClass("nbs-flexisel-ul");
106                object.wrap("<div class='nbs-flexisel-container'><div class='nbs-flexisel-inner'></div></div>");
107                object.find("li").addClass("nbs-flexisel-item");
108
109                var flexiselInner = object.parent(); // flexisel-inner
110
111                if (settings.setMaxWidthAndHeight) {
112                    var baseWidth = $(".nbs-flexisel-item img").width();
113                    var baseHeight = $(".nbs-flexisel-item img").height();
114                    $(".nbs-flexisel-item img").css("max-width", baseWidth);
115                    $(".nbs-flexisel-item img").css("max-height", baseHeight);
116                }
117                $("<div class='nbs-flexisel-nav-left'></div><div class='nbs-flexisel-nav-right'></div>").insertAfter(flexiselInner);
118                if (settings.clone) {
119                    var cloneContent = object.children().clone();
120                    object.append(cloneContent);
121                }
122            },
123            /******************************
124            Set Event Handlers
125	    Set events: click, resize, etc
126            *******************************/
127            setEventHandlers : function() {
128
129                var listParent = object.parent();
130                var flexiselInner = listParent.parent();
131                var childSet = object.children();
132                var leftArrow = flexiselInner.find(".nbs-flexisel-nav-left");
133                var rightArrow = flexiselInner.find(".nbs-flexisel-nav-right");
134
135                $(window).on("resize", function(event) {
136
137                    methods.setResponsiveEvents();
138
139                    var innerWidth = $(listParent).width();
140                    var innerHeight = $(listParent).height();
141
142                    itemsWidth = (innerWidth) / itemsVisible;
143
144                    childSet.width(itemsWidth);
145                    if (settings.clone) {
146                        object.css({
147                            'left' : -itemsWidth                            
148                        });
149                    }else {
150                        object.css({
151                            'left' : 0
152                        });
153                    }
154
155                    // Hide the arrows if the elements are the same of the visible
156                    if (!settings.clone && totalItems <= itemsVisible) {
157                      leftArrow.add(rightArrow).css('visibility', 'hidden');
158                    }
159                    else {
160                      leftArrow.add(rightArrow).css('visibility', 'visible');
161
162                      var halfArrowHeight = (leftArrow.height()) / 2;
163                      var arrowMargin = (innerHeight / 2) - halfArrowHeight;
164                      leftArrow.css("top", arrowMargin + "px");
165                      rightArrow.css("top", arrowMargin + "px");
166                    }
167
168                });
169                $(leftArrow).on("click", function(event) {
170                    methods.scrollLeft();
171                });
172                $(rightArrow).on("click", function(event) {
173                    methods.scrollRight();
174                });
175                if (settings.pauseOnHover == true) {
176                    $(".nbs-flexisel-item").on({
177                        mouseenter : function() {
178                            canNavigate = false;
179                        },
180                        mouseleave : function() {
181                            canNavigate = true;
182                        }
183                    });
184                }
185                if (settings.autoPlay == true) {
186
187                    setInterval(function() {
188                        if (canNavigate == true)
189                            methods.scrollRight();
190                    }, settings.autoPlaySpeed);
191                }
192
193            },
194            /******************************
195            Set Responsive Events
196            Set breakpoints depending on responsiveBreakpoints
197            *******************************/            
198            
199            setResponsiveEvents: function() {
200                var contentWidth = $('html').width();
201                
202                if(settings.enableResponsiveBreakpoints) {
203                    
204                    var largestCustom = responsivePoints[responsivePoints.length-1].changePoint; // sorted array 
205                    
206                    for(var i in responsivePoints) {
207                        
208                        if(contentWidth >= largestCustom) { // set to default if width greater than largest custom responsiveBreakpoint 
209                            itemsVisible = settings.visibleItems;
210                            break;
211                        }
212                        else { // determine custom responsiveBreakpoint to use
213                        
214                            if(contentWidth < responsivePoints[i].changePoint) {
215                                itemsVisible = responsivePoints[i].visibleItems;
216                                break;
217                            }
218                            else
219                                continue;
220                        }
221                    }
222                }
223            },
224
225            /******************************
226            Sort Responsive Object
227            Gets all the settings in resposiveBreakpoints and sorts them into an array
228            *******************************/            
229            
230            sortResponsiveObject: function(obj) {
231                
232                var responsiveObjects = [];
233                
234                for(var i in obj) {
235                    responsiveObjects.push(obj[i]);
236                }
237                
238                responsiveObjects.sort(function(a, b) {
239                    return a.changePoint - b.changePoint;
240                });
241            
242                responsivePoints = responsiveObjects;
243            },
244            
245            /******************************
246            Scroll Left
247            *******************************/
248            scrollLeft : function() {
249                if (object.position().left < 0) {
250                    if (canNavigate == true) {
251                        canNavigate = false;
252
253                        var listParent = object.parent();
254                        var innerWidth = listParent.width();
255
256                        itemsWidth = (innerWidth) / itemsVisible;
257
258                        var childSet = object.children();
259			var increment = (settings.flipPage)? innerWidth: itemsWidth;
260			
261                        object.animate({
262                            'left' : "+=" + increment
263                        }, {
264                            queue : false,
265                            duration : settings.animationSpeed,
266                            easing : "linear",
267                            complete : function() {
268                                if (settings.clone) {
269                                    childSet.last().insertBefore(
270                                            childSet.first()); // Get the first list item and put it after the last list item (that's how the infinite effects is made)                                   
271                                }
272                                methods.adjustScroll();
273                                canNavigate = true;
274                            }
275                        });
276                    }
277                }
278            },
279            /******************************
280            Scroll Right
281            *******************************/            
282            scrollRight : function() {
283                var listParent = object.parent();
284                var innerWidth = listParent.width();
285
286                itemsWidth = (innerWidth) / itemsVisible;
287
288                var difObject = (itemsWidth - innerWidth);
289                var objPosition = (object.position().left + ((totalItems-itemsVisible)*itemsWidth)-innerWidth);    
290                
291                var increment = (settings.flipPage)? innerWidth: itemsWidth;
292                
293                if((difObject <= Math.ceil(objPosition)) && (!settings.clone)){
294                    if (canNavigate == true) {
295                        canNavigate = false;                    
296    
297                        object.animate({
298                            'left' : "-=" + increment
299                        }, {
300                            queue : false,
301                            duration : settings.animationSpeed,
302                            easing : "linear",
303                            complete : function() {                                
304                                methods.adjustScroll();
305                                canNavigate = true;
306                            }
307                        });
308                    }
309                } else if(settings.clone){
310                    if (canNavigate == true) {
311                        canNavigate = false;
312    
313                        var childSet = object.children();
314    
315                        object.animate({
316                            'left' : "-=" + increment
317                        }, {
318                            queue : false,
319                            duration : settings.animationSpeed,
320                            easing : "linear",
321                            complete : function() {                                
322                                    childSet.first().insertAfter(childSet.last()); // Get the first list item and put it after the last list item (that's how the infinite effects is made)                                
323                                methods.adjustScroll();
324                                canNavigate = true;
325                            }
326                        });
327                    }
328                };                
329            },
330            /******************************
331            Adjust Scroll 
332             *******************************/
333            adjustScroll : function() {
334                var listParent = object.parent();
335                var childSet = object.children();
336
337                var innerWidth = listParent.width();
338                itemsWidth = (innerWidth) / itemsVisible;
339                childSet.width(itemsWidth);
340                
341                var increment = (settings.flipPage)? innerWidth: itemsWidth;
342                
343                if (settings.clone) {
344                    object.css({
345                        'left' : -increment
346                    });
347                }
348            }
349        };
350        if (methods[options]) { // $("#element").pluginName('methodName', 'arg1', 'arg2');
351            return methods[options].apply(this, Array.prototype.slice.call(arguments, 1));
352        } else if (typeof options === 'object' || !options) { // $("#element").pluginName({ option: 1, option:2 });
353            return methods.init.apply(this);
354        } else {
355            $.error('Method "' + method + '" does not exist in flexisel plugin!');
356        }
357    };
358})(jQuery);
359
360}

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.