Initializes React Native plugin
481998
function reactNativePlugin(Raven, options, internalDataCallback) {
  options = options || {};

  // Use data callback to strip device-specific paths from stack traces
  Raven.setDataCallback(
    wrappedCallback(function(data) {
      data = reactNativePlugin._normalizeData(data, options.pathStrip);
      if (internalDataCallback) {
        internalDataCallback(data);
      }
    })
  );

  if (options.nativeClientAvailable === false) {
    // react-native doesn't have a document, so can't use default Image
    // transport - use XMLHttpRequest instead
    Raven.setTransport(reactNativePlugin._transport);

    // Check for a previously persisted payload, and report it.
    reactNativePlugin._restorePayload().then(function(payload) {
      options.onInitialize && options.onInitialize(payload);
      if (!payload) return;
      Raven._sendProcessedPayload(payload, function(error) {
        if (error) return; // Try again next launch.
        reactNativePlugin._clearPayload();
      });
    })['catch'](function() {});

    Raven.setShouldSendCallback(function(data, originalCallback) {
      if (!(FATAL_ERROR_KEY in data)) {
        // not a fatal (will not crash runtime), continue as planned
        return originalCallback ? originalCallback.call(this, data) : true;
      }

      var origError = data[FATAL_ERROR_KEY];
      delete data[FATAL_ERROR_KEY];

      reactNativePlugin._persistPayload(data).then(function() {
        defaultHandler(origError, true);
        handlingFatal = false; // In case it isn't configured to crash.
        return null;
      })['catch'](function() {});

      return false; // Do not continue.
    });
  }

  // Make sure that if multiple fatals occur, we only persist the first one.
  //
  // The first error is probably the most important/interesting error, and we
  // want to crash ASAP, rather than potentially queueing up multiple errors.
  var handlingFatal = false;

  var defaultHandler =
    (ErrorUtils.getGlobalHandler && ErrorUtils.getGlobalHandler()) ||
    ErrorUtils._globalHandler;

  if (options.handlePromiseRejection) {
    // Track unhandled promise rejections
    var tracking = require('promise/setimmediate/rejection-tracking');
    tracking.disable();
    tracking.enable({
      allRejections: true,
      onUnhandled: function(id, error) {
        var captureOptions = {
          timestamp: new Date() / 1000,
          type: 'Unhandled Promise Rejection'
        };
        Raven.captureException(error, captureOptions);
      },
      onHandled: function() {}
    });
  }

  ErrorUtils.setGlobalHandler(function(error, isFatal) {
    var captureOptions = {
      timestamp: new Date() / 1000
    };
    var error = arguments[0];
    if (isFatal) {
      captureOptions.level = 'fatal';
    }
    // We want to handle fatals, but only in production mode.
    var shouldHandleFatal = isFatal && !global.__DEV__;
    if (shouldHandleFatal) {
      if (handlingFatal) {
        console.log('Encountered multiple fatals in a row. The latest:', error);
        return;
      }
      handlingFatal = true;
      // We need to preserve the original error so that it can be rethrown
      // after it is persisted (see our shouldSendCallback above).
      captureOptions[FATAL_ERROR_KEY] = error;
    }
    Raven.captureException(error, captureOptions);
    if (options.nativeClientAvailable) {
      // We always want to tunnel errors to the default handler
      Sentry._setInternalEventStored(() => {
        defaultHandler(error, isFatal);
      });
    } else {
      // if we don't have a native
      defaultHandler(error, isFatal);
    }
  });
}
1330832
def pyang_plugin_init():
    """"""

    # Register the plugin
    plugin.register_plugin(MDPlugin())

    # Register that we handle extensions from the YANG module
    # 'ietf-yang-metadata'
    grammar.register_extension_module(md_module_name)

    # Register the special grammar
    for (stmt, occurance, (arg, rules), add_to_stmts) in md_stmts:
        grammar.add_stmt((md_module_name, stmt), (arg, rules))
        grammar.add_to_stmts_rules(add_to_stmts,
                                   [((md_module_name, stmt), occurance)])
