var Nil=null,
    Undefined=undefined,_=Undefined;

var True=true,
    False=false;

var SERVER=(typeof window)=="undefined",
    ERRCATCH=False;
function errorCatch(CATCH) {
  ERRCATCH=CATCH;
}
function errstop(errno) {
  if (ERRCATCH) throw "";
           else if (SERVER) process.exit(errno); else nofunc();
}
var ERRLI=-1,ERRCOL=-1,ERRFNAME=Nil;
function errlicolSet(LI,COL,FNAME) {
  ERRLI=LI>0?LI:-1;
  ERRCOL=COL>0?COL:-1;
  if (isDefined(FNAME)) ERRFNAME=FNAME;
}
function error(msg) {
  if (ERRFNAME!=Nil) msg+=" in "+ERRFNAME;
  if (ERRLI>0 || ERRCOL>0) msg+=" at (";
  if (ERRLI>0) msg+=ERRLI.toString();
  if (ERRCOL>0) {
    if (ERRLI>0) msg+=",";
    msg+=ERRCOL.toString();
  }
  if (ERRLI>0 || ERRCOL>0) msg+=")";
  (SERVER?console.log:alert)(msg);
  errstop(1);
}

function prototype(X) {
  var RES=Object.getPrototypeOf(X);
  if (RES==Nil) return Object.prototype;
  return RES;
}
function constructor(X) {
  return prototype(X).constructor;
}
function isa0(O,C,REC) {
  if (isNil(O)) return False;
  if (constructor(O)==C) return True;
  if (isUndefined(REC)) REC=True;
  if (!REC || constructor(O)==Object) return False;
  return isa0(prototype(O),C,REC);
}

function eqNil(O) { return O===Nil; }
function isDefined(O) { return O!==Undefined; }
function isUndefined(O) { return O===Undefined; }
function isNil(O) { return isUndefined(O) || O==BoxedUndefined
                         || eqNil(O) || O==BoxedNil; }
function isSymbol(O) { return isa0(O,Symbol); }
function isBoolean(O) { return isa0(O,Boolean); }
function isNumber(O) { return isa0(O,Number); }
function isString(O) { return isa0(O,String); }
function isNumStr(O) { return isNumber(O) || strIsNum(O); }
function isDate(O) { return isa0(O,Date); }
function isAtom(O) { return isNil(O)
                          || isSymbol(O) || isBoolean(O)
                          || isNumber(O) || isString(O) || isDate(O); }
function isRootAtom(O) { return typeOf(O).root()==typeOf(O) && isAtom(O); }
function isArray(O) { return isa0(O,Array); }
function isFunction(O) { return isa0(O,Function); }

var _SY={};
function sy(S) {
  if (isString(S)) { _SY[S]=1;return Symbol.for(S); }
  else
  if (isSymbol(S)) return Symbol.keyFor(S);
              else error("sy");
}
function syExists(S) {
  return isDefined(_SY[S]);
}

var CharNatNone=0,CharNatUnknown=CharNatNone,
    CharNatAlf=1,CharNatQuote=2,CharNatDQuote=3,
    CharNatOmg=4,CharNatDigit=5,CharNatBlank=6
var CharNat=[];

function asc(c) {
  return c.codePointAt(0);
}
function chr(i) {
  return String.fromCharCode(i);
}
function charnat(c) {
  return CharNat[asc(c)];
}
function charnatSet(c,n) {
  return CharNat[asc(c)]=n;
}
function charIsLetter(C) {
  return asc(C)>=asc("A") && asc(C)<=asc("Z")
      || asc(C)>=asc("a") && asc(C)<=asc("z");
}
function charIsDigit10(C) {
  return asc(C)>=asc("0") && asc(C)<=asc("9");
}
function charIsXDigit(C) {
  return charIsDigit10(C) || (asc(C)>=asc('A') && asc(C)<=asc('F')) || (asc(C)>=asc('a') && asc(C)<=asc('f'));
}
function charIsDigitInRadix(C,RADIX) {
  if (RADIX<2 || RADIX>16) error("charIsDigitInRadix");
  if (RADIX<=10) return charIsDigit10(C) && asc(C)<=asc('0')+RADIX-1;
  return charIsDigit10(C) || (charIsXDigit(C) && ((asc(C)>=asc('A') && asc(C)<=asc('A')+RADIX-11)
                                               || (asc(C)>=asc('a') && asc(C)<=asc('a')+RADIX-11)));
}
function charIsAlpha(C) {
  return charnat(C)==CharNatAlf;
}
function charIsOmg(C) {
  return charnat(C)==CharNatOmg;
}
function charIsDigit(C) {
  return charnat(C)==CharNatDigit;
}
function charIsBlank(C) {
  return charnat(C)==CharNatBlank;
}
function charIsUnknown(C) {
  return charnat(C)==CharNatUnknown;
}
function charIs(C,N) {
  return charnat(C)==N;
}
function strIs(S,N) {
  if (!isString(S) || length(S)==0) return False;
  for (var I=0;I<length(S);I++) if (!charIs(S[I],N)) return False;
  return True;
}
function strIsAlpha(S) {   return strIs(S,CharNatAlf);
}
function strIsOmg(S) {
  return strIs(S,CharNatOmg);
}
function strIsNum(S) {
  return strIs(S,CharNatDigit);
}
function strIsBlank(S) {
  return strIs(S,CharNatBlank);
}

function charsInit() {
  var i;
  for (i=0;i<256;i++) CharNat[i]=CharNatNone;
  for (i=0;i<10;i++) CharNat[i]=CharNatAlf;   for (i=32;i<=126;i++) CharNat[i]=CharNatOmg;
  for (i=asc('A');i<=asc('Z');i++) CharNat[i]=CharNatAlf;
  for (i=asc('a');i<=asc('z');i++) CharNat[i]=CharNatAlf;
  for (i=192;i<=255;i++) CharNat[i]=CharNatAlf;
  CharNat[asc('"')]=CharNatDQuote;
  CharNat[asc('\'')]=CharNatQuote;   CharNat[asc('_')]=CharNatAlf;
  CharNat[asc('$')]=CharNatAlf;
  for (i=asc('0');i<=asc('9');i++) CharNat[i]=CharNatDigit;
  CharNat[asc("\t")]=CharNatBlank;
  CharNat[asc(" ")]=CharNatBlank;
  CharNat[asc("\n")]=CharNatBlank;
  CharNat[asc("\r")]=CharNatBlank;
}

function trim(s,chars,left,right) {
  if (chars==undefined) chars=" \r\n";
  if (left==undefined) left=true;
  if (right==undefined) right=true;
  var res="",a=s.split(""),i;
  if (left) {
    i=0;
    while (i<a.length && chars.indexOf(a[i])!=-1) {
      a[i]=null;
      i++;
    }
  }
  if (right) {
    i=a.length-1;
    while (i>=0 && chars.indexOf(a[i])!=-1) {
      a[i]=null;
      i--;
    }
  }
  for (i=0;i<a.length;i++) if (a[i]!=null) res+=a[i];   return res;
}
function startsWith(s,i,pref) {
  if (isUndefined(pref)) pref=i,i=0;
  if (s.length-i<pref.length) return false;
  else {
    return substring(s,i,pref.length)==pref;
  }
}
function endsWith(s,suff) {
  if (s.length<suff.length) return false;
  else {
    return substring(s,s.length-suff.length,s.length)==suff;
  }
}
function strFind(s,ss) {
  for (var i=0;i<s.length;i++) {
    if (startsWith(substring(s,i,s.length),0,ss)) return i;
  }
  return -1;
}
function strMatch(S,PATTERN) {
  if (isArray(PATTERN)) {
    for (P of PATTERN) if (strMatch(S,P)) return True;
    return False;
  }
  var A=PATTERN.split("*");
  if (length(A)==1) return S==PATTERN;
  if (length(A)==2) {
    if (A[0]=="" && A[1]=="") return True;
    if (A[0]=="") return endsWith(S,A[1]);
    if (A[1]=="") return startsWith(S,0,A[0]);
    if (length(A[0])>length(S) || length(A[1])>length(S)) return False;
    return startsWith(S,0,A[0]) && endsWith(substring(S,length(A[0]),length(S)),A[1]);
  }
  if (length(A)==3) {
    if (A[0]=="" && A[1]=="" && A[2]=="") return True;
    if (A[0]=="" && A[1]!="" && A[2]=="") return strFind(S,A[1])!=-1;
  }
  error("strMatch");
}
function substring(S,I0,I1) {
  return S.substring(I0,I1);
}
function splitTrim(s,chars) {
  var a=s==""?[]:s.split(chars);   for (var i=0;i<a.length;i++) a[i]=trim(a[i]," \r\n",true,true);
  return a;
}
function splitOnce(S,SEP,DFLT) {
  var A=splitTrim(S,SEP),RES=[DFLT[0],DFLT[1]];
  if (length(A)==0) error("splitOnce");
  if (length(A)==1) if (isUndefined(DFLT[0])) RES[0]=S; else RES[1]=S;
  else {
    RES[0]=A[0];
    RES[1]=substring(S,length(A[0])+length(SEP),length(S));
  }
  return RES;
}
function unsplit(L,SEP) {
  var RES="",FIRST=1;
  for (var S of L) {
    RES+=(FIRST?"":SEP)+S;
    FIRST=0;
  }
  return RES;
}
function replaceAll(s,s1,s2) {
  var s0;
  do {
    s0=s;
    s=s.replace(s1,s2);
  }
  while (s!=s0);
  return s; 
}
function lcase(s) {
  return s.toLowerCase();
}
function ucase(s) {
  return s.toUpperCase();
}
function count(S,CHARS,I0,ATBEG) {
  var RES=0;
  if (isUndefined(I0)) I0=0;
  for (var i=I0;i<length(S);i++) {
    var FOUND=False;
    for (var j=0;j<length(CHARS);j++) {
      if (CHARS=="" || S[i]==CHARS[j]) { RES++;FOUND=True;break; }
    }
    if (!FOUND && ATBEG) break;
  }
  return RES;
}
function explode(S) {
  if (!isUndefined(S) && !isString(S)) error("explode");
  var RES=[];
  if (isDefined(S)) for (var I=0;I<length(S);I++) RES[I]=S[I];
  return RES;
}
function implode(A) {
  if (isString(A)) return A;
  if (!isArray(A)) error("implode");
  var RES="";
  for (var I=0;I<length(A);I++) RES+=A[I];   return RES;
}

function arrayN(N,VAL) {
  var A=[];
  while (N--) A.push(VAL);
  return A;
}
function length(o) {
  if (isString(o) || isArray(o)) return o.length;
  else
  if (isAtom(o)) return 0;
            else return Object.getOwnPropertyNames(o).length;
}
function empty(st) {
  return length(st)==0;
}
function last(st) {   if (empty(st)) return null;
  return st[st.length-1];
}
function contains(a,o,weak) {
  if (isString(a)) return strFind(a,o)!=-1;
  else
  if (isArray(a)) {
    for (var i=0;i<a.length;i++) if (weak?a[i]==o:a[i]===o) return true;
  }
  else out(display(a)),error("contains");
  return false;
}
function containsVal(a,o) {
  return contains(a,o,True);
}
function index(a,o,weak) {
  for (var i=0;i<a.length;i++) if (weak?a[i]==o:a[i]===o) return i;
  return -1;
}
function find(a,o,data) {
  for (var i=0;i<a.length;i++) {
    if (!data && o(a[i]) || data && (isNil(o)?a[i]===o:a[i]==o)) return a[i];
  }
  return Undefined;
}
function arrayToDict(a) {
  var d={};
  for (var i=0;i<a.length;i++) if (a[i]!=null) d[a[i][0]]=a[i][1];
  return d;
}
function splice(t,i,ndel,t2) {
  t.splice.apply(t,[i,ndel].concat(t2));
}
function acopy(A,I0,I1) {
  var RES=arrayN(I1-I0);
  for (var I=I0;I<I1;I++) RES[I-I0]=A[I];
  return RES;
}
function sort(A,SLOTS) {
  if (isUndefined(SLOTS) || isString(SLOTS) && length(SLOTS)==0) return A;
  if (!isString(SLOTS)) error("sort");   var SIGN=+1;
  if (SLOTS[0]=="+" || SLOTS[0]=="-") {
    SIGN=SLOTS[0]=="+"?+1:-1;
    SLOTS=substring(SLOTS,1,length(SLOTS));
    if (length(SLOTS)==0) error("sort(2)");
  }
  A.sort(function (O1,O2) {
    return O1[SLOTS]>O2[SLOTS]?SIGN:-SIGN;
  });
  return A;
}

function strEscape(s) {
  var res="";
  for (var i=0;i<s.length;i++) {
    var c=s[i];
    if (c=='"') c="\\\"";
    if (c=='\n') c="\\n";
    res+=c;
  }
  return res;
}
var displaying=[],display_mode="cooked";
function displayMode(mode) {
  display_mode=mode;
}
function display(o) {   var res=null;
  if (isUndefined(o)) res="Undefined";
  else
  if (isNil(o)) res="Nil";
  else
  if (isBoolean(o)) res=o.toString();
  else
  if (isNumber(o)) res=o.toString();
  else
  if (isString(o)) {
   res=o;
    if (display_mode=="cooked") res='"'+strEscape(o)+'"';
  }
  else
  if (isSymbol(o)) res=o.toString();
  else
  if (isFunction(o)) res="<JSFunc>";
  else
  if (contains(displaying,o)) res="^^";
  else
  if (isArray(o)) {
    displaying.push(o);
    res="[";
    for (var i=0;i<o.length;i++) {
      if (i>0) res+="|";
      res+=display(o[i]);
    }
    res+="]";
    displaying.pop();
  }
  else {
    displaying.push(o);
    res="{";
    var first=true;
    for (var val in o) {
      if (!first) { if (val!="parent") res+="|"; } else first=false;
      if (val!="parent") {
        res+=val+"="+display(o[val]);
      }
    }
    res+="}";
    displaying.pop();
  }
  return res;
}

var origin;
if (SERVER) origin=global;
       else origin=window;

charsInit();


var SymbolLicol=Symbol("licol");
function licolSet(S,LI,COL,FNAME) {
  if (isUnboxed(S)) S=new String(S);
  S[SymbolLicol]={ LI:LI, COL:COL, FNAME:FNAME }; 
  return S;
}
function licol(S) {
  var LICOL;
  if (isBoxed(S)) LICOL=S[SymbolLicol];
  if (isUndefined(LICOL)) LICOL={ LI:-1, COL:-1, FNAME:Undefined }; 
  return LICOL;
}
function errlicolSet2(LICOL) {   if (isString(LICOL)) LICOL=licol(LICOL);
  errlicolSet(LICOL.LI,LICOL.COL,LICOL.FNAME);
}

function fileExists(fname) {
  if (SERVER) return fs.existsSync(fname);
         else return httpSend("GET","http://localhost:8080/fileExists?"+fname); }
function fileIsDir(fname) {
  var fd=fs.openSync(fname,"r");
  var stats=fs.fstatSync(fd);
  return stats.isDirectory();
}
function fileStats(fname) {
  if (!fileExists(fname)) return { mtime:new Date("1/1/80") };
  var fd=fs.openSync(fname,"r");
  return fs.fstatSync(fd);
}
function fileRead(fname,encoding) {   if (SERVER) {
    if (!fileExists(fname)) error("File not found: "+fname);
    if (isUndefined(encoding)) encoding="utf8";
    var RES=fs.readFileSync(fname,"latin1");
    if (encoding=="utf8") RES=Buffer.from(RES,"latin1").toString("utf8");
    return licolSet(RES,1,1,fname);
  }
  else return httpSend("GET","http://localhost:8080/"+fname); }
function filePath(fname) {
  var a=fnameNormalize(fname).split("/"),s="";
  for (var i=0;i<length(a)-1;i++) {
    s+=a[i];
    if (i+2<length(a)) s+="/";
  }
  return s;
}
function fileName0(fname) {
  var a=fname.split("/");
  return a[length(a)-1];
}
function fileName(fname) {
  var a=fname.split(".");
  return fileName0(a[0]); }
function fileExt(fname) {
  var a=fname.split(".");
  return length(a)>1?a[length(a)-1]:Undefined;
}
function fileWrite(fname,str,encoding) {   try {
    if (isUndefined(encoding)) encoding="utf8";
    fs.writeFileSync(fname,str,encoding);   }
  catch (err) {
    error("Can't write file: "+fname);
  }
}
function fileCopy(SRC,DEST,ENC) {
  if (SRC==DEST) return;
  var S=fileRead(SRC,ENC);
  fileWrite(DEST,S,ENC);
}
function fileMove(SRC,DEST) {
  fs.renameSync(SRC,DEST);
}
function fileDelete(fname) {
  fs.unlinkSync(fname);
}

function dirCreate(fname) {
  try {
    fs.mkdirSync(fname);
  }
  catch (err) {
    error("Can't create directory: "+fname);
  }
}
function vfileCreate(dir,fname,isDir,parent,val) {
  var D=fileStats(dir+"/"+fname).mtime;
  return {"dir":trim(replaceAll(dir,"//","/"),"/",false,true),"fname":fname,
          "isDir":isDir,
          "date":D,
          "isModified":false,"val":val,
          "parent":parent};
}
_READ={};
function fileReadSet(ext,readFunc) {
  _READ[ext]=readFunc;
}
function dirRead(fname,mask,rec,ldf) {
  function fileRead(fname) {
    var dir=path.dirname(fname)+"/";
    fname=path.basename(fname);
    var val="";
    var readFunc=_READ[fileExt(fname)];
    if (readFunc!=undefined) {
      val=readFunc(dir+fname);
      val=replaceAll(val,"\r\n","\n");
    }
    return val;
  }
  var predir=path.dirname(fname)+"/";
  fname=path.basename(fname);
  if (isUndefined(mask)) mask="*";
  var d=vfileCreate(predir,fname,true,null,{});
  var dir=fname;
  if (predir!="") dir=predir+"/"+fname;
  var a=fs.readdirSync(dir);
  for (var i=0;i<a.length;i++) {
    var b=fileIsDir(dir+"/"+a[i]);
    if (b) {
      if (rec) {
        d.val[a[i]]=dirRead(dir+"/"+a[i],mask,rec,ldf);
        d.val[a[i]].parent=d;
      }
      else
      if (strMatch(a[i],mask)) {
        d.val[a[i]]=vfileCreate(dir,a[i],b,d,{});
      }
    }
    else {
      var matches=strMatch(a[i],mask);
      if (matches) {
        d.val[a[i]]=vfileCreate(dir,a[i],b,d,null);
        if (ldf) d.val[a[i]].val=fileRead(dir+"/"+a[i]);
      }
    }
  }
  return d;
}
function foreach_vfile(d,func) {
  for (var fname in d.val) {
    var f=d.val[fname];
    if (f.isDir) foreach_vfile(f,func);
            else func(f);
  }
  func(d);
}
function fnameNormalize(fname) {
  return replaceAll(path.resolve(path.normalize(fname)),"\\","/");
}
function fnameIsAbsPath(fname) {
  return isString(fname) && (fname[0]=="/" || fname[1]==":");
}
function vfilePathname(vf) {
  var a=[];
  do {
    a.push(vf.fname);
    vf=vf.parent;
  }
  while (vf!=null);
  return fnameNormalize(a.reverse().join("/"));
}
function isChildPath(p,parent) {
  p=path.normalize(p);
  parent=path.normalize(parent);
  if (parent[0]=="." && p[0]!='/') p="./"+p;   return startsWith(p,parent);
}

function urlParse(U) {
  var RES;
  if (SERVER) RES=url.parse(U);
         else RES=document.createElement('a'),RES.href=U;   return RES;
}
function urlNormalize(U,BASE) {
  U=trim(U);
  if (isUndefined(BASE)) BASE="";
  var I=strFind(U,"://")
  if (I!=-1) {
    var P=substring(U,0,I+3),U=substring(U,I+3,length(U));
    return P+U;   }
  else {
    if (BASE!="" && BASE[length(BASE)-1]!="/" && U!="" && U[0]!="/") BASE+="/";
    return BASE+U;
  }
}
function urlSelf() {
  if (SERVER) return Nil;
         else return urlParse(trim(document.location.href,"/",false,true));
}

var ColorNone           ="0",
    ColorBright         ="1",
    ColorNoBright       ="22",
    ColorUnderscore     ="4",
    ColorNoUnderscore   ="24",
    ColorBlink          ="5",
    ColorNoBlink        ="25",
    ColorReverse        ="7",
    ColorNoReverse      ="27";

var ColorBlack          ="30",
    ColorRed            ="31",
    ColorGreen          ="32",
    ColorBrown          ="33",
    ColorBlue           ="34",
    ColorMagenta        ="35",
    ColorCyan           ="36",
    ColorWhite          ="37",
    ColorGrey           ="b30",
    ColorBrightRed      ="b31",
    ColorBrightGreen    ="b32",
    ColorYellow         ="b33",
    ColorBrightBlue     ="b34",
    ColorBrightMagenta  ="b35",
    ColorBrightCyan     ="b36",
    ColorBrightWhite    ="b37";
    ColorBgBlack        ="40",
    ColorBgRed          ="41",
    ColorBgGreen        ="42",
    ColorBgBrown        ="43",
    ColorBgBlue         ="44",
    ColorBgMagenta      ="45",
    ColorBgCyan         ="46",
    ColorBgWhite        ="47";

var
   HTMLColor={};    HTMLColor[ColorBlack]="#000000",HTMLColor[ColorRed]="#FF0000";
   HTMLColor[ColorGreen]="#00FF00",HTMLColor[ColorBrown]="#800080";
   HTMLColor[ColorBlue]="#000080",HTMLColor[ColorMagenta]="#008080";
   HTMLColor[ColorCyan]="#0000FF",HTMLColor[ColorWhite]="#808080";

function htmlEscapeChars(html) {
  var res="";
  for (var i=0;i<html.length;i++) {
    var c=html[i];
    if (c=='<') c="&lt;";
    if (c=='>') c="&gt;";
    if (c=='&') c="&amp;";
    res+=c;
  }
  return res;
}
function htmlEscapeBlanks(html) {
  var res="";
  for (var i=0;i<html.length;i++) {
    var c=html[i];
    if (c=='\n') c="<br>";
    if (c==' ') c="<span style=\"white-space:pre-wrap;\"> </span>";     res+=c;
  }
  return res;
}

var OUTS=Nil;
function startOutS() {
  OUTS="";
}
function stopOutS() {
  OUTS=Nil;
}
function getOutS() {
  return OUTS;
}
function _out0(S) {
  if (!isString(S)) { console.log("<"+display(S)+">");error("out0"); }
  if (OUTS==Nil) if (SERVER) process.stdout.write(S); else document.write(S);
            else OUTS+=S; }
function out0(S) {
  return _out0(S);
}
function _out(S) {
  if (SERVER || OUTS!=Nil) out0(S); else out0(htmlEscapeBlanks(htmlEscapeChars(S)));
}
function out(O) {
  return _out(O);
}
function outd(O) {
  out(display(O));
}
function br(s) {
  out0("<br>");
}
function hr(s) {
  out0("<hr>");
}

function esc(C) {
  if (SERVER) return "\x1b["+C+"m";
  else {
    C=HTMLColor[C];
    return C==undefined?"":"</font><font color=\""+C+"\">";   }
}
function color(C) {
  if (C[0]=="b") out0(esc(ColorBright)),C=substring(C,1,length(C));
            else out0(esc(ColorNoBright));
  out0(esc(C));
}
function cr() {
  out("\n");
}
function spc(N,C) {
  var RES="";
  if (isUndefined(C)) C=" ";
  while (N--) RES+=C;
  return RES;
}
function indent(N) {
  while (N--) out(" ");
}
var OUTINDENT=0;
function outIndent() {
  indent(OUTINDENT);
}
function outIndentInc(N) {
  OUTINDENT+=N;
}
function crIndent() {
  cr();
  outIndent();
}

function consoleInputMode(RAW) {
  if (isUndefined(RAW)) RAW=False;
  process.stdin.setRawMode(RAW);
}

function consoleMain(FUNC) {
  process.stdin.on('data',FUNC);
}
function consoleRepeat(FUNC,ONCE) {
  FUNC();
  consoleMain(function (KEY) {
    if (ONCE) process.exit(0);
    FUNC();
  });
}

function consoleInit() {
  ColorBlue=env("TERM")=="cygwin"?"37":"34";   ColorWhite=env("TERM")=="cygwin"?"34":"37";
}

function env(VAR) {
  if (SERVER) return process.env[VAR]; else return "";
}

