{"version":3,"sources":["jsdelivr-header.js","/npm/hylar@10.0.4/hylar/hylar.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,ACFA,MAAM,GAAK,QAAQ,MACf,MAAQ,QAAQ,SAChB,aAAe,QAAQ,iBACvB,EAAI,QAAQ,KAEhB,MAAM,QAAU,QAAQ,YAElB,QAAU,QAAQ,kBAElB,WAAa,QAAQ,qBACvB,iBAAmB,QAAQ,2BAC3B,qBAAuB,QAAQ,+BAC/B,OAAS,QAAQ,wBACjB,SAAW,QAAQ,mBACnB,MAAQ,QAAQ,gBAChB,MAAQ,QAAQ,gBAChB,OAAS,QAAQ,iBACjB,mBAAqB,QAAQ,6BAC7B,SAAW,QAAQ,mBACnB,OAAS,QAAQ,iBAIf,QAAU,YAShB,MAAM,MACF,WAAA,CAAY,EAAS,CAAC,GAClB,KAAK,KAAO,IAAI,WAChB,KAAK,aAAe,GACpB,KAAK,GAAK,IAAI,qBACd,KAAK,GAAG,OAER,KAAK,SAAW,SAChB,KAAK,WAAY,EAEjB,KAAK,eAAe,EAAO,YAC3B,KAAK,kBAAkB,EAAO,YAE9B,KAAK,aAAe,GACpB,KAAK,IAAM,GAEX,MAAM,gBAAkB,IAC5B,CAEA,UAAO,CAAI,GACP,IAAI,EAAU,MAAK,IAAI,MAAO,gBAAgB,MAC9C,MAAM,gBAAgB,IAAI,KAAK,GAC/B,GAAG,eAAe,QAAS,EAC/B,CAOA,SAAI,GACA,OAAO,KAAK,aAAa,OAAO,MAAM,KAAK,YAC/C,CAKA,UAAI,GACA,OAAO,OAAO,UAAU,KAAK,WACjC,CAEA,mBAAI,GACA,OAAO,KAAK,SACR,KAAK,SAAS,QAAQ,GAAG,cACrB,MAAO,cAEX,KAAK,SAAS,QAAQ,GAAG,SACrB,MAAO,WAEX,QACI,MAAO,OAEnB,CAUA,oBAAM,CAAe,GACjB,KAAK,WAA2B,MAAd,EAAqB,EAAa,SACpD,SAAS,uBAAuB,KAAK,MACzC,CAOA,uBAAM,CAAkB,GACF,MAAd,GAAoC,GAAd,GACtB,KAAK,cAAe,EACpB,KAAK,WAEL,KAAK,cAAe,CAE5B,CAEA,OAAA,GACI,OAAO,KAAK,IAAI,OAAS,EAAI,KAAK,IAAI,KAAK,IAAI,OAAO,GAAK,EAC/D,CAMA,mBAAO,CAAa,GAChB,IAAI,EAAM,EAAM,OAAS,EAAM,WAC/B,QAAQ,IAAI,GAAG,MAAM,IAAI,kBAAkB,MAAM,KAAK,aAAa,KACnE,IACI,MAAM,IAAI,EACd,CAAE,MAAO,GACL,OAAO,OAAO,OAAO,QACzB,CACJ,CAMA,qBAAO,CAAe,GAClB,QAAQ,IAAI,GAAG,MAAM,OAAO,2BAA2B,KACvD,IACI,MAAM,IAAI,EACd,CAAE,MAAO,GACL,OAAO,OAAO,OAAO,QACzB,CACJ,CAMA,aAAO,CAAO,EAAK,EAAS,CAAE,QAAQ,IACb,GAAjB,EAAO,QAAiB,QAAQ,IAAI,MAAM,MAAM,YAAc,GAClE,IACI,MAAM,IAAI,EACd,CAAE,MAAO,GACL,OAAO,OAAO,OAAO,QACzB,CACJ,CAEA,cAAO,CAAQ,GACX,QAAQ,IAAI,GAAG,aAAa,iBAAiB,KAC7C,IACI,MAAM,IAAI,EACd,CAAE,MAAO,GACL,OAAO,OAAO,OAAO,QACzB,CACJ,CAEA,oBAAM,GACF,KAAK,WAAY,QACX,KAAK,kBACf,CAEA,qBAAM,GACF,MAAM,eAAe,+BACrB,KAAK,WAAY,QACX,KAAK,kBACf,CAEA,KAAA,GACI,KAAK,KAAO,IAAI,WAChB,KAAK,GAAK,IAAI,qBACd,KAAK,GAAG,OACR,KAAK,SACT,CAKA,oBAAM,GACF,KAAK,QAAU,SAAS,QAAQ,GAAG,cACnC,KAAK,KAAK,oBACV,MAAM,OAAO,+BACjB,CAKA,iBAAM,GACF,KAAK,QAAU,SAAS,QAAQ,GAAG,SACnC,KAAK,KAAK,mBACV,MAAM,OAAO,6BACjB,CAEA,cAAM,CAAS,GACX,KAAK,MAAQ,QACP,KAAK,kBACf,CAMA,qBAAA,CAAsB,EAAS,eAC3B,IAAK,KAAK,QACN,OAAQ,GACJ,IAAK,WACG,KAAK,SAAW,SAAS,QAAQ,GAAG,UAAU,KAAK,cACvD,MACJ,IAAK,cACG,KAAK,SAAW,SAAS,QAAQ,GAAG,eAAe,KAAK,iBAC5D,MACJ,QACI,MAAM,eAAe,oBAAoB,+CACzC,KAAK,iBAGrB,CAYA,UAAM,CAAK,EAAa,EAAU,EAAe,GAG7C,OAFA,QAAQ,KAAK,mBAER,IACD,KAAK,KAAK,cACJ,KAAK,GAAG,QAGP,KAAK,UAAU,EAAa,EAAU,EAErD,CAEA,eAAM,CAAU,EAAa,EAAU,GACnC,OAAO,GACH,IAAK,kBACL,IAAK,sBACL,KAAK,EAED,OADA,MAAM,MAAM,oFACL,EAEX,QACI,IACI,IAAI,QAAU,KAAK,GAAG,KAAK,EAAa,GAExC,OADA,MAAM,OAAO,EAAI,gCAAiC,CAAG,GAC/B,GAAlB,KAAK,UACE,KAAK,SAAS,GAEd,CAEf,CAAE,MAAO,GAEL,MADA,MAAM,aAAa,GACb,CACV,EAEZ,CAOA,WAAM,CAAM,EAAO,GACf,IAAI,EAAQ,EAAqB,GACjC,MAAM,OAAO,YAAY,IAAS,CAAE,QAAQ,IAE5C,IAEI,EAAS,iBAAiB,YAAY,EAC1C,CAAE,MAAO,GAEL,MADA,MAAM,aAAa,8BAAgC,GAC7C,CACV,CAEA,GAAsB,GAAlB,KAAK,UAAoB,OAAO,KAAK,GAAG,MAAM,GAIlD,GAFA,KAAK,sBAAsB,GAIlB,WAFD,EAAO,KAEX,CACI,GAAI,iBAAiB,cAAc,GAAS,CAExC,IAAI,EAAkB,iBAAiB,4BAA4B,GAC/D,QAAa,KAAK,MAAM,iBAAiB,iBAAiB,IAG9D,OAAO,KAAK,MAAM,iBAAiB,qCAAqC,EAAQ,GACpF,CACI,OAAO,KAAK,qBAAqB,EAEhC,CAKL,GAAI,KAAK,SAAW,SAAS,QAAQ,GAAG,cAAe,CAEnD,IAAI,EAAkB,GAElB,EAAO,eAAe,cACtB,EAAO,UAAU,SAAQ,CAAC,EAAM,KAC5B,GAAI,EAAK,eAAe,eAAgD,SAA/B,EAAK,WAAW,YAAwB,CAE7E,GAAkC,KAA9B,EAAK,WAAW,WAKhB,MAAM,OAAO,oBAAoB,EAAK,WAAW,YAJjD,EAAgB,KAAK,GACrB,EAAO,UAAU,GAAS,EAAK,WAAW,UAKlD,KAKR,IAAI,EAAU,GACd,IACI,QAAgB,KAAK,GAAG,MAAM,EAClC,CAAE,MAAM,GACJ,MAAM,CACV,CA0CA,OAvCI,EAAgB,OAAS,GACzB,EAAgB,SAAQ,IACpB,GAAoC,KAAhC,EAAO,WAAW,WAgClB,MAAM,OAAO,oBAAoB,EAAO,WAAW,YAhCd,CAErC,IAAI,EAAc,CACd,MAAO,UACP,KAAM,2CACN,MAAO,EAAQ,QAiBnB,GAbA,EAAQ,SAAQ,CAAC,EAAS,KACtB,OAAO,KAAK,GAAS,SAAQ,KACc,GAAnC,EAAO,UAAU,QAAQ,WAClB,EAAQ,EACnB,IAE+B,GAA/B,OAAO,KAAK,GAAS,eACd,EAAQ,EACnB,IAEJ,EAAU,EAAQ,QAAO,GAAW,IAGhC,EAAQ,OAAS,EACjB,EAAQ,SAAQ,IACZ,EAAQ,EAAO,UAAY,SAE5B,CACH,IAAI,EAAU,CAAC,EACf,EAAQ,EAAO,UAAY,EAC3B,EAAQ,KAAK,EACjB,CACJ,CAEA,IAID,CAGX,OACU,KAAK,GAAG,sBAEd,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,MAAM,OAAQ,IACrC,EAAmB,KAAK,iBAAiB,kBAAkB,EAAQ,IASvE,aANM,QAAQ,OAAO,GAAoB,CAAC,EAAU,IACzC,KAAK,uBAAuB,IACpC,SAEiB,KAAK,GAAG,eAAe,EAK3D,CAMA,0BAAM,CAAqB,GAIvB,IAHA,IACmB,EADf,EAAS,iBAAiB,YAAY,GACtC,EAAW,GAEN,EAAI,EAAG,EAAI,EAAO,QAAQ,OAAQ,IAAK,CACR,UAAhC,EAAO,QAAQ,GAAG,WAClB,EAAU,EAAO,QAAQ,GAAG,OACW,UAAhC,EAAO,QAAQ,GAAG,aACzB,EAAU,EAAO,QAAQ,GAAG,QAEhC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,OAAQ,IAChC,EAAS,KAAK,KAAK,YAAY,EAAQ,GAAI,EAAO,QAAQ,GAAG,YAErE,CAEA,IAAI,QAAe,QAAQ,IAAI,GAC/B,MAAO,GAAG,OAAO,MAAM,GAAI,EAE/B,CAMA,gBAAM,GAEF,aADoB,KAAK,GAAG,cACb,QAAQ,UAC3B,CAQA,UAAA,CAAW,GACP,OAAO,KAAK,GAAG,gBAAgB,EACnC,CAEA,qBAAA,GAEI,IADA,IAAI,EAAW,GACN,EAAI,EAAG,EAAI,KAAK,MAAM,OAAQ,IACnC,EAAS,KAAK,CAAE,KAAM,KAAK,MAAM,GAAG,KAAM,KAAM,KAAK,MAAM,GAAG,WAAY,KAAM,KAAK,MAAM,GAAG,OAElG,OAAO,CACX,CAMA,aAAA,GACI,OAAO,KAAK,IAChB,CAMA,oBAAA,CAAqB,GACjB,KAAK,KAAK,WAAW,GACrB,KAAK,SACT,CAEA,UAAA,CAAW,GACP,IAAI,EAAkB,GAClB,EAAc,EAAW,KAC7B,IAAK,IAAI,KAAS,EACd,IAAK,IAAI,KAAU,EAAY,GAAQ,CACnC,GAAmB,EAAO,QAAQ,cAAe,IAAM,KACvD,IAAK,IAAI,EAAI,EAAG,EAAI,EAAY,GAAO,GAAQ,OAAQ,IACnD,EAAY,GAAO,GAAQ,GAAG,UAAY,KAAK,SAEvD,CAGJ,OADA,KAAK,qBAAqB,GACnB,KAAK,GAAG,KAAK,EAAiB,cACzC,CAEA,OAAA,GACI,IAAK,KAAK,cAAgB,GAAI,OAGzB,GAAG,WAAW,SACf,GAAG,UAAU,QAGjB,IAAI,EAAS,CACT,qBAAsB,CAAC,EACvB,YAAa,IAGb,GAAG,WAAW,kBACd,EAAS,OAAO,OAAO,EAAQ,KAAK,MAAM,GAAG,aAAa,gBAAgB,cAG9E,EAAO,YAAc,KAAK,aAAa,KAAK,IAAc,CAAE,KAAM,EAAE,KAAM,QAAS,EAAE,eAErF,IAAK,IAAI,KAAY,KAAK,gBAAgB,KAAM,CAE5C,IAAI,EAAW,GAAG,EAAS,MAAM,mBAAmB,yBAAyB,QACzE,EAAa,QAAQ,IACrB,EAAe,KAAK,gBAAgB,KAAK,GACzC,EAAkB,GAEtB,IAAK,IAAI,KAAU,EACX,OAAO,qBAAqB,EAAa,IAAS,OAAS,GAAG,EAAgB,KAAK,GAE3F,GAAG,cAAc,EAAY,EAAgB,KAAK,OAElD,EAAO,qBAAqB,GAAY,CAC5C,CAEA,GAAG,cAAc,eAAgB,KAAK,UAAU,EAAQ,KAAM,GAClE,CAEA,aAAM,GACF,IAAK,KAAO,GAAG,WAAW,UAAY,KAAK,aAAc,OAEzD,MAAM,OAAO,yBAEb,IAAI,EAAS,GAAG,YAAY,QACxB,EAAS,CACT,qBAAsB,CAAC,EACvB,YAAa,IAGb,GAAG,WAAW,kBACd,EAAS,OAAO,OAAO,EAAQ,KAAK,MAAM,GAAG,aAAa,gBAAgB,cAG9E,IAAK,IAAI,KAAQ,EAAM,QAAQ,GAA0B,WAAR,IAC7C,IACI,IAAI,EAAU,GAAG,aAAa,QAAQ,KAAQ,WAC9C,IAAK,IAAI,KAAQ,EAAO,YACpB,KAAK,aAAa,KAAK,OAAO,UAAU,EAAK,QAAS,EAAK,aAEzD,KAAK,KAAK,EAAS,WAAW,EAAM,EAAO,qBAAqB,GAC1E,CAAE,MAAO,GACL,MAAM,eAAe,OAAO,UAAU,GAC1C,CAGJ,MAAM,OAAO,0BACjB,CAEA,gBAAA,GACI,IACyB,EADrB,EAAY,KAAK,gBAAgB,KAAK,YAAuB,UAC7D,GAAe,EASnB,YAPkB,IAAd,IACM,KAAK,iBAAqB,KAAK,cAAgB,EAAU,GAAG,aAC9D,GAAe,EACf,EAAuB,EAAU,UAIlC,CACH,WAAY,EACZ,MAAO,EAEf,CAEA,UAAA,GACI,OAAQ,KAAK,SAAW,SAAS,QAAQ,GAAG,QAChD,CAEA,aAAA,GACI,OAAQ,KAAK,SAAW,SAAS,QAAQ,GAAG,aAChD,CAOA,iBAAM,CAAY,EAAQ,GACtB,IAGI,EAAO,EACP,EAJA,EAAQ,EAAO,KACf,EAAW,GACX,EAAW,GACG,EAAI,KAAK,gBAAgB,OAAO,GAC7B,EAAW,GAC5B,EAAkB,MAAM,aAAa,CAAE,CAAE,QAAQ,MAErD,GAAW,UAAR,EACC,MAAM,OAAO,uBACb,EAAW,EAAS,OAAO,EAAO,cAC/B,GAAY,UAAT,EAAmB,CACzB,MAAM,OAAO,sBACb,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,QAAQ,OAAQ,IACnC,MAAM,uBAAuB,EAAO,QAAQ,KAC5C,EAAkB,iBAAiB,eAAe,EAAO,QAAQ,IACjE,EAAS,KAAK,KAAK,GAAG,MAAM,eAAiB,EAAkB,eAAiB,EAAkB,QAElG,EAAS,KAAK,EAAO,QAAQ,IAIrC,EAAkB,QAAQ,IAAI,GAC9B,IAAI,QAAgB,EAEpB,IAAS,EAAI,EAAG,EAAI,EAAQ,OAAQ,IAChC,EAAW,EAAS,OAAO,EAAQ,GAAG,QAE9C,CAEA,EAAQ,iBAAiB,eAAe,GAAU,EAAO,KAAK,SAAW,SAAS,QAAQ,GAAG,eAC7F,EAAQ,iBAAiB,eAAe,GAAU,EAAO,KAAK,SAAW,SAAS,QAAQ,GAAG,eAE7F,IAAI,QAAoB,SAAS,SAAS,EAAO,EAAO,EAAE,OAAO,KAAK,QAAS,KAAK,QAAS,KAAK,OAElG,KAAK,oBAAoB,EAAa,GAEtC,IAAI,EAAU,CACV,OAAQ,iBAAiB,cAAc,EAAY,WACnD,OAAQ,iBAAiB,cAAc,EAAY,YAGvD,MAAqB,IAAlB,EAAQ,OAAqB,KAAK,GAAG,OAAO,EAAQ,OAAQ,GAC1C,IAAlB,EAAQ,QAAqB,KAAK,GAAG,OAAO,EAAQ,OAAQ,EAEnE,CAQA,4BAAM,CAAuB,GACzB,GAAI,KAAK,SAAW,SAAS,QAAQ,GAAG,SAAU,CAC9C,IACI,EADa,iBAAiB,YAAY,GACtB,MAAM,GAAG,KAC7B,EAA2B,iBAAiB,yBAAyB,EAAO,GAE5E,QAAgB,KAAK,GAAG,MAAM,GAC9B,EAAU,EAAQ,QAElB,EADM,KAAK,KAAK,WAAW,EAAS,GACxB,MAEZ,EAAmB,CACnB,QAAS,EACT,SAAU,SAAS,OAAO,UAAU,EAAO,KAAK,KAAK,OAAO,KAG5D,EAAgB,KAAK,KAAK,SAAS,EAAiB,SAAU,GAAO,MAAM,KAAK,KACpF,OAAO,KAAK,GAAG,kBAAkB,EAAe,EACpD,CACI,OAAO,KAAK,GAAG,MAAM,EAE7B,CAOA,mBAAA,CAAoB,EAAa,GAC7B,IAAI,EAAiB,EAAY,UAC7B,EAAmB,EAAY,UACnC,EAAQ,KAAK,KAAK,aAAa,GAC/B,MAAM,OAAO,4CAEb,IAAK,IAAI,EAAI,EAAG,EAAI,EAAiB,OAAQ,IACH,UAAlC,EAAiB,GAAG,kBACb,KAAK,KAAK,KAAK,GAAkB,iBAEjC,KAAK,KAAK,KAAK,GAAO,iBAAiB,aAAa,EAAiB,KAIpF,IAAK,IAAI,EAAI,EAAG,EAAI,EAAe,OAAQ,IACvC,KAAK,KAAK,IAAI,EAAe,GAAI,GAIrC,KAAK,UACL,MAAM,QAAQ,2BAClB,CAOA,cAAM,CAAS,GACX,MAAM,OAAO,2BAEb,IAAI,QAAU,KAAK,GAAG,MAAM,6CACxB,EAAQ,GAEZ,IAAK,IAAI,EAAI,EAAG,EAAK,EAAE,QAAQ,OAAQ,IAAK,CACxC,IAAI,EAAS,EAAE,QAAQ,GACnB,EAAM,KAAK,KAAK,IAAI,GACxB,GAAI,EAIG,EAAQ,EAAM,OAAO,OAJnB,CACL,IAAI,EAAI,iBAAiB,aAAa,GAAQ,EAAO,KAAK,SAAW,SAAS,QAAQ,GAAG,eACzF,KAAK,KAAK,IAAI,EAAG,GACjB,EAAM,KAAK,EACf,CACJ,CAEA,IAAI,QAAoB,SAAS,SAAS,EAAO,GAAI,KAAK,OAAQ,KAAK,QAAS,KAAK,OACrF,KAAK,oBAAoB,EAAa,GAEtC,IAAI,EAAS,GAEb,IAAK,IAAI,EAAI,EAAG,EAAI,EAAY,UAAU,OAAQ,EAAI,EAAG,GAF7B,IAE4C,CACpE,IAAI,EAAa,EAAY,UAAU,MAAM,EAAE,EAHvB,KAIxB,EAAO,KAAK,iBAAiB,cAAc,GAC/C,CASA,OAPA,MAAM,OAAO,mCAEP,QAAQ,OAAO,GAAQ,CAAC,EAAU,IAC7B,KAAK,GAAG,OAAO,IACvB,GAEH,QAAQ,KAAK,kBACN,CACX,CAEA,sBAAM,GACF,IAAI,EAAqB,KAAK,KAAK,uBAC7B,KAAK,QAEX,IAAK,IAAI,KAAS,QACR,KAAK,KAAK,EAAM,QAAS,eAAe,EAAM,EAAM,KAElE,CAOA,cAAM,CAAS,GACX,KAAK,aAAa,QAAQ,SACpB,KAAK,kBACf,CAEA,aAAM,CAAQ,GACV,KAAK,aAAa,KAAK,SACjB,KAAK,kBACf,CAEA,qBAAM,CAAgB,EAAS,GAC3B,IAAI,EACJ,IACI,EAAO,OAAO,UAAU,EAAS,EACrC,CAAE,MAAM,GAEJ,YADA,MAAM,aAAa,2BAA6B,EAEpD,OACM,KAAK,QAAQ,EACvB,CAEA,sBAAM,CAAiB,GACnB,KAAK,aAAe,KAAK,aAAa,QAAQ,GACnC,EAAK,MAAQ,UAElB,KAAK,kBACf,CAEA,iBAAA,CAAkB,EAAO,GACrB,KAAK,aAAa,KAAK,CAAE,MAAO,EAAO,QAAS,GACpD,CAEA,gBAAM,GACF,KAAK,aAAe,SACd,KAAK,kBACf,CAEA,KAAA,GACI,MAAM,OAAS,WAAW,CAC9B,EAKJ,OAAO,QAAU","file":"/npm/hylar@10.0.4/hylar/hylar.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/hylar@10.0.4/hylar/hylar.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/**\r\n * Created by MT on 01/12/2015.\r\n */\r\n\r\nconst fs = require('fs'),\r\n    chalk = require('chalk'),\r\n    chalkRainbow = require('chalk-rainbow')\r\n    q = require('q');\r\n\r\nconst Promise = require('bluebird');\r\n\r\nconst emitter = require('./core/Emitter');\r\n\r\nconst Dictionary = require('./core/Dictionary'),\r\n    ParsingInterface = require('./core/ParsingInterface'),\r\n    TripleStorageManager = require('./core/TripleStorageManager'),\r\n    Logics = require('./core/Logics/Logics'),\r\n    Reasoner = require('./core/Reasoner'),\r\n    Rules = require('./core/Rules'),\r\n    Utils = require('./core/Utils'),\r\n    Errors = require('./core/Errors'),\r\n    RegularExpressions = require('./core/RegularExpressions'),\r\n    Prefixes = require('./core/Prefixes'),\r\n    Axioms = require('./core/Axioms')\r\n\r\n\r\n\r\nconst logFile = 'hylar.log';\r\n\r\n/**\r\n * HyLAR main module.\r\n * @author Mehdi Terdjimi\r\n * @organization LIRIS, Universite Lyon 1\r\n * @email mehdi.terdjimi@univ-lyon1.fr\r\n */\r\n\r\nclass Hylar {\r\n    constructor(params = {}) {\r\n        this.dict = new Dictionary()\r\n        this._customRules = []\r\n        this.sm = new TripleStorageManager()\r\n        this.sm.init()\r\n\r\n        this.prefixes = Prefixes\r\n        this.reasoning = true\r\n\r\n        this._setEntailment(params.entailment)\r\n        this._setupPersistence(params.persistent)\r\n\r\n        this.queryHistory = []\r\n        this.log = []\r\n\r\n        Hylar.currentInstance = this\r\n    }\r\n\r\n    static log(msg) {\r\n        let dateMsg = `[ ${new Date().toString()} ] ${msg}\\n`\r\n        Hylar.currentInstance.log.push(msg)\r\n        fs.appendFileSync(logFile, dateMsg);\r\n    }\r\n\r\n    /**\r\n     * Rule set getter.\r\n     * Depends on the specified entailment\r\n     * @return {*}\r\n     */\r\n    get rules() {\r\n        return this._customRules.concat(Rules[this.entailment])\r\n    }\r\n\r\n    /**\r\n     * Entailment-related axioms\r\n     */\r\n    get axioms() {\r\n        return Axioms.getAxioms(this.entailment)\r\n    }\r\n\r\n    get reasoningMethod() {\r\n        switch(this.rMethod) {\r\n            case Reasoner.process.it.incrementally:\r\n                return 'incremental'\r\n                break\r\n            case Reasoner.process.it.tagBased:\r\n                return 'tagBased'\r\n                break\r\n            default:\r\n                return 'none'\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Sets up specified entailement,\r\n     * then put axioms and compute rule dependencies\r\n     * to optimize reasoning task time performance\r\n     * @param entailment\r\n     * @return {Promise<void>}\r\n     * @private\r\n     */\r\n    async _setEntailment(entailment) {\r\n        this.entailment = entailment != null ? entailment : 'owl2rl'\r\n        Reasoner.updateRuleDependencies(this.rules);\r\n    }\r\n\r\n    /**\r\n     * Process persistence task if specified\r\n     * @param persistent\r\n     * @private\r\n     */\r\n    async _setupPersistence(persistent) {\r\n        if (persistent != null && persistent == true) {\r\n            this.allowPersist = true\r\n            this.restore()\r\n        } else {\r\n            this.allowPersist = false\r\n        }\r\n    }\r\n\r\n    lastLog() {\r\n        return this.log.length > 0 ? this.log[this.log.length-1] : ''\r\n    }\r\n\r\n    /**\r\n     * Custom error display\r\n     * @returns {*}\r\n     */\r\n    static displayError(error) {\r\n        let msg = error.stack || error.toString()\r\n        console.log(`${chalk.red('[HyLAR] ')} 😰 ${chalk.bold('ERROR:')} ${msg}`);\r\n        try {\r\n            Hylar.log(msg)\r\n        } catch (e) {\r\n            return Errors.FileIO(logFile);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Custom warning display\r\n     * @returns {*}\r\n     */\r\n    static displayWarning(msg) {\r\n        console.log(`${chalk.yellow('[HyLAR] ')} 😐 WARNING: ${msg}`);\r\n        try {\r\n            Hylar.log(msg)\r\n        } catch (e) {\r\n            return Errors.FileIO(logFile);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Notifications of HyLAR (similar to console.log behavior)\r\n     * @returns {*}\r\n     */\r\n    static notify(msg, params = { silent: false }) {\r\n        if (params.silent == false) console.log(chalk.green('[HyLAR] ') + msg);\r\n        try {\r\n            Hylar.log(msg)\r\n        } catch (e) {\r\n            return Errors.FileIO(logFile);\r\n        }\r\n    }\r\n\r\n    static success(msg) {\r\n        console.log(`${chalkRainbow('[HyLAR] ')} ✨ ${msg}`);\r\n        try {\r\n            Hylar.log(msg)\r\n        } catch (e) {\r\n            return Errors.FileIO(logFile);\r\n        }\r\n    }\r\n\r\n    async setReasoningOn() {\r\n        this.reasoning = true\r\n        await this.recomputeClosure()\r\n    }\r\n\r\n    async setReasoningOff() {\r\n        Hylar.displayWarning('Reasoning has been set off.')\r\n        this.reasoning = false\r\n        await this.recomputeClosure()\r\n    }\r\n\r\n    clean() {\r\n        this.dict = new Dictionary();\r\n        this.sm = new TripleStorageManager();\r\n        this.sm.init();\r\n        this.persist()\r\n    }\r\n\r\n    /**\r\n     * Puts on incremental reasoning\r\n     */\r\n    async setIncremental() {\r\n        this.rMethod = Reasoner.process.it.incrementally;\r\n        this.dict.turnOffForgetting();\r\n        Hylar.notify('Reasoner set as incremental.');\r\n    }\r\n\r\n    /**\r\n     * Puts on tag-based reasoning\r\n     */\r\n    async setTagBased() {\r\n        this.rMethod = Reasoner.process.it.tagBased;\r\n        this.dict.turnOnForgetting();\r\n        Hylar.notify('Reasoner set as tag-based.');\r\n    }\r\n\r\n    async setRules(rules) {\r\n        this.rules = rules;\r\n        await this.recomputeClosure()\r\n    }\r\n\r\n    /**\r\n     * Switches HyLAR's reasoning method\r\n     * @param method Name of the method ('incremental' or 'tagBased')\r\n     */\r\n    updateReasoningMethod(method = 'incremental') {\r\n        if (!this.rMethod) {\r\n            switch (method) {\r\n                case 'tagBased':\r\n                    if (this.rMethod != Reasoner.process.it.tagBased) this.setTagBased()\r\n                    break;\r\n                case 'incremental':\r\n                    if (this.rMethod != Reasoner.process.it.incrementally) this.setIncremental()\r\n                    break;\r\n                default:\r\n                    Hylar.displayWarning(`Reasoning method ${method} not supported, using incremental instead.`)\r\n                    this.setIncremental()\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Intializes the triple store, loads/classifies an ontology and register its\r\n     * entities into the Dictionary.\r\n     * @param ontologyTxt The raw ontology text\r\n     * @param mimeType The specified mime type\r\n     * @param reasoningMethod The desired reasoning method for the classification\r\n     * @param graph (optional) The graph in which the ontology will be loaded\r\n     * @param keepOldValues (optional - default: false) Avoid storage cleaning if set to true.\r\n     * @returns {*}\r\n     */\r\n    async load(ontologyTxt, mimeType, keepOldValues, graph) {\r\n        emitter.emit('classif-started');\r\n\r\n        if (!keepOldValues) {\r\n            this.dict.clear();\r\n            await this.sm.init()\r\n            return this.treatLoad(ontologyTxt, mimeType, graph)\r\n        } else {\r\n            return this.treatLoad(ontologyTxt, mimeType, graph)\r\n        }\r\n    }\r\n\r\n    async treatLoad(ontologyTxt, mimeType, graph) {\r\n        switch(mimeType) {\r\n            case 'application/xml':\r\n            case 'application/rdf+xml':\r\n            case false:\r\n                Hylar.error(`Unrecognized or unsupported mimeType. Supported formats are json-ld, turtle, n3`)\r\n                return false;\r\n                break;\r\n            default:\r\n                try {\r\n                    let r = await this.sm.load(ontologyTxt, mimeType)\r\n                    Hylar.notify(r + ' triples loaded in the store.', {  })\r\n                    if (this.reasoning == true) {\r\n                        return this.classify(graph)\r\n                    } else {\r\n                        return r\r\n                    }\r\n                } catch (error) {\r\n                    Hylar.displayError(error)\r\n                    throw error;\r\n                }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Launches a SPARQL query against the triplestore.\r\n     * @param query The SPARQL query text\r\n     * @param reasoningMethod The desired reasoning method if inserting/deleting\r\n     */\r\n    async query(query, reasoningMethod) {\r\n        let sparql, singleWhereQueries = [], result\r\n        Hylar.notify(`Received ${query}`, { silent: true })\r\n\r\n        try {\r\n            // Parse original query\r\n            sparql = ParsingInterface.parseSPARQL(query)\r\n        } catch (e) {\r\n            Hylar.displayError('Problem with SPARQL query: ' + query);\r\n            throw e;\r\n        }\r\n\r\n        if (this.reasoning == false) return this.sm.query(query)\r\n\r\n        this.updateReasoningMethod(reasoningMethod);\r\n\r\n        switch (sparql.type) {\r\n            // Insert, delete queries\r\n            case 'update':\r\n                if (ParsingInterface.isUpdateWhere(sparql)) {\r\n                    // Get construct results of the update where query\r\n                    let sparqlConstruct = ParsingInterface.updateWhereToConstructWhere(sparql)\r\n                    let data = await this.query(ParsingInterface.deserializeQuery(sparqlConstruct))\r\n\r\n                    // Put them back in a simple update data manner to provide inner-graph inference\r\n                    return this.query(ParsingInterface.buildUpdateQueryWithConstructResults(sparql, data));\r\n                } else {\r\n                    return this.treatUpdateWithGraph(query);\r\n                }\r\n                break;\r\n\r\n            // Select, Ask, Construct queries\r\n            default:\r\n                // If incremental query\r\n                if (this.rMethod == Reasoner.process.it.incrementally) {\r\n                    // To overcome rdfstore not supporting count; only supports count(*) though\r\n                    let countStatements = []\r\n\r\n                    if (sparql.hasOwnProperty('variables')) {\r\n                        sparql.variables.forEach((_var, index) => {\r\n                            if (_var.hasOwnProperty('expression') && _var.expression.aggregation == 'count') {\r\n                                // If this is a count statement on a wildcard select, process it\r\n                                if (_var.expression.expression == '*') {\r\n                                    countStatements.push(_var)\r\n                                    sparql.variables[index] = _var.expression.expression\r\n                                    // Otherwise throw unsupported\r\n                                } else {\r\n                                    throw Errors.CountNotImplemented(_var.expression.expression)\r\n                                }\r\n                            }\r\n                        })\r\n                    }\r\n\r\n                    // Execute query against the store\r\n                    let results = []\r\n                    try {\r\n                        results = await this.sm.query(query)\r\n                    } catch(err) {\r\n                        throw err\r\n                    }\r\n\r\n                    // Reattach counted if relevant\r\n                    if (countStatements.length > 0) {\r\n                        countStatements.forEach(cntStm => {\r\n                            if (cntStm.expression.expression == '*') {\r\n                                // The count result that will be attached\r\n                                let countResult = {\r\n                                    token: 'literal',\r\n                                    type: 'http://www.w3.org/2001/XMLSchema#integer',\r\n                                    value: results.length\r\n                                }\r\n\r\n                                // Replace bindings\r\n                                results.forEach((binding, index) => {\r\n                                    Object.keys(binding).forEach(_var => {\r\n                                        if (sparql.variables.indexOf(_var) == -1) {\r\n                                            delete binding[_var]\r\n                                        }\r\n                                    })\r\n                                    if (Object.keys(binding).length == 0) {\r\n                                        delete results[index]\r\n                                    }\r\n                                })\r\n                                results = results.filter(binding => binding)\r\n\r\n                                // Either attach to remaining bindings or add a unique count binding\r\n                                if (results.length > 0) {\r\n                                    results.forEach(binding => {\r\n                                        binding[cntStm.variable] = countResult\r\n                                    })\r\n                                } else {\r\n                                    let binding = {}\r\n                                    binding[cntStm.variable] = countResult\r\n                                    results.push(binding)\r\n                                }\r\n                            } else {\r\n                                throw Errors.CountNotImplemented(cntStm.expression.expression)\r\n                            }\r\n                        })\r\n                    }\r\n\r\n                    return results\r\n\r\n                    // If tag-based query\r\n                } else {\r\n                    await this.sm.regenerateSideStore()\r\n\r\n                    for (var i = 0; i < sparql.where.length; i++) {\r\n                        singleWhereQueries.push(ParsingInterface.isolateWhereQuery(sparql, i))\r\n                    }\r\n\r\n                    await Promise.reduce(singleWhereQueries, (previous, singleWhereQuery) => {\r\n                        return this.treatSelectOrConstruct(singleWhereQuery);\r\n                    }, 0)\r\n\r\n                    let results = await this.sm.querySideStore(query);\r\n\r\n                    return results\r\n                }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * High-level treatUpdate that takes graphs into account.\r\n     * @returns Promise\r\n     */\r\n    async treatUpdateWithGraph(query) {\r\n        var sparql = ParsingInterface.parseSPARQL(query),\r\n            promises = [], updates;\r\n\r\n        for (var i = 0; i < sparql.updates.length; i++) {\r\n            if (sparql.updates[i].updateType == 'insert') {\r\n                updates = sparql.updates[i].insert;\r\n            } else if (sparql.updates[i].updateType == 'delete') {\r\n                updates = sparql.updates[i].delete;\r\n            }\r\n            for (var j = 0; j < updates.length; j++) {\r\n                promises.push(this.treatUpdate(updates[j], sparql.updates[i].updateType));\r\n            }\r\n        }\r\n\r\n        let values = await Promise.all(promises)\r\n        return [].concat.apply([], values);\r\n\r\n    }\r\n\r\n    /**\r\n     * Returns the content of the triplestore as turtle.\r\n     * @returns {String}\r\n     */\r\n    async getStorage() {\r\n        let content = await this.sm.getContent()\r\n        return content.triples.toString();\r\n    }\r\n\r\n    /**\r\n     * Empties and recreate the triplestore with elements\r\n     * indicated in turtle/n3.\r\n     * @param ttl The turtle/n3 triples to be added.\r\n     * @returns {*}\r\n     */\r\n    setStorage(ttl) {\r\n        return this.sm.createStoreWith(ttl);\r\n    }\r\n\r\n    getRulesAsStringArray() {\r\n        var strRules = [];\r\n        for (var i = 0; i < this.rules.length; i++) {\r\n            strRules.push({ name: this.rules[i].name, rule: this.rules[i].toString(), type: this.rules[i].type } );\r\n        }\r\n        return strRules;\r\n    }\r\n\r\n    /**\r\n     * Returns the dictionary content.\r\n     * @returns {Object}\r\n     */\r\n    getDictionary() {\r\n        return this.dict;\r\n    }\r\n\r\n    /**\r\n     * Empties and recreate the content of the dictionary.\r\n     * @param dict The content of the dictionary.\r\n     */\r\n    setDictionaryContent(dict) {\r\n        this.dict.setContent(dict);\r\n        this.persist()\r\n    }\r\n\r\n    importData(dictionary) {\r\n        var importedTriples = \"\",\r\n            dictContent = dictionary.dict;\r\n        for (var graph in dictContent) {\r\n            for (var triple in dictContent[graph]) {\r\n                importedTriples += triple.replace(/(\\n|\\r|\\\\)/g, '') + \"\\n\";\r\n                for (var i = 0; i < dictContent[graph][triple].length; i++) {\r\n                    dictContent[graph][triple][i].__proto__ = Fact.prototype;\r\n                }\r\n            }\r\n        }\r\n        this.setDictionaryContent(dictContent);\r\n        return this.sm.load(importedTriples, \"text/turtle\")\r\n    }\r\n\r\n    persist() {\r\n        if (!this.allowPersist && fs) return\r\n\r\n        // Check if db folder exists\r\n        if (!fs.existsSync('./db')){\r\n            fs.mkdirSync('./db')\r\n        }\r\n\r\n        let dbconf = {\r\n            mappingsGraphDbFiles: {},\r\n            customRules: []\r\n        }\r\n\r\n        if (fs.existsSync('./db/db.conf')) {\r\n            dbconf = Object.assign(dbconf, JSON.parse(fs.readFileSync('./db/db.conf').toString()))\r\n        }\r\n\r\n        dbconf.customRules = this._customRules.map((r => { return { name: r.name, content: r.toString() } }))\r\n\r\n        for (let graphUri in this.getDictionary().dict) {\r\n            // Write db content on file\r\n            let filename = `${graphUri.match(RegularExpressions.URI_AFTER_HASH_OR_SLASH)[0]}.n3`\r\n            let dbfilename = `./db/${filename}`\r\n            let graphContent = this.getDictionary().dict[graphUri]\r\n            let explicitEntries = []\r\n\r\n            for (let triple in graphContent) {\r\n                if (Logics.getOnlyExplicitFacts(graphContent[triple]).length > 0) explicitEntries.push(triple)\r\n            }\r\n            fs.writeFileSync(dbfilename, explicitEntries.join('\\n'))\r\n\r\n            dbconf.mappingsGraphDbFiles[filename] = graphUri\r\n        }\r\n\r\n        fs.writeFileSync('./db/db.conf', JSON.stringify(dbconf, null, 3))\r\n    }\r\n\r\n    async restore() {\r\n        if (!fs || !fs.existsSync('./db') || !this.allowPersist) return\r\n\r\n        Hylar.notify('... Recovering DB ...')\r\n\r\n        let files  = fs.readdirSync('./db')\r\n        let dbconf = {\r\n            mappingsGraphDbFiles: {},\r\n            customRules: []\r\n        }\r\n\r\n        if (fs.existsSync('./db/db.conf')) {\r\n            dbconf = Object.assign(dbconf, JSON.parse(fs.readFileSync('./db/db.conf').toString()))\r\n        }\r\n\r\n        for (let file of files.filter((file) => { return file != 'db.conf'})) {\r\n            try {\r\n                let content = fs.readFileSync(`./db/${file}`).toString()\r\n                for (let rule of dbconf.customRules) {\r\n                    this._customRules.push(Logics.parseRule(rule.content, rule.name))\r\n                }\r\n                await this.load(content, 'text/n3', true, dbconf.mappingsGraphDbFiles[file])\r\n            } catch (err) {\r\n                Hylar.displayWarning(Errors.DBParsing(file))\r\n            }\r\n        }\r\n\r\n        Hylar.notify('* DB recover finished *')\r\n    }\r\n\r\n    checkConsistency() {\r\n        var __FALSE__ = this.getDictionary().dict['#default']['__FALSE__'],\r\n            isConsistent = true, inconsistencyReasons;\r\n\r\n        if (__FALSE__ !== undefined) {\r\n            if ( (this.isIncremental()) || (this.isTagBased() && __FALSE__[0].isValid()) ) {\r\n                isConsistent = false;\r\n                inconsistencyReasons = __FALSE__.causedBy;\r\n            }\r\n        }\r\n\r\n        return {\r\n            consistent: isConsistent,\r\n            trace: inconsistencyReasons\r\n        }\r\n    }\r\n\r\n    isTagBased() {\r\n        return (this.rMethod == Reasoner.process.it.tagBased);\r\n    }\r\n\r\n    isIncremental() {\r\n        return (this.rMethod == Reasoner.process.it.incrementally);\r\n    }\r\n\r\n    /**\r\n     * Processes update queries.\r\n     * @param sparql The query text.\r\n     * @returns {Object} The results of this query.\r\n     */\r\n    async treatUpdate(update, type) {\r\n        let graph = update.name,\r\n            iTriples = [],\r\n            dTriples = [],\r\n            FeIns, FeDel, F = this.getDictionary().values(graph),\r\n            deleteQueryBody, promises = [],\r\n            initialResponse = Utils.emptyPromise([ { triples:[] } ]);\r\n\r\n        if(type == 'insert') {\r\n            Hylar.notify('Starting insertion.');\r\n            iTriples = iTriples.concat(update.triples);\r\n        } else if(type  == 'delete') {\r\n            Hylar.notify('Starting deletion.');\r\n            for (var i = 0; i < update.triples.length; i++) {\r\n                if (Utils.tripleContainsVariable(update.triples[i])) {\r\n                    deleteQueryBody = ParsingInterface.tripleToTurtle(update.triples[i]);\r\n                    promises.push(this.sm.query('CONSTRUCT { ' + deleteQueryBody + \" }  WHERE { \" + deleteQueryBody + \" }\"));\r\n                } else {\r\n                    dTriples.push(update.triples[i]);\r\n                }\r\n            }\r\n\r\n            initialResponse = Promise.all(promises);\r\n            let results = await initialResponse\r\n\r\n            for (var i = 0; i < results.length; i++) {\r\n                dTriples = dTriples.concat(results[i].triples);\r\n            }\r\n        }\r\n\r\n        FeIns = ParsingInterface.triplesToFacts(iTriples, true, (this.rMethod == Reasoner.process.it.incrementally));\r\n        FeDel = ParsingInterface.triplesToFacts(dTriples, true, (this.rMethod == Reasoner.process.it.incrementally));\r\n\r\n        let derivations = await Reasoner.evaluate(FeIns, FeDel, F.concat(this.axioms), this.rMethod, this.rules,)\r\n\r\n        this.registerDerivations(derivations, graph);\r\n\r\n        let updates = {\r\n            insert: ParsingInterface.factsToTurtle(derivations.additions),\r\n            delete: ParsingInterface.factsToTurtle(derivations.deletions)\r\n        }\r\n\r\n        if(updates.delete != '') return this.sm.delete(updates.delete, graph)\r\n        if(updates.insert != '') return this.sm.insert(updates.insert, graph)\r\n        return true\r\n    }\r\n\r\n\r\n    /**\r\n     * Processes select or construct queries.\r\n     * @param query The query text.\r\n     * @returns {Object} The results of this query.\r\n     */\r\n    async treatSelectOrConstruct(query) {\r\n        if (this.rMethod == Reasoner.process.it.tagBased) {\r\n            let parsedQuery= ParsingInterface.parseSPARQL(query),\r\n                graph = parsedQuery.where[0].name,\r\n                constructEquivalentQuery = ParsingInterface.constructEquivalentQuery(query, graph);\r\n\r\n            let results = await this.sm.query(constructEquivalentQuery)\r\n            let triples = results.triples;\r\n            let val = this.dict.findValues(triples, graph);\r\n            let facts = val.found;\r\n\r\n            let formattedResults = {\r\n                results: results,\r\n                filtered: Reasoner.engine.tagFilter(facts, this.dict.values(graph))\r\n            }\r\n\r\n            let temporaryData = this.dict.findKeys(formattedResults.filtered, graph).found.join(' ');\r\n            return this.sm.loadIntoSideStore(temporaryData, graph);\r\n        } else {\r\n            return this.sm.query(query);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Registers newly inferred derivations\r\n     * in the Dictionary.\r\n     * @param derivations The derivations to be registered.\r\n     */\r\n    registerDerivations(derivations, graph) {\r\n        let factsToBeAdded = derivations.additions,\r\n            factsToBeDeleted = derivations.deletions;\r\n        graph = this.dict.resolveGraph(graph);\r\n        Hylar.notify('Registering derivations to dictionary...');\r\n\r\n        for (let i = 0; i < factsToBeDeleted.length; i++) {\r\n            if (factsToBeDeleted[i].toString() == 'IFALSE') {\r\n                delete this.dict.dict[graph]['__FALSE__'];\r\n            } else {\r\n                delete this.dict.dict[graph][ParsingInterface.factToTurtle(factsToBeDeleted[i])];\r\n            }\r\n        }\r\n\r\n        for (var i = 0; i < factsToBeAdded.length; i++) {\r\n            this.dict.put(factsToBeAdded[i], graph);\r\n            //Prefixes.registerPrefixFrom(factsToBeAdded[i])\r\n        }\r\n\r\n        this.persist()\r\n        Hylar.success('Registered successfully.');\r\n    }\r\n\r\n    /**\r\n     * Classifies the ontology\r\n     * already loaded in the triplestore.\r\n     * @returns {*}\r\n     */\r\n    async classify(graph) {\r\n        Hylar.notify('Classification started.');\r\n\r\n        let r = await this.sm.query('CONSTRUCT { ?a ?b ?c } WHERE { ?a ?b ?c }')\r\n        let facts = []\r\n\r\n        for (let i = 0; i <  r.triples.length; i++) {\r\n            let triple = r.triples[i];\r\n            let _fs = this.dict.get(triple);\r\n            if(!_fs) {\r\n                let f = ParsingInterface.tripleToFact(triple, true, (this.rMethod == Reasoner.process.it.incrementally))\r\n                this.dict.put(f, graph)\r\n                facts.push(f)\r\n            } else facts = facts.concat(_fs)\r\n        }\r\n\r\n        let derivations = await Reasoner.evaluate(facts, [], this.axioms, this.rMethod, this.rules)\r\n        this.registerDerivations(derivations, graph);\r\n\r\n        let chunks = [], chunksNb = 5000\r\n\r\n        for (var i = 0, j = derivations.additions.length; i < j; i += chunksNb) {\r\n            let factsChunk = derivations.additions.slice(i,i+chunksNb);\r\n            chunks.push(ParsingInterface.factsToTurtle(factsChunk));\r\n        }\r\n\r\n        Hylar.notify('Classification succeeded.');\r\n\r\n        await Promise.reduce(chunks, (previous, chunk) => {\r\n            return this.sm.insert(chunk);\r\n        }, 0)\r\n\r\n        emitter.emit('classif-ended');\r\n        return true\r\n    }\r\n\r\n    async recomputeClosure() {\r\n        let fullExplicitGraphs = this.dict.explicitGraphs()\r\n        await this.clean()\r\n\r\n        for (let graph of fullExplicitGraphs) {\r\n            await this.load(graph.content, 'text/turtle', true, graph.name)\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Add rules to the reasoner for\r\n     * the next inferences.\r\n     * @param ruleSet\r\n     */\r\n    async addRules(ruleSet) {\r\n        this._customRules.push(...ruleSet)\r\n        await this.recomputeClosure()\r\n    }\r\n\r\n    async addRule(rule) {\r\n        this._customRules.push(rule)\r\n        await this.recomputeClosure()\r\n    }\r\n\r\n    async parseAndAddRule(rawRule, name) {\r\n        var rule;\r\n        try {\r\n            rule = Logics.parseRule(rawRule, name);\r\n        } catch(e) {\r\n            Hylar.displayError('Error when parsing rule ' + rule);\r\n            return;\r\n        }\r\n        await this.addRule(rule)\r\n    }\r\n\r\n    async removeRuleByName(name) {\r\n        this._customRules = this._customRules.filter((rule) => {\r\n            return rule.name != name\r\n        })\r\n        await this.recomputeClosure()\r\n    }\r\n\r\n    addToQueryHistory(query, noError) {\r\n        this.queryHistory.push({ query: query, noError: noError });\r\n    }\r\n\r\n    async resetRules() {\r\n        this._customRules = [];\r\n        await this.recomputeClosure()\r\n    }\r\n\r\n    quiet() {\r\n        Hylar.notify = function(){};\r\n    }\r\n}\r\n\r\n\r\n\r\nmodule.exports = Hylar;\r\n"]}