506463
function init(config) {
        exports.config = config;
        MainViewManager
            .on("currentFileChange", _onFileChange);
        DocumentManager
            .on("documentSaved", _onDocumentSaved)
            .on("dirtyFlagChange", _onDirtyFlagChange);
        ProjectManager
            .on("beforeProjectClose beforeAppClose", close);

        // Default transport for live connection messages - can be changed
        setTransport(NodeSocketTransport);

        // Default launcher for preview browser - can be changed
        setLauncher(DefaultLauncher);

        // Initialize exports.status
        _setStatus(STATUS_INACTIVE);
    }
916604
function init(){

    frameUnixTime = utils.getUnixTimeInMilliseconds();
    frameDuration = 0;
    frameDurationClone = 0;
    timeSinceStart = 0;
    playTimeSinceStart = 0;
    appActive = true;
    appPlaying = true;
    videoDuration = 0;
    videoPlaying = false;

}
1093121
function Init(appGlobal, pathsList) {
            debug("Initializing Boot");
            loadFinder = new Finder();
            loadProvider = new Provider();
            loadNamespace = new Namespace();
            global = appGlobal;
            global.App = {};
            global.Modules = {};
            global.Config = {};
            this.initProviders(sortProvider);
            this.initApplication();
            this.initModules();
            var mainApp = require("../express");
            this.boot(mainApp);
            mainApp.boot = function (nameProvider, userApp) {
                debug("Booting Manual Provider");
                loadProvider.bootProvider(nameProvider, userApp ? userApp : mainApp);
            };
            mainApp.provider = function (nameProvider) {
                debug("Getting " + nameProvider + " Provider");
                return loadProvider.providerByName(nameProvider).instance;
            };
            return mainApp;
        }
1012874
function Plugin(script, _interface, options) {
  this._script = script
  this._options = options || {}
  this._initialInterface = _interface || {}
  this._connect()
}
823708
static function init(){
		
		// Start error handling asap
		self::set_error_handlers();
		// PLUG_ERROR_REPORTING should be set in conf
		if( defined('PLUG_ERROR_REPORTING') ){
			error_reporting( PLUG_ERROR_REPORTING );
		}
		else {
			define('PLUG_ERROR_REPORTING', error_reporting() );
		}
		
		// Select execution mode ( Server | Command line interface )
		if( defined('PLUG_CLI') ){
			// PLUGCli must have been included to define this constant
			PLUGCli::init();
		}
		else {
			// Default to server module mode
			// already checked PHP_SAPI
			define( 'PLUG_CLI', false );
		}
	}
419133
public function init() {
		global $wp_customize;
		if ( ! $wp_customize ) {
			return;
		}
		// Allow disabling the custom loader using the kirki_config filter.
		$config = apply_filters( 'kirki_config', [] );
		if ( isset( $config['disable_loader'] ) && true === $config['disable_loader'] ) {
			return;
		}
		// Add the "loading" icon.
		add_action( 'wp_footer', [ $this, 'add_loader_to_footer' ] );
		add_action( 'wp_head', [ $this, 'add_loader_styles_to_header' ], 99 );
		$this->remove_default_loading_styles();
	}
1110733
function init() {
        CodeMirror.defineOption("foldGutter", false, function (cm, val, old) {
            if (old && old !== CodeMirror.Init) {
                cm.clearGutter(cm.state.foldGutter.options.gutter);
                cm.state.foldGutter = null;
                cm.off("gutterClick", old.onGutterClick);
                cm.off("change", onChange);
                cm.off("viewportChange", onViewportChange);
                cm.off("cursorActivity", onCursorActivity);

                cm.off("fold", onFold);
                cm.off("unfold", onUnFold);
                cm.off("swapDoc", updateInViewport);
            }
            if (val) {
                cm.state.foldGutter = new State(parseOptions(val));
                updateInViewport(cm);
                cm.on("gutterClick", val.onGutterClick);
                cm.on("change", onChange);
                cm.on("viewportChange", onViewportChange);
                cm.on("cursorActivity", onCursorActivity);
                cm.on("fold", onFold);
                cm.on("unfold", onUnFold);
                cm.on("swapDoc", updateInViewport);
            }
        });
    }