function argvRemove(argv,j) {
  splice(argv,j,1,[]);
}
function processCwd() {
  return fnameNormalize(process.cwd());
}
function chdir(PATH) {
  return process.chdir(PATH);
}
function spawn(EXE,PARM,OPTIONS,ASYNC) {
  function from(S,KEEP) {
    if (S==Nil) return "";
    return Buffer.from(S).toString();
  }
  if (ASYNC) return child_process.spawn(EXE,PARM,OPTIONS);
  else {
    var RES=child_process.spawnSync(EXE,PARM,OPTIONS);
    if (RES.stderr==Nil || from(RES.stderr).length>0) {
      throw new Error(from(RES.stderr));
    }
    return from(RES.stdout);
  }
}

function scriptFind(CMD) {
  if (!fnameIsAbsPath(CMD)) {
    var PATH;
    if (isDefined(project.cwp())) PATH=project.cwp().CONF.BIN;
    if (isDefined(project.JIXPROJ)
     && (isUndefined(PATH) || !fileExists(PATH+"/"+CMD))) PATH=project.JIXPROJ.CONF.BIN;
    if (isDefined(PATH) && fileExists(PATH+"/"+CMD)) CMD=PATH+"/"+CMD;
  }
  if (!fnameIsAbsPath(CMD)) CMD=Nil;
  return CMD;
}
function pythonExe() {
  var PYTHON=env("PYTHON_HOME");
  function ex(FP) {
    return fileExists(FP+"/python") || fileExists(FP+"/python.exe");
  }
  if (!(isDefined(PYTHON) && ex(PYTHON))) {
    PYTHON=env("PYTHON_PATH");
    if (isDefined(PYTHON)) {
      var L=splitTrim(PYTHON,";").map(fnameNormalize);       PYTHON=Undefined;
      for (var DIR of L) if (ex(DIR)) { PYTHON=DIR;break; }
    }
  }
  if (isDefined(PYTHON) && ex(PYTHON)) PYTHON+="/python";
                                  else PYTHON=Undefined;
  return PYTHON;
}
function python(CMD,PARMS) {
  CMD=scriptFind(CMD);
  if (!fnameIsAbsPath(CMD)) error("python::script "+CMD+" not found");
  var PYTHON=pythonExe();
  if (isUndefined(PYTHON)) error("python not found");
  return spawn(PYTHON,[CMD].concat(PARMS));
}

var fs,path,url,child_process;
if (SERVER) {
  fs=require('fs');
  path=require('path');
  url=require('url');
  child_process=require('child_process');
}
consoleInit();


function setprop(O,NAME,VAL,E,W,C) {
  if (!isString(NAME)) error("setprop");
  if (isUndefined(E)) E=False;
  if (isUndefined(W)) W=False;
  if (isUndefined(C)) C=False;
  Object.defineProperty(O,NAME,{
    "value": VAL,
    "enumerable": E,
    "writable": W,
    "configurable": C
  });
}

var getPrototypeOf=Object.getPrototypeOf || function (O) {   return O.__proto__; }
var setPrototypeOf=Object.setPrototypeOf || function (O,PROTO) {   O.__proto__=PROTO;
  return O;
}
function hasPrototype(O,P) {
  O=getPrototypeOf(O);
  while (O!=Nil) {
    if (O==P) return True;
    O=getPrototypeOf(O);
  }
  return False;
}

var SymbolType=Symbol("type");
function _mtypeOf() {
  var OBJ=this;
  if (!isNil(this.typeOf)) OBJ=prototype(this);  return OBJ[SymbolType];
}
function jsprotoCreate(JSPROTO,TYPE,JSPARENT) {
  var CLASS=Object;
  if (!isNil(JSPARENT)) CLASS=JSPARENT.constructor;
  var RES=JSPROTO;
  if (JSPROTO==Nil) RES=(class extends CLASS {}).prototype;
  RES[SymbolType]=TYPE;
  setprop(RES,"typeOf",_mtypeOf);
  setprop(RES,"init0",function () {},False,True);
  return RES;
}
function jsprotoIsAtom(PROTO) {
  return PROTO==Symbol.prototype
      || PROTO==Boolean.prototype
      || PROTO==Number.prototype
      || PROTO==String.prototype;
}
function jsprotoInheritsAtom(PROTO) {
  if (PROTO==Nil) return False;
  if (jsprotoIsAtom(PROTO)) return True;
  return jsprotoInheritsAtom(Object.getPrototypeOf(PROTO));
}

function _createObject(CONT) {
  var RES=new this.JSPROTO.constructor();
  if (!isUndefined(CONT)) {
    if (!isContainer(CONT)) error("_createObject");
    CONT.store(RES);
  }
  RES.init0();
  return RES;
}
function _consObject(JSPROTO,VAL,CONT) {
  if (!isUndefined(VAL) && constructor(VAL)!=Object && constructor(VAL)!=Array) {
    if (!isContainer(VAL) || !isUndefined(CONT)) error("_consObject");
    CONT=VAL;
    VAL=Undefined;
  }
  var RES=({ "_":_createObject, "JSPROTO":JSPROTO })._(CONT);
  RES.init();
  if (isDefined(VAL)) Object.assign(RES,VAL);   return RES;
}
function _createAtom(VAL,CONT) {
  var RES=new this.JSPROTO.constructor(VAL);
  if (!isUndefined(CONT)) CONT.store(RES);
  RES.init0();
  return RES;
}
function _consAtom(JSPROTO,VAL,CONT) {   var RES=({ "_":_createAtom, "JSPROTO":JSPROTO })._(VAL,CONT);
  RES.init();
  return RES;
}
var TYPEPROTO=jsprotoCreate(Nil,Nil);
setprop(TYPEPROTO,"init0",function () {
  this.NAME=Nil;
  this.PARENT=Nil;
  this.JSPROTO=Nil;
  this.ATTRS=[];
  setprop(this,"create",_createObject,False,True);
});
var TYPES={};
var type=function (CONS,O) {
  var PARENT=Nil;
  if (!isNil(O)) PARENT=O.PARENT;
  var JSPARENT=Nil;
  if (PARENT!=Nil) JSPARENT=PARENT.JSPROTO;
  var JSPROTO=Nil;
  if (CONS==type) JSPROTO=TYPEPROTO;
  else
  if (!isNil(O) && !isNil(O.JSPROTO)) JSPROTO=O.JSPROTO;
  if (isNil(CONS) || CONS!=type) JSPROTO=jsprotoCreate(JSPROTO,CONS,JSPARENT);
  var CREATE=jsprotoInheritsAtom(JSPROTO)
             ?_createAtom
             :_createObject;
  if (isNil(CONS)) {
    CONS=CREATE==_createObject
         ?function (VAL,CONT) { return _consObject(JSPROTO,VAL,CONT); }
         :function (VAL,CONT) { return _consAtom(JSPROTO,VAL,CONT); };
  }
  JSPROTO[SymbolType]=CONS;
  Object.setPrototypeOf(CONS,TYPEPROTO);
  CONS.init0();
  CONS.PARENT=PARENT;
  CONS.JSPROTO=JSPROTO;
  if (!isNil(O)) {
    if (!isNil(O.NAME)) {
      CONS.NAME=O.NAME;
      TYPES[O.NAME]=CONS;
    }
    CONS.ATTRS=[];
    if (!isArray(O.ATTRS)) { if (!isNil(O.ATTRS)) error("type::ATTRS"); }
                      else if (!empty(O.ATTRS)) CONS.setAttrs(O.ATTRS);     CONS.NOEVAL={};
    for (var N in O) if (N!="NAME" && N!="PARENT" && N!="JSPROTO" && N!="ATTRS") CONS[N]=O[N];
  }
  delete CONS.name;   if (!empty(CONS.ATTRS)) {
    setprop(CONS.JSPROTO,"init0",function () {
      for (var I=0;I<length(CONS.ATTRS);I++) {
        var VAL0=CONS.ATTRS[I].VAL0;
        if (isBoxed(VAL0)) {
          var VAL1={};
          if (isArray(VAL0)) VAL1=[];
          Object.assign(VAL1,VAL0);
          VAL0=VAL1;
        }
        if (CONS.ATTRS[I].QUALIF.has("v>")) this.setv(CONS.ATTRS[I].NAME,VAL0);         else
        if (CONS.ATTRS[I].QUALIF.has("v")) this[CONS.ATTRS[I].NAME]=VAL0;
      }
    },
    False,True);
  }
  setprop(CONS,"create",CREATE,False,True);
  return CONS;
}
var obj=type(function (VAL,CONT) {                if (!isUndefined(VAL) && constructor(VAL)!=Object) {
                 if (!isContainer(VAL)) {
                   if (constructor(VAL)==Array && isDefined(tree)) return tree(VAL,CONT);
                 }
                 else {
                   if (!isUndefined(CONT)) error("obj.cons");
                   CONT=VAL;
                   VAL=Undefined;
                 }
               }
               var RES=obj.create(CONT);
               if (isDefined(VAL)) Object.assign(RES,VAL);                return RES;
             },
             { "NAME":"obj", "PARENT":Nil, "JSPROTO":Object.prototype, "ATTRS":[] });

type=type(type,
          { "NAME":"type", "PARENT":obj, "ATTRS":[] });
setprop(type,"create",function () { error("type.create"); });

setprop(type,"getByName",function (NAME) {
  return TYPES[NAME];
});

function isType(O) {
  return isa(O,type);
}
setprop(TYPEPROTO,"setMethod",function (NAME,FUNC) {
  setprop(this.JSPROTO,NAME,FUNC,False,True);
},
False,True);

obj.setMethod("init",function () {});

type.setMethod("name",function () {
  return this.NAME;
});
type.setMethod("parent",function () {
  return this.PARENT;
});
type.setMethod("inherits",function (T) {
  var P=this.parent();
  if (!isType(T) || P==Nil) return False;
  if (P==T) return True;
       else return P.inherits(T);
});
type.setMethod("method",function (NAME) {
  var FUNC=this.JSPROTO[NAME];   return isFunction(FUNC)?FUNC:Undefined;
});
type.setMethod("super",function (NAME) {
  return this.parent().method(NAME);
});
obj.setMethod("super",function (NAME,...PARMS) {
  var M=typeOf(this).super(NAME);
  if (isNil(M)) error("super::method "+NAME+" doesn't exists in class "+typeOf(this).parent().name());
  return M.apply(this,PARMS);
});
obj.setMethod("call",function (METHOD,...PARMS) {
  return METHOD.apply(this,PARMS);
});

var nil=type(function (VAL) {
               var RES=boxit(VAL);
               if (!isNil(RES.valueOf())) error("nil");
               return RES;
             },
             { "NAME":"nil", "PARENT":obj, "ATTRS":[] });

var BoxedNil=nil.create(),BoxedUndefined=nil.create();

nil.setMethod("valueOf",function () {
  if (this==BoxedUndefined) return Undefined;
  if (this==BoxedNil) return Nil;
  error("nil.valueOf");
});

function isUnboxed(O) {
  if (O==Nil) return True;
  return isAtom(O) && O.valueOf()===O;
}
function isBoxed(O) {   if (O==Nil) return False;
  return !isUnboxed(O);
}
function boxed(O) {
  if (O==Nil) return boxit(O);
  if (isUnboxed(O)) return Object(O);
  return O;
}

function boxit(O) {
  if (isUndefined(O)) return BoxedUndefined;
  if (eqNil(O)) return BoxedNil;
  return O;
}
function typeOf(O) {
  O=boxit(O);
  if (!isFunction(O.typeOf)) return obj;
  return O.typeOf();
}

var symb=type(function (S) {
                return Symbol(S);
              },
              { "NAME":"symb", "PARENT":obj, "JSPROTO":Symbol.prototype, "ATTRS":[] });
var bool=type(function (B,CONT) {
                 return bool.create(B,CONT);
              },
              { "NAME":"bool", "PARENT":obj, "JSPROTO":Boolean.prototype, "ATTRS":[] });
var num=type(function (N,CONT) {
               return num.create(N,CONT);
             },
             { "NAME":"num", "PARENT":obj, "JSPROTO":Number.prototype, "ATTRS":[] });
var str=type(function (S,CONT) {
               return str.create(S,CONT);
             },
             { "NAME":"str", "PARENT":obj, "JSPROTO":String.prototype, "ATTRS":[] });
var array=type(function (VAL) {                  if (isString(VAL)) return explode(VAL);
                 var RES=[];
                 if (isDefined(VAL)) Object.assign(RES,VAL);                  return RES;
               },
               { "NAME":"array", "PARENT":obj, "JSPROTO":Array.prototype, "ATTRS":[] });

type.setMethod("isAtom",function (STRICT) {
  if (STRICT) return this==nil || this==symb || this==bool || this==num || this==str;
         else return this.isAtom(True) || this.inherits(nil)
                                        || this.inherits(symb) || this.inherits(bool)
                                        || this.inherits(num) || this.inherits(str);
});
type.setMethod("root",function () {
  if (this.isAtom(True) || this==array) return this;
                                   else if (this.parent()==Nil) return obj;
                                                           else return this.parent().root();
});

var set=type(function (VAL) {
               if (isUndefined(VAL)) VAL=[];
               return set.create(implode(VAL));              },
             { "NAME":"set", "PARENT":str, "ATTRS":[], "ELEMS":Undefined });

function isSet(O) {
  return isa(O,set);
}
set.setMethod("contains",function (ELTS) {   if (!isString(ELTS)) error("set.contains");
  ;   for (var I=0;I<length(ELTS);I++) if (!contains(this,ELTS[I])) return False;
  return True;
});
set.setMethod("has",set.method("contains"));

set.setMethod("inter",function (S) {
  ;   var A=[];
  for (var I=0;I<length(this);I++) if (contains(S,this[I])) A.push(this[I]);
  return typeOf(this)(A);
});
set.setMethod("union",function (S) {
  ;   var A=explode(S);
  for (var I=0;I<length(this);I++) if (!contains(A,this[I])) A.push(this[I]);
  return typeOf(this)(A);
});
set.setMethod("minus",function (S) {
  ;   var A=[];
  for (var I=0;I<length(this);I++) if (!contains(S,this[I])) A.push(this[I]);
  return typeOf(this)(A);
});

setprop(set,"parse",function (S) {   error("set.parse");
});
set.setMethod("serialize",function (VAL) {   error("set.serialize");
});

function tset(NAME,ELEMS) {   if (!isArray(ELEMS)) error("tset");
  return RES=type(function (VAL) {
                    if (isUndefined(VAL)) VAL=[];
                    return type.getByName(NAME).create(implode(VAL));                   },
                  { "NAME":NAME, "PARENT":set, "ATTRS":[], "ELEMS":ELEMS });
}

var qualif=tset("qualif",[
  "v",   "c",   "i",   "p",   "a",   "*",   "!",   ">",   "l"  ]);

function isQualif(O) {
  return isa(O,qualif);
}

var addr=type(function (NAME,TYPE,QUALIF,VAL0) {
                if (isUndefined(TYPE) && isUndefined(QUALIF)) return addr.obj(NAME);
                else {
                  var RES=addr.create();
                  RES.init(NAME,TYPE,QUALIF,VAL0);
                  return RES;
                }
              },
              { "NAME":"addr", "PARENT":obj, "ATTRS":[] });

addr.setMethod("init",function (NAME,TYPE,QUALIF,VAL0) {
  if (isUndefined(TYPE)) TYPE=str;
  if (isString(QUALIF)) QUALIF=qualif(QUALIF);
  else
  if (!isQualif(QUALIF)) error("addr.init");
  Object.assign(this,{ "NAME":NAME, "TYPE":TYPE, "QUALIF":QUALIF, "VAL0":VAL0 });
});
setprop(addr,"obj",function (S) {   S=trim(S," ",True,True);
  var A=splitOnce(S," ",["v",Undefined]);
  var Q=qualif(A[0]);
  if (Q.inter("vci")=="") Q=Q.union("v");
  A=splitOnce(A[1],"=",[Undefined,Undefined]);
  var VAL0=eval("(function () { return "+A[1]+"; })()");   A=splitOnce(A[0],":",[Undefined,"obj"]);
  var NAME=A[0],TYPE=type.getByName(A[1]);
  return addr(NAME,TYPE,Q,VAL0);
});

function isAddr(O) {
  return isa(O,addr);
}

type.setMethod("attr",function (NAME) {
  return find(this.ATTRS,function (O) { return O.NAME==NAME; });
});
addr.setMethod("has",function (Q) {
  return this.QUALIF.has(Q);
});
type.setMethod("attrHas",function (NAME,Q) {
  var A=this.attr(NAME);
  return isDefined(A) && A.has(Q);
});
  
type.setMethod("setAttr",function (A) {
  if (isString(A)) A=addr(A);
  if (!isAddr(A)) error("setAttr");
  if (!isNil(this.attr(A.NAME))) error("type.setAttr");
  this.ATTRS.push(A);
  if (A.QUALIF.has("c")) {
    setprop(this.JSPROTO,A.NAME,A.VAL0,False,True);
  }
});

type.setMethod("attrs",function () {
  return this.ATTRS;
});
type.setMethod("setAttrs",function (L) {
  for (var I=0;I<length(L);I++) this.setAttr(L[I]);
});

type.setAttrs(["NAME","PARENT","JSPROTO","ATTRS"]);
addr.setAttrs(["NAME","TYPE","QUALIF","VAL0"]);

var func=type(function () {
               return func.create();
             },
             { "NAME":"func", "PARENT":obj, "JSPROTO":Function.prototype, "ATTRS":[] });

setprop(TYPEPROTO,"setMethod",function (NAME,FUNC) {
  if (!isFunction(FUNC)) error("setMethod");
  this.setAttr(addr(NAME,func,"c",FUNC));
});


function isObject(O) {
  return isBoxed(O);
}

setprop(obj,"getById",function (ID) {
  error("obj.getById(!Yet)");
});

var create=obj; 
function isa(O,T) {
  return typeOf(O)==T || typeOf(O).inherits(T);
}

obj.setMethod("equalAttrs",function (O) {
  var RES=True;
  for (var N in O) if (this[N]!=O[N]) RES=False;
  return RES;
});
obj.setMethod("setAttrs",function (O,NOSLOTS) {
  if (isUndefined(NOSLOTS)) NOSLOTS={};
  var RES=False;
  if (!isUndefined(O)) for (var N in O) if (isUndefined(NOSLOTS[N])) {
    if (this[N]!=O[N]) {
      this[N]=O[N];
      RES=True;
    }
  }
  return RES;
});

var oflags=tset("oflags",[
  "d" ]);

var MEMORY;
function memory() {
  return MEMORY;
}

function copy(O,MODE,CONT) {
  if (isContainer(MODE)) {
    if (!isUndefined(CONT)) error("copy");
    CONT=MODE;
    MODE=Undefined;
  }
  if (isUndefined(CONT)) CONT=MEMORY;
  return CONT.copy(O,MODE);
}
function move(O,MODE,CONT) {
  if (isContainer(MODE)) {
    if (!isUndefined(CONT)) error("move");
    CONT=MODE;
    MODE=Undefined;
  }
  if (isUndefined(CONT)) CONT=MEMORY;
  return CONT.move(O,MODE);
}

function parse(S,CONT) {
  return parsef(S,CONT);
}
function serialize(O,MODE) {
  if (isUndefined(MODE)) MODE="full";
  if (!contains(["full","flat*","flat"],MODE)) error("serialize");
  var FMT=[["*",MODE=="flat*"?"flat":MODE,[]]];
  if (MODE=="flat") {
    sfinit();
    serializefBis(O,"flat",[]);
    return sfresult();
  }
  else return serializef(O,FMT);
}

function isDeleted(O) {
  return O.hasFlags("d");
}
obj.setMethod("delete",function (MODE) {   if (isUndefined(MODE)) MODE="flat";
  if (isUnboxed(this)) return;
  var ISARR=isArray(this);
  for (var N of sfattrs(this)) {
    var VAL=this[N],PO=True;
    if (!(ISARR && isNumStr(N))) PO=typeOf(this).attrHas(N,">");
    if (isBoxed(VAL) && MODE=="flat" && !PO) error("delete(!PO)::"+N);
    if (isBoxed(VAL) && (MODE=="full" || PO)) {
      VAL.delete(MODE);
    }
  }
  this.addFlags("d");
});
setprop(obj,"delete",function (O,MODE) {
  if (isUnboxed(O)) O.delete(MODE);
});

function tree(A,CONT) {
  if (isAtom(A) || constructor(A)!=Array && !isTemplate(A) || length(A)<1 || !isType(A[0])) return A;   var O={};
  Object.assign(O,length(A)==1?{}:A[1]);
  if (constructor(O)!=Object) error("tree(1)");
  O.$=[];
  for (var I=2;I<length(A);I++) {     var VAL=A[I];
    if (isUndefined(A[0].NOEVAL["$"])) VAL=tree(VAL,CONT);
    O.$.push(VAL);
  }
  var RES=A[0](O,CONT);
  if (!isArray(RES["$"]) && length(A)>2) error("tree(2)");
  return RES;
}


var mlstr=type(function (VAL,LANG) {
                 var RES;
                 if (!isString(LANG)) LANG=mlstr.DEFAULT;                  if (isString(VAL)) {
                   RES=mlstr.create(VAL);
                 }
                 else 
                 if (typeOf(VAL)==obj) {                    if (isString(VAL.LANG)) LANG=VAL.LANG;
                   var VAL0=VAL.$;
                   if (isUndefined(VAL0) && isString(LANG)) VAL0=VAL[LANG];
                   if (isUndefined(VAL0)) VAL0="";
                   if (!isString(VAL0)) if (isNumber(VAL0)) VAL0=VAL0.toString();
                                                       else error("mlstr(1)");
                   RES=mlstr.create(VAL0);
                   RES.setAttrs(VAL);
                   delete RES.$;
                   if (isString(LANG)) delete RES[LANG];
                 }
                 else error("mlstr(2)");
                 RES.LANG=LANG;
                 return RES;
               },
               { "NAME":"mlstr", "PARENT":str, "ATTRS":[],
                 "LANGS":[], "TRANS":{}, "DEFAULT":"en", "LANG":"en", "VOFWE":True });

function isMLStr(O) {
  return isa(O,mlstr);
}

setprop(mlstr,"langs",function () {
  return mlstr.LANGS;
});
setprop(mlstr,"isLang",function (LANG) {
  return contains(mlstr.LANGS,LANG);
});
setprop(mlstr,"addLang",function (LANG) {
  mlstr.addLangs([LANG]);
});
setprop(mlstr,"addLangs",function (L) {
  for (var LANG of L) if (!mlstr.isLang(LANG)) {
    mlstr.LANGS.push(LANG);
    mlstr.TRANS[LANG]={};
  }
  mlstr.LANGS.sort(function (O1,O2) {
    return O1>O2;
  });
});
setprop(mlstr,"default",function () {
  return mlstr.DEFAULT;
});
setprop(mlstr,"setDefault",function (LANG) {
  if (!mlstr.isLang(LANG)) error("mlstr.setDefault");
  mlstr.DEFAULT=LANG;
});
setprop(mlstr,"lang",function () {
  return mlstr.LANG;
});
setprop(mlstr,"setLang",function (LANG) {
  if (!isString(LANG)) error("mlstr.setLang");
  mlstr.LANG=LANG;
});
setprop(mlstr,"vofWE",function () {   return mlstr.VOFWE;
});
setprop(mlstr,"setVofWE",function (B) {
  if (!mlstr.isLang(LANG)) error("mlstr.setVofWE");
  mlstr.VOFWE=B;
});

mlstr.setMethod("toString",function (LANG) {
  if (isUndefined(LANG)) LANG=mlstr.LANG;
  if (!isString(LANG)) error("mlstr.toString");
  if (LANG==this.LANG || empty(this[LANG]) && mlstr.VOFWE) return this.valueOf();
                                                      else return this[LANG];
});
mlstr.setMethod("hasValue",function (S,CINS) {
  var F=isDefined(CINS)?lcase:function (X) { return X; };
  for (var LANG of mlstr.LANGS) if (F(this.toString(LANG))==F(S)) return True;
  return False;
});

setprop(mlstr,"trans",function (S,LANG,LANG2) {
  if (!mlstr.isLang(LANG)) error("mlstr.trans(1)");
  if (isMLStr(S)) {
    if (isDefined(LANG2)) error("mlstr.trans(2)");
    var S2=S.toString(LANG);
    if (isDefined(S2)) return S2;
    S=S2;
  }
  if (!mlstr.isLang(LANG2)) error("mlstr.trans(3)");
  if (LANG==LANG2) return S;
  S=mlstr.TRANS[LANG][S];
  if (isUndefined(S)) return Undefined;
  return S.toString(LANG2);
});
setprop(mlstr,"setTrans",function (S,LANG,S2,LANG2) {
  if (isMLStr(S)) {
    if (isDefined(LANG) || isDefined(S2) || isDefined(LANG2)) error("mlstr.setTrans(1)");
    for (var LS of mlstr.LANGS) for (var LD of mlstr.LANGS) if (LS!=LD) {
      var SS=S.toString(LS),SD=S.toString(LD);
      if (isString(SS) && SS!="" && isString(SD) && SS!="") {
        mlstr.setTrans(SS,LS,SD,LD);
      }
    }
  }
  else {
    if (!isString(S) || !mlstr.isLang(LANG)
     || !isString(S2) || !mlstr.isLang(LANG2)) error("mlstr.setTrans(2)");
    var MS=mlstr.TRANS[LANG][S];
    if (isUndefined(MS)) MS=mlstr(S,LANG);
    if (MS.toString(LANG)!=S) error("mlstr.setTrans(3)");
    mlstr.TRANS[LANG][S]=MS;
    if (LANG2!=LANG) {
      if (isUndefined(mlstr.TRANS[LANG2][S2])) mlstr.TRANS[LANG2][S2]=MS;       MS[LANG2]=S2;
    }
    else if (S!=S2) error("mlstr.setTrans(4)");
  }
});

