@reliverse/relinka 1.1.5 → 1.1.6

package/dist-npm/utils/constants.js

@@ -1,68 +1,67 @@
 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,2 +1,3 @@
-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,281 +1,260 @@
-import { Buffer } from "safe-buffer";
+import {Buffer} from 'safe-buffer';
+
+const isString = (a) => typeof a === 'string';
 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;
+    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;
         }
-        encoding = encoding.toLowerCase();
-        retried = true;
     }
-  }
 }
+
 function normalizeEncoding(enc) {
-  const nenc = _normalizeEncoding(enc);
-  if (typeof nenc !== "string" && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) {
-    throw new Error("Unknown encoding: " + enc);
-  }
-  return nenc || enc;
+    const nenc = _normalizeEncoding(enc);
+    
+    if (!isString(nenc) && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) {
+        throw 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;
+    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);
     }
-    this.lastNeed = 0;
-    this.lastTotal = 0;
-    this.lastChar = Buffer.allocUnsafe(nb);
-    this.writeFn = this.write.bind(this);
-  }
+    
     write(buf) {
-    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) : "";
+        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 || '';
     }
-    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) {
-    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;
+    end(buf) {
+        return this.endFn?.(buf) ?? '';
     }
-    return nb;
-  }
-  if (--j < i || nb === -2) {
-    return 0;
-  }
-  nb = utf8CheckByte(buf[j]);
-  if (nb >= 0) {
-    if (nb > 0) {
-      self.lastNeed = nb - 2;
+}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) {
-      if (nb === 2) {
-        nb = 0;
-      } else {
-        self.lastNeed = nb - 3;
-      }
+    
+    if (this.lastNeed <= buf.length) {
+        buf.copy(this.lastChar, p, 0, this.lastNeed);
+        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
     }
-    return nb;
-  }
-  return 0;
+    
+    buf.copy(this.lastChar, p, 0, buf.length);
+    this.lastNeed -= buf.length;
 }
-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";
+
+function utf8CheckExtraBytes(self, buf) {
+    if ((buf[0] & 192) !== 128) {
+        self.lastNeed = 0;
+        return '\uFFFD';
     }
-    if (self.lastNeed > 2 && buf.length > 2) {
-      if ((buf[2] & 192) !== 128) {
-        self.lastNeed = 2;
-        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';
+        }
     }
-  }
 }
+
 function utf16Text(buf, i) {
-  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);
-      }
+    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;
     }
-    return r;
-  }
-  this.lastNeed = 1;
-  this.lastTotal = 2;
-  this.lastChar[0] = buf[buf.length - 1];
-  return buf.toString("utf16le", i, buf.length - 1);
+    
+    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 === 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);
+    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);
 }
+
 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,6 +1,11 @@
-import { sep } from "node:path";
+import {sep} from 'node:path';
+import process from 'node:process';
+
 export function parseStack(stack) {
-  const cwd = process.cwd() + sep;
-  const lines = stack.split("\n").splice(1).map((l) => l.trim().replace("file://", "").replace(cwd, ""));
-  return lines;
+    const cwd = process.cwd() + sep;
+    
+    return stack
+        .split('\n')
+        .splice(1)
+        .map((l) => l.trim().replace('file://', '').replace(cwd, ''));
 }