Initialize a new `Vorpal` instance.

@return {Vorpal}
@api public
480950
function Vorpal() {
  if (!(this instanceof Vorpal)) {
    return new Vorpal();
  }

  // Program version
  // Exposed through vorpal.version(str);
  this._version = '';

  // Program title
  this._title = '';

  // Program description
  this._description = '';

  // Program baner
  this._banner = '';

  // Command line history instance
  this.cmdHistory = new this.CmdHistoryExtension();

  // Registered `vorpal.command` commands and
  // their options.
  this.commands = [];

  // Queue of IP requests, executed async, in sync.
  this._queue = [];

  // Current command being executed.
  this._command = undefined;

  // Expose UI.
  this.ui = ui;

  // Expose chalk as a convenience.
  this.chalk = chalk;

  // Expose lodash as a convenience.
  this.lodash = _;

  // Exposed through vorpal.delimiter(str).
  this._delimiter = 'local@' + String(os.hostname()).split('.')[0] + '~$ ';
  ui.setDelimiter(this._delimiter);

  // Placeholder for vantage server. If vantage
  // is used, this will be over-written.
  this.server = {
    sessions: []
  };

  // Whether all stdout is being hooked through a function.
  this._hooked = false;

  this._useDeprecatedAutocompletion = false;

  // Expose common utilities, like padding.
  this.util = VorpalUtil;

  this.Session = Session;

  // Active vorpal server session.
  this.session = new this.Session({
    local: true,
    user: 'local',
    parent: this,
    delimiter: this._delimiter
  });

  // Allow unix-like key value pair normalization to be turned off by toggling this switch on.
  this.isCommandArgKeyPairNormalized = true;

  this._init();
  return this;
}
599590
function create(objectName) {

        // for resources we need to load them the first time they are referenced
        if (objectName === 'resources' && this.internalObjects[objectName] === true) {
            this.internalObjects[objectName] = this.loadResources();
        }

        // for reactors we need to load them the first time they are referenced
        else if (objectName === 'reactors' && this.internalObjects[objectName] === true) {
            this.internalObjects[objectName] = this.loadReactors();
        }

        // for reactors we need to load them the first time they are referenced
        else if (objectName === 'appConfigs' && this.internalObjects[objectName] === true) {
            this.internalObjects[objectName] = this.loadAppConfigs();
        }

        // for adapters we need to load them the first time they are referenced
        else if (objectName === 'adapters' && this.internalObjects[objectName] === true) {
            this.internalObjects[objectName] = this.loadAdapters();
        }

        return this.internalObjects[objectName];
    }
1350121
function () {
            this.$Container.initWidget.apply(this, arguments);
            var getChild = ariaUtilsDom.getDomElementChild;
            var parentContainer = getChild(getChild(this.getDom(), 0), 0);
            this._splitPanel1 = getChild(parentContainer, 0);
            this._splitBar = getChild(parentContainer, 1);
            this._splitBarProxy = getChild(parentContainer, 2);
            this._splitPanel2 = getChild(parentContainer, 3);

            this._splitBarProxyClass = new ariaUtilsClassList(this._splitBarProxy);
            var handleBarElem = "splitBarProxy_" + this._domId;
            var cursor = this._orientation ? "n-resize" : "e-resize";
            this._draggable = new ariaUtilsDragdropDrag(handleBarElem, {
                handle : handleBarElem,
                cursor : cursor,
                proxy : null,
                constrainTo : parentContainer
            });

            this._draggable.$on({
                "dragstart" : {
                    fn : this._onDragStart,
                    scope : this
                },

                "dragend" : {
                    fn : this._onDragEnd,
                    scope : this
                }
            });

        }
664788
function createFactory() {
    return function Stamp(options) {
      var i = Stamp[_compose] || {};
      // Next line was optimized for most JS VMs. Please, be careful here!
      var obj = {__proto__: i[_methods]};

      var inits = i[_initializers], args = slice.apply(arguments);
      var initializer, returnedValue;

      var tmp = i[_deepProperties];
      if (tmp) merge(obj, tmp);
      tmp = i[_properties];
      if (tmp) assign(obj, tmp);
      tmp = i[_propertyDescriptors];
      if (tmp) defineProperties(obj, tmp);

      if (!inits || !inits[_length]) return obj;

      if (options === _undefined) options = {};
      for (i = 0; i < inits[_length];) {
        initializer = inits[i++];
        if (isFunction(initializer)) {
          returnedValue = initializer.call(obj, options,
            {instance: obj, stamp: Stamp, args: args});
          obj = returnedValue === _undefined ? obj : returnedValue;
        }
      }

      return obj;
    };
  }
