@quantiya/codevibe-codex-plugin 2.0.6 → 2.0.7

package/node_modules/iconv-lite/lib/index.d.ts

@@ -9,27 +9,30 @@
  * This file provides detailed typings for the public API of iconv-lite
  *-------------------------------------------------------------------------------------------- */
 
+import type Stream = require("stream")
 import type { Encoding } from "../types/encodings"
 
-// --- Options ---
-
 declare namespace iconv {
   export interface DecodeOptions {
-    /** Strip the byte order mark (BOM) from the input, when decoding. @default true */
+    /**
+     * Strip the Byte Order Mark (BOM) from the input,
+     * when decoding, if the codec is BOM-aware. @default true
+     */
     stripBOM?: boolean;
     /** Override the default endianness for `UTF-16` and `UTF-32` decodings. */
     defaultEncoding?: "utf16be" | "utf32be";
   }
 
   export interface EncodeOptions {
-    /** Add a byte order mark (BOM) to the output, when encoding. @default false */
+    /**
+     * Add a Byte Order Mark (BOM) to the output, when encoding,
+     * if the codec is BOM-aware. @default false
+     */
     addBOM?: boolean;
     /** Override the default endianness for `UTF-32` encoding. */
     defaultEncoding?: "utf32be";
   }
 
-  // --- Return values ---
-
   export interface EncoderStream {
     write(str: string): Buffer;
     end(): Buffer | undefined;
@@ -41,91 +44,86 @@ declare namespace iconv {
   }
 
   export interface Codec {
-    encoder: new (options?: EncodeOptions, codec?: any) => EncoderStream;
-    decoder: new (options?: DecodeOptions, codec?: any) => DecoderStream;
+    encoder: new (options?: EncodeOptions, codec?: Codec) => EncoderStream;
+    decoder: new (options?: DecodeOptions, codec?: Codec) => DecoderStream;
+    bomAware?: boolean;
     [key: string]: any;
   }
 
-  const iconv: {
-    // --- Basic API ---
-
-    /** Encodes a `string` into a `Buffer`, using the provided `encoding`. */
-    encode(content: string, encoding: Encoding, options?: EncodeOptions): Buffer;
-
-    /** Decodes a `Buffer` into a `string`, using the provided `encoding`. */
-    decode(buffer: Buffer | Uint8Array, encoding: Encoding, options?: DecodeOptions): string;
+  /** Encodes a `string` into a `Buffer`, using the provided `encoding`. */
+  export function encode (content: string, encoding: Encoding, options?: EncodeOptions): Buffer
 
-    /** Checks if a given encoding is supported by `iconv-lite`. */
-    encodingExists(encoding: string): encoding is Encoding;
+  /** Decodes a `Buffer` into a `string`, using the provided `encoding`. */
+  export function decode (buffer: Buffer | Uint8Array, encoding: Encoding, options?: DecodeOptions): string
 
-    // --- Legacy aliases ---
+  /** Checks if a given encoding is supported by `iconv-lite`. */
+  export function encodingExists (encoding: string): encoding is Encoding
 
-    /** Legacy alias for {@link iconv.encode}. */
-    toEncoding: typeof iconv.encode;
+  /** Legacy alias for {@link iconv.encode}. */
+  export const toEncoding: typeof iconv.encode
 
-    /** Legacy alias for {@link iconv.decode}. */
-    fromEncoding: typeof iconv.decode;
+  /** Legacy alias for {@link iconv.decode}. */
+  export const fromEncoding: typeof iconv.decode
 
-    // --- Stream API ---
+  /** Creates a stream that decodes binary data from a given `encoding` into strings. */
+  export function decodeStream (encoding: Encoding, options?: DecodeOptions): NodeJS.ReadWriteStream
 
-    /** Creates a stream that decodes binary data from a given `encoding` into strings. */
-    decodeStream(encoding: Encoding, options?: DecodeOptions): NodeJS.ReadWriteStream;
+  /** Creates a stream that encodes strings into binary data in a given `encoding`. */
+  export function encodeStream (encoding: Encoding, options?: EncodeOptions): NodeJS.ReadWriteStream
 
-    /** Creates a stream that encodes strings into binary data in a given `encoding`. */
-    encodeStream(encoding: Encoding, options?: EncodeOptions): NodeJS.ReadWriteStream;
+  /**
+   * Explicitly enable Streaming API in browser environments by passing in:
+   * ```js
+   * require('stream')
+   * ```
+   * @example iconv.enableStreamingAPI(require('stream'));
+   */
+  export function enableStreamingAPI (stream_module: { Transform: typeof Stream.Transform }): void
 
-    /**
-     * Explicitly enable Streaming API in browser environments by passing in:
-     * ```js
-     * require('stream')
-     * ```
-     * @example iconv.enableStreamingAPI(require('stream'));
-     */
-    enableStreamingAPI(stream_module: any): void;
-
-    // --- Low-level stream APIs ---
-
-    /** Creates and returns a low-level encoder stream. */
-    getEncoder(encoding: Encoding, options?: EncodeOptions): EncoderStream;
+  /** Creates and returns a low-level encoder stream. */
+  export function getEncoder (encoding: Encoding, options?: EncodeOptions): EncoderStream
 
-    /** Creates and returns a low-level decoder stream. */
-    getDecoder(encoding: Encoding, options?: DecodeOptions): DecoderStream;
+  /** Creates and returns a low-level decoder stream. */
+  export function getDecoder (encoding: Encoding, options?: DecodeOptions): DecoderStream
 
-    /**
-     * Returns a codec object for the given `encoding`.
-     * @throws If the `encoding` is not recognized.
-     */
-    getCodec(encoding: Encoding): Codec;
+  /**
+   * Returns a codec object for the given `encoding`.
+   * @throws If the `encoding` is not recognized.
+   */
+  export function getCodec (encoding: Encoding): Codec
 
-    /** Strips all non-alphanumeric characters and appended year from `encoding`. */
-    _canonicalizeEncoding(encoding: Encoding): string;
+  /** Strips all non-alphanumeric characters and appended year from `encoding`. */
+  export function _canonicalizeEncoding (encoding: Encoding): string
 
-    // --- Properties ---
+  /** A cache of all loaded encoding definitions. */
+  export let encodings: Record<
+    Encoding,
+    | string
+    | {
+      type: string;
+      [key: string]: any;
+    }
+  > | null
 
-    /** A cache of all loaded encoding definitions. */
-    encodings: Record<
-      Encoding,
-      | string
-      | {
-        type: string;
-        [key: string]: any;
-      }
-    > | null;
+  /** A cache of initialized codec objects. */
+  export let _codecDataCache: Record<string, Codec>
 
-    /** A cache of initialized codec objects. */
-    _codecDataCache: Record<string, Codec>;
+  /** The character used for untranslatable `Unicode` characters. @default "�" */
+  export let defaultCharUnicode: string
 
-    /** The character used for untranslatable `Unicode` characters. @default "�" */
-    defaultCharUnicode: string;
+  /** The character used for untranslatable `single-byte` characters. @default "?" */
+  export let defaultCharSingleByte: string
 
-    /** The character used for untranslatable `single-byte` characters. @default "?" */
-    defaultCharSingleByte: string;
+  /**
+   * Skip deprecation warning when strings are used instead of Buffers during decoding.
+   * Note: {@link iconv.decode} converts the string to Buffer regardless.
+   */
+  export let skipDecodeWarning: boolean
 
-    /** @readonly Whether or not, Streaming API is enabled. */
-    readonly supportsStreams: boolean;
-  }
+  /** @readonly Whether or not, Streaming API is enabled. */
+  export const supportsStreams: boolean
 
   export type { iconv as Iconv, Encoding }
-  export { iconv as default }
 }
+
 export = iconv

package/node_modules/iconv-lite/lib/index.js

@@ -4,22 +4,21 @@ var Buffer = require("safer-buffer").Buffer
 
 var bomHandling = require("./bom-handling")
 var mergeModules = require("./helpers/merge-exports")
-var iconv = module.exports
 
 // All codecs and aliases are kept here, keyed by encoding name/alias.
 // They are lazy loaded in `iconv.getCodec` from `encodings/index.js`.
 // Cannot initialize with { __proto__: null } because Boolean({ __proto__: null }) === true
-iconv.encodings = null
+module.exports.encodings = null
 
 // Characters emitted in case of error.
-iconv.defaultCharUnicode = "�"
-iconv.defaultCharSingleByte = "?"
+module.exports.defaultCharUnicode = "�"
+module.exports.defaultCharSingleByte = "?"
 
 // Public API.
-iconv.encode = function encode (str, encoding, options) {
+module.exports.encode = function encode (str, encoding, options) {
   str = "" + (str || "") // Ensure string.
 
-  var encoder = iconv.getEncoder(encoding, options)
+  var encoder = module.exports.getEncoder(encoding, options)
 
   var res = encoder.write(str)
   var trail = encoder.end()
@@ -27,17 +26,17 @@ iconv.encode = function encode (str, encoding, options) {
   return (trail && trail.length > 0) ? Buffer.concat([res, trail]) : res
 }
 
-iconv.decode = function decode (buf, encoding, options) {
+module.exports.decode = function decode (buf, encoding, options) {
   if (typeof buf === "string") {
-    if (!iconv.skipDecodeWarning) {
+    if (!module.exports.skipDecodeWarning) {
       console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding")
-      iconv.skipDecodeWarning = true
+      module.exports.skipDecodeWarning = true
     }
 
     buf = Buffer.from("" + (buf || ""), "binary") // Ensure buffer.
   }
 
-  var decoder = iconv.getDecoder(encoding, options)
+  var decoder = module.exports.getDecoder(encoding, options)
 
   var res = decoder.write(buf)
   var trail = decoder.end()
@@ -45,9 +44,9 @@ iconv.decode = function decode (buf, encoding, options) {
   return trail ? (res + trail) : res
 }
 
-iconv.encodingExists = function encodingExists (enc) {
+module.exports.encodingExists = function encodingExists (enc) {
   try {
-    iconv.getCodec(enc)
+    module.exports.getCodec(enc)
     return true
   } catch (e) {
     return false
@@ -55,31 +54,31 @@ iconv.encodingExists = function encodingExists (enc) {
 }
 
 // Legacy aliases to convert functions
-iconv.toEncoding = iconv.encode
-iconv.fromEncoding = iconv.decode
+module.exports.toEncoding = module.exports.encode
+module.exports.fromEncoding = module.exports.decode
 
 // Search for a codec in iconv.encodings. Cache codec data in iconv._codecDataCache.
-iconv._codecDataCache = { __proto__: null }
+module.exports._codecDataCache = { __proto__: null }
 
-iconv.getCodec = function getCodec (encoding) {
-  if (!iconv.encodings) {
+module.exports.getCodec = function getCodec (encoding) {
+  if (!module.exports.encodings) {
     var raw = require("../encodings")
     // TODO: In future versions when old nodejs support is removed can use object.assign
-    iconv.encodings = { __proto__: null } // Initialize as empty object.
-    mergeModules(iconv.encodings, raw)
+    module.exports.encodings = { __proto__: null } // Initialize as empty object.
+    mergeModules(module.exports.encodings, raw)
   }
 
   // Canonicalize encoding name: strip all non-alphanumeric chars and appended year.
-  var enc = iconv._canonicalizeEncoding(encoding)
+  var enc = module.exports._canonicalizeEncoding(encoding)
 
   // Traverse iconv.encodings to find actual codec.
   var codecOptions = {}
   while (true) {
-    var codec = iconv._codecDataCache[enc]
+    var codec = module.exports._codecDataCache[enc]
 
     if (codec) { return codec }
 
-    var codecDef = iconv.encodings[enc]
+    var codecDef = module.exports.encodings[enc]
 
     switch (typeof codecDef) {
       case "string": // Direct alias to other encoding.
@@ -100,9 +99,9 @@ iconv.getCodec = function getCodec (encoding) {
         // The codec function must load all tables and return object with .encoder and .decoder methods.
         // It'll be called only once (for each different options object).
         //
-        codec = new codecDef(codecOptions, iconv)
+        codec = new codecDef(codecOptions, module.exports)
 
-        iconv._codecDataCache[codecOptions.encodingName] = codec // Save it to be reused later.
+        module.exports._codecDataCache[codecOptions.encodingName] = codec // Save it to be reused later.
         return codec
 
       default:
@@ -111,13 +110,13 @@ iconv.getCodec = function getCodec (encoding) {
   }
 }
 
-iconv._canonicalizeEncoding = function (encoding) {
+module.exports._canonicalizeEncoding = function (encoding) {
   // Canonicalize encoding name: strip all non-alphanumeric chars and appended year.
   return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "")
 }
 
-iconv.getEncoder = function getEncoder (encoding, options) {
-  var codec = iconv.getCodec(encoding)
+module.exports.getEncoder = function getEncoder (encoding, options) {
+  var codec = module.exports.getCodec(encoding)
   var encoder = new codec.encoder(options, codec)
 
   if (codec.bomAware && options && options.addBOM) { encoder = new bomHandling.PrependBOM(encoder, options) }
@@ -125,8 +124,8 @@ iconv.getEncoder = function getEncoder (encoding, options) {
   return encoder
 }
 
-iconv.getDecoder = function getDecoder (encoding, options) {
-  var codec = iconv.getCodec(encoding)
+module.exports.getDecoder = function getDecoder (encoding, options) {
+  var codec = module.exports.getCodec(encoding)
   var decoder = new codec.decoder(options, codec)
 
   if (codec.bomAware && !(options && options.stripBOM === false)) { decoder = new bomHandling.StripBOM(decoder, options) }
@@ -139,26 +138,26 @@ iconv.getDecoder = function getDecoder (encoding, options) {
 // up to 100Kb to the output bundle. To avoid unnecessary code bloat, we don't enable Streaming API in browser by default.
 // If you would like to enable it explicitly, please add the following code to your app:
 // > iconv.enableStreamingAPI(require('stream'));
-iconv.enableStreamingAPI = function enableStreamingAPI (streamModule) {
-  if (iconv.supportsStreams) { return }
+module.exports.enableStreamingAPI = function enableStreamingAPI (streamModule) {
+  if (module.exports.supportsStreams) { return }
 
   // Dependency-inject stream module to create IconvLite stream classes.
   var streams = require("./streams")(streamModule)
 
   // Not public API yet, but expose the stream classes.
-  iconv.IconvLiteEncoderStream = streams.IconvLiteEncoderStream
-  iconv.IconvLiteDecoderStream = streams.IconvLiteDecoderStream
+  module.exports.IconvLiteEncoderStream = streams.IconvLiteEncoderStream
+  module.exports.IconvLiteDecoderStream = streams.IconvLiteDecoderStream
 
   // Streaming API.
-  iconv.encodeStream = function encodeStream (encoding, options) {
-    return new iconv.IconvLiteEncoderStream(iconv.getEncoder(encoding, options), options)
+  module.exports.encodeStream = function encodeStream (encoding, options) {
+    return new module.exports.IconvLiteEncoderStream(module.exports.getEncoder(encoding, options), options)
   }
 
-  iconv.decodeStream = function decodeStream (encoding, options) {
-    return new iconv.IconvLiteDecoderStream(iconv.getDecoder(encoding, options), options)
+  module.exports.decodeStream = function decodeStream (encoding, options) {
+    return new module.exports.IconvLiteDecoderStream(module.exports.getDecoder(encoding, options), options)
   }
 
-  iconv.supportsStreams = true
+  module.exports.supportsStreams = true
 }
 
 // Enable Streaming API automatically if 'stream' module is available and non-empty (the majority of environments).
@@ -168,10 +167,10 @@ try {
 } catch (e) {}
 
 if (streamModule && streamModule.Transform) {
-  iconv.enableStreamingAPI(streamModule)
+  module.exports.enableStreamingAPI(streamModule)
 } else {
   // In rare cases where 'stream' module is not available by default, throw a helpful exception.
-  iconv.encodeStream = iconv.decodeStream = function () {
+  module.exports.encodeStream = module.exports.decodeStream = function () {
     throw new Error("iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it.")
   }
 }

package/node_modules/iconv-lite/package.json

@@ -1,7 +1,7 @@
 {
     "name": "iconv-lite",
     "description": "Convert character encodings in pure javascript.",
-    "version": "0.7.1",
+    "version": "0.7.3",
     "license": "MIT",
     "keywords": [
         "iconv",
@@ -14,6 +14,11 @@
     "typings": "./lib/index.d.ts",
     "homepage": "https://github.com/pillarjs/iconv-lite",
     "bugs": "https://github.com/pillarjs/iconv-lite/issues",
+    "files": [
+        "lib/",
+        "encodings/",
+        "types/"
+    ],
     "funding": {
       "type": "opencollective",
       "url": "https://opencollective.com/express"
@@ -41,7 +46,7 @@
         "stream": false
     },
     "devDependencies": {
-        "@arethetypeswrong/cli": "^0.17.4",
+        "@arethetypeswrong/cli": "^0.18.4",
         "@stylistic/eslint-plugin": "^5.1.0",
         "@stylistic/eslint-plugin-js": "^4.1.0",
         "@types/node": "^24.0.12",

package/node_modules/iconv-lite/types/encodings.d.ts

@@ -276,6 +276,8 @@ export type Encoding =
   | "iso88596"
   | "iso88597"
   | "iso88598"
+  | "iso88598e"
+  | "iso88598i"
   | "iso88599"
   | "isoceltic"
   | "isoir100"

package/node_modules/ini/README.md

@@ -1,102 +1,180 @@
-An ini format parser and serializer for node.
 
-Sections are treated as nested objects.  Items before the first
-heading are saved on the object directly.
+An INI format parser & serializer.
+
+## Note
+
+-   Sections are treated as nested objects.
+
+-   Section-less items are treated as globals.
 
 ## Usage
 
-Consider an ini-file `config.ini` that looks like this:
+Consider an INI file such as the following:
+
+```ini
+; This comment is being ignored
+scope = global
+
+[database]
+user = dbuser
+password = dbpassword
+database = use_this_database
 
-    ; this comment is being ignored
-    scope = global
+[paths.default]
+datadir = /var/lib/data
+array[] = first value
+array[] = second value
+array[] = third value
+```
 
-    [database]
-    user = dbuser
-    password = dbpassword
-    database = use_this_database
+You can **read**, **modify** and **write** it like so:
 
-    [paths.default]
-    datadir = /var/lib/data
-    array[] = first value
-    array[] = second value
-    array[] = third value
+```js
+import { writeFile , readFile } from 'node:fs/promises'
+import { stringify , parse } from 'ini'
 
-You can read, manipulate and write the ini-file like so:
+//  Read INI file as text
 
-    var fs = require('fs')
-      , ini = require('ini')
+let text = await readFile(`./Original.ini`,{
+    encoding : 'utf-8'
+})
 
-    var config = ini.parse(fs.readFileSync('./config.ini', 'utf-8'))
+//  Parse text data to object
 
-    config.scope = 'local'
-    config.database.database = 'use_another_database'
-    config.paths.default.tmpdir = '/tmp'
-    delete config.paths.default.datadir
-    config.paths.default.array.push('fourth value')
+const config = parse(text)
 
-    fs.writeFileSync('./config_modified.ini', ini.stringify(config, { section: 'section' }))
+//  Modify data object
 
-This will result in a file called `config_modified.ini` being written
-to the filesystem with the following content:
+config.scope = 'local'
+config.database.database = 'use_another_database'
+config.paths.default.tmpdir = '/tmp'
+delete config.paths.default.datadir
+config.paths.default.array.push('fourth value')
 
-    [section]
-    scope=local
-    [section.database]
-    user=dbuser
-    password=dbpassword
-    database=use_another_database
-    [section.paths.default]
-    tmpdir=/tmp
-    array[]=first value
-    array[]=second value
-    array[]=third value
-    array[]=fourth value
+//  Stringify data object
 
+text = stringify(config,{ 
+    section : 'section' 
+})
+
+//  Write INI file as text
+
+await writeFile(`./Modified.ini`,text)
+```
+
+The written file will contain the following:
+
+```ini
+[section]
+scope=local
+[section.database]
+user=dbuser
+password=dbpassword
+database=use_another_database
+[section.paths.default]
+tmpdir=/tmp
+array[]=first value
+array[]=second value
+array[]=third value
+array[]=fourth value
+```
 
 ## API
 
-### decode(inistring)
+### Parse
+
+Attempts to turn the given INI string into a nested data object.
+
+```js
+// You can also use `decode`
+const object = parse(`<INI Text>`) 
+```
+
+### Stringify
+
+Encodes the given data object as an INI formatted string.
+
+```js
+// You can also use `encode`
+stringify(object,{
+
+    /**
+     *  Whether to insert spaces before & after `=`
+     * 
+     *  Disabled by default to have better 
+     *  compatibility with old picky parsers.
+     */
+
+    whitespace : false ,
+
+    /**
+     *  Whether to align the `=` character for each section.
+     *  -> Also enables the `whitespace` option
+     */
+
+    align : false ,
+
+    /**
+     *  Identifier to use for global items 
+     *  and to prepend to all other sections.
+     */
 
-Decode the ini-style formatted `inistring` into a nested object.
+    section ,
 
-### parse(inistring)
+    /**
+     *  Whether to sort all sections & their keys alphabetically.
+     */
 
-Alias for `decode(inistring)`
+    sort : false ,
 
-### encode(object, [options])
+    /**
+     *  Whether to insert a newline after each section header.
+     * 
+     *  The TOSHIBA & FlashAir parser require this format. 
+     */
 
-Encode the object `object` into an ini-style formatted string. If the
-optional parameter `section` is given, then all top-level properties
-of the object are put into this section and the `section`-string is
-prepended to all sub-sections, see the usage example above.
+    newline : false ,
 
-The `options` object may contain the following:
+    /**
+     *  Which platforms line-endings should be used.
+     * 
+     *  win32 -> CR+LF
+     *  other -> LF
+     * 
+     *  Default is the current platform
+     */
 
-* `section` A string which will be the first `section` in the encoded
-  ini data.  Defaults to none.
-* `whitespace` Boolean to specify whether to put whitespace around the
-  `=` character.  By default, whitespace is omitted, to be friendly to
-  some persnickety old parsers that don't tolerate it well.  But some
-  find that it's more human-readable and pretty with the whitespace.
+    platform ,
 
-For backwards compatibility reasons, if a `string` options is passed
-in, then it is assumed to be the `section` value.
+    /**
+     *  Whether to append `[]` to array keys.
+     * 
+     *  Some parsers treat duplicate names by themselves as arrays
+     */
 
-### stringify(object, [options])
+    bracketedArray : true
 
-Alias for `encode(object, [options])`
+})
+```
 
-### safe(val)
+*For backwards compatibility any string passed as the*  
+*options parameter is treated as the `section` option.*
 
-Escapes the string `val` such that it is safe to be used as a key or
-value in an ini-file. Basically escapes quotes. For example
+```js
+stringify(object,'section')
+```
 
-    ini.safe('"unsafe string"')
+### Un / Escape
 
-would result in
+Turn the given string into a safe to  
+use key or value in your INI file.
 
-    "\"unsafe string\""
+```js
+safe(`"unsafe string"`) // -> \"unsafe string\"
+```
 
-### unsafe(val)
+Or reverse the process with:
 
-Unescapes the string `val`
+```js
+unsafe(`\\"safe string\\"`) // -> "safe string"
+```