mlstr.addLangs(["en","sp","de","fr","cn","pt","ar","ru"]);


function range(O,MIN,MAX,LI,COL) {
  return { "OBJ":O,"MIN":MIN,"MAX":MAX,"NAT":Nil,"LI":LI,"COL":COL };
}
function rangeBOF(RG) {
  return RG.MIN==0;
}
function rangeEOF(RG) {
  return RG.MIN>=length(RG.OBJ);
}
function rangeValue(RG) {
  return substring(RG.OBJ,RG.MIN,RG.MAX);
}

function strNumberLength(S,i) {
  var i0=i;
  while (S[i]=='+' || S[i]=='-') i++;
  if (!charIsDigit10(S[i])) return 0;
  var DOT=False,
      RADIX=10;
  if (S[i+1]=='b' || S[i+1]=='B') RADIX=2,i+=2;   if (S[i+1]=='x' || S[i+1]=='X') RADIX=16,i+=2;
  if (!charIsDigitInRadix(S[i],RADIX)) return 0;
  while (i<length(S) && charIsDigitInRadix(S[i],RADIX)) {
    while (i<length(S) && charIsDigitInRadix(S[i],RADIX)) i++;
    if (S[i]=='.') { if (DOT) return i-i0; else DOT=True,i++; }
  }
  if (RADIX==10 && (S[i]=='e' || S[i]=='E')) {
    i++;if (S[i]=='+' || S[i]=='-') i++;
    while (i<length(S) && charIsDigitInRadix(S[i],RADIX)) i++;
  }
  return i-i0;
}

function lexerReadString(S,i,C) {
  while (i<length(S)) {
    if (S[i]=='\\') i++;
    else
    if (S[i]==C) break;
    i++;
  }
  if (i>=length(S)) error("lexerReadString");
  return i;
}
function lexerReadUntil(S,i,C1,C2,STRICT) {
  if (STRICT==Undefined) STRICT=True;
  while (i<length(S)) {
    if (S[i]==C1 && (C2==-1 || i+1<length(S) && S[i+1]==C2)) break;
    i++;
  }
  if (STRICT && i>=length(S)) error("lexerReadUntil");
  return i;
}
function lexerRead(S,i,N1,N2) {
  while (i<length(S) && (charIs(S[i],N1) || charIs(S[i],N2))) {
    if (TOKENIZECOMMENTS && S[i]=="/" && i+1<length(S) && (S[i+1]=="*" || S[i+1]=="/")) break;
    i++;
  }
  return i;
}

var TokenNatNone=0,
    TokenNatIdf=1,
    TokenNatStr=2,TokenNatNum=3,
    TokenNatOpn=4,
    TokenNatSpc=5,TokenNatComment=6;
function charnatToToknat(N) {
  var RES=TokenNatNone;
  switch (N) {
    case CharNatAlf  : RES=TokenNatIdf; break;
    case CharNatOmg  : RES=TokenNatOpn; break;
    case CharNatDigit: RES=TokenNatNum; break;
    case CharNatBlank: RES=TokenNatSpc; break;
    default: return TokenNatNone;   }
  return RES;
}
function lexerLiColNext(RG) {
  var LI=RG.LI,COL=RG.COL,
      S=RG.OBJ,i;
  if (RG.MIN<length(S)) for (i=RG.MIN;i<RG.MAX;i++) {
    if (S[i]=="\n") LI+=1,COL=1;
               else COL+=1;
  }
  return [LI,COL];
}
var TOKOPS,TOKENIZECOMMENTS=True,TOKENIZEPYCOMMENTS=False; var TOKENIZEQUOTES=True; function lexerNext(RG) {
  var S=RG.OBJ;
  var i0,i=RG.MAX;
  var BEG,END,LI,COL;
  var LICOL=lexerLiColNext(RG);
  LI=LICOL[0];
  COL=LICOL[1];
  var NAT=TokenNatNone;
  if (i<length(S)) {
    BEG=END=-1;
    if (i>=0 && TOKENIZEQUOTES && !(i>0 && S[i-1]=='\\') && (S[i]=='\"' || charIs("'",CharNatQuote) && S[i]=='\'')) {
      i0=i;
      i=lexerReadString(S,i+1,S[i]);
      BEG=i0,END=i+1;
      NAT=TokenNatStr;
    }
    else
    if (TOKENIZECOMMENTS && i>=0 && i+1<length(S) && S[i]=='/' && S[i+1]=='*') {
      i0=i;
      i=lexerReadUntil(S,i+2,'*','/');
      BEG=i0,END=i+2;
      NAT=TokenNatComment;
    }
    else
    if (TOKENIZECOMMENTS && i>=0 && i+1<length(S) && S[i]=='/' && S[i+1]=='/') {
      i0=i;
      i=lexerReadUntil(S,i+2,"\n",-1,False);
      BEG=i0,END=i+(i>=length(S)?0:1);
      NAT=TokenNatComment;
    }
    else
    if (TOKENIZEPYCOMMENTS && i>=0 && i<length(S) && S[i]=='#') {
      i0=i;
      i=lexerReadUntil(S,i+2,"\n",-1,False);
      BEG=i0,END=i+(i>=length(S)?0:1);
      NAT=TokenNatComment;
    }
    else
    if ((S[i]=='+' || S[i]=='-' || charIsDigit10(S[i])) && strNumberLength(S,i)>0) {
      BEG=i,END=i+strNumberLength(S,i);
      NAT=TokenNatNum;
    }
    else {
      var j;
      j=lexerRead(S,i,charnat(S[i]),charIs(S[i],CharNatAlf)?CharNatDigit:-1);       BEG=i,END=j;
          NAT=charnatToToknat(charnat(S[i]));
    }
    if (BEG==-1) error("lexerNext");
    RG.MIN=BEG;
    RG.MAX=END;
  }
  else {
    RG.MIN=RG.MAX=length(S);
  }
  RG.NAT=NAT;
  RG.LI=LI;
  RG.COL=COL;
  errlicolSet(LI,COL);
  S=rangeValue(RG);
  if (RG.NAT==TokenNatOpn) {
    function findop(I) {
      var N=length(S),TOK=S;
      while (N>0) {
        TOK=substring(S,I,N);
        if (TOKOPS[TOK]!=Undefined) break;
        N--;
      }
      return N;
    }
    var N=findop(0);
    if (N>0 && N!=length(S)) RG.MAX=RG.MIN+N;
    else
    if (N==0) {
      for (var I=1;I<length(S);I++) {
        N=findop(I);
        if (N>0) { RG.MAX=RG.MIN+I;break; }
      }
    }
  }
  return NAT;
}
function lexerStart(TEXT) {
  errlicolSet(1,1,licol(TEXT).FNAME);
  var RG=range(TEXT,0,0,1,1);
  lexerNext(RG);
  return RG;
}
function lexerEOF(RG) {
  return rangeEOF(RG);
}
function tokenize(SRC,KEEP) {
  var RES=[],
      RG=lexerStart(SRC);
  while (!lexerEOF(RG)) {
    if (KEEP || RG.NAT!=TokenNatSpc && RG.NAT!=TokenNatComment) RES.push(licolSet(rangeValue(RG),RG.LI,RG.COL));
    lexerNext(RG);
  }
  errlicolSet(-1,-1,Nil);
  return RES;
}

var PRIOR,POSTFIX,MULTI;
function tokenizeStart(TOKSPEC,COMMENTS,PYCOMMENTS) {
  TOKOPS={};
  PRIOR={},POSTFIX={},MULTI={};
  var T=splitTrim(TOKSPEC," "),
      P=-1;
  for (var I in T) {
    if (T[I]==";;") P--;
    else {
      var OP=T[I],POST=False;
      for (var I=0;I<length(OP);I++) if (!charIsOmg(OP[I])) error("tokenizeStart");       if (OP[length(OP)-1]=="_") POST=True,OP=substring(OP,0,length(OP)-1);
      var OP0=OP;
      if (OP[0]=="_") OP=substring(OP,1,length(OP));
      TOKOPS[OP]=1;
      PRIOR[OP0]=P;
      POSTFIX[OP0]=POST;
    }
  }
  TOKENIZECOMMENTS=True,TOKENIZEPYCOMMENTS=False;
  if (isDefined(COMMENTS)) TOKENIZECOMMENTS=True;
  if (isDefined(PYCOMMENTS)) TOKENIZEPYCOMMENTS=True;
}

function tokenizeInit() {}


var format=type(function (EXT,TOKINIT) {
                  if (!isString(EXT)) error("format(1)");
                  var RES=format.getBy("EXT",EXT);
                  if (RES==Nil) {
                    var RES=format.create();
                    RES.EXT=EXT;
                    RES.TOKINIT=isUndefined(TOKINIT)?function (){
                      tokenizeStart("");
                    }:TOKINIT;
                    format.$.push(RES);
                  }
                  return RES;
                },
                { "NAME":"format", "PARENT":obj,
                  "ATTRS":["EXT=''","TOKINIT=Nil"] });

format.$=[];
setprop(format,"getBy",function (NAME,VAL) {
  var RES=Nil;
  for (var I in format.$) if (format.$[I][NAME]==VAL) RES=format.$[I];
  return RES;
});

function isFormat(O) {
  return isa(O,format);
}

function load(FPATH,KEEP) {
  var TXT=fileRead(FPATH),
      EXT=fileExt(FPATH);
  if (!isString(EXT) || EXT=="") error("load(1)");
  var FMT=format.getBy("EXT",EXT);
  if (!isFormat(FMT)) error("load::format<"+EXT+"> doesn't exists");
  charsInit();
  FMT.TOKINIT();
  return tokenize(TXT,isDefined(KEEP));
}

function txtsave(TXT,N,SEP) {   var PREVS="",RES="",I=0;
  for (var S of TXT) {
    if (isNumber(N) && I>=N) break;
    if (isDefined(SEP)) { if (N>0) RES+=SEP; }
                   else if (PREVS!="" && charIsAlpha(PREVS[0]) && S!="" && charIsAlpha(S[0])) RES+=" ";
    RES+=S;
    PREVS=S;
    I++;
  }
  return RES;
}
function save(FPATH,TXT) {
  if (isArray(TXT)) TXT=txtsave(TXT);
  fileWrite(FPATH,TXT);
}


var _SERIALIZING=[],
    SERIALIZEINDENT=0,
    SERIALIZING=False,
    _PRETTYID=0,
    PRETTYSTRID=0,PRETTYINDENT2=False; 
var SymbolPrettyId=sy("pretty::+o"),SymbolCont=sy("^$");
function prettyGetId(O) {
  if (isDefined(O[SymbolPrettyId])) return O[SymbolPrettyId];
  if (isFunction(O.getId)) return O.getId();
  return "^^";
}
function prettyStrId(O) {
  if (PRETTYSTRID && length(O)>0) return "<"+prettyGetId(O)+">";
                             else return "";
}
function prettyStore(O) {
  O[SymbolPrettyId]=_PRETTYID++;
  _SERIALIZING.push(O);
}
function prettyFreeBufs() {
  if (isArray(_SERIALIZING)) {
    for (O in _SERIALIZING) if (isDefined(O[SymbolPrettyId])) delete O[SymbolPrettyId];
  }
  _SERIALIZING=[];
  _PRETTYID=0;
}
function prettyBis(O,MODE,SKIN,INDENT) {
  if (INDENT==Undefined) INDENT=False;
  var OSERIALIZING=SERIALIZING;
  if (isFunction(MODE)) return MODE(O);
  if (isType(O)) return O.NAME;   if (isNil(O)) return "Nil";
  if (isUndefined(O)) return "Undef";
  if (isBoolean(O)) return O?"True":"False";
  if (isNumber(O)) return O.toString();
  if (isSymbol(O)) return isUndefined(sy(O))?O.toString():sy(O);
  if (isString(O)) return '"'+strEscape(O)+'"';
  if (isDate(O)) return 'd"'+O.toISOString()+'"';
  if (isFunction(O)) return '<Func>';
  if (contains(_SERIALIZING,O)) return "@"+prettyGetId(O);
  SERIALIZING=True;
  var RES="";
  if (MODE=="name") {
    if (isArray(O)) RES="[...]";
    else {
      var NAME=O.NAME;
      if (!isUndefined(NAME)) RES=NAME;
                         else RES="{...}";
    }
  }
  else {
    function incIndent(N) {
      SERIALIZEINDENT+=N;
    }
    if (isArray(O)) {
      prettyStore(O);
      RES+=prettyStrId(O)+"[";
      if (INDENT) incIndent(2);
      var PREVINDENT2=False;
      for (var I=0;I<length(O);I++) {
        if (INDENT) RES+="\n"+spc(SERIALIZEINDENT);
        var ISATOM=isAtom(O[I]) || isType(O[I]),
            ISUP=contains(_SERIALIZING,O[I]);
        if (PRETTYINDENT2 && !INDENT && !ISATOM && !ISUP) {
          incIndent(+2);
          if (!PREVINDENT2) RES+="\n"+spc(SERIALIZEINDENT);
        }
        RES+=prettyBis(O[I],MODE,SKIN);
        if (I+1<length(O)) RES+=",";
        if (PRETTYINDENT2 && !INDENT && !ISATOM && !ISUP) {
          if (I+1<length(O)) RES+="\n"+spc(SERIALIZEINDENT);
          incIndent(-2);
          PREVINDENT2=True;
        }
        else PREVINDENT2=False;
      }
      if (INDENT) incIndent(-2);
      RES+="]";
        }
    else {
      prettyStore(O);
      var TYPE=typeOf(O),PATTERN=Nil;
      RES+=prettyStrId(O)+(TYPE==obj?"":TYPE.NAME)+"{";
      if (SKIN!=Undefined) {
        var SKINT=SKIN[TYPE.NAME];
        if (isUndefined(SKINT)) SKINT=SKIN["*"];
        if (SKINT!=Undefined) {
          if (MODE==Undefined) MODE=SKINT["default"];
          if (MODE!=Undefined) PATTERN=SKINT[MODE];
        }
      }
      if (MODE==Undefined) MODE="short";       if (isNil(PATTERN)) PATTERN={"*":["av","full"]};
      if (INDENT) incIndent(2);
      var PREVINDENT2=False;
      var FIRST=True,I=0,
          NAMES=Object.getOwnPropertyNames(O),LNAMES=length(NAMES),TRGI="";
      for (var NAME of NAMES) {
        var MODE2=Undefined;
        if (PATTERN.hasOwnProperty(NAME)) MODE2=PATTERN[NAME];
        if (MODE2==Undefined) MODE2=PATTERN["*"];
        if (MODE2!=Undefined && !contains(MODE2[0],"-")) {
          var SA=contains(MODE2[0],"a"),
              SV=contains(MODE2[0],"v");
          if (!FIRST && (SA||SV)) RES+=",";
          RES+=TRGI,TRGI="";
          var VAL;
          if (NAME=="caller" || NAME=="callee" || NAME=="arguments") VAL="<Forbidden>";
                                                                else VAL=O[NAME];
          var ISATOM=(isAtom(VAL) || isType(VAL)) && !(isString(VAL) && length(VAL)>5) && !isDate(VAL),
              ISUP=contains(_SERIALIZING,VAL);
          if (SA||SV) {
            if (INDENT) RES+="\n"+spc(SERIALIZEINDENT);
            if (PRETTYINDENT2 && !INDENT && !ISATOM && !ISUP) {
              incIndent(+2);
              if (!PREVINDENT2) RES+="\n"+spc(SERIALIZEINDENT);
            }
            FIRST=False;
          }
          if (SA) RES+=isSymbol(NAME)?pretty(NAME):NAME;
          if (SA&&SV) RES+=":";
          if (SV) RES+=prettyBis(VAL,MODE2[1],SKIN,contains(MODE2[0],"i"));
          if (SA||SV) {
            if (PRETTYINDENT2 && !INDENT && !ISATOM && !ISUP) {
              if (I+1<LNAMES) TRGI+="\n"+spc(SERIALIZEINDENT);
              incIndent(-2);
              PREVINDENT2=True;
            }
            else PREVINDENT2=False;
            I++;
          }
        }
      }
      RES+=TRGI,TRGI="";
      if (INDENT) incIndent(-2);
      RES+="}";
        }
  }  
  SERIALIZING=OSERIALIZING;
  return RES;  
}
function pretty(O,MODE,SKIN) {   var INDENT=False;
  if (MODE=="indent") MODE=Undefined,INDENT=True;   var OPRETTYINDENT2=PRETTYINDENT2;
  if (INDENT) PRETTYINDENT2=1;
  if (!SERIALIZING) _SERIALIZING=[];
  if (isUndefined(MODE)) MODE="short";
  var RES=prettyBis(O,MODE,SKIN);
  if (!SERIALIZING) prettyFreeBufs();
  PRETTYINDENT2=OPRETTYINDENT2;
  return RES;
}


var _SFID,_SFOBJ;
function sfid(HIDDEN) {
  HIDDEN=isDefined(HIDDEN);
  return (HIDDEN?chr(1):chr(2))+_SFID++;
}
function sfisHiddenId(ID) {
  if (!isNumber(ID) && !isString(ID)) outd(ID),cr(),error("sfisHiddenId");
  return ID[0]==chr(1);
}
function sfisLocId(ID) {
  if (!isNumber(ID) && !isString(ID)) error("sfisLocId");
  return ID[0]==chr(1) || ID[0]==chr(2);
}
function sffetch(ID) {
  return _SFOBJ[ID];
}
function sfoid(O) {
  if (!contains(Object.getOwnPropertySymbols(O),SymbolId)) return Undefined;
  return O[SymbolId];
}
function sfstore(O,HIDDEN) {
  if (isUnboxed(O) || isRootAtom(O)) return;
  var ID=sfoid(O);
  if (isUndefined(ID)) ID=sfid(isAtom(O)?True:HIDDEN);
                  else if (isDefined(sffetch(ID))) return;
  O[SymbolId]=ID;
  _SFOBJ[ID]=O;
}
function sfrelease() {
  for (N in _SFOBJ) {
    if (sfisLocId(N)) delete sffetch(N)[SymbolId];
  }
}
function sfinit() {
  _SFID=0;
  _SFOBJ={};
  _SFOUT=[];
  _SFDONE={};
  _SFFIRST=True;
  _SFINDENT=0;
}

var _SFSymbElt="ELT"+chr(2),_SFLANG,ERRL,ERRI;
function parsefList(L,I,STOP,CONT) {


  var N=length(L),FOUND=False,TYPE=array,RES=[],ADDA={},VAR=Undefined,ELT=Nil,TYNAME;
  function omg(S) {
    if (S=="(") return _SFLANG=="lisp"?S:"{";
    if (S==")") return _SFLANG=="lisp"?S:"}";
    if (S=="=") return _SFLANG=="lisp"?S:":";
    error("omg");
  }
  if (STOP==omg(")")) {
    TYPE=obj;
    var OBJ0=False;
    if (_SFLANG=="json" && L[I]=="{") I++,OBJ0=True;
    else
    if (I<N && strIsAlpha(L[I]) && (I+1>=N || I+1<N && L[I+1]!=omg("="))) {
      if (L[I]=="type") TYNAME=L[I];
      else {
        TYPE=type.getByName(L[I]);
        if (isUndefined(TYPE)) TYPE=type(Nil,{ NAME:L[I] });       }
      I++;
    }
    if (isUndefined(TYPE)) error("parsefList(1)-->"+I+" "+L[I]);
    if (_SFLANG=="json" && !OBJ0) if (L[I]!="{") error("parsefList(2)"); else I++;
    RES=obj({});   }
  function unescape(S) {
    S=replaceAll(S,"\\\"",'"');
    S=replaceAll(S,"\\\'","'");
    S=replaceAll(S,"\\n","\n");
    S=replaceAll(S,"\r","");
    return S;
  }
  function parseval(VAR,VAL,TYELT) {
    if (isUndefined(TYELT)) TYELT=obj;
    if (isDefined(VAR) && (!isString(VAR) || !contains(VAR,".")) && !empty(TYPE.attrs())) {
      var A=TYPE.attr(VAR);
      if (A!=Nil) TYELT=A.TYPE;
    }
    if (TYELT==obj) {
      if (isString(VAL) && VAL!="" && strNumberLength(VAL,0)==length(VAL)) TYELT=num;
      else
      if (isString(VAL) && length(VAL)>=2 && VAL[0]=='"' && VAL[length(VAL)-1]=='"') {
        TYELT=str;
        if (length(VAL)>2 && strNumberLength(VAL,1)==length(VAL)-2) TYELT=num;       }
      else
      if (VAL=="Nil") VAL=Nil;
      else ;     }
    if (TYELT==bool) {
      if (VAL=="True") VAL=True;
      else
      if (VAL=="False") VAL=False;
                  else error("parseval(1)");
    }
    else
    if (TYELT==num) {
      if (length(VAL)>=2 && VAL[0]=='"' && VAL[length(VAL)-1]=='"') VAL=substring(VAL,1,length(VAL)-1);       if (strNumberLength(VAL,0)!=length(VAL)) error("parseval(num expected)<"+VAL+">");
      if (VAL[0]=="0") VAL=trim(VAL,"0",1,0);       if (VAL=="" || VAL[0]==".") VAL="0"+VAL;       VAL=JSON.parse(VAL);
    }
    else
    if (TYELT==str || TYELT.inherits(str)) {
           VAL=VAL.valueOf().toString();
      VAL=unescape(substring(VAL,1,length(VAL)-1));
      if (TYELT!=str) VAL=TYELT(VAL);
    }
    return VAL;
  }
  function pushvar(VAL) {
    if (isString(VAR)) if (syExists(VAR)) VAR=sy(VAR);
    if (strIsOmg(VAR)) error("pushvar(0)-->"+VAR);
      if (STOP==omg(")")) {
      if (isString(VAR) && contains(VAR,".")) ADDA[VAR]=parseval(Undefined,VAL);
      else
      if (VAR==_SFSymbElt) ELT.push(parseval(Undefined,VAL));
      else {
        var TYELT;
        if (VAR==sy("+o")) TYELT=num;
        VAL=parseval(VAR,VAL,TYELT);
        if (VAR==sy("+o")) RES.setId(VAL);
                      else RES[VAR]=VAL;
      }
      VAR=Undefined;
    }
    else RES.push(parseval(Undefined,VAL));
  }
  var FIRST=True;
  while (I<N) {
    if (L[I]==STOP && (STOP==omg(")") || STOP=="]")) {
      FOUND=True,I++;
      break;
    }
    else {
      if (STOP==omg(")")) {
        if (_SFLANG=="json" && !FIRST) if (L[I]!=",") error("parsefList(3)"); else I++;
                                  else FIRST=False;
        if (I+1>=N || L[I+1]!=omg("=")) {
          VAR=_SFSymbElt;
          if (ELT==Nil) ELT=[];
        }
        else {
          VAR=L[I];
          I+=2;
          if (I>=N || L[I]==omg(")") || L[I]=="]") error("parsefList::Nothing after '='");
        }
      }
      if ((_SFLANG=="lisp" && L[I]==omg("("))
       || (_SFLANG=="json" && L[I]==omg("("))
       || (_SFLANG=="json" && L[I+1]==omg("(")) || L[I]=="[") {
        var A=parsefList(L,I+(_SFLANG=="lisp"||L[I]=="["?1:0),L[I]=="["?"]":omg(")"),CONT);
        pushvar(A[0]);
        I=A[1];
      }
      else {
        pushvar(L[I]),I++;
        if (_SFLANG=="json" && STOP=="]") if (L[I]==",") I++;
                                          else if (L[I]!="]") error("parsefList::']' expected");
      }
    }
  }
  if (ELT!=Nil) VAR="$",pushvar(ELT);
  if (STOP!=omg(")") && STOP!="]" && FOUND) error("parsefList::STOP(1)");
  if ((STOP==omg(")") || STOP=="]") && !FOUND) error("parsefList::STOP(2)<"+STOP+">");
  if (TYNAME=="type") RES.PARENT=type.getByName(RES.PARENT),RES=type(Nil,RES);   else
  if (TYPE!=obj && TYPE!=array) {     RES=TYPE(RES);
    for (var N in ADDA) {
      var A=splitTrim(N,".");
      RES[A[0]][A[1]]=ADDA[N];
    }
    if (!isNil(CONT) && !isAtom(RES)) CONT.store(RES,RES.getId());
  }
  return [RES,I];
}
var ERRS;
function parsef(S,CONT,LANG) {
  if (isString(CONT)) LANG=CONT,CONT=Undefined;
  if (isUndefined(LANG)) LANG="json";
  _SFLANG=LANG;
  if (LANG!="lisp" && LANG!="json") error("parsef(0)");
  parsefStart();
  var RES=parsefList(tokenize(ERRS=S),0,"",CONT)[0];
  RES=linkf(RES,CONT);
  return RES;
}