47204
public function create()
    {
        $instance = self::createVariant($this);
        $this->setId($instance->getId());
        return $instance;
    }
459299
function init(options = {}, handlebars) {
  const opts = deepExtend({}, defaults, options);
  normalizePaths(opts);
  opts.handlebars = handlebars || Handlebars.create();
  return Promise.resolve(opts);
}
985943
function initialize() {
    var getRenderer = require( config.getRenderer ?
      path.join( './../../../', config.getRenderer ) :
      markedRenderer
    );
    var renderer = getRenderer( marked );
    filingCabinet = new FilingCabinet( config );

    readControls(
      config.controls,
      filingCabinet
    );
    readReferences(
      config.components,
      config.referenceFile,
      filingCabinet
    );
    readComponents(
      config.components,
      config.referenceFile,
      config.localeFile,
      config.layoutSegment,
      config.contentSegment,
      filingCabinet,
      renderer
    );
    readContents(
      config.contents,
      config.submenuFile,
      filingCabinet,
      renderer
    );

    logger.showInfo( '*** Validating elements...' );
    filingCabinet.finalize();
    logger.showInfo( '*** Content manager is initialized.' );

    contextFactory = new ContextFactory( config, filingCabinet );
  }
34784
public function newInstanceData()
    {
        $className = $this->class_name;

        $arguments = (array) Yaml::parse(strval($this->class_arguments));

        return new $className(...$arguments);
    }
654970
function () {
      var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

      options.base = this;
      return _emberApplicationSystemEngineInstance.default.create(options);
    }
632030
protected function initPhalconApplication()
    {
        $diFactory     = $this->diManager->getDI();
        $moduleHandler = $diFactory->get('moduleHandler');

        // Register autoloader
        (new Autoloader($diFactory))->register();

        // Register services and routers
        $this->diManager->initInvokableServices()
                ->initFactoriedServices()
                ->initRouterDi();

        // Init listeners
        (new Listener($diFactory))
                ->listenApplicationEvents(new Listener\Application())
                ->listenDispatchEvents(new Listener\Dispatch());

        // Register modules
        $application = new PhalconApplication($diFactory);
        $application->setEventsManager($diFactory['eventsManager']);
        $application->registerModules($moduleHandler->getRegisteredModules());

        return $application;
    }
73699
public function initialize()
    {
        $lang = $this;

        if (is_callable($this->options['lang'])) {
            $this->options['lang'] = call_user_func($this->options['lang']);
        }

        if ($p = realpath(rtrim($this->app->config('bono.base.path'), DIRECTORY_SEPARATOR))) {
            $this->addBaseDirectory($p, 9);
        }

        $d = explode(DIRECTORY_SEPARATOR.'src', __DIR__);
        $this->addBaseDirectory($d[0]);

        $this->app->container->singleton('lang', function () use ($lang) {
            return $lang;
        });
    }
