@reliverse/relinka 1.1.7 → 1.1.8

package/dist-npm/utils/constants.js

@@ -1,67 +1,68 @@
 export const LogLevels = {
-    silent: Number.NEGATIVE_INFINITY,
-    fatal: 0,
-    error: 0,
-    warn: 1,
-    log: 2,
-    info: 3,
-    success: 3,
-    fail: 3,
-    ready: 3,
-    start: 3,
-    box: 3,
-    debug: 4,
-    trace: 5,
-    verbose: Number.POSITIVE_INFINITY,
+  silent: Number.NEGATIVE_INFINITY,
+  fatal: 0,
+  error: 0,
+  warn: 1,
+  log: 2,
+  info: 3,
+  success: 3,
+  fail: 3,
+  ready: 3,
+  start: 3,
+  box: 3,
+  debug: 4,
+  trace: 5,
+  verbose: Number.POSITIVE_INFINITY
 };
 export const LogTypes = {
-    silent: {
-        level: -1,
-    },
-    
-    fatal: {
-        level: LogLevels.fatal,
-    },
-    error: {
-        level: LogLevels.error,
-    },
-    
-    warn: {
-        level: LogLevels.warn,
-    },
-    
-    log: {
-        level: LogLevels.log,
-    },
-    
-    info: {
-        level: LogLevels.info,
-    },
-    success: {
-        level: LogLevels.success,
-    },
-    fail: {
-        level: LogLevels.fail,
-    },
-    ready: {
-        level: LogLevels.info,
-    },
-    start: {
-        level: LogLevels.info,
-    },
-    box: {
-        level: LogLevels.info,
-    },
-    
-    debug: {
-        level: LogLevels.debug,
-    },
-    
-    trace: {
-        level: LogLevels.trace,
-    },
-    
-    verbose: {
-        level: LogLevels.verbose,
-    },
+  
+  silent: {
+    level: -1
+  },
+  
+  fatal: {
+    level: LogLevels.fatal
+  },
+  error: {
+    level: LogLevels.error
+  },
+  
+  warn: {
+    level: LogLevels.warn
+  },
+  
+  log: {
+    level: LogLevels.log
+  },
+  
+  info: {
+    level: LogLevels.info
+  },
+  success: {
+    level: LogLevels.success
+  },
+  fail: {
+    level: LogLevels.fail
+  },
+  ready: {
+    level: LogLevels.info
+  },
+  start: {
+    level: LogLevels.info
+  },
+  box: {
+    level: LogLevels.info
+  },
+  
+  debug: {
+    level: LogLevels.debug
+  },
+  
+  trace: {
+    level: LogLevels.trace
+  },
+  
+  verbose: {
+    level: LogLevels.verbose
+  }
 };

package/dist-npm/utils/core.js

@@ -1,3 +1,2 @@
-export {createRelinka} from '../components/prompts/relinka.js';
-export * from '../components/instance/shared.js';
-
+export { createRelinka } from "../components/prompts/relinka.js";
+export * from "../components/instance/shared.js";

package/dist-npm/utils/decoder.js

@@ -1,260 +1,281 @@
-import {Buffer} from 'safe-buffer';
-
-const isString = (a) => typeof a === 'string';
+import { Buffer } from "safe-buffer";
 const isEncoding = Buffer.isEncoding || function(encoding) {
-    const enc = String(encoding).toLowerCase();
-    
-    switch(enc) {
-    case 'hex':    
-    case 'utf8':    
-    case 'utf-8':    
-    case 'ascii':    
-    case 'binary':    
-    case 'base64':    
-    case 'ucs2':    
-    case 'ucs-2':    
-    case 'utf16le':    
-    case 'utf-16le':    
-    case 'raw':
-        return true;
-    
+  const enc = String(encoding).toLowerCase();
+  switch (enc) {
+    case "hex":
+    case "utf8":
+    case "utf-8":
+    case "ascii":
+    case "binary":
+    case "base64":
+    case "ucs2":
+    case "ucs-2":
+    case "utf16le":
+    case "utf-16le":
+    case "raw":
+      return true;
     default:
-        return false;
-    }
+      return false;
+  }
 };
