Returs list of supported vendors, depending on user preferences
@return {Array}
516770
function getVendorsList() {
		var allVendors = Object.keys(vendorsDB);
		var vendors = prefs.getArray('caniuse.vendors');
		if (!vendors || vendors[0] == 'all') {
			return allVendors;
		}

		return intersection(allVendors, vendors);
	}
5557
def get_vendors_info(self, limit=10, offset=10):
        
        params = {}
        if offset:
            params['offset'] = offset
        if limit:
            params['limit'] = limit
        url = 'rest/1.0/vendors'
        return (self.get(url, params=params) or {}).get('vendors')
1243739
static String[] getUsable(final List<String> available, final String[] supported)
    {
        final List<String> filtered = new ArrayList<String>(available.size());
        final List<String> supportedList = Arrays.asList(supported);

        for (final String s : available)
        {
            if (supportedList.contains(s)) filtered.add(s);
        }

        final String[] filteredArray = new String[filtered.size()];
        filtered.toArray(filteredArray);
        return filteredArray;
    }
1016313
function getPublicExportedNames(entryModule) {
    const fn = function() {};
    const isStaticOrProtoName = (x) => (
        !(x in fn) &&
        (x !== `default`) &&
        (x !== `undefined`) &&
        (x !== `__esModule`) &&
        (x !== `constructor`)
    );
    return Object
        .getOwnPropertyNames(entryModule)
        .filter((name) => name !== 'default')
        .filter((name) => (
            typeof entryModule[name] === `object` ||
            typeof entryModule[name] === `function`
        ))
        .map((name) => [name, entryModule[name]])
        .reduce((reserved, [name, value]) => {

            const staticNames = value &&
                typeof value === 'object' ? Object.getOwnPropertyNames(value).filter(isStaticOrProtoName) :
                typeof value === 'function' ? Object.getOwnPropertyNames(value).filter(isStaticOrProtoName) : [];

            const instanceNames = (typeof value === `function` && Object.getOwnPropertyNames(value.prototype || {}) || []).filter(isStaticOrProtoName);

            return [...reserved, { exportName: name, staticNames, instanceNames }];
        }, []);
}
1093648
function _get_selected_items(){
	
	var ret_filters = [];

	// Push out the filters that have selected == true.
	var all_filters = _get_all_items();
	for( var afi = 0; afi < all_filters.length; afi++ ){
	    var filter_name = all_filters[afi];
	    var fconf = anchor.current_data[filter_name];
	    if( fconf &&
		typeof fconf['selected'] != 'undefined' &&
		fconf['selected'] == true ){
		    ret_filters.push(filter_name);
		}
	}

	return ret_filters;
    }
691447
function getAllPackages () {
  const packages = [
    // main package
    {
      entry: config.entry,
      jsName: 'index',
      cssName: 'style',
      globName: config.fullname,
      amdName: config.name,
    },
  ]

  return Promise.all([
    packagesFromPath(utils.resolve('src/component'), utils.resolve('src/component')),
    packagesFromPath(utils.resolve('src/mixin'), srcPath),
    packagesFromPath(utils.resolve('src/ol-ext'), srcPath),
    packagesFromPath(utils.resolve('src/rx-ext'), srcPath),
    packagesFromPath(utils.resolve('src/util'), srcPath),
  ]).then(otherPackages => {
    return packages.concat(otherPackages.reduce((all, packages) => all.concat(packages), []))
  })
}
985371
def get_applicable_values(self):
        """"""
        return [v for v in self._values if v.is_active and not v.is_all_results]
