returns the configuration of the given extension point or undefined
@private
495229
function(sViewName, sExtensionPointName, vObject) { // FIXME: currently ONE extension wins, but they should be somehow merged - but how to define the order?
				var oResultConfig;
				// TODO: checking order of components?
				findConfig(CONFIG_VIEW_EXTENSIONS, vObject, function(oConfig) {
					oResultConfig = oConfig[sViewName] && oConfig[sViewName][sExtensionPointName];
					return !!oResultConfig;
				});
				return oResultConfig;
			}
1112708
function fetchOptions() {
  /**
   * Name of the cookie that contains the options for the injection.
   * The data is just a blob GUID that is used to construct a URL to the blob
   * exposed by the extension.
   * @const
   * @type {string}
   */
  var WTF_OPTIONS_COOKIE = 'wtf';

  /**
   * Cookie used for instrumentation options.
   * @const
   * @type {string}
   */
  var WTF_INSTRUMENTATION_COOKIE = 'wtfi';

  // Check for the injection cookie.
  var optionsUuid = null;
  var instrumentationOptions = null;
  var cookies = document.cookie.split('; ');
  for (var n = 0; n < cookies.length; n++) {
    if (cookies[n].lastIndexOf(WTF_OPTIONS_COOKIE + '=') == 0) {
      optionsUuid = cookies[n].substr(cookies[n].indexOf('=') + 1);
    }
    if (cookies[n].lastIndexOf(WTF_INSTRUMENTATION_COOKIE + '=') == 0) {
      instrumentationOptions = cookies[n].substr(cookies[n].indexOf('=') + 1);
    }
  }
  if (!optionsUuid && !instrumentationOptions) {
    return null;
  }

  // If we have an instrumentation cookie we use that and go into
  // instrumentation mode.
  if (instrumentationOptions) {
    instrumentationOptions = JSON.parse(instrumentationOptions);
    instrumentationOptions['__instrumented__'] = true;
    return instrumentationOptions;
  }

  // Fetch the options from the extension.
  // This is complicated by a regression in Chrome that prevents the blob trick
  // from working in certain versions. We try that first (as it's the best) and
  // if it fails we fallback to a nasty HTTP header trick.
  // https://code.google.com/p/chromium/issues/detail?id=295829

  // blob:chrome-extension%3A//[extension id]/[options uuid]
  var blobUrl = 'blob:' +
      chrome.extension.getURL(optionsUuid).replace(':', '%3A');
  var headerUrl =
      'http://tracing-framework.appspot.com/tab-options/' + optionsUuid;

  try {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', blobUrl, false);
    xhr.send(null);
    if (xhr.status != 200) {
      log('Failed to load WTF injection options:',
          blobUrl,
          xhr.status, xhr.statusText);
      return null;
    }
    return JSON.parse(xhr.responseText);
  } catch(e) {
    log('Failed to parse WTF injection options (falling back to headers)... ' +
        'See https://code.google.com/p/chromium/issues/detail?id=295829');

    // Try the headers.
    try {
      var xhr = new XMLHttpRequest();
      xhr.open('GET', headerUrl, false);
      xhr.send(null);
      var optionsData = xhr.getResponseHeader('X-WTF-Options');
      if (!optionsData) {
        log('Failed to load WTF injection options from header:' + headerUrl);
        log('Using defaults for settings :(');
        return {
          'wtf.injector': true,
          'wtf.injector.failed': true,
          'wtf.trace.session.bufferSize': 6 * 1024 * 1024,
          'wtf.trace.session.maximumMemoryUsage': 512 * 1024 * 1024,
          'wtf.trace.provider.chromeDebug.present': true,
          'wtf.trace.provider.chromeDebug.tracing': false
        };
      }
      return JSON.parse(optionsData);
    } catch(e) {
      log('Really failed to fetch WTF injection options, aborting', e);

      // Try again!
      window.setTimeout(function() {
        window.location.reload();
      }, 100);

      return null;
    }
  }

  return null;
}
427117
function matchesExtension(requestedUrl, opts) {
  var exts = !opts.ext || Array.isArray(opts.ext) ?
    opts.ext : [opts.ext];

  if (exts) {
    return exts.some(function(ext) {
      return requestedUrl.pathname.substr(ext.length * -1) === ext;
    });
  }
}
55330
function getConfigForNode(node) {
            if (
                node.generator &&
                context.options.length > 1 &&
                context.options[1].generators
            ) {
                return context.options[1].generators;
            }

            return context.options[0] || "always";
        }
