PageSourceSearch

https://www.sertoma.org/Resources/libraries/jQuery-Migrate/03_04_01/jquery-migrate.js?cdv=1530

js sertoma.org collected 2026-09-24 10:19:12 UTC 25,584 bytes, 863 lines download raw bytes

1/*! jQuery Migrate v3.4.1 | (c) OpenJS Foundation and other contributors | jquery.org/license */
2("undefined" == typeof jQuery.migrateMute && (jQuery.migrateMute = !0),
3  (function (t) {
4    "use strict";
5    "function" == typeof define && define.amd
6      ? define(["jquery"], function (e) {
7          return t(e, window);
8        })
9      : "object" == typeof module && module.exports
10        ? (module.exports = t(require("jquery"), window))
11        : t(jQuery, window);
12  })(function (s, n) {
13    "use strict";
14    function e(e) {
15      return (
16        0 <=
17        (function (e, t) {
18          for (
19            var r = /^(\d+)\.(\d+)\.(\d+)/,
20              n = r.exec(e) || [],
21              o = r.exec(t) || [],
22              a = 1;
23            a <= 3;
24            a++
25          ) {
26            if (+o[a] < +n[a]) return 1;
27            if (+n[a] < +o[a]) return -1;
28          }
29          return 0;
30        })(s.fn.jquery, e)
31      );
32    }
33    s.migrateVersion = "3.4.1";
34    var t = Object.create(null);
35    ((s.migrateDisablePatches = function () {
36      for (var e = 0; e < arguments.length; e++) t[arguments[e]] = !0;
37    }),
38      (s.migrateEnablePatches = function () {
39        for (var e = 0; e < arguments.length; e++) delete t[arguments[e]];
40      }),
41      (s.migrateIsPatchEnabled = function (e) {
42        return !t[e];
43      }),
44      n.console &&
45        n.console.log &&
46        ((s && e("3.0.0") && !e("5.0.0")) ||
47          n.console.log("JQMIGRATE: jQuery 3.x-4.x REQUIRED"),
48        s.migrateWarnings &&
49          n.console.log("JQMIGRATE: Migrate plugin loaded multiple times"),
50        n.console.log(
51          "JQMIGRATE: Migrate is installed" +
52            (s.migrateMute ? "" : " with logging active") +
53            ", version " +
54            s.migrateVersion,
55        )));
56    var o = {};
57    function u(e, t) {
58      var r = n.console;
59      !s.migrateIsPatchEnabled(e) ||
60        (s.migrateDeduplicateWarnings && o[t]) ||
61        ((o[t] = !0),
62        s.migrateWarnings.push(t + " [" + e + "]"),
63        r &&
64          r.warn &&
65          !s.migrateMute &&
66          (r.warn("JQMIGRATE: " + t), s.migrateTrace && r.trace && r.trace()));
67    }
68    function r(e, t, r, n, o) {
69      Object.defineProperty(e, t, {
70        configurable: !0,
71        enumerable: !0,
72        get: function () {
73          return (u(n, o), r);
74        },
75        set: function (e) {
76          (u(n, o), (r = e));
77        },
78      });
79    }
80    function a(e, t, r, n, o) {
81      var a = e[t];
82      e[t] = function () {
83        return (
84          o && u(n, o),
85          (s.migrateIsPatchEnabled(n) ? r : a || s.noop).apply(this, arguments)
86        );
87      };
88    }
89    function c(e, t, r, n, o) {
90      if (!o) throw new Error("No warning message provided");
91      return (a(e, t, r, n, o), 0);
92    }
93    function i(e, t, r, n) {
94      return (a(e, t, r, n), 0);
95    }
96    ((s.migrateDeduplicateWarnings = !0),
97      (s.migrateWarnings = []),
98      void 0 === s.migrateTrace && (s.migrateTrace = !0),
99      (s.migrateReset = function () {
100        ((o = {}), (s.migrateWarnings.length = 0));
101      }),
102      "BackCompat" === n.document.compatMode &&
103        u("quirks", "jQuery is not compatible with Quirks Mode"));
104    var d,
105      l,
106      p,
107      f = {},
108      m = s.fn.init,
109      y = s.find,
110      h = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/,
111      g = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/g,
112      v = /^[\s\uFEFF\xA0]+|([^\s\uFEFF\xA0])[\s\uFEFF\xA0]+$/g;
113    for (d in (i(
114      s.fn,
115      "init",
116      function (e) {
117        var t = Array.prototype.slice.call(arguments);
118        return (
119          s.migrateIsPatchEnabled("selector-empty-id") &&
120            "string" == typeof e &&
121            "#" === e &&
122            (u("selector-empty-id", "jQuery( '#' ) is not a valid selector"),
123            (t[0] = [])),
124          m.apply(this, t)
125        );
126      },
127      "selector-empty-id",
128    ),
129    (s.fn.init.prototype = s.fn),
130    i(
131      s,
132      "find",
133      function (t) {
134        var r = Array.prototype.slice.call(arguments);
135        if ("string" == typeof t && h.test(t))
136          try {
137            n.document.querySelector(t);
138          } catch (e) {
139            t = t.replace(g, function (e, t, r, n) {
140              return "[" + t + r + '"' + n + '"]';
141            });
142            try {
143              (n.document.querySelector(t),
144                u(
145                  "selector-hash",
146                  "Attribute selector with '#' must be quoted: " + r[0],
147                ),
148                (r[0] = t));
149            } catch (e) {
150              u(
151                "selector-hash",
152                "Attribute selector with '#' was not fixed: " + r[0],
153              );
154            }
155          }
156        return y.apply(this, r);
157      },
158      "selector-hash",
159    ),
160    y))
161      Object.prototype.hasOwnProperty.call(y, d) && (s.find[d] = y[d]);
162    (c(
163      s.fn,
164      "size",
165      function () {
166        return this.length;
167      },
168      "size",
169      "jQuery.fn.size() is deprecated and removed; use the .length property",
170    ),
171      c(
172        s,
173        "parseJSON",
174        function () {
175          return JSON.parse.apply(null, arguments);
176        },
177        "parseJSON",
178        "jQuery.parseJSON is deprecated; use JSON.parse",
179      ),
180      c(
181        s,
182        "holdReady",
183        s.holdReady,
184        "holdReady",
185        "jQuery.holdReady is deprecated",
186      ),
187      c(
188        s,
189        "unique",
190        s.uniqueSort,
191        "unique",
192        "jQuery.unique is deprecated; use jQuery.uniqueSort",
193      ),
194      r(
195        s.expr,
196        "filters",
197        s.expr.pseudos,
198        "expr-pre-pseudos",
199        "jQuery.expr.filters is deprecated; use jQuery.expr.pseudos",
200      ),
201      r(
202        s.expr,
203        ":",
204        s.expr.pseudos,
205        "expr-pre-pseudos",
206        "jQuery.expr[':'] is deprecated; use jQuery.expr.pseudos",
207      ),
208      e("3.1.1") &&
209        c(
210          s,
211          "trim",
212          function (e) {
213            return null == e ? "" : (e + "").replace(v, "$1");
214          },
215          "trim",
216          "jQuery.trim is deprecated; use String.prototype.trim",
217        ),
218      e("3.2.0") &&
219        (c(
220          s,
221          "nodeName",
222          function (e, t) {
223            return e.nodeName && e.nodeName.toLowerCase() === t.toLowerCase();
224          },
225          "nodeName",
226          "jQuery.nodeName is deprecated",
227        ),
228        c(
229          s,
230          "isArray",
231          Array.isArray,
232          "isArray",
233          "jQuery.isArray is deprecated; use Array.isArray",
234        )),
235      e("3.3.0") &&
236        (c(
237          s,
238          "isNumeric",
239          function (e) {
240            var t = typeof e;
241            return (
242              ("number" == t || "string" == t) && !isNaN(e - parseFloat(e))
243            );
244          },
245          "isNumeric",
246          "jQuery.isNumeric() is deprecated",
247        ),
248        s.each(
249          "Boolean Number String Function Array Date RegExp Object Error Symbol".split(
250            " ",
251          ),
252          function (e, t) {
253            f["[object " + t + "]"] = t.toLowerCase();
254          },
255        ),
256        c(
257          s,
258          "type",
259          function (e) {
260            return null == e
261              ? e + ""
262              : "object" == typeof e || "function" == typeof e
263                ? f[Object.prototype.toString.call(e)] || "object"
264                : typeof e;
265          },
266          "type",
267          "jQuery.type is deprecated",
268        ),
269        c(
270          s,
271          "isFunction",
272          function (e) {
273            return "function" == typeof e;
274          },
275          "isFunction",
276          "jQuery.isFunction() is deprecated",
277        ),
278        c(
279          s,
280          "isWindow",
281          function (e) {
282            return null != e && e === e.window;
283          },
284          "isWindow",
285          "jQuery.isWindow() is deprecated",
286        )),
287      s.ajax &&
288        ((l = s.ajax),
289        (p = /(=)\?(?=&|$)|\?\?/),
290        i(
291          s,
292          "ajax",
293          function () {
294            var e = l.apply(this, arguments);
295            return (
296              e.promise &&
297                (c(
298                  e,
299                  "success",
300                  e.done,
301                  "jqXHR-methods",
302                  "jQXHR.success is deprecated and removed",
303                ),
304                c(
305                  e,
306                  "error",
307                  e.fail,
308                  "jqXHR-methods",
309                  "jQXHR.error is deprecated and removed",
310                ),
311                c(
312                  e,
313                  "complete",
314                  e.always,
315                  "jqXHR-methods",
316                  "jQXHR.complete is deprecated and removed",
317                )),
318              e
319            );
320          },
321          "jqXHR-methods",
322        ),
323        e("4.0.0") ||
324          s.ajaxPrefilter("+json", function (e) {
325            !1 !== e.jsonp &&
326              (p.test(e.url) ||
327                ("string" == typeof e.data &&
328                  0 ===
329                    (e.contentType || "").indexOf(
330                      "application/x-www-form-urlencoded",
331                    ) &&
332                  p.test(e.data))) &&
333              u(
334                "jsonp-promotion",
335                "JSON-to-JSONP auto-promotion is deprecated",
336              );
337          })));
338    var j = s.fn.removeAttr,
339      b = s.fn.toggleClass,
340      w = /\S+/g;
341    function x(e) {
342      return e.replace(/-([a-z])/g, function (e, t) {
343        return t.toUpperCase();
344      });
345    }
346    (i(
347      s.fn,
348      "removeAttr",
349      function (e) {
350        var r = this,
351          n = !1;
352        return (
353          s.each(e.match(w), function (e, t) {
354            (s.expr.match.bool.test(t) &&
355              r.each(function () {
356                if (!1 !== s(this).prop(t)) return !(n = !0);
357              }),
358              n &&
359                (u(
360                  "removeAttr-bool",
361                  "jQuery.fn.removeAttr no longer sets boolean properties: " +
362                    t,
363                ),
364                r.prop(t, !1)));
365          }),
366          j.apply(this, arguments)
367        );
368      },
369      "removeAttr-bool",
370    ),
371      i(
372        s.fn,
373        "toggleClass",
374        function (t) {
375          return void 0 !== t && "boolean" != typeof t
376            ? b.apply(this, arguments)
377            : (u(
378                "toggleClass-bool",
379                "jQuery.fn.toggleClass( boolean ) is deprecated",
380              ),
381              this.each(function () {
382                var e = (this.getAttribute && this.getAttribute("class")) || "";
383                (e && s.data(this, "__className__", e),
384                  this.setAttribute &&
385                    this.setAttribute(
386                      "class",
387                      (!e && !1 !== t && s.data(this, "__className__")) || "",
388                    ));
389              }));
390        },
391        "toggleClass-bool",
392      ));
393    var Q,
394      A,
395      R = !1,
396      C = /^[a-z]/,
397      N =
398        /^(?:Border(?:Top|Right|Bottom|Left)?(?:Width|)|(?:Margin|Padding)?(?:Top|Right|Bottom|Left)?|(?:Min|Max)?(?:Width|Height))$/;
399    (s.swap &&
400      s.each(["height", "width", "reliableMarginRight"], function (e, t) {
401        var r = s.cssHooks[t] && s.cssHooks[t].get;
402        r &&
403          (s.cssHooks[t].get = function () {
404            var e;
405            return ((R = !0), (e = r.apply(this, arguments)), (R = !1), e);
406          });
407      }),
408      i(
409        s,
410        "swap",
411        function (e, t, r, n) {
412          var o,
413            a,
414            i = {};
415          for (a in (R ||
416            u("swap", "jQuery.swap() is undocumented and deprecated"),
417          t))
418            ((i[a] = e.style[a]), (e.style[a] = t[a]));
419          for (a in ((o = r.apply(e, n || [])), t)) e.style[a] = i[a];
420          return o;
421        },
422        "swap",
423      ),
424      e("3.4.0") &&
425        "undefined" != typeof Proxy &&
426        (s.cssProps = new Proxy(s.cssProps || {}, {
427          set: function () {
428            return (
429              u("cssProps", "jQuery.cssProps is deprecated"),
430              Reflect.set.apply(this, arguments)
431            );
432          },
433        })),
434      e("4.0.0")
435        ? ((A = {
436            animationIterationCount: !0,
437            columnCount: !0,
438            fillOpacity: !0,
439            flexGrow: !0,
440            flexShrink: !0,
441            fontWeight: !0,
442            gridArea: !0,
443            gridColumn: !0,
444            gridColumnEnd: !0,
445            gridColumnStart: !0,
446            gridRow: !0,
447            gridRowEnd: !0,
448            gridRowStart: !0,
449            lineHeight: !0,
450            opacity: !0,
451            order: !0,
452            orphans: !0,
453            widows: !0,
454            zIndex: !0,
455            zoom: !0,
456          }),
457          "undefined" != typeof Proxy
458            ? (s.cssNumber = new Proxy(A, {
459                get: function () {
460                  return (
461                    u("css-number", "jQuery.cssNumber is deprecated"),
462                    Reflect.get.apply(this, arguments)
463                  );
464                },
465                set: function () {
466                  return (
467                    u("css-number", "jQuery.cssNumber is deprecated"),
468                    Reflect.set.apply(this, arguments)
469                  );
470                },
471              }))
472            : (s.cssNumber = A))
473        : (A = s.cssNumber),
474      (Q = s.fn.css),
475      i(
476        s.fn,
477        "css",
478        function (e, t) {
479          var r,
480            n,
481            o = this;
482          return e && "object" == typeof e && !Array.isArray(e)
483            ? (s.each(e, function (e, t) {
484                s.fn.css.call(o, e, t);
485              }),
486              this)
487            : ("number" == typeof t &&
488                ((r = x(e)),
489                (n = r),
490                (C.test(n) && N.test(n[0].toUpperCase() + n.slice(1))) ||
491                  A[r] ||
492                  u(
493                    "css-number",
494                    'Number-typed values are deprecated for jQuery.fn.css( "' +
495                      e +
496                      '", value )',
497                  )),
498              Q.apply(this, arguments));
499        },
500        "css-number",
501      ));
502    var S,
503      P,
504      k,
505      H,
506      E = s.data;
507    (i(
508      s,
509      "data",
510      function (e, t, r) {
511        var n, o, a;
512        if (t && "object" == typeof t && 2 === arguments.length) {
513          for (a in ((n = s.hasData(e) && E.call(this, e)), (o = {}), t))
514            a !== x(a)
515              ? (u(
516                  "data-camelCase",
517                  "jQuery.data() always sets/gets camelCased names: " + a,
518                ),
519                (n[a] = t[a]))
520              : (o[a] = t[a]);
521          return (E.call(this, e, o), t);
522        }
523        return t &&
524          "string" == typeof t &&
525          t !== x(t) &&
526          (n = s.hasData(e) && E.call(this, e)) &&
527          t in n
528          ? (u(
529              "data-camelCase",
530              "jQuery.data() always sets/gets camelCased names: " + t,
531            ),
532            2 < arguments.length && (n[t] = r),
533            n[t])
534          : E.apply(this, arguments);
535      },
536      "data-camelCase",
537    ),
538      s.fx &&
539        ((k = s.Tween.prototype.run),
540        (H = function (e) {
541          return e;
542        }),
543        i(
544          s.Tween.prototype,
545          "run",
546          function () {
547            (1 < s.easing[this.easing].length &&
548              (u(
549                "easing-one-arg",
550                "'jQuery.easing." +
551                  this.easing.toString() +
552                  "' should use only one argument",
553              ),
554              (s.easing[this.easing] = H)),
555              k.apply(this, arguments));
556          },
557          "easing-one-arg",
558        ),
559        (S = s.fx.interval),
560        (P = "jQuery.fx.interval is deprecated"),
561        n.requestAnimationFrame &&
562          Object.defineProperty(s.fx, "interval", {
563            configurable: !0,
564            enumerable: !0,
565            get: function () {
566              return (
567                n.document.hidden || u("fx-interval", P),
568                s.migrateIsPatchEnabled("fx-interval") && void 0 === S ? 13 : S
569              );
570            },
571            set: function (e) {
572              (u("fx-interval", P), (S = e));
573            },
574          })));
575    var M = s.fn.load,
576      q = s.event.add,
577      O = s.event.fix;
578    ((s.event.props = []),
579      (s.event.fixHooks = {}),
580      r(
581        s.event.props,
582        "concat",
583        s.event.props.concat,
584        "event-old-patch",
585        "jQuery.event.props.concat() is deprecated and removed",
586      ),
587      i(
588        s.event,
589        "fix",
590        function (e) {
591          var t,
592            r = e.type,
593            n = this.fixHooks[r],
594            o = s.event.props;
595          if (o.length) {
596            u(
597              "event-old-patch",
598              "jQuery.event.props are deprecated and removed: " + o.join(),
599            );
600            while (o.length) s.event.addProp(o.pop());
601          }
602          if (
603            n &&
604            !n._migrated_ &&
605            ((n._migrated_ = !0),
606            u(
607              "event-old-patch",
608              "jQuery.event.fixHooks are deprecated and removed: " + r,
609            ),
610            (o = n.props) && o.length)
611          )
612            while (o.length) s.event.addProp(o.pop());
613          return ((t = O.call(this, e)), n && n.filter ? n.filter(t, e) : t);
614        },
615        "event-old-patch",
616      ),
617      i(
618        s.event,
619        "add",
620        function (e, t) {
621          return (
622            e === n &&
623              "load" === t &&
624              "complete" === n.document.readyState &&
625              u(
626                "load-after-event",
627                "jQuery(window).on('load'...) called after load event occurred",
628              ),
629            q.apply(this, arguments)
630          );
631        },
632        "load-after-event",
633      ),
634      s.each(["load", "unload", "error"], function (e, t) {
635        i(
636          s.fn,
637          t,
638          function () {
639            var e = Array.prototype.slice.call(arguments, 0);
640            return "load" === t && "string" == typeof e[0]
641              ? M.apply(this, e)
642              : (u(
643                  "shorthand-removed-v3",
644                  "jQuery.fn." + t + "() is deprecated",
645                ),
646                e.splice(0, 0, t),
647                arguments.length
648                  ? this.on.apply(this, e)
649                  : (this.triggerHandler.apply(this, e), this));
650          },
651          "shorthand-removed-v3",
652        );
653      }),
654      s.each(
655        "blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(
656          " ",
657        ),
658        function (e, r) {
659          c(
660            s.fn,
661            r,
662            function (e, t) {
663              return 0 < arguments.length
664                ? this.on(r, null, e, t)
665                : this.trigger(r);
666            },
667            "shorthand-deprecated-v3",
668            "jQuery.fn." + r + "() event shorthand is deprecated",
669          );
670        },
671      ),
672      s(function () {
673        s(n.document).triggerHandler("ready");
674      }),
675      (s.event.special.ready = {
676        setup: function () {
677          this === n.document &&
678            u("ready-event", "'ready' event is deprecated");
679        },
680      }),
681      c(
682        s.fn,
683        "bind",
684        function (e, t, r) {
685          return this.on(e, null, t, r);
686        },
687        "pre-on-methods",
688        "jQuery.fn.bind() is deprecated",
689      ),
690      c(
691        s.fn,
692        "unbind",
693        function (e, t) {
694          return this.off(e, null, t);
695        },
696        "pre-on-methods",
697        "jQuery.fn.unbind() is deprecated",
698      ),
699      c(
700        s.fn,
701        "delegate",
702        function (e, t, r, n) {
703          return this.on(t, e, r, n);
704        },
705        "pre-on-methods",
706        "jQuery.fn.delegate() is deprecated",
707      ),
708      c(
709        s.fn,
710        "undelegate",
711        function (e, t, r) {
712          return 1 === arguments.length
713            ? this.off(e, "**")
714            : this.off(t, e || "**", r);
715        },
716        "pre-on-methods",
717        "jQuery.fn.undelegate() is deprecated",
718      ),
719      c(
720        s.fn,
721        "hover",
722        function (e, t) {
723          return this.on("mouseenter", e).on("mouseleave", t || e);
724        },
725        "pre-on-methods",
726        "jQuery.fn.hover() is deprecated",
727      ));
728    function T(e) {
729      var t = n.document.implementation.createHTMLDocument("");
730      return ((t.body.innerHTML = e), t.body && t.body.innerHTML);
731    }
732    var F =
733      /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi;
734    ((s.UNSAFE_restoreLegacyHtmlPrefilter = function () {
735      s.migrateEnablePatches("self-closed-tags");
736    }),
737      i(
738        s,
739        "htmlPrefilter",
740        function (e) {
741          var t, r;
742          return (
743            (r = (t = e).replace(F, "<$1></$2>")) !== t &&
744              T(t) !== T(r) &&
745              u(
746                "self-closed-tags",
747                "HTML tags must be properly nested and closed: " + t,
748              ),
749            e.replace(F, "<$1></$2>")
750          );
751        },
752        "self-closed-tags",
753      ),
754      s.migrateDisablePatches("self-closed-tags"));
755    var D,
756      W,
757      _,
758      I = s.fn.offset;
759    return (
760      i(
761        s.fn,
762        "offset",
763        function () {
764          var e = this[0];
765          return !e || (e.nodeType && e.getBoundingClientRect)
766            ? I.apply(this, arguments)
767            : (u(
768                "offset-valid-elem",
769                "jQuery.fn.offset() requires a valid DOM element",
770              ),
771              arguments.length ? this : void 0);
772        },
773        "offset-valid-elem",
774      ),
775      s.ajax &&
776        ((D = s.param),
777        i(
778          s,
779          "param",
780          function (e, t) {
781            var r = s.ajaxSettings && s.ajaxSettings.traditional;
782            return (
783              void 0 === t &&
784                r &&
785                (u(
786                  "param-ajax-traditional",
787                  "jQuery.param() no longer uses jQuery.ajaxSettings.traditional",
788                ),
789                (t = r)),
790              D.call(this, e, t)
791            );
792          },
793          "param-ajax-traditional",
794        )),
795      c(
796        s.fn,
797        "andSelf",
798        s.fn.addBack,
799        "andSelf",
800        "jQuery.fn.andSelf() is deprecated and removed, use jQuery.fn.addBack()",
801      ),
802      s.Deferred &&
803        ((W = s.Deferred),
804        (_ = [
805          [
806            "resolve",
807            "done",
808            s.Callbacks("once memory"),
809            s.Callbacks("once memory"),
810            "resolved",
811          ],
812          [
813            "reject",
814            "fail",
815            s.Callbacks("once memory"),
816            s.Callbacks("once memory"),
817            "rejected",
818          ],
819          ["notify", "progress", s.Callbacks("memory"), s.Callbacks("memory")],
820        ]),
821        i(
822          s,
823          "Deferred",
824          function (e) {
825            var a = W(),
826              i = a.promise();
827            function t() {
828              var o = arguments;
829              return s
830                .Deferred(function (n) {
831                  (s.each(_, function (e, t) {
832                    var r = "function" == typeof o[e] && o[e];
833                    a[t[1]](function () {
834                      var e = r && r.apply(this, arguments);
835                      e && "function" == typeof e.promise
836                        ? e
837                            .promise()
838                            .done(n.resolve)
839                            .fail(n.reject)
840                            .progress(n.notify)
841                        : n[t[0] + "With"](
842                            this === i ? n.promise() : this,
843                            r ? [e] : arguments,
844                          );
845                    });
846                  }),
847                    (o = null));
848                })
849                .promise();
850            }
851            return (
852              c(a, "pipe", t, "deferred-pipe", "deferred.pipe() is deprecated"),
853              c(i, "pipe", t, "deferred-pipe", "deferred.pipe() is deprecated"),
854              e && e.call(a, a),
855              a
856            );
857          },
858          "deferred-pipe",
859        ),
860        (s.Deferred.exceptionHook = W.exceptionHook)),
861      s
862    );
863  }));

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.