function parsefStart() {
  charsInit();
  charnatSet("#",CharNatAlf);
  charnatSet("+",CharNatAlf);
  charnatSet("%",CharNatAlf);
  charnatSet(".",CharNatAlf);
  tokenizeStart("( ) [ ] { } = : ,");
}

var _SFOUT,_SFDONE,_SFFIRST,_SFINDENT;
function sfout(S) {
  _SFOUT.push(S);
  return S;
}
function sfresult() {
  return _SFOUT.join("");
}
function sfattrs(O) {
  return RES=Object.getOwnPropertyNames(O).concat(Object.getOwnPropertySymbols(O)).filter(function (X) {
               return X!=SymbolUp && X!=SymbolCont && X!="TO" 
                   && X!="length" && (!isNumStr(X) || !isAtom(O));
             });
}
function serializefBis(O,MODE,MODES) {

  var ISFIRST,SKIPSPC,SFSDONE;
  function sfslot(N,SMODE) {
    if (isUndefined(SMODE)) SMODE={};
    if ((isAtom(O) && N=="$" || O.hasOwnProperty(N)) && !(N==sy("+o") && sfisHiddenId(O[N]))) {
      var NAME=isSymbol(N)?sy(N):N;
      if (contains(NAME,":")) return;       if (!SKIPSPC) {
        if (_SFLANG=="json" && !ISFIRST) sfout(",");
        if (isDefined(SMODE["nl"])) sfout("\n"+spc(_SFINDENT));
                               else if (_SFLANG=="lisp") sfout(" ");
      }
      SKIPSPC=False;
      sfout(NAME),sfout(_SFLANG=="lisp"?"=":":");
      if (N=="caller" || N=="callee" || N=="arguments") VAL="<Forbidden>";
      else
      if (isAtom(O) && N=="$") VAL=O.valueOf();
                          else VAL=O[N];
      if (N==sy("+o")) sfout(VAL);
                  else serializefBis(VAL,typeOf(VAL)==type?"name"
                                                          :MODE=="flat" && !isAtom(VAL)?"symb":MODE,MODES);
      ISFIRST=False;
      SFSDONE[N]=1;
    }
  }
  if (isNil(O)) return sfout("Nil");
  if (isUndefined(O)) return sfout("Undef");
  if (isBoolean(O)) return sfout(O?"True":"False");
  if (isNumber(O)) return sfout(O.toString());
  if (typeOf(O)==str) return sfout('"'+strEscape(O)+'"');   if (isFunction(O)) return sfout('<Func>');
  if (isArray(O)) {
    ISFIRST=True;
    sfout("[");
    for (var I=0;I<length(O);I++) {
      if (ISFIRST) ISFIRST=False;
              else sfout(_SFLANG=="lisp"?" ":",");
      serializefBis(O[I],typeOf(O[I])==type?"name":MODE=="flat" && !isAtom(VAL)?"symb":MODE,MODES);
    }
    sfout("]");
  }
  else {
    if (isRootAtom(O)) out(pretty(O)),cr(),error("serializefBis(1)");
    if (MODE=="symb" && isUndefined(sfoid(O))) error("serializefBis(undef ID)");
    var DEFINED=isDefined(_SFDONE[sfoid(O)]);
    sfstore(O,True);
    if (!DEFINED) _SFDONE[sfoid(O)]=O;
    if (MODE=="name") {
      if (!isFunction(O.name)) error("serializefBis(name)");
      return sfout(O.name());
    }
    if (DEFINED || MODE=="symb") return sfout("#"+sfoid(O));
    if (_SFLANG=="lisp") sfout("(");
    if (typeOf(O)!=obj) sfout(typeOf(O).name()); else SKIPSPC=True;
    if (_SFLANG=="json") sfout("{"),SKIPSPC=True;
    _SFINDENT+=2;
    SFSDONE={};
    ISFIRST=True;
    for (var I=0;I<length(MODES);I++) sfslot(MODES[I][0],MODES[I][1]);
    if (isAtom(O)) sfslot("$",{});
    for (var N of sfattrs(O)) if (isUndefined(SFSDONE[N])) sfslot(N,{});     if (_SFLANG=="lisp") sfout(")");
                    else sfout("}");
    _SFINDENT-=2;
  }
}
function serializefAllOfType(O,TYPE,MODE,MODES,SETID) {   if (isUndefined(SETID)) SETID=False;
  if (isRootAtom(O) || isFunction(O)) return;
  if (typeOf(O).root()==obj && isDefined(_SFDONE[sfoid(O)])) return;
  if (isArray(O)) {
    for (var I=0;I<length(O);I++) {
      serializefAllOfType(O[I],TYPE,MODE,MODES,SETID);
    }
  }
  else {
    if (SETID) sfstore(O);
    for (var N of sfattrs(O)) {
      if (!isRootAtom(O[N]) && !isArray(O[N]) && MODE!="full") sfstore(O[N]);
    }
    if (!_SFDONE[sfoid(O)] && (TYPE=="*" || typeOf(O)==TYPE)) {
      if (_SFFIRST) _SFFIRST=False;
               else sfout("\n")
      serializefBis(O,MODE,MODES);
    }
    for (var N of sfattrs(O)) {
      serializefAllOfType(O[N],TYPE,MODE,MODES,True);
    }
  }
}
function serializef(O,FMT,LANG) {
  if (isRootAtom(O)) return JSON.stringify(O);
  sfinit();
  if (isUndefined(LANG)) LANG="json";
  _SFLANG=LANG;
  if (LANG!="lisp" && LANG!="json") error("serializef(0)");
  for (var I=0;I<length(FMT);I++) {
    var F=FMT[I],TYPE="*";
    if (F[0]!="*") TYPE=type.getByName(F[0]);
    if (isUndefined(TYPE)) error("serializef(1)");
    serializefAllOfType(O,TYPE,F[1],F[2]);
  }
  if (isArray(O)) {     for (var I=0;I<length(O);I++) if (!_SFDONE[sfoid(O[I])]) {
      if (_SFFIRST) _SFFIRST=False;
               else sfout("\n")
      serializefBis(O[I],"full",[]);
    }
  }
  else serializefAllOfType(O,"*","full",[]);
  sfrelease();
  return sfresult();
}


function linkf(O,CONT) {
  return O;
}


var APIDefault={};
var api=type(Nil,
             { "NAME":"api", "PARENT":obj, "ATTRS":[] });

function isApi(O) {
  return isa(O,api);
}

var server=type(function (PORT,API) {
                  function create(CATEG) {
                    var RES=server.create();
                    RES.IDSRV=server.LASTIDSRV++;
                    RES.CATEG=CATEG;
                    server.SRV.push(RES);
                    return RES;
                  }
                  var RES;
                  if (isNumber(PORT)) {
                    RES=server.getBy("PORT",PORT);
                    if (RES==Nil) {
                      RES=create("l");                       if (isUndefined(API) || typeOf(API)==obj) API=api(API);
                      if (!isApi(API)) error("server.cons(1)");
                      RES.ADDR="0.0.0.0";
                      RES.PORT=PORT;
                      RES.API=API;
                      setPrototypeOf(API,APIDefault);                                                                           }
                  }
                  else
                  if (PORT=="c") {
                    if (!isNumber(API)) error("server.cons(2)");
                    RES=create("c");                     RES.IDSRVPARENT=API;
                  }
                  else {
                    var URL=server.urlNormalize(PORT);
                    if (!isString(URL) || !isUndefined(API)) error("server.cons(3)");
                    RES=server.getBy("HREF",URL);
                    if (RES==Nil) {
                      RES=create("r");                       var URL0=urlParse(URL);
                      RES.HREF=URL;
                      RES.ADDR=URL0.hostname;
                      RES.PORT=JSON.parse(URL0.port==""?"80":URL0.port);
                      var CLI=RES.call("_connect",[]);                       RES.IDCLI=CLI.IDSRV;
                      confExec(CLI.CONF);                     }
                  }
                  return RES;
                },
                { "NAME":"server", "PARENT":obj,
                  "ATTRS":["IDSRV=0","IDCLI","IDSRVPARENT",
                           "CATEG=''","PORT=0",
                           "ADDR=''","HREF=''",
                           "API={}","_RUNNING=Nil",
                           "CONT=[]"] });

server.SRV=[];
server.LASTIDSRV=0; 
setprop(server,"getById",function (ID) {
  return server.SRV[ID];
});
setprop(server,"getBy",function (NAME,VAL) {
  var RES=Nil;
  for (var I in server.SRV) if (server.SRV[I][NAME]==VAL) RES=server.SRV[I];
  return RES;
});

function isServer(O) {
  return isa(O,server);
}
function isLocal(O) {
  return isServer(O) && O.CATEG=="l";
}
function isRemote(O) {
  return isServer(O) && O.CATEG=="r";
}
function isClient(O) {
  return isServer(O) && O.CATEG=="c";
}

setprop(server,"find",function (ADDR,PORT,IDCLI) {
  var RES=Nil;
  for (var I in server.SRV) {
    var SRV2=server.SRV[I];
    if (SRV2.ADDR==ADDR && SRV2.PORT==PORT && SRV2.IDSRV==IDCLI) {
      if (RES!=Nil) error("server.find");       RES=SRV2;
    }
  }
  return RES;
});

setprop(server,"urlApp",function () {
  return server.APP_URL;
});
setprop(server,"urlWeb",function () {
  return server.WEB_URL;
});
setprop(server,"urlNormalize",function (U) {
  return urlNormalize(U,server.urlApp());
});

function _connect(IDSRV) {
  var RES;
  if (isDefined(IDSRV)) {
    RES=server.getById(IDSRV);
    if (isUndefined(RES)) error("_connect(1)");
  }
  else {
    if (isNil(server.currentServer())) error("_connect(2)");
    RES=server("c",server.currentServer().IDSRV);
    RES.ADDR=_REQLOG.ADDR.address;
    RES.PORT=_REQLOG.ADDR.port;
  }
  return { "IDSRV":RES.IDSRV, "CONF":conf(1) };
}

server.setMethod("close",function () {
  if (this.CATEG=="r") this.call("_close",[]);   else
  if (this.CATEG=="c") {     var DONE=False;
    for (var I in server.SRV) if (server.SRV[I]==this) {
      if (DONE) error("server.close");       splice(server.SRV,I,1,[]);
      DONE=True;
    }
  }
});
function _close() {
  var SRV=server.currentClient();
  SRV.close();
  return True;
}

server.setMethod("call",function (FNAME,PARMS,CALLBACK) {
  var RES=Nil;
  if (isLocal(this)) {
      var F=this.API[FNAME];
    if (isFunction(F)) {
      RES=F.apply(Nil,PARMS);
    }
  }
  else
  if (isRemote(this)) {
    PARMS.unshift(this.IDCLI);
    RES=this.send("POST","",JSON.stringify([FNAME,PARMS]),CALLBACK);
  }
  else error("server.call");
  return RES;
});

server.setMethod("send",function (METHOD,PARMS,DATA,CALLBACK) {
  var REQ,RES=null,
      ASYNC=isDefined(CALLBACK);
  function ret(RES) {
    if (RES!=null && (SERVER || REQ.getResponseHeader("Content-Type")=="application/json")) RES=JSON.parse(RES);
    return RES;
  }
  if (!isRemote(this)) error("server.send(!remote)");
  if (SERVER) {
    if (ASYNC) error("server.send(SERVER)::ASYNC");
    else {
      RES=spawn('node',
                ['./bin/httpsend.js',
                 JSON.stringify([this.HREF,DATA])
                ]);
      var L=splitTrim(RES,"\n"),
          HEADERS=JSON.parse(L[0]);
      RES=L[1];
        }
  }
  else {
    if (METHOD!="GET" && !isUndefined(DATA)) DATA=JSON.stringify(DATA);
                                        else DATA=null;
    REQ=new XMLHttpRequest();
    REQ.open(METHOD,this.HREF+(PARMS!=Nil && PARMS!=""?"?"+PARMS:""),ASYNC);
    REQ.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
    REQ.setRequestHeader("Accept","application/json");     REQ.onreadystatechange=function() {
      if (REQ.readyState==4) {
        if (REQ.status==200) {
          RES=REQ.responseText;
          if (ASYNC) CALLBACK(ret(RES));
        }
      }
    }
  }
  if (SERVER) ;          else REQ.send(DATA);
  if (ASYNC) return null;
        else return ret(RES);
});

var _REQLOG=Nil,_CURSRV=Nil;
setprop(server,"currentClient",function () {   if (isNil(_REQLOG)) return Nil;
  var SRV=server.find(_REQLOG.ADDR.address,_REQLOG.ADDR.port,_REQLOG.IDCLI);
  if (!isClient(SRV)) error("server.currentClient");
  return SRV;
});
setprop(server,"currentServer",function () {   return _CURSRV;
});

var http=Undefined;
server.setMethod("start",function () {
  var REQNO=0;
  function req(REQ) {
    var PARMS=urlParse(REQ.url);
    return { "METHOD":REQ.method,
             "PATHNAME":PARMS.pathname,"QUERY":PARMS.query,
             "ADDR":REQ.socket.address(),"RADDR":REQ.socket.remoteAddress,
             "ACCEPT":REQ.headers.accept,"REFERER":REQ.headers.referer,
             "IDCLI":-1
            };
  }
  function log(NO,REQ,BODY,ERR,ANSW) {
    out(REQ.METHOD+"<#"+NO+"><"+
        REQ.ADDR.address+":"+REQ.ADDR.port+"::"+
        REQ.IDCLI+" "+REQ.PATHNAME+" "+REQ.QUERY+">");
    if (REQ.METHOD=="GET") out("[]"); else out(BODY.toString());
    cr(),out("["+JSON.stringify(ERR)+"]=> ");
    if (REQ.METHOD=="GET") out("..."); else out(ANSW);
    cr(),cr();
  }
  var THIS=this;
  function handler(REQ,ANSW) {
    var REQLOG=_REQLOG=req(REQ);
    _CURSRV=THIS;
    function ret(ERR,CTYPE,MSG,RES,BIN) {
      if (CTYPE=="application/json") RES=isUndefined(RES)?"null":JSON.stringify(RES);
      var SRES=RES;
      if (!BIN && length(SRES)>80 && !conf().LOG_FULLANSW) SRES=substring(RES,0,80)+" ...";
      log(REQNO++,REQLOG,MSG,ERR,SRES);
      ANSW.writeHead(ERR, {'Content-Type': CTYPE,
                           'Access-Control-Allow-Origin': '*'                           });
          if (isDefined(BIN)) ANSW.end(RES);
      else {
        ANSW.write(RES);
        ANSW.end("\n");
      }
      _REQLOG=_CURSRV=Nil;
    }
    if (REQLOG.PATHNAME=="/" && REQ.method=="GET") REQLOG.PATHNAME="/index.html";
    if (!contains(REQLOG.PATHNAME,".")) {       if (REQ.method=="POST") {
        var MSG="",ISOBJ=false;
        REQ.on('data', function (DATA) {
          if (ISOBJ) error("serverCreate(multipart obj)");
          else {
            if (typeOf(DATA)==str) MSG+=DATA;
            else {
              MSG=DATA;
              ISOBJ=true;
            }
          }
        });
        REQ.on('end',function () {
          if (ISOBJ) MSG=JSON.parse(MSG.toString());
          var PARMS=JSON.parse(MSG);
          REQLOG.IDCLI=PARMS[1].shift();
          var RES=THIS.call(PARMS[0],PARMS[1]);           ret(200,"application/json",MSG,RES);
        });
      }
      else
      if (REQ.method=="GET") {
        ret(200,"application/json","",{ _type:"error", MSG:"RPCs must be POST"});
      }
    }
    else {
      function rd(PATH,BIN,FUNC) {
        if (BIN) fs.readFile(PATH,FUNC);             else fs.readFile(PATH,'utf-8',FUNC);
      }
      var BIN=False;
      if (contains(["jpg","png","gif"], fileExt(REQLOG.PATHNAME))) BIN=True;
      rd(conf().WEB+'/'+REQLOG.PATHNAME,BIN,function(ERR,DATA) {
        ;         if (ERR) {
          ret(404,"text/html","",'<h1>Page Not Found</h1>');
        }
        else { 
          var MIME="text/html", EXT=fileExt(REQLOG.PATHNAME);
          if (endsWith(REQLOG.PATHNAME,".css")) MIME="text/css";
          if (contains(["jpg","png","gif"],EXT)) MIME="image/"+(EXT=="jpg"?"jpeg":EXT);
          ret(200,MIME,"",DATA,BIN);
        }
      });
    
    }
  }
  if (!isNil(this._RUNNING)) error("server.start");
  var SRV=http.createServer(handler);
  this._RUNNING=SRV;
  SRV.on('connection', function (SOCK) { SOCK.unref(); });
  SRV.listen(this.PORT,"0.0.0.0");
});

server.setMethod("stop",function () {
  if (isNil(this._RUNNING)) error("server.stop");
  this._RUNNING.close();
  this._RUNNING=Nil;
});

server.setMethod("attach",function (CONT) {
  if (!isContainer(CONT) || isDefined(CONT.SRV)) error("server.attach");
  this.CONT[CONT.IDCONT]=CONT;
  CONT.SRV=this;
});

server.setMethod("container",function (NAME,FOP) {
  if (FOP) {
    var CONT=this.container(NAME);
    if (isNil(CONT)) {
      CONT=container(NAME,this);
    }
    return CONT;
  }
  else return find(this.CONT,function (X) { return isDefined(X) && X.NAME==NAME });
});
function _fetchconts() {
  return RES=server.currentClient().containers(True).map(function (C) {
    return {"NAME":C.NAME};
  });
}
server.setMethod("containers",function (FETCH) {
  if (FETCH) {
    if (isLocal(this)) ;
    else
    if (isRemote(this)) {
      var L=this.call("_fetchconts",[]);
      for (var C of L) {
        this.container(C.NAME,True);
      }
    }
    else
    if (isClient(this)) {
      var SRV=server.getById(this.IDSRVPARENT);
      for (var C of SRV.containers()) {
        if (isString(C.NAME) && C.NAME!="") {
          this.container(C.NAME,True);
        }
      }
    }
    return this.containers();
  }
  else return this.CONT.filter(function (X) { return isDefined(X); });
});

function _grep(NAME,Q) {
  var CONT=server.getById(server.currentClient().IDSRVPARENT).container(NAME);
  if (isNil(CONT)) error("_grep");
  return serialize(CONT.query(Q),"flat*");
}

function _syncobjs(NAME,S) {
  var CONT=server.getById(server.currentClient().IDSRVPARENT).container(NAME);
  if (isNil(CONT)) error("_syncobjs");
  parse(S,CONT);
  return True;
}

function _srvls() {
  var T={ "l":"LOC", "r":"REM", "c":"CLI" };
  function cls(CONT) {
    outd(CONT.IDCONT),out(" ");
    outd(CONT.SRV.IDSRV),out(" [");
    outd(CONT.NAME),out(";");
    outd(CONT.FNAME),out("]");
  }
  function ls(SRV) {
    out(T[SRV.CATEG]),
    out(" "),outd(SRV.IDSRV);
    out(" "),outd(SRV.IDCLI);
    out(" "),outd(SRV.HREF);
    out(" "),outd(SRV.ADDR);
    out(" "),outd(SRV.PORT);
    for (var C of SRV.containers()) cr(),out("  "),cls(C);
  }
  for (var I in server.SRV) ls(server.SRV[I]),cr();
  return Nil;
}

function serversInit() {
  if (SERVER) {
    http=require('http');
    APIDefault={ "_connect": _connect,
                 "_close": _close,
                 "_srvls": _srvls,
                 "_fetchconts": _fetchconts,
                 "_grep": _grep,
                 "_syncobjs": _syncobjs
               };
  }
  else {
    var U=urlSelf();
    if (U.protocol=="file:") U=urlParse("http://localhost");
    var PATH=U.pathname,A=splitTrim(PATH,"/"),I=length(A)-1,HASWEB=False;
    if (endsWith(A[I],".html")) {
      I--;
      if (I>=0 && A[I]=="web") HASWEB=True,I--;
      var S="";
      for (var J=1;J<=I;J++) S+="/"+A[J];
      PATH=S;
    }
    U=urlParse(U.origin+PATH);
    server.APP_URL=U.href;
    server.WEB_URL=U.href+(HASWEB?"web":"");
  }
}


function csvparseObjVals(S) {
  var A=tokenize(S,True);
  if (length(A)==0) error("csvparseObjVals");
  var EXP="v",I=0,RES=[];
  while (I<length(A)) {
    if (EXP=="v") {
      var VAL="";
      while (I<length(A) && A[I]!=",") VAL+=A[I],I++;
      RES.push(VAL);
      EXP="s";
    }
    else {
      if (A[I]!=",") out(A[I]),error("csvparseObjVals(2)");
      I++;
      EXP="v";
      if (I>=length(A)) RES.push("");
    }
  }
  return RES;
}
function csvparseObj(S,TYPE,SLOT,CONT) {
  var A=csvparseObjVals(S),O={};
  if (length(A)!=length(SLOT)) out(display(A)),cr(),out(display(SLOT)),cr(),error("csvparse");
  for (var I=0;I<length(A);I++) {
    var VAL=A[I];
    if (length(VAL)>1 && VAL[0]=='"' && VAL[length(VAL)-1]=='"') VAL=trim(VAL,'"',True,True);
    O[SLOT[I]]=VAL;
  }
  return TYPE(O,CONT);
}
function csvparsef(S,CONT,TYPE) {
  csvparsefStart();
  var A=splitTrim(S,"\n"),RES=[];
  if (length(A)==0) error("csvparsef");
  var SLOT=splitTrim(A[0],","),
      TYNAME;
  for (var I=0;I<length(SLOT);I++) {     if (I==0) {
      var A2=splitTrim(SLOT[0],"||");
      if (length(A2)>1) TYNAME=A2[0],SLOT[0]=A2[1];
    }
    SLOT[I]=splitTrim(SLOT[I],":")[0];
  }
  if (isType(CONT)) TYPE=CONT,CONT=Undefined;
  if (isDefined(TYNAME) && isUndefined(TYPE)) {
    TYPE=type(Nil,{ NAME:TYNAME, PARENT:obj, ATTRS:SLOT });
  }
  if (isUndefined(TYPE)) TYPE=obj;   RES.push(SLOT);
  for (var I=1;I<length(A);I++) {
    if (length(A[I])==0) continue;
    RES.push(csvparseObj(A[I],TYPE,SLOT,CONT));
  }
  return RES;
}

function csvparsefStart() {
  charsInit();
  charnatSet("'",CharNatAlf);
  charnatSet("(",CharNatAlf);   charnatSet(")",CharNatAlf);
  charnatSet("[",CharNatAlf); 
  charnatSet("]",CharNatAlf);
  charnatSet("?",CharNatAlf);
  charnatSet(".",CharNatAlf);
  charnatSet(";",CharNatAlf);   charnatSet("!",CharNatAlf);   tokenizeStart(",");
  TOKENIZECOMMENTS=False;
}

function csvserializef(L) {
  startOutS();
  var SLOT=L[0];
  for (var I=0;I<length(SLOT);I++) {
    if (I>0) out(",");
    out(SLOT[I]);
  }
  cr();
  var A=splitTrim(SLOT[0],"||");
  if (length(A)>1) SLOT[0]=A[1];
  for (var I=1;I<length(L);I++) {
    for (var J=0;J<length(SLOT);J++) {
      if (J>0) out(",");
      var VAL=L[I][SLOT[J]];
      if (isUndefined(VAL)) VAL="";
      if (contains(VAL,",")) VAL='"'+VAL+'"';
      out(VAL);
    }
    cr();
  }
  var RES=getOutS();
  stopOutS();
  return RES;
}