1083422
function init(options) {
		setting = options || {};

		if (!setting.googleApiKey && !setting.yandexApiKey) {
			console.warn(constant.ERROR.MISSING_TOKEN);
			return false;
		} else if (setting.yandexApiKey) {
			serviceType = constant.YANDEX_NAME;
			translateSrv = require('./service/yandex.js');
		} else {
			serviceType = constant.GOOGLE_NAME;
			translateSrv = require('./service/google.js');
		}

		translateSrv.init(setting);
		return true;
	}
1125034
function PluginInitializationError (message, module) {
    this.message = message;
    this.stack = new Error().stack;
    this.module = module;
}
762282
public function init()
    {

		parent::init();
		self::$plugin = $this;

		Craft::$app->getView()->registerTwigExtension(new SuperSortTwigExtension());

    }
605765
protected function initialize()
    {
        // Sanity check; must be on (or after) `plugins_loaded` hook.
        // If uninstalling, must be on (or after) `init` hook.

        if (!did_action('plugins_loaded')) {
            throw new Exception('`plugins_loaded` action not done yet.');
        } elseif ($this->Config->§uninstall && !did_action('init')) {
            throw new Exception('`init` action not done yet.');
        }
        // Check for any known conflicts.

        if ($this->s::conflictsExist()) {
            return; // Stop here.
        }
        // Check for any unsatisfied dependencies.

        if ($this->s::dependenciesUnsatisfied()) {
            return; // Stop here.
        }
        // Add app instance to collection.

        if ($this->Parent && $this->Parent->is_core && !$this->Config->§uninstall) {
            $this->Parent->s::addApp($this);
        }
        // Remaining routines are driven by setup hook.

        if ($this->Config->§uninstall || did_action($this->Config->§setup['§hook'])) {
            $this->onSetup(); // Run setup immediately.
        } else { // Delay setup routines; i.e., attach to hook.
            add_action($this->Config->§setup['§hook'], [$this, 'onSetup'], $this->Config->§setup['§hook_priority']);
        }
    }
82779
public static function Initialize()
    {
        // Initialize the plugin loader and try to load any plugins.
        self::$plugin_loader = new Plugins\Loader();

        if(self::ValidExtension())
        {
            self::$plugin_loader->Start(self::GetCwd() . "/plugins");
            
            if(file_exists(self::GetCwd() . "/peg.conf"))
            {
                Settings::SetBackEnd(new Config\INI);
                Settings::Load(self::GetCwd(), "peg.conf");
            }
            else
            {
                Settings::SetBackEnd(new Config\JSON);
                Settings::Load(self::GetCwd(), "peg.json");
            }
        }
    }
400955
public function init()
    {
        // define the path that your publishable resources live
        $this->sourcePath = '@rias/passwordpolicy/assetbundles/PasswordPolicy/dist';

        // define the dependencies
        $this->depends = [
            CpAsset::class,
        ];

        // define the relative path to CSS/JS files that should be registered with the page
        // when this asset bundle is registered
        $this->js = [
            'js/zxcvbn.min.js',
            'js/PasswordPolicy.js',
        ];

        Craft::$app->view->registerJsVar('passwordpolicy', [
            'showStrengthIndicator' => PasswordPolicy::$plugin->settings->showStrengthIndicator,
        ]);

        $this->css = [
            'css/PasswordPolicy.css',
        ];

        parent::init();
    }
78416
public function _initialize()
    {
        parent::_initialize();

        $this->configBackCompat();

        $adminPath = $this->config['adminPath'];
        $this->loginUrl = str_replace('wp-admin', 'wp-login.php', $adminPath);
        $this->adminPath = rtrim($adminPath, '/');
        $this->pluginsPath = $this->adminPath . '/plugins.php';
    }
1058205
protected static void initialize(boolean load) {
		if (load && initialized.compareAndSet(false, true)) {
			boolean nativeFound = getNativeDiscovery().discover();
			if (!nativeFound) {
				throw new IllegalStateException("The libvlc native library has not been found");
			}
			// Native.loadLibrary(RuntimeUtil.getLibVlcLibraryName(), LibVlc.class);
		}
	}