PageSourceSearch

https://onlyticket.com.my/Ticket/assets/js/nav-bundle2.js

js onlyticket.com.my collected 2026-10-06 18:07:23 UTC 17,151 bytes, 452 lines download raw bytes

vendor: 17,151 bytes, lines 1-452
1/*!
2Waypoints - 4.0.0
3Copyright © 2011-2015 Caleb Troughton
4Licensed under the MIT license.
5https://github.com/imakewebthings/waypoints/blog/master/licenses.txt
6*/
7!function () {
8    "use strict";
9    function t(o) {
10        if (!o)
11            throw new Error("No options passed to Waypoint constructor");
12        if (!o.element)
13            throw new Error("No element option passed to Waypoint constructor");
14        if (!o.handler)
15            throw new Error("No handler option passed to Waypoint constructor");
16        this.key = "waypoint-" + e,
17            this.options = t.Adapter.extend({}, t.defaults, o),
18            this.element = this.options.element,
19            this.adapter = new t.Adapter(this.element),
20            this.callback = o.handler,
21            this.axis = this.options.horizontal ? "horizontal" : "vertical",
22            this.enabled = this.options.enabled,
23            this.triggerPoint = null,
24            this.group = t.Group.findOrCreate({
25                name: this.options.group,
26                axis: this.axis
27            }),
28            this.context = t.Context.findOrCreateByElement(this.options.context),
29            t.offsetAliases[this.options.offset] && (this.options.offset = t.offsetAliases[this.options.offset]),
30            this.group.add(this),
31            this.context.add(this),
32            i[this.key] = this,
33            e += 1
34    }
35    var e = 0
36        , i = {};
37    t.prototype.queueTrigger = function (t) {
38        this.group.queueTrigger(this, t)
39    }
40        ,
41        t.prototype.trigger = function (t) {
42            this.enabled && this.callback && this.callback.apply(this, t)
43        }
44        ,
45        t.prototype.destroy = function () {
46            this.context.remove(this),
47                this.group.remove(this),
48                delete i[this.key]
49        }
50        ,
51        t.prototype.disable = function () {
52            return this.enabled = !1,
53                this
54        }
55        ,
56        t.prototype.enable = function () {
57            return this.context.refresh(),
58                this.enabled = !0,
59                this
60        }
61        ,
62        t.prototype.next = function () {
63            return this.group.next(this)
64        }
65        ,
66        t.prototype.previous = function () {
67            return this.group.previous(this)
68        }
69        ,
70        t.invokeAll = function (t) {
71            var e = [];
72            for (var o in i)
73                e.push(i[o]);
74            for (var n = 0, r = e.length; r > n; n++)
75                e[n][t]()
76        }
77        ,
78        t.destroyAll = function () {
79            t.invokeAll("destroy")
80        }
81        ,
82        t.disableAll = function () {
83            t.invokeAll("disable")
84        }
85        ,
86        t.enableAll = function () {
87            t.invokeAll("enable")
88        }
89        ,
90        t.refreshAll = function () {
91            t.Context.refreshAll()
92        }
93        ,
94        t.viewportHeight = function () {
95            return window.innerHeight || document.documentElement.clientHeight
96        }
97        ,
98        t.viewportWidth = function () {
99            return document.documentElement.clientWidth
100        }
101        ,
102        t.adapters = [],
103        t.defaults = {
104            context: window,
105            continuous: !0,
106            enabled: !0,
107            group: "default",
108            horizontal: !1,
109            offset: 0
110        },
111        t.offsetAliases = {
112            "bottom-in-view": function () {
113                return this.context.innerHeight() - this.adapter.outerHeight()
114            },
115            "right-in-view": function () {
116                return this.context.innerWidth() - this.adapter.outerWidth()
117            }
118        },
119        window.Waypoint = t
120}(),
121    function () {
122        "use strict";
123        function t(t) {
124            window.setTimeout(t, 1e3 / 60)
125        }
126        function e(t) {
127            this.element = t,
128                this.Adapter = n.Adapter,
129                this.adapter = new this.Adapter(t),
130                this.key = "waypoint-context-" + i,
131                this.didScroll = !1,
132                this.didResize = !1,
133                this.oldScroll = {
134                    x: this.adapter.scrollLeft(),
135                    y: this.adapter.scrollTop()
136                },
137                this.waypoints = {
138                    vertical: {},
139                    horizontal: {}
140                },
141                t.waypointContextKey = this.key,
142                o[t.waypointContextKey] = this,
143                i += 1,
144                this.createThrottledScrollHandler(),
145                this.createThrottledResizeHandler()
146        }
147        var i = 0
148            , o = {}
149            , n = window.Waypoint
150            , r = window.onload;
151        e.prototype.add = function (t) {
152            var e = t.options.horizontal ? "horizontal" : "vertical";
153            this.waypoints[e][t.key] = t,
154                this.refresh()
155        }
156            ,
157            e.prototype.checkEmpty = function () {
158                var t = this.Adapter.isEmptyObject(this.waypoints.horizontal)
159                    , e = this.Adapter.isEmptyObject(this.waypoints.vertical);
160                t && e && (this.adapter.off(".waypoints"),
161                    delete o[this.key])
162            }
163            ,
164            e.prototype.createThrottledResizeHandler = function () {
165                function t() {
166                    e.handleResize(),
167                        e.didResize = !1
168                }
169                var e = this;
170                this.adapter.on("resize.waypoints", function () {
171                    e.didResize || (e.didResize = !0,
172                        n.requestAnimationFrame(t))
173                })
174            }
175            ,
176            e.prototype.createThrottledScrollHandler = function () {
177                function t() {
178                    e.handleScroll(),
179                        e.didScroll = !1
180                }
181                var e = this;
182                this.adapter.on("scroll.waypoints", function () {
183                    (!e.didScroll || n.isTouch) && (e.didScroll = !0,
184                        n.requestAnimationFrame(t))
185                })
186            }
187            ,
188            e.prototype.handleResize = function () {
189                n.Context.refreshAll()
190            }
191            ,
192            e.prototype.handleScroll = function () {
193                var t = {}
194                    , e = {
195                        horizontal: {
196                            newScroll: this.adapter.scrollLeft(),
197                            oldScroll: this.oldScroll.x,
198                            forward: "right",
199                            backward: "left"
200                        },
201                        vertical: {
202                            newScroll: this.adapter.scrollTop(),
203                            oldScroll: this.oldScroll.y,
204                            forward: "down",
205                            backward: "up"
206                        }
207                    };
208                for (var i in e) {
209                    var o = e[i]
210                        , n = o.newScroll > o.oldScroll
211                        , r = n ? o.forward : o.backward;
212                    for (var s in this.waypoints[i]) {
213                        var a = this.waypoints[i][s]
214                            , l = o.oldScroll < a.triggerPoint
215                            , h = o.newScroll >= a.triggerPoint
216                            , p = l && h
217                            , u = !l && !h;
218                        (p || u) && (a.queueTrigger(r),
219                            t[a.group.id] = a.group)
220                    }
221                }
222                for (var c in t)
223                    t[c].flushTriggers();
224                this.oldScroll = {
225                    x: e.horizontal.newScroll,
226                    y: e.vertical.newScroll
227                }
228            }
229            ,
230            e.prototype.innerHeight = function () {
231                return this.element == this.element.window ? n.viewportHeight() : this.adapter.innerHeight()
232            }
233            ,
234            e.prototype.remove = function (t) {
235                delete this.waypoints[t.axis][t.key],
236                    this.checkEmpty()
237            }
238            ,
239            e.prototype.innerWidth = function () {
240                return this.element == this.element.window ? n.viewportWidth() : this.adapter.innerWidth()
241            }
242            ,
243            e.prototype.destroy = function () {
244                var t = [];
245                for (var e in this.waypoints)
246                    for (var i in this.waypoints[e])
247                        t.push(this.waypoints[e][i]);
248                for (var o = 0, n = t.length; n > o; o++)
249                    t[o].destroy()
250            }
251            ,
252            e.prototype.refresh = function () {
253                var t, e = this.element == this.element.window, i = e ? void 0 : this.adapter.offset(), o = {};
254                this.handleScroll(),
255                    t = {
256                        horizontal: {
257                            contextOffset: e ? 0 : i.left,
258                            contextScroll: e ? 0 : this.oldScroll.x,
259                            contextDimension: this.innerWidth(),
260                            oldScroll: this.oldScroll.x,
261                            forward: "right",
262                            backward: "left",
263                            offsetProp: "left"
264                        },
265                        vertical: {
266                            contextOffset: e ? 0 : i.top,
267                            contextScroll: e ? 0 : this.oldScroll.y,
268                            contextDimension: this.innerHeight(),
269                            oldScroll: this.oldScroll.y,
270                            forward: "down",
271                            backward: "up",
272                            offsetProp: "top"
273                        }
274                    };
275                for (var r in t) {
276                    var s = t[r];
277                    for (var a in this.waypoints[r]) {
278                        var l, h, p, u, c, d = this.waypoints[r][a], f = d.options.offset, w = d.triggerPoint, y = 0, g = null == w;
279                        d.element !== d.element.window && (y = d.adapter.offset()[s.offsetProp]),
280                            "function" == typeof f ? f = f.apply(d) : "string" == typeof f && (f = parseFloat(f),
281                                d.options.offset.indexOf("%") > -1 && (f = Math.ceil(s.contextDimension * f / 100))),
282                            l = s.contextScroll - s.contextOffset,
283                            d.triggerPoint = y + l - f,
284                            h = w < s.oldScroll,
285                            p = d.triggerPoint >= s.oldScroll,
286                            u = h && p,
287                            c = !h && !p,
288                            !g && u ? (d.queueTrigger(s.backward),
289                                o[d.group.id] = d.group) : !g && c ? (d.queueTrigger(s.forward),
290                                    o[d.group.id] = d.group) : g && s.oldScroll >= d.triggerPoint && (d.queueTrigger(s.forward),
291                                        o[d.group.id] = d.group)
292                    }
293                }
294                return n.requestAnimationFrame(function () {
295                    for (var t in o)
296                        o[t].flushTriggers()
297                }),
298                    this
299            }
300            ,
301            e.findOrCreateByElement = function (t) {
302                return e.findByElement(t) || new e(t)
303            }
304            ,
305            e.refreshAll = function () {
306                for (var t in o)
307                    o[t].refresh()
308            }
309            ,
310            e.findByElement = function (t) {
311                return o[t.waypointContextKey]
312            }
313            ,
314            window.onload = function () {
315                r && r(),
316                    e.refreshAll()
317            }
318            ,
319            n.requestAnimationFrame = function (e) {
320                var i = window.requestAnimationFrame || window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame || t;
321                i.call(window, e)
322            }
323            ,
324            n.Context = e
325    }(),
326    function () {
327        "use strict";
328        function t(t, e) {
329            return t.triggerPoint - e.triggerPoint
330        }
331        function e(t, e) {
332            return e.triggerPoint - t.triggerPoint
333        }
334        function i(t) {
335            this.name = t.name,
336                this.axis = t.axis,
337                this.id = this.name + "-" + this.axis,
338                this.waypoints = [],
339                this.clearTriggerQueues(),
340                o[this.axis][this.name] = this
341        }
342        var o = {
343            vertical: {},
344            horizontal: {}
345        }
346            , n = window.Waypoint;
347        i.prototype.add = function (t) {
348            this.waypoints.push(t)
349        }
350            ,
351            i.prototype.clearTriggerQueues = function () {
352                this.triggerQueues = {
353                    up: [],
354                    down: [],
355                    left: [],
356                    right: []
357                }
358            }
359            ,
360            i.prototype.flushTriggers = function () {
361                for (var i in this.triggerQueues) {
362                    var o = this.triggerQueues[i]
363                        , n = "up" === i || "left" === i;
364                    o.sort(n ? e : t);
365                    for (var r = 0, s = o.length; s > r; r += 1) {
366                        var a = o[r];
367                        (a.options.continuous || r === o.length - 1) && a.trigger([i])
368                    }
369                }
370                this.clearTriggerQueues()
371            }
372            ,
373            i.prototype.next = function (e) {
374                this.waypoints.sort(t);
375                var i = n.Adapter.inArray(e, this.waypoints)
376                    , o = i === this.waypoints.length - 1;
377                return o ? null : this.waypoints[i + 1]
378            }
379            ,
380            i.prototype.previous = function (e) {
381                this.waypoints.sort(t);
382                var i = n.Adapter.inArray(e, this.waypoints);
383                return i ? this.waypoints[i - 1] : null
384            }
385            ,
386            i.prototype.queueTrigger = function (t, e) {
387                this.triggerQueues[e].push(t)
388            }
389            ,
390            i.prototype.remove = function (t) {
391                var e = n.Adapter.inArray(t, this.waypoints);
392                e > -1 && this.waypoints.splice(e, 1)
393            }
394            ,
395            i.prototype.first = function () {
396                return this.waypoints[0]
397            }
398            ,
399            i.prototype.last = function () {
400                return this.waypoints[this.waypoints.length - 1]
401            }
402            ,
403            i.findOrCreate = function (t) {
404                return o[t.axis][t.name] || new i(t)
405            }
406            ,
407            n.Group = i
408    }(),
409    function () {
410        "use strict";
411        function t(t) {
412            this.$element = e(t)
413        }
414        var e = window.jQuery
415            , i = window.Waypoint;
416        e.each(["innerHeight", "innerWidth", "off", "offset", "on", "outerHeight", "outerWidth", "scrollLeft", "scrollTop"], function (e, i) {
417            t.prototype[i] = function () {
418                var t = Array.prototype.slice.call(arguments);
419                return this.$element[i].apply(this.$element, t)
420            }
421        }),
422            e.each(["extend", "inArray", "isEmptyObject"], function (i, o) {
423                t[o] = e[o]
424            }),
425            i.adapters.push({
426                name: "jquery",
427                Adapter: t
428            }),
429            i.Adapter = t
430    }(),
431    function () {
432        "use strict";
433        function t(t) {
434            return function () {
435                var i = []
436                    , o = arguments[0];
437                return t.isFunction(arguments[0]) && (o = t.extend({}, arguments[1]),
438                    o.handler = arguments[0]),
439                    this.each(function () {
440                        var n = t.extend({}, o, {
441                            element: this
442                        });
443                        "string" == typeof n.context && (n.context = t(this).closest(n.context)[0]),
444                            i.push(new e(n))
445                    }),
446                    i
447            }
448        }
449        var e = window.Waypoint;
450        window.jQuery && (window.jQuery.fn.waypoint = t(window.jQuery)),
451            window.Zepto && (window.Zepto.fn.waypoint = t(window.Zepto))
452    }();

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.