text: import * as Util from './Util';
  
  // @class Class
  // @aka L.Class
  
  // @section
  // @uninheritable
  
  // Thanks to John Resig and Dean Edwards for inspiration!
  
  export function Class() {
  }
  
  Class.extend = function (props) {
  
    // @function extend(props: Object): Function
    // [Extends the current class](#class-inheritance) given the properties to be included.
    // Returns a Javascript function that is a class constructor (to be called with `new`).
    var NewClass = function () {
  
      // call the constructor
      if (this.initialize) {
        this.initialize.apply(this, arguments);
      }
  
      // call all constructor hooks
      this.callInitHooks();
    };
  
    var parentProto = NewClass.__super__ = this.prototype;
  
    var proto = Util.create(parentProto);
    proto.constructor = NewClass;
  
    NewClass.prototype = proto;
  
    // inherit parent's statics
    for (var i in this) {
      if (Object.prototype.hasOwnProperty.call(this, i) && i !== 'prototype' && i !== '__super__') {
        NewClass[i] = this[i];
      }
    }
  
    // mix static properties into the class
    if (props.statics) {
      Util.extend(NewClass, props.statics);
      delete props.statics;
    }
  
    // mix includes into the prototype
    if (props.includes) {
      checkDeprecatedMixinEvents(props.includes);
      Util.extend.apply(null, [proto].concat(props.includes));
      delete props.includes;
    }
  
    // merge options
    if (proto.options) {
      props.options = Util.extend(Util.create(proto.options), props.options);
    }
  
    // mix given properties into the prototype
    Util.extend(proto, props);
  
    proto._initHooks = [];
  
    // add method for calling all hooks
    proto.callInitHooks = function () {
  
      if (this._initHooksCalled) {
        return;
      }
  
      if (parentProto.callInitHooks) {
        parentProto.callInitHooks.call(this);
      }
  
      this._initHooksCalled = true;
  
      for (var i = 0, len = proto._initHooks.length; i < len; i++) {
        proto._initHooks[i].call(this);
      }
    };
  
    return NewClass;
  };
  
  
  // @function include(properties: Object): this
  // [Includes a mixin](#class-includes) into the current class.
  Class.include = function (props) {
    Util.extend(this.prototype, props);
    return this;
  };
  
  // @function mergeOptions(options: Object): this
  // [Merges `options`](#class-options) into the defaults of the class.
  Class.mergeOptions = function (options) {
    Util.extend(this.prototype.options, options);
    return this;
  };
  
  // @function addInitHook(fn: Function): this
  // Adds a [constructor hook](#class-constructor-hooks) to the class.
  Class.addInitHook = function (fn) { // (Function) || (String, args...)
    var args = Array.prototype.slice.call(arguments, 1);
  
    var init = typeof fn === 'function' ? fn : function () {
      this[fn].apply(this, args);
    };
  
    this.prototype._initHooks = this.prototype._initHooks || [];
    this.prototype._initHooks.push(init);
    return this;
  };
  
  function checkDeprecatedMixinEvents(includes) {
    if (typeof L === 'undefined' || !L || !L.Mixin) {
      return;
    }
  
    includes = Util.isArray(includes) ? includes : [includes];
  
    for (var i = 0; i < includes.length; i++) {
      if (includes[i] === L.Mixin.Events) {
        console.warn('Deprecated include of L.Mixin.Events: ' +
          'this property will be removed in future releases, ' +
          'please inherit from L.Evented instead.', new Error().stack);
      }
    }
  }
  