function csvRawCheck(L) {
  if (!isArray(L)) return False;
  if (length(L)>0) {
    if (!isArray(L[0]) || length(L)==0) return False;
    var N=length(L[0]);
    for (var E of L) {
      if (!isArray(E) || length(E)!=N) return False;
      for (var S of E) if (!isString(S)) return False;
    }
  }
  return True;
}
function csvLoadRaw(FNAME) {
    var TXT=python("csv2db.py",[FNAME]);
  function skipb(I) {
    while (I<length(TXT) && TXT[I]!="\n" && charIsBlank(TXT[I])) I++;
    return I;
  }
  var RES=[],L=[],J=0;
  for (var I=0;I<length(TXT);I++) {
    I=J=skipb(I);
    if (I<length(TXT)) {
      if (TXT[I]=='"' && !(I>0 && TXT[I-1]=="\\")) {
        J=I+1;
        while (J<length(TXT) && !(TXT[J]=='"' && TXT[J-1]!="\\")) {
          if (TXT[J]=="\n") error("csvLoadRaw(2)");
          J++;
        }
        L.push(substring(TXT,I+1,J));
        I=J;
      }
      else
      if (TXT[I]=="\n" || I+1==length(TXT)) {
        if (length(L)>0 && !(length(L)==1 && strIsBlank(L[0]))) RES.push(L);
        L=[];
      }
    }
  }
  if (!csvRawCheck(RES)) error("csvLoadRaw(3)");
  return RES;
}

var csvh=type(function (L,DESCR) {
                function proto(L) {
                  var P=["",[]];
                  if (!isArray(L) || isNil(L[0])) error("csvh.proto");
                  var A=splitTrim(L[0],"||");
                  if (length(A)!=2) error("csvh.proto(2)");
                  P[0]=A[0];
                  L[0]=A[1];
                  for (var I=0;I<length(L);I++) {
                    A=splitTrim(L[I],":");
                    var SLOT;
                    if (length(A)==1) SLOT=[A[0],"str"];
                    else
                    if (length(A)==2) SLOT=[A[0],A[1]];
                                 else error("csvh.proto(3)");
                    P[1].push(SLOT);
                  }
                  return P;
                }
                if (!csvRawCheck(L) || length(L)<=0) error("csvh(1)");
                var CSVH=csvh.create();
                var P=["",[]],ISFULL=contains(L[0][0],"||");
                if (ISFULL) P=proto(L[0]);
                CSVH.NAME=P[0];
                CSVH.TYPE=P[1];
                if (ISFULL) {
                  if (length(L)>1) {
                    for (var I=1;I<length(L);I++) {
                      var LANG;
                      if (contains(L[I][0],"||")) {
                        var A=splitTrim(L[I][0],"||");
                        LANG=A[0];
                        if (!mlstr.isLang(LANG) || length(A)!=2) error("csvh(2)");
                        L[I][0]=A[1];
                      }
                      else LANG="*";
                      if (isDefined(CSVH.TITLES[LANG])) error("csvh(3)");
                      CSVH.TITLES[LANG]=L[I];                     }
                  }
                }
                else {
                  CSVH.TITLES["*"]=L[0];
                  if (length(L)!=1) error("csvh(4)");
                }
                var RES;
                if (DESCR) RES=CSVH;
                      else RES=csvh.find(CSVH);
                if (RES==Nil) {
                  if (!ISFULL) error("csvh: "+pretty(CSVH.TITLES["*"])+" not found");
                  RES=CSVH;
                  csvh.$.push(RES);
                }
                return RES;
              },
              { "NAME":"csvh", "PARENT":obj,
                "ATTRS":["NAME=''",
                         "TYPE=Nil",
                         "TITLES={}"]
              });

csvh.$=[];
setprop(csvh,"find",function (L) {   if (!isCsvh(L)) L=csvh(L,1);
  var RES=Nil;
  for (var CSVH of csvh.$) if (CSVH.match(L)) RES=CSVH;
  return RES;
});
csvh.setMethod("match",function (L) {
  if (!isCsvh(L)) L=csvh(L,1);
  if (L.NAME!="" && this.NAME!=L.NAME) return False;
  function matcht(L1,L2) {
    if (length(L1)!=length(L2)) return False;
    for (var I=0;I<length(L1);I++) if (L1[I][0]!=L2[I][0] || L1[I][1]!=L2[I][1]) return False;
    return True;
  }
  function matchtit(L1,L2) {
    if (length(L1)!=length(L2)) return False;
    for (var I=0;I<length(L1);I++) if (L1[I]!=L2[I]) return False;
    return True;
  }
  if (length(L.TYPE)!=0) {
      if (matcht(this.TYPE,L.TYPE)) return True;
  }
  else {
    var LT=L.TITLES["*"];
    if (length(L.TITLES)!=1 || isUndefined(LT)) error("csvh.match(2)");
    for (var LANG in this.TITLES) {
      if (matchtit(this.TITLES[LANG],LT)) return True;
    }
  }
  return False;
});

function isCsvh(O) {
  return isa(O,csvh);
}

setprop(csvh,"load",function (FNAME) {
  var L=csvLoadRaw(FNAME);
  return csvh(L);
});

var csv=type(function (L) {
               RES=csv.create();
               if (!isArray(L) || isNil(L[0])) error("csv");
               RES.CSVH=L.shift();
               RES.$=L;
               return RES;
             },
             { "NAME":"csv", "PARENT":obj,
               "ATTRS":["CSVH=Nil",
                        "$=[]"]
             });

function isCsv(O) {
  return isa(O,csv);
}

setprop(csv,"load",function (FNAME) {
  var L=csvLoadRaw(FNAME);
  L[0]=csvh([L[0]]);
  return csv(L);
});
csv.setMethod("toDb",function () {
  var CSVH=this.CSVH,L=this.$,
      RES='(type NAME="'+CSVH.NAME+'" PARENT="obj" ATTRS=[',
      FIRST=True;
  for (var I=0;I<length(CSVH.TYPE);I++) {
    var NAME=CSVH.TYPE[I][0];
    if (!contains(NAME,".")) {
      if (!FIRST) RES+=" ";
      var TY=CSVH.TYPE[I][1];
      if (TY!="str") RES+='"';
      RES+=NAME;
      if (TY!="str") RES+=":"+TY+'"';
      FIRST=False;
    }
  }
  RES+="])\n";
  for (var I=0;I<length(L);I++) {
    var S="("+CSVH.NAME;
    for (var J=0;J<length(CSVH.TYPE);J++) S+=" "+CSVH.TYPE[J][0]+'="'+L[I][J]+'"';
    RES+=S+" +o="+(I+1)+")\n";
  }
  return RES;
});


var container=type(function (NAME,FNAME,CATEG,SRV) {
                     var RES=container.create();
                     RES.IDCONT=container.LASTIDCONT++;
                     if (isString(NAME) && isString(FNAME)) {                        if (!isString(CATEG)) SRV=CATEG,CATEG=FNAME,FNAME=NAME,NAME=Undefined;
                       RES.load(FNAME,CATEG);
                     }
                     else
                     if (isContainer(NAME) || isContainer(FNAME)) {                        var CONT=FNAME;
                       if (isContainer(NAME)) CONT=NAME,NAME=Undefined,SRV=FNAME;
                       else {
                         if (!isString(NAME)) error("container.cons(1)");
                         SRV=CATEG;
                       }
                       RES.setParent(CONT);
                       error("container.derived(!Yet)");
                     }
                     else
                     if (isUndefined(NAME) || isString(NAME) || isServer(NAME)) {                        if (isServer(NAME)) SRV=NAME;
                       else {
                         SRV=FNAME;
                       }
                     }
                     else error("container.cons(2)");
                     RES.NAME=NAME;
                     if (!isUndefined(SRV)) {
                       if (!isServer(SRV)) error("container.cons(3)");
                       SRV.attach(RES);
                     }
                     return RES;
                   },
                   { "NAME":"container", "PARENT":obj,
                     "ATTRS":["SRV",
                              "IDCONT","PARENT",
                              "NAME","FNAME=''",
                              "LASTID=0",
                              "QMETHODS={}",
                              "$={}"] });

container.LASTIDCONT=0; 
function isContainer(O) {
  return isa(O,container);
}

container.setMethod("getById",function (ID) {
  return this.$[ID];
});
container.setMethod("parent",function () {
  return this.PARENT;
});
container.setMethod("setParent",function (CONT) {
  if (!isContainer(CONT)) error("setParent");
  this.PARENT=CONT;
});
container.setMethod("qmethod",function (NAME) {
  return this.QMETHODS[NAME];
});
container.setMethod("setQMethod",function (NAME,FUNC) {
  this.QMETHODS[NAME]=FUNC;
});

var SymbolCont=sy("^$"),
    SymbolId=sy("+o"),
    SymbolFlags=sy("%"),
    SymbolUp=sy("^");

obj.setMethod("containerOf",function () {
  return this[SymbolCont];
});
obj.setMethod("setContainerOf",function (CONT) {
  if (!isContainer(CONT)) error("setContainerOf");
  if (this.containerOf()) error("setContainerOf(2)");
  this[SymbolCont]=CONT;
  CONT.$[this.getId()]=this;
});
obj.setMethod("getId",function () {
  return this[SymbolId];
});
obj.setMethod("setId",function (ID) {
  var CONT=this.containerOf(),ID0=this.getId();
  if (ID0 && !isNil(CONT)) {
    delete CONT.$[ID0];
  }
  this[SymbolId]=ID;
  if (ID0 && !isNil(CONT)) {
    if (!isUndefined(CONT.$[ID])) error("obj.setId");
    CONT.$[ID]=this;
  }
});
obj.setMethod("flags",function () {
  var F=this[SymbolFlags];
  if (isNil(F)) return set(""); else return F;
});
obj.setMethod("hasFlags",function (F) {
  return this.flags().has(F);
});
obj.setMethod("setFlags",function (FLAGS) {
  if (isString(FLAGS)) FLAGS=oflags(FLAGS);
  this[SymbolFlags]=FLAGS;
  if (this[SymbolFlags]=="") delete this[SymbolFlags];
});
obj.setMethod("addFlags",function (FLAGS) {
  if (isUndefined(this.flags())) this.setFlags(FLAGS);
                            else this.setFlags(this.flags().union(FLAGS));
});
obj.setMethod("delFlags",function (FLAGS) {
  if (isDefined(this.flags())) this.setFlags(this.flags().minus(FLAGS));
});
obj.setMethod("up",function (CLOSEST,FULLREF) {
  var UP=this[SymbolUp];
  if (UP) {
    if (!CLOSEST && isArray(UP[0]) && isNumStr(UP[1])) {
      var UP2=UP[0].up(True,True),A;
      if (isDefined(UP2)
       && isDefined(A=typeOf(UP2[0]).attr(UP2[1]))
       && A.has("*>")) return FULLREF?[UP2[0],UP2[1],UP[1]]:UP2[0];
    }
    if (!FULLREF) return UP[0];
  }
  return UP;
});
obj.setMethod("upa",function () {
  var UP=this.up(True,True);
  if (isUndefined(UP)) return Undefined;
  var A=typeOf(UP[0]).attr(UP[1]);
  return A;
});
obj.setMethod("multiA",function () {   if (!isArray(this)) return Undefined;
  var A=this.upa();
  return isDefined(A) && A.has("*")?A:Undefined;
});
obj.setMethod("setUp",function (NEWUP,NAME) {
  if (!isUndefined(NEWUP) && !isObject(NEWUP)) error("setUp(1)");
  var UP=this.up(True,True);
  if (!isUndefined(UP)) {
    if (UP[0][UP[1]]!=this) error("setUp(2)");
    UP[0][UP[1]]=Undefined;
    }
  if (isUndefined(NEWUP)) this[SymbolUp]=Undefined;
                     else this[SymbolUp]=[NEWUP,NAME];
});
obj.setMethod("detach",function () {
  this.setUp(Undefined);
});

container.setMethod("newId",function () {
  return this.LASTID++;  });
container.setMethod("store",function (O,ID,UP,UPNAME) {
  if (isUndefined(ID)) ID=this.newId();
  else
  if (isNumStr(ID)) this.LASTID=num(ID)+1;   O.setId(ID);
  O.setUp(UP,UPNAME);
  O.setContainerOf(this);
});

obj.setMethod("getv",function (NAME) {
  return this[NAME];
});
obj.setMethod("setv",function (NAME,VAL) {   if (!isString(NAME) && !isNumber(NAME)) error("setv::"+NAME);   if (this[NAME]==VAL) return;
  var A=typeOf(this).attr(NAME),
      MA=this.multiA(),
      NUM=isNumStr(NAME),
      SAMECONT=isUnboxed(VAL) || this.containerOf()==VAL.containerOf();
  if (NUM && isDefined(MA) && MA.has(">") || isDefined(A) && A.has(">")) {     if (NUM && SAMECONT && isDefined(MA) && MA.has("!") || isDefined(A) && A.has("!")) {       if (isBoxed(this[NAME])) this[NAME].detach();
    }
    else {
      if (isBoxed(VAL) && (!SAMECONT || isDefined(VAL.up()))) VAL=copy(VAL,this.containerOf());
    }
    if (isBoxed(VAL)) VAL.setUp(this,NAME);
  }
  this[NAME]=VAL;
});

obj.setMethod("remove",function (NAME,N) {
  function rm(A,I) {
    var VAL=A[I];
    if (isBoxed(VAL) && VAL.up(True)==A) VAL.detach();
  }
  if (isArray(this) && isNumStr(NAME)) {
    if (isUndefined(N)) N=1;
    if (NAME<0 || NAME>=length(this) || NAME+N>length(this)) error("obj.remove");
    var M=N;
    while (M--) {
      rm(this,NAME);
      this.splice0(NAME,1);
    }
    for (var I=NAME;I<length(this);I++) {
      var VAL=this[I],UP;
      if (isBoxed(VAL)) UP=VAL.up(True,True);
      if (isDefined(UP)) UP[1]-=N;
    }
  }
  else {
    rm(this,NAME);
    delete this[NAME];
  }
});
obj.setMethod("cut",function (NAME,N) {   var NDEF=True,RES=[];
  if (isUndefined(N)) N=1,NDEF=False;
  if (isArray(this) && isNumStr(NAME)) {
    if (NAME<0 || NAME>=length(this) || NAME+N>length(this)) error("obj.cut");
    for (var I=NAME;I<NAME+N;I++) RES.push(this[NAME]);
  }
  else RES.push(this[NAME]);
  this.remove(NAME,N);
  return NDEF?RES:RES[0];
});

array.setMethod("insert",function (I,...VAL) {   if (!isNumStr(I)) error("array.insert");
  for (var J=0;J<length(VAL);J++) this.splice0(I,0,Undefined);
  var N=length(VAL);
  for (var J=I+N;J<length(this);J++) {
    var UP=this[J].up(True,True);
    if (isDefined(UP)) UP[1]+=N;
  }
  for (var J=0;J<length(VAL);J++) this.setv(I+J,VAL[J]);
});
array.setMethod("push0",array.method("push"));
array.setMethod("push",function (VAL) {
  var A=this.upa();
  if (isUndefined(A)) return this.push0(VAL);
  this.insert(length(this),VAL);
  return VAL;
});

array.setMethod("splice0",array.method("splice"));
array.setMethod("splice",function (I,N,...VAL) {
  var A=this.upa();
  if (isUndefined(A)) return this.splice0(I,N,...VAL);
  var RES=this.cut(I,N);
  this.insert(I,...VAL);
  return RES;
});

obj.setMethod("first",function () {
  if (isArray(this)) return this[0];
  else {
    if (!this.$) error("obj.first");
    return this.$[0];
  }
});
obj.setMethod("last",function () {
  if (isArray(this)) return this[length(this)-1];
  else {
    if (!this.$) error("obj.last");
    return this.$[length(this.$)-1];
  }
});

obj.setMethod("prev",function () {
  error("obj.prev (!Yet)");
});
obj.setMethod("next",function () {
  var UP=this.up(True,True);
  if (!UP || !isArray(UP[0])) return Undefined;
  return UP[0][UP[1]+1]; });

container.setMethod("copy",function (O,MODE) {   if (isUndefined(MODE)) MODE="flat";
  var T=typeOf(O);
  function cons(O,CONT) {
    if (T.root()==obj) return T(CONT);
                  else return T(O,CONT);
  }
  if (isUnboxed(O) || isFunction(O) || isType(O)) return O;
  var ISARR=isArray(O);
  var RES=cons(O,this);
  for (var N of sfattrs(O)) {
    var VAL=O[N],PO=True;
    if (!(ISARR && isNumStr(N))) PO=T.attrHas(N,">");
    var VAL2=VAL;
    if (isBoxed(VAL) && MODE=="flat" && !PO) error("copy(!PO)::"+N);     if (isBoxed(VAL) && (MODE=="full" || PO)) {
      VAL2=this.copy(VAL,MODE);
      if (isArray(VAL2) && PO) {
        for (var I=0;I<length(VAL2);I++) {
          var ELT=VAL2[I];
          if (isBoxed(ELT)) ELT.setUp(VAL2,N);
        }
      }
    }
    RES.setv(N,VAL2);
  }
  return RES;
});
container.setMethod("move",function (O,MODE) {
  var RES=this.copy(O,MODE);
  O.delete(MODE);
  return RES;
});

container.setMethod("load",function (FNAME,CATEG) {   if (!isNil(this.FNAME) && this.FNAME!="") error("container.load");
  this.FNAME=FNAME+"."+CATEG;
  var S=fileRead(this.FNAME);
  if (CATEG=="db") {
    parsef(S,this,"lisp");
  }
  else
  if (CATEG=="csv") {
    csvparsef(S,this);
  }
  else error("container.load(2)");
});
container.setMethod("save",function () {   if (isNil(this.FNAME)) error("container.save");
  var L=[];
  for (N in this.$) L.push(this.$[N]);
  var S;
  if (fileExt(this.FNAME)=="db") {
    var S=serializef(L,[],"lisp");
  }
  else error("container.save(2)");
  fileWrite(this.FNAME,S+"\n");
});

var query=type(function (VARS,OBJ) {
                 var RES=query.create();
                 if (isUndefined(OBJ)) OBJ=VARS,VARS=Undefined;
                 if (isUndefined(VARS)) VARS=["*"];
                 if (!isObject(OBJ)) error("query");
                 RES.VARS=VARS;
                 RES.QUERY=OBJ;
                 return RES;
               },
               { "NAME":"query", "PARENT":obj, "ATTRS":["VARS=[]","QUERY={}"] });

function isQuery(O) {
  return isa(O,query);
}

query.setMethod("match",function (O,Q) {
  if (isAtom(O)) {
    if (!isString(O)) O=str(O);
    if (!isString(Q)) error("query.match::str");
    return strMatch(O,Q[0]=="'"?substring(Q,1,length(Q)-1):Q);
  }
  if (!isObject(O)) return False;
  var RES=True;
  if (typeOf(this.QUERY)==array) {
    var CONT=O.containerOf();
    if (isDefined(CONT)) {
      var M=CONT.qmethod(this.QUERY[0]);
      if (isUndefined(M)) error("query.match::qmethod(1)");
      RES=M(O,...acopy(this.QUERY,1,length(this.QUERY)));
    }
    else error("query.match::qmethod(2)");
  }
  else
  for (VAR in this.QUERY) {
    if (!this.match(O[VAR],this.QUERY[VAR])) RES=False;
  }
  return RES;
});
container.setMethod("query",function (VARS,QUERY,FETCH) {
  if (typeOf(VARS)==obj || isQuery(VARS)) {
    FETCH=QUERY;
    QUERY=VARS;
    VARS=Undefined;
  }
  if (!isQuery(QUERY)) {
    QUERY=query(VARS,QUERY);
  }
  if (FETCH && isRemote(this.SRV)) {
    var S=this.SRV.call("_grep",[this.NAME,QUERY.QUERY]);
    return parse(S,this);
  }
  else
  if (typeOf(QUERY.QUERY)==array && QUERY.QUERY[0]=="!") {
    var TYPE=QUERY.QUERY[1],O=QUERY.QUERY[2];
    TYPE=type.getByName(TYPE);
    if (!isType(TYPE)) return [];
    return [TYPE(O,this)];
  }
  else {
    var L=[];
    for (var ID in this.$) {
      var O=this.$[ID];
      if (QUERY.match(O)) L.push(O);
    }

    return L;
  }
});

function isModified(O) {
  return O.hasFlags("m");
}
obj.setMethod("setModified",function (B) {
  if (isUndefined(B) || B) this.addFlags("m");
                      else this.delFlags("m");
});
container.setMethod("sync",function (L,FORCE) {
  if (isUndefined(L)) L=this.$;
  else
  if (typeOf(L)!=array) {
    if (isAtom(L)) FORCE=L,L=this.$;
              else L=[L];
  }
  if (isUndefined(FORCE)) FORCE=False;
  if (isRemote(this.SRV)) {
    if (!FORCE) L=L.filter(isModified);
    for (var O of L) O.setModified(False);
    var PARMS=[this.NAME,serialize(L,"flat*")];
    return this.SRV.call("_syncobjs",PARMS);   }
  else
  if (isClient(this.SRV)) error("container.sync(Client !Yet)");
  else
  if (isLocal(this.SRV)) error("container.sync(Local !Yet)");
                    else error("container.sync");
});

function containersInit() {
  MEMORY=container("memory");
  setprop(MEMORY,"store",function () {});
}


var _CONF;
function conf(CLI) {
  if (isUndefined(CLI)) return _CONF;
                   else return _CONF["[cli]"];
}
function confCompile(CONF) {
  if (!isObject(CONF)) return;
  for (var N in CONF) {
    if (N=="CONT") {
      if (!isArray(CONF[N])) CONF[N]=[CONF[N]];
      var CONT=CONF[N],I;
      for (I in CONT) {
        CONT[I]=splitTrim(CONT[I],";");
        if (length(CONT[I])>1) CONT[I][1]=splitTrim(CONT[I][1]," ");
                          else CONT[I][1]=[];
      }
    }
    if (N=="APP" && length(CONF[N])>0) {
      CONF[N]=splitTrim(CONF[N][0]," ");
      if (CONF[N][0]=="") CONF[N]=[];
    }
  }
}
function confExec(CONF) {
  if (!isObject(CONF)) return;
  for (var N in CONF) {
    if (N=="DEFAULT_LANG") mlstr.setDefault(CONF[N]);
    if (N=="LANG") mlstr.setLang(CONF[N]);
  }
}

function confInit(PROJ,EXEC) {
  _CONF={ "[cli]":{}, "CONT":[], "APP":[] };
  if (SERVER) {
    if (EXEC) _CONF.CWD=processCwd();
    _CONF.PROJ=isString(PROJ)?PROJ:filePath(fnameNormalize(process.argv[1]));
    if (fileName0(_CONF.PROJ)=="bin") _CONF.PROJ=filePath(_CONF.PROJ);     _CONF.LIB=_CONF.PROJ;
    if (fileExists(_CONF.PROJ+"/lib")) _CONF.LIB=_CONF.PROJ+"/lib";
    _CONF.SRC=_CONF.PROJ;
    if (fileExists(_CONF.PROJ+"/src")) _CONF.SRC=_CONF.PROJ+"/src";
    _CONF.DATA=_CONF.PROJ;
    if (fileExists(_CONF.PROJ+"/data")) _CONF.DATA=_CONF.PROJ+"/data";
    _CONF.BIN=_CONF.PROJ;
    if (fileExists(_CONF.PROJ+"/bin")) _CONF.BIN=_CONF.PROJ+"/bin";
    _CONF.BUILD=_CONF.PROJ;
    if (fileExists(_CONF.PROJ+"/build")) _CONF.BUILD=_CONF.PROJ+"/build";
    _CONF.CONF=_CONF.PROJ;
    if (fileExists(_CONF.PROJ+"/conf")) _CONF.CONF=_CONF.PROJ+"/conf";
    _CONF.DOC=_CONF.PROJ;
    if (fileExists(_CONF.PROJ+"/doc")) _CONF.DOC=_CONF.PROJ+"/doc";
    _CONF.WEB=_CONF.PROJ;
    if (fileExists(_CONF.PROJ+"/web")) _CONF.WEB=_CONF.PROJ+"/web";
    if (fileExists(_CONF.CONF+"/BOOT.ini")) {
      var L=splitTrim(fileRead(_CONF.CONF+"/BOOT.ini"),"\n"),L2=[],L3=[],SECTION="srv";
      for (var S of L) {
        S=trim(S);
        if (S[0]=="[") SECTION=lcase(trim(replaceAll(S," ",""),"[]"));
        else
        if (S!="" && S[0]!="#") {
          if (contains(SECTION,"srv")) L2.push(S);
          if (contains(SECTION,"cli")) L3.push(S);
        }
      }
      function rd(O,L) {
        for (var S of L) {
          var A=splitTrim(S,"=");
          if (length(A)!=2) error("confInit(1)");
          for (var S2 of ["CWD","PROG","PROJ","SRC","DATA","BIN","BUILD","LIB","CONF","DOC","WEB"]) {
            if (A[0]==S2) error("confInit::predef-->",S);
          }
          if (strIsNum(A[1])) A[1]=eval(A[1]);           if (isUndefined(O[A[0]])) O[A[0]]=A[1];
          else {
            if (!isArray(O[A[0]])) O[A[0]]=[O[A[0]]];
            O[A[0]].push(A[1]);
          }
        }
      }
      rd(_CONF,L2);
      rd(_CONF["[cli]"],L3);
        }
  }
  confCompile(_CONF);
  confCompile(_CONF["[cli]"]);
  if (EXEC) confExec(_CONF);
}
function confFetch(PROG) {
  var _CONF0=_CONF;
  confInit(PROG)
  var RES=_CONF;
  _CONF=_CONF0;
  return RES;
}


