Subversion-Projekte lars-tiefland.laravel_shop

/*! jQuery UI - v1.12.1+0b7246b6eeadfa9e2696e22f3230f6452f8129dc - 2020-02-20

 * http://jqueryui.com

 * Includes: widget.js

 * Copyright jQuery Foundation and other contributors; Licensed MIT */

/* global define, require */

/* eslint-disable no-param-reassign, new-cap, jsdoc/require-jsdoc */

(function (factory) {

  'use strict';

  if (typeof define === 'function' && define.amd) {

    // AMD. Register as an anonymous module.

    define(['jquery'], factory);

  } else if (typeof exports === 'object') {

    // Node/CommonJS

    factory(require('jquery'));

  } else {

    // Browser globals

    factory(window.jQuery);

  }

})(function ($) {

  ('use strict');

  $.ui = $.ui || {};

  $.ui.version = '1.12.1';

  /*!

   * jQuery UI Widget 1.12.1

   * http://jqueryui.com

   *

   * Copyright jQuery Foundation and other contributors

   * Released under the MIT license.

   * http://jquery.org/license

   */

  //>>label: Widget

  //>>group: Core

  //>>description: Provides a factory for creating stateful widgets with a common API.

  //>>docs: http://api.jqueryui.com/jQuery.widget/

  //>>demos: http://jqueryui.com/widget/

  // Support: jQuery 1.9.x or older

  // $.expr[ ":" ] is deprecated.

  if (!$.expr.pseudos) {

    $.expr.pseudos = $.expr[':'];

  }

  // Support: jQuery 1.11.x or older

  // $.unique has been renamed to $.uniqueSort

  if (!$.uniqueSort) {

    $.uniqueSort = $.unique;

  }

  var widgetUuid = 0;

  var widgetHasOwnProperty = Array.prototype.hasOwnProperty;

  var widgetSlice = Array.prototype.slice;

  $.cleanData = (function (orig) {

    return function (elems) {

      var events, elem, i;

      // eslint-disable-next-line eqeqeq

      for (i = 0; (elem = elems[i]) != null; i++) {

        // Only trigger remove when necessary to save time

        events = $._data(elem, 'events');

        if (events && events.remove) {

          $(elem).triggerHandler('remove');

        }

      }

      orig(elems);

    };

  })($.cleanData);

  $.widget = function (name, base, prototype) {

    var existingConstructor, constructor, basePrototype;

    // ProxiedPrototype allows the provided prototype to remain unmodified

    // so that it can be used as a mixin for multiple widgets (#8876)

    var proxiedPrototype = {};

    var namespace = name.split('.')[0];

    name = name.split('.')[1];

    var fullName = namespace + '-' + name;

    if (!prototype) {

      prototype = base;

      base = $.Widget;

    }

    if ($.isArray(prototype)) {

      prototype = $.extend.apply(null, [{}].concat(prototype));

    }

    // Create selector for plugin

    $.expr.pseudos[fullName.toLowerCase()] = function (elem) {

      return !!$.data(elem, fullName);

    };

    $[namespace] = $[namespace] || {};

    existingConstructor = $[namespace][name];

    constructor = $[namespace][name] = function (options, element) {

      // Allow instantiation without "new" keyword

      if (!this._createWidget) {

        return new constructor(options, element);

      }

      // Allow instantiation without initializing for simple inheritance

      // must use "new" keyword (the code above always passes args)

      if (arguments.length) {

        this._createWidget(options, element);

      }

    };

    // Extend with the existing constructor to carry over any static properties

    $.extend(constructor, existingConstructor, {

      version: prototype.version,

      // Copy the object used to create the prototype in case we need to

      // redefine the widget later

      _proto: $.extend({}, prototype),

      // Track widgets that inherit from this widget in case this widget is

      // redefined after a widget inherits from it

      _childConstructors: []

    });

    basePrototype = new base();

    // We need to make the options hash a property directly on the new instance

    // otherwise we'll modify the options hash on the prototype that we're

    // inheriting from

    basePrototype.options = $.widget.extend({}, basePrototype.options);

    $.each(prototype, function (prop, value) {

      if (!$.isFunction(value)) {

        proxiedPrototype[prop] = value;

        return;

      }

      proxiedPrototype[prop] = (function () {

        function _super() {

          return base.prototype[prop].apply(this, arguments);

        }

        function _superApply(args) {

          return base.prototype[prop].apply(this, args);

        }

        return function () {

          var __super = this._super;

          var __superApply = this._superApply;

          var returnValue;

          this._super = _super;

          this._superApply = _superApply;

          returnValue = value.apply(this, arguments);

          this._super = __super;

          this._superApply = __superApply;

          return returnValue;

        };

      })();

    });

    constructor.prototype = $.widget.extend(

      basePrototype,

      {

        // TODO: remove support for widgetEventPrefix

        // always use the name + a colon as the prefix, e.g., draggable:start

        // don't prefix for widgets that aren't DOM-based

        widgetEventPrefix: existingConstructor

          ? basePrototype.widgetEventPrefix || name

          : name

      },

      proxiedPrototype,

      {

        constructor: constructor,

        namespace: namespace,

        widgetName: name,

        widgetFullName: fullName

      }

    );

    // If this widget is being redefined then we need to find all widgets that

    // are inheriting from it and redefine all of them so that they inherit from

    // the new version of this widget. We're essentially trying to replace one

    // level in the prototype chain.

    if (existingConstructor) {

      $.each(existingConstructor._childConstructors, function (i, child) {

        var childPrototype = child.prototype;

        // Redefine the child widget using the same prototype that was

        // originally used, but inherit from the new version of the base

        $.widget(

          childPrototype.namespace + '.' + childPrototype.widgetName,

          constructor,

          child._proto

        );

      });

      // Remove the list of existing child constructors from the old constructor

      // so the old child constructors can be garbage collected

      delete existingConstructor._childConstructors;

    } else {

      base._childConstructors.push(constructor);

    }

    $.widget.bridge(name, constructor);

    return constructor;

  };

  $.widget.extend = function (target) {

    var input = widgetSlice.call(arguments, 1);

    var inputIndex = 0;

    var inputLength = input.length;

    var key;

    var value;

    for (; inputIndex < inputLength; inputIndex++) {

      for (key in input[inputIndex]) {

        value = input[inputIndex][key];

        if (

          widgetHasOwnProperty.call(input[inputIndex], key) &&

          value !== undefined

        ) {

          // Clone objects

          if ($.isPlainObject(value)) {

            target[key] = $.isPlainObject(target[key])

              ? $.widget.extend({}, target[key], value)

              : // Don't extend strings, arrays, etc. with objects

                $.widget.extend({}, value);

            // Copy everything else by reference

          } else {

            target[key] = value;

          }

        }

      }

    }

    return target;

  };

  $.widget.bridge = function (name, object) {

    var fullName = object.prototype.widgetFullName || name;

    $.fn[name] = function (options) {

      var isMethodCall = typeof options === 'string';

      var args = widgetSlice.call(arguments, 1);

      var returnValue = this;

      if (isMethodCall) {

        // If this is an empty collection, we need to have the instance method

        // return undefined instead of the jQuery instance

        if (!this.length && options === 'instance') {

          returnValue = undefined;

        } else {

          this.each(function () {

            var methodValue;

            var instance = $.data(this, fullName);

            if (options === 'instance') {

              returnValue = instance;

              return false;

            }

            if (!instance) {

              return $.error(

                'cannot call methods on ' +

                  name +

                  ' prior to initialization; ' +

                  "attempted to call method '" +

                  options +

                  "'"

              );

            }

            if (!$.isFunction(instance[options]) || options.charAt(0) === '_') {

              return $.error(

                "no such method '" +

                  options +

                  "' for " +

                  name +

                  ' widget instance'

              );

            }

            methodValue = instance[options].apply(instance, args);

            if (methodValue !== instance && methodValue !== undefined) {

              returnValue =

                methodValue && methodValue.jquery

                  ? returnValue.pushStack(methodValue.get())

                  : methodValue;

              return false;

            }

          });

        }

      } else {

        // Allow multiple hashes to be passed on init

        if (args.length) {

          options = $.widget.extend.apply(null, [options].concat(args));

        }

        this.each(function () {

          var instance = $.data(this, fullName);

          if (instance) {

            instance.option(options || {});

            if (instance._init) {

              instance._init();

            }

          } else {

            $.data(this, fullName, new object(options, this));

          }

        });

      }

      return returnValue;

    };

  };

  $.Widget = function (/* options, element */) {};

  $.Widget._childConstructors = [];

  $.Widget.prototype = {

    widgetName: 'widget',

    widgetEventPrefix: '',

    defaultElement: '<div>',

    options: {

      classes: {},

      disabled: false,

      // Callbacks

      create: null

    },

    _createWidget: function (options, element) {

      element = $(element || this.defaultElement || this)[0];

      this.element = $(element);

      this.uuid = widgetUuid++;

      this.eventNamespace = '.' + this.widgetName + this.uuid;

      this.bindings = $();

      this.hoverable = $();

      this.focusable = $();

      this.classesElementLookup = {};

      if (element !== this) {

        $.data(element, this.widgetFullName, this);

        this._on(true, this.element, {

          remove: function (event) {

            if (event.target === element) {

              this.destroy();

            }

          }

        });

        this.document = $(

          element.style

            ? // Element within the document

              element.ownerDocument

            : // Element is window or document

              element.document || element

        );

        this.window = $(

          this.document[0].defaultView || this.document[0].parentWindow

        );

      }

      this.options = $.widget.extend(

        {},

        this.options,

        this._getCreateOptions(),

        options

      );

      this._create();

      if (this.options.disabled) {

        this._setOptionDisabled(this.options.disabled);

      }

      this._trigger('create', null, this._getCreateEventData());

      this._init();

    },

    _getCreateOptions: function () {

      return {};

    },

    _getCreateEventData: $.noop,

    _create: $.noop,

    _init: $.noop,

    destroy: function () {

      var that = this;

      this._destroy();

      $.each(this.classesElementLookup, function (key, value) {

        that._removeClass(value, key);

      });

      // We can probably remove the unbind calls in 2.0

      // all event bindings should go through this._on()

      this.element.off(this.eventNamespace).removeData(this.widgetFullName);

      this.widget().off(this.eventNamespace).removeAttr('aria-disabled');

      // Clean up events and states

      this.bindings.off(this.eventNamespace);

    },

    _destroy: $.noop,

    widget: function () {

      return this.element;

    },

    option: function (key, value) {

      var options = key;

      var parts;

      var curOption;

      var i;

      if (arguments.length === 0) {

        // Don't return a reference to the internal hash

        return $.widget.extend({}, this.options);

      }

      if (typeof key === 'string') {

        // Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }

        options = {};

        parts = key.split('.');

        key = parts.shift();

        if (parts.length) {

          curOption = options[key] = $.widget.extend({}, this.options[key]);

          for (i = 0; i < parts.length - 1; i++) {

            curOption[parts[i]] = curOption[parts[i]] || {};

            curOption = curOption[parts[i]];

          }

          key = parts.pop();

          if (arguments.length === 1) {

            return curOption[key] === undefined ? null : curOption[key];

          }

          curOption[key] = value;

        } else {

          if (arguments.length === 1) {

            return this.options[key] === undefined ? null : this.options[key];

          }

          options[key] = value;

        }

      }

      this._setOptions(options);

      return this;

    },

    _setOptions: function (options) {

      var key;

      for (key in options) {

        this._setOption(key, options[key]);

      }

      return this;

    },

    _setOption: function (key, value) {

      if (key === 'classes') {

        this._setOptionClasses(value);

      }

      this.options[key] = value;

      if (key === 'disabled') {

        this._setOptionDisabled(value);

      }

      return this;

    },

    _setOptionClasses: function (value) {

      var classKey, elements, currentElements;

      for (classKey in value) {

        currentElements = this.classesElementLookup[classKey];

        if (

          value[classKey] === this.options.classes[classKey] ||

          !currentElements ||

          !currentElements.length

        ) {

          continue;

        }

        // We are doing this to create a new jQuery object because the _removeClass() call

        // on the next line is going to destroy the reference to the current elements being

        // tracked. We need to save a copy of this collection so that we can add the new classes

        // below.

        elements = $(currentElements.get());

        this._removeClass(currentElements, classKey);

        // We don't use _addClass() here, because that uses this.options.classes

        // for generating the string of classes. We want to use the value passed in from

        // _setOption(), this is the new value of the classes option which was passed to

        // _setOption(). We pass this value directly to _classes().

        elements.addClass(

          this._classes({

            element: elements,

            keys: classKey,

            classes: value,

            add: true

          })

        );

      }

    },

    _setOptionDisabled: function (value) {

      this._toggleClass(

        this.widget(),

        this.widgetFullName + '-disabled',

        null,

        !!value

      );

      // If the widget is becoming disabled, then nothing is interactive

      if (value) {

        this._removeClass(this.hoverable, null, 'ui-state-hover');

        this._removeClass(this.focusable, null, 'ui-state-focus');

      }

    },

    enable: function () {

      return this._setOptions({ disabled: false });

    },

    disable: function () {

      return this._setOptions({ disabled: true });

    },

    _classes: function (options) {

      var full = [];

      var that = this;

      options = $.extend(

        {

          element: this.element,

          classes: this.options.classes || {}

        },

        options

      );

      function bindRemoveEvent() {

        options.element.each(function (_, element) {

          var isTracked = $.map(that.classesElementLookup, function (elements) {

            return elements;

          }).some(function (elements) {

            return elements.is(element);

          });

          if (!isTracked) {

            that._on($(element), {

              remove: '_untrackClassesElement'

            });

          }

        });

      }

      function processClassString(classes, checkOption) {

        var current, i;

        for (i = 0; i < classes.length; i++) {

          current = that.classesElementLookup[classes[i]] || $();

          if (options.add) {

            bindRemoveEvent();

            current = $(

              $.uniqueSort(current.get().concat(options.element.get()))

            );

          } else {

            current = $(current.not(options.element).get());

          }

          that.classesElementLookup[classes[i]] = current;

          full.push(classes[i]);

          if (checkOption && options.classes[classes[i]]) {

            full.push(options.classes[classes[i]]);

          }

        }

      }

      if (options.keys) {

        processClassString(options.keys.match(/\S+/g) || [], true);

      }

      if (options.extra) {

        processClassString(options.extra.match(/\S+/g) || []);

      }

      return full.join(' ');

    },

    _untrackClassesElement: function (event) {

      var that = this;

      $.each(that.classesElementLookup, function (key, value) {

        if ($.inArray(event.target, value) !== -1) {

          that.classesElementLookup[key] = $(value.not(event.target).get());

        }

      });

      this._off($(event.target));

    },

    _removeClass: function (element, keys, extra) {

      return this._toggleClass(element, keys, extra, false);

    },

    _addClass: function (element, keys, extra) {

      return this._toggleClass(element, keys, extra, true);

    },

    _toggleClass: function (element, keys, extra, add) {

      add = typeof add === 'boolean' ? add : extra;

      var shift = typeof element === 'string' || element === null,

        options = {

          extra: shift ? keys : extra,

          keys: shift ? element : keys,

          element: shift ? this.element : element,

          add: add

        };

      options.element.toggleClass(this._classes(options), add);

      return this;

    },

    _on: function (suppressDisabledCheck, element, handlers) {

      var delegateElement;

      var instance = this;

      // No suppressDisabledCheck flag, shuffle arguments

      if (typeof suppressDisabledCheck !== 'boolean') {

        handlers = element;

        element = suppressDisabledCheck;

        suppressDisabledCheck = false;

      }

      // No element argument, shuffle and use this.element

      if (!handlers) {

        handlers = element;

        element = this.element;

        delegateElement = this.widget();

      } else {

        element = delegateElement = $(element);

        this.bindings = this.bindings.add(element);

      }

      $.each(handlers, function (event, handler) {

        function handlerProxy() {

          // Allow widgets to customize the disabled handling

          // - disabled as an array instead of boolean

          // - disabled class as method for disabling individual parts

          if (

            !suppressDisabledCheck &&

            (instance.options.disabled === true ||

              $(this).hasClass('ui-state-disabled'))

          ) {

            return;

          }

          return (

            typeof handler === 'string' ? instance[handler] : handler

          ).apply(instance, arguments);

        }

        // Copy the guid so direct unbinding works

        if (typeof handler !== 'string') {

          handlerProxy.guid = handler.guid =

            handler.guid || handlerProxy.guid || $.guid++;

        }

        var match = event.match(/^([\w:-]*)\s*(.*)$/);

        var eventName = match[1] + instance.eventNamespace;

        var selector = match[2];

        if (selector) {

          delegateElement.on(eventName, selector, handlerProxy);

        } else {

          element.on(eventName, handlerProxy);

        }

      });

    },

    _off: function (element, eventName) {

      eventName =

        (eventName || '').split(' ').join(this.eventNamespace + ' ') +

        this.eventNamespace;

      element.off(eventName);

      // Clear the stack to avoid memory leaks (#10056)

      this.bindings = $(this.bindings.not(element).get());

      this.focusable = $(this.focusable.not(element).get());

      this.hoverable = $(this.hoverable.not(element).get());

    },

    _delay: function (handler, delay) {

      var instance = this;

      function handlerProxy() {

        return (

          typeof handler === 'string' ? instance[handler] : handler

        ).apply(instance, arguments);

      }

      return setTimeout(handlerProxy, delay || 0);

    },

    _hoverable: function (element) {

      this.hoverable = this.hoverable.add(element);

      this._on(element, {

        mouseenter: function (event) {

          this._addClass($(event.currentTarget), null, 'ui-state-hover');

        },

        mouseleave: function (event) {

          this._removeClass($(event.currentTarget), null, 'ui-state-hover');

        }

      });

    },

    _focusable: function (element) {

      this.focusable = this.focusable.add(element);

      this._on(element, {

        focusin: function (event) {

          this._addClass($(event.currentTarget), null, 'ui-state-focus');

        },

        focusout: function (event) {

          this._removeClass($(event.currentTarget), null, 'ui-state-focus');

        }

      });

    },

    _trigger: function (type, event, data) {

      var prop, orig;

      var callback = this.options[type];

      data = data || {};

      event = $.Event(event);

      event.type = (

        type === this.widgetEventPrefix ? type : this.widgetEventPrefix + type

      ).toLowerCase();

      // The original event may come from any element

      // so we need to reset the target on the new event

      event.target = this.element[0];

      // Copy original event properties over to the new event

      orig = event.originalEvent;

      if (orig) {

        for (prop in orig) {

          if (!(prop in event)) {

            event[prop] = orig[prop];

          }

        }

      }

      this.element.trigger(event, data);

      return !(

        ($.isFunction(callback) &&

          callback.apply(this.element[0], [event].concat(data)) === false) ||

        event.isDefaultPrevented()

      );

    }

  };

  $.each({ show: 'fadeIn', hide: 'fadeOut' }, function (method, defaultEffect) {

    $.Widget.prototype['_' + method] = function (element, options, callback) {

      if (typeof options === 'string') {

        options = { effect: options };

      }

      var hasOptions;

      var effectName = !options

        ? method

        : options === true || typeof options === 'number'

        ? defaultEffect

        : options.effect || defaultEffect;

      options = options || {};

      if (typeof options === 'number') {

        options = { duration: options };

      }

      hasOptions = !$.isEmptyObject(options);

      options.complete = callback;

      if (options.delay) {

        element.delay(options.delay);

      }

      if (hasOptions && $.effects && $.effects.effect[effectName]) {

        element[method](options);

      } else if (effectName !== method && element[effectName]) {

        element[effectName](options.duration, options.easing, callback);

      } else {

        element.queue(function (next) {

          $(this)[method]();

          if (callback) {

            callback.call(element[0]);

          }

          next();

        });

      }

    };

  });

});