708401
function(bundle, callback){
        var configuration = Config.getInstance(bundle);

        console.log("getting for bundle ", bundle, configuration);
        if ( typeof(configuration) != 'undefined' ) {
            //Response.
            var confObj = {
                model : configuration.content.model,
                path : configuration.modelsPath
            };
            callback(false, confObj);
        } else {
            callback('Config not instantiated')
        }
    }
72272
function findTypeForExtend(types, extend) {
  var orig = types.find(ea => ea.name === extend.name && ea.type !== "extend");
  if (!orig) throw new Error("Cannot find original for extension " + JSON.stringify(extend, null, 2));
  return orig;
}
1031006
function getConfigElement(name) {
    checkIsString('name', name);
    if (config.has(name)) {
        return config.get(name);
    }
}
236250
function getConfig(query) {
	let config = query;

	if (typeof config === 'string') {
		try {
			config = JSON.parse(config.replace(/^\?/, ''));
		} catch(ex) {}
	}

	if (typeof config !== 'object') {
		config = {};
	}

	return config;
}
232051
def get_ext_param(self, ext_key, param_key):
        '''
        
        '''
        return self.extensions[ext_key][param_key] if self.extensions[ext_key]\
                else None
620449
function getPointRelativeToCanvas (point) {
            return {
                x: point.x / canvas.width,
                y: point.y / canvas.height
            };
        }
1357716
function findRenderer(extension) {
  var renderer;

  // Default to HTML if you don't have an extension
  extension = extension || renderers.default;
  // Get the renderer
  renderer = _.get(renderers, `${extension}`, null);

  if (renderer) {
    return renderer;
  } else {
    return new Error(`Renderer not found for extension ${extension}`);
  }
}
225955
protected function getExtensionConfiguration()
    {
        $cacheInstance = CacheService::get()->getCacheInstance();
        $hash = $this->getContextHash();

        if ($cacheInstance->has($hash)) {
            $result = $cacheInstance->get($hash);
        } else {
            $result = $this->getFullConfiguration();
            $result = (ArrayUtility::isValidPath($result, self::EXTENSION_CONFIGURATION_PATH, '.'))
                ? ArrayUtility::getValueByPath($result, self::EXTENSION_CONFIGURATION_PATH, '.')
                : [];

            if (ArrayUtility::isValidPath($result, 'settings.typoScriptIncluded', '.')) {
                $cacheInstance->set($hash, $result);
            }
        }

        return $result;
    }
1127042
function readConfigs() {
    const configsRoot = path.resolve(__dirname, "../../lib/configs")
    const result = fs.readdirSync(configsRoot)
    const configs = []
    for (const name of result) {
        const configName = name.replace(/\.js$/u, "")
        const configId = `plugin:lodash-template/${configName}`
        const configPath = require.resolve(path.join(configsRoot, name))

        const config = require(configPath)
        configs.push({
            name: configName,
            configId,
            config,
            path: configPath,
        })
    }
    return configs
}
1347821
function(context) {
        var node = this.createElementDefaultNS("Extension");
        
        var bounds = context.maxExtent;
        if(bounds) {
            var maxExtent = this.createElementNS(
                this.namespaces.ol, "ol:maxExtent"
            );
            this.setAttributes(maxExtent, {
                minx: bounds.left.toPrecision(18),
                miny: bounds.bottom.toPrecision(18),
                maxx: bounds.right.toPrecision(18),
                maxy: bounds.top.toPrecision(18)
            });
            node.appendChild(maxExtent);
        }
        
        return node;
    }
375029
function getOption(name) {
        var ret = getConfig('options.' + name);
        if (ret === undefined) {
            var framework = configuredFramework();
            if (db.frameworks.options[framework] && (name in db.frameworks.options[framework])) {
                ret = db.frameworks.options[framework][name];
            } else if (name in db.frameworks.options.all) {
                ret = db.frameworks.options.all[name];
            }
        }

        if (typeof(ret) === 'function') {
            ret = ret();
        }

        return ret;
    }
339391
function getConfigForFunction(node) {
            if (node.type === "ArrowFunctionExpression") {

                // Always ignore non-async functions and arrow functions without parens, e.g. async foo => bar
                if (node.async && astUtils.isOpeningParenToken(sourceCode.getFirstToken(node, { skip: 1 }))) {
                    return overrideConfig.asyncArrow || baseConfig;
                }
            } else if (isNamedFunction(node)) {
                return overrideConfig.named || baseConfig;

            // `generator-star-spacing` should warn anonymous generators. E.g. `function* () {}`
            } else if (!node.generator) {
                return overrideConfig.anonymous || baseConfig;
            }

            return "ignore";
        }
988219
function getOptions(opts) {
	var obj = Object.create(_options);
	obj = util._extend(obj, opts);
	return obj;
}