-
 function _normalizeEncoding(enc) {
-    if (!enc) {
-        return 'utf8';
-    }
-    
-    let retried = false;
-    let encoding = String(enc);
-    
-    while (true) {
-        switch(encoding) {
-        case 'utf8':        
-        case 'utf-8':
-            return 'utf8';
-        
-        case 'ucs2':        
-        case 'ucs-2':        
-        case 'utf16le':        
-        case 'utf-16le':
-            return 'utf16le';
-        
-        case 'latin1':        
-        case 'binary':
-            return 'latin1';
-        
-        case 'base64':        
-        case 'ascii':        
-        case 'hex':
-            return encoding;
-        
-        default:
-            if (retried) {
-                return void 0;
-            }
-            
-            encoding = encoding.toLowerCase();
-            retried = true;
+  if (!enc) {
+    return "utf8";
+  }
+  let retried = false;
+  let encoding = String(enc);
+  while (true) {
+    switch (encoding) {
+      case "utf8":
+      case "utf-8":
+        return "utf8";
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+        return "utf16le";
+      case "latin1":
+      case "binary":
+        return "latin1";
+      case "base64":
+      case "ascii":
+      case "hex":
+        return encoding;
+      default:
+        if (retried) {
+          return void 0;
         }
+        encoding = encoding.toLowerCase();
+        retried = true;
     }
+  }
 }
-
 function normalizeEncoding(enc) {
-    const nenc = _normalizeEncoding(enc);
-    
-    if (!isString(nenc) && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) {
-        throw Error(`Unknown encoding: ${enc}`);
-    }
-    
-    return nenc || enc;
+  const nenc = _normalizeEncoding(enc);
+  if (typeof nenc !== "string" && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) {
+    throw new Error("Unknown encoding: " + enc);
+  }
+  return nenc || enc;
 }
-
 export class StringDecoder {
-    encoding;
-    lastNeed;
-    lastTotal;
-    lastChar;
-    fillLast;
-    text;
-    endFn;
-    writeFn;
-    constructor(encoding) {
-        this.encoding = normalizeEncoding(encoding);
-        let nb;
-        
-        switch(this.encoding) {
-        case 'utf16le':
-            this.text = utf16Text;
-            this.endFn = utf16End;
-            nb = 4;
-            break;
-        
-        case 'utf8':
-            this.fillLast = utf8FillLast;
-            nb = 4;
-            break;
-        
-        case 'base64':
-            this.text = base64Text;
-            this.endFn = base64End;
-            nb = 3;
-            break;
-        
-        default:
-            this.writeFn = simpleWrite;
-            this.endFn = simpleEnd;
-            return;
-        }
-        
-        this.lastNeed = 0;
-        this.lastTotal = 0;
-        this.lastChar = Buffer.allocUnsafe(nb);
-        this.writeFn = this.write.bind(this);
+  encoding;
+  lastNeed;
+  lastTotal;
+  lastChar;
+  fillLast;
+  text;
+  endFn;
+  writeFn;
+  constructor(encoding) {
+    this.encoding = normalizeEncoding(encoding);
+    let nb;
+    switch (this.encoding) {
+      case "utf16le":
+        this.text = utf16Text;
+        this.endFn = utf16End;
+        nb = 4;
+        break;
+      case "utf8":
+        this.fillLast = utf8FillLast;
+        nb = 4;
+        break;
+      case "base64":
+        this.text = base64Text;
+        this.endFn = base64End;
+        nb = 3;
+        break;
+      default:
+        this.writeFn = simpleWrite;
+        this.endFn = simpleEnd;
+        return;
     }
-    
+    this.lastNeed = 0;
+    this.lastTotal = 0;
+    this.lastChar = Buffer.allocUnsafe(nb);
+    this.writeFn = this.write.bind(this);
+  }
     write(buf) {
-        if (!buf.length) {
-            return '';
-        }
-        
-        let r;
-        let i;
-        
-        if (this.lastNeed) {
-            r = this.fillLast(buf);
-            if (r === void 0) {
-                return '';
-            }
-            
-            i = this.lastNeed;
-            this.lastNeed = 0;
-        } else {
-            i = 0;
-        }
-        
-        if (i < buf.length) {
-            return r ? r + (this.text ? this.text(buf, i) : '') : this.text ? this.text(buf, i) : '';
-        }
-        
-        return r || '';
+    if (buf.length === 0) {
+      return "";
+    }
+    let r;
+    let i;
+    if (this.lastNeed) {
+      r = this.fillLast(buf);
+      if (r === void 0) {
+        return "";
+      }
+      i = this.lastNeed;
+      this.lastNeed = 0;
+    } else {
+      i = 0;
+    }
+    if (i < buf.length) {
+      return r ? r + (this.text ? this.text(buf, i) : "") : this.text ? this.text(buf, i) : "";
     }
-    /**
+    return r || "";
+  }
+  /**
    * Ends the decoding and returns any remaining characters.
    * @param buf - Optional buffer to write before ending.
    * @returns The final decoded string.
    */
-    end(buf) {
-        return this.endFn?.(buf) ?? '';
+  end(buf) {
+    const result = this.endFn?.(buf) ?? "";
+    return result;
+  }
+}
+function utf8FillLast(buf) {
+  const p = this.lastTotal - this.lastNeed;
+  const r = utf8CheckExtraBytes(this, buf, p);
+  if (r !== void 0) {
+    return r;
+  }
+  if (this.lastNeed <= buf.length) {
+    buf.copy(this.lastChar, p, 0, this.lastNeed);
+    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  }
+  buf.copy(this.lastChar, p, 0, buf.length);
+  this.lastNeed -= buf.length;
+}
+function utf8Text(buf, i) {
+  const total = utf8CheckIncomplete(this, buf, i);
+  if (!this.lastNeed) {
+    return buf.toString("utf8", i);
+  }
+  this.lastTotal = total;
+  const end = buf.length - (total - this.lastNeed);
+  buf.copy(this.lastChar, 0, end);
+  return buf.toString("utf8", i, end);
+}
+function utf8End(buf) {
+  const r = buf?.length ? this.write(buf) : "";
+  if (this.lastNeed) {
+    return r + "\uFFFD";
+  }
+  return r;
+}
+function utf8CheckByte(byte) {
+  if (byte <= 127) {
+    return 0;
+  } else if (byte >> 5 === 6) {
+    return 2;
+  } else if (byte >> 4 === 14) {
+    return 3;
+  } else if (byte >> 3 === 30) {
+    return 4;
+  }
+  return byte >> 6 === 2 ? -1 : -2;
+}
+function utf8CheckIncomplete(self, buf, i) {
+  let j = buf.length - 1;
+  if (j < i) {
+    return 0;
+  }
+  let nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) {
+      self.lastNeed = nb - 1;
     }
-}function utf8FillLast(buf) {
-    const p = this.lastTotal - this.lastNeed;
-    const r = utf8CheckExtraBytes(this, buf);
-    
-    if (r !== void 0) {
-        return r;
+    return nb;
+  }
+  if (--j < i || nb === -2) {
+    return 0;
+  }
+  nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) {
+      self.lastNeed = nb - 2;
     }
-    
-    if (this.lastNeed <= buf.length) {
-        buf.copy(this.lastChar, p, 0, this.lastNeed);
-        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+    return nb;
+  }
+  if (--j < i || nb === -2) {
+    return 0;
+  }
+  nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) {
+      if (nb === 2) {
+        nb = 0;
+      } else {
+        self.lastNeed = nb - 3;
+      }
     }
-    
-    buf.copy(this.lastChar, p, 0, buf.length);
-    this.lastNeed -= buf.length;
+    return nb;
+  }
+  return 0;
 }
-
-function utf8CheckExtraBytes(self, buf) {
-    if ((buf[0] & 192) !== 128) {
-        self.lastNeed = 0;
-        return '\uFFFD';
+function utf8CheckExtraBytes(self, buf, p) {
+  if ((buf[0] & 192) !== 128) {
+    self.lastNeed = 0;
+    return "\uFFFD";
+  }
+  if (self.lastNeed > 1 && buf.length > 1) {
+    if ((buf[1] & 192) !== 128) {
+      self.lastNeed = 1;
+      return "\uFFFD";
     }
-    
-    if (self.lastNeed > 1 && buf.length > 1) {
-        if ((buf[1] & 192) !== 128) {
-            self.lastNeed = 1;
-            return '\uFFFD';
-        }
-        
-        if (self.lastNeed > 2 && buf.length > 2 && (buf[2] & 192) !== 128) {
-            self.lastNeed = 2;
-            return '\uFFFD';
-        }
+    if (self.lastNeed > 2 && buf.length > 2) {
+      if ((buf[2] & 192) !== 128) {
+        self.lastNeed = 2;
+        return "\uFFFD";
+      }
     }
+  }
 }
-
 function utf16Text(buf, i) {
-    if (!((buf.length - i) % 2)) {
-        const r = buf.toString('utf16le', i);
-        
-        if (r) {
-            const c = r.charCodeAt(r.length - 1);
-            
-            if (c >= 55_296 && c <= 56_319) {
-                this.lastNeed = 2;
-                this.lastTotal = 4;
-                this.lastChar[0] = buf[buf.length - 2];
-                this.lastChar[1] = buf[buf.length - 1];
-                return r.slice(0, -1);
-            }
-        }
-        
-        return r;
+  if ((buf.length - i) % 2 === 0) {
+    const r = buf.toString("utf16le", i);
+    if (r) {
+      const c = r.charCodeAt(r.length - 1);
+      if (c >= 55296 && c <= 56319) {
+        this.lastNeed = 2;
+        this.lastTotal = 4;
+        this.lastChar[0] = buf[buf.length - 2];
+        this.lastChar[1] = buf[buf.length - 1];
+        return r.slice(0, -1);
+      }
     }
-    
-    this.lastNeed = 1;
-    this.lastTotal = 2;
-    this.lastChar[0] = buf[buf.length - 1];
-    return buf.toString('utf16le', i, buf.length - 1);
+    return r;
+  }
+  this.lastNeed = 1;
+  this.lastTotal = 2;
+  this.lastChar[0] = buf[buf.length - 1];
+  return buf.toString("utf16le", i, buf.length - 1);
 }
-
 function utf16End(buf) {
-    const r = buf?.length ? this.write(buf) : '';
-    
-    if (this.lastNeed) {
-        const end = this.lastTotal - this.lastNeed;
-        return r + this.lastChar.toString('utf16le', 0, end);
-    }
-    
-    return r;
+  const r = buf?.length ? this.write(buf) : "";
+  if (this.lastNeed) {
+    const end = this.lastTotal - this.lastNeed;
+    return r + this.lastChar.toString("utf16le", 0, end);
+  }
+  return r;
 }
-
 function base64Text(buf, i) {
-    const n = (buf.length - i) % 3;
-    
-    if (!n) {
-        return buf.toString('base64', i);
-    }
-    
-    this.lastNeed = 3 - n;
-    this.lastTotal = 3;
-    if (n === 1) {
-        this.lastChar[0] = buf[buf.length - 1];
-    } else {
-        this.lastChar[0] = buf[buf.length - 2];
-        this.lastChar[1] = buf[buf.length - 1];
-    }
-    
-    return buf.toString('base64', i, buf.length - n);
+  const n = (buf.length - i) % 3;
+  if (n === 0) {
+    return buf.toString("base64", i);
+  }
+  this.lastNeed = 3 - n;
+  this.lastTotal = 3;
+  if (n === 1) {
+    this.lastChar[0] = buf[buf.length - 1];
+  } else {
+    this.lastChar[0] = buf[buf.length - 2];
+    this.lastChar[1] = buf[buf.length - 1];
+  }
+  return buf.toString("base64", i, buf.length - n);
 }
-
 function base64End(buf) {
-    const r = buf?.length ? this.write(buf) : '';
-    
-    if (this.lastNeed) {
-        return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
-    }
-    
-    return r;
+  const r = buf?.length ? this.write(buf) : "";
+  if (this.lastNeed) {
+    return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
+  }
+  return r;
 }
-
 function simpleWrite(buf) {
-    return buf.toString(this.encoding);
+  return buf.toString(this.encoding);
 }
-
 function simpleEnd(buf) {
-    return buf?.length ? this.write(buf) : '';
+  return buf?.length ? this.write(buf) : "";
 }

package/dist-npm/utils/error.js

@@ -1,11 +1,6 @@
-import {sep} from 'node:path';
-import process from 'node:process';
-
+import { sep } from "node:path";
 export function parseStack(stack) {
-    const cwd = process.cwd() + sep;
-    
-    return stack
-        .split('\n')
-        .splice(1)
-        .map((l) => l.trim().replace('file://', '').replace(cwd, ''));
+  const cwd = process.cwd() + sep;
+  const lines = stack.split("\n").splice(1).map((l) => l.trim().replace("file://", "").replace(cwd, ""));
+  return lines;
 }