///////////////// 读取Properties ////////////////////
768033
public static Boolean getBoolean(Properties p, String name, Boolean defaultValue) {
		return BooleanUtil.toBooleanObject(p.getProperty(name), defaultValue);
	}
1273615
@SuppressWarnings("unchecked")
    protected void configure() {

        Properties properties = readDefaultConfig();

        Properties appProperties = new Props();

        List<String> appConf = Lists.newArrayListWithExpectedSize(configFiles.length);
        for (String conf : configFiles) {
            //读取应用程序配置
            URL appCfgUrl = readAppConfig(appProperties, conf);
            appConf.add(toExternalForm(appCfgUrl));
        }

        //获取应用程序模式
        try {
            mode = Mode.valueOf(appProperties.getProperty("app.mode").toUpperCase());
        } catch (Exception e) {
            mode = Mode.PRODUCT;
        }

        //设置应用程序名称
        setApplicationName(StringUtils.defaultString(appProperties.getProperty("app.name"), DEFAULT_APP_NAME));
        applicationVersion = appProperties.getProperty("app.version");
        if (StringUtils.isBlank(applicationVersion)) {
            applicationVersion = new UnknownVersion();
        }

        //配置日志器
        configureLogger(appProperties);

        if (!isInitialized())
            Ameba.printInfo();

        logger.info(Messages.get("info.init"));
        logger.info(Messages.get("info.app.conf", appConf));

        //读取模式配置
        readModeConfig(properties, mode);

        //读取模块配置
        readModuleConfig(properties, getMode().isDev());

        properties.putAll(appProperties);

        srcProperties.putAll((Map) properties);

        setEnvironmentConfig(srcProperties);

        addOnSetup(srcProperties);

        //转换jersey配置项
        convertJerseyConfig(srcProperties);

        //将临时配置对象放入应用程序配置
        addProperties(srcProperties);

        srcProperties = Collections.unmodifiableMap(srcProperties);

        registerBinder();

        configureExclude(srcProperties);

        //配置资源
        configureResource();

        //配置特性
        configureFeature(srcProperties);

        //配置服务器相关
        configureServer();

        //清空临时读取的配置
        properties.clear();

        scanClasses();

        addOnDone();

        addons = Collections.unmodifiableSet(addons);
        excludes = Collections.unmodifiableSet(excludes);

        logger.info(Messages.get("info.feature.load"));
    }
