PageSourceSearch

https://crazymoto.pro/wp-content/themes/keymoto/assets/js/vendors-libs/gmap3.js?ver=7.1.3

js crazymoto.pro collected 2026-10-08 14:47:32 UTC 66,513 bytes, 2,143 lines download raw bytes

1/*!
2 *  GMAP3 Plugin for JQuery
3 *  Version   : 5.1.1
4 *  Date      : 2013-05-25
5 *  Licence   : GPL v3 : http://www.gnu.org/licenses/gpl.html
6 *  Author    : DEMONTE Jean-Baptiste
7 *  Contact   : [email protected]
8 *  Web site  : http://gmap3.net
9 */
10(function(y, t) {
11    var z, i = 0;
12
13    function J() {
14        if (!z) {
15            z = {
16                verbose: false,
17                queryLimit: {
18                    attempt: 5,
19                    delay: 250,
20                    random: 250
21                },
22                classes: {
23                    Map: google.maps.Map,
24                    Marker: google.maps.Marker,
25                    InfoWindow: google.maps.InfoWindow,
26                    Circle: google.maps.Circle,
27                    Rectangle: google.maps.Rectangle,
28                    OverlayView: google.maps.OverlayView,
29                    StreetViewPanorama: google.maps.StreetViewPanorama,
30                    KmlLayer: google.maps.KmlLayer,
31                    TrafficLayer: google.maps.TrafficLayer,
32                    BicyclingLayer: google.maps.BicyclingLayer,
33                    GroundOverlay: google.maps.GroundOverlay,
34                    StyledMapType: google.maps.StyledMapType,
35                    ImageMapType: google.maps.ImageMapType
36                },
37                map: {
38                    mapTypeId: google.maps.MapTypeId.ROADMAP,
39                    center: [46.578498, 2.457275],
40                    zoom: 2
41                },
42                overlay: {
43                    pane: "floatPane",
44                    content: "",
45                    offset: {
46                        x: 0,
47                        y: 0
48                    }
49                },
50                geoloc: {
51                    getCurrentPosition: {
52                        maximumAge: 60000,
53                        timeout: 5000
54                    }
55                }
56            }
57        }
58    }
59
60    function k(M, L) {
61        return M !== t ? M : "gmap3_" + (L ? i + 1 : ++i)
62    }
63
64    function d(L) {
65        var O = function(P) {
66                return parseInt(P, 10)
67            },
68            N = google.maps.version.split(".").map(O),
69            M;
70        L = L.split(".").map(O);
71        for (M = 0; M < L.length; M++) {
72            if (N.hasOwnProperty(M)) {
73                if (N[M] < L[M]) {
74                    return false
75                }
76            } else {
77                return false
78            }
79        }
80        return true
81    }
82
83    function n(P, L, N, Q, O) {
84        if (L.todo.events || L.todo.onces) {
85            var M = {
86                id: Q,
87                data: L.todo.data,
88                tag: L.todo.tag
89            };
90            if (L.todo.events) {
91                y.each(L.todo.events, function(R, U) {
92                    var T = P,
93                        S = U;
94                    if (y.isArray(U)) {
95                        T = U[0];
96                        S = U[1]
97                    }
98                    google.maps.event.addListener(N, R, function(V) {
99                        S.apply(T, [O ? O : N, V, M])
100                    })
101                })
102            }
103            if (L.todo.onces) {
104                y.each(L.todo.onces, function(R, U) {
105                    var T = P,
106                        S = U;
107                    if (y.isArray(U)) {
108                        T = U[0];
109                        S = U[1]
110                    }
111                    google.maps.event.addListenerOnce(N, R, function(V) {
112                        S.apply(T, [O ? O : N, V, M])
113                    })
114                })
115            }
116        }
117    }
118
119    function l() {
120        var L = [];
121        this.empty = function() {
122            return !L.length
123        };
124        this.add = function(M) {
125            L.push(M)
126        };
127        this.get = function() {
128            return L.length ? L[0] : false
129        };
130        this.ack = function() {
131            L.shift()
132        }
133    }
134
135    function w(T, L, N) {
136        var R = {},
137            P = this,
138            Q, S = {
139                latLng: {
140                    map: false,
141                    marker: false,
142                    infowindow: false,
143                    circle: false,
144                    overlay: false,
145                    getlatlng: false,
146                    getmaxzoom: false,
147                    getelevation: false,
148                    streetviewpanorama: false,
149                    getaddress: true
150                },
151                geoloc: {
152                    getgeoloc: true
153                }
154            };
155        if (typeof N === "string") {
156            N = M(N)
157        }
158
159        function M(V) {
160            var U = {};
161            U[V] = {};
162            return U
163        }
164
165        function O() {
166            var U;
167            for (U in N) {
168                if (U in R) {
169                    continue
170                }
171                return U
172            }
173        }
174        this.run = function() {
175            var U, V;
176            while (U = O()) {
177                if (typeof T[U] === "function") {
178                    Q = U;
179                    V = y.extend(true, {}, z[U] || {}, N[U].options || {});
180                    if (U in S.latLng) {
181                        if (N[U].values) {
182                            x(N[U].values, T, T[U], {
183                                todo: N[U],
184                                opts: V,
185                                session: R
186                            })
187                        } else {
188                            v(T, T[U], S.latLng[U], {
189                                todo: N[U],
190                                opts: V,
191                                session: R
192                            })
193                        }
194                    } else {
195                        if (U in S.geoloc) {
196                            o(T, T[U], {
197                                todo: N[U],
198                                opts: V,
199                                session: R
200                            })
201                        } else {
202                            T[U].apply(T, [{
203                                todo: N[U],
204                                opts: V,
205                                session: R
206                            }])
207                        }
208                    }
209                    return
210                } else {
211                    R[U] = null
212                }
213            }
214            L.apply(T, [N, R])
215        };
216        this.ack = function(U) {
217            R[Q] = U;
218            P.run.apply(P, [])
219        }
220    }
221
222    function c(N) {
223        var L, M = [];
224        for (L in N) {
225            M.push(L)
226        }
227        return M
228    }
229
230    function b(N, Q) {
231        var L = {};
232        if (N.todo) {
233            for (var M in N.todo) {
234                if ((M !== "options") && (M !== "values")) {
235                    L[M] = N.todo[M]
236                }
237            }
238        }
239        var O, P = ["data", "tag", "id", "events", "onces"];
240        for (O = 0; O < P.length; O++) {
241            A(L, P[O], Q, N.todo)
242        }
243        L.options = y.extend({}, N.opts || {}, Q.options || {});
244        return L
245    }
246
247    function A(N, M) {
248        for (var L = 2; L < arguments.length; L++) {
249            if (M in arguments[L]) {
250                N[M] = arguments[L][M];
251                return
252            }
253        }
254    }
255
256    function r() {
257        var L = [];
258        this.get = function(S) {
259            if (L.length) {
260                var P, O, N, R, M, Q = c(S);
261                for (P = 0; P < L.length; P++) {
262                    R = L[P];
263                    M = Q.length == R.keys.length;
264                    for (O = 0;
265                         (O < Q.length) && M; O++) {
266                        N = Q[O];
267                        M = N in R.request;
268                        if (M) {
269                            if ((typeof S[N] === "object") && ("equals" in S[N]) && (typeof S[N] === "function")) {
270                                M = S[N].equals(R.request[N])
271                            } else {
272                                M = S[N] === R.request[N]
273                            }
274                        }
275                    }
276                    if (M) {
277                        return R.results
278                    }
279                }
280            }
281        };
282        this.store = function(N, M) {
283            L.push({
284                request: N,
285                keys: c(N),
286                results: M
287            })
288        }
289    }
290
291    function e(Q, P, O, L) {
292        var N = this,
293            M = [];
294        z.classes.OverlayView.call(this);
295        this.setMap(Q);
296        this.onAdd = function() {
297            var R = this.getPanes();
298            if (P.pane in R) {
299                y(R[P.pane]).append(L)
300            }
301            y.each("dblclick click mouseover mousemove mouseout mouseup mousedown".split(" "), function(T, S) {
302                M.push(google.maps.event.addDomListener(L[0], S, function(U) {
303                    y.Event(U).stopPropagation();
304                    google.maps.event.trigger(N, S, [U]);
305                    N.draw()
306                }))
307            });
308            M.push(google.maps.event.addDomListener(L[0], "contextmenu", function(S) {
309                y.Event(S).stopPropagation();
310                google.maps.event.trigger(N, "rightclick", [S]);
311                N.draw()
312            }))
313        };
314        this.getPosition = function() {
315            return O
316        };
317        this.draw = function() {
318            var R = this.getProjection().fromLatLngToDivPixel(O);
319            L.css("left", (R.x + P.offset.x) + "px").css("top", (R.y + P.offset.y) + "px")
320        };
321        this.onRemove = function() {
322            for (var R = 0; R < M.length; R++) {
323                google.maps.event.removeListener(M[R])
324            }
325            L.remove()
326        };
327        this.hide = function() {
328            L.hide()
329        };
330        this.show = function() {
331            L.show()
332        };
333        this.toggle = function() {
334            if (L) {
335                if (L.is(":visible")) {
336                    this.show()
337                } else {
338                    this.hide()
339                }
340            }
341        };
342        this.toggleDOM = function() {
343            if (this.getMap()) {
344                this.setMap(null)
345            } else {
346                this.setMap(Q)
347            }
348        };
349        this.getDOMElement = function() {
350            return L[0]
351        }
352    }
353
354    function f(O, L) {
355        function M() {
356            this.onAdd = function() {};
357            this.onRemove = function() {};
358            this.draw = function() {};
359            return z.classes.OverlayView.apply(this, [])
360        }
361        M.prototype = z.classes.OverlayView.prototype;
362        var N = new M();
363        N.setMap(O);
364        return N
365    }
366
367    function F(ae, ao, aa) {
368        var an = false,
369            ai = false,
370            af = false,
371            Z = false,
372            W = true,
373            V = this,
374            N = [],
375            T = {},
376            ad = {},
377            U = {},
378            aj = [],
379            ah = [],
380            O = [],
381            ak = f(ao, aa.radius),
382            Y, ap, am, P, Q;
383        S();
384
385        function L(aq) {
386            if (!aj[aq]) {
387                delete ah[aq].options.map;
388                aj[aq] = new z.classes.Marker(ah[aq].options);
389                n(ae, {
390                    todo: ah[aq]
391                }, aj[aq], ah[aq].id)
392            }
393        }
394        this.getById = function(aq) {
395            if (aq in ad) {
396                L(ad[aq]);
397                return aj[ad[aq]]
398            }
399            return false
400        };
401        this.rm = function(ar) {
402            var aq = ad[ar];
403            if (aj[aq]) {
404                aj[aq].setMap(null)
405            }
406            delete aj[aq];
407            aj[aq] = false;
408            delete ah[aq];
409            ah[aq] = false;
410            delete O[aq];
411            O[aq] = false;
412            delete ad[ar];
413            delete U[aq];
414            ai = true
415        };
416        this.clearById = function(aq) {
417            if (aq in ad) {
418                this.rm(aq);
419                return true
420            }
421        };
422        this.clear = function(az, av, aA) {
423            var ar, ay, at, aw, au, ax = [],
424                aq = C(aA);
425            if (az) {
426                ar = ah.length - 1;
427                ay = -1;
428                at = -1
429            } else {
430                ar = 0;
431                ay = ah.length;
432                at = 1
433            }
434            for (aw = ar; aw != ay; aw += at) {
435                if (ah[aw]) {
436                    if (!aq || aq(ah[aw].tag)) {
437                        ax.push(U[aw]);
438                        if (av || az) {
439                            break
440                        }
441                    }
442                }
443            }
444            for (au = 0; au < ax.length; au++) {
445                this.rm(ax[au])
446            }
447        };
448        this.add = function(aq, ar) {
449            aq.id = k(aq.id);
450            this.clearById(aq.id);
451            ad[aq.id] = aj.length;
452            U[aj.length] = aq.id;
453            aj.push(null);
454            ah.push(aq);
455            O.push(ar);
456            ai = true
457        };
458        this.addMarker = function(ar, aq) {
459            aq = aq || {};
460            aq.id = k(aq.id);
461            this.clearById(aq.id);
462            if (!aq.options) {
463                aq.options = {}
464            }
465            aq.options.position = ar.getPosition();
466            n(ae, {
467                todo: aq
468            }, ar, aq.id);
469            ad[aq.id] = aj.length;
470            U[aj.length] = aq.id;
471            aj.push(ar);
472            ah.push(aq);
473            O.push(aq.data || {});
474            ai = true
475        };
476        this.todo = function(aq) {
477            return ah[aq]
478        };
479        this.value = function(aq) {
480            return O[aq]
481        };
482        this.marker = function(aq) {
483            if (aq in aj) {
484                L(aq);
485                return aj[aq]
486            }
487            return false
488        };
489        this.markerIsSet = function(aq) {
490            return Boolean(aj[aq])
491        };
492        this.setMarker = function(ar, aq) {
493            aj[ar] = aq
494        };
495        this.store = function(aq, ar, at) {
496            T[aq.ref] = {
497                obj: ar,
498                shadow: at
499            }
500        };
501        this.free = function() {
502            for (var aq = 0; aq < N.length; aq++) {
503                google.maps.event.removeListener(N[aq])
504            }
505            N = [];
506            y.each(T, function(ar) {
507                ac(ar)
508            });
509            T = {};
510            y.each(ah, function(ar) {
511                ah[ar] = null
512            });
513            ah = [];
514            y.each(aj, function(ar) {
515                if (aj[ar]) {
516                    aj[ar].setMap(null);
517                    delete aj[ar]
518                }
519            });
520            aj = [];
521            y.each(O, function(ar) {
522                delete O[ar]
523            });
524            O = [];
525            ad = {};
526            U = {}
527        };
528        this.filter = function(aq) {
529            am = aq;
530            ag()
531        };
532        this.enable = function(aq) {
533            if (W != aq) {
534                W = aq;
535                ag()
536            }
537        };
538        this.display = function(aq) {
539            P = aq
540        };
541        this.error = function(aq) {
542            Q = aq
543        };
544        this.beginUpdate = function() {
545            an = true
546        };
547        this.endUpdate = function() {
548            an = false;
549            if (ai) {
550                ag()
551            }
552        };
553        this.autofit = function(ar) {
554            for (var aq = 0; aq < ah.length; aq++) {
555                if (ah[aq]) {
556                    ar.extend(ah[aq].options.position)
557                }
558            }
559        };
560
561        function S() {
562            ap = ak.getProjection();
563            if (!ap) {
564                setTimeout(function() {
565                    S.apply(V, [])
566                }, 25);
567                return
568            }
569            Z = true;
570            N.push(google.maps.event.addListener(ao, "zoom_changed", function() {
571                al()
572            }));
573            N.push(google.maps.event.addListener(ao, "bounds_changed", function() {
574                al()
575            }));
576            ag()
577        }
578
579        function ac(aq) {
580            if (typeof T[aq] === "object") {
581                if (typeof(T[aq].obj.setMap) === "function") {
582                    T[aq].obj.setMap(null)
583                }
584                if (typeof(T[aq].obj.remove) === "function") {
585                    T[aq].obj.remove()
586                }
587                if (typeof(T[aq].shadow.remove) === "function") {
588                    T[aq].obj.remove()
589                }
590                if (typeof(T[aq].shadow.setMap) === "function") {
591                    T[aq].shadow.setMap(null)
592                }
593                delete T[aq].obj;
594                delete T[aq].shadow
595            } else {
596                if (aj[aq]) {
597                    aj[aq].setMap(null)
598                }
599            }
600            delete T[aq]
601        }
602
603        function M() {
604            var ay, ax, aw, au, av, at, ar, aq;
605            if (arguments[0] instanceof google.maps.LatLng) {
606                ay = arguments[0].lat();
607                aw = arguments[0].lng();
608                if (arguments[1] instanceof google.maps.LatLng) {
609                    ax = arguments[1].lat();
610                    au = arguments[1].lng()
611                } else {
612                    ax = arguments[1];
613                    au = arguments[2]
614                }
615            } else {
616                ay = arguments[0];
617                aw = arguments[1];
618                if (arguments[2] instanceof google.maps.LatLng) {
619                    ax = arguments[2].lat();
620                    au = arguments[2].lng()
621                } else {
622                    ax = arguments[2];
623                    au = arguments[3]
624                }
625            }
626            av = Math.PI * ay / 180;
627            at = Math.PI * aw / 180;
628            ar = Math.PI * ax / 180;
629            aq = Math.PI * au / 180;
630            return 1000 * 6371 * Math.acos(Math.min(Math.cos(av) * Math.cos(ar) * Math.cos(at) * Math.cos(aq) + Math.
630cos(av) * Math.sin(at) * Math.cos(ar) * Math.sin(aq) + Math.sin(av) * Math.sin(ar), 1))
631        }
632
633        function R() {
634            var aq = M(ao.getCenter(), ao.getBounds().getNorthEast()),
635                ar = new google.maps.Circle({
636                    center: ao.getCenter(),
637                    radius: 1.25 * aq
638                });
639            return ar.getBounds()
640        }
641
642        function X() {
643            var ar = {},
644                aq;
645            for (aq in T) {
646                ar[aq] = true
647            }
648            return ar
649        }
650
651        function al() {
652            clearTimeout(Y);
653            Y = setTimeout(function() {
654                ag()
655            }, 25)
656        }
657
658        function ab(ar) {
659            var au = ap.fromLatLngToDivPixel(ar),
660                at = ap.fromDivPixelToLatLng(new google.maps.Point(au.x + aa.radius, au.y - aa.radius)),
661                aq = ap.fromDivPixelToLatLng(new google.maps.Point(au.x - aa.radius, au.y + aa.radius));
662            return new google.maps.LatLngBounds(aq, at)
663        }
664
665        function ag() {
666            if (an || af || !Z) {
667                return
668            }
669            var aE = [],
670                aG = {},
671                aF = ao.getZoom(),
672                aH = ("maxZoom" in aa) && (aF > aa.maxZoom),
673                aw = X(),
674                av, au, at, aA, ar = false,
675                aq, aD, ay, az, aB, aC, ax;
676            ai = false;
677            if (aF > 3) {
678                aq = R();
679                ar = aq.getSouthWest().lng() < aq.getNorthEast().lng()
680            }
681            for (av = 0; av < ah.length; av++) {
682                if (ah[av] && (!ar || aq.contains(ah[av].options.position)) && (!am || am(O[av]))) {
683                    aE.push(av)
684                }
685            }
686            while (1) {
687                av = 0;
688                while (aG[av] && (av < aE.length)) {
689                    av++
690                }
691                if (av == aE.length) {
692                    break
693                }
694                aA = [];
695                if (W && !aH) {
696                    ax = 10;
697                    do {
698                        az = aA;
699                        aA = [];
700                        ax--;
701                        if (az.length) {
702                            ay = aq.getCenter()
703                        } else {
704                            ay = ah[aE[av]].options.position
705                        }
706                        aq = ab(ay);
707                        for (au = av; au < aE.length; au++) {
708                            if (aG[au]) {
709                                continue
710                            }
711                            if (aq.contains(ah[aE[au]].options.position)) {
712                                aA.push(au)
713                            }
714                        }
715                    } while ((az.length < aA.length) && (aA.length > 1) && ax)
716                } else {
717                    for (au = av; au < aE.length; au++) {
718                        if (aG[au]) {
719                            continue
720                        }
721                        aA.push(au);
722                        break
723                    }
724                }
725                aD = {
726                    indexes: [],
727                    ref: []
728                };
729                aB = aC = 0;
730                for (at = 0; at < aA.length; at++) {
731                    aG[aA[at]] = true;
732                    aD.indexes.push(aE[aA[at]]);
733                    aD.ref.push(aE[aA[at]]);
734                    aB += ah[aE[aA[at]]].options.position.lat();
735                    aC += ah[aE[aA[at]]].options.position.lng()
736                }
737                aB /= aA.length;
738                aC /= aA.length;
739                aD.latLng = new google.maps.LatLng(aB, aC);
740                aD.ref = aD.ref.join("-");
741                if (aD.ref in aw) {
742                    delete aw[aD.ref]
743                } else {
744                    if (aA.length === 1) {
745                        T[aD.ref] = true
746                    }
747                    P(aD)
748                }
749            }
750            y.each(aw, function(aI) {
751                ac(aI)
752            });
753            af = false
754        }
755    }
756
757    function a(M, L) {
758        this.id = function() {
759            return M
760        };
761        this.filter = function(N) {
762            L.filter(N)
763        };
764        this.enable = function() {
765            L.enable(true)
766        };
767        this.disable = function() {
768            L.enable(false)
769        };
770        this.add = function(O, N, P) {
771            if (!P) {
772                L.beginUpdate()
773            }
774            L.addMarker(O, N);
775            if (!P) {
776                L.endUpdate()
777            }
778        };
779        this.getById = function(N) {
780            return L.getById(N)
781        };
782        this.clearById = function(P, O) {
783            var N;
784            if (!O) {
785                L.beginUpdate()
786            }
787            N = L.clearById(P);
788            if (!O) {
789                L.endUpdate()
790            }
791            return N
792        };
793        this.clear = function(P, Q, N, O) {
794            if (!O) {
795                L.beginUpdate()
796            }
797            L.clear(P, Q, N);
798            if (!O) {
799                L.endUpdate()
800            }
801        }
802    }
803
804    function D() {
805        var M = {},
806            N = {};
807
808        function L(P) {
809            return {
810                id: P.id,
811                name: P.name,
812                object: P.obj,
813                tag: P.tag,
814                data: P.data
815            }
816        }
817        this.add = function(R, Q, T, S) {
818            var P = R.todo || {},
819                U = k(P.id);
820            if (!M[Q]) {
821                M[Q] = []
822            }
823            if (U in N) {
824                this.clearById(U)
825            }
826            N[U] = {
827                obj: T,
828                sub: S,
829                name: Q,
830                id: U,
831                tag: P.tag,
832                data: P.data
833            };
834            M[Q].push(U);
835            return U
836        };
837        this.getById = function(R, Q, P) {
838            if (R in N) {
839                if (Q) {
840                    return N[R].sub
841                } else {
842                    if (P) {
843                        return L(N[R])
844                    }
845                }
846                return N[R].obj
847            }
848            return false
849        };
850        this.get = function(R, T, P, S) {
851            var V, U, Q = C(P);
852            if (!M[R] || !M[R].length) {
853                return null
854            }
855            V = M[R].length;
856            while (V) {
857                V--;
858                U = M[R][T ? V : M[R].length - V - 1];
859                if (U && N[U]) {
860                    if (Q && !Q(N[U].tag)) {
861                        continue
862                    }
863                    return S ? L(N[U]) : N[U].obj
864                }
865            }
866            return null
867        };
868        this.all = function(S, Q, T) {
869            var P = [],
870                R = C(Q),
871                U = function(X) {
872                    var V, W;
873                    for (V = 0; V < M[X].length; V++) {
874                        W = M[X][V];
875                        if (W && N[W]) {
876                            if (R && !R(N[W].tag)) {
877                                continue
878                            }
879                            P.push(T ? L(N[W]) : N[W].obj)
880                        }
881                    }
882                };
883            if (S in M) {
884                U(S)
885            } else {
886                if (S === t) {
887                    for (S in M) {
888                        U(S)
889                    }
890                }
891            }
892            return P
893        };
894
895        function O(P) {
896            if (typeof(P.setMap) === "function") {
897                P.setMap(null)
898            }
899            if (typeof(P.remove) === "function") {
900                P.remove()
901            }
902            if (typeof(P.free) === "function") {
903                P.free()
904            }
905            P = null
906        }
907        this.rm = function(S, Q, R) {
908            var P, T;
909            if (!M[S]) {
910                return false
911            }
912            if (Q) {
913                if (R) {
914                    for (P = M[S].length - 1; P >= 0; P--) {
915                        T = M[S][P];
916                        if (Q(N[T].tag)) {
917                            break
918                        }
919                    }
920                } else {
921                    for (P = 0; P < M[S].length; P++) {
922                        T = M[S][P];
923                        if (Q(N[T].tag)) {
924                            break
925                        }
926                    }
927                }
928            } else {
929                P = R ? M[S].length - 1 : 0
930            }
931            if (!(P in M[S])) {
932                return false
933            }
934            return this.clearById(M[S][P], P)
935        };
936        this.clearById = function(S, P) {
937            if (S in N) {
938                var R, Q = N[S].name;
939                for (R = 0; P === t && R < M[Q].length; R++) {
940                    if (S === M[Q][R]) {
941                        P = R
942                    }
943                }
944                O(N[S].obj);
945                if (N[S].sub) {
946                    O(N[S].sub)
947                }
948                delete N[S];
949                M[Q].splice(P, 1);
950                return true
951            }
952            return false
953        };
954        this.objGetById = function(R) {
955            var Q;
956            if (M.clusterer) {
957                for (var P in M.clusterer) {
958                    if ((Q = N[M.clusterer[P]].obj.getById(R)) !== false) {
959                        return Q
960                    }
961                }
962            }
963            return false
964        };
965        this.objClearById = function(Q) {
966            if (M.clusterer) {
967                for (var P in M.clusterer) {
968                    if (N[M.clusterer[P]].obj.clearById(Q)) {
969                        return true
970                    }
971                }
972            }
973            return null
974        };
975        this.clear = function(V, U, W, P) {
976            var R, T, S, Q = C(P);
977            if (!V || !V.length) {
978                V = [];
979                for (R in M) {
980                    V.push(R)
981                }
982            } else {
983                V = g(V)
984            }
985            for (T = 0; T < V.length; T++) {
986                S = V[T];
987                if (U) {
988                    this.rm(S, Q, true)
989                } else {
990                    if (W) {
991                        this.rm(S, Q, false)
992                    } else {
993                        while (this.rm(S, Q, false)) {}
994                    }
995                }
996            }
997        };
998        this.objClear = function(S, R, T, Q) {
999            if (M.clusterer && (y.inArray("marker", S) >= 0 || !S.length)) {
1000                for (var P in M.clusterer) {
1001                    N[M.clusterer[P]].obj.clear(R, T, Q)
1002                }
1003            }
1004        }
1005    }
1006    var m = {},
1007        H = new r();
1008
1009    function p() {
1010        if (!m.geocoder) {
1011            m.geocoder = new google.maps.Geocoder()
1012        }
1013        return m.geocoder
1014    }
1015
1016    function G() {
1017        if (!m.directionsService) {
1018            m.directionsService = new google.maps.DirectionsService()
1019        }
1020        return m.directionsService
1021    }
1022
1023    function h() {
1024        if (!m.elevationService) {
1025            m.elevationService = new google.maps.ElevationService()
1026        }
1027        return m.elevationService
1028    }
1029
1030    function q() {
1031        if (!m.maxZoomService) {
1032            m.maxZoomService = new google.maps.MaxZoomService()
1033        }
1034        return m.maxZoomService
1035    }
1036
1037    function B() {
1038        if (!m.distanceMatrixService) {
1039            m.distanceMatrixService = new google.maps.DistanceMatrixService()
1040        }
1041        return m.distanceMatrixService
1042    }
1043
1044    function u() {
1045        if (z.verbose) {
1046            var L, M = [];
1047            if (window.console && (typeof console.error === "function")) {
1048                for (L = 0; L < arguments.length; L++) {
1049                    M.push(arguments[L])
1050                }
1051                console.error.apply(console, M)
1052            } else {
1053                M = "";
1054                for (L = 0; L < arguments.length; L++) {
1055                    M += arguments[L].toString() + " "
1056                }
1057                alert(M)
1058            }
1059        }
1060    }
1061
1062    function E(L) {
1063        return (typeof(L) === "number" || typeof(L) === "string") && L !== "" && !isNaN(L)
1064    }
1065
1066    function g(N) {
1067        var M, L = [];
1068        if (N !== t) {
1069            if (typeof(N) === "object") {
1070                if (typeof(N.length) === "number") {
1071                    L = N
1072                } else {
1073                    for (M in N) {
1074                        L.push(N[M])
1075                    }
1076                }
1077            } else {
1078                L.push(N)
1079            }
1080        }
1081        return L
1082    }
1083
1084    function C(L) {
1085        if (L) {
1086            if (typeof L === "function") {
1087                return L
1088            }
1089            L = g(L);
1090            return function(N) {
1091                if (N === t) {
1092                    return false
1093                }
1094                if (typeof N === "object") {
1095                    for (var M = 0; M < N.length; M++) {
1096                        if (y.inArray(N[M], L) >= 0) {
1097                            return true
1098                        }
1099                    }
1100                    return false
1101                }
1102                return y.inArray(N, L) >= 0
1103            }
1104        }
1105    }
1106
1107    function I(M, O, L) {
1108        var N = O ? M : null;
1109        if (!M || (typeof M === "string")) {
1110            return N
1111        }
1112        if (M.latLng) {
1113            return I(M.latLng)
1114        }
1115        if (M instanceof google.maps.LatLng) {
1116            return M
1117        } else {
1118            if (E(M.lat)) {
1119                return new google.maps.LatLng(M.lat, M.lng)
1120            } else {
1121                if (!L && y.isArray(M)) {
1122                    if (!E(M[0]) || !E(M[1])) {
1123                        return N
1124                    }
1125                    return new google.maps.LatLng(M[0], M[1])
1126                }
1127            }
1128        }
1129        return N
1130    }
1131
1132    function j(M) {
1133        var N, L;
1134        if (!M || M instanceof google.maps.LatLngBounds) {
1135            return M || null
1136        }
1137        if (y.isArray(M)) {
1138            if (M.length == 2) {
1139                N = I(M[0]);
1140                L = I(M[1])
1141            } else {
1142                if (M.length == 4) {
1143                    N = I([M[0], M[1]]);
1144                    L = I([M[2], M[3]])
1145                }
1146            }
1147        } else {
1148            if (("ne" in M) && ("sw" in M)) {
1149                N = I(M.ne);
1150                L = I(M.sw)
1151            } else {
1152                if (("n" in M) && ("e" in M) && ("s" in M) && ("w" in M)) {
1153                    N = I([M.n, M.e]);
1154                    L = I([M.s, M.w])
1155                }
1156            }
1157        }
1158        if (N && L) {
1159            return new google.maps.LatLngBounds(L, N)
1160        }
1161        return null
1162    }
1163
1164    function v(T, L, O, S, P) {
1165        var N = O ? I(S.todo, false, true) : false,
1166            R = N ? {
1167                latLng: N
1168            } : (S.todo.address ? (typeof(S.todo.address) === "string" ? {
1169                address: S.todo.address
1170            } : S.todo.address) : false),
1171            M = R ? H.get(R) : false,
1172            Q = this;
1173        if (R) {
1174            P = P || 0;
1175            if (M) {
1176                S.latLng = M.results[0].geometry.location;
1177                S.results = M.results;
1178                S.status = M.status;
1179                L.apply(T, [S])
1180            } else {
1181                if (R.location) {
1182                    R.location = I(R.location)
1183                }
1184                if (R.bounds) {
1185                    R.bounds = j(R.bounds)
1186                }
1187                p().geocode(R, function(V, U) {
1188                    if (U === google.maps.GeocoderStatus.OK) {
1189                        H.store(R, {
1190                            results: V,
1191                            status: U
1192                        });
1193                        S.latLng = V[0].geometry.location;
1194                        S.results = V;
1195                        S.status = U;
1196                        L.apply(T, [S])
1197                    } else {
1198                        if ((U === google.maps.GeocoderStatus.OVER_QUERY_LIMIT) && (P < z.queryLimit.attempt)) {
1199                            setTimeout(function() {
1200                                v.apply(Q, [T, L, O, S, P + 1])
1201                            }, z.queryLimit.delay + Math.floor(Math.random() * z.queryLimit.random))
1202                        } else {
1203                            u("geocode failed", U, R);
1204                            S.latLng = S.results = false;
1205                            S.status = U;
1206                            L.apply(T, [S])
1207                        }
1208                    }
1209                })
1210            }
1211        } else {
1212            S.latLng = I(S.todo, false, true);
1213            L.apply(T, [S])
1214        }
1215    }
1216
1217    function x(Q, L, R, M) {
1218        var O = this,
1219            N = -1;
1220
1221        function P() {
1222            do {
1223                N++
1224            } while ((N < Q.length) && !("address" in Q[N]));
1225            if (N >= Q.length) {
1226                R.apply(L, [M]);
1227                return
1228            }
1229            v(O, function(S) {
1230                delete S.todo;
1231                y.extend(Q[N], S);
1232                P.apply(O, [])
1233            }, true, {
1234                todo: Q[N]
1235            })
1236        }
1237        P()
1238    }
1239
1240    function o(L, O, M) {
1241        var N = false;
1242        if (navigator && navigator.geolocation) {
1243            navigator.geolocation.getCurrentPosition(function(P) {
1244                if (N) {
1245                    return
1246                }
1247                N = true;
1248                M.latLng = new google.maps.LatLng(P.coords.latitude, P.coords.longitude);
1249                O.apply(L, [M])
1250            }, function() {
1251                if (N) {
1252                    return
1253                }
1254                N = true;
1255                M.latLng = false;
1256                O.apply(L, [M])
1257            }, M.opts.getCurrentPosition)
1258        } else {
1259            M.latLng = false;
1260            O.apply(L, [M])
1261        }
1262    }
1263
1264    function K(T) {
1265        var S = this,
1266            U = new l(),
1267            V = new D(),
1268            N = null,
1269            P;
1270        this._plan = function(Z) {
1271            for (var Y = 0; Y < Z.length; Y++) {
1272                U.add(new w(S, R, Z[Y]))
1273            }
1274            Q()
1275        };
1276
1277        function Q() {
1278            if (!P && (P = U.get())) {
1279                P.run()
1280            }
1281        }
1282
1283        function R() {
1284            P = null;
1285            U.ack();
1286            Q.call(S)
1287        }
1288
1289        function X(Y) {
1290            if (Y.todo.callback) {
1291                var Z = Array.prototype.slice.call(arguments, 1);
1292                if (typeof Y.todo.callback === "function") {
1293                    Y.todo.callback.apply(T, Z)
1294                } else {
1295                    if (y.isArray(Y.todo.callback)) {
1296                        if (typeof Y.todo.callback[1] === "function") {
1297                            Y.todo.callback[1].apply(Y.todo.callback[0], Z)
1298                        }
1299                    }
1300                }
1301            }
1302        }
1303
1304        function O(Y, Z, aa) {
1305            if (aa) {
1306                n(T, Y, Z, aa)
1307            }
1308            X(Y, Z);
1309            P.ack(Z)
1310        }
1311
1312        function L(aa, Y) {
1313            Y = Y || {};
1314            if (N) {
1315                if (Y.todo && Y.todo.options) {
1316                    if (Y.todo.options.center) {
1317                        Y.todo.options.center = I(Y.todo.options.center)
1318                    }
1319                    N.setOptions(Y.todo.options)
1320                }
1321            } else {
1322                var Z = Y.opts || y.extend(true, {}, z.map, Y.todo && Y.todo.options ? Y.todo.options : {});
1323                Z.center = aa || I(Z.center);
1324                N = new z.classes.Map(T.get(0), Z)
1325            }
1326        }
1327        this.map = function(Y) {
1328            L(Y.latLng, Y);
1329            n(T, Y, N);
1330            O(Y, N)
1331        };
1332        this.destroy = function(Y) {
1333            V.clear();
1334            T.empty();
1335            if (N) {
1336                N = null
1337            }
1338            O(Y, true)
1339        };
1340        this.infowindow = function(Z) {
1341            var aa = [],
1342                Y = "values" in Z.todo;
1343            if (!Y) {
1344                if (Z.latLng) {
1345                    Z.opts.position = Z.latLng
1346                }
1347                Z.todo.values = [{
1348                    options: Z.opts
1349                }]
1350            }
1351            y.each(Z.todo.values, function(ac, ad) {
1352                var af, ae, ab = b(Z, ad);
1353                ab.options.position = ab.options.position ? I(ab.options.position) : I(ad.latLng);
1354                if (!N) {
1355                    L(ab.options.position)
1356                }
1357                ae = new z.classes.InfoWindow(ab.options);
1358                if (ae && ((ab.open === t) || ab.open)) {
1359                    if (Y) {
1360                        ae.open(N, ab.anchor ? ab.anchor : t)
1361                    } else {
1362                        ae.open(N, ab.anchor ? ab.anchor : (Z.latLng ? t : (Z.session.marker ? Z.session.marker : t)))
1363                    }
1364                }
1365                aa.push(ae);
1366                af = V.add({
1367                    todo: ab
1368                }, "infowindow", ae);
1369                n(T, {
1370                    todo: ab
1371                }, ae, af)
1372            });
1373            O(Z, Y ? aa : aa[0])
1374        };
1375        this.circle = function(Z) {
1376            var aa = [],
1377                Y = "values" in Z.todo;
1378            if (!Y) {
1379                Z.opts.center = Z.latLng || I(Z.opts.center);
1380                Z.todo.values = [{
1381                    options: Z.opts
1382                }]
1383            }
1384            if (!Z.todo.values.length) {
1385                O(Z, false);
1386                return
1387            }
1388            y.each(Z.todo.values, function(ac, ad) {
1389                var af, ae, ab = b(Z, ad);
1390                ab.options.center = ab.options.center ? I(ab.options.center) : I(ad);
1391                if (!N) {
1392                    L(ab.options.center)
1393                }
1394                ab.options.map = N;
1395                ae = new z.classes.Circle(ab.options);
1396                aa.push(ae);
1397                af = V.add({
1398                    todo: ab
1399                }, "circle", ae);
1400                n(T, {
1401                    todo: ab
1402                }, ae, af)
1403            });
1404            O(Z, Y ? aa : aa[0])
1405        };
1406        this.overlay = function(aa, Z) {
1407            var ab = [],
1408                Y = "values" in aa.todo;
1409            if (!Y) {
1410                aa.todo.values = [{
1411                    latLng: aa.latLng,
1412                    options: aa.opts
1413                }]
1414            }
1415            if (!aa.todo.values.length) {
1416                O(aa, false);
1417                return
1418            }
1419            if (!e.__initialised) {
1420                e.prototype = new z.classes.OverlayView();
1421                e.__initialised = true
1422            }
1423            y.each(aa.todo.values, function(ae, af) {
1424                var ah, ag, ac = b(aa, af),
1425                    ad = y(document.createElement("div")).css({
1426                        border: "none",
1427                        borderWidth: "0px",
1428                        position: "absolute"
1429                    });
1430                ad.append(ac.options.content);
1431                ag = new e(N, ac.options, I(ac) || I(af), ad);
1432                ab.push(ag);
1433                ad = null;
1434                if (!Z) {
1435                    ah = V.add(aa, "overlay", ag);
1436                    n(T, {
1437                        todo: ac
1438                    }, ag, ah)
1439                }
1440            });
1441            if (Z) {
1442                return ab[0]
1443            }
1444            O(aa, Y ? ab : ab[0])
1445        };
1446        this.getaddress = function(Y) {
1447            X(Y, Y.results, Y.status);
1448            P.ack()
1449        };
1450        this.getlatlng = function(Y) {
1451            X(Y, Y.results, Y.status);
1452            P.ack()
1453        };
1454        this.getmaxzoom = function(Y) {
1455            q().getMaxZoomAtLatLng(Y.latLng, function(Z) {
1456                X(Y, Z.status === google.maps.MaxZoomStatus.OK ? Z.zoom : false, status);
1457                P.ack()
1458            })
1459        };
1460        this.getelevation = function(Z) {
1461            var aa, Y = [],
1462                ab = function(ad, ac) {
1463                    X(Z, ac === google.maps.ElevationStatus.OK ? ad : false, ac);
1464                    P.ack()
1465                };
1466            if (Z.latLng) {
1467                Y.push(Z.latLng)
1468            } else {
1469                Y = g(Z.todo.locations || []);
1470                for (aa = 0; aa < Y.length; aa++) {
1471                    Y[aa] = I(Y[aa])
1472                }
1473            }
1474            if (Y.length) {
1475                h().getElevationForLocations({
1476                    locations: Y
1477                }, ab)
1478            } else {
1479                if (Z.todo.path && Z.todo.path.length) {
1480                    for (aa = 0; aa < Z.todo.path.length; aa++) {
1481                        Y.push(I(Z.todo.path[aa]))
1482                    }
1483                }
1484                if (Y.length) {
1485                    h().getElevationAlongPath({
1486                        path: Y,
1487                        samples: Z.todo.samples
1488                    }, ab)
1489                } else {
1490                    P.ack()
1491                }
1492            }
1493        };
1494        this.defaults = function(Y) {
1495            y.each(Y.todo, function(Z, aa) {
1496                if (typeof z[Z] === "object") {
1497                    z[Z] = y.extend({}, z[Z], aa)
1498                } else {
1499                    z[Z] = aa
1500                }
1501            });
1502            P.ack(true)
1503        };
1504        this.rectangle = function(Z) {
1505            var aa = [],
1506                Y = "values" in Z.todo;
1507            if (!Y) {
1508                Z.todo.values = [{
1509                    options: Z.opts
1510                }]
1511            }
1512            if (!Z.todo.values.length) {
1513                O(Z, false);
1514                return
1515            }
1516            y.each(Z.todo.values, function(ac, ad) {
1517                var af, ae, ab = b(Z, ad);
1518                ab.options.bounds = ab.options.bounds ? j(ab.options.bounds) : j(ad);
1519                if (!N) {
1520                    L(ab.options.bounds.getCenter())
1521                }
1522                ab.options.map = N;
1523                ae = new z.classes.Rectangle(ab.options);
1524                aa.push(ae);
1525                af = V.add({
1526                    todo: ab
1527                }, "rectangle", ae);
1528                n(T, {
1529                    todo: ab
1530                }, ae, af)
1531            });
1532            O(Z, Y ? aa : aa[0])
1533        };
1534
1535        function M(Z, aa, ab) {
1536            var ac = [],
1537                Y = "values" in Z.todo;
1538            if (!Y) {
1539                Z.todo.values = [{
1540                    options: Z.opts
1541                }]
1542            }
1543            if (!Z.todo.values.length) {
1544                O(Z, false);
1545                return
1546            }
1547            L();
1548            y.each(Z.todo.values, function(af, ah) {
1549                var aj, ag, ae, ai, ad = b(Z, ah);
1550                if (ad.options[ab]) {
1551                    if (ad.options[ab][0][0] && y.isArray(ad.options[ab][0][0])) {
1552                        for (ag = 0; ag < ad.options[ab].length; ag++) {
1553                            for (ae = 0; ae < ad.options[ab][ag].length; ae++) {
1554                                ad.options[ab][ag][ae] = I(ad.options[ab][ag][ae])
1555                            }
1556                        }
1557                    } else {
1558                        for (ag = 0; ag < ad.options[ab].length; ag++) {
1559                            ad.options[ab][ag] = I(ad.options[ab][ag])
1560                        }
1561                    }
1562                }
1563                ad.options.map = N;
1564                ai = new google.maps[aa](ad.options);
1565                ac.push(ai);
1566                aj = V.add({
1567                    todo: ad
1568                }, aa.toLowerCase(), ai);
1569                n(T, {
1570                    todo: ad
1571                }, ai, aj)
1572            });
1573            O(Z, Y ? ac : ac[0])
1574        }
1575        this.polyline = function(Y) {
1576            M(Y, "Polyline", "path")
1577        };
1578        this.polygon = function(Y) {
1579            M(Y, "Polygon", "paths")
1580        };
1581        this.trafficlayer = function(Y) {
1582            L();
1583            var Z = V.get("trafficlayer");
1584            if (!Z) {
1585                Z = new z.classes.TrafficLayer();
1586                Z.setMap(N);
1587                V.add(Y, "trafficlayer", Z)
1588            }
1589            O(Y, Z)
1590        };
1591        this.bicyclinglayer = function(Y) {
1592            L();
1593            var Z = V.get("bicyclinglayer");
1594            if (!Z) {
1595                Z = new z.classes.BicyclingLayer();
1596                Z.setMap(N);
1597                V.add(Y, "bicyclinglayer", Z)
1598            }
1599            O(Y, Z)
1600        };
1601        this.groundoverlay = function(Y) {
1602            Y.opts.bounds = j(Y.opts.bounds);
1603            if (Y.opts.bounds) {
1604                L(Y.opts.bounds.getCenter())
1605            }
1606            var aa, Z = new z.classes.GroundOverlay(Y.opts.url, Y.opts.bounds, Y.opts.opts);
1607            Z.setMap(N);
1608            aa = V.add(Y, "groundoverlay", Z);
1609            O(Y, Z, aa)
1610        };
1611        this.streetviewpanorama = function(Y) {
1612            if (!Y.opts.opts) {
1613                Y.opts.opts = {}
1614            }
1615            if (Y.latLng) {
1616                Y.opts.opts.position = Y.latLng
1617            } else {
1618                if (Y.opts.opts.position) {
1619                    Y.opts.opts.position = I(Y.opts.opts.position)
1620                }
1621            }
1622            if (Y.todo.divId) {
1623                Y.opts.container = document.getElementById(Y.todo.divId)
1624            } else {
1625                if (Y.opts.container) {
1626                    Y.opts.container = y(Y.opts.container).get(0)
1627                }
1628            }
1629            var aa, Z = new z.classes.StreetViewPanorama(Y.opts.container, Y.opts.opts);
1630            if (Z) {
1631                N.setStreetView(Z)
1632            }
1633            aa = V.add(Y, "streetviewpanorama", Z);
1634            O(Y, Z, aa)
1635        };
1636        this.kmllayer = function(Z) {
1637            var aa = [],
1638                Y = "values" in Z.todo;
1639            if (!Y) {
1640                Z.todo.values = [{
1641                    options: Z.opts
1642                }]
1643            }
1644            if (!Z.todo.values.length) {
1645                O(Z, false);
1646                return
1647            }
1648            y.each(Z.todo.values, function(ad, ae) {
1649                var ag, af, ac, ab = b(Z, ae);
1650                if (!N) {
1651                    L()
1652                }
1653                ac = ab.options;
1654                if (ab.options.opts) {
1655                    ac = ab.options.opts;
1656                    if (ab.options.url) {
1657                        ac.url = ab.options.url
1658                    }
1659                }
1660                ac.map = N;
1661                if (d("3.10")) {
1662                    af = new z.classes.KmlLayer(ac)
1663                } else {
1664                    af = new z.classes.KmlLayer(ac.url, ac)
1665                }
1666                aa.push(af);
1667                ag = V.add({
1668                    todo: ab
1669                }, "kmllayer", af);
1670                n(T, {
1671                    todo: ab
1672                }, af, ag)
1673            });
1674            O(Z, Y ? aa : aa[0])
1675        };
1676        this.panel = function(ab) {
1677            L();
1678            var ad, Y = 0,
1679                ac = 0,
1680                aa, Z = y(document.createElement("div"));
1681            Z.css({
1682                position: "absolute",
1683                zIndex: 1000,
1684                visibility: "hidden"
1685            });
1686            if (ab.opts.content) {
1687                aa = y(ab.opts.content);
1688                Z.append(aa);
1689                T.first().prepend(Z);
1690                if (ab.opts.left !== t) {
1691                    Y = ab.opts.left
1692                } else {
1693                    if (ab.opts.right !== t) {
1694                        Y = T.width() - aa.width() - ab.opts.right
1695                    } else {
1696                        if (ab.opts.center) {
1697                            Y = (T.width() - aa.width()) / 2
1698                        }
1699                    }
1700                }
1701                if (ab.opts.top !== t) {
1702                    ac = ab.opts.top
1703                } else {
1704                    if (ab.opts.bottom !== t) {
1705                        ac = T.height() - aa.height() - ab.opts.bottom
1706                    } else {
1707                        if (ab.opts.middle) {
1708                            ac = (T.height() - aa.height()) / 2
1709                        }
1710                    }
1711                }
1712                Z.css({
1713                    top: ac,
1714                    left: Y,
1715                    visibility: "visible"
1716                })
1717            }
1718            ad = V.add(ab, "panel", Z);
1719            O(ab, Z, ad);
1720            Z = null
1721        };
1722
1723        function W(aa) {
1724            var af = new F(T, N, aa),
1725                Y = {},
1726                ab = {},
1727                ae = [],
1728                ad = /^[0-9]+$/,
1729                ac, Z;
1730            for (Z in aa) {
1731                if (ad.test(Z)) {
1732                    ae.push(1 * Z);
1733                    ab[Z] = aa[Z];
1734                    ab[Z].width = ab[Z].width || 0;
1735                    ab[Z].height = ab[Z].height || 0
1736                } else {
1737                    Y[Z] = aa[Z]
1738                }
1739            }
1740            ae.sort(function(ah, ag) {
1741                return ah > ag
1742            });
1743            if (Y.calculator) {
1744                ac = function(ag) {
1745                    var ah = [];
1746                    y.each(ag, function(aj, ai) {
1747                        ah.push(af.value(ai))
1748                    });
1749                    return Y.calculator.apply(T, [ah])
1750                }
1751            } else {
1752                ac = function(ag) {
1753                    return ag.length
1754                }
1755            }
1756            af.error(function() {
1757                u.apply(S, arguments)
1758            });
1759            af.display(function(ag) {
1760                var ai, aj, am, ak, al, ah = ac(ag.indexes);
1761                if (aa.force || ah > 1) {
1762                    for (ai = 0; ai < ae.length; ai++) {
1763                        if (ae[ai] <= ah) {
1764                            aj = ab[ae[ai]]
1765                        }
1766                    }
1767                }
1768                if (aj) {
1769                    al = aj.offset || [-aj.width / 2, -aj.height / 2];
1770                    am = y.extend({}, Y);
1771                    am.options = y.extend({
1772                        pane: "overlayLayer",
1773                        content: aj.content ? aj.content.replace("CLUSTER_COUNT", ah) : "",
1774                        offset: {
1775                            x: ("x" in al ? al.x : al[0]) || 0,
1776                            y: ("y" in al ? al.y : al[1]) || 0
1777                        }
1778                    }, Y.options || {});
1779                    ak = S.overlay({
1780                        todo: am,
1781                        opts: am.options,
1782                        latLng: I(ag)
1783                    }, true);
1784                    am.options.pane = "floatShadow";
1785                    am.options.content = y(document.createElement("div")).width(aj.width + "px").height(aj.height + "px").css({
1786                        cursor: "pointer"
1787                    });
1788                    shadow = S.overlay({
1789                        todo: am,
1790                        opts: am.options,
1791                        latLng: I(ag)
1792                    }, true);
1793                    Y.data = {
1794                        latLng: I(ag),
1795                        markers: []
1796                    };
1797                    y.each(ag.indexes, function(ao, an) {
1798                        Y.data.markers.push(af.value(an));
1799                        if (af.markerIsSet(an)) {
1800                            af.marker(an).setMap(null)
1801                        }
1802                    });
1803                    n(T, {
1804                        todo: Y
1805                    }, shadow, t, {
1806                        main: ak,
1807                        shadow: shadow
1808                    });
1809                    af.store(ag, ak, shadow)
1810                } else {
1811                    y.each(ag.indexes, function(ao, an) {
1812                        af.marker(an).setMap(N)
1813                    })
1814                }
1815            });
1816            return af
1817        }
1818        this.marker = function(aa) {
1819            var Y = "values" in aa.todo,
1820                ad = !N;
1821            if (!Y) {
1822                aa.opts.position = aa.latLng || I(aa.opts.position);
1823                aa.todo.values = [{
1824                    options: aa.opts
1825                }]
1826            }
1827            if (!aa.todo.values.length) {
1828                O(aa, false);
1829                return
1830            }
1831            if (ad) {
1832                L()
1833            }
1834            if (aa.todo.cluster && !N.getBounds()) {
1835                google.maps.event.addListenerOnce(N, "bounds_changed", function() {
1836                    S.marker.apply(S, [aa])
1837                });
1838                return
1839            }
1840            if (aa.todo.cluster) {
1841                var Z, ab;
1842                if (aa.todo.cluster instanceof a) {
1843                    Z = aa.todo.cluster;
1844                    ab = V.getById(Z.id(), true)
1845                } else {
1846                    ab = W(aa.todo.cluster);
1847                    Z = new a(k(aa.todo.id, true), ab);
1848                    V.add(aa, "clusterer", Z, ab)
1849                }
1850                ab.beginUpdate();
1851                y.each(aa.todo.values, function(af, ag) {
1852                    var ae = b(aa, ag);
1853                    ae.options.position = ae.options.position ? I(ae.options.position) : I(ag);
1854                    ae.options.map = N;
1855                    if (ad) {
1856                        N.setCenter(ae.options.position);
1857                        ad = false
1858                    }
1859                    ab.add(ae, ag)
1860                });
1861                ab.endUpdate();
1862                O(aa, Z)
1863            } else {
1864                var ac = [];
1865                y.each(aa.todo.values, function(af, ag) {
1866                    var ai, ah, ae = b(aa, ag);
1867                    ae.options.position = ae.options.position ? I(ae.options.position) : I(ag);
1868                    ae.options.map = N;
1869                    if (ad) {
1870                        N.setCenter(ae.options.position);
1871                        ad = false
1872                    }
1873                    ah = new z.classes.Marker(ae.options);
1874                    ac.push(ah);
1875                    ai = V.add({
1876                        todo: ae
1877                    }, "marker", ah);
1878                    n(T, {
1879                        todo: ae
1880                    }, ah, ai)
1881                });
1882                O(aa, Y ? ac : ac[0])
1883            }
1884        };
1885        this.getroute = function(Y) {
1886            Y.opts.origin = I(Y.opts.origin, true);
1887            Y.opts.destination = I(Y.opts.destination, true);
1888            G().route(Y.opts, function(aa, Z) {
1889                X(Y, Z == google.maps.DirectionsStatus.OK ? aa : false, Z);
1890                P.ack()
1891            })
1892        };
1893        this.directionsrenderer = function(Y) {
1894            Y.opts.map = N;
1895            var aa, Z = new google.maps.DirectionsRenderer(Y.opts);
1896            if (Y.todo.divId) {
1897                Z.setPanel(document.getElementById(Y.todo.divId))
1898            } else {
1899                if (Y.todo.container) {
1900                    Z.setPanel(y(Y.todo.container).get(0))
1901                }
1902            }
1903            aa = V.add(Y, "directionsrenderer", Z);
1904            O(Y, Z, aa)
1905        };
1906        this.getgeoloc = function(Y) {
1907            O(Y, Y.latLng)
1908        };
1909        this.styledmaptype = function(Y) {
1910            L();
1911            var Z = new z.classes.StyledMapType(Y.todo.styles, Y.opts);
1912            N.mapTypes.set(Y.todo.id, Z);
1913            O(Y, Z)
1914        };
1915        this.imagemaptype = function(Y) {
1916            L();
1917            var Z = new z.classes.ImageMapType(Y.opts);
1918            N.mapTypes.set(Y.todo.id, Z);
1919            O(Y, Z)
1920        };
1921        this.autofit = function(Y) {
1922            var Z = new google.maps.LatLngBounds();
1923            y.each(V.all(), function(aa, ab) {
1924                if (ab.getPosition) {
1925                    Z.extend(ab.getPosition())
1926                } else {
1927                    if (ab.getBounds) {
1928                        Z.extend(ab.getBounds().getNorthEast());
1929                        Z.extend(ab.getBounds().getSouthWest())
1930                    } else {
1931                        if (ab.getPaths) {
1932                            ab.getPaths().forEach(function(ac) {
1933                                ac.forEach(function(ad) {
1934                                    Z.extend(ad)
1935                                })
1936                            })
1937                        } else {
1938                            if (ab.getPath) {
1939                                ab.getPath().forEach(function(ac) {
1940                                    Z.extend(ac);
1941                                    ""
1942                                })
1943                            } else {
1944                                if (ab.getCenter) {
1945                                    Z.extend(ab.getCenter())
1946                                } else {
1947                                    if (ab instanceof a) {
1948                                        ab = V.getById(ab.id(), true);
1949                                        if (ab) {
1950                                            ab.autofit(Z)
1951                                        }
1952                                    }
1953                                }
1954                            }
1955                        }
1956                    }
1957                }
1958            });
1959            if (!Z.isEmpty() && (!N.getBounds() || !N.getBounds().equals(Z))) {
1960                if ("maxZoom" in Y.todo) {
1961                    google.maps.event.addListenerOnce(N, "bounds_changed", function() {
1962                        if (this.getZoom() > Y.todo.maxZoom) {
1963                            this.setZoom(Y.todo.maxZoom)
1964                        }
1965                    })
1966                }
1967                N.fitBounds(Z)
1968            }
1969            O(Y, true)
1970        };
1971        this.clear = function(Y) {
1972            if (typeof Y.todo === "string") {
1973                if (V.clearById(Y.todo) || V.objClearById(Y.todo)) {
1974                    O(Y, true);
1975                    return
1976                }
1977                Y.todo = {
1978                    name: Y.todo
1979                }
1980            }
1981            if (Y.todo.id) {
1982                y.each(g(Y.todo.id), function(Z, aa) {
1983                    V.clearById(aa) || V.objClearById(aa)
1984                })
1985            } else {
1986                V.clear(g(Y.todo.name), Y.todo.last, Y.todo.first, Y.todo.tag);
1987                V.objClear(g(Y.todo.name), Y.todo.last, Y.todo.first, Y.todo.tag)
1988            }
1989            O(Y, true)
1990        };
1991        this.exec = function(Y) {
1992            var Z = this;
1993            y.each(g(Y.todo.func), function(aa, ab) {
1994                y.each(Z.get(Y.todo, true, Y.todo.hasOwnProperty("full") ? Y.todo.full : true), function(ac, ad) {
1995                    ab.call(T, ad)
1996                })
1997            });
1998            O(Y, true)
1999        };
2000        this.get = function(aa, ad, ac) {
2001            var Z, ab, Y = ad ? aa : aa.todo;
2002            if (!ad) {
2003                ac = Y.full
2004            }
2005            if (typeof Y === "string") {
2006                ab = V.getById(Y, false, ac) || V.objGetById(Y);
2007                if (ab === false) {
2008                    Z = Y;
2009                    Y = {}
2010                }
2011            } else {
2012                Z = Y.name
2013            }
2014            if (Z === "map") {
2015                ab = N
2016            }
2017            if (!ab) {
2018                ab = [];
2019                if (Y.id) {
2020                    y.each(g(Y.id), function(ae, af) {
2021                        ab.push(V.getById(af, false, ac) || V.objGetById(af))
2022                    });
2023                    if (!y.isArray(Y.id)) {
2024                        ab = ab[0]
2025                    }
2026                } else {
2027                    y.each(Z ? g(Z) : [t], function(af, ag) {
2028                        var ae;
2029                        if (Y.first) {
2030                            ae = V.get(ag, false, Y.tag, ac);
2031                            if (ae) {
2032                                ab.push(ae)
2033                            }
2034                        } else {
2035                            if (Y.all) {
2036                                y.each(V.all(ag, Y.tag, ac), function(ai, ah) {
2037                                    ab.push(ah)
2038                                })
2039                            } else {
2040                                ae = V.get(ag, true, Y.tag, ac);
2041                                if (ae) {
2042                                    ab.push(ae)
2043                                }
2044                            }
2045                        }
2046                    });
2047                    if (!Y.all && !y.isArray(Z)) {
2048                        ab = ab[0]
2049                    }
2050                }
2051            }
2052            ab = y.isArray(ab) || !Y.all ? ab : [ab];
2053            if (ad) {
2054                return ab
2055            } else {
2056                O(aa, ab)
2057            }
2058        };
2059        this.getdistance = function(Y) {
2060            var Z;
2061            Y.opts.origins = g(Y.opts.origins);
2062            for (Z = 0; Z < Y.opts.origins.length; Z++) {
2063                Y.opts.origins[Z] = I(Y.opts.origins[Z], true)
2064            }
2065            Y.opts.destinations = g(Y.opts.destinations);
2066            for (Z = 0; Z < Y.opts.destinations.length; Z++) {
2067                Y.opts.destinations[Z] = I(Y.opts.destinations[Z], true)
2068            }
2069            B().getDistanceMatrix(Y.opts, function(ab, aa) {
2070                X(Y, aa === google.maps.DistanceMatrixStatus.OK ? ab : false, aa);
2071                P.ack()
2072            })
2073        };
2074        this.trigger = function(Z) {
2075            if (typeof Z.todo === "string") {
2076                google.maps.event.trigger(N, Z.todo)
2077            } else {
2078                var Y = [N, Z.todo.eventName];
2079                if (Z.todo.var_args) {
2080                    y.each(Z.todo.var_args, function(ab, aa) {
2081                        Y.push(aa)
2082                    })
2083                }
2084                google.maps.event.trigger.apply(google.maps.event, Y)
2085            }
2086            X(Z);
2087            P.ack()
2088        }
2089    }
2090
2091    function s(M) {
2092        var L;
2093        if (!typeof M === "object" || !M.hasOwnProperty("get")) {
2094            return false
2095        }
2096        for (L in M) {
2097            if (L !== "get") {
2098                return false
2099            }
2100        }
2101        return !M.get.hasOwnProperty("callback")
2102    }
2103    y.fn.gmap3 = function() {
2104        var M, O = [],
2105            N = true,
2106            L = [];
2107        J();
2108        for (M = 0; M < arguments.length; M++) {
2109            if (arguments[M]) {
2110                O.push(arguments[M])
2111            }
2112        }
2113        if (!O.length) {
2114            O.push("map")
2115        }
2116        y.each(this, function() {
2117            var P = y(this),
2118                Q = P.data("gmap3");
2119            N = false;
2120            if (!Q) {
2121                Q = new K(P);
2122                P.data("gmap3", Q)
2123            }
2124            if (O.length === 1 && (O[0] === "get" || s(O[0]))) {
2125                if (O[0] === "get") {
2126                    L.push(Q.get("map", true))
2127                } else {
2128                    L.push(Q.get(O[0].get, true, O[0].get.full))
2129                }
2130            } else {
2131                Q._plan(O)
2132            }
2133        });
2134        if (L.length) {
2135            if (L.length === 1) {
2136                return L[0]
2137            } else {
2138                return L
2139            }
2140        }
2141        return this
2142    }
2143})(jQuery);

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.