var hasDirectives = {},

Suffix = 'Directive',

COMMENT_DIRECTIVE_REGEXP = /^\s*directive\:\s*([\w\-]+)\s+(.*)$/,

CLASS_DIRECTIVE_REGEXP = /(([\w\-]+)(?:\:([^;]+))?;?)/,

ALL_OR_NOTHING_ATTRS = makeMap('ngSrc,ngSrcset,src,srcset'),

REQUIRE_PREFIX_REGEXP = /^(?:(\^\^?)?(\?)?(\^\^?)?)?/;

// Ref: http://developers.whatwg.org/webappapis.html#event-handler-idl-attributes

// The assumption is that future DOM event attribute names will begin with

// 'on' and be composed of only English letters.

var EVENT_HANDLER_ATTR_REGEXP = /^(on[a-z]+|formaction)$/;

var bindingCache = createMap();

function parseIsolateBindings(scope, directiveName, isController) {

var LOCAL_REGEXP = /^\s*([@&<]|=(\*?))(\??)\s*(\w*)\s*$/;

var bindings = {};

forEach(scope, function(definition, scopeName) {

if (definition in bindingCache) {

bindings[scopeName] = bindingCache[definition];

return;

}

var match = definition.match(LOCAL_REGEXP);

if (!match) {

throw $compileMinErr('iscp',

"Invalid {3} for directive '{0}'." +

" Definition: {... {1}: '{2}' ...}",

directiveName, scopeName, definition,

(isController ? "controller bindings definition" :

"isolate scope definition"));

}

bindings[scopeName] = {

mode: match[1][0],

collection: match[2] === '*',

optional: match[3] === '?',

attrName: match[4] || scopeName

};

if (match[4]) {

bindingCache[definition] = bindings[scopeName];

}

});

return bindings;

}

function parseDirectiveBindings(directive, directiveName) {

var bindings = {

isolateScope: null,

bindToController: null

};

if (isObject(directive.scope)) {

if (directive.bindToController === true) {

bindings.bindToController = parseIsolateBindings(directive.scope,

directiveName, true);

bindings.isolateScope = {};

} else {

bindings.isolateScope = parseIsolateBindings(directive.scope,

directiveName, false);

}

}

if (isObject(directive.bindToController)) {

bindings.bindToController =

parseIsolateBindings(directive.bindToController, directiveName, true);

}

if (isObject(bindings.bindToController)) {

var controller = directive.controller;

var controllerAs = directive.controllerAs;

if (!controller) {

// There is no controller, there may or may not be a controllerAs property

throw $compileMinErr('noctrl',

"Cannot bind to controller without directive '{0}'s controller.",

directiveName);

} else if (!identifierForController(controller, controllerAs)) {

// There is a controller, but no identifier or controllerAs property

throw $compileMinErr('noident',

"Cannot bind to controller without identifier for directive '{0}'.",

directiveName);

}

}

return bindings;

}

function assertValidDirectiveName(name) {

var letter = name.charAt(0);

if (!letter || letter !== lowercase(letter)) {

throw $compileMinErr('baddir', "Directive/Component name '{0}' is invalid. The first character must be a lowercase letter", name);

}

if (name !== name.trim()) {

throw $compileMinErr('baddir',

"Directive/Component name '{0}' is invalid. The name should not contain leading or trailing whitespaces",

name);

}

}

/**

this.directive = function registerDirective(name, directiveFactory) {

assertNotHasOwnProperty(name, 'directive');

if (isString(name)) {

assertValidDirectiveName(name);

assertArg(directiveFactory, 'directiveFactory');

if (!hasDirectives.hasOwnProperty(name)) {

hasDirectives[name] = [];

$provide.factory(name + Suffix, ['$injector', '$exceptionHandler',

function($injector, $exceptionHandler) {

var directives = [];

forEach(hasDirectives[name], function(directiveFactory, index) {

try {

var directive = $injector.invoke(directiveFactory);

if (isFunction(directive)) {

directive = { compile: valueFn(directive) };

} else if (!directive.compile && directive.link) {

directive.compile = valueFn(directive.link);

}

directive.priority = directive.priority || 0;

directive.index = index;

directive.name = directive.name || name;

directive.require = directive.require || (directive.controller && directive.name);

directive.restrict = directive.restrict || 'EA';

directive.$$moduleName = directiveFactory.$$moduleName;

directives.push(directive);

} catch (e) {

$exceptionHandler(e);

}

});

return directives;

}]);

}