Plugin | vue-head
@param  {Function} Vue
@param  {Object} options
322851
function VueHead (Vue, options) {
    if (installed) return

    installed = true

    if (options) {
      Vue.util.extend(opt, options)
    }

    /**
     * Initializes and updates the elements in the head
     * @param  {Boolean} update
     */
    function init (update) {
      var self = this
      var head = (typeof self.$options.head === 'function') ? self.$options.head.bind(self)() : self.$options.head
      if (!head) return
      Object.keys(head).map(function (key) {
        var prop = head[key]
        if (!prop) return
        var obj = (typeof prop === 'function') ? head[key].bind(self)() : head[key]
        if (key === 'title') {
          util[key](obj)
          return
        }
        util.handle(obj, key, 'head', update)
      })
      self.$emit('okHead')
    }

    /**
     * Remove the meta tags elements in the head
     */
    function destroy () {
      if (!this.$options.head) return
      util.undoTitle(diffTitle)
      util.undo()
    }

    // v1
    if (Vue.version.match(/[1].(.)+/g)) {
      Vue.mixin({
        ready: function () {
          init.bind(this)()
        },
        destroyed: function () {
          destroy.bind(this)()
        },
        events: {
          updateHead: function () {
            init.bind(this)(true)
            util.update()
          }
        }
      })
    }
    // v2
    if (Vue.version.match(/[2].(.)+/g)) {
      Vue.mixin({
        created: function () {
          var self = this
          self.$on('updateHead', function () {
            init.bind(self)(true)
            util.update()
          })
        },
        mounted: function () {
          init.bind(this)()
        },
        beforeDestroy: function () {
          destroy.bind(this)()
        }
      })
    }
  }
15789
function plugin(options) {

    return function(files, metalsmith, done) {

        Object.keys(files).forEach(function(file) {
            var data = files[file];
            data.contents = new Buffer(special(data.contents.toString()));
        });
        done();
    }
}
319021
function(options) {
        this.$main.addClass(defaultClass + ' ' + options.customClass);

        this.$main.placeholder();

        if (options.disabled) {
            this.disable();
        }

        this.$main.on('mouseover.bizTextarea', function() {
            $(this).addClass(hoverClass);
        }).on('mouseout.bizTextarea', function() {
            $(this).removeClass(hoverClass);
        }).on('focus.bizTextarea', function() {
            $(this).addClass(focusClass + options.theme);
        }).on('blur.bizTextarea', function() {
            $(this).removeClass(focusClass + options.theme);
        });
    }
740620
function Plugin(option, args) {
    return this.each(function() {
      var $this = $(this);
      var data = $this.data('bs.maskedinput');
      var options = typeof option == 'object' && option;
      if (!data) {
        $this.data('bs.maskedinput', (data = new MaskedInput(this, options)));
      }
      if (typeof option == 'string') {
        data[option](args);
      }
    });
  }
1324301
function (vnode, options) {
    const scroller = getParentScroller(vnode)
    const scrollDirection = scroller.scrollDirection || 'vertical'

    if (scroller && scroller.$el && vnode.$el) {
      // if it's a list, then the listVnode.scrollDirection is undefined. just
      // assum it is the default value 'vertical'.
      const dSuffix = ({
        horizontal: 'Left',
        vertical: 'Top'
      })[scrollDirection]
      let offset = vnode.$el[`offset${dSuffix}`]

      if (options) {
        offset += Number(options.offset) || 0
        offset *= jud.config.env.scale /* adapt offset to different screen scales. */
      }
      else if (process.env.NODE_ENV === 'development') {
        console.warn('[Vue Render] The second parameter of "scrollToElement" is required, '
          + 'otherwise it may not works well on native.')
      }

      step({
        scrollable: scroller.$el,
        startTime: now(),
        frame: null,
        startPosition: scroller.$el[`scroll${dSuffix}`],
        position: offset,
        method: scrollElement,
        dSuffix: dSuffix
      })
    }
  }
1350467
function (inputNodes, options) {
  options = options || {}
  Plugin.call(this, inputNodes, {
    annotations: options.annotations
  })
  this.options = options
}
79009
function install(Vue) {
  for (const name in components) {
    const component = components[name].component || components[name]
    Vue.component(name, component)
  }
  Vue.prototype.$actionSheet = $actionSheet
  Vue.prototype.$loading = $loading
  Vue.prototype.$toast = $toast
  Vue.prototype.$dialog = $dialog
}
882461
function Plugin(option) {
			return this.each(function () {
				var $this = $(this);
				var data = $this.data("bs.dropdown");

				if (!data) $this.data("bs.dropdown", (data = new Dropdown(this)));
				if (typeof option == "string") data[option].call($this);
			});
		}