var project=type(function (PATH,APPS,NOLINK) {
                   var RES=project.getBy("PATH",PATH);
                   if (RES==Nil) {
                     var RES=project.create();
                     RES.NAME=fileName(PATH);
                     RES.PATH=PATH;
                     if (!fileExists(PATH)) error("project()::Directory "+PATH+" does not exists");
                     if (!fileIsDir(PATH)) error("project()::File "+PATH+" is not a directory");
                     RES.CONF=confFetch(PATH);
                     project.$.push(RES);
                   }
                   return RES;
                 },
                 { "NAME":"project", "PARENT":obj,
                   "ATTRS":["NAME=''","PATH=''","CONF={}"] });

project.$=[];
setprop(project,"getBy",function (NAME,VAL) {
  var RES=Nil;
  for (var I in project.$) if (project.$[I][NAME]==VAL) RES=project.$[I];
  return RES;
});

function isProject(O) {
  return isa(O,project);
}

setprop(project,"cwp",function () {
  return project.CWP;
});
setprop(project,"setCwp",function (PROJ) {
  if (isDefined(PROJ) && !isProject(PROJ)) error("project.setCwp");
  project.CWP=PROJ;
});

project.setMethod("toDb",function (FNAME) {
  var CSV=csv.load(FNAME),
      TXT=CSV.toDb();
  fileWrite(filePath(FNAME)+"/"+fileName(FNAME)+".db",TXT);
});
project.setMethod("toHtml",function (FNAME) {
  var S=fileRead(FNAME),
      TYRES=[],
      TXT=jxml.toHtml(S,TYRES);
  if (TYRES[0]!="html") error("project.toHtml::jxml=>js !Yet");
  fileWrite(filePath(FNAME)+"/"+fileName(FNAME)+".html",TXT);
});

function ffname(S,CONF,LOC) {
  if (CONF[LOC]!=CONF.PROJ) S=substring(CONF[LOC],length(CONF.PROJ)+1,
                                                  length(CONF[LOC]))+"/"+fileName0(S);
  return S;
}
project.setMethod("build",function (LWEIGHT) {
  if (LWEIGHT) {     var DATA=fs.readdirSync(this.CONF.DATA),
        WEB=fs.readdirSync(this.CONF.WEB);
    for (var FNAME of DATA) if (fileExt(FNAME)=="csvh") {
      out("Loading "+ffname(FNAME,this.CONF,"DATA")),cr();
      csvh.load(this.CONF.DATA+"/"+FNAME);
    }
    for (var FNAME of DATA) if (fileExt(FNAME)=="csv") {
      out("Generating "+fileName(ffname(FNAME,this.CONF,"DATA"))+".db ..."),cr();
      this.toDb(this.CONF.DATA+"/"+FNAME);
    }
    for (var FNAME of WEB) if (fileExt(FNAME)=="jxml") {
      out("Generating "+fileName(ffname(FNAME,this.CONF,"WEB"))+".html ..."),cr();
      this.toHtml(this.CONF.WEB+"/"+FNAME);
    }
  }
  else {} });

project.setMethod("release",function () {   var CONF=this.CONF,
      PROJ=fs.readdirSync(CONF.PROJ);
  function copy(FNAME) {
    out("Releasing "+FNAME+" ..."),cr();
    fileCopy(CONF.PROJ+"/"+FNAME,CONF.PROJ+"/release/"+FNAME,"binary");
  }
  if (fileExists(CONF.PROJ+"/release")) {
    if (!fileIsDir(CONF.PROJ+"/release")) error("File "+CONF.PROJ+"/release is not a directory");
  }
  else dirCreate(CONF.PROJ+"/release");
  if (contains(PROJ,"BOOT.ini")) copy("BOOT.ini");
  for (var FNAME of PROJ) if (fileExt(FNAME)=="js"
                            && !contains(["build","release"],fileName(FNAME))) copy(FNAME);
  for (var FNAME of PROJ) if (fileExt(FNAME)=="db") copy(FNAME);
  for (var FNAME of PROJ) if (contains(["html","css"],fileExt(FNAME))) copy(FNAME);
  for (var FNAME of PROJ) if (contains(["gif","png","jpg"],fileExt(FNAME))) copy(FNAME);
});

if (SERVER) {
  project.JIXPATH=env("JIX_HOME");   if (isDefined(project.JIXPATH)) project.JIXPROJ=project(project.JIXPATH);
}


function event(TAG,TARGET,PAYLOAD) {
  this.TAG=TAG;
  this.TARGET=TARGET;
  this.PAYLOAD=PAYLOAD;
  this.X=this.Y=0;
}
var _LASTEVENT=null;

var KeyReturn=0x1000+13,
    KeyEscape=0x1000+27,
    KeyLeft  =0x1000+37,     KeyRight =0x1000+39,
    KeyDown  =0x1000+40,
    KeyUp    =0x1000+38,
    KeyClick =0x1000+200,
    KeyMove =0x1000+201;

var ASCII=[[],[]];
for (var I=0;I<=255;I++) ASCII[0][I]=ASCII[1][I]=null;
for (var I=65;I<=91;I++) ASCII[0][I]=I+32; for (var I=65;I<=91;I++) ASCII[1][I]=I;    ASCII[0][KeyReturn%0x1000]=ASCII[1][KeyReturn%0x1000]=KeyReturn;
ASCII[0][KeyEscape%0x1000]=ASCII[1][KeyEscape%0x1000]=KeyEscape;
ASCII[0][KeyLeft%0x1000]=ASCII[1][KeyLeft%0x1000]=KeyLeft;
ASCII[0][KeyRight%0x1000]=ASCII[1][KeyRight%0x1000]=KeyRight;
ASCII[0][KeyDown%0x1000]=ASCII[1][KeyDown%0x1000]=KeyDown;
ASCII[0][KeyUp%0x1000]=ASCII[1][KeyUp%0x1000]=KeyUp;
ASCII[0][KeyClick%0x1000]=ASCII[1][KeyClick%0x1000]=KeyClick;
ASCII[0][KeyMove%0x1000]=ASCII[1][KeyMove%0x1000]=KeyMove;

function keyboardGetAscii(SHIFT,CHAR,KEY) {
  if (CHAR!=0 && CHAR>=32) return CHAR;
                      else return ASCII[SHIFT?1:0][KEY];
}
function keyboardIsChar(KEY) {
  return KEY<0x1000;
}

function shift() { return _LASTEVENT.SHIFT; }
function ctrl() { return _LASTEVENT.CTRL; }
function alt() { return _LASTEVENT.ALT; }
function mouseX() { return _LASTEVENT.X; }
function mouseY() { return _LASTEVENT.Y; }

function keyToStr(KEY) {
  if (isString(KEY)) return KEY;
  if (keyboardIsChar(KEY)) return chr(KEY);
  switch (KEY) {
    case KeyReturn: return "return";
    case KeyEscape: return "escape";
    case KeyLeft: return "left";
    case KeyRight: return "right";
    case KeyDown: return "down";
    case KeyUp: return "up";
    case KeyClick: return "click";
    case KeyMove: return "move";
  }
  return Nil;
}
function strToKey(S) {
  if (!isString(S)) error("strToKey");
  if (length(S)==1) {
    var KEY=asc(S[0]);
    if (KEY==10) return KeyReturn;
    return KEY;
  }
  if (S=="return") return KeyReturn;
  if (S=="escape") return KeyEscape;
  if (S=="left") return KeyLeft;
  if (S=="right") return KeyRight;
  if (S=="down") return KeyDown;
  if (S=="up") return KeyUp;
  if (S=="click") return KeyClick;
  if (S=="move") return KeyMove;
  return Nil;
}


var ELEMENT_NODE=1,
    ATTRIBUTE_NODE=2,
    TEXT_NODE=3,
    CDATA_SECTION_NODE=4,
    ENTITY_REFERENCE_NODE=5,
    ENTITY_NODE=6,
    PROCESSING_INSTRUCTION_NODE=7,
    COMMENT_NODE=8,
    DOCUMENT_NODE=9,
    DOCUMENT_TYPE_NODE=10,
    DOCUMENT_FRAGMENT_NODE=11,
    NOTATION_NODE=12;

var DomElement;

if (SERVER) {
  var physdom=type(function (TAG,VAL) {
                if (!isString(TAG)) error("physdom.cons(0)");
                var RES=physdom.create();
                if (TAG=="#text") {
                  if (!isString(VAL)) error("physdom.cons(1)");
                  RES.nodeType=TEXT_NODE;
                }
                else {
                                  RES.nodeType=ELEMENT_NODE;
                  RES.nodeName=TAG;
                  RES.childNodes=[];
                  RES.style={};
                }
                return RES;
              },
              { "NAME":"physdom", "PARENT":obj, "ATTRS":["nodeType","nodeName","childNodes"] });
}
else {
  function physdom(TAG,VAL) {
    if (!isString(TAG)) error("physdom.cons(0)");
    if (TAG=="#text") {
      if (!isString(VAL)) error("physdom.cons(1)");
      return document.createTextNode(VAL);
    }
    else {
          return document.createElement(TAG);
    }
  }
}

function isPhysDomTextNode(O) {
  return O.nodeType==TEXT_NODE;
}
function isPhysDomElement(O) {
  if (SERVER) return O.nodeType==ELEMENT_NODE;
         else return isa0(O,DomElement);
}

setprop(physdom,"getById",function (ID) {
  if (SERVER) return Undefined;          else return document.getElementById(ID);
});
setprop(physdom,"getByName",function (NAME) {
  if (SERVER) return [];          else return document.getElementsByTagName(NAME);
});

if (SERVER) {
  physdom.setMethod("getAttribute",function (NAME) {
    return this[lcase(NAME)];
  });
  physdom.setMethod("setAttribute",function (NAME,VAL) {
    this[lcase(NAME)]=VAL;
  });
  physdom.setMethod("appendChild",function (E) {
  });
  physdom.setMethod("insertBefore",function (NEW,E) {
  });
  physdom.setMethod("replaceChild",function (E,OLD) {
  });
  physdom.setMethod("removeChild",function (E) {
  });
}

function physdomInit() {
  if (!SERVER) {
    DomElement=prototype(prototype(prototype(prototype(document.createElement("div"))))).constructor;   }
}


var ERRO;
var SymbolFrom=sy("<="),
    dom=type(function (O) {
               var DOM;
               if (isString(O)) DOM=physdom("#text",O);
               else
               if (isPhysDomElement(O)) {
                 DOM=O;
                 if (DOM[SymbolFrom]) return DOM[SymbolFrom];
                 ;                }
               else {
                 if (!isType(O) || !O.inherits(html)) ERRO=O,error("dom.cons");
                 DOM=physdom(O.name()=="_input"?"input":O.name());
               }
               var RES=dom.create();
               RES.DOM=DOM;
               DOM[SymbolFrom]=RES;
               return RES;
             },
             { "NAME":"dom", "PARENT":obj });

function isDom(O) {
  return isa(O,dom);
}

dom.setMethod("categ",function () {
  return this.DOM.nodeType;
});
function isDomTextNode(O) {
  return isDom(O) && O.categ()==TEXT_NODE;
}
function isDomElement(O) {
  return isDom(O) && O.categ()==ELEMENT_NODE;
}

setprop(dom,"getById",function (ID) {
  var E=physdom.getById(ID);
  if (E) return dom(E);
  return Undefined;
});
setprop(dom,"getByName",function (NAME,ALL) {
  var L=physdom.getByName(NAME),RES=[];
  for (var E of L) RES.push(dom(E));   return ALL?RES:RES[0];
});

dom.setMethod("tag",function () {
  return lcase(this.DOM.nodeName);
});
dom.setMethod("from",function () {
  return this.FROM; });
dom.setMethod("setFrom",function (W) {
  if (!isHtml(W)) error("dom.setFrom");
  this.FROM=W;
});
dom.setMethod("getv",function (NAME) {   if (isDomElement(this)) return this.DOM.getAttribute(NAME);
  return this[NAME];
});
dom.setMethod("setv",function (NAME,VAL) {
  if (isDomElement(this)) {
    var DOIT=1;
    if (NAME=="hidden") { if (!VAL || VAL=="0") DOIT=0; ERRL=[VAL,DOIT]; }
    if (DOIT) this.DOM.setAttribute(NAME,VAL);
  }
  this[NAME]=VAL;
});

var _DOMFOCUS=Nil;
setprop(dom,"focussed",function () {
  return _DOMFOCUS;
});
setprop(dom,"focus",function (E) {
  E.focus();
  _DOMFOCUS=E;
});

var _SHIFT=False,_CTRL=False,_ALT=False;
setprop(dom,"event",function (EVT) {
  var TARGET=EVT.target;
  if (TARGET.nodeName.toLowerCase()=="html") TARGET=document.getElementsByTagName("body")[0];   var EVT2=new event(EVT.type,TARGET,EVT),EVT3=Nil;
  if (EVT.type=="keydown" || EVT.type=="keyup" || EVT.type=="keypress") {
    if (EVT.shiftKey!=Nil) _SHIFT=EVT.shiftKey;
    if (EVT.ctrlKey!=Nil) _CTRL=EVT.ctrlKey;
    if (EVT.altKey!=Nil) _ALT=EVT.altKey;
    EVT2.KEY=keyboardGetAscii(EVT.shiftKey,EVT.charCode,EVT.keyCode);
    EVT2.SCANCODE=EVT.keyCode;
    if (EVT.type=="keydown" && EVT2.KEY!=Nil
     && EVT.keyIdentifier!=Nil && EVT.keyIdentifier.substring(0,2)!="U+") {       EVT3=new event("keypress",TARGET,EVT);
      EVT3.KEY=EVT2.KEY;
      EVT3.SCANCODE=EVT2.SCANCODE;
      EVT3.SHIFT=_SHIFT;
      EVT3.CTRL=_CTRL;
      EVT3.ALT=_ALT;
    }
    if (EVT2.KEY==Nil) EVT2.KEY=EVT2.SCANCODE;
  }
  if (EVT.type=="click" || EVT.type=="mousemove") {
    if (EVT.type=="click") EVT2.KEY=KeyClick;
    if (EVT.type=="move") EVT2.KEY=KeyMove;
    EVT2.X=0;     EVT2.Y=0;   }
  EVT2.SHIFT=_SHIFT;
  EVT2.CTRL=_CTRL;
  EVT2.ALT=_ALT;
  if (EVT3!=Nil) return EVT3;
  if (EVT2.TAG=="keyup"
   || EVT2.TAG=="keydown" && (keyboardIsChar(EVT2.KEY) || EVT2.KEY==KeyReturn)) return Nil;
  if (EVT2.TAG=="keydown") EVT2.TAG="keypress";
  return EVT2;
});
setprop(dom,"propagate",function (EVT) {
  EVT=dom.event(EVT);
  if (EVT!=Nil) {
    if (dom.focussed()!=Nil
     && (EVT.TAG=="keydown" || EVT.TAG=="keyup" || EVT.TAG=="keypress")) EVT.TARGET=dom.focussed();
      var _E=EVT.TARGET;
    while (_E!=Nil) {       if (!isUndefined(_E[SymbolFrom])) {
        var E=_E[SymbolFrom];
        if (E!=Nil && E.from()!=Nil) {
                  EVT.TARGET=E.from();
          html.propagate(EVT);
          break;
        }
      }
      _E=_E.parentNode;
    }
  }
});

function domInit() {
  if (!SERVER) {
    document.addEventListener("keyup",dom.propagate,false);
    document.addEventListener("keydown",dom.propagate,false);
    document.addEventListener("keypress",dom.propagate,false);
    document.addEventListener("click",dom.propagate,false);
    }
}


var widget=type(function (O) {
                  error("widget.cons");                 },
                { "NAME":"widget", "PARENT":obj,
                  "ATTRS":["TAG",
                           "FROM","TO",
                           "!*> $"]
                });

widget.$=container();
setprop(widget,"getById",function (ID) {
  return widget.$.getById(ID);
});

setprop(widget,"create0",widget.create);
setprop(widget,"create",function () { return this.create0(widget.$) });

function isWidget(O) {
  return isa(O,widget);
}

widget.setMethod("parent",function () {
  return this.up();
});
widget.setMethod("setParent",function (WUP) {
  error("widget.setParent(!Yet)");
});

function widgetType(NAME,PARENT) {
  var T=type(function (O) {                var T=origin[NAME];                if (isContainer(O)) {
                 if (O!=widget.$) error(T.name()+".cons(!widget.$)::"+O.NAME);
                 O=Undefined;
               }
               if (isDom(O)) return T({ "TO":O });
               else {
                 var RES=T.create();
                 RES.init(O);
                 return RES;
               }
             },
             { "NAME":NAME, "PARENT":PARENT,
               "ATTRS":["TAG",                         "FROM","TO",
                        "!*> $=[]"]
             });
  setprop(T,"create0",widget.create0);
  setprop(T,"create",widget.create);
  origin[NAME]=T;
  return T;
}

var htmla=type(function () {
                 return htmla.create(widget.$);
               },
               { "NAME":"htmla", "PARENT":array });

htmla.setMethod("setv",function (I,VAL) {   if (!isNumStr(I)) error("htmla.setv");
  this.super("setv",I,VAL);
  var UP=this.up();
  if (isUndefined(UP)) error("htmla.setv(2)");
  if (isDomElement(UP.TO)) {
    var DOM=UP.TO.DOM;
      if (I<0 || I>=DOM.childNodes.length) if (!SERVER) error("htmla.setv(3)");
    if (isString(VAL)) {
      DOM.replaceChild(physdom("#text",VAL),DOM.childNodes[I]);
    }
    else
    if (isDom(VAL.TO)) {
      DOM.replaceChild(VAL.TO.DOM,DOM.childNodes[I]);
    }
  }
});

htmla.setMethod("push",function (VAL) {
  if (isNumber(VAL)) VAL=VAL.toString();
  if (isNil(VAL)) VAL="{{Undefined}}";
  if (!isHtml(VAL) && !isString(VAL)) error("htmla.push"+pretty(VAL));
  this.super("push",VAL);
  return VAL;
});

htmla.setMethod("remove",function (I,N) {
  this.super("remove",I,N);
  var UP=this.up();
  if (isUndefined(UP)) error("htmla.remove");
  if (isDomElement(UP.TO)) {
    while (N--) UP.TO.DOM.removeChild(UP.TO.DOM.childNodes[I]);   }
  ; });
htmla.setMethod("removeAll",function () {
  this.remove(0,length(this));
});

htmla.setMethod("insert",function (I,...VAL) {
  var UP=this.up();
  if (isUndefined(UP)) error("htmla.insert(1)");
  if (isDomElement(UP.TO)) {
    var DOM=UP.TO.DOM;
    if (I<0 || I>DOM.childNodes.length) if (!SERVER) error("htmla.insert(2)");
    var N=length(VAL);
    while (N--) {
      DOM.insertBefore(physdom("#text",""),DOM.childNodes[I]);
    }
  }
  this.super("insert",I,...VAL);
});

var html=widgetType("html",widget);

html.setMethod("init",function (O) {
  if (isUndefined(O)) O={};
  if (constructor(O)!=Object) error("html.init(1)");
  var TO=O.TO;
  if (isUndefined(TO)) TO=dom(typeOf(this));
                  else if (TO.tag()!=typeOf(this).name()) error("html.init(2)");   if (isDefined(TO.from())) error("html.init(3)");
  TO.setFrom(this);
  this.TAG=typeOf(this).name();
  this.TO=TO;
  this.$=htmla();
  this.$.setUp(this,"$");
  if (isDefined(this.TO)) html.fetchDomTree(this.$,TO);
  for (var N of ["events", "targets"]) {
    var VAL=this.TO.getv(N);
    if (!isNil(VAL)) {
      if (!isNil(O[VAL])) error("html.init("+N+")(1)");
      this[N]=html[N=="events"?"parseLEvent":"parseLTarget"](VAL);
    }
    else this[N]=N=="events"?[]:{};
  }
  for (var N in O) {     var VAL=O[N];
    if (N=="TO") ;     else
    if (N=="TAG" && isDefined(VAL) && VAL!=typeOf(this).name()) error("html.init(4)");
    else
    if (N=="$") for (var N2 in O.$) {
      var W=O.$[N2];
      if (isJxmlPure(W)) W=W.TO;
      if (isDefined(W)) {
        this.$.push(W);
        if (this.TAG=="tr" && length(this.$)>0 && this.$[0].TAG=="table") {
          this.$[0]._NOCELL=1; 
          ERRO=this;
        }
      }
    }
    else
    if (N=="events") this[N]=html.parseLEvent(VAL);     else
    if (N=="targets") this[N]=html.parseLTarget(VAL);
    else {       this[N]=VAL;
      this.TO.setv(N,VAL);     }
  }
});

var markup=tree; 
function isHtml(O) {
  return isa(O,html);
}
function isHtmlAtom(O) {
  return isHtml(O) && isDom(O.TO) && isDomTextNode(O.TO);
}

setprop(html,"getById",function (ID) {
  var D=dom.getById(ID);
  if (D) return D.FROM;
  return Undefined;
});
setprop(html,"getByName",function (NAME,ALL) {
  var L=dom.getByName(NAME,ALL);
  if (!ALL) if (L) return L.FROM; else return L;
       else return L.filter(function (D) { return isDefined(D.FROM) });
});

setprop(html,"fetchDomTree",function (A,DOM) {
  var A2=DOM.DOM.childNodes;
  for (var I=0;I<A2.length;I++) {
    var D=dom(A2[I]),
        W=D.FROM;
    if (isUndefined(W)) W=htmlType(lcase(D.DOM.nodeName))({ TO:D });
    A.push(W);
  }
});

var BODY;
setprop(html,"body",function () {
  if (!BODY) BODY=body({ TO:dom.getByName("body") });
  return BODY;
});

html.setMethod("setParent",function (WUP) {
  error("html.setParent(!Yet)");
});

html.TYPES={};
function htmlType(NAME) {
  var T=html.TYPES[NAME];
  if (isDefined(T)) return T;
  T=widgetType(NAME,html);
  html.TYPES[NAME]=T;
  return T;
}

for (var N of [
       "body",
       "i","u","b","h1",
       "span", "div", "br","hr","img","iframe",
       "table", "tbody", "tr", "td",
       "_input","a"
     ]
    )
    htmlType(N);

setprop(html,"parseEvent",function (E) {
  var A=splitTrim(E,"=>");
  return [splitTrim(A[0],"|"),splitTrim(A[1],"&")];
});
setprop(html,"parseLEvent",function (L) {   if (isString(L)) L=splitTrim(L,";");
  if (!isArray(L)) error("html.parseLEvent");
  return L.map(html.parseEvent);
});
setprop(html,"eventMatch",function (E,KEY) {
  var LHS=E[0],S=keyToStr(KEY);
  for (var I in LHS) {
    if (LHS[I]=="alpha" && keyboardIsChar(KEY) && strIsAlpha(S)) return True;
    if (LHS[I]=="num" && keyboardIsChar(KEY) && strIsNum(S)) return True;
    if (LHS[I]==S) return True;
  }
  return False;
});
setprop(html,"leventMatch",function (L,KEY) {
  for (var I in L) if (html.eventMatch(L[I],KEY)) return L[I];
  return Nil;
});

setprop(html,"parseTarget",function (L,T) {
  var A=splitTrim(T,":"),L2=L[A[0]];
  if (isUndefined(L2)) L2=[],L[A[0]]=L2;
  L2.push(A[1])
});
setprop(html,"parseLTarget",function (L) {   if (isString(L)) L=splitTrim(L,";");
  if (!isArray(L)) return L;
  var RES={};
  for (var T of L) html.parseTarget(RES,T);
  return RES;
});

