Decortaor for `call` component helper.
@param   {string}          path - Path in store
@returns {VueDecorator}  - Vue decortaor to be used in cue class component.
177360
function Call(path) {
  if (typeof path !== 'string' || arguments.length > 1) { throw new Error('Property decorators can be used for single property access') }
  return createDecorator((options, key) => {
    if (!options.methods) options.methods = {}
    options.methods[key] = call(path)
  })
}
327964
function applyObjectDecorators(path, state) {
  if (!hasMethodDecorators(path.node.properties)) return;

  return applyTargetDecorators(path, state, path.node.properties);
}
499910
function(path) {
			return (
				n.Identifier.check(path.node.callee) &&
				path.node.callee.name === "define" &&
				!n.Program.check(path.parent.parent.node)
			);
		}
458599
def import_by_path(path: str) -> Callable:
    

    module_path, _, class_name = path.rpartition('.')
    return getattr(import_module(module_path), class_name)
239785
function alias(path, aliases)
{
	// if it's a path to a file - don't interfere
	if (!is_package_path(path))
	{
		return
	}

	// extract module name from the path
	const slash_index = path.indexOf('/')
	const module_name = slash_index >= 0 ? path.substring(0, slash_index) : path
	const rest = slash_index >= 0 ? path.substring(slash_index) : ''

	// find an alias
	const alias = aliases[module_name]

	// if an alias is found, require() the correct path
	if (alias)
	{
		return alias + rest
	}
}
168529
function(path, callback) {
      var self = this
      request({url: this.endpoint + path, json: true}, function(err, resp, body) {
        if (err) {
          return console.error(err);
        }
        callback.call(self, body);
      });
    }
1233029
function(path, callbackSuccess, callbackError) {
  var xhr = new XMLHttpRequest();
  xhr.onreadystatechange = function() {
    if (xhr.readyState === 4) {
      if (xhr.status >= 200 && xhr.status < 300) {
        callbackSuccess(xhr.responseText);
      } else {
        callbackError();
      }
    }
  };
  xhr.open('GET', path, false);
  try {
    xhr.send();
  } catch (e) {
    callbackError();
  }
}
541963
function(path) {
			if (!path.forEach)
				path = path.split(':');
			if (path.length !== 2)
				throw new Error('yamvish method call badly formatted : ' + path.join(':'));
			var Cl = this.classes[path[0]];
			if (!Cl)
				throw new Error('no api found with "' + path.join(':') + '"');
			var method = Cl.prototype[path[1]];
			if (!method)
				throw new Error('no API method found with "' + path.join(':') + '"');
			return method;
		}
502794
function(path, value, fromParent) {
		// console.log('context.set : ', this.path, path, value, fromParent);
		// .set({ ...:..., ... }) case
		if (typeof path === 'object' && !path.forEach && !value) {
			for (var i in path)
				this.set(i, path[i], fromParent);
			return this;
		}
		path = parsePath(path);
		// $this case : reset
		if (path.length === 1 && path[0] === '$this')
			return this.reset(value, fromParent);

		path = modification(this, 'set', path, [value], fromParent);
		if (path.__yContext__)
			return this;
		// console.log('context.set : really apply : ', this.path, path, value, fromParent);
		var old = utils.setProp(this.data, path, value);
		if (old !== value)
			this.notify('set', path, value, path[path.length - 1]);
		return this;
	}
997411
function setPath(path, val, obj) {
  if(!isArray(path) || isEmpty(path)) {
    throw new TypeError(pathErr)
  }

  if(!isValid(obj)) {
    throw new TypeError(
      'setPath: Object or Array required for third argument'
    )
  }

  const key = path[0]
  let newVal = val

  if(!(isString(key) && !isEmpty(key) || isInteger(key) && key >= 0)) {
    throw new TypeError(pathErr)
  }

  if(path.length > 1) {
    const next = !isValid(obj[key])
      ? isInteger(path[1]) ? [] : {}
      : obj[key]

    newVal = setPath(path.slice(1), val, next)
  }

  if(isObject(obj)) {
    if(isString(key)) {
      return object.set(key, newVal, obj)
    }

    throw new TypeError(
      'setPath: Non-empty String required in path when referencing an Object'
    )
  }

  if(isInteger(key)) {
    return array.set(key, newVal, obj)
  }

  throw new TypeError(
    'setPath: Positive Integers required in path when referencing an Array'
  )
}
1090293
function (path) {
        if (!path) {
            return;
        }
        // TODO Name have slash ?
        var pathArr = path.split('/');
        var current = this;
        for (var i = 0; i < pathArr.length; i++) {
            var name = pathArr[i];
            // Skip empty
            if (!name) {
                continue;
            }
            var found = false;
            var children = current._children;
            for (var j = 0; j < children.length; j++) {
                var child = children[j];
                if (child.name === name) {
                    current = child;
                    found = true;
                    break;
                }
            }
            // Early return if not found
            if (!found) {
                return;
            }
        }

        return current;
    }
1363729
function parse(path) {
  if (t.Array.is(path)) {
    return path.map(parse).filter(Boolean);
  }
  var component = getComponent(require(path));
  if (component) {
    var comments = getComments(path);
    var descriptions = getDescriptions(comments);
    var type = toObject(getPropsType(component));
    var props = type.kind === 'refinement' ? type.type.props : type.props;
    var defaultProps = getDefaultProps(component);
    var name = getComponentName(component);
    for (var prop in props) {
      if (props.hasOwnProperty(prop)) {
        if (defaultProps.hasOwnProperty(prop)) {
          props[prop].defaultValue = defaultProps[prop];
        }
        if (descriptions.props.hasOwnProperty(prop)) {
          props[prop].description = descriptions.props[prop];
        }
      }
    }
    return {
      name: name,
      description: descriptions.component,
      props: props
    };
  }
}
244822
function applyEnsureOrdering(path) {
  // TODO: This should probably also hoist computed properties.
  const decorators = (path.isClass()
    ? [path].concat(path.get("body.body"))
    : path.get("properties")
  ).reduce((acc, prop) => acc.concat(prop.node.decorators || []), []);

  const identDecorators = decorators.filter(
    decorator => !t.isIdentifier(decorator.expression),
  );
  if (identDecorators.length === 0) return;

  return t.sequenceExpression(
    identDecorators
      .map(decorator => {
        const expression = decorator.expression;
        const id = (decorator.expression = path.scope.generateDeclaredUidIdentifier(
          "dec",
        ));
        return t.assignmentExpression("=", id, expression);
      })
      .concat([path.node]),
  );
}
856308
function get(path) {
    return defineRouteProperty([{ name: "path", args: [path || ""] }, { name: "method", args: [appolo_agent_1.Methods.GET] }]);
}
790972
function(path, contract) {
  if (!contract) {
    contract = path;
    path = '/';
  }

  if (contract.handle) {
    this.root.use(path, (req, res, next) => {
      contract.handle(req, res, next)
    });
  } else {
    this.root.use(path, contract);
  }
  return this;
}
1298878
function get(path) {
  return splitPath(path).concat('@').reduce(function (t, segment) {
    return t ? t[segment]
             : undefined
  }, this)
}
570740
function resolve(path, options, callback) {
        resolvePath(path, options, function (err, path) {
            if (err) return callback(err);
            callback(null, { path: path });
        });
    }