1136483
function injectTemplate(template) {
  let js = [
    '',
    'var __vue__options__ = (module.exports.__esModule) ?',
    'module.exports.default : module.exports;',
    '__vue__options__.template = ' + JSON.stringify(template) + ';',
    '',
  ];

  return js.join(os.EOL);
}
1212400
function(options) {
        this.$main.addClass([defaultClass, options.customClass, prefix + options.theme].join(' '))
            .html('<div><pre></pre></div><textarea></textarea>');

        var w = options.width || this.$main.width(),
            h = options.height || this.$main.height();

        w = Math.max(w, 200);
        h = Math.max(h, 52);

        this.$main.css({
            width: w,
            height: h
        });

        this.$line = this.$main.children('div').css({
            height: h - 10
        });
        this.$lineNumber = this.$main.find('pre');
        this.$textarea = this.$main.children('textarea').css({
            width: w - 36,
            height: h - 12
        });

        if (options.disabled) {
            this.disable();
        }

        var self = this;
        this.$textarea.on('mouseover.bizTextline', function() {
            $(this).addClass(hoverClass);
        }).on('mouseout.bizTextline', function() {
            $(this).removeClass(hoverClass);
        }).on('focus.bizTextline', function() {
            $(this).addClass(focusClass + options.theme);
        }).on('blur.bizTextline', function() {
            $(this).removeClass(focusClass + options.theme);
        }).on('keyup.bizTextline.render', function(e) {
            self.renderLineNumber(e.target.scrollTop);
        }).on('scroll.bizTextline', function(e) {
            self.scrollLineNumber(e.target.scrollTop);
        });

        if (parseInt(options.maxLine, 10) >= 1) {
            this.$textarea.on('keyup.bizTextline.maxLine', function(e) {
                if (e.keyCode === 13) {
                    var valArray = self.valArray(),
                        length = valArray.length;
                    if (length > options.maxLine) {
                        valArray.splice(options.maxLine, length - options.maxLine);
                        self.valArray(valArray);
                    }
                }
            });
        }

        this.renderLineNumber(0);

        if (typeof options.val === 'string') {
            this.val(options.val);
        }

        if (jQuery.isArray(options.valArray)) {
            this.valArray(options.valArray);
        }
    }
539977
def head(path, options = {})
      options = options.merge(:head => true) # No parsing!
      execute('HEAD', path, options)
    end
1200220
function Plugin(option) {
    return this.each(function () {
      var $this = $(this);
      var data  = $this.data(DataKey);

      if (!data) {
        var options = $.extend({}, Default, $this.data(), typeof option == 'object' && option);
        $this.data(DataKey, new Tree($this, options));
      }
    });
  }
384678
function install (Vue, options = {}) {
  options.lang = options.lang || 'zh_cn'
  Object.assign(validator, options.validators)
  Object.assign(lang[options.lang], options.messages)
  try {
    const directive = new Directive(Vue, {
      mode: options.mode,
      errorIcon: options.errorIcon,
      errorClass: options.errorClass || null,
      errorForm: options.errorForm,
      validators: validator,
      messages: lang[options.lang]
    })
    directive.install(Vue)
  } catch (e) {
    console.error(`${e}\nfrom v-verify`)
  }
}
799008
public function head($url, $body = [], $headers = [], $options = [])
    {
        return $this->request('HEAD', $url, $body, $headers, $options);
    }
1088227
public function head($url, $headers = [], $options = [])
    {
        return $this->createRequestShortcut('HEAD', $url, null, $headers, $options);
    }
1075500
public function head($url, array $options = array())
    {
        $options[CURLOPT_NOBODY] = true;
        return $this->makeRequest($url, $options);
    }
928298
function plugin(options) {
    if (!options || typeof options !== 'object') {
        throw new Error('AjvMoment#plugin requires options');
    }
    if (!options.ajv) {
        throw new Error(`AjvMoment#plugin options requries an 'ajv' attribute (ajv instance)`);
    }
    if (!options.moment) {
        throw new Error(`AjvMoment#plugin options requries a 'moment' attribute (moment.js)`);
    }
    const { ajv, moment } = options;
    ajv.moment = moment;
    const keywordSettings = {
        type: 'string',
        statements: true,
        errors: true,
        inline
    };
    if (ajv) {
        ajv.addKeyword('moment', keywordSettings);
    }
    return keywordSettings;
}