368721
function list() {
  return installer.listPlugins(function(listErr, plugins) {
    if (listErr) {
      return out.error("error : %s", listErr);
    }
    if (plugins.length === 0) {
      return out.success("no plugins found");
    }
    var string = "";
    for (var idx = 0; idx < plugins.length; idx++) {
      string += "  " + (idx + 1) + ".  " + plugins[idx].name +
        " - " + plugins[idx].description + "\n";
    }
    return out.success("installed plugins:\n%s", string);
  });
}
375817
function getPackages() {
	var results = [];

	if (extensions && extensions.hasOwnProperty('packages')) {
		var sourceArray = extensions.packages;

		for (index = 0; index < sourceArray.length; ++index) {
		    results.push(sourceArray[index]);
		}
	}

	return results;
}
1277663
public static function getSelectOptions ()
	{
		return [
			[ 'optgroup' => SimpleMap::t('Open Source') ],

			self::Nominatim => SimpleMap::t('Nominatim'),

			[ 'optgroup' => SimpleMap::t('Requires API Key (Token)') ],

			self::Mapbox => SimpleMap::t('Mapbox'),
			self::GoogleMaps => SimpleMap::t('Google Maps'),

			// MapKit lacks both separate address parts and country restriction
			// on the front-end, and any sort of server-side API, so it's
			// disabled for now.
//			self::AppleMapKit => SimpleMap::t('Apple MapKit'),

			self::Here => SimpleMap::t('Here'),
		];
	}
1056157
def get_enabled_plugins():
    '''
    
    '''
    plugins = entrypoints.get_enabled('udata.preview', current_app).values()
    valid = [p for p in plugins if issubclass(p, PreviewPlugin)]
    for plugin in plugins:
        if plugin not in valid:
            clsname = plugin.__name__
            msg = '{0} is not a valid preview plugin'.format(clsname)
            warnings.warn(msg, PreviewWarning)
    return [p() for p in sorted(valid, key=lambda p: 1 if p.fallback else 0)]
1068750
function getGradientPrefixes(type) {
		var prefixes = cssResolver.vendorPrefixes(type);
		if (!prefixes) {
			// disabled Can I Use, fallback to property list
			prefixes = prefs.getArray('css.gradient.prefixes');
		}

		return prefixes || [];
	}
1338503
function findInternalPrefixes(property, noAutofill) {
		var result = [];
		var prefixes = findVendorPrefixes(property);
		
		if (prefixes) {
			var prefixMap = {};
			Object.keys(vendorPrefixes).forEach(function(key) {
				prefixMap[vendorPrefixes[key].prefix] = key;
			});

			result = prefixes.map(function(prefix) {
				return prefixMap[prefix];
			});
		}
		
		if (!result.length && !noAutofill) {
			// add all non-obsolete prefixes
			Object.keys(vendorPrefixes).forEach(function(prefix) {
				if (!vendorPrefixes[prefix].obsolete) {
					result.push(prefix);
				}
			});
		}
		
		return result;
	}
470360
public static function supportedTypes()
    {
        return [
            self::YAML,
            self::JSON,
            self::INI,
            self::COLUMNS,
            self::TABLE,
            self::MARKDOWN,
            self::DUMP
        ];
    }
1615
function parsePlatforms() {
        var supportPlatforms = [
            { platform: 'android',          regexp: /android/ig         },
            { platform: 'ios',              regexp: /ios/ig             },
            { platform: 'firefoxos',        regexp: /firefoxos/ig       },
            { platform: 'windows8',         regexp: /windows8/ig        },
            { platform: 'browser',          regexp: /browser/ig         },
            { platform: 'amazon-fireos',    regexp: /amazon-fireos/ig   },
            { platform: 'blackberry10',     regexp: /blackberry10/ig    },
            { platform: 'windows',          regexp: /windows/ig         },
            { platform: 'wp8',              regexp: /wp8/ig             },
        ];

        var gruntTasks = [];

        supportPlatforms.forEach(function (checker) {
            if (null != _cmdline.match(checker.regexp)) {
                gruntTasks.push('cordova_register_platform:' + checker.platform);
            }
        });

        return gruntTasks;
    }
514607
function getProviderIDsForLanguage(languageId) {
        if (!_providers[languageId]) {
            return [];
        }
        return _providers[languageId].map(function (provider) {
            return provider.name;
        });
    }
1321562
def compprefs(self):
        
        if 'PreferredCompressionAlgorithms' in self._signature.subpackets:
            return next(iter(self._signature.subpackets['h_PreferredCompressionAlgorithms'])).flags
        return []