1154767
function initialize() {
    if (aurelia_pal_1.isInitialized) {
        return;
    }
    let pal = nodejs_pal_builder_1.buildPal();
    aurelia_pal_1.initializePAL((platform, feature, dom) => {
        Object.assign(platform, pal.platform);
        Object.setPrototypeOf(platform, pal.platform.constructor.prototype);
        Object.assign(dom, pal.dom);
        Object.setPrototypeOf(dom, pal.dom.constructor.prototype);
        Object.assign(feature, pal.feature);
        Object.setPrototypeOf(feature, pal.feature.constructor.prototype);
        (function (global) {
            global.console = global.console || {};
            let con = global.console;
            let prop;
            let method;
            let empty = {};
            let dummy = function () { };
            let properties = 'memory'.split(',');
            let methods = ('assert,clear,count,debug,dir,dirxml,error,exception,group,' +
                'groupCollapsed,groupEnd,info,log,markTimeline,profile,profiles,profileEnd,' +
                'show,table,time,timeEnd,timeline,timelineEnd,timeStamp,trace,warn').split(',');
            while (prop = properties.pop())
                if (!con[prop])
                    con[prop] = empty;
            while (method = methods.pop())
                if (!con[method])
                    con[method] = dummy;
        })(platform.global);
        if (platform.global.console && typeof console.log === 'object') {
            if (typeof console['debug'] === 'undefined') {
                console['debug'] = this.bind(console['log'], console);
            }
            ['log', 'info', 'warn', 'error', 'assert', 'dir', 'clear', 'profile', 'profileEnd'].forEach(function (method) {
                console[method] = this.bind(console[method], console);
            }, Function.prototype.call);
        }
        Object.defineProperty(dom, 'title', {
            get: function () {
                return pal.global.document.title;
            },
            set: function (value) {
                pal.global.document.title = value;
            }
        });
        Object.defineProperty(dom, 'activeElement', {
            get: function () {
                return pal.global.document.activeElement;
            }
        });
        Object.defineProperty(platform, 'XMLHttpRequest', {
            get: function () {
                return pal.global.XMLHttpRequest;
            }
        });
    });
}
1206411
function init() {  // {{{2
/**
 * Class constructor
 *
 * @method constructor
 */

  O.inherited(this)();

  this.setMaxListeners(Consts.coreListeners);

  this.subjectState = this.SUBJECT_STATE.INIT;

  this.homeTimeOffset = 0;

  this.lastTid = 0;  // {{{3
  /**
   * Autoincemental part of last transaction id created in this shard and peer
   *
   * @property lastTid
   * @type Number
   */

  this.lastEid = 0;  // {{{3
  /**
   * Autoincremental part of last entry id created in this shard and peer
   *
   * @property lastEid
   * @type Number
   */

  this.cache = {};  // {{{3
  /**
   * Object containing entries
   *
   * @property cache
   * @type Object
   */

  // }}}3

  return true;
}
704310
private function initAppState()
    {
        $appState = $this->getMagentoObject(State::class);
        $configLoader = $this->getMagentoObject(ConfigLoaderInterface::class);
        $registry = $this->getMagentoObject(Registry::class);
        
        try {
            $appState->getAreaCode();
        } catch (\Exception $e) {
            $appState->setAreaCode('adminhtml');
            $this->objectManager->configure($configLoader->load('adminhtml'));
            $registry->register('isSecureArea', true);
        }
    }
909328
function init(obj = {}, prevName = '') {
    return new Proxy(obj, {
        get (target, name) {
            if (typeof name === 'symbol' || deflectedProperties.includes(name)) {
                return Reflect.get(target, name);
            }
            ns.resetTo(prevName);
            ns.push(name);
            let value = process.env[ns.serialize()];
            if (value) {
                ns.pop();
                return value;
            }
            return init(target, name);
        },
        set (target, name, val) {
            ns.resetTo(prevName);
            ns.push(name);
            let value = String(val);
            process.env[ns.serialize()] = value;
            ns.pop();
            return value;
        }
    });
}
259540
function preferencesInitialize() {
          return this.initializedPromise = defaultPreferences.then(function (defaults) {
            Object.defineProperty(this, 'defaults', {
              value: Object.freeze(defaults),
              writable: false,
              enumerable: true,
              configurable: false
            });
            this.prefs = cloneObj(defaults);
            return this._readFromStorage(defaults);
          }.bind(this)).then(function (prefObj) {
            this.isInitializedPromiseResolved = true;
            if (prefObj) {
              this.prefs = prefObj;
            }
          }.bind(this));
        }
116040
private function buildInitialize() {
        $method = new Object\Method();
        $method->setAccess('public');
        $method->setDescription('Initializer, only called once per page load');
        $method->setName('initialize');
        $method->setReturnType('void');
        $method->setContent(
            '$this->setConnectionService(\'' . $this->getConfiguration()->getConnectionService() . '\');
		parent::initialize();
' . $this->buildValidation() . '
' . $this->buildRelationshipsBuffer() . '
' . $this->buildUpdateSkips()
        );
        $this->getAbstractClass()->addMethod($method);
    }