*

@param {Function} factory
@param {Object} [attributes]
@param [descriptor=false]
@return {*}
773254
function (factory, attributes, descriptor) {
                descriptor = descriptor || false;
                attributes = attributes || [];
                if (factory instanceof Function) {
                    return new factory(attributes, descriptor, this.$stage, this, this.$rootScope, this.$cidScope, true);
                }
                return this.$stage.$applicationContext.createInstance(factory, [attributes, descriptor, this.$stage, this, this.$rootScope, this.$cidScope, true]);
            }
1098380
function(descriptor) {
					var newDescriptor = {
						get: descriptor.get,
						set: function(val) {
							if (fnIsACBUrl(val)) {
								val = fnConvertUrl(val);
							}
							descriptor.set.call(this, val);
						},
						enumerable: descriptor.enumerable,
						configurable: descriptor.configurable
					};
					newDescriptor.set._sapUiCoreACB = true;
					return newDescriptor;
				}
833161
function setDomAttrs(attrs, el) {
	for (let attr in attrs) {
		if (!attrs.hasOwnProperty(attr)) { continue; }
		switch (attr) {
			case 'className':
			case 'id':
				el[attr] = attrs[attr];
				break;
			default:
				el.setAttribute(attr, attrs[attr]);
				break;
		}
	}

	return el;
}
268192
function modPreDefine( id, dependencies, factory ) {
        if ( modModules[ id ] ) {
            return;
        }

        // 模块内部信息包括
        // -----------------------------------
        // id: module id
        // deps: 模块定义时声明的依赖，默认为['require', 'exports', 'module']
        // factory: 初始化函数或对象
        // factoryDeps: 初始化函数的参数依赖
        // exports: 模块的实际暴露对象（AMD定义）
        // config: 用于获取模块配置信息的函数（AMD定义）
        // state: 模块当前状态
        // require: local require函数
        // depMs: 实际依赖的模块集合，数组形式
        // depMsIndex: 实际依赖的模块集合，表形式，便于查找
        // depRs: 实际依赖的资源集合
        // depPMs: 用于加载资源的模块集合，key是模块名，value是1，仅用于快捷查找
        // ------------------------------------
        var module = {
            id          : id,
            deps        : dependencies || ['require', 'exports', 'module'],
            factoryDeps : [],
            factory     : factory,
            exports     : {},
            config      : moduleConfigGetter,
            state       : MODULE_PRE_DEFINED,
            require     : createLocalRequire( id ),
            depMs       : [],
            depMsIndex  : {},
            depRs       : [],
            depPMs      : {}
        };

        // 将模块存入容器
        modModules[ id ] = module;
        modModuleList.push( module );
    }
996061
function(b) {
        if (b instanceof Model) {
          if (this.constructor !== b.constructor) return false;
          b = b.attributes;
        }
        return _.isEqual(this.attributes, b);
      }
757858
function modPreDefine(id, dependencies, factory) {
        // 将模块存入容器
        //
        // 模块内部信息包括
        // -----------------------------------
        // id: module id
        // depsDec: 模块定义时声明的依赖
        // deps: 模块依赖，默认为['require', 'exports', 'module']
        // factory: 初始化函数或对象
        // factoryDeps: 初始化函数的参数依赖
        // exports: 模块的实际暴露对象（AMD定义）
        // config: 用于获取模块配置信息的函数（AMD定义）
        // state: 模块当前状态
        // require: local require函数
        // depMs: 实际依赖的模块集合，数组形式
        // depMkv: 实际依赖的模块集合，表形式，便于查找
        // depRs: 实际依赖的资源集合
        // ------------------------------------
        if (!modModules[id]) {
            modModules[id] = {
                id         : id,
                depsDec    : dependencies,
                deps       : dependencies || ['require', 'exports', 'module'],
                factoryDeps: [],
                factory    : factory,
                exports    : {},
                config     : moduleConfigGetter,
                state      : MODULE_PRE_DEFINED,
                require    : createLocalRequire(id),
                depMs      : [],
                depMkv     : {},
                depRs      : [],
                hang       : 0
            };
        }
    }
381488
function _includeModelFactory (obj, mds, field, v) {
  let md = mds.shift()
  let Field = field

  if (reg.test(field) && !regOr.test(field) && !regOrAnd.test(field)) {
    Field = field.replace(reg, '')
  } else if (regOr.test(field)) {
    Field = field.replace(regOr, '')
  } else if (regOrAnd.test(field)) {
    Field = field.replace(regOrAnd, '')
  }

  obj.model = this.models[md]
  if (mds.length === 0) {
    obj.attributes = ['id', Field]
    obj.where = {}
    _queryField2where.call(this, obj.where, field, v, md)
  } else {
    obj.attributes = ['id']
    let includeObj = {}

    obj.include = [includeObj]
    _includeModelFactory.call(this, includeObj, mds, field, v)
  }

  return obj
}
546925
function(options, view) {
      var attrs = options.attributes;
      if (_.isFunction(attrs)) {
        attrs = attrs(view);
      } else if (_.isString(attrs) && (_.isFunction(defaultAttributeLoaders[attrs]))) {
        attrs = defaultAttributeLoaders[attrs](view);
      }
      if (_.isArray(attrs)) {
        return attrs;
      }
    }