setprop(html,"evalTarget",function (TARGET,EXPR) {
  if (!isString(EXPR) || length(EXPR)==0) error("html.evalTarget");
  var O=Nil;
  if (EXPR=="$") O=TARGET;
  else {
    if (EXPR[0]=="#") O=substring(EXPR,1,length(EXPR));
    if (O!=Nil) O=html.getById(O);
  }
  return O;
});
setprop(html,"defaultParm",function (ACTION) {
  switch (ACTION) {
    case "load": return "^";     case "add": return "^";
    case "mode": return "^";
    case "alert": return "^";
    case "save": return "";
    case "focus": return "_^";     default: return "_^";   }
});
setprop(html,"evalParm",function (ACTION,PARM,THIS,TARGET) {
  var A=ACTION.split("!");   ACTION=A[0];
  if (length(A)>1) PARM=A[1];
  if (PARM=="") PARM=html.defaultParm(ACTION);
  switch (PARM) {
    case "$": return THIS;
    case "*": return THIS.collect();
    case "^": return TARGET.OBJ;     case "_^": return TARGET;
    case "": return Nil;
    default: return PARM;   }
});
setprop(html,"propagate",function (EVT) {   function fn(ACTION) {
    var A=ACTION.split("!");     return A[0];
  }
  var TARGET=EVT.TARGET,ACTION=Nil;
  while (TARGET!=Nil) {
      ACTION=html.leventMatch(TARGET.events,EVT.KEY);
    if (ACTION!=Nil) break;
    TARGET=TARGET.parent();
  }
  if (ACTION!=Nil) {
      _LASTEVENT=EVT;     ACTION=ACTION[1];
    TARGET=EVT.TARGET;
    while (TARGET!=Nil) {
      var TARGETA=TARGET.targets[fn(ACTION[0])];
      if (!isUndefined(TARGETA)) {
        var L=TARGETA;
        if (!isArray(L)) L=[L];
        for (var MSG of L) {
          var A=splitTrim(MSG,"!"),PARM="";           TARGETA=A[0];
          if (length(A)>1) PARM=A[1];
          TARGETA=html.evalTarget(TARGET,TARGETA);
          if (TARGETA==Nil) error("html.propagate(1)");
          for (var I in ACTION) {             if (!isFunction(TARGETA[fn(ACTION[I])])) error("html.propagate(2)");
          }
                         for (var I in ACTION) TARGETA[fn(ACTION[I])](html.evalParm(ACTION[I],PARM,TARGET,EVT.TARGET));
        }
        break;
      }
      TARGET=TARGET.parent();
    }
  }
});

function out0(S) {
  if (isHtml(S)) {
    if (isHtml(S.TO)) S=S.TO;
    html.body().$.push(S);return;
  }
  if (OUTS!=Nil || SERVER) { _out0(S);return; }
  if (!isString(S)) error("widgets.out0");
  if (S=="<br>" || S=="\n") S=br();
  if (S=="<hr>") S=hr();
  ;   html.body().$.push(S);
}
function out(S) {
  out0(S);
}


function jxmleTokenize(S) {   var L=[],TOK="";
  for (var I=0;I<length(S);I++) {
    if (S[I]=="$") {
      I++;
      if (TOK!="") L.push(TOK);
      TOK="$";
      while (I<length(S) && (charIsLetter(S[I]) || charIsDigit10(S[I])) || S[I]=='_') TOK+=S[I],I++;
      L.push(TOK);
      TOK="";
      if (I<length(S)) I--;
    }
    else
    if (S[I]=="{" || S[I]=="}") {
      if (TOK!="") L.push(TOK);
      L.push(S[I]),TOK="";
    }
    else TOK+=S[I];
  }
  if (TOK!="") L.push(TOK);
  return L;
}

function jxmleEval(CTX,S) {
  var INJS=False;
  function ev(O,VAR) {
    if (INJS) return serialize(O);
    else {
      if (O==Nil) return "";       if (isNumber(O)) return serialize(O);
      if (isString(O) || isArray(O)) return O;
      if (isBoolean(O)) return O?"1":"0";
      if (isDefined(VAR)) return VAR;
      error("jxmlEval.ev(!INJS)<<"+S+">>-->"+serialize(O));     }
  }
  if (!isString(S)) S=serialize(S);
  var L=jxmleTokenize(S);
  for (var I=0;I<length(L);I++) {
    if (L[I][0]=="{") INJS=1;     if (L[I][0]=="}") INJS=0;
    if (L[I][0]=="$" && CTX.hasOwnProperty(substring(L[I],1,length(L[I])))) {
      var VAR=substring(L[I],1,length(L[I]));
      L[I]=ev(CTX[VAR],VAR);
    }
  }
  var RES="";
  INJS=0;
  for (var I=0;I<length(L);I++) {
    if (L[I]=="{") {
      I++;
      var ES="",LEV=1,I0=I;
      while (I<length(L) && !(LEV==1 && L[I]=="}")) {
        ES+=L[I];
        if (L[I]=="{") LEV++;
        if (L[I]=="}") LEV--;
        I++;
      }
      if (L[I]!="}") error("jxmleEval(1)");
      if (LEV<1) error("jxmleEval(2)");
      var VAL=ev(eval(ES));
      if (I0==1 && I+1==length(L)) RES=VAL;
                              else RES+=VAL;
    }
    else RES+=L[I];
  }
  return RES;
}

function jxmleCollectJSNext(L,I) {
  if (L[I]!="{") error("jxmleCollectJS(1)");
  I++;
  var LEV=0;
  while (I<length(L)) {
    if (LEV==0 && L[I]=="}") break;
    if (L[I]=="{") LEV++;
    if (L[I]=="}") LEV--;
    I++;
  }
  if (L[I]!="}") error("jxmleCollectJS(2)");
  if (LEV<0) error("jxmleCollectJS(3)");
  return I;
}

function jxmleCollectJS(L,I0,I1) {
  var RES="";
  for (var I=I0; I<I1; I++) RES+=L[I];
  return RES;
}


var jxml=widgetType("jxml",html);

jxml.setMethod("init",function (O) {
  if (isUndefined(O)) O={};
  if (constructor(O)!=Object) error("jxml.init(1)");
  this.TAG=typeOf(this).name();
  this.$=array.create(widget.$);
  this.$.setUp(this,"$");
  for (var N in O) {
    var VAL=O[N];
    if (N=="TAG" && isDefined(VAL) && VAL!=typeOf(this).name()) error("jxml.init(2)");
    else
    if (N=="$") for (var N2 in O.$) this.$.push(O.$[N2]);
    else
    if (N=="src") if (!isContainer(VAL)) error("jxml.init(src)");
                                    else this[N]=VAL;
    else
    if (N=="value") this.value=VAL;
    else
    if (N=="skin") if (!isSkin(VAL)) error("jxml.init(skin)");
                                else this[N]=VAL;
    else
    if (N=="msg") this.msg=VAL;     else {       this[N]=VAL;
    }
  }
  this.expand();
  for (var N of ["id",
                 "style", "class",
                 "events", "targets"])
  {
    if (isDefined(this[N]) && isDefined(this.TO)) {
      if (N=="events") { if (this.typeOf()!=mutton) this.TO[N]=html.parseLEvent(this[N]); }
      else
      if (N=="targets") this.TO[N]=html.parseLTarget(this[N]);
      else
      if (!(N=="class" && this.typeOf()==mutton)) {
        this.TO[N]=this[N];
        if (isDefined(this.TO.TO)) this.TO.TO.setv(N,this[N]);       }
    }
  }
});

function isJxml(O,STRICT) {
  return isa(O,jxml) && (!STRICT || isJxmlPure(O));
}
function isHtmlPure(O) {
  return isa(O,html) && !isa(O,jxml);
}

jxml.setMethod("expand",function () {
  return Nil;
});

var JXMLTAGS=[
      "title","import",
      "@",
      "var",
      "skin","shape","view",
      "superpose",
      "lines","columns",
      "mlspan","mltrans","lang",
      "button","input","mutton",
      "splitv"
    ];
for (var N of JXMLTAGS) widgetType(N,N=="columns"?lines:jxml);

function isJxmlPure(O) {   if (!isJxml(O)) return False;
  return contains(JXMLTAGS,typeOf(O).name());
}

var JXMLREF=origin["@"];

var template=type(Nil,
                  { NAME:"template", PARENT:array });

function isTemplate(O) {
  return isa(O,template);
}

template.setMethod("expand",function (PARMS,ISMK) {   function exp(A) {
      if (isString(A) && A[0]=="{") return jxmleEval(PARMS,A);
    if (isString(A) && A[0]=="$") {       var VAR=substring(A,1,length(A));
      if (PARMS.hasOwnProperty(VAR)) {
        var VAL=PARMS[VAR];
              return VAL;
      }
        }
    if (isUndefined(ISMK)) ISMK=True;
    if (isArray(A) && length(A)==0 && isDefined(PARMS[""])) return PARMS[""];
    var RES=[];
    if (ISMK) {
      if (isArray(A) && length(A)>0 && !isType(A[0])) A.unshift(columns);       if (isAtom(A) || constructor(A)!=Array && !isTemplate(A) || length(A)<1 || !isType(A[0])) return A;
      var O=length(A)==1?{}:A[1];
      if (constructor(O)!=Object) error("template.expand(2)");
      RES[0]=A[0];
      var O2={};
      for (var N in O) O2[N]=jxmleEval(PARMS,O[N]);       RES[1]=O2;
    }
    else if (!isArray(A)) return A;
    for (var I=(ISMK?2:0);I<length(A);I++) {
      var BLK=0;
      if (A[I]=="{") BLK=1,I++;       var VAL=A[I];
      if (isString(VAL) && BLK) {
        var I0=I;
        I=jxmleCollectJSNext(A,I0-1);
        VAL=jxmleEval(PARMS,"{"+jxmleCollectJS(A,I0,I)+"}");
      }
      RES.push(exp(VAL));       if (BLK && A[I]!="}") error("template.expand(3)<"+A[I]+">");
    }
    return RES;
  }
  if (typeOf(PARMS).root()!=obj) error("template.expand(0)");
  return exp(this);
});

template.setMethod("findVarPos",function (VAR) {
  function f(O,PATH) {
    for (var I=2;I<length(O);I++) if (O[I]==VAR) {
      PATH.unshift(I-2);
      return PATH;
    }
    for (var I=2;I<length(O);I++) if (isArray(O[I])) {
      if (f(O[I],PATH)) {
        PATH.unshift(I-2);
        return PATH;
      }
    }
    return Nil;
  }
  return f(this,[]);
});
obj.setMethod("getByPath",function (PATH) {
  var RES=this;
  for (var I of PATH) RES=RES.$[I];
  return RES;
});

skin.setMethod("init",function (O) {
  if (isUndefined(O.$) || !isUndefined(O.CODE)) error("skin.init(0)");
  O.CODE=O.$;
  delete O.$;
  this.super("init",O);
  var CODE={};
  for (var SH of this.CODE) {
    if (!isArray(SH) || length(SH)<2 || SH[0]!=shape || constructor(SH[1])!=Object) error("skin.init(1)");
    var CLASS=SH[1].class,
        MODE=SH[1].mode;
    if (isUndefined(CLASS)) error("skin.init(2)");
    if (isUndefined(MODE)) {
      if (length(SH)!=3) error("skin.init(3)");
      MODE="";
    }
    var SH2={ "mode":MODE, "VIEW":{} };
    for (var I=2;I<length(SH);I++) {
      var V=SH[I];
      if (!isArray(V) || length(V)<2 || V[0]!=view || constructor(V[1])!=Object) error("skin.init(4)");
      if (isUndefined(V[1].mode)) {
        if (MODE!="") error("skin.init(5)");
      }
      var V2=[columns,{}];
      if (length(V)==3 && isArray(V[2])) V2=V[2];
                                    else for (var J=2;J<length(V);J++) V2.push(V[J]);
      if (MODE=="") SH2.VIEW[MODE]=template(V2);
               else SH2.VIEW[V[1].mode]=template(V2);
    }
    CODE[CLASS]=SH2;
  }
  this.CODE=CODE;
});

function isSkin(O) {
  return typeOf(O)==skin;
}

setprop(skin,"context",type(function (O) {
                              var RES=skin.context.create();
                              RES.init(O);
                              return RES;
                            },
                            { NAME:"skin.context" })); 

skin.context.setMethod("init",function (O) {
  this.MODE=O.MODE;
  this.SHAPE=O.SHAPE; });

function isSkinContext(O) {
  return typeOf(O)==skin.context;
}

lines.LB=template([table,{},"$"]);
lines.LBPATH=lines.LB.findVarPos("$");
lines.LBPATH.pop();
lines.LD=template([tr,{},"$"]);
lines.LDPATH=lines.LD.findVarPos("$");

lines.setMethod("lb",function () {
  return typeOf(this).LB;
});
lines.setMethod("lbPath",function () {
  return typeOf(this).LBPATH;
});
lines.setMethod("ld",function () {
  return typeOf(this).LD;
});
lines.setMethod("ldPath",function () {
  return typeOf(this).LDPATH;
});

html.setMethod("display1",function (O,TO,PUSH,SETFROMTO) {
  SETFROMTO=isUndefined(SETFROMTO)?True:SETFROMTO;
  var XP;
  if (PUSH) {     XP=markup(this.ld().expand({ "":TO }));
    TO=XP.getByPath(this.ldPath());
  }
  else {
    TO=markup(TO);
    if (isJxmlPure(TO)) TO=TO.TO;   }
  if (isAtom(TO)) TO=markup([span,{},TO]);   if (isUndefined(TO._NOCELL)) TO.TO.DOM.style.display="table-cell";
  if (SETFROMTO) {
    if (isDefined(O.TO)) error("lines.display1(1)");       O.TO=TO;
    TO.FROM=O;
  }
  if (PUSH) this.HEAD.$.push(XP);
  return TO;
});
html.setMethod("display2",function (O,CTX,PUSH) {   var TO=Nil,SH;
  if (isDefined(CTX)) {
    SH=CTX.SHAPE;
    var V=SH.VIEW[CTX.MODE];
    TO=V.expand(O);
  }
  else TO=str(pretty(O));
  TO=this.display1(O,TO,PUSH);
  if (isDefined(CTX)) {
    TO.CTX=CTX;
  }
  return TO;
});
lines.setMethod("undisplay1",function (I) {
  var E=this.HEAD.$[I].getByPath(this.ldPath());
  if (isDefined(E)) {     if (isUndefined(E.FROM)) error("undisplay1(1)");
    if (isUndefined(E.FROM.TO)) error("undisplay1(2)");
    delete E.FROM.TO;
    delete E.FROM;
  }
  this.HEAD.$.remove(I,1);
});
lines.setMethod("undisplay",function () {
  var N=length(this.HEAD.$);
  while (N--) this.undisplay1(0);
});

lines.setMethod("display",function () {
  var L=isDefined(this.src)?this.TO.value:this.value;
  if (isUndefined(L)) error("lines.display");
  this.undisplay();
  var SK=this.skin;
  for (var O of L) {
    var CTX;
    if (isDefined(SK)) {
      var SH=SK.CODE[typeOf(O).name()];
      CTX=skin.context({ MODE:SH.mode, SHAPE:SH });
    }
    this.display2(O,CTX,1);
  }
});
html.setMethod("redisplay",function () {
  var O=this.FROM,
      CTX=this.CTX;
  if (isDefined(CTX)) {
    if (isUndefined(O)) error("html.redisplay(1)");
    delete O.TO;
    var UP=this.up(1,1),
        A=UP[0],I=UP[1];
        RES=this.display2(O,CTX);
    A.setv(I,RES);
  }
  else {
    if (isJxml(this.FROM) && !isa(this.FROM,lines)) this.FROM.expand(1);     else for (var I=0;I<length(this.$);I++) if (isHtml(this.$[I])) {
      this.$[I].redisplay();
    }
  }
});

lines.setMethod("load",function (L) {
  if (isUndefined(L)) error("lines.load");
  if (isString(L)) L=parse(L)[0];
  if (constructor(L)==Object || constructor(L)==Array || isQuery(L)) {
    if (!isQuery(L)) L=query(L);
    this.TO.value=sort(this.src.query(L,1),this.sort);
  }

  else error("lines.load(2)");
  this.display();
});

lines.setMethod("expand",function () {
  if (!isNil(this.TO)) ERRO=this,error("lines.expand");
  this.TO=markup(this.lb());
  this.TO.FROM=this;   this.HEAD=this.TO.getByPath(this.lbPath());
  this.HEAD.$.remove(0,1);
  if (isDefined(this.value)) {
    if (length(this.$)>0) {
      if (length(this.$)!=1 || !isSkin(this.$[0])) error("lines.expand(skin !Yet)");
    }
    this.load(this.value);
  }
  else {
    ;     for (var I in this.$) {
      var W=this.$[I];
      if (isHtmlPure(W) || isString(W) || isNumStr(W) || isNil(W)) {
        var REF=JXMLREF();
        if (isNil(W)) W="";         W.detach();
        this.display1(REF,W,1);
        this.$.setv(I,REF);
      }
      else
      if (isJxmlPure(W)) {
        this.display1(W,W.TO,1,0);
      }
      else error("lines.expand(2)");
    }
  }
});

columns.LB=template([table,{},[tr,{},"$"]]);
columns.LBPATH=columns.LB.findVarPos("$");
columns.LBPATH.pop();
columns.LD=template([]);
columns.LDPATH=[];

mlspan.setMethod("expand",function (REDO) {
  if (isUndefined(REDO) && !isNil(this.TO)) error("mlspan.expand");
  var LANG=mlstr.lang();   VAL=this[LANG];
  if (isUndefined(VAL)) {
    for (var L in this) if (mlstr.isLang(L)) {
      VAL=this[LANG=L];
      break;
    }
    if (!isUndefined(VAL)) VAL=mlstr.trans(VAL,LANG,mlstr.lang());
    if (isUndefined(VAL)) VAL="Untranslated";
  }
  if (REDO) {
    this.TO.TO.DOM.replaceChild(physdom("#text",VAL),this.TO.TO.DOM.childNodes[0]);   }
  else {
    this.TO=markup([span,{},VAL]);
    this.TO.FROM=this;
  }
});
mltrans.setMethod("expand",function () {
  for (var W of this.$) if (W.TAG=="mlspan") {
    var O={};
    for (var LANG in W) if (mlstr.isLang(LANG)) O[LANG]=W[LANG];
    mlstr.setTrans(mlstr(O));
  }
  this.TO=markup([span,{}]);
  this.TO.FROM=this;
});

lang.setMethod("expand",function () {   mlstr.setDefault(this.value);
  mlstr.setLang(this.value);
  this.TO=markup([span,{}]);
  this.TO.FROM=this;
});

button.setMethod("expand",function () {
  if (!isNil(this.TO)) error("button.expand");
  this.TO=markup([_input,{type:"button"}]);
  this.TO.FROM=this;
  if (isDefined(this.title)) {
    this.TO.title=this.title;
    this.TO.TO.setv("value",this.title);
  }
});

input.setMethod("setValue",function (S) {
  this.value=S;
  this.TO.value=S;   this.TO.TO.DOM.value=S; });
input.setMethod("reset",function () {
  this.setValue("");
});
input.setMethod("add",function (S) {
  var VAL=this.TO.TO.DOM.value;
  VAL=trim(VAL," ",False,True);
  S=trim(S," ",True,True);
  if (S=="") return;
  if (contains(S," ")) S='"'+S+'"';
  VAL+=(VAL==""?"":" ")+S;
  this.setValue(VAL);
});
input.setMethod("expand",function () {
  if (!isNil(this.TO)) error("input.expand");
  this.TO=markup([_input,{type:"text"}]);
  this.TO.FROM=this;
  if (isDefined(this.name)) {
    this.TO.name=this.name;
  }
  if (isDefined(this.$[0]) || isDefined(this.value)) {
    var VAL=this.value;
    if (isUndefined(VAL)) VAL=this.$[0];
    else
    if (isDefined(this.$[0])) error("input.expand(2)");
    this.TO.value=VAL;     this.TO.TO.setv("value",VAL);
  }
  if (isDefined(this.placeholder)) this.TO.TO.setv("placeholder",this.placeholder);
});

mutton.setMethod("load0",function (L) {
  if (isUndefined(L)) error("mutton.load0");
  if (isString(L)) L=parse(L)[0];
  var RES;
  if (constructor(L)==Object || constructor(L)==Array || isQuery(L)) {
    if (!isQuery(L)) L=query(L);
    RES=sort(this.src.query(L,1),this.sort);
  }
  return RES;
});
mutton.setMethod("expand",function (REDO) {
  if (isUndefined(REDO) && !isNil(this.TO)) error("mutton.expand");
  var CLASS,
      HASTITLE=isDefined(this.title),TRIG,
      ALIGN=this.align,
      MAXHEIGHT=this["maxheight"];
  if (!isString(ALIGN) || ALIGN!="left" && ALIGN!="right") ALIGN="right";
  if (isDefined(this.class)) CLASS=this["class"];
  if (HASTITLE) {
    TRIG=[button,{"class":"jix-muttonb"+(isDefined(CLASS)?" "+CLASS:""),
                  title:this.title}];
  }
  else {
    if (length(this.$)<1) error("mutton.expand(1)");
    TRIG=this.$[0];
    var CLASS2=TRIG[1]["class"];
    if (!(isDefined(CLASS2) && contains(CLASS2,"jix-muttonb"))) {       if (isDefined(CLASS2)) CLASS=CLASS2;
      TRIG[1]["class"]="jix-muttonb"+(isDefined(CLASS)?" "+CLASS:"");
    }
  }
  var MENU=[div,{"class":"jix-muttonm jix-muttonm-"+ALIGN}],
      L=this.$,EVTS=this.events,TG;
  if (REDO) TG=this.TO.targets;
  if (isDefined(this.value)) {     if (length(this.$)>(HASTITLE?0:1)) error("mutton.expand(2)");
    if (REDO) L=this.TO.value;
         else L=this.load0(this.value);   }
  function post(M,LAST) {
    var SUB=False;
    for (var I=2;I<length(M);I++) if (contains(M[I][1]["class"],"jix-subi")) SUB=True;
    if (!SUB) for (var I=2;I<length(M);I++) M[I][1]["class"]="jix-muttoni";
    else
    if (ALIGN=="right") for (var I=2;I<length(M);I++) {
      var CLASSI=contains(M[I][1]["class"],"jix-subi")?"jix-subi-right":"jix-spci";
      M[I][1]["class"]="jix-muttoni";
      var ZSPC="padding: 0px; margin: 0px; border: 0px;";
      M[I][2]=[table,{style: "border-collapse: collapse;"},
                [tr,{},[td,{style:ZSPC+" width: 100vw;"},M[I][2]],
                       [td,{"class":CLASSI, style:ZSPC},""]]];
    }
    for (var I=2;I<length(M);I++) M[I]=[tr,{},M[I]];
    if (isDefined(MAXHEIGHT)) {       var M2=[tbody,
              {style:"display: block; overflow-x: hidden; overflow-y: auto; max-height: "+MAXHEIGHT+";"}              ];
      for (var I=2;I<length(M);I++) M2[I]=M[I];
      M[2]=M2;
      splice(M,3,length(M)-3);
    }
    return M;
  }
  function fromc() {
    var CURLEV=0,STACK=[],LEV=0,NEW;
    function cs(S) {
      var V=S.valueOf();       LEV=0;
      while (V[LEV]==">") LEV++;
      NEW=V[LEV]=="*"?1:0;
      if (isMLStr(S) && S.LANG==mlstr.lang()) S=substring(S,LEV+NEW,length(S));
      return S;
    }
    var POSTM=[];
    for (var I in L) {
      var W=L[I];
      if (W.Categ=="A") ;
      else
      if (W.Categ=="K") {
        if (!isString(W) && isString(W.$)) W=W.$;
        NEW=0;
        if (isString(W)) {
          W=cs(W);
          if (LEV>CURLEV) {
            if (LEV!=CURLEV+1) error("mutton.expand::CURLEV");
            STACK.push(MENU);
            MENU=[table,{"class":"jix-muttonm2 jix-muttonm2-"+ALIGN}];
            POSTM.push(MENU);
            CURLEV=LEV;
          }
          else
          if (LEV<CURLEV) {
            while (LEV<CURLEV) {
              last(last(STACK)).push(MENU);
              MENU=STACK.pop();
              CURLEV--;
            }
          }
        }
        if (!isString(W)) W=pretty(W);
        var SPAN=[span,{"class":"jix-muttoni "+(NEW?"jix-subi":"jix-spci"), OBJ:W},W];
        if (isDefined(EVTS)) SPAN[1].events=EVTS;         MENU.push(SPAN);       }
    }
    while (!empty(STACK)) {
      last(last(STACK)).push(MENU);
      MENU=STACK.pop();
    }
    POSTM.push(MENU);
    for (var I in POSTM) POSTM[I]=post(POSTM[I],I==length(POSTM)-1);
    return POSTM[length(POSTM)-1];
  }
  if (isDefined(this.value)) MENU=fromc();
  var UP;
  if (REDO) UP=this.TO.up(1,1);
  this.TO=markup([span,{"class":"jix-mutton"},
                   TRIG,
                   MENU
                ]);
  if (isDefined(this.value)) this.TO.value=L;
  if (isDefined(this.events)) this.TO.events=[];
  if (isDefined(TG)) this.TO.targets=TG;
  if (REDO) {
    UP[0].setv(UP[1],this.TO);
  }
  this.TO.FROM=this;
});
mutton.NOEVAL["$"]=1;