220896
function (filedir) {
    var files = fs.readdirSync(filedir);

    files.forEach(function (url) {
        var fullUrl = path.join(filedir, url);
        var stat = fs.statSync(fullUrl);
        if (stat.isDirectory()) {
            walkAllFiles(fullUrl);
        }
        if (stat.isFile()) {
            var pass = true;
            paramObj.staticResourcesFileFilter.forEach(function (val) {
                if (val.test(fullUrl)) {
                    pass = false;
                }
            });
            var isHtml = url.match(/\.html|\.htm/);
            if (isHtml) {
                addToHtmlFiles(path.relative(baseRoot, fullUrl).replace(isHtml[0], '').replace(/\\|\//g, '/'), fullUrl);
            }
            if (pass) { //需要过滤掉的格式
                allFilesToUpload.push(fullUrl);
            }
        }
    });
}
711146
function(_dest, _src){
                var _nodeName, _attr;

                if (_dest.nodeType !== 1) {
                    return;
                }
                // lt ie9 才有
                if (_dest.clearAttributes) {
                    _dest.clearAttributes();
                    _dest.mergeAttributes(_src);
                }
                // 判断是否有需要处理属性的节点
                _nodeName = _dest.nodeName.toLowerCase();
                if(_prop = _definitions.fixProps[_nodeName]){
                    _dest[_prop] = _src[_prop];
                }
                //移除节点标示
                _dest.removeAttribute($._$signal);
                // 移除ID:  TODO? 是否允许有重复ID?
                _dest.removeAttribute("id");
            }
412464
function obtainFramework(content, resource, opts, host) {
  rScript.lastIndex = rLoader.lastIndex = 0;

  return content.replace(rScript, function(all, comment, script, body, ignored) {

    // 忽略注释。
    if (comment || ignored ) {
      return all;
    }
   // console.log(script);

    if (!body.trim() && rSrcHref.test(script)) {
      var src = RegExp.$2;
      var file = resource.getFileByUrl(src);

      if (!file) {
        file = resource.getFileByUrl(fis.util(path.join(path.dirname(host.release), src)));
      }

      // 如果 require.js 或者 esl.js 或者是 mod.js
      // 或者 <script 设置了 data-loader 属性
      // 则认为此资源为前端loader
      if (rLoader.test(script) || file && ~['require.js', 'esl.js', 'mod.js', 'sea.js'].indexOf(file.basename)) {

        // 根据 js 自动设置 resourceType。
        if (opts.resourceType === 'auto' && file) {
          opts.resourceType = file.basename === 'mod.js' ? 'mod' : (file.basename === 'sea.js' ? 'cmd' : 'amd');
        }

        if (opts.obtainScript) {
          file ? resource.add(file.id) : resource.addJs(src);

          if (opts.useInlineMap) {
            if (!~content.indexOf(opts.resoucePlaceHolder)) {
              resource.addJsEmbed('/*resourcemap*/\n'+opts.resoucePlaceHolder);
            }
          } else {
            resource.addJs('resoucePlaceHolder');
          }

          all = '';
        } else if (!~content.indexOf(opts.resoucePlaceHolder)) {
          all += '\n' + opts.resoucePlaceHolder;
        }
      } else if (rFramework.test(script) && opts.obtainScript) {
        file ? resource.add(file.id) : resource.addJs(src);
      }
    }

    return all;
  });
}
459564
function (_this) {
    // 窗口高度
    var windowHeight = $window.height();

    // 配置参数
    var gutter = _this.options.gutter;
    var position = _this.options.position;

    // mdui-select 高度
    var selectHeight = parseInt(_this.$select.height());

    // 菜单项高度
    var $menuItemFirst = _this.$items.eq(0);
    var menuItemHeight = parseInt($menuItemFirst.height());
    var menuItemMargin = parseInt($menuItemFirst.css('margin-top'));

    // 菜单高度
    var menuWidth = parseFloat(_this.$select.width() + 0.01); // 必须比真实宽度多一点，不然会出现省略号
    var menuHeight = menuItemHeight * _this.size + menuItemMargin * 2;

    // var menuRealHeight = menuItemHeight * _this.$items.length + menuItemMargin * 2;

    // 菜单是否出现了滚动条
    //var isMenuScrollable = menuRealHeight > menuHeight;

    // select 在窗口中的位置
    var selectTop = _this.$select[0].getBoundingClientRect().top;

    var transformOriginY;
    var menuMarginTop;

    // position 为 auto 时
    if (position === 'auto') {

      // 菜单高度不能超过窗口高度
      var heightTemp = windowHeight - gutter * 2;
      if (menuHeight > heightTemp) {
        menuHeight = heightTemp;
      }

      // 菜单的 margin-top
      menuMarginTop = -(
        menuItemMargin + _this.selectedIndex * menuItemHeight +
        (menuItemHeight - selectHeight) / 2
      );
      var menuMarginTopMax = -(
        menuItemMargin + (_this.size - 1) * menuItemHeight +
        (menuItemHeight - selectHeight) / 2
      );
      if (menuMarginTop < menuMarginTopMax) {
        menuMarginTop = menuMarginTopMax;
      }

      // 菜单不能超出窗口
      var menuTop = selectTop + menuMarginTop;

      if (menuTop < gutter) {
        // 不能超出窗口上方
        menuMarginTop = -(selectTop - gutter);
      } else if (menuTop + menuHeight + gutter > windowHeight) {
        // 不能超出窗口下方
        menuMarginTop = -(selectTop + menuHeight + gutter - windowHeight);
      }

      // transform 的 Y 轴坐标
      transformOriginY = (_this.selectedIndex * menuItemHeight + menuItemHeight / 2 + menuItemMargin) + 'px';
    } else if (position === 'bottom') {
      menuMarginTop = selectHeight;
      transformOriginY = '0px';
    } else if (position === 'top') {
      menuMarginTop = -menuHeight - 1;
      transformOriginY = '100%';
    }

    // 设置样式
    _this.$select.width(menuWidth);
    _this.$menu
      .width(menuWidth)
      .height(menuHeight)
      .css({
        'margin-top': menuMarginTop + 'px',
        'transform-origin':
        'center ' + transformOriginY + ' 0',
      });
  }
88134
public Properties getSmtpProps() {
		//全局系统参数
		System.setProperty(SPLIT_LONG_PARAMS, String.valueOf(this.splitlongparameters));
		
		final Properties p = new Properties();
		p.put(MAIL_PROTOCOL, "smtp");
		p.put(SMTP_HOST, this.host);
		p.put(SMTP_PORT, String.valueOf(this.port));
		p.put(SMTP_AUTH, String.valueOf(this.auth));
		if(this.timeout > 0) {
			p.put(SMTP_TIMEOUT, String.valueOf(this.timeout));
		}
		if(this.connectionTimeout > 0) {
			p.put(SMTP_CONNECTION_TIMEOUT, String.valueOf(this.connectionTimeout));
		}

		p.put(MAIL_DEBUG, String.valueOf(this.debug));

		if (this.startttlsEnable) {
			//STARTTLS是对纯文本通信协议的扩展。它将纯文本连接升级为加密连接（TLS或SSL）， 而不是使用一个单独的加密通信端口。
			p.put(STARTTTLS_ENABLE, String.valueOf(this.startttlsEnable));
			
			if(null == this.sslEnable) {
				//为了兼容旧版本，当用户没有此项配置时，按照startttlsEnable开启状态时对待
				this.sslEnable = true;
			}
		}
		
		// SSL
		if(null != this.sslEnable && this.sslEnable) {
			p.put(SOCKEY_FACTORY, socketFactoryClass);
			p.put(SOCKEY_FACTORY_FALLBACK, String.valueOf(this.socketFactoryFallback));
			p.put(SOCKEY_FACTORY_PORT, String.valueOf(this.socketFactoryPort));
		}
		
		return p;
	}
149545
private static function initFramework()
    {
        static::$runtimeInfo = new RuntimeInfo;
        static::$container = new Container;
        // 初始化Main类
        static::initMains();
        // 设置临时子目录
        $subPath = Random::letterAndNumber(32, 32);
        // 注解处理
        static::$annotation = Annotation::getInstance();
        // 框架运行时缓存支持
        if('server/start' === $_SERVER['argv'][1])
        {
            $result = false;
        }
        else
        {
            // 尝试加载
            $result = App::loadRuntimeInfo(Imi::getRuntimePath('imi-runtime.cache'));
        }
        if(!$result)
        {
            // 不使用缓存时去扫描
            static::$annotation->init([
                MainHelper::getMain('Imi', 'Imi'),
            ]);
        }
        static::$isInited = true;
        Event::trigger('IMI.INITED');
    }
763413
function(pathname) {
        // 如果在路径配置中显示忽略这个路径，那就直接忽略之
        var ignore = this._options.ignore;
        if (ignore) {
            if (pathname.indexOf(ignore) == 0) {
                return false;
            }
        }

        // 如果不存在配置信息，那就直接返回
        var pathsConfig = this._config.paths;
        if (!pathsConfig) return null;

        var path2RegMap = this._path2RegMap;
        for (var path in pathsConfig) {
            var reg = path2RegMap[path] || (path2RegMap[path] = path2reg(path, []));
            if (reg.test(pathname)) {
                return pathsConfig[path];
            }
        }

        return null;
    }
1374720
function ieRgbaHack(decl, i) {
  //十六进制不足两位自动补 0
  function pad(str) {
    return str.length == 1 ? '0' + str : '' + str
  }
  if (
    (decl.prop == 'background' || decl.prop == 'background-color') &&
    decl.value.match(reRGBA)
  ) {
    // rgba 转换为 AARRGGBB
    var colorR = pad(parseInt(RegExp.$1).toString(16))
    var colorG = pad(parseInt(RegExp.$2).toString(16))
    var colorB = pad(parseInt(RegExp.$3).toString(16))
    var colorA = pad(parseInt(RegExp.$4 * 255).toString(16))
    var ARGB = "'" + '#' + colorA + colorR + colorG + colorB + "'"

    // 插入IE半透明滤镜
    var reBefore = decl.raws.before.replace(reBLANK_LINE, '$1')
    insertDecl(decl, i, {
      raws: {
        before: reBefore
      },
      prop: 'filter',
      value:
        'progid:DXImageTransform.Microsoft.gradient(startColorstr=' +
        ARGB +
        ', endColorstr=' +
        ARGB +
        ')'
    })

    // IE9 rgba 和滤镜都支持，插入 :root hack 去掉滤镜
    var newSelector = ':root ' + decl.parent.selector

    var nextrule = postcss.rule({
      selector: newSelector
    })
    decl.parent.parent.insertAfter(decl.parent, nextrule)
    nextrule.append({
      prop: 'filter',
      value: 'none\\9'
    })
  }
}
312750
function install (presetName, options = {}) {
  debug('run install from cli, arguments: %o', arguments)

  /**
   * 处理 preset name
   */
  const parsedPresetName = parse(presetName)
  debug('parsed presetName object: %o', parsedPresetName)

  if (!parsedPresetName || !parsedPresetName.name) {
    log.error('请输入正确的 presetName.')
    process.exit(1)
  }

  const { name, scope, version } = parsedPresetName

  /**
   * 处理 options
   */
  const keep = options.keep || process.env.npm_config_keep || ''
  const registry = getRegistryUrl(
    options.registry || process.env.npm_config_registry || ''
  )

  // registryUrl 存在但是不合法
  if (registry && !/^https?:\/\//.test(registry)) {
    log.error('registry must be a full url with http(s)://')
    process.exit(1)
  }

  debug('parsed options: %o', { keep, registry })

  // 临时安装目录
  const tmpdir = path.join(os.tmpdir(), `elint_tmp_${Date.now()}`)
  const prestPackageName = stringify({ scope, name })
  const presetModulePath = process.platform === 'win32'
    ? path.join(tmpdir, `node_modules/${prestPackageName}`)
    : path.join(tmpdir, `lib/node_modules/${prestPackageName}`)
  const presetPkgPath = path.join(presetModulePath, 'package.json')

  debug(`tmpdir: ${tmpdir}`)
  debug(`preset module path: ${presetModulePath}`)
  debug(`preset package.json path: ${presetPkgPath}`)

  fs.ensureDirSync(tmpdir)

  co(function * () {
    /**
     * step1: 安装 preset
     */
    const installName = stringify({ scope, name, version })
    console.log(`install "${installName}"...`)

    yield npmInstall(installName, {
      prefix: tmpdir,
      registry
    })

    /**
     * step2: mv config file
     */
    link(presetModulePath, keep)

    // eslint-disable-next-line global-require
    const dependencies = require(presetPkgPath).dependencies
    if (!dependencies) {
      // 无需执行 step3, step4
      return
    }

    /**
     * step3: 修改 package.json
     *
     * 将 preset 的 dependencies 写入项目 package.json 的 devDependencies
     */
    console.log('save dependencies to package.json')
    writePkg(dependencies)

    /**
     * step4: 安装 preset 的 dependencies
     */
    console.log('install dependencies...')

    // 兼容 node v6
    const packages = _.toPairs(dependencies)
      .map(([name, range]) => {
        return `${name}@${packageVersion(range)}`
      })

    yield npmInstall(packages, {
      saveDev: true
    })

    // 清理临时目录
    fs.removeSync(tmpdir)
  }).catch(error => {
    log.error(error.message)
    process.exit(1)
  })
}
68977
function margeConfig(options, origId) {
    if (!origId) return;
    var config = options.config,
        arr, modId;
    // 处理build.json => map
    if (options.map && options.map[origId]) {
        origId = options.map[origId];
    }

    // 处理seajs.config => vars
    if (config.vars) {
        if (~origId.indexOf('{')) {
            origId = origId.replace(rVar, function ($, $1) {
                if (config.vars[$1]) {
                    return config.vars[$1];
                }

                return $;
            });
        }
    }

    // 处理seajs.config => alias
    if (config.alias && config.alias[origId]) {
        origId = config.alias[origId];
    }

    // 处理seajs.config => paths
    if (config.paths) {
        arr = origId.split('/');
        modId = arr.splice(arr.length - 1, 1);

        arr.forEach(function (_item, i) {
            if (config.paths[_item]) {
                arr[i] = config.paths[_item];
            }
        });

        arr = arr.concat(modId);
        origId = arr.join('/');
    }
    return origId;
}
819614
function() {
                // 获取现有颜色映射
                //     resource => color_index
                var colorMapping = this._getResourceColorIndexMapping();

                var resource, used, i;

                used = [];

                // 抽取已经使用的值到 used 数组
                for (resource in colorMapping) {
                    if (Object.prototype.hasOwnProperty.call(colorMapping, resource)) {
                        used.push(colorMapping[resource]);
                    }
                }

                // 枚举所有的可用值，如果还没被使用，返回
                for (i = 0; i < RESOURCE_COLOR_SERIES.length; i++) {
                    if (!~used.indexOf(i)) return i;
                }

                // 没有可用的颜色了
                return -1;
            }
477582
function (resourceID, ext, merge) {
            var self = this;
            var staticPath;
            if (_.isEmpty(self.map)) {
                // map 为空时, 直接拼接路径, 并确保文件存在
                staticPath = FileLoader.matchFile(path.join(self.staticPath, resourceID) + ext);
                if (!merge && staticPath) {
                    staticPath = staticPath.substr(staticPath.indexOf(self.staticFolder));
                }
            } else {
                var resourceKey = path.join(self.templateFolder, resourceID) + ext;
                var result = self.map['res'] && self.map['res'][resourceKey];
                staticPath = result && result.uri;
                if (merge && staticPath) {
                    staticPath = self.webRootPath + staticPath;
                }
            }
            return staticPath;
        }
163342
public void norm_setBaseRelated() {
        String[] time_grid = new String[6];
        time_grid = timeBaseText.split("-");
        int[] ini = new int[6];
        for (int i = 0; i < 6; i++) {
            ini[i] = Integer.parseInt(time_grid[i]);
        }

        Calendar calendar = Calendar.getInstance();
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        calendar.set(ini[0], ini[1] - 1, ini[2], ini[3], ini[4], ini[5]);
        calendar.getTime();

        //year, month, day, hour, min, second
        boolean[] flag = {false, false, false, false, false, false};//观察时间表达式是否因当前相关时间表达式而改变时间

        String rule = "\\d+(?=天[以之]?前)";
        Pattern pattern = Pattern.compile(rule);
        Matcher match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[2] = true;
            int day = Integer.parseInt(match.group());
            calendar.add(Calendar.DATE, -day);
        }

        rule = "\\d+(?=天[以之]?后)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[2] = true;
            int day = Integer.parseInt(match.group());
            calendar.add(Calendar.DATE, day);
        }

        rule = "\\d+(?=(个)?月[以之]?前)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[1] = true;
            int month = Integer.parseInt(match.group());
            calendar.add(Calendar.MONTH, -month);
        }

        rule = "\\d+(?=(个)?月[以之]?后)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[1] = true;
            int month = Integer.parseInt(match.group());
            calendar.add(Calendar.MONTH, month);
        }

        rule = "\\d+(?=年[以之]?前)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[0] = true;
            int year = Integer.parseInt(match.group());
            calendar.add(Calendar.YEAR, -year);
        }

        rule = "\\d+(?=年[以之]?后)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[0] = true;
            int year = Integer.parseInt(match.group());
            calendar.add(Calendar.YEAR, year);
        }

        /////////////////////新支持各类之前/之后 //////	//added by zhu
        rule = "\\d+(?=小时[以之]?前)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[4] = true;
            int hour = Integer.parseInt(match.group());
            long ms = calendar.getTime().getTime() - hour * 3600 * 1000;
            calendar.setTimeInMillis(ms);
        }

        rule = "\\d+(?=小时[以之]?后)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[4] = true;
            int hour = Integer.parseInt(match.group());
            long ms = calendar.getTime().getTime() + hour * 3600 * 1000;
            calendar.setTimeInMillis(ms);
        }

        rule = "半个?小时[以之]?前";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[4] = true;
            long ms = calendar.getTime().getTime() - 1800 * 1000;
            calendar.setTimeInMillis(ms);
        }

        rule = "半个?小时[以之]?后";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[4] = true;
            long ms = calendar.getTime().getTime() + 1800 * 1000;
            calendar.setTimeInMillis(ms);
        }

        rule = "\\d+(?=刻钟[以之]?前)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[4] = true;
            int q = Integer.parseInt(match.group());
            long ms = calendar.getTime().getTime() - q * 15 * 60 * 1000;
            calendar.setTimeInMillis(ms);
        }

        rule = "\\d+(?=刻钟[以之]?后)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[4] = true;
            int q = Integer.parseInt(match.group());
            long ms = calendar.getTime().getTime() + q * 15 * 60 * 1000;
            calendar.setTimeInMillis(ms);
        }

        rule = "\\d+(?=分钟?[以之]?前)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[4] = true;
            int min = Integer.parseInt(match.group());
            long ms = calendar.getTime().getTime() - min * 60 * 1000;
            calendar.setTimeInMillis(ms);
        }

        rule = "\\d+(?=分钟?[以之]?后)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[4] = true;
            int min = Integer.parseInt(match.group());
            long ms = calendar.getTime().getTime() + min * 60 * 1000;
            calendar.setTimeInMillis(ms);
        }

        rule = "半分钟?[以之]?前";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[4] = true;
            long ms = calendar.getTime().getTime() - 30 * 1000;
            calendar.setTimeInMillis(ms);
        }

        rule = "半分钟?[以之]?后";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[4] = true;
            long ms = calendar.getTime().getTime() + 30 * 1000;
            calendar.setTimeInMillis(ms);
        }

        rule = "\\d+(?=秒钟?[以之]?前)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[5] = true;
            int sec = Integer.parseInt(match.group());
            long ms = calendar.getTime().getTime() - sec * 1000;
            calendar.setTimeInMillis(ms);
        }

        rule = "\\d+(?=秒钟?[以之]?后)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[5] = true;
            int sec = Integer.parseInt(match.group());
            long ms = calendar.getTime().getTime() + sec * 1000;
            calendar.setTimeInMillis(ms);
        }

        rule = "半秒钟?[以之]?前";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[5] = true;
            long ms = calendar.getTime().getTime() - 500;
            calendar.setTimeInMillis(ms);
        }

        rule = "半秒钟?[以之]?后";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[5] = true;
            long ms = calendar.getTime().getTime() + 500;
            calendar.setTimeInMillis(ms);
        }

        rule = "(\\d+)((周|星期)?[以之]?后)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[2] = true;
            int week = Integer.parseInt(match.group(1));
            long ms = calendar.getTime().getTime() + week * 7 * 24 * 3600 * 1000;
            calendar.setTimeInMillis(ms);
        }

        rule = "(\\d+)((周|星期)?[以之]?前)";
        pattern = Pattern.compile(rule);
        match = pattern.matcher(Time_Expression);
        if (match.find()) {
            flag[2] = true;
            String weekText = match.group(1);
            int week = Integer.parseInt(match.group(1));
            long ms = calendar.getTime().getTime() - week * 7 * 24 * 3600 * 1000;
            calendar.setTimeInMillis(ms);
        }
        ///////////////////////////////////////

        String s = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss").format(calendar.getTime());
        String[] time_fin = s.split("-");
        if (flag[0] || flag[1] || flag[2] || flag[3] || flag[4] || flag[5]) {
            _tp.tunit[0] = Integer.parseInt(time_fin[0]);
        }
        if (flag[1] || flag[2] || flag[3] || flag[4] || flag[5]) {
            _tp.tunit[1] = Integer.parseInt(time_fin[1]);
        }
        if (flag[2] || flag[3] || flag[4] || flag[5]) {
            _tp.tunit[2] = Integer.parseInt(time_fin[2]);
        }
        if (flag[3] || flag[4] || flag[5]) {
            _tp.tunit[3] = Integer.parseInt(time_fin[3]);
        }
        if (flag[4] || flag[5]) {
            _tp.tunit[4] = Integer.parseInt(time_fin[4]);
        }
        if (flag[5]) {
            _tp.tunit[5] = Integer.parseInt(time_fin[5]);
        }
    }
