aview-app 1.0.2

package/aardio/lib/preload/io.aardio

@@ -0,0 +1,107 @@
+//io 文件相关
+namespace preload;
+self.io = global.io;
+
+namespace io;
+
+::Shell32 = ..raw.loadDll("Shell32.dll")
+
+getSpecial = function(id,...){
+	var r = {WORD v[0x208/*_MAX_PATH_U16*/]}
+	if ( 0 <= ::Shell32.SHGetFolderPath(null,id,null,0,r) ){
+    	return joinpath(r.v,...);
+	} 
+}
+
+getSize = function(path){
+	var f = open(path,"rb");
+	if( f ){ 
+		var r = f.size();
+		f.close();
+		return r;
+	}
+}
+
+appData = function(p,d){
+	if(!d) return getSpecial(0x1c /*_CSIDL_LOCAL_APPDATA*/,p);
+	return specialData(p,d,0x1c/*_CSIDL_LOCAL_APPDATA*/);
+}
+
+specialData = function(p,d,id){
+	p  = getSpecial(id,p);
+	if(d!==null) return updateData(d,p);
+	return p;
+}
+
+updateData = function(d,p,...){
+	if(...) p = joinpath(p,...);
+	if(d!==null){
+		var e;
+		var f = open(p,"rb");
+		if(f){
+			e = f.size()==#d;
+			if(e && (d[1]+d[2]==0xA7) ){ 
+				var a = ..raw.convert(d,{INT v},60).v + 8;
+				f.seek("set",a);
+				e = f.read({INT v})[["v"]]===..raw.convert(d,{INT v},a).v; 
+			}
+			
+			f.close();
+		}
+
+		if(!e && ! ..string.save(p,d) ) return exist(p);
+	}
+	
+	return p;
+}
+
+var tmpdir =  ..string.expand("%TMP%") : appData("Temp") ;
+..string.setenv("TMP",tmpdir);
+
+tmpname = function(p,e){
+	d = joinpath(tmpdir,"\");
+	
+	var t = ..string.format("%s$%X$%X$",p:"",..thread.getId(),..time.tick());
+	if(!e) e = "";
+	
+	var r;
+	var i = 0;
+	do{
+		r= ..io.joinpath(d, t ++ i ++ e)
+		i++;
+	}while(exist(r))
+	
+	return r;
+}
+
+curDir = lambda(dir) !dir ? ..io.fullpath("./") :  ::Kernel32.SetCurrentDirectoryB( fullpath(dir) );
+
+if(_WIN10_LATER) {
+	if( _WIN_VER_MAJOR > 10 ||  _WIN_VER_MINOR > 0 || _WIN_VER_BUILD >= 16299 ){
+		self.utf8 = true; //if(::Kernel32.GetACP()==65001) io.utf8 = true;
+	} 
+}
+
+/**intellisense(io)
+getSpecial(_CSIDL__) = 获取特殊文件夹,\n参数@1使用 _CSIDL 开头的常量指定特殊文件夹的 CSIDL,\n不指定参数@1则默认值为 _CSIDL_DESKTOP,\n可选增加任意个拼接到目录后的子路径参数\n这个函数与fsys.getSpecial函数用法接近,\n但支持不定个数子路径参数, 不支持返回PIDL\n\nfsys.knownFolder 可用于获取更多已知的特殊文件夹
+appData( = 获取  %LocalAppData% 目录下的绝对路径。\n可选使用指定需要存入的数据
+appData(.(path,data) = 将@path指定的相对路径转换为系统 %LocalAppData% 目录下的绝对路径,\n可选使用 @data 指定需要存入的数据,\n存入文件与目标文件长度不同或 PE 时间戳不同则允许替换旧文件,\n指定 @data 参数后如果无法创建文件返回null,\n最后返回转换所得的完整路径
+specialData(.(path,data,csidl) = 将 @path 指定的相对路径转换为特殊文件夹下的绝对路径,\n可选使用 @data 指定需要存入的数据,\n存入文件与目标文件长度不同或 PE 时间戳不同则允许替换旧文件,\n指定 @data 参数后如果无法创建文件返回null,\n参数@csidl 使用 _CSIDL 开头的常量指定特殊文件夹的 CSIDL,\n不指定@csidl 则默认值为 _CSIDL_DESKTOP,\n最后返回转换所得的完整路径
+updateData( = 更新指定文件的数据
+updateData(.(data,path,->->->) = 更新指定 @path 指定路径的文件为 @data 指定的数据。\n如果添加更多参数，则首先调用 io.joinpath 拼接到 @path 后面。\n存入文件与目标文件长度不同或 PE 时间戳不同则允许替换旧文件。\n替换失败返回 null，否则返回文件路径
+getSize(__) = 获取参数@1指定路径的文件字节长度,\n返回数值
+curDir( = 获取或修改当前目录
+curDir(.() = 无参数获取当前目录
+curDir(.(dir) = 将 @dir 参数指定的目录路径转换为完整路径并设为当前目录\n成功返回 true
+tmpname( = 生成系统临时文件目录下的临时文件路径
+tmpname(.(prefix,ext) = 生成临时文件路径，\n可选用 @prefix 参数指定前缀名，\n可选用 @ext 参数指定后缀名，后缀名应包含点
+end intellisense**/
+
+/**intellisense(::)
+::Shell32 = 默认已加载的Shell32.dll模块对象（参考标准库：peload.io），\n提供Windows系统外壳 API
+::Shell32.api("__/*输入函数名字*/","void()" ) = 声明Kernel32 API函数
+::Shell32.SHChangeNotify(_SHCNE__,0,0,0) = 通知操作系统外壳刷新,例如刷新桌面图标等\n参数依次为@eventId,@flags,@item1,@item2
+::Shell32.ShellExecute(.(hwnd,operation,path,param,workDir,cmdShow) = 执行 path 指定的程序,\n第一个参数为数值格式的句柄,\n最后一个参数为数值,指定为1即可,其他参数都是字符串,\n详细用法请参考该 API 文档,\n注意省略的参数也要指定 null 值,\n非声明式调用 API 不能减少参数个数,\nraw.execute 函数提供类似功能，但所有参数都可以省略。\nprocess.execute 函数也提供类似功能
+::Shell32.Control_RunDLL(.(hwnd,hinst,cmdLine,cmdShow) = 可用于启动控制面板命令,\nhwnd可指定为0,hinst 可指定为 _HINSTANSE,\ncmdLine 指定启动参数,cmdShow 指定为1即可,\n也可以通过process.rundll 运行此函数,\n或通过 process.control 直接执行控制面板命令
+::Shell32.? = 可不用声明直接在此输入函数名并调用API函数\n\n一、传入参数规则：\n1、null参数不可省略\n2、32位整数类型，小于32位的整数、以及枚举类型都可以直接在API参数中写数值。\n3、对于任何数值类型的指针（输出参数）一律使用结构体表示，例如double * v 表示为{ double v }\n4、数组使用结构体表示\n5、所有结构体传给API的都是指针地址，都是输出参数并增加返回值\n\n二、返回值规则：\n1、返回值默认为int类型\n2、可以使用[API尾标]改变返回值为其他类型\n\n三、所有可用的【API尾标】:\n::Shell32.ApiNameW() 切换到Unicode版本，字符串UTF8-UTF16双向转换\n::Shell32.ApiNameA() 切换到ANSI版本,字符串不作任何转换\n::Shell32.ApiNameL() 返回值为64位LONG类型\n::Shell32.ApiNameP() 返回值为指针类型\n::Shell32.ApiNameD() 返回值为double浮点数\n::Shell32.ApiNameF() 返回值为float浮点数\n::Shell32.ApiNameB() 返回值为C++中的8位bool类型\n注意【尾标】前必须是小写字母
+end intellisense**/

package/aardio/lib/preload/math.aardio

@@ -0,0 +1,91 @@
+//math 数值运算
+namespace preload;
+self.math = global.math;
+
+namespace math;
+
+_size64_meta._add = function(b){
+	return size64(owner).add(b);
+};
+
+_size64_meta._sub = function(b){
+	return size64(owner).sub(b);
+};
+
+_size64_meta._mod = function(b){
+	return size64(owner).mod(b);
+};
+
+_size64_meta._div = function(b){
+	return size64(owner).div(b);
+};
+
+_size64_meta._mul = function(b){
+	return size64(owner).mul(b);
+};
+
+_size64_meta._lshift = function(b){
+	return size64(owner).lshift(b);
+};
+
+_size64_meta._rshift = function(b){
+	return size64(owner).rshift(b);
+};
+
+_size64_meta._concat = function(b){
+	return tostring(owner) ++ tostring(b);
+};
+
+_size64_meta.swap = function(){
+	var a,b = owner.split32();
+	return size64(..raw.swap(b),..raw.swap(a));
+};
+
+_size64_meta.divf = function(b){
+	return tonumber( owner / b )  + ( tonumber(  owner % b ) / tonumber(b) )
+}
+
+isSize64  = function(v){
+	return v@ == _size64_meta;
+};
+
+isFinite = function(v){
+	return (type(v) == "number") &&  (v==v) &&  (v != 1/0) && (v !=-1/0)
+};
+
+isInteger = function(v) {
+    if(isFinite(v)){
+    	 var i,f = modf(v);
+    	 return !f;
+    }
+};
+
+stringify = function(v,p){  
+    var i,f = modf(v);
+    return (!f) ? ..string.format("%.0f",v) : ..string.trimright(..string.format("%."+(p:15)+"f",v),"0"); 
+};
+
+roundToEven = function (v,p){ 
+    p = p : 0;
+    var d = v * ( 10 ** p );
+    var i,n = floor(d),floor(d*10); 
+    	
+    if(n%5==0 && i%2 == 0 
+    	&& floor(n*10)== floor(d*100)
+    ) return i/( 10 ** p ); 
+    else return round(v,p);
+}; 
+
+mulDiv = ::Kernel32.api( "MulDiv", "int(int a,int b,int c)"); 
+
+/**intellisense(math)
+mulDiv(.(a,b,c) = 返回a乘b再除以c的结果,并自动四舍五入转为整数\n可尽量使运算不会溢出,运算错误则返回-1\n\n注意这个函数是系统 API 函数，\n参数只能传入数值不能传入字符串
+round( = 四舍五入，舍入规则以取整为例：\n小数小于0.5取相邻的绝对值更小的整数，\n小数大于0.5取相邻的绝对值更大的整数，\n小数等于0.5取相邻的正无穷大方向的整数。\n\n注意四舍五入非常多的规则，\n各种语言的默认实现并不完全一致，\n计算机浮点数都存在可容忍的精度误差，\n如果无法接受并一定要追求完美，这边建议试试重新发明计算机
+round(.(数值,精度) = 四舍五入取接近的数，\n精度指定小数后的位数,默认为0（取整）
+roundToEven( = aardio 改良版银行家舍入法，\n舍入规则为：尾数四舍六入，五后为零前凑偶（只看一位零）。\n\n解决问题1:1到9出现机率一样，5到9进位导致进多舍少。\n解决问题2:浮点数误差导致的不合理舍入。\n\n注意四舍五入非常多的规则，\n各种语言的默认实现并不完全一致，\n计算机浮点数都存在可容忍的精度误差，\n如果无法接受并一定要追求完美，这边建议试试重新发明计算机
+roundToEven(.(数值,精度) = 使用改良版银行家舍入法转换并返回参数@1指定的数值，\n参数@2指定返回数值的小数位数,默认为0（也就是取整）
+isSize64(__) = 判断参数是否 math.size64 长整数对象
+isFinite(__) = 如果参数是一个有效数值,\n并且不是正负无穷大则返回 true，否则返回 false。\n如果传入字符串会直接返回 false
+isInteger(__) = 参数是一个数值并且是整数返回true，否则返回false。\n如果传入字符串会直接返回 false
+stringify(.(数值,最大精度) = 数值转换为10进制字符串,最大精度默认为15,\n不使用科学计数法，小数尾部不会有0
+end intellisense**/

package/aardio/lib/preload/raw.aardio

@@ -0,0 +1,105 @@
+//raw 原生静态类型
+namespace preload;
+self.raw = global.raw;
+
+namespace raw{
+	convertArray = function(p,l,t="pointer"){
+		if(!p) return; 
+		
+		var a; 
+		if(type(t)=="class") t = t();
+		
+		if( !t[["_struct"]] ) a = toarray(l,t,"v" );
+		else{
+	    	a = toarray(l,"struct","v");a.v = {t};
+		} 
+		
+		return convert(p,a).v;
+	};
+	
+	mixin = function(p,s,v,...){
+ 		if(v){
+    		convert(p, s);
+    		..table.assign(s,v,...)
+    	}
+    	convert(s,p);
+    	return s;
+	};
+	
+	dup = function(h,src,dst,inherit){
+		var t = {ptr v}
+		if( ::Kernel32.DuplicateHandle(src:-1,h,dst :-1,t,0,inherit,2) ) return t.v;
+	};
+	
+	serializeDupHandle = function(cls,handle){ 
+		return ..string.format("global.import('%s') : %s( ..raw.dup(topointer(0x%p)),true)",cls,cls,topointer(handle) );
+	};
+
+	__module__ = {};
+	module = function(cal){
+		if(!cal)cal="stdcall";
+		if( __module__[cal] ) return __module__[cal];
+		__module__[cal] = loadDll(,,cal); 
+		return __module__[cal];
+	};
+	
+	main = module("stdcall");
+	
+	class number {
+		ctor(t,v){
+			this = v;
+			this.type = t;
+		};
+		@_meta;
+	};
+	
+	number._meta = {
+		_tonumber=lambda() owner.value;
+		_number_type=lambda() owner.type;
+		_tostring=lambda() tostring(owner.value);
+		_json=function() { return tostring(owner.value),true}; 
+		_eq = lambda(v) owner.value = v.value;
+		_type="raw.number";
+	}; 
+	
+	double = lambda(v,ref) number("double",ref?{double value=v}:{value = v});
+	float = lambda(v,ref) number("float",ref?{float value=v}:{value = v});
+	byte = lambda(v,ref) number("byte",ref?{byte value=v}:{value = v});
+	ubyte = lambda(v,ref) number("BYTE",ref?{BYTE value=v}:{value = v});
+	word = lambda(v,ref) number("word",ref?{word value=v}:{value = v});
+	uword = lambda(v,ref) number("WORD",ref?{WORD value=v}:{value = v});
+	int = lambda(v,ref) number("int",ref?{int value=v}:{value = v});
+	uint = lambda(v,ref) number("INT",ref?{INT value=v}:{value = v});
+	long = lambda(v,ref) number("long",ref?{long value=v}:{value = v});
+	ulong = lambda(v,ref) number("LONG",ref?{LONG value=v}:{value = v}); 
+	
+	malloc = buffer;//@Deprecated
+}
+
+raw.execute = function(file,param,op,show,dir,hwnd){  
+	return 32 < ::Shell32.ShellExecute(hwnd || ::User32.GetActiveWindow(),op,file:"",param,dir,show===null?5/*_SW_SHOW*/:show); 
+}
+
+/**intellisense(raw)
+mixin(.(指针,结构体对象,任意个混入对象) = 混入新的值,支持任意个混入table对象,\n自动更新指针指向内存,并返回结构体对象
+convertArray(.(源内存指针,源数组长度,"数据类型") = 将指针指向的内存转换为普通数组,传入空指针返回空值\n数据类型参数可省略,默认为"pointer"\n类型类型也可以直接传入一个声明元素类型的结构体参数\n注意该函数不会检测内存溢出错误,调用该函数时必须保证数组长度是正确的值
+dup(.(源句柄,源进程,目标进程,允许子进程继承) = 返回复制的系统句柄\n除参数1之外,其他参数可选\n默认仅在当前进程中复制句柄\n复制的句柄应使用raw.closehandle释放
+serializeDupHandle(.("类名",句柄) = 复制进程内有效句柄并序列化对象\n只能用于_serialize元方法，且必须kernelCall参数为真\n序列化类构造函数必须支持指针参数1为指针类型句柄,参数2为true的参数\n并负责在析构函数中调用 raw.closehandle 释放该句柄
+module() = !dllModule.
+module(.("调用约定") = 指定约定并返回进程主模块, \n省略参数时调用约定默认为stdcall,\n可用于将当前进程中的函数指针转换为aardio函数,
+main = 进程主模块,默认调用约定为stdcall\n与raw.module("stdcall")返回的值相同,\n可用于将当前进程中的函数指针转换为aardio函数\n!dllModule.
+
+double(__) = 转换参数@1指定的数值为 double 类型数值（64位浮点数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式静态 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.double 函数
+float(__) = 转换参数@1指定的数值为 float 类型数值（32位浮点数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式静态 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.float 函数
+byte(__) = 转换参数@1指定的数值为 byte 类型数值（8位整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式静态 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.byte 函数
+ubyte(__) = 转换参数@1指定的数值为 BYTE 类型数值（8位无符号整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式静态 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.ubyte 函数,\n注意在静态类型中使用大写的 BYTE 类型表示8位无符号整数
+word(__) = 转换参数@1指定的数值为 byte 类型数值（16位整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式静态 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.word 函数
+uword(__) = 转换参数@1指定的数值为 BYTE 类型数值（16位无符号整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式静态 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.uword 函数,\n注意在静态类型中使用大写的 WORD 类型表示16位无符号整数
+int(__) = 转换参数@1指定的数值为 byte 类型数值（32位整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式静态 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.int 函数
+uint(__) = 转换参数@1指定的数值为 BYTE 类型数值（32位无符号整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式静态 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.uint 函数,\n注意在静态类型中使用大写的 INT 类型表示32位无符号整数
+long(__) = 转换参数@1指定的数值为 byte 类型数值（64位整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式静态 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.long 函数
+ulong(__) = 参数@1可传入数值或math.size64 对象,\n返回适用于 LONG 类型数值（64位无符号整数）的包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式静态 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.ulong 函数,\n注意在静态类型中使用大写的 LONG 类型表示64位无符号整数
+
+execute( = 运行外部程序，成功返回 true。\n process.execute 函数提供类似的功能，区别可参考函数源码
+execute(.(file,param,operation,showCmd,workDir,hwnd) = 运行外部程序，成功返回 true。\n@file 指定要运行的程序路径，其他所有参数可省略，\n@param 字符串参数，可选指定启动参数。\n@operation 可选用一个字符串指定执行动词，省略则使用默认动词或 "open"。\n@showCmd 可选用 _SW_ 前缀常量指定显示选项，默认为 _SW_SHOW。\n@workDir 参数可选指定工作目录。\n@hwnd 可选指定所有窗口句柄，默认取当前线程活动窗口
+end intellisense**/

package/aardio/lib/preload/string.aardio

@@ -0,0 +1,224 @@
+//string 字符串
+namespace preload;
+self.string = global.string;
+
+namespace string{
+	gfind = function(str,p,f){ 
+		if(!f) f = 0;
+		var r = function(b,e,...){
+			if( b ) f = ( e > b ) ? e : b  ;
+			return b,e,...;
+		};
+		return function(){
+			return r( find(str,p,f+1) ); 
+		} 
+	}; 
+	splitEx = function(s,p,l,f){
+		if(!#s) return {};
+		
+        var a = {{1;1}}
+        var push = ..table.push;
+        for i,j in gfind( s,p:"<\r*\n>|\r",f) if( push(a,{i-1;j+1}) && l && l <= #a ) break ; 
+        
+        for(i=1;#a) a[i] = sub(s,a[i][2],a[[i+1]][[1]]);
+        return a; 
+    };
+    matches = function(s,...){
+    	return ..table.array(gmatch(s,...) );
+    };
+	lines = function(s,line,delims,limit){
+		var t,i = splitEx(s,line),0;
+		if(!delims) {
+			return function(){
+				i = i + 1; return t[i];
+			}
+		}
+		
+		return function(){
+			i = i + 1; if(t[i]) return splitEx(t[i],delims,limit);
+		}
+	};
+	each = function(s,p,line){
+		if(!p) error("请指定参数@2",2)
+		var t,i = splitEx(s,line),0;
+		return function(){
+			var m;
+			while(!#m){
+				i = i + 1;
+				if(!t[i]) return;
+				m = { match(t[i],p) }; 
+			}
+			return ..table.unpack(m);
+		}
+	};
+	crlf = function(s,c){
+		if(s!==null) return ( replace(tostring(s),"<\r\n>|\n|\r",c ?(c===true?'\n':c):'\r\n') );
+	};
+	cmpMatch = function(a,b){
+		return  ( type(a)==type(b) && ( ( cmp( a,b) == 0 ) ||  ( match( a  ,b ) ) ) )  
+	};
+	concatUnicode = function(...){
+		var args = {...};
+		for i,v in ..table.eachArgs(args){
+			args[i] = toUnicode(v);
+		}   
+		return sliceUnicode( (join(args))); 
+	}
+	isUtf8 = function(s){
+		if( !#s ) return;
+		var u = getUtf(s);
+		if( u & 8 ) return true;
+		if( u & 1 ) return;
+		if( u & 16 ) return;
+		var m = match(s,'[\x80-\xFF]+') //'€'# 
+		if( !#m ) return;
+		if( !len(s) ) return false;
+		if( #m > 50 ) return true;
+		if( fromUnicode(toUnicode(m,65001) ,65001) != m ) return false;
+		return true;
+	}
+	self.loadcode = function(c,...){
+		var f,e = loadcode(c,"=(string.loadcode)");
+		if(!f) return null,e;
+		
+		var p = ..print;
+		var t = {};
+		..print = function(s,...){
+			if(s!==null) ..table.push(t,tostring(s));
+			if(...===null) return;
+			return ..print(...);
+		}
+		
+		var r,e = callex(,f,...,...);
+		..print = p;
+		
+		if(!r) return null,e;
+		return join(t);
+	};
+	self.reduce = function(s,p,...){
+		if( type(p) !="table" ) p = {p;...};
+		return reduce(p, lambda(s,p)  s ? match(s,p),s);
+	};
+	search = function(f,s,p,...){
+		var r;
+		if( type(f) === "table" ){
+			r = f;
+			f = function(m,...) ..table.push(r,... ? {m;...} : m);
+		}
+		
+		if( type( p ) === "function" ){
+			if(!s) return r;
+			
+			var m = p(s);
+			if(!m) return r;
+			elseif( type(m) == "string") s = m;
+			
+			if(...) search(f,s,...);
+			else f(s);
+			return r;
+		}
+		
+    	if(!...) replace(s,p,f);
+    	else {
+    		if(p[1]=='^'#) {
+    			m = match(s,p);
+    			if(m) search(f,m,...);
+    			return r; 
+    		}
+    		for m in gmatch(s,p) search(f,m,...);
+    	}
+    	
+    	return r;
+	};
+	map = function(s,p,f){
+		var r,m = {}
+		if( type(p) == "string" ) p = {p};
+		elseif(!p ) {
+			p = {"[-\d]+"};
+			if(!f) f = tonumber;
+		}
+		if(!f) f = lambda(s,...) ... ? {s;...} : s;
+		
+		if(#p){
+			search(function(...){
+				m = f(...);
+				if( m!==null ) ..table.push(r,m);
+			},s,..table.unpack(p) );	
+		}
+		else { 
+			for(k,v in p) r[k] = map(s,v,f)[1];
+		}
+		
+		return r;
+	};
+	repline = function(s,p,r,c){
+		return ( replace(s,"\N+",lambda(line) replace(line,p,r,c) ) ); 
+	};
+	removeBom = function(s){
+		if(!s) return s;
+		var c1 = s[1];
+		
+		if(c1 == 0xEF && s[2] == 0xBB && s[3] == 0xBF) return right(s,-4);
+		elseif(c1 == 0xFF && s[2] == 0xFE) return fromto(right(s,-3),1200,65001);  
+		elseif(c1 == 0xFE && s[2] == 0xFF) return fromto(right(s,-3),1201,65001);  
+		return s;
+	};
+	
+	setenv = ::Kernel32.api( "SetEnvironmentVariable", "INT(ustring name,ustring v)"); 
+
+	var getEnvironmentVariable = ::Kernel32.api( "GetEnvironmentVariable", "INT(str name,str &v,INT size)");
+	getenv = function(name){
+		var len,val =  getEnvironmentVariable(name,256,256);
+		if(len > 256) len,val =  getEnvironmentVariable(name, len,len); 
+		if(len) return val;
+	} 
+	
+	expand = function(s,p,r){
+		var c;
+		if(!p){p,r="\%([^%]+)\%",getenv}
+		do{ s,c = replace(s,p,lambda(v)r(v):"") }while(c);
+		if(#s) return s;
+    }
+    
+	subUnicode = sliceUnicode;//@Deprecated
+	sub = slice;//@Deprecated
+}  
+
+type.isString = function(v){
+	var t = type(v);
+	return t == "string" || t == "buffer";
+}
+
+/**intellisense(string)
+splitEx( = 使用模式匹配语法指定分隔符,用于拆分字符串,\n返回拆分后的字符串数组,\n传入null值或空字符串返回空数组
+splitEx(.(字符串,分隔符模式串,最大拆分次数,开始位置) = 使用模式匹配语法指定分隔符,拆分字符串并返回数组,\n参数@1传入null值或空字符串返回空数组,\n用零宽匹配指定分隔符可在拆分的字符串中包含分隔符,\n省略分隔符模式则按行拆分,支持回车、换行、回车换行等不同换行规则,空行不合并,\n拆分次数可省略,默认不限次数,\n开始位置可省略,默认从开始拆分
+gfind(字符串,模式串,开始位置) = @for i,j,group1  in string.gfind( __/*查找字符串*/,"(.)") { 
+	
+}
+each( = 创建适用于 for in 语句的迭代器,\n用于分行匹配字符串,\n可将返回迭代器传入 table.array 生成数组
+each(.(字符串,模式串,行分隔符) = 必须使用参数@2指定模式串,\n查找模式串中可用圆括号创建捕获分组自定义迭代器返回值个数,\n行分隔符支持模式匹配语法,可省略
+lines( = 创建用于for in语句的迭代器按行拆分字符串\n也可将返回迭代器传入 table.array 生成数组,\n按行读取文件请使用 io.lines 函数,\nnull值或空字符串忽略不执行
+lines(.(字符串,行分隔符,列分隔符,最大列数)  = 按行拆分参数@1传入的字符串,\n可选使用参数@2指定行分隔符,支持模式匹配语法,\n如果不指定列分隔符,每次循环返回字符串,\n如果指定列分隔符,使用模式匹配二次拆分,每次循环返回数组,\n可选用参数@4指定最大列数,\n列分隔符支持模式匹配语法
+cmpMatch( __,"" ) = 忽略大小写比较两个字符串\n如果失败则使用模式语法匹配是否相同.\n如果其中一个参数不是字符串则返回false
+concatUnicode(.(str,->->->) = 将所有参数转换为Unicode字符串并连接后返回\n参数可以是数值,字符串,Unicode字符串,\n忽略null值参数
+isUtf8(__) = 快速检测字符串是否包含UTF8编码\n空字符串返回null
+loadcode(  = 加载并执行 aardio 代码或文件,返回 HTML 模板输出的 HTML 代码\n如果当前应用未定义 response 对象,请使用 print 函数替代。\n此函数也可以用于非 HTML 格式的任意字符串模板，\n但非 HTML 格式的字符串开始部分必须是 aardio 模板标记
+loadcode(.("代码文件",->->->) = 加载并执行 aardio 代码或文件,\n返回 HTML 模板输出的 HTML 代码,失败返回空值,错误信息。\n参数@1,与 loadcode 函数相同,其他参数作为模板参数传给被调用的文件,\n在被调用文件的函数外部可使用 owner 参数获取首个模板参数,\n也可以使用...获取多个模板参数
+crlf(.(字符串,回车换行) = 自动调用 tostring 函数转换传入参数为字符串,\n此函数格式化文本中的回车换行组合、或单独的回车、换行,\n例如 string.crlf(str,'\r') 格式化所有格式的回车换行为回车符。\n省略参数 @2 默认为回车换行组合。\n\n注意字符串字面值解析换行的规则:\n双引号或反引号内字符串只有换行没有回车,\n单引号内字符串解析时忽略所有回车换号,\n使用/*多行注释*/包含字符串,则总是解析为回车换行组合
+matches(.("字符串","模式表达式") = 全局匹配并将匹配结果返回为数组\n每次匹配成功的多个返回值存为成员数组\n即使没有匹配到任何结果,也会返回一个空数组
+search(.(回调函数,字符串,模式表达式,->->->) = 模式匹配搜索.\n\n可以指定1个或多个模式表达式,\n此函数使用前面表达式的结果作为后面表达式的查询字符串,\n每一个模式表达式都支持全局搜索并可以返回多个匹配结果,\n最后一个表达式的匹配结果作为参数回调参数@1指定的函数.\n\n每一个模式表达式参数都可以使用函数或 lambda表达式替代,\n用于作为筛选器筛选上次的匹配结果,筛选器可以返回新的字符串,\n返回非字符串类型则用于指定是否保留上次的匹配结果,\n\n如果参数@1是一个数组,则将匹配结果添加到该数组,如果有多个捕获分组则返回二维数组,\n如果参数@1是数组则返回该数组,否则函数无返回值
+reduce( = 使用string.match依次匹配多个模式表达式,逐步缩减并返回最终匹配结果
+reduce(.(字符串,模式,->->->) = 参数@1指定要查找的字符串,\n参数@2开始指定一个或多个模式表达式,\n使用前面一个的匹配结果作为后面一次匹配的条件,\n逐步缩减并返回最终匹配结果,\n也可以在参数@2中使用一个数组指定多个模式表达式
+map( =  搜索并返回搜索结果数组,\n并调用映射函数转换数组中的每个匹配结果为新的值,\n\n注意如果模式串中使用括号指定了多个分组,\n映射函数会有多个对应的回调参数
+map(.(字符串,模式,映射函数) = 参数@1指定要查找的字符串,\n参数@2可以指定模式表达式,或包含多个表达式的数组,\n省略则默认为"[-\d]+",并且参数@3的默认值会被更换为tonumber\n可选用参数@3指定映射函数,\n\n返回值为匹配的字符串数组,如果有多个捕获分组则返回二维数组\n如果参数@2不是数组而是表,则返回相同结构的表,\n每个键对应的值更新为参数表中同名键指定的模式表达式的匹配结果。
+repline( = 按行替换字符串,返回替换后的字符串,\n此函数仅返回替换后的新字符串,只有一个返回值
+repline(.(源字符串,模式串,替换串,替换次数) = 模式串用于匹配所有的单行文本,\n替换串与 string.replace 用法相同\n替换次数指的也是每一行内部进行替换的最大次数,不指定则不限制
+repline(.(源字符串,模式串,替换函数,替换次数) = 模式串用于匹配所有的单行文本,\n替换函数与 string.replace 用法相同\n,\n替换次数指的也是每一行内部进行替换的最大次数,不指定则不限制
+repline(.(源字符串,模式串,替换表,替换次数) = 模式串用于匹配所有的单行文本,\n替换表与 string.replace 用法相同\n,\n替换次数指的也是每一行内部进行替换的最大次数,不指定则不限制
+removeBom(.(字符串) = 如果字符串开始为UTF8 BOM，则返回移除该 BOM 的字符串。\n如果字符串开始为 UTF-16 BOM,则移除 BOM 并返回转换为 UTF-8 编码的字符串,\n否则直接返回参数
+getenv(.("变量名") = 读取当前进程环境变量\n成功返回字符串,失败返回 null
+setenv(.("变量名","变量值") = 设置当前进程环境变量\n参数@2为 null 或省略则删除参数@1指定的环境变量
+expand( = 重复替换直到找不到匹配,\n可用于展开字符串中的环境变量
+expand(.(字符串,查找模式串,替换函数) = 在字符串中重复执行替换操作,\n直到参数@2指定的模式串找不到匹配,\n省略参数@2,@3则默认展开百分号包含的进程环境变量\n可用于展开文件路径中的环境变量\n注意即使替换函数返回null,此函数仍然会替换为空串,\n如果替换结果为空字符串,此函数返回 null
+fromCharCode(__) = 使用1个或多个 Unicode 编码值转换为 UTF-8 字符串\n参数可以指定1个或多个Unicode编码数值,可指定大于0x10000的编码,\n不可直接传入数组作为参数
+end intellisense**/