if (!SERVER) {
  document.addEventListener("click",function(EVT) {
    function get(ELT) {       return ELT.style.display;
    }
    function set(ELT,VAL) {
      ELT.style.display=VAL;
    }
    function toggle(ELT,VAL) {
      if (get(ELT)!="none" && get(ELT)!="") VAL="none";
      set(ELT,VAL);
    }                      if (contains(EVT.target.className,'jix-muttonb')) {
      var L=document.getElementsByClassName("jix-muttonm");
      for (var I=0; I<L.length; I++) {
        if (L[I]!=EVT.target.nextElementSibling) set(L[I],"none");
      }
      toggle(EVT.target.nextElementSibling,"table");
    }
    else {
      var L=document.getElementsByClassName("jix-muttonm");
      for (var I=0; I<L.length; I++) set(L[I],"none");
    }
  },
  false);
}

splitv.setMethod("expand",function () {
  if (!isNil(this.TO)) error("splitv.expand");
  var VAL=this.value;
  if (isUndefined(VAL)) VAL=this.$[0];
  else
  if (isDefined(this.$[0])) error("splitv.expand(2)");
  var L=splitTrim(VAL,",");
  L.splice(0,0,lines,{});
  this.TO=markup(L).TO;
  this.TO.FROM=this;
});

html.setMethod("mode",function (MODE) {
  var CTX=this.CTX;
  CTX.MODE=MODE;
  this.redisplay();
});

html.setMethod("load",function (L) {   if (isUndefined(this.FROM) || !isJxmlPure(this.FROM)) error("html.load(1)");
  this.FROM.load(L);
});

html.setMethod("reset",function () {
  if (isUndefined(this.FROM) || !isJxmlPure(this.FROM)) error("html.reset(1)");
  this.FROM.reset();
});
html.setMethod("add",function (L) {
  if (isUndefined(this.FROM) || !isJxmlPure(this.FROM)) error("html.add(1)");
  this.FROM.add(L);
});

html.setMethod("lang",function (LANG) {
  if (isUndefined(this.FROM) || !isJxmlPure(this.FROM)) error("html.lang(1)");
  mlstr.setLang(LANG);
  var WS=widget.$.$;
  for (var N in WS) if (isJxml(WS[N]) && WS[N].TAG=="mutton") WS[N].TO.redisplay();
  this.redisplay();
});

html.setMethod("alert",function (MSG) {
  if (!isString(MSG)) MSG=pretty(MSG);
  alert(MSG);
});

html.setMethod("collect",function () {
  var RES={},N=0;
  function traverse(W) {
    if (isAtom(W)) return;
    if (typeOf(W)==_input && W.type=="text") {
      var NAME=W.name,VALUE=W.TO.DOM.value;
      if (isUndefined(NAME)) NAME="in"+N,N++;
      if (isUndefined(VALUE)) VALUE="";
      RES[NAME]=VALUE;
    }
    for (var I=0;I<length(W.$);I++) traverse(W.$[I]);
  }
  traverse(this);
  if (isDefined(this.FROM) && isDefined(this.FROM.msg)) {
    var T=template(parse(this.FROM.msg)[0]);
    RES=T.expand(RES,False);
  }
  return RES;
});
html.setMethod("save",function (X) {
  var O2=this.collect();
  var O=this.FROM;
  if (isHtml(O)) error("html.save(1)");
  var C=O.containerOf();
  if (!isContainer(C)) error("html.save(2)");
  O.setModified(O.setAttrs(O2));   C.sync([O]);
});

html.ATTRS=["id", "type", "name", "value"];
html.SELFCLOSE=["br", "hr", "_input", "input", "button", "var", "import", "img", "mlspan"];
html.setMethod("toHtml",function () {
  function traverse(W) {
    if (isAtom(W)) { outd(W);return; }
    out("<"+W.TAG);
    for (var A of html.ATTRS) if (isDefined(W[A]) && isAtom(W[A])) out(' '+A+"="+serialize(W[A]));
    out(">");
    if (!contains(html.SELFCLOSE,W.TAG)) {
      if (length(W.$)>0) outIndentInc(+2);
      for (var I=0;I<length(W.$);I++) crIndent(),traverse(W.$[I]);
      if (length(W.$)>0) outIndentInc(-2),crIndent(),out("</"+W.TAG+">");
    }
  }
  startOutS();
  traverse(this);
  var RES=getOutS();
  stopOutS();
  return RES;
});

str.setMethod("fromHtml",function () {   if (!isString(this)) error("obj.fromHtml");
  function tokstart() {
    charsInit();
    charnatSet("#",CharNatAlf);
    charnatSet("+",CharNatAlf);
    charnatSet("-",CharNatAlf);
    tokenizeStart("< / > = & ; { }");
  }
  function parseAtom(VAL) {
    if (VAL[0]=='"' || VAL[0]=="'") VAL=substring(VAL,1,length(VAL)-1);
    return VAL.valueOf();
  }
  function parseTag(RES,A,I) {
    if (A[I]!="<") error("fromHtml.parseTag(1)");
    var TAG=A[I+1].valueOf(),ATTR={};
    if (TAG=="!") {
      var TAG2=A[I+2];
      if (length(TAG2)>=2 && startsWith(TAG2,0,"--")) {
        I+=2;
        while (I+1<length(A) && !(endsWith(A[I],"--") && A[I+1]==">")) I++;
        if (I+1>=length(A)) error("fromHtml.parseTag(<!...)(1)");
        return I+2;
      }
      else error("fromHtml.parseTag(<!...)(2)");
    }
    if (A[I+1]=="/") return I;
    TAG=type.getByName(TAG);
    if (typeOf(TAG)!=type) TAG=A[I+1];     RES[0]=TAG;
    RES[1]=ATTR;
    I+=2;
    while (A[I]!=">" && !(A[I]=="/" && A[I+1]==">")) {
      if (A[I+1]!="=") error("fromHtml.parseTag(3)::"+A[I+1]);
      if (!strIsAlpha(A[I])) error("fromHtml.parseTag(4)");
      ATTR[A[I]]=parseAtom(A[I+2]);
      I+=3;
      if (I>=length(A)) error("fromHtml.parseTag(5)");
    }
    return I;
  }
  function postc(O,I0,I) {
    if (I==I0+1) return O[I0];
    var RES=[{}];
    for (var J=I0;J<I;J++) RES.push(O[J]);
    return RES;
  }
  function copy(RES,O) {
    splice(RES,0,length(RES),[]);
    for (var I=0;I<length(O);I++) RES.push(O[I]);
  }
  function post(O) {
    if (isDefined(O[1].skin)) O[1].skin=sy(O[1].skin);
    if (isDefined(O[1].src)
     && (O[0]==superpose || O[0]==lines || O[0]==columns || O[0]==mutton)) O[1].src=sy(O[1].src);
    var RES=[O[0],O[1]];
    var I0=2;
    for (var I=2;I<length(O);I++) {
      if (O[I]=="<>") RES.push(postc(O,I0,I)),I0=I+1;
    }
    if (I0!=2) {
      RES.push(postc(O,I0,I))
      copy(O,RES);
    }
  }
  function transc(C) {
    if (C[0]=="u" || C[0]=="U") return "\\"+C;
    if (C=="nbsp") return "\\u00A0";
    return "&"+C+";";
  }
  function parse(RES,A,I) {
    if (A[I]!="<") error("fromHtml.parse(1)");
    while (length(RES)==0 && I<length(A)) {
      I=parseTag(RES,A,I);
      if (A[I+1]=="/") return I;
    }
    var NAME=RES[0].valueOf();
    if (isType(NAME)) NAME=NAME.name();
    if (A[I]!="/" && !contains(html.SELFCLOSE,NAME)) {
      I+=1;
      while (!(A[I]=="<" && A[I+1]=="/")) {
        var O=[];
        if (A[I]=="&") {
          if (A[I+2]!=";") error("fromHtml.parse(2)::"+A[I+1]+"||"+A[I+2]+"_");
          O=transc(A[I+1]),I+=3;
        }
        else
        if (A[I]!="<") O=A[I],I++;
        else
        if (A[I+1]==">") O="<>",I+=2;
                    else I=parse(O,A,I);
        if (length(O)>0) RES.push(O);
        if (I>=length(A)) error("fromHtml.parse(3)");
      }
      if (A[I+2]!=NAME || A[I+3]!=">") errlicolSet2(A[I+2]),X1=NAME,X2=A,X3=I,error("Missing </"+NAME+"> tag");
      I+=3;
    }
    if (A[I]=="/") I++;
    if (A[I]==">") I++;
    post(RES);
    return I;
  }
  tokstart();
  var RES=[],A=tokenize(this);
  errlicolSet(-1,-1,licol(this).FNAME);
  parse(RES,A,0);
  return RES;
});

jxml.toHtml=function (S,TYRES) {
  function ptitle(O) {
    var S="";
    for (var I=2;I<length(O);I++) S+=O[I]+(I+1<length(O)?" ":"");
    return S;
  }
  var A=S.fromHtml(),
      ISLIB=A[1].type=="library",
      TITLE,
      IMPORTS=[],
      BODY=[];
  for (var I=2;I<length(A);I++) {
    var O=A[I];
    if (isArray(O) && O[0]==title) TITLE=ptitle(O);
    else
    if (isArray(O) && O[0]==origin["import"]) IMPORTS.push(O[1].src);
                                         else BODY.push(O);
  }
  if (isUndefined(TYRES)) TYRES=["html"];
  else
  if (!isArray(TYRES) && length(TYRES)<=1) error("jxml.toHtml::TYRES");
  if (length(TYRES)==0) TYRES.push(ISLIB?"js":"html");
  if (TYRES[0]!="html" && TYRES[0]!="js" || !ISLIB && TYRES[0]=="js") error("jxml.toHtml::TYRES(2)");
  startOutS();
  if (!ISLIB) {
    out("<!DOCTYPE HTML>"),cr();
    out("<html>"),cr();
    out("<head>");
    outIndentInc(+2),crIndent();
    out('<meta charset="utf8">'),crIndent();
    if (isDefined(TITLE)) out("<title>"+TITLE+"</title>"),crIndent();
    for (var I=0;I<length(IMPORTS);I++) {
      var S=IMPORTS[I];
      if (endsWith(S,".css")) out('<link rel="stylesheet" href="'+S+'" type="text/css" media="screen">'),
                              crIndent();
      if (endsWith(S,".jxml")) out('<script src="'+substring(S,0,length(S)-5)+'.js"></script>'),crIndent();
      if (endsWith(S,".js")) out('<script src="'+S+'"></script>'),crIndent();
    }
  }
  if (!(ISLIB && TYRES[0]=="js")) {
    out('<script language="javascript">');
    outIndentInc(+2),crIndent();
    out('installOnload(function () {');
  }
  outIndentInc(+2),crIndent();
  var OSERIALIZEINDENT=SERIALIZEINDENT;
  SERIALIZEINDENT=OUTINDENT+2;
  var OTYPES={};
  for (var I=0;I<length(BODY);I++) {
    if (isArray(BODY[I]) && BODY[I][0]==template) {
      var N=BODY[I][1].name;
      if (isDefined(OTYPES[N])) error("jxml.toHtml::template(1)");
      OTYPES[N]={ old:origin[N] };
      origin[N]=widgetType(N,jxml);
    }
  }
  function linkt(O) {
    if (isArray(O)) {
      if (length(O)>0 && isString(O[0])) {
        if (isDefined(OTYPES[O[0]])) O[0]=origin[O[0]];
      }
      for (var I=1;I<length(O);I++) linkt(O[I]);
    }
  }
  linkt(BODY);
  for (var N in OTYPES) origin[N]=OTYPES[N].old;
  var VNO=1,PREVSTR=False;
  for (var I=0;I<length(BODY);I++) {
    var O=BODY[I];
    if (isArray(O) && O[0]==template) {
      out("jxmltType(");       outIndentInc(+2),crIndent();
      out("\""+O[1].name+"\",\""+O[1].parms+"\",");
      crIndent();
      out(pretty(O[2],"indent"));
      outIndentInc(-2),crIndent();
      out(");");
      if (I+1<length(BODY)) crIndent();
    }
    else
    if (ISLIB) error("jxml.toHtml::ISLIB");
    else
    if (isString(O)) {
      if (PREVSTR) out('out(" ");'),crIndent();
      out('out("'+O+'");'),crIndent();
    }
    else
    if (isArray(O) && O[0]==origin.var) {
      var SRC=O[1].src,U=urlParse(SRC),HOST=U.host,A2=splitTrim(U.pathname,"/"),CONTN=A2.pop();
      var SRV="V"+VNO;
      VNO++;
      out('var '+SRV+'=jix.server("'+(isString(HOST)?'http://'+HOST:'')+A2.join("/")+'");'),crIndent();
      out(SRV+'.containers(1);'),crIndent();
      out('var '+O[1].name+'=server.SRV[0].container("'+CONTN+'")');
      if (I+1<length(BODY)) crIndent();
    }
    else
    if (isArray(O)) {
      var ID=O[1].id;
      if (isUndefined(ID)) ID="V"+VNO,VNO++;
      out("var "+ID+"=");
      if (O[0]==skin) {
        out("skin({ ");
        for (NAME in O[1]) out(NAME+':"'+O[1][NAME]+'",');
        out("$:[");
        outIndentInc(+2),crIndent();
        for (var J=2;J<length(O);J++) {
          out(pretty(O[J],"indent"));
          if (J+1<length(O)) crIndent();
        }
        outIndentInc(-2),crIndent();
        out("]});");
      }
      else {
        out("markup(");
        outIndentInc(+2),crIndent();
        out(pretty(O,"indent"));
        outIndentInc(-2),crIndent();
        out(");");
        crIndent(),out("out("+ID+");");
      }
      if (I+1<length(BODY)) crIndent();
    }
    else error("jxml.toHtml(1)");
    PREVSTR=isString(O);
  }  
  SERIALIZEINDENT=OSERIALIZEINDENT;
  outIndentInc(-2),crIndent();
  if (!(ISLIB && TYRES[0]=="js")) {
    out('});');
    outIndentInc(-2),crIndent();
    out('</script>');
  }
  if (!ISLIB) {
    outIndentInc(-2),crIndent();
    out('</head>'),cr();
    out('<body');
    if (isDefined(A[1].class)) out(' class="'+A[1].class+'"');
    if (isDefined(A[1].style)) out(' style="'+A[1].style+'"');     out('>'),cr();
    out('</body>'),cr();
    out('</html>'),cr();
  }
  var RES=getOutS();
  stopOutS();
  return RES;
}

function jxmltType(N,PARMS,MARKUP) {
  var T=widgetType(N,jxml);
  if (!isString(PARMS)) error("jxmltType.PARMS(0)");
  PARMS=splitTrim(PARMS," ");
  for (var I in PARMS) {
    if (PARMS[I][0]!="$") error("jxmltType.PARMS(1)");
    PARMS[I]=substring(PARMS[I],1,length(PARMS[I]));
  }
  T.PARMS=PARMS;
  if (!isArray(MARKUP)) error("jxmltType.MARKUP");
  T.MARKUP=template(MARKUP);
  T.setMethod("expand",function () {
    if (!isNil(this.TO)) error(N+".expand");
    var O={};
X1=PARMS;X2=this;
    for (var VAR of PARMS) for (VAR2 in this) if (lcase(VAR)==lcase(VAR2)) {       O[VAR]=this[VAR2];     }
    this.TO=markup(T.MARKUP.expand(O));
    if (isJxml(this.TO)) this.TO=this.TO.TO;
    this.TO.FROM=this;
  });
  if (!contains(html.SELFCLOSE,N)) html.SELFCLOSE.push(N);
  if (!contains(JXMLTAGS,N)) JXMLTAGS.push(N);
  return T;
}


function test1() {
  parsefStart();
  var S="(56abcd1234 [befghij \"abcd\\\\\"])",
      RG=lexerStart(S);
  while (!lexerEOF(RG)) {
    out("<"+rangeValue(RG)+">"),cr();
    out(display([RG.MIN,RG.MAX,RG.NAT,RG.LI,RG.COL])),cr();
    lexerNext(RG);
  }
  out("---\n");
  var A=tokenize(S);
  out(display(A)),cr();
  out("---\n");

  A=tokenize(S);

  var person=type(Nil,{ NAME:"person" });
  var O=person({ "NAME":"Smith", "FNAME":"John", "AGE":43 });
  out(pretty(O,"short")),cr();
  out("---\n");
  out(pretty({R1:{A:1,B:2},R2:{C:1,D:2}},"indent")),cr();
  out("---\n");
  type(Nil,{ NAME:"range" });
  var O=parsef('range{+o:"id1",A:1,B:2,C,D,E,F:{}}{Z:1}');   out(pretty(O)),cr();
  out("---\n");
  out(serializef(O,[["range","flat",
                      [["ID"],["A"],["B"],["F"],["$",{"nl":1}]]
                    ],
                    ["*","full",[]]],"json")),out("_"),cr();
  out("---\n");
  out(pretty(O)),cr();
}

function test2() {
  var C=container("C1"),
      person=type(Nil,{ NAME:"person", ATTRS:["NAME=''","FNAME","AGE=0","> YEARS=[]"] }),
          P=person({ NAME:"Smith", FNAME:"John", AGE:23, YEARS:[{ A:123 },{ B:456 }] });
  out(pretty(P)),cr();
  var P2=copy(P,C);
  out(pretty(P2)),cr();
  out(pretty(P2.YEARS[0])),cr();
  P2.delete();
  out(pretty(P2)),cr();
}

var SK={ "song":{ "short":{ "Title":["av",""],
                          "Authors":["av",""],
                             "Year":["av",""]
                               }
                },
            "*":{ "short":{   "+o":["av",""],
                            "NAME":["av",""] }
                }
       };
function test3() {
  var C=container("C1");
  C.load("./Songs","db");
  SK["song"]["short"][SymbolCont]=["-",""];
  SK["song"]["short"][SymbolId]=["av",""];
  out(pretty(C.$[0],"short",SK)),cr();

}

function test4() {
  var S=fileRead("./Songs.csv"),
      C=container("C1");
  C.load("./Songs","csv");
  out(pretty(C.$[0],"short",SK)),cr();
  out("---\n");
  var L=C.query({ Year:"*5" });
  for (var I=0;I<length(L);I++) {
    out(pretty(L[I],"short",SK)),cr();
  }
}

function test5() {
  var person=type(Nil,{ NAME:"person", ATTRS:["Name","FName","Age"] }),
      song=type(Nil,{ NAME:"song", ATTRS:["Title","Year","$=[]"] }),
      P1=person({ "Name":"Smith", "FName":"John", "Age":23 }),
      P2=person({ "Name":"Dupont", "FName":"Georges", "Age":27 }),
      S=song({ Title:"Imagine", Year:1981, $:[P1,P2] });
  out(serialize(S)),cr();
  var S2=tree([song,{Title:"A"},[person,{Name:"B"}],[person,{Name:"C"}]])
  out(serialize(S2)),cr();
}

function tests() {
  test1();
  out("---\n");
  test2();
  out("---\n");
  test3();
  out("---\n");
  test4();
  out("---\n");
  test5();
}


 

function start(NOTNOW) {
  var PORT=conf().PORT || 80,
      SRV=server(PORT);

  for (var C of conf().CONT) {
    out("Loading "+C[0]),cr();
    container(C[0],conf().DATA+"/"+C[0],"db",SRV);
  }
  for (var MOD of conf().APP) {
    var JS=conf().PROJ+"/"+MOD,
        SRC=fileRead(JS).toString();
    out("Loading "+JS),cr();
    eval(SRC);
  }
  for (var C of conf().CONT) {
    var CONT=SRV.container(C[0]);
    for (FNAME of C[1]) {
      out("Setting method "+FNAME+"() of "+C[0]),cr();
      CONT.setQMethod(FNAME,origin[FNAME]);
    }
  }

  if (NOTNOW) return SRV;   out("Server started on port "+PORT+"...\n");
  SRV.start();
}

function stop() {
  error("stop !Yet");
}


var jix={
  error: error,
  isUndefined: isUndefined,
  type: type,
  boxit: boxit,
  parse: parse,
  serialize: serialize,
  memory: memory,
  length: length,
  trim: trim,
  splitTrim: splitTrim,
  contains: contains,
  mlstr: mlstr,
  filePath: filePath,
  fileName: fileName,
  fileRead: fileRead,
  fileWrite: fileWrite,
  fileCopy: fileCopy,
  dirRead: dirRead,
  fileReadSet: fileReadSet,
  foreach_vfile: foreach_vfile,
  out: out,
  outd: outd,
  cr: cr,
  consoleRepeat: consoleRepeat,
  processCwd: processCwd,
  spawn: spawn,
  pretty: pretty,
  api: api,
  server: server,
  container: container,
  conf: conf,
  test1: test1,
  tests: tests,
  start: start,
  init: function() {     serversInit();
    containersInit();
    confInit(Nil,True);
    if (typeof JIXWEB!="undefined") {
      physdomInit();
      domInit();
    }
  },
  exportAll: function() {     origin.Undefined=Undefined;
    origin._=_;
    origin.Nil=Nil;
    origin.True=True;
    origin.False=False;
    origin.error=error;
    origin.errorCatch=errorCatch;
    origin.type=type;
    origin.obj=obj;
    origin.setprop=setprop;
    origin.isa=isa;
    origin.isUndefined=isUndefined;
    origin.isNil=isNil;
    origin.isDefined=isDefined;
    origin.isBoolean=isBoolean;
    origin.isNumber=isNumber;
    origin.isString=isString;
    origin.isArray=isArray;
    origin.isType=isType;
    origin.isAtom=isAtom;
    origin.isObject=isObject;
    origin.substring=substring;
    origin.contains=contains;
    origin.empty=empty;
    origin.index=index;
    origin.trim=trim;
    origin.splitTrim=splitTrim;
    origin.splice=splice;
    origin.parse=parse;
    origin.serialize=serialize;
    origin.length=length;
    origin.charIsLetter=charIsLetter;
    origin.charIsDigit10=charIsDigit10;
    origin.charsInit=charsInit;
    origin.charnat=charnat;
    origin.charnatSet=charnatSet;
    origin.CharNatAlf=CharNatAlf;
    origin.CharNatOmg=CharNatOmg;
    origin.CharNatQuote=CharNatQuote;
    origin.charIs=charIs;
    origin.charIsAlpha=charIsAlpha;
    origin.charIsBlank=charIsBlank;
    origin.strIsBlank=strIsBlank;
    origin.startsWith=startsWith;
    origin.endsWith=endsWith;
    origin.strMatch=strMatch;
    origin.replaceAll=replaceAll;
    origin.lcase=lcase;
    origin.ucase=ucase;
    origin.mlstr=mlstr;
    origin.filePath=filePath;
    origin.fileName=fileName;
    origin.fileName0=fileName0;
    origin.fileExt=fileExt;
    origin.fileRead=fileRead;
    origin.fileReadSet=fileReadSet;
    origin.fileWrite=fileWrite;
    origin.fileCopy=fileCopy;
    origin.fileMove=fileMove;
    origin.fileDelete=fileDelete;
    origin.dirCreate=dirCreate;
    origin.dirRead=dirRead;
    origin.foreach_vfile=foreach_vfile;
    origin.vfileCreate=vfileCreate;
    origin.urlParse=urlParse;
    origin.out=out;
    origin.outd=outd;
    origin.cr=cr;
    origin.outIndentInc=outIndentInc;
    origin.crIndent=crIndent;
    origin.startOutS=startOutS;
    origin.stopOutS=stopOutS;
    origin.getOutS=getOutS;
    origin.consoleMain=consoleMain;
    origin.consoleRepeat=consoleRepeat;
    origin.fileExists=fileExists;
    origin.fileIsDir=fileIsDir;
    origin.fnameNormalize=fnameNormalize;
    origin.processCwd=processCwd;
    origin.child_process=child_process;
    origin.spawn=spawn;
    origin.chdir=chdir;
    origin.pretty=pretty;
    origin.conf=conf;
    origin.confInit=confInit;
    origin.project=project;
    origin.server=server;
    origin.container=container;
    origin.tokenizeStart=tokenizeStart;
    origin.tokenize=tokenize;
    origin.format=format;
    origin.load=load;
    origin.save=save;
    origin.txtsave=txtsave;
    if (typeof JIXWEB!="undefined") {
      origin.markup=markup;
    }
    origin.csvparsef=csvparsef;
    origin.csvserializef=csvserializef;
    origin.csvh=csvh;
    origin.csv=csv;
    origin.start=start;
  }
};


 

var JIXWEB=1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

function installOnload(f) {
  var oldf=window.onload;
  if (typeof oldf!='function') window.onload=f;
  else {
    window.onload=function() {
      oldf();
      f();
    }
  }
}

if (SERVER) module.exports=jix;
  jix.init();