The methods below are all non-standard. The following batch were introduced by Mozilla but have since been removed from Mozilla.
173211
function(node) {
                assertRangeValid(this);

                var parent = node.parentNode;
                var nodeIndex = getNodeIndex(node);

                if (!parent) {
                    throw new DOMException("NOT_FOUND_ERR");
                }

                var startComparison = this.comparePoint(parent, nodeIndex),
                    endComparison = this.comparePoint(parent, nodeIndex + 1);

                if (startComparison < 0) { // Node starts before
                    return (endComparison > 0) ? n_b_a : n_b;
                } else {
                    return (endComparison > 0) ? n_a : n_i;
                }
            }
1103135
function _mixinGenMethod(aMixinSuper, aMethod, src) {
  var oldSuper = src.__super__;
  return function() {
    // src.__super__ = aMixinSuper;
    console.error('mx', aMixinSuper, 'src', src, 'aMethod', aMethod);
    // var oldvar = getPrototypeOf(this);
    // setPrototypeOf(this, aMixinSuper);
    var result = aMethod.apply(this, arguments);
    // setPrototypeOf(this, oldvar);
    // src.__super__ = oldSuper;
    return result;
  };
}
104620
private function genericDefaultHeaders()
    {

        //Cache-Control: no-cache
        $this->addRawHeaderLine('Cache-Control', 'no-cache');

        //Pragma: no-cache
        $this->addRawHeaderLine('Pragma', 'no-cache');

        //Connection: keep-alive
        $this->addRawHeaderLine('Connection', 'keep-alive');

        //Upgrade-Insecure-Requests: 1
        $this->addRawHeaderLine('Upgrade-Insecure-Requests', '1');

        //User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36
        $this->addRawHeaderLine('User-Agent', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.94 Safari/537.36');

        //Accept-Encoding: gzip, deflate Only support the 2 types
        $this->addRawHeaderLine('Accept-Encoding', ['gzip', 'deflate']);

        //Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
        $this->addRawHeaderLine('Accept-Language', ['zh-CN', 'zh;q=0.8', 'zh-TW;q=0.7', 'zh-HK;q=0.5', 'en-US;q=0.3', 'en;q=0.2']);

    }
1098148
public void removeDuplicatedAlgorithms() {
    List<ExperimentAlgorithm<S, Result>> algorithmList = new ArrayList<>() ;
    HashSet<String> algorithmTagList = new HashSet<>() ;


    getAlgorithmList().removeIf(alg -> !algorithmTagList.add(alg.getAlgorithmTag())) ;
  }
303396
private static void printNonAffectedClasses(Set<String> allClasses, Set<String> affectedClasses,
            List<String> nonAffectedClasses, String mode) {
        if (mode != null && mode.equals(ANT_MODE)) {
            StringBuilder sb = new StringBuilder();
            for (String className : nonAffectedClasses) {
                className = className.replaceAll("\\.", "/");
                sb.append("<exclude name=\"" + className + ".java\"/>");
            }
            System.out.println(sb);
        } else if (mode != null && mode.equals(MAVEN_SIMPLE_MODE)) {
            StringBuilder sb = new StringBuilder();
            for (String className : nonAffectedClasses) {
                className = className.replaceAll("\\.", "/");
                sb.append("<exclude>");
                sb.append(className).append(".java");
                sb.append("</exclude>");
            }
            System.out.println(sb);
        } else if (mode != null && mode.equals(MAVEN_MODE)) {
            StringBuilder sb = new StringBuilder();
            sb.append("<excludes>");
            for (String className : nonAffectedClasses) {
                className = className.replaceAll("\\.", "/");
                sb.append("<exclude>");
                sb.append(className).append(".java");
                sb.append("</exclude>");
            }
            sb.append("</excludes>");
            System.out.println(sb);
        } else if (mode != null && mode.equals(DEBUG_MODE)) {
            System.out.println("AFFECTED: " + affectedClasses);
            System.out.println("NONAFFECTED: " + nonAffectedClasses);
        } else {
            for (String className : nonAffectedClasses) {
                System.out.println(className);
            }
        }
    }
414528
function mergeBatchResults(batches) {
    let files = [];
    let unformattedFiles = [];
    let formattedFiles = [];
    let errors = [];

    batches.forEach(batch => {
        files.push(...batch.files);
        unformattedFiles.push(...batch.unformattedFiles);
        formattedFiles.push(...batch.formattedFiles);
        errors.push(...batch.errors);
    });

    return { files, formattedFiles, unformattedFiles, errors };
}
135692
function(type) {
    this.rules = {};
    this.parseMethods = {};
    this.lastTag;

    var rules = require('./rules/all');
    Object.keys(rules.parseMethods).forEach(function(key) {
        this.parseMethods[key] = typeof rules.parseMethods[key] === 'function' ? rules.parseMethods[key] : this[rules.parseMethods[key]];
    }, this);

    if (type === 'js') {
        rules = require('./rules/javascript');
        this.rules = rules.rules;
    }
    else if (type === 'css' || type === 'less' || type === 'styl' || type === 'scss' || type === 'sass') {
        rules = require('./rules/styles');
        this.rules = rules.rules;
    }
    else {
        rules = null;
    }

    if (rules) {
        Object.keys(rules.parseMethods).forEach(function(key) {
            this.parseMethods[key] = typeof rules.parseMethods[key] === 'function' ? rules.parseMethods[key] : this[rules.parseMethods[key]];
        }, this);
    }
}
606370
function unbindFromStrings(target, entity, evt, methods){
    var methodNames = methods.split(/\s+/);

    _.each(methodNames,function(methodName) {
      var method = target[methodName];
      target.stopListening(entity, evt, method, target);
    });
  }
694133
private List<List<File>> batchOutdatedFiles(List<File> outdatedFiles) {

        List<List<File>> batches = new LinkedList<List<File>>();

        int total = outdatedFiles.size();

        int myBatchSize = (batchSize <= 0) ? outdatedFiles.size() : batchSize;

        for (int start = 0; start < total; start += myBatchSize) {
            int end = Math.min(start + myBatchSize, total);
            batches.add(outdatedFiles.subList(start, end));
        }

        return batches;
    }
696601
function getNoExpansions(names) {
  names = Array.isArray(names) ? names : [];
  var output = [];
  names.forEach(function(name) {
    if(re.no().test(name)) {
      var variants = getNoVariants(name);
      output.push(variants.yes, variants.no);
    }else{
      output.push(name);
    }
  })
  return output;
}
1121118
def make_generic_c_patterns(keywords, builtins,
                            instance=None, define=None, comment=None):
    ""
    kw = r"\b" + any("keyword", keywords.split()) + r"\b"
    builtin = r"\b" + any("builtin", builtins.split()+C_TYPES.split()) + r"\b"
    if comment is None:
        comment = any("comment", [r"//[^\n]*", r"\/\*(.*?)\*\/"])
    comment_start = any("comment_start", [r"\/\*"])
    comment_end = any("comment_end", [r"\*\/"])
    if instance is None:
        instance = any("instance", [r"\bthis\b"])
    number = any("number",
                 [r"\b[+-]?[0-9]+[lL]?\b",
                  r"\b[+-]?0[xX][0-9A-Fa-f]+[lL]?\b",
                  r"\b[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\b"])
    sqstring = r"(\b[rRuU])?'[^'\\\n]*(\\.[^'\\\n]*)*'?"
    dqstring = r'(\b[rRuU])?"[^"\\\n]*(\\.[^"\\\n]*)*"?'
    string = any("string", [sqstring, dqstring])
    if define is None:
        define = any("define", [r"#[^\n]*"])
    return "|".join([instance, kw, comment, string, number,
                     comment_start, comment_end, builtin,
                     define, any("SYNC", [r"\n"])])
294626
@Override
    protected void implementationSpecificPut(List<Metric> metrics,
                                             Set<String> scopeNames,
                                             Set<Pair<String, String>> scopesAndMetricNames,
                                             Map<String, MetatagsRecord> metatagsToPut) {
        requireNotDisposed();
        SystemAssert.requireArgument(metrics != null, "Metric list cannot be null.");

        for (Metric metric : metrics) {
            if (metric.getTags().isEmpty()) {
                _putWithoutTag(metric);
            }

            for (Entry<String, String> tag : metric.getTags().entrySet()) {
                _putWithTag(metric, tag);
            }
        }
    }
1173965
public static Method[] getDeclaredMethods(Class clazz) {
	Method[] methods = clazz.getMethods();
	ArrayList list = new ArrayList();
	for (int i = 0; i < methods.length; i++) {
	    if (methods[i].getDeclaringClass() == clazz) list.add(methods[i]);
	}
	if (list.size() == 0) return new Method[0];
	return (Method[]) list.toArray(new Method[list.size()]);
    }
1316871
private Method[] getMethodsToProxyRecursive() {
        Set<MethodSetEntry> methodsToProxy = new HashSet<>();
        Set<MethodSetEntry> seenFinalMethods = new HashSet<>();
        // Traverse the class hierarchy to ensure that all concrete methods (which could be marked
        // as final) are visited before any abstract methods from interfaces.
        for (Class<?> c = baseClass; c != null; c = c.getSuperclass()) {
            getMethodsToProxy(methodsToProxy, seenFinalMethods, c);
        }
        // Now traverse the interface hierarchy, starting with the ones implemented by the class,
        // followed by any extra interfaces.
        for (Class<?> c = baseClass; c != null; c = c.getSuperclass()) {
            for (Class<?> i : c.getInterfaces()) {
                getMethodsToProxy(methodsToProxy, seenFinalMethods, i);
            }
        }
        for (Class<?> c : interfaces) {
            getMethodsToProxy(methodsToProxy, seenFinalMethods, c);
        }

        Method[] results = new Method[methodsToProxy.size()];
        int i = 0;
        for (MethodSetEntry entry : methodsToProxy) {
            results[i++] = entry.originalMethod;
        }

        return results;
    }
175323
@Override
	@Deprecated
	public int[] batch() {
		if (context().batchCount() == 0) {
			return new int[0];
		}
		if (!batch) {
			addBatch();
		}
		try {
			return agent().batch(context());
		} catch (Exception e) {
			throw new UroborosqlSQLException(e);
		}
	}
1331059
public function standardFeatures(): array
    {
        return [
            'stdout.ansi' => function () {
                // @codeCoverageIgnoreStart
                if (DIRECTORY_SEPARATOR === '\\') {
                    return
                        0 >= version_compare(
                        '10.0.10586',
                        PHP_WINDOWS_VERSION_MAJOR .
                            '.' . PHP_WINDOWS_VERSION_MINOR .
                            '.' . PHP_WINDOWS_VERSION_BUILD
                        ) ||
                        false !== getenv('ANSICON') ||
                        'ON' === getenv('ConEmuANSI') ||
                        'xterm' === getenv('TERM') ||
                        false !== getenv('BABUN_HOME');
                }
                // @codeCoverageIgnoreEnd

                return function_exists('posix_isatty') && @posix_isatty(STDOUT);
            },

            'type.object' => function () {
                try {
                    $function =
                        new ReflectionFunction(function (object $a) {});
                    $parameters = $function->getParameters();
                    $result = null === $parameters[0]->getClass();
                    // @codeCoverageIgnoreStart
                } catch (ReflectionException $e) {
                    $result = false;
                }
                // @codeCoverageIgnoreEnd

                return $result;
            },
        ];
    }
1013981
private function setUnsupportedMethodsIfExists()
    {
        if (!function_exists('mb_strpos')) {
            throw new \Exception('You must have php-mbstring extension installed in the server.');
        }

        /*
         * If the content is not passed from FORM then we will simply return corresponding
         * GLOBAL variable raw data
         */
        if (
            \mb_strpos($this->header->get('CONTENT_TYPE'), 'application/x-www-form-urlencoded') === 0 &&
            in_array($this->getMethod(), [RequestMethods::PUT, RequestMethods::PATCH, RequestMethods::DELETE])
        ) {
            parse_str($this->getRawBody(), $array);

            switch ($this->getMethod()) {
                case RequestMethods::PUT:
                    $this->put->exchangeArray($array);
                    break;
                case RequestMethods::PATCH:
                    $this->patch->exchangeArray($array);
                    break;
                case RequestMethods::DELETE:
                    $this->delete->exchangeArray($array);
                    break;
            }
        }
    }