121474
function(_style){
            var _list  = _style.split(':'),
                _prop  = _list[0],
                _value = _list[1],
                _node  = this.__node;
            // 需要解析=号
            if(_value.indexOf('=') > -1){
                var _a = parseInt(_e._$getStyle(_node,_prop))||0;
                var _b = parseInt(_value.split('=')[1]);
                if(_value.indexOf('+') > -1)
                    _value = _a + _b;
                else
                    _value = _a - _b;
            }
            // 需要加单位
            if(_h.__doCheckProp(_prop)){
                if(_value.toString().indexOf('px') < 0)
                    _value += 'px';
            }
            this.__propMap[_prop] = _value;
        }
617645
function mergeProperties(ci) {
    var propertiesClass = [].concat(ci.propertiesClass || ci.properties || []);
    if (ci.hasOwnProperty('accessors')) {
        for (var prop in ci.accessors) {
            if (ci.inputsClass && ci.inputsClass.find(i => i.name == prop)) {
                // 同时出现在inputsClass里的，需要剔除
                continue;
            }
            var info = ci.accessors[prop];
            var desc = info.getSignature && info.getSignature.description ? info.getSignature.description : '';
            desc += info.setSignature && info.setSignature.description ? info.setSignature.description : '';
            var type = info.getSignature ? (info.getSignature.returnType || info.getSignature.type) :
                info.setSignature ? info.setSignature.args[0].type : '';
            propertiesClass.push({
                name: info.name, description: desc, type: type,
                readOnly: !info.hasOwnProperty('setSignature')
            });
        }
    }
    propertiesClass.forEach(p => {
        if (p.readOnly || !p.modifierKind) return;
        p.readOnly = p.modifierKind.includes(READ_ONLY);
    });
    return propertiesClass;
}