初始化遮罩信息

@method initMask
@private
547904
function() {
    var self = this;

    // 遮罩层
    if (self.option('mask') && !self.mask) {
      self.mask = new Mask({
        autoShow: self.option('effect') === 'none',
        baseElement: self.option('baseElement'),
        container: self.element,
        css: {
          position: self.option('maskFixed') ? 'fixed' : self.option('css/position')
        },
        delegates: {
          'keydown': function(e) {
            (e.keyCode === 27) && self.close();
          },
          'click': function(e) {
            // shaking
            self.stop()
              .animate({
                left: '-=10'
              }, 40)
              .animate({
                left: '+=20'
              }, 80)
              .animate({
                left: '-=20'
              }, 80)
              .animate({
                left: '+=10'
              }, 40);
          }
        },
        effect: self.option('effect'),
        insert: function() {
          this.container.before(this.element);
        }
      });

      self.show(function() {
        this.mask && this.mask.show();
      }).hide(function() {
        this.mask && this.mask.hide();
      });
    }
  }
601903
function init() {

    // ex. jif(true, div('blah'))
    registerPlugin('jif', function jif(condition, elem) {
        if (utils.isArray(elem)) {
            elem = runtime.naked(elem, null);
        }

        return condition ? elem : null;
    });

    // ex. jeach({}, function (item) {})
    registerPlugin('jeach', function jeach(items, cb) {
        if (!items || !cb) { return null; }

        var ret = [];
        for (var i = 0, len = items.length; i < len; ++i) {
            ret.push(cb(items[i]));
        }

        return ret;
    });
}
398
function initialize() {
  var flags = [];

  Object.keys( levels ).forEach(function( type, level ) {
    var method = type.toLowerCase();
    exports[ method ] = log.bind( exports, type, level, false );
    exports[ method ].json = log.bind( exports, type, level, true );
    if ( new RegExp( '\\b' + type + '\\b', 'i' ).test( env ) ) {
      flags.push( level );
    }
  });

  loglevel = Math.min.apply( Math, flags );
}
1189586
function initAnim(element, gpuTrigger) {
  var style = element.style;
  style.webkitTapHighlightColor = 'transparent';

  // Only when it has no shadow
  var cssPropBoxShadow = CSSPrefix.getName('boxShadow'),
      boxShadow = window.getComputedStyle(element, '')[cssPropBoxShadow];
  if (!boxShadow || boxShadow === 'none') {
    style[cssPropBoxShadow] = '0 0 1px transparent';
  }

  if (gpuTrigger && cssPropTransform) {
    style[cssPropTransform] = 'translateZ(0)';
  }
  return element;
}
521996
private int getVertMask(int vertsCount) {
        int vertMask = Integer.highestOneBit(vertsCount);
        if (vertMask != vertsCount) {
            vertMask *= 2;
        }
        vertMask--;
        return vertMask;
    }
126564
function() {
		if(this.init) { this.init.apply(this, arguments) }
		for (var i=0, mixin; mixin = mixins[i]; i++) {
			if (mixin.init) { mixin.init.apply(this) }
		}
	}
380496
function init() {
        if (isInitialized) {
            return;
        }
    
        isInitialized = true;
    
        // Watch for scroll position changes and trigger recalc/refresh if needed
        function checkScroll() {
            if (window.pageXOffset != scroll.left) {
                scroll.top = window.pageYOffset;
                scroll.left = window.pageXOffset;
    
                Stickyfill.refreshAll();
            } else if (window.pageYOffset != scroll.top) {
                scroll.top = window.pageYOffset;
                scroll.left = window.pageXOffset;
    
                // recalc position for all stickies
                stickies.forEach(function (sticky) {
                    return sticky._recalcPosition();
                });
            }
        }
    
        checkScroll();
        window.addEventListener('scroll', checkScroll);
    
        // Watch for window resizes and device orientation changes and trigger refresh
        window.addEventListener('resize', Stickyfill.refreshAll);
        window.addEventListener('orientationchange', Stickyfill.refreshAll);
    
        //Fast dirty check for layout changes every 500ms
        var fastCheckTimer = void 0;
    
        function startFastCheckTimer() {
            fastCheckTimer = setInterval(function () {
                stickies.forEach(function (sticky) {
                    return sticky._fastCheck();
                });
            }, 500);
        }
    
        function stopFastCheckTimer() {
            clearInterval(fastCheckTimer);
        }
    
        var docHiddenKey = void 0;
        var visibilityChangeEventName = void 0;
    
        if ('hidden' in document) {
            docHiddenKey = 'hidden';
            visibilityChangeEventName = 'visibilitychange';
        } else if ('webkitHidden' in document) {
            docHiddenKey = 'webkitHidden';
            visibilityChangeEventName = 'webkitvisibilitychange';
        }
    
        if (visibilityChangeEventName) {
            if (!document[docHiddenKey]) startFastCheckTimer();
    
            document.addEventListener(visibilityChangeEventName, function () {
                if (document[docHiddenKey]) {
                    stopFastCheckTimer();
                } else {
                    startFastCheckTimer();
                }
            });
        } else startFastCheckTimer();
    }
