/* Restricted partials
429305
public function increaseRestrictedMetaPartials($MetaName) {
        $this->fields['RestrictedMetaPartials'] = PartialUtils::increasePartials($this->fields['RestrictedMetaPartials'], '#'.ltrim($MetaName, '#'));
    }
794857
function(key, ctx, partials, returnFound) {
      var val = false,
          v = null,
          found = false;

      for (var i = ctx.length - 1; i >= 0; i--) {
        v = ctx[i];
        if (v && typeof v == 'object' && key in v) {
          val = v[key];
          found = true;
          break;
        }
      }

      if (!found) {
        return (returnFound) ? false : "";
      }

      if (!returnFound && typeof val == 'function') {
        val = this.lv(val, ctx, partials);
      }

      return val;
    }
332703
def _partial(self):
        """"""
        raw_stdout = self._process.readAllStandardOutput()
        stdout = handle_qbytearray(raw_stdout, _CondaAPI.UTF8)

        json_stdout = stdout.replace('\n\x00', '')
        try:
            json_stdout = json.loads(json_stdout)
        except Exception:
            json_stdout = stdout

        if self._partial_stdout is None:
            self._partial_stdout = stdout
        else:
            self._partial_stdout += stdout

        self.sig_partial.emit(self, json_stdout, None)
310219
private boolean containsRestrictedPrefix(String tpl)
	{
		for (String i : blackPrefixList) {
			if (tpl.startsWith(i))
				return true;
		}
		return false;
	}
1053460
def eager_partial(__fn, *a, **kw):
        
        return (EAGER_PARTIAL, (__fn, a, tuple(kw.items())))
28143
public static function partial()
    {
        $args = func_get_args();
        $f = array_shift($args);
        return function () use ($f, $args) {
            return call_user_func_array($f, array_merge($args, func_get_args()));
        };
    }
1310555
func Partial(p *Template) Option {
	return func(t *Template) {
		t.partials[p.name] = p
	}
}
1351713
function(compoundSelector) {
            // Break at a `.` or `[`, capturing the delineator

            var partials    = compoundSelector.split(/([\.\[])/g),
                toggleArray = [],
                selector    = '',
                i           = -1;

            if (partials[0] === '') {
                partials.shift();
            }

            for (i = 0; i < partials.length; i++) {
                if (i % 2 === 0) {
                    selector = '';
                }

                selector += partials[i];

                if (i % 2 !== 0) {
                    toggleArray.push(selector);
                }
            }

            return toggleArray;
        }
422255
function(template, context, partials) {
        if(!this.includes("#", template) && !this.includes("^", template)) {
          return template;
        }

        var that = this;
        // CSW - Added "+?" so it finds the tighest bound, not the widest
        var regex = new RegExp(this.otag + "(\\^|\\#)\\s*(.+)\\s*" + this.ctag +
                "\n*([\\s\\S]+?)" + this.otag + "\\/\\s*\\2\\s*" + this.ctag +
                "\\s*", "mg");

        // for each {{#foo}}{{/foo}} section do...
        return template.replace(regex, function(match, type, name, content) {
          var value = that.find(name, context);
          if(type == "^") { // inverted section
            if(!value || that.is_array(value) && value.length === 0) {
              // false or empty list, render it
              return that.render(content, context, partials, true);
            } else {
              return "";
            }
          } else if(type == "#") { // normal section
            if(that.is_array(value)) { // Enumerable, Let's loop!
              return that.map(value, function(row) {
                return that.render(content, that.create_context(row),
                  partials, true);
              }).join("");
            } else if(that.is_object(value)) { // Object, Use it as subcontext!
              return that.render(content, that.create_context(value),
                partials, true);
            } else if(typeof value === "function") {
              // higher order section
              return value.call(context, content, function(text) {
                return that.render(text, context, partials, true);
              });
            } else if(value) { // boolean section
              return that.render(content, context, partials, true);
            } else {
              return "";
            }
          }
        });
      }
1143914
public static function getPartial($name)
    {
        //Argument 1 must be a string
        Argument::i()->test(1, 'string');
        
        if (isset(self::$partials[$name])) {
            return self::$partials[$name];
        }
        
        return null;
    }
326602
function include(partial, cb) {
    cb((params.partials && params.partials[partial]) ?
      params.partials[partial] :
      '[error] partial ' + partial + ' does not exist');
  }
181
public function setPartial($partial)
    {
        if (null === $partial || is_string($partial) || is_array($partial)) {
            $this->partial = $partial;
        }

        return $this;
    }
802671
function getComponentDirectives(appName, componentPrefix) {
    componentPrefix = (componentPrefix || 'pc') + '-';
    var directives = {};
    var me = this;

    _.each(this.getAppFileNames(appName, 'partials'), function (partialName) {

        // if not a JavaScript file, ignore it
        if (!me.pancakes.utils.isJavaScript(partialName)) { return; }

        // get the right partial name and partial
        var partial = me.pancakes.cook('app/' + appName + '/partials/' + partialName);

        // don't include if no view, is client only or is an abstract view
        if ((!partial.view && !partial.subviews && !partial.parent) ||
            partial.clientOnly || partial.abstract) { return; }

        // set the directive map values that will be used by jangular to render
        var directiveName = componentPrefix +
            partialName.substring(0, partialName.length - 11).replace(/\./g, '-');

        directives[directiveName] = me.getPartialRenderFn(partial, partialName);
    });

    return directives;
}
312032
public function getPartialInfo($partial) {

		$styleModifier = array();
		$parameters	= array();

		if (strpos($partial, "(") !== false) {
			$partialBits      = explode("(",$partial,2);
			$partial          = trim($partialBits[0]);
			$parametersString = substr($partialBits[1],0,(strlen($partialBits[1]) - strlen(strrchr($partialBits[1],")"))));
			$parameters       = $this->parseParameters($parametersString);
		}

		if (strpos($partial, ":") !== false) {
			$partialBits      = explode(":",$partial,2);
			$partial          = $partialBits[0];
			$styleModifier    = $partialBits[1];
			if (strpos($styleModifier, "|") !== false) {
				$styleModifierBits = explode("|",$styleModifier);
				$styleModifier     = join(" ",$styleModifierBits);
			}
			$styleModifier    = array("styleModifier" => $styleModifier);
		}

		return array($partial,$styleModifier,$parameters);

	}
463845
public function getPartial(string $name)
    {
        if (isset($this->partials[$name])) {
            return $this->partials[$name];
        }

        return null;
    }
11994
def eager_partial_regardless(self, fn, *a, **kw):
        """"""
        if self.has_annotations(fn):
            return self.eager_partial(fn, *a, **kw)
        return functools.partial(fn, *a, **kw)
17367
def _partial(self):
        """"""
        raw_stdout = self._process.readAllStandardOutput()
        stdout = handle_qbytearray(raw_stdout, self._get_encoding())

        if self._partial_stdout is None:
            self._partial_stdout = stdout
        else:
            self._partial_stdout += stdout

        self.sig_partial.emit(self, stdout, None)