1025077
function createFactory(viewSpecifier, viewName) {
	return function() {
		var props = {}
		var children = []
		each(arguments, function processArg(val) {
			if (val === undefined || val === null || val === true || val === false) {
				return
				
			} else if (_isReactObj(val)) {
				children.push(val)
				
			} else if (val._isTagsStyleSheet) {
				if (!props.style) {
					props.style = [val._tagsStyleSheetId]
				} else if (!isArray(props.style)) {
					throw new Error('Cannot use both tags.Style and tags.StyleSheet on the same element')
				} else {
					props.style.push(val._tagsStyleSheetId)
				}
				
			} else if (val._isTagsStyleVal) {
				if (!props.style) {
					props.style = val._tagsStyleVal
				} else if (!isObject(props.style)) {
					throw new Error('Cannot use both tags.StyleSheet and tags.Style on the same element')
				} else {
					assign(props.style, val._tagsStyleVal)
				}
				
			} else if (isFunction(val)) {
				processArg(val(props, children))
				
			} else if (isArray(val) || isArguments(val)) {
				each(val, processArg)
				
			} else if (isObject(val)) {
				if (val.style && props.style) {
					throw new Error("Cannot use multiple style properties on the same element")
				} else if (val.__value) {
					// TODO: expose canonical way for autoreact to play well with tags.js
					processArg(val.__value)
				} else {
					assign(props, val)
				}
				
			} else {
				children.push(val)
			}
		})
		applyStyleDefaults(viewName, props)
		return React.createElement(viewSpecifier, props, ...children)
	}
}
626189
function defaultAttrs(attrs) {
  let defaults = Object.create(null)
  for (let attrName in attrs) {
    let attr = attrs[attrName]
    if (!attr.hasDefault) return null
    defaults[attrName] = attr.default
  }
  return defaults
}
1065399
function ClassInstance(attr) {
    Object.defineProperties(this,
      { __jsmf__: {value: elementMeta(ClassInstance)}
      })
    createAttributes(this, ClassInstance)
    createReferences(this, ClassInstance)
    _.forEach(attr, (v,k) => {this[k] = v})
  }
223196
function Model(attr, options) {

  if (!(this instanceof Model)) return new Model(attr, options);

  EE.call(this);
  this.options = options || {};

  //private(ish) model not to be accessed or changed
  this._attributes = {};
  this.set(attr || {});
}
466411
function factory(tree, options) {
  var settings = options || {}
  var dangerous = settings.allowDangerousHTML

  h.dangerous = dangerous
  h.definition = definitions(tree, settings)
  h.footnotes = []
  h.augment = augment
  h.handlers = xtend(handlers, settings.handlers || {})

  visit(tree, 'footnoteDefinition', visitor)

  return h

  // Finalise the created `right`, a hast node, from `left`, an mdast node.
  function augment(left, right) {
    var data
    var ctx

    // Handle `data.hName`, `data.hProperties, `hChildren`.
    if (left && 'data' in left) {
      data = left.data

      if (right.type === 'element' && data.hName) {
        right.tagName = data.hName
      }

      if (right.type === 'element' && data.hProperties) {
        right.properties = xtend(right.properties, data.hProperties)
      }

      if (right.children && data.hChildren) {
        right.children = data.hChildren
      }
    }

    ctx = left && left.position ? left : {position: left}

    if (!generated(ctx)) {
      right.position = {
        start: position.start(ctx),
        end: position.end(ctx)
      }
    }

    return right
  }

  // Create an element for a `node`.
  function h(node, tagName, props, children) {
    if (
      (children === undefined || children === null) &&
      typeof props === 'object' &&
      'length' in props
    ) {
      children = props
      props = {}
    }

    return augment(node, {
      type: 'element',
      tagName: tagName,
      properties: props || {},
      children: children || []
    })
  }

  function visitor(definition) {
    h.footnotes.push(definition)
  }
}
217973
function (node, attributes, rootScope, cidScope) {
                if (!node) {
                    return null;
                }

                attributes = attributes || {};
                rootScope = rootScope || this.$rootScope;
                cidScope = cidScope || this.$cidScope;
                // only instantiation and construction but no initialization


                var instance = null;

                if (node.nodeType === 1) { // Elements
                    var namespaceURI = node.namespaceURI,
                        localName = this._localNameFromDomNode(node),
                        cacheKey = namespaceURI + ":" + localName,
                        factory = FactoryCache[cacheKey];

                    if (factory) {
                        instance = new factory(attributes, node, this.$stage, this, rootScope, cidScope, true);
                    } else {
                        var fqClassName = this.$stage.$applicationContext.getFqClassName(namespaceURI, localName, true);
                        var className = this.$stage.$applicationContext.getFqClassName(namespaceURI, localName, false);
                        instance = this.$stage.$applicationContext.createInstance(fqClassName, [attributes, node, this.$stage, this, rootScope, cidScope, true], className);
                        FactoryCache[cacheKey] = instance.factory;
                    }

                } else if (node.nodeType === 3 || node.nodeType === 4) {
                    // Text nodes
                    instance = this._createTextElement(node, rootScope, cidScope, attributes);
                }

                return instance;
            }
11041
function getAttrMap(attrs)
{
	var i;
	var map = {};
	var numAttrs = attrs.length;
	
	for (i=0; i<numAttrs; i++)
	{
		map[ attrs[i].name ] = attrs[i].value;
	}
	
	return map;
}
904898
function attributes(el, attrs, store) {
  for(var key in attrs) {
    var value = attrs[key];
    if(typeof value === 'object') value = styles(value);
    else if(typeof value === 'function') {
      var bool = key.substring(0, 2) === 'on';
      if(bool) el.addEventListener(key.slice(2), value);
      else el.setAttribute(key, value.call(store.data));
      // @not we should compute the function if it's not an event
      break;
    }

    bind(value, function(data) {
       // @note should refactor with render (too bad attribute can't append text node anymore)
       el.setAttribute(this, data);
    }.bind(key), store);
  }
}
341265
function attributes(node) {
    var obj = {};
    each(function(attr) {
      obj[attr.name] = attr.value;
    }, node.attributes);
    return obj;
  }