457007
function $onInit() {
        if (!ctrl.multiple && ctrl.model.length) {
            $scope.item = ctrl.model[0];
        }

        if (ctrl.options instanceof Array) {
            ctrl._options = ctrl.options;
        } else {
            ctrl.options(ctrl.searchTerms, function (options) {
                ctrl._options = options;
                if (options.length === 0) checkLater();
                $scope.$apply();
            });
        }

        if (ctrl.search === undefined) {
            ctrl.search = true; // default true
        }
    }
1145748
function isMasked(x, y) {
    var bit;

    if (x > y) {
      bit = x;
      x   = y;
      y   = bit;
    }

    bit   = y;
    bit  += y * y;
    bit >>= 1;
    bit  += x;

    return frameMask[bit] === 1;
  }
248531
protected function initAutoHide()
    {
        if ($this->getIsDelayed() === false) {
            return null;
        }

        /** @var \yii\web\View $view */
        $view = $this->getView();

        $view->registerJs($this->makeJs(), View::POS_READY);

        AlertAssets::register($view);
    }
379808
def mask(self):
        
        if not hasattr(self, "_mask"):
            self._mask = Mask(self) if self.has_mask() else None
        return self._mask
1232230
function () {
            var elt = this._getInputMarkupDomElt();
            if (elt) {
                this._initInputMarkup(elt);
            }
            var lbl = this._getInputLabelMarkupDomElt();
            if (lbl) {
                this._initLabelMarkup(lbl);
            }
        }
985545
void remask() {
    if (parsedFormatInfo == null) {
      return; // We have no format information, and have no data mask
    }
    DataMask dataMask = DataMask.values()[parsedFormatInfo.getDataMask()];
    int dimension = bitMatrix.getHeight();
    dataMask.unmaskBitMatrix(bitMatrix, dimension);
  }
1234031
function init() {
  var keys = ['\\\\', '\\[', '\\]']
  var key

  for (key in groff) {
    keys.push(key)
    escapes[key] = groff[key]
  }

  return new RegExp(keys.sort(longest).join('|'), 'g')
}
912501
protected function generateFirstMask() {
    $this->mask = array_fill(0, $this->length, 0);
    for ($i = 0; $i < $this->positivesAmount; $i++) {
      $this->mask[$this->length - $i - 1] = 1;
    }
  }
956928
function addMask(resultMask, newMask) {
	// base cases
	if (resultMask === true || newMask === true) return true;
	if (objtools.isScalar(newMask)) return resultMask;
	if (objtools.isScalar(resultMask)) return objtools.deepCopy(newMask);

	var key;
	// If there are keys that exist in result but not in the newMask,
	// and the result mask has a _ key (wildcard), combine
	// the wildcard mask with the new mask, because in the existing
	// result mask, that key has the wildcard permissions
	if ('_' in newMask) {
		for (key in resultMask) {
			if (key !== '_' && !(key in newMask)) resultMask[key] = addMask(resultMask[key], newMask._);
		}
	}
	// same here ... also, copy over or merge fields
	for (key in newMask) {
		if (key !== '_') {
			if (key in resultMask) {
				resultMask[key] = addMask(resultMask[key], newMask[key]);
			} else if ('_' in resultMask) {
				resultMask[key] = addMask(objtools.deepCopy(newMask[key]), resultMask._);
			} else {
				resultMask[key] = objtools.deepCopy(newMask[key]);
			}
		}
	}
	// fill in the _ key that we skipped earlier
	if ('_' in newMask) {
		resultMask._ = ('_' in resultMask)
			? addMask(resultMask._, newMask._)
			: objtools.deepCopy(newMask._);
	}
	// If there is a wildcard, remove any keys that are set to the same thing as the wildcard
	// This isn't strictly necessary, but removes redundant data
	if ('_' in resultMask) {
		for (key in resultMask) {
			if (key !== '_' && objtools.deepEquals(resultMask[key], resultMask._)) {
				delete resultMask[key];
			}
		}
	}
	return resultMask || false;
}
395721
function init (cfg) {
  renderer.Document = cfg.Document;
  renderer.Element = cfg.Element;
  renderer.Comment = cfg.Comment;
  renderer.sendTasks = cfg.sendTasks;
}