Server : Apache/2.4.41 (Ubuntu) System : Linux absol.cf 5.4.0-198-generic #218-Ubuntu SMP Fri Sep 27 20:18:53 UTC 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.33 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, Directory : /var/www/html/keeview_app/html/
Upload File :
Current File : /var/www/html/keeview_app/html/jsfs.js
const fs = Object.freeze(function () {
var maincore = {};
var retval = {};
var core = {};
core.check = function (callbackfunc) {
if (false) {
callbackfunc(false);
return;
}
if (rootdir === undefined) {
if (navigator.storage === undefined) {
callbackfunc(false);
return;
}
if (navigator.storage.getDirectory === undefined) {
callbackfunc(false);
return;
}
}
callbackfunc(true);
}
core.init = function (callbackfunc) {
if (rootdir === undefined) {
navigator.storage.getDirectory().then(function (value) {
rootdir = value;
callbackfunc();
});
}
else {
callbackfunc();
}
};
core.getAccessHandle = function (fHandle, mode, callbackfunc) {
var returncall = function (value) {
callbackfunc(value);
};
var catchFunc = function (e) {
callbackfunc(null, e);
};
try {
switch (mode) {
case "r":
case "rw":
if (fHandle.createSyncAccessHandle !== undefined) {
fHandle.createSyncAccessHandle().catch(catchFunc).then(returncall);
}
break;
case "w":
if (fHandle.createWritable !== undefined) {
fHandle.createWritable().catch(catchFunc).then(returncall);
return;
}
if (fHandle.createSyncAccessHandle !== undefined) {
fHandle.createSyncAccessHandle().catch(catchFunc).then(returncall);
}
break;
}
}
catch (e) {
catchFunc(e);
}
};
core.openF = function (dir, fname, mode, callbackfunc) {
var nextcall = function (value) {
core.getAccessHandle(value, mode, callbackfunc);
};
var catchFunc = function (e) {
callbackfunc(null, e);
}
try {
switch (mode) {
case "r":
dir.getFileHandle(fname).catch(catchFunc).then(nextcall);
break;
case "w":
case "rw":
dir.getFileHandle(fname, { create: true }).catch(catchFunc).then(nextcall);
break;
default:
setTimeout(function () {
callbackfunc(null, "invalid mode");
}, 0);
}
}
catch (e) {
catchFunc(e);
}
};
core.getDir = function (path, index, curdir, createnew, callbackfunc) {
var xparams = [path[index]];
var catchFunc = function (e) {
callbackfunc(null, e);
}
if (createnew === true) {
xparams.push({ create: true });
}
try {
curdir.getDirectoryHandle(...xparams).catch(catchFunc).then(function (value) {
if (value === undefined) {
callbackfunc(null, "path not found");
return;
}
if (index == path.length - 1) {
callbackfunc(value);
}
else {
core.getDir(path, index + 1, value, createnew, callbackfunc);
}
});
}
catch (e) {
catchFunc(e);
}
}
core.openFile = function (path, fname, mode, callbackfunc) {
var returnStep = function (fHandle, e) {
if (fHandle === null) {
callbackfunc({
success: false,
content: e
});
return;
}
main.handle = fHandle;
main.position = 0;
callbackfunc({
success: true
});
}
var openFileStep = function (dirHandle, e) {
if (dirHandle === null) {
callbackfunc({
success: false,
content: e
});
return;
}
core.openF(dirHandle, fname, mode, returnStep);
};
var getDirStep = function () {
if (path.length == 0) {
openFileStep(rootdir, "directory not found!");
}
else {
core.getDir(path, 0, rootdir, false, openFileStep);
}
};
core.init(getDirStep);
};
core.mkdir = function (path, callbackfunc) {
core.init(function () {
core.getDir(path, 0, rootdir, true, function (retval, e) {
if (retval === null) {
callbackfunc({
success: false,
content: e
});
return;
}
callbackfunc({
success: true
});
});
});
}
core.remove = function (path, callbackfunc) {
var target;
var removeStep = function (dirHandle) {
try {
dirHandle.removeEntry(target, {recursive: true}).then(function () {
callbackfunc({
success: true
});
});
}
catch (e) {
callbackfunc({
success: false,
content: e
});
}
}
if (path.length < 1) {
callbackfunc({
success: false,
content: "target not found"
});
return;
}
target = path.pop();
if (path.length == 0) {
core.init(function () {
removeStep(rootdir);
});
return;
}
core.init(function () {
core.getDir(path, 0, rootdir, false, function (retval, e) {
if (retval === null) {
callbackfunc({
success: false,
content: e
});
return;
}
removeStep(retval);
});
});
}
core.readFileU8 = function (length, callbackfunc) {
var fsize = main.handle.getSize();
var buffer, readBuffer;
if (length == 0) {
length = fsize - main.position;
}
else if (length > fsize - main.position) {
length = fsize - main.position;
}
if (length == 0) {
callbackfunc({
success: true,
content: new Uint8Array(0)
});
return;
}
try {
buffer = new Uint8Array(length);
readBuffer = main.handle.read(buffer, {at: main.position});
if (EncodingClass.type.isNumber(readBuffer)) {
main.position += readBuffer;
callbackfunc({
success: true,
content: buffer
});
}
else {
readBuffer.then(function () {
main.position += length;
callbackfunc({
success: true,
content: buffer
});
});
}
}
catch (e) {
callbackfunc({
success: false,
content: e
});
}
};
core.readFile = function (length, callbackfunc) {
core.readFileU8(length, function (retval) {
if (retval.success) retval.content = EncodingClass.string.fromUint8Array(retval.content);
callbackfunc(retval);
});
};
core.seekFile = function (type, offset, callbackfunc) {
var fsize = main.handle.getSize();
type = type.toLowerCase().trim();
switch (type) {
case "seek_set":
main.position = offset;
break;
case "seek_cur":
main.position += offset;
break;
case "seek_end":
main.position = fsize + offset;
break;
}
if (main.position > fsize) main.position = fsize;
if (main.position < 0) main.position = 0;
callbackfunc({
success: true
});
};
core.writeFileU8 = function (data, callbackfunc) {
try {
var writeBuffer = main.handle.write(data, {at: main.position});
if (EncodingClass.type.isNumber(writeBuffer)) {
main.position += writeBuffer;
callbackfunc({
success: true,
content: writeBuffer
});
}
else {
writeBuffer.then(function () {
main.position += data.length;
callbackfunc({
success: true,
content: data.length
});
});
}
}
catch (e) {
callbackfunc({
success: false,
content: e
});
}
}
core.writeFile = function (data, callbackfunc) {
data = EncodingClass.string.toUint8Array(data);
core.writeFileU8(data, callbackfunc);
};
core.close = function (callbackfunc) {
try {
if (main.handle.flush !== undefined) main.handle.flush();
main.handle.close();
delete main.handle;
delete main.position;
callbackfunc({
success: true
});
}
catch (e) {
callbackfunc({
success: false,
content: e
});
}
};
core.readDir = function (path, callbackfunc) {
var target;
var catchFunc = function (e) {
callbackfunc({
success: false,
content: e
});
}
var fetch = function (entries, retval, callbackfunc) {
entries.next().catch(catchFunc).then(function (r) {
if (r.done) {
callbackfunc();
}
else {
retval.push({
type: r.value[1].kind.toString().toLowerCase(),
name: r.value[1].name.toString()
});
fetch(entries, retval, callbackfunc);
}
});
}
var readStep = function (dirHandle) {
var retval = [];
try {
fetch(dirHandle.entries(), retval, function () {
callbackfunc({
success: true,
content: retval
});
});
}
catch (e) {
catchFunc(e);
}
}
if (path.length == 0) {
core.init(function () {
readStep(rootdir);
});
return;
}
core.init(function () {
core.getDir(path, 0, rootdir, false, function (retval, e) {
if (retval === null) {
callbackfunc({
success: false,
content: e
});
return;
}
readStep(retval);
});
});
}
core.writes = function (path, flist, func, callbackfunc) {
var retval = [];
var dirHandle;
var returnStep = function () {
ext = null;
callbackfunc({
success: true,
content: retval
});
};
var writeStep = function (value) {
if (EncodingClass.type.isString(value)) value = EncodingClass.string.toUint8Array(value);
core.writeFileU8(value, function (r) {
retval.push({name: flist[0].name, success: r.success, content: r.content});
flist.shift();
try {
if (main.handle.flush !== undefined) main.handle.flush();
main.handle.close();
delete main.handle;
delete main.position;
if (flist.length > 0) {
openFileStep(dirHandle);
}
else {
returnStep();
}
}
catch (e) {
ext = null;
callbackfunc({
success: false,
content: e
});
}
});
};
var processStep = function (fHandle, e) {
if (fHandle === null) {
retval.push({
success: false,
content: e
});
flist.shift();
if (flist.length > 0) {
openFileStep(dirHandle);
}
else {
returnStep();
}
return;
}
main.handle = fHandle;
main.position = 0;
if (func === undefined) {
writeStep(flist[0].value);
}
else {
func(flist[0].name, flist[0].value, writeStep);
}
};
var openFileStep = function (handle, e) {
if (handle === null) {
ext = null;
callbackfunc({
success: false,
content: e
});
return;
}
dirHandle = handle;
core.openF(dirHandle, flist[0].name, "w", processStep);
};
var getDirStep = function () {
if (path.length == 0) {
openFileStep(rootdir, "directory not found!");
}
else {
core.getDir(path, 0, rootdir, false, openFileStep);
}
};
core.init(getDirStep);
};
core.reads = function (path, flist, mode, func, callbackfunc) {
var retval = [];
var dirHandle;
var transferList = [];
var readFunc;
var returnStep = function () {
ext = null;
callbackfunc({
success: true,
content: retval
}, transferList);
};
var processStep = function (value, tList) {
var i;
retval.push({name: flist[0], success: true, content: value});
if (tList !== undefined) {
for (i = 0; i < tList.length; i++) {
transferList.push(tList[i]);
}
}
flist.shift();
if (flist.length > 0) {
openFileStep(dirHandle);
}
else {
returnStep();
}
}
var readStep = function (fHandle, e) {
if (fHandle === null) {
retval.push({
name: flist[0],
success: false,
content: e
});
flist.shift();
if (flist.length > 0) {
openFileStep(dirHandle);
}
else {
returnStep();
}
return;
}
main.handle = fHandle;
main.position = 0;
readFunc(0, function (r) {
try {
main.handle.close();
delete main.handle;
delete main.position;
}
catch (e) {
ext = null;
callbackfunc({
success: false,
content: e
});
return;
}
if (r.success && (func !== undefined)) {
func(flist[0], r.content, processStep);
return;
}
retval.push({name: flist[0], success: r.success, content: r.content});
flist.shift();
if (flist.length > 0) {
openFileStep(dirHandle);
}
else {
returnStep();
}
});
}
var openFileStep = function (handle, e) {
if (handle === null) {
ext = null;
callbackfunc({
success: false,
content: e
});
return;
}
dirHandle = handle;
core.openF(dirHandle, flist[0], "r", readStep);
};
var getDirStep = function () {
if (path.length == 0) {
openFileStep(rootdir, "directory not found!");
}
else {
core.getDir(path, 0, rootdir, false, openFileStep);
}
};
switch (mode) {
case "u8":
readFunc = core.readFileU8;
break;
case "str":
default:
readFunc = core.readFile;
}
core.init(getDirStep);
};
maincore.blob = Thread.generateBlob({
extcode: EncodingClass.exportCode() +
"var rootdir, ext;\r\n" +
"core = " + EncodingClass.string.exportVariable(core) + ";\r\n",
afunc: function (params, callbackfunc) {
switch (params.task) {
case "check":
core.check(callbackfunc);
break;
case "mkdir":
core.mkdir(params.path, callbackfunc);
break;
case "fopen":
core.openFile(params.path, params.fname, params.mode, callbackfunc);
break;
case "fread":
core.readFile(params.length, callbackfunc);
break;
case "fseek":
core.seekFile(params.type, params.offset, callbackfunc);
break;
case "fwrite":
core.writeFile(params.data, callbackfunc);
break;
case "fwrite8":
core.writeFileU8(params.data, callbackfunc);
break;
case "fclose":
core.close(callbackfunc);
break;
case "delete":
core.remove(params.path, callbackfunc);
break;
case "readdir":
core.readDir(params.path, callbackfunc);
break;
case "writes":
if (params.ext !== undefined) ext = params.ext;
core.writes(params.path, params.list, EncodingClass.string.toVariable(params.func), callbackfunc);
break;
case "reads":
if (params.ext !== undefined) ext = params.ext;
core.reads(params.path, params.list, params.mode, EncodingClass.string.toVariable(params.func), callbackfunc);
break;
}
}
});
maincore.getInstance = function () {
var instance = {};
instance.thread = Thread.createFromBlob({
blobURL: maincore.blob,
callbackfunc: function (me) {
return function (retval) {
me.callbackfunc(retval);
}
} (instance)
})[0];
return instance;
};
maincore.rCall = function (functionName, extraParams) {
return function (...args) {
var x = [];
var i;
for (i = 0; i < extraParams.length; i++) {
x.push(extraParams[i]);
}
for (i = 0; i < args.length; i++) {
x.push(args[i]);
}
maincore[functionName](...x);
}
};
maincore.readFile = function (instance, callbackfunc, length) {
instance.callbackfunc = function (retval) {
callbackfunc(retval.success, retval.content);
};
if (length === undefined) length = 0;
instance.thread.acall({
task: "fread",
length: length
});
};
maincore.seekFile = function (instance, callbackfunc, type, offset) {
type = type.toLowerCase().trim();
if ((type != "seek_set") && (type != "seek_end") && (type != "seek_cur")) type = "seek_set";
instance.callbackfunc = function (retval) {
callbackfunc(retval.success, retval.content);
};
if (length === undefined) length = 0;
instance.thread.acall({
task: "fseek",
type: type,
offset: offset
});
};
maincore.writeFile = function (instance, callbackfunc, data) {
if (!EncodingClass.type.isString(data)) {
Thread.setTimeout({
func: callbackfunc,
args: [false, "invalid data"]
});
return;
}
instance.callbackfunc = function (retval) {
callbackfunc(retval.success, retval.content);
};
instance.thread.acall({
task: "fwrite",
data: data
});
};
maincore.writeFileU8 = function (instance, callbackfunc, data) {
if (!(data instanceof Uint8Array)) {
Thread.setTimeout({
func: callbackfunc,
args: [false, "invalid data"]
});
return;
}
instance.callbackfunc = function (retval) {
callbackfunc(retval.success, retval.content);
};
instance.thread.acall({
task: "fwrite8",
data: data
});
};
maincore.closeFile = function (instance, r, callbackfunc) {
instance.callbackfunc = function (retval) {
if (retval.success) {
var keys = Object.keys(r);
var i;
for (i = 0; i < keys.length; i++) delete r[keys[i]];
instance.thread.terminate();
callbackfunc(true);
}
else {
callbackfunc(retval.success, retval.content);
}
}
instance.thread.acall({
task: "fclose"
});
};
maincore.check = function (callbackfunc) {
var i;
if (navigator.userAgentData !== undefined) {
if (navigator.userAgentData.brands !== undefined) {
for (i = 0; i < navigator.userAgentData.brands.length; i++) {
if (navigator.userAgentData.brands[i].brand == "Google Chrome") {
if (navigator.userAgentData.brands[i].version < 111) {
Thread.setTimeout({
func: callbackfunc,
args: [false]
});
return;
}
break;
}
}
}
}
if (maincore.checked !== undefined) {
Thread.setTimeout({
func: callbackfunc,
args: [maincore.checked]
});
return;
}
if (maincore.checking === true) {
Thread.wait(
function () {
return maincore.checked !== undefined;
},
function () {
callbackfunc(maincore.checked);
}
);
return;
}
maincore.checking = true;
var instance = maincore.getInstance();
instance.callbackfunc = function (me) {
return function (retval) {
maincore.checked = retval;
maincore.checking = false;
Thread.setTimeout({
func: callbackfunc,
args: [maincore.checked]
});
me.thread.terminate();
}
} (instance);
instance.thread.acall({ task: "check" });
};
maincore.open = function (callbackfunc, fname, mode) {
var path = fname.split("/");
var r, i;
var instance;
if (path.length == 1) {
path = [];
}
else {
fname = path.pop();
r = [];
for (i = 0; i < path.length; i++) {
if (path[i].length > 0) r.push(path[i]);
}
path = r;
}
instance = maincore.getInstance();
instance.callbackfunc = function (me, r) {
return function (retval) {
var r = {};
if (retval.success) {
if ((mode == "r") || (mode == "rw")) {
r.read = maincore.rCall("readFile", [me]);
r.seek = maincore.rCall("seekFile", [me]);
}
if ((mode == "w") || (mode == "rw")) {
r.write = maincore.rCall("writeFile", [me]);
r.write8 = maincore.rCall("writeFileU8", [me]);
}
r.close = maincore.rCall("closeFile", [me, r]);
callbackfunc(true, r);
}
else {
callbackfunc(false, retval.content);
}
}
} (instance, r);
instance.thread.acall({
task: "fopen",
path: path,
fname: fname,
mode: mode
});
};
maincore.mkdir = function (callbackfunc, path) {
var path = path.split("/");
var r, i;
var instance;
r = [];
for (i = 0; i < path.length; i++) {
if (path[i].length > 0) r.push(path[i]);
}
path = r;
instance = maincore.getInstance();
instance.callbackfunc = function (me) {
return function (retval) {
if (retval.success) {
Thread.setTimeout({
func: callbackfunc,
args: [true]
});
}
else {
Thread.setTimeout({
func: callbackfunc,
args: [retval.success, retval.content]
});
}
me.thread.terminate();
}
} (instance);
instance.thread.acall({
task: "mkdir",
path: path
});
};
maincore.remove = function (callbackfunc, path) {
var path = path.split("/");
var r, i;
var instance;
r = [];
for (i = 0; i < path.length; i++) {
if (path[i].length > 0) r.push(path[i]);
}
path = r;
instance = maincore.getInstance();
instance.callbackfunc = function (me) {
return function (retval) {
if (retval.success) {
Thread.setTimeout({
func: callbackfunc,
args: [true]
});
}
else {
Thread.setTimeout({
func: callbackfunc,
args: [retval.success, retval.content]
});
}
me.thread.terminate();
}
} (instance);
instance.thread.acall({
task: "delete",
path: path
});
};
maincore.readDir = function (callbackfunc, path) {
var path = path.split("/");
var r, i;
var instance;
r = [];
for (i = 0; i < path.length; i++) {
if (path[i].length > 0) r.push(path[i]);
}
path = r;
instance = maincore.getInstance();
instance.callbackfunc = function (me) {
return function (retval) {
Thread.setTimeout({
func: callbackfunc,
args: [retval.success, retval.content]
});
me.thread.terminate();
}
} (instance);
instance.thread.acall({
task: "readdir",
path: path
});
};
maincore.readWholeFile = function (callbackfunc, fname) {
var handle;
var closeStep = function (success, content) {
Thread.setTimeout({
func: callbackfunc,
args: [success, content]
});
handle.close(function (success) {});
handle = null;
}
var readStep = function (success, content) {
if (!success) {
Thread.setTimeout({
func: callbackfunc,
args: [success, content]
});
return;
}
handle = content;
handle.read(closeStep);
};
maincore.open(readStep, fname, "r");
}
maincore.readFiles = function (callbackfunc, path, flist, mode, processFunc, extraParams) {
var path = path.split("/");
var r, i;
var instance;
r = [];
for (i = 0; i < path.length; i++) {
if (path[i].length > 0) r.push(path[i]);
}
path = r;
instance = maincore.getInstance();
instance.callbackfunc = function (me) {
return function (retval) {
Thread.setTimeout({
func: callbackfunc,
args: [retval.success, retval.content]
});
if (me.thread.terminate !== undefined) me.thread.terminate();
}
} (instance);
if (processFunc !== undefined) {
if (!EncodingClass.type.isFunction(processFunc)) processFunc = undefined;
}
instance.thread.acall({
task: "reads",
path: path,
list: flist,
mode: mode,
func: EncodingClass.string.fromVariable(processFunc),
ext: extraParams
});
}
maincore.writeFiles = function (callbackfunc, path, flist, processFunc, extraParams, transferList) {
var path = path.split("/");
var r, i;
var instance;
r = [];
for (i = 0; i < path.length; i++) {
if (path[i].length > 0) r.push(path[i]);
}
path = r;
instance = maincore.getInstance();
instance.callbackfunc = function (me) {
return function (retval) {
Thread.setTimeout({
func: callbackfunc,
args: [retval.success, retval.content]
});
me.thread.terminate();
}
} (instance);
if (processFunc !== undefined) {
if (!EncodingClass.type.isFunction(processFunc)) processFunc = undefined;
}
if (transferList !== undefined) {
instance.thread.acall({
task: "writes",
path: path,
list: flist,
func: EncodingClass.string.fromVariable(processFunc),
ext: extraParams
}, transferList);
}
else {
instance.thread.acall({
task: "writes",
path: path,
list: flist,
func: EncodingClass.string.fromVariable(processFunc),
ext: extraParams
});
}
}
maincore.writeWholeFile = function (callbackfunc, fname, data) {
var handle;
var closeStep = function (success, content) {
Thread.setTimeout({
func: callbackfunc,
args: [success, content]
});
handle.close(function (success) {});
handle = null;
}
var writeStep = function (success, content) {
if (!success) {
Thread.setTimeout({
func: callbackfunc,
args: [success, content]
});
return;
}
handle = content;
handle.write(closeStep, data);
};
maincore.open(writeStep, fname, "w");
}
retval.support = function (callbackfunc) {
maincore.check(callbackfunc);
}
retval.open = function (callbackfunc, fname, mode) {
mode = mode.toLowerCase().trim();
maincore.open(callbackfunc, fname, mode);
};
retval.mkdir = function (callbackfunc, pathname) {
maincore.mkdir(callbackfunc, pathname);
}
retval.remove = function (callbackfunc, pathname) {
maincore.remove(callbackfunc, pathname);
}
retval.readDir = function (callbackfunc, pathname) {
maincore.readDir(callbackfunc, pathname);
}
retval.readFile = function (callbackfunc, fname) {
maincore.readWholeFile(callbackfunc, fname);
}
retval.writeFile = function (callbackfunc, fname, data) {
maincore.writeWholeFile(callbackfunc, fname, data);
}
retval.readFiles = function (params) {
var callbackfunc, path, flist, mode, processFunc, extraParams;
callbackfunc = params.callbackfunc;
path = params.path;
flist = params.list;
mode = params.mode;
processFunc = params.processFunc;
extraParams = params.extraParams;
if ((mode != "str") && (mode != "u8")) mode = "str";
if (mode === undefined) mode = "str";
maincore.readFiles(callbackfunc, path, flist, mode, processFunc, extraParams);
}
retval.writeFiles = function (params) {
var callbackfunc, path, flist, mode, processFunc, extraParams, transferList;
callbackfunc = params.callbackfunc;
path = params.path;
flist = params.list;
processFunc = params.processFunc;
extraParams = params.extraParams;
transferList = params.transferList;
maincore.writeFiles(callbackfunc, path, flist, processFunc, extraParams, transferList);
}
return retval;
} ());
Server : Apache/2.4.41 (Ubuntu)