prpm 1.0.4 → 1.1.0

package/dist/index.js

@@ -495,6 +495,8 @@ function getDestinationDir2(format, subtype, name) {
     case "kiro":
       if (subtype === "hook") return ".kiro/hooks";
       return ".kiro/steering";
+    case "gemini":
+      return ".gemini/commands";
     case "agents.md":
       return ".";
     case "generic":
@@ -548,6 +550,7 @@ async function autoDetectFormat() {
     { format: "windsurf", dir: ".windsurf" },
     { format: "copilot", dir: ".github/instructions" },
     { format: "kiro", dir: ".kiro" },
+    { format: "gemini", dir: ".gemini" },
     { format: "agents.md", dir: ".agents" }
   ];
   for (const { format, dir } of formatDirs) {
@@ -802,6 +805,8 @@ function normalizeFormat(sourceFormat) {
     return "kiro";
   if (normalized.includes("agents.md") || normalized.includes("agentsmd"))
     return "agents.md";
+  if (normalized.includes("gemini"))
+    return "gemini";
   if (normalized.includes("mcp"))
     return "mcp";
   return "generic";
@@ -1441,7 +1446,7 @@ function constructYamlInteger(data) {
   }
   return sign * parseInt(value, 10);
 }
-function isInteger(object) {
+function isInteger2(object) {
   return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 === 0 && !common.isNegativeZero(object));
 }
 function resolveYamlFloat(data) {
@@ -1502,7 +1507,7 @@ function representYamlFloat(object, style) {
   res = object.toString(10);
   return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
 }
-function isFloat(object) {
+function isFloat2(object) {
   return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object));
 }
 function resolveYamlTimestamp(data) {
@@ -2861,14 +2866,14 @@ function isPlainSafe(c, prev, inblock) {
     (inblock ? (
       // c = flow-in
       cIsNsCharOrWhitespace
-    ) : cIsNsCharOrWhitespace && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET) && c !== CHAR_SHARP && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar
+    ) : cIsNsCharOrWhitespace && c !== CHAR_COMMA2 && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET) && c !== CHAR_SHARP && !(prev === CHAR_COLON2 && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON2 && cIsNsChar
   );
 }
 function isPlainSafeFirst(c) {
-  return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT;
+  return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON2 && c !== CHAR_COMMA2 && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS2 && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT;
 }
 function isPlainSafeLast(c) {
-  return !isWhitespace(c) && c !== CHAR_COLON;
+  return !isWhitespace(c) && c !== CHAR_COLON2;
 }
 function codePointAt(string, pos) {
   var first = string.charCodeAt(pos), second;
@@ -3311,7 +3316,7 @@ function renamed(from, to) {
     throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default.");
   };
 }
-var isNothing_1, isObject_1, toArray_1, repeat_1, isNegativeZero_1, extend_1, common, exception, snippet, TYPE_CONSTRUCTOR_OPTIONS, YAML_NODE_KINDS, type, schema, str, seq, map, failsafe, _null, bool, int, YAML_FLOAT_PATTERN, SCIENTIFIC_WITHOUT_DOT, float, json, core, YAML_DATE_REGEXP, YAML_TIMESTAMP_REGEXP, timestamp, merge, BASE64_MAP, binary, _hasOwnProperty$3, _toString$2, omap, _toString$1, pairs, _hasOwnProperty$2, set, _default, _hasOwnProperty$1, CONTEXT_FLOW_IN, CONTEXT_FLOW_OUT, CONTEXT_BLOCK_IN, CONTEXT_BLOCK_OUT, CHOMPING_CLIP, CHOMPING_STRIP, CHOMPING_KEEP, PATTERN_NON_PRINTABLE, PATTERN_NON_ASCII_LINE_BREAKS, PATTERN_FLOW_INDICATORS, PATTERN_TAG_HANDLE, PATTERN_TAG_URI, simpleEscapeCheck, simpleEscapeMap, i, directiveHandlers, loadAll_1, load_1, loader, _toString, _hasOwnProperty, CHAR_BOM, CHAR_TAB, CHAR_LINE_FEED, CHAR_CARRIAGE_RETURN, CHAR_SPACE, CHAR_EXCLAMATION, CHAR_DOUBLE_QUOTE, CHAR_SHARP, CHAR_PERCENT, CHAR_AMPERSAND, CHAR_SINGLE_QUOTE, CHAR_ASTERISK, CHAR_COMMA, CHAR_MINUS, CHAR_COLON, CHAR_EQUALS, CHAR_GREATER_THAN, CHAR_QUESTION, CHAR_COMMERCIAL_AT, CHAR_LEFT_SQUARE_BRACKET, CHAR_RIGHT_SQUARE_BRACKET, CHAR_GRAVE_ACCENT, CHAR_LEFT_CURLY_BRACKET, CHAR_VERTICAL_LINE, CHAR_RIGHT_CURLY_BRACKET, ESCAPE_SEQUENCES, DEPRECATED_BOOLEANS_SYNTAX, DEPRECATED_BASE60_SYNTAX, QUOTING_TYPE_SINGLE, QUOTING_TYPE_DOUBLE, STYLE_PLAIN, STYLE_SINGLE, STYLE_LITERAL, STYLE_FOLDED, STYLE_DOUBLE, dump_1, dumper, Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump, jsYaml;
+var isNothing_1, isObject_1, toArray_1, repeat_1, isNegativeZero_1, extend_1, common, exception, snippet, TYPE_CONSTRUCTOR_OPTIONS, YAML_NODE_KINDS, type, schema, str, seq, map, failsafe, _null, bool, int, YAML_FLOAT_PATTERN, SCIENTIFIC_WITHOUT_DOT, float, json, core, YAML_DATE_REGEXP, YAML_TIMESTAMP_REGEXP, timestamp, merge, BASE64_MAP, binary, _hasOwnProperty$3, _toString$2, omap, _toString$1, pairs, _hasOwnProperty$2, set, _default, _hasOwnProperty$1, CONTEXT_FLOW_IN, CONTEXT_FLOW_OUT, CONTEXT_BLOCK_IN, CONTEXT_BLOCK_OUT, CHOMPING_CLIP, CHOMPING_STRIP, CHOMPING_KEEP, PATTERN_NON_PRINTABLE, PATTERN_NON_ASCII_LINE_BREAKS, PATTERN_FLOW_INDICATORS, PATTERN_TAG_HANDLE, PATTERN_TAG_URI, simpleEscapeCheck, simpleEscapeMap, i, directiveHandlers, loadAll_1, load_1, loader, _toString, _hasOwnProperty, CHAR_BOM, CHAR_TAB, CHAR_LINE_FEED, CHAR_CARRIAGE_RETURN, CHAR_SPACE, CHAR_EXCLAMATION, CHAR_DOUBLE_QUOTE, CHAR_SHARP, CHAR_PERCENT, CHAR_AMPERSAND, CHAR_SINGLE_QUOTE, CHAR_ASTERISK, CHAR_COMMA2, CHAR_MINUS, CHAR_COLON2, CHAR_EQUALS2, CHAR_GREATER_THAN, CHAR_QUESTION, CHAR_COMMERCIAL_AT, CHAR_LEFT_SQUARE_BRACKET, CHAR_RIGHT_SQUARE_BRACKET, CHAR_GRAVE_ACCENT, CHAR_LEFT_CURLY_BRACKET, CHAR_VERTICAL_LINE, CHAR_RIGHT_CURLY_BRACKET, ESCAPE_SEQUENCES, DEPRECATED_BOOLEANS_SYNTAX, DEPRECATED_BASE60_SYNTAX, QUOTING_TYPE_SINGLE, QUOTING_TYPE_DOUBLE, STYLE_PLAIN, STYLE_SINGLE, STYLE_LITERAL, STYLE_FOLDED, STYLE_DOUBLE, dump_1, dumper, Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump, jsYaml;
 var init_js_yaml = __esm({
   "../converters/node_modules/js-yaml/dist/js-yaml.mjs"() {
     "use strict";
@@ -3464,7 +3469,7 @@ var init_js_yaml = __esm({
       kind: "scalar",
       resolve: resolveYamlInteger,
       construct: constructYamlInteger,
-      predicate: isInteger,
+      predicate: isInteger2,
       represent: {
         binary: function(obj) {
           return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
@@ -3497,7 +3502,7 @@ var init_js_yaml = __esm({
       kind: "scalar",
       resolve: resolveYamlFloat,
       construct: constructYamlFloat,
-      predicate: isFloat,
+      predicate: isFloat2,
       represent: representYamlFloat,
       defaultStyle: "lowercase"
     });
@@ -3653,10 +3658,10 @@ var init_js_yaml = __esm({
     CHAR_AMPERSAND = 38;
     CHAR_SINGLE_QUOTE = 39;
     CHAR_ASTERISK = 42;
-    CHAR_COMMA = 44;
+    CHAR_COMMA2 = 44;
     CHAR_MINUS = 45;
-    CHAR_COLON = 58;
-    CHAR_EQUALS = 61;
+    CHAR_COLON2 = 58;
+    CHAR_EQUALS2 = 61;
     CHAR_GREATER_THAN = 62;
     CHAR_QUESTION = 63;
     CHAR_COMMERCIAL_AT = 64;
@@ -4602,6 +4607,2072 @@ var init_from_agents_md = __esm({
   }
 });
 
+// ../../node_modules/@iarna/toml/lib/parser.js
+var require_parser = __commonJS({
+  "../../node_modules/@iarna/toml/lib/parser.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    var ParserEND = 1114112;
+    var ParserError = class _ParserError extends Error {
+      /* istanbul ignore next */
+      constructor(msg, filename, linenumber) {
+        super("[ParserError] " + msg, filename, linenumber);
+        this.name = "ParserError";
+        this.code = "ParserError";
+        if (Error.captureStackTrace) Error.captureStackTrace(this, _ParserError);
+      }
+    };
+    var State2 = class {
+      constructor(parser) {
+        this.parser = parser;
+        this.buf = "";
+        this.returned = null;
+        this.result = null;
+        this.resultTable = null;
+        this.resultArr = null;
+      }
+    };
+    var Parser = class {
+      constructor() {
+        this.pos = 0;
+        this.col = 0;
+        this.line = 0;
+        this.obj = {};
+        this.ctx = this.obj;
+        this.stack = [];
+        this._buf = "";
+        this.char = null;
+        this.ii = 0;
+        this.state = new State2(this.parseStart);
+      }
+      parse(str2) {
+        if (str2.length === 0 || str2.length == null) return;
+        this._buf = String(str2);
+        this.ii = -1;
+        this.char = -1;
+        let getNext;
+        while (getNext === false || this.nextChar()) {
+          getNext = this.runOne();
+        }
+        this._buf = null;
+      }
+      nextChar() {
+        if (this.char === 10) {
+          ++this.line;
+          this.col = -1;
+        }
+        ++this.ii;
+        this.char = this._buf.codePointAt(this.ii);
+        ++this.pos;
+        ++this.col;
+        return this.haveBuffer();
+      }
+      haveBuffer() {
+        return this.ii < this._buf.length;
+      }
+      runOne() {
+        return this.state.parser.call(this, this.state.returned);
+      }
+      finish() {
+        this.char = ParserEND;
+        let last;
+        do {
+          last = this.state.parser;
+          this.runOne();
+        } while (this.state.parser !== last);
+        this.ctx = null;
+        this.state = null;
+        this._buf = null;
+        return this.obj;
+      }
+      next(fn) {
+        if (typeof fn !== "function") throw new ParserError("Tried to set state to non-existent state: " + JSON.stringify(fn));
+        this.state.parser = fn;
+      }
+      goto(fn) {
+        this.next(fn);
+        return this.runOne();
+      }
+      call(fn, returnWith) {
+        if (returnWith) this.next(returnWith);
+        this.stack.push(this.state);
+        this.state = new State2(fn);
+      }
+      callNow(fn, returnWith) {
+        this.call(fn, returnWith);
+        return this.runOne();
+      }
+      return(value) {
+        if (this.stack.length === 0) throw this.error(new ParserError("Stack underflow"));
+        if (value === void 0) value = this.state.buf;
+        this.state = this.stack.pop();
+        this.state.returned = value;
+      }
+      returnNow(value) {
+        this.return(value);
+        return this.runOne();
+      }
+      consume() {
+        if (this.char === ParserEND) throw this.error(new ParserError("Unexpected end-of-buffer"));
+        this.state.buf += this._buf[this.ii];
+      }
+      error(err) {
+        err.line = this.line;
+        err.col = this.col;
+        err.pos = this.pos;
+        return err;
+      }
+      /* istanbul ignore next */
+      parseStart() {
+        throw new ParserError("Must declare a parseStart method");
+      }
+    };
+    Parser.END = ParserEND;
+    Parser.Error = ParserError;
+    module2.exports = Parser;
+  }
+});
+
+// ../../node_modules/@iarna/toml/lib/create-datetime.js
+var require_create_datetime = __commonJS({
+  "../../node_modules/@iarna/toml/lib/create-datetime.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    module2.exports = (value) => {
+      const date = new Date(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@iarna/toml/lib/format-num.js
+var require_format_num = __commonJS({
+  "../../node_modules/@iarna/toml/lib/format-num.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    module2.exports = (d, num) => {
+      num = String(num);
+      while (num.length < d) num = "0" + num;
+      return num;
+    };
+  }
+});
+
+// ../../node_modules/@iarna/toml/lib/create-datetime-float.js
+var require_create_datetime_float = __commonJS({
+  "../../node_modules/@iarna/toml/lib/create-datetime-float.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    var f = require_format_num();
+    var FloatingDateTime = class extends Date {
+      constructor(value) {
+        super(value + "Z");
+        this.isFloating = true;
+      }
+      toISOString() {
+        const date = `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
+        const time = `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
+        return `${date}T${time}`;
+      }
+    };
+    module2.exports = (value) => {
+      const date = new FloatingDateTime(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@iarna/toml/lib/create-date.js
+var require_create_date = __commonJS({
+  "../../node_modules/@iarna/toml/lib/create-date.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    var f = require_format_num();
+    var DateTime = global.Date;
+    var Date2 = class extends DateTime {
+      constructor(value) {
+        super(value);
+        this.isDate = true;
+      }
+      toISOString() {
+        return `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
+      }
+    };
+    module2.exports = (value) => {
+      const date = new Date2(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@iarna/toml/lib/create-time.js
+var require_create_time = __commonJS({
+  "../../node_modules/@iarna/toml/lib/create-time.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    var f = require_format_num();
+    var Time = class extends Date {
+      constructor(value) {
+        super(`0000-01-01T${value}Z`);
+        this.isTime = true;
+      }
+      toISOString() {
+        return `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
+      }
+    };
+    module2.exports = (value) => {
+      const date = new Time(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@iarna/toml/lib/toml-parser.js
+var require_toml_parser = __commonJS({
+  "../../node_modules/@iarna/toml/lib/toml-parser.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    module.exports = makeParserClass(require_parser());
+    module.exports.makeParserClass = makeParserClass;
+    var TomlError = class _TomlError extends Error {
+      constructor(msg) {
+        super(msg);
+        this.name = "TomlError";
+        if (Error.captureStackTrace) Error.captureStackTrace(this, _TomlError);
+        this.fromTOML = true;
+        this.wrapped = null;
+      }
+    };
+    TomlError.wrap = (err) => {
+      const terr = new TomlError(err.message);
+      terr.code = err.code;
+      terr.wrapped = err;
+      return terr;
+    };
+    module.exports.TomlError = TomlError;
+    var createDateTime = require_create_datetime();
+    var createDateTimeFloat = require_create_datetime_float();
+    var createDate = require_create_date();
+    var createTime = require_create_time();
+    var CTRL_I = 9;
+    var CTRL_J = 10;
+    var CTRL_M = 13;
+    var CTRL_CHAR_BOUNDARY = 31;
+    var CHAR_SP = 32;
+    var CHAR_QUOT = 34;
+    var CHAR_NUM = 35;
+    var CHAR_APOS = 39;
+    var CHAR_PLUS = 43;
+    var CHAR_COMMA = 44;
+    var CHAR_HYPHEN = 45;
+    var CHAR_PERIOD = 46;
+    var CHAR_0 = 48;
+    var CHAR_1 = 49;
+    var CHAR_7 = 55;
+    var CHAR_9 = 57;
+    var CHAR_COLON = 58;
+    var CHAR_EQUALS = 61;
+    var CHAR_A = 65;
+    var CHAR_E = 69;
+    var CHAR_F = 70;
+    var CHAR_T = 84;
+    var CHAR_U = 85;
+    var CHAR_Z = 90;
+    var CHAR_LOWBAR = 95;
+    var CHAR_a = 97;
+    var CHAR_b = 98;
+    var CHAR_e = 101;
+    var CHAR_f = 102;
+    var CHAR_i = 105;
+    var CHAR_l = 108;
+    var CHAR_n = 110;
+    var CHAR_o = 111;
+    var CHAR_r = 114;
+    var CHAR_s = 115;
+    var CHAR_t = 116;
+    var CHAR_u = 117;
+    var CHAR_x = 120;
+    var CHAR_z = 122;
+    var CHAR_LCUB = 123;
+    var CHAR_RCUB = 125;
+    var CHAR_LSQB = 91;
+    var CHAR_BSOL = 92;
+    var CHAR_RSQB = 93;
+    var CHAR_DEL = 127;
+    var SURROGATE_FIRST = 55296;
+    var SURROGATE_LAST = 57343;
+    var escapes = {
+      [CHAR_b]: "\b",
+      [CHAR_t]: "	",
+      [CHAR_n]: "\n",
+      [CHAR_f]: "\f",
+      [CHAR_r]: "\r",
+      [CHAR_QUOT]: '"',
+      [CHAR_BSOL]: "\\"
+    };
+    function isDigit(cp) {
+      return cp >= CHAR_0 && cp <= CHAR_9;
+    }
+    function isHexit(cp) {
+      return cp >= CHAR_A && cp <= CHAR_F || cp >= CHAR_a && cp <= CHAR_f || cp >= CHAR_0 && cp <= CHAR_9;
+    }
+    function isBit(cp) {
+      return cp === CHAR_1 || cp === CHAR_0;
+    }
+    function isOctit(cp) {
+      return cp >= CHAR_0 && cp <= CHAR_7;
+    }
+    function isAlphaNumQuoteHyphen(cp) {
+      return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_APOS || cp === CHAR_QUOT || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
+    }
+    function isAlphaNumHyphen(cp) {
+      return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
+    }
+    var _type = Symbol("type");
+    var _declared = Symbol("declared");
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    var defineProperty = Object.defineProperty;
+    var descriptor = { configurable: true, enumerable: true, writable: true, value: void 0 };
+    function hasKey(obj, key) {
+      if (hasOwnProperty.call(obj, key)) return true;
+      if (key === "__proto__") defineProperty(obj, "__proto__", descriptor);
+      return false;
+    }
+    var INLINE_TABLE = Symbol("inline-table");
+    function InlineTable() {
+      return Object.defineProperties({}, {
+        [_type]: { value: INLINE_TABLE }
+      });
+    }
+    function isInlineTable(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === INLINE_TABLE;
+    }
+    var TABLE = Symbol("table");
+    function Table() {
+      return Object.defineProperties({}, {
+        [_type]: { value: TABLE },
+        [_declared]: { value: false, writable: true }
+      });
+    }
+    function isTable(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === TABLE;
+    }
+    var _contentType = Symbol("content-type");
+    var INLINE_LIST = Symbol("inline-list");
+    function InlineList(type2) {
+      return Object.defineProperties([], {
+        [_type]: { value: INLINE_LIST },
+        [_contentType]: { value: type2 }
+      });
+    }
+    function isInlineList(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === INLINE_LIST;
+    }
+    var LIST = Symbol("list");
+    function List() {
+      return Object.defineProperties([], {
+        [_type]: { value: LIST }
+      });
+    }
+    function isList(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === LIST;
+    }
+    var _custom;
+    try {
+      const utilInspect = eval("require('util').inspect");
+      _custom = utilInspect.custom;
+    } catch (_) {
+    }
+    var _inspect = _custom || "inspect";
+    var BoxedBigInt = class {
+      constructor(value) {
+        try {
+          this.value = global.BigInt.asIntN(64, value);
+        } catch (_) {
+          this.value = null;
+        }
+        Object.defineProperty(this, _type, { value: INTEGER });
+      }
+      isNaN() {
+        return this.value === null;
+      }
+      /* istanbul ignore next */
+      toString() {
+        return String(this.value);
+      }
+      /* istanbul ignore next */
+      [_inspect]() {
+        return `[BigInt: ${this.toString()}]}`;
+      }
+      valueOf() {
+        return this.value;
+      }
+    };
+    var INTEGER = Symbol("integer");
+    function Integer(value) {
+      let num = Number(value);
+      if (Object.is(num, -0)) num = 0;
+      if (global.BigInt && !Number.isSafeInteger(num)) {
+        return new BoxedBigInt(value);
+      } else {
+        return Object.defineProperties(new Number(num), {
+          isNaN: { value: function() {
+            return isNaN(this);
+          } },
+          [_type]: { value: INTEGER },
+          [_inspect]: { value: () => `[Integer: ${value}]` }
+        });
+      }
+    }
+    function isInteger(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === INTEGER;
+    }
+    var FLOAT = Symbol("float");
+    function Float(value) {
+      return Object.defineProperties(new Number(value), {
+        [_type]: { value: FLOAT },
+        [_inspect]: { value: () => `[Float: ${value}]` }
+      });
+    }
+    function isFloat(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === FLOAT;
+    }
+    function tomlType(value) {
+      const type2 = typeof value;
+      if (type2 === "object") {
+        if (value === null) return "null";
+        if (value instanceof Date) return "datetime";
+        if (_type in value) {
+          switch (value[_type]) {
+            case INLINE_TABLE:
+              return "inline-table";
+            case INLINE_LIST:
+              return "inline-list";
+            /* istanbul ignore next */
+            case TABLE:
+              return "table";
+            /* istanbul ignore next */
+            case LIST:
+              return "list";
+            case FLOAT:
+              return "float";
+            case INTEGER:
+              return "integer";
+          }
+        }
+      }
+      return type2;
+    }
+    function makeParserClass(Parser) {
+      class TOMLParser extends Parser {
+        constructor() {
+          super();
+          this.ctx = this.obj = Table();
+        }
+        /* MATCH HELPER */
+        atEndOfWord() {
+          return this.char === CHAR_NUM || this.char === CTRL_I || this.char === CHAR_SP || this.atEndOfLine();
+        }
+        atEndOfLine() {
+          return this.char === Parser.END || this.char === CTRL_J || this.char === CTRL_M;
+        }
+        parseStart() {
+          if (this.char === Parser.END) {
+            return null;
+          } else if (this.char === CHAR_LSQB) {
+            return this.call(this.parseTableOrList);
+          } else if (this.char === CHAR_NUM) {
+            return this.call(this.parseComment);
+          } else if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+            return null;
+          } else if (isAlphaNumQuoteHyphen(this.char)) {
+            return this.callNow(this.parseAssignStatement);
+          } else {
+            throw this.error(new TomlError(`Unknown character "${this.char}"`));
+          }
+        }
+        // HELPER, this strips any whitespace and comments to the end of the line
+        // then RETURNS. Last state in a production.
+        parseWhitespaceToEOL() {
+          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+            return null;
+          } else if (this.char === CHAR_NUM) {
+            return this.goto(this.parseComment);
+          } else if (this.char === Parser.END || this.char === CTRL_J) {
+            return this.return();
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected only whitespace or comments till end of line"));
+          }
+        }
+        /* ASSIGNMENT: key = value */
+        parseAssignStatement() {
+          return this.callNow(this.parseAssign, this.recordAssignStatement);
+        }
+        recordAssignStatement(kv) {
+          let target = this.ctx;
+          let finalKey = kv.key.pop();
+          for (let kw of kv.key) {
+            if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            }
+            target = target[kw] = target[kw] || Table();
+          }
+          if (hasKey(target, finalKey)) {
+            throw this.error(new TomlError("Can't redefine existing key"));
+          }
+          if (isInteger(kv.value) || isFloat(kv.value)) {
+            target[finalKey] = kv.value.valueOf();
+          } else {
+            target[finalKey] = kv.value;
+          }
+          return this.goto(this.parseWhitespaceToEOL);
+        }
+        /* ASSSIGNMENT expression, key = value possibly inside an inline table */
+        parseAssign() {
+          return this.callNow(this.parseKeyword, this.recordAssignKeyword);
+        }
+        recordAssignKeyword(key) {
+          if (this.state.resultTable) {
+            this.state.resultTable.push(key);
+          } else {
+            this.state.resultTable = [key];
+          }
+          return this.goto(this.parseAssignKeywordPreDot);
+        }
+        parseAssignKeywordPreDot() {
+          if (this.char === CHAR_PERIOD) {
+            return this.next(this.parseAssignKeywordPostDot);
+          } else if (this.char !== CHAR_SP && this.char !== CTRL_I) {
+            return this.goto(this.parseAssignEqual);
+          }
+        }
+        parseAssignKeywordPostDot() {
+          if (this.char !== CHAR_SP && this.char !== CTRL_I) {
+            return this.callNow(this.parseKeyword, this.recordAssignKeyword);
+          }
+        }
+        parseAssignEqual() {
+          if (this.char === CHAR_EQUALS) {
+            return this.next(this.parseAssignPreValue);
+          } else {
+            throw this.error(new TomlError('Invalid character, expected "="'));
+          }
+        }
+        parseAssignPreValue() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else {
+            return this.callNow(this.parseValue, this.recordAssignValue);
+          }
+        }
+        recordAssignValue(value) {
+          return this.returnNow({ key: this.state.resultTable, value });
+        }
+        /* COMMENTS: #...eol */
+        parseComment() {
+          do {
+            if (this.char === Parser.END || this.char === CTRL_J) {
+              return this.return();
+            }
+          } while (this.nextChar());
+        }
+        /* TABLES AND LISTS, [foo] and [[foo]] */
+        parseTableOrList() {
+          if (this.char === CHAR_LSQB) {
+            this.next(this.parseList);
+          } else {
+            return this.goto(this.parseTable);
+          }
+        }
+        /* TABLE [foo.bar.baz] */
+        parseTable() {
+          this.ctx = this.obj;
+          return this.goto(this.parseTableNext);
+        }
+        parseTableNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else {
+            return this.callNow(this.parseKeyword, this.parseTableMore);
+          }
+        }
+        parseTableMore(keyword) {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === CHAR_RSQB) {
+            if (hasKey(this.ctx, keyword) && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            } else {
+              this.ctx = this.ctx[keyword] = this.ctx[keyword] || Table();
+              this.ctx[_declared] = true;
+            }
+            return this.next(this.parseWhitespaceToEOL);
+          } else if (this.char === CHAR_PERIOD) {
+            if (!hasKey(this.ctx, keyword)) {
+              this.ctx = this.ctx[keyword] = Table();
+            } else if (isTable(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword];
+            } else if (isList(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+            } else {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            }
+            return this.next(this.parseTableNext);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+          }
+        }
+        /* LIST [[a.b.c]] */
+        parseList() {
+          this.ctx = this.obj;
+          return this.goto(this.parseListNext);
+        }
+        parseListNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else {
+            return this.callNow(this.parseKeyword, this.parseListMore);
+          }
+        }
+        parseListMore(keyword) {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === CHAR_RSQB) {
+            if (!hasKey(this.ctx, keyword)) {
+              this.ctx[keyword] = List();
+            }
+            if (isInlineList(this.ctx[keyword])) {
+              throw this.error(new TomlError("Can't extend an inline array"));
+            } else if (isList(this.ctx[keyword])) {
+              const next = Table();
+              this.ctx[keyword].push(next);
+              this.ctx = next;
+            } else {
+              throw this.error(new TomlError("Can't redefine an existing key"));
+            }
+            return this.next(this.parseListEnd);
+          } else if (this.char === CHAR_PERIOD) {
+            if (!hasKey(this.ctx, keyword)) {
+              this.ctx = this.ctx[keyword] = Table();
+            } else if (isInlineList(this.ctx[keyword])) {
+              throw this.error(new TomlError("Can't extend an inline array"));
+            } else if (isInlineTable(this.ctx[keyword])) {
+              throw this.error(new TomlError("Can't extend an inline table"));
+            } else if (isList(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+            } else if (isTable(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword];
+            } else {
+              throw this.error(new TomlError("Can't redefine an existing key"));
+            }
+            return this.next(this.parseListNext);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+          }
+        }
+        parseListEnd(keyword) {
+          if (this.char === CHAR_RSQB) {
+            return this.next(this.parseWhitespaceToEOL);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+          }
+        }
+        /* VALUE string, number, boolean, inline list, inline object */
+        parseValue() {
+          if (this.char === Parser.END) {
+            throw this.error(new TomlError("Key without value"));
+          } else if (this.char === CHAR_QUOT) {
+            return this.next(this.parseDoubleString);
+          }
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseSingleString);
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            return this.goto(this.parseNumberSign);
+          } else if (this.char === CHAR_i) {
+            return this.next(this.parseInf);
+          } else if (this.char === CHAR_n) {
+            return this.next(this.parseNan);
+          } else if (isDigit(this.char)) {
+            return this.goto(this.parseNumberOrDateTime);
+          } else if (this.char === CHAR_t || this.char === CHAR_f) {
+            return this.goto(this.parseBoolean);
+          } else if (this.char === CHAR_LSQB) {
+            return this.call(this.parseInlineList, this.recordValue);
+          } else if (this.char === CHAR_LCUB) {
+            return this.call(this.parseInlineTable, this.recordValue);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expecting string, number, datetime, boolean, inline array or inline table"));
+          }
+        }
+        recordValue(value) {
+          return this.returnNow(value);
+        }
+        parseInf() {
+          if (this.char === CHAR_n) {
+            return this.next(this.parseInf2);
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
+          }
+        }
+        parseInf2() {
+          if (this.char === CHAR_f) {
+            if (this.state.buf === "-") {
+              return this.return(-Infinity);
+            } else {
+              return this.return(Infinity);
+            }
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
+          }
+        }
+        parseNan() {
+          if (this.char === CHAR_a) {
+            return this.next(this.parseNan2);
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "nan"'));
+          }
+        }
+        parseNan2() {
+          if (this.char === CHAR_n) {
+            return this.return(NaN);
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "nan"'));
+          }
+        }
+        /* KEYS, barewords or basic, literal, or dotted */
+        parseKeyword() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseBasicString);
+          } else if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralString);
+          } else {
+            return this.goto(this.parseBareKey);
+          }
+        }
+        /* KEYS: barewords */
+        parseBareKey() {
+          do {
+            if (this.char === Parser.END) {
+              throw this.error(new TomlError("Key ended without value"));
+            } else if (isAlphaNumHyphen(this.char)) {
+              this.consume();
+            } else if (this.state.buf.length === 0) {
+              throw this.error(new TomlError("Empty bare keys are not allowed"));
+            } else {
+              return this.returnNow();
+            }
+          } while (this.nextChar());
+        }
+        /* STRINGS, single quoted (literal) */
+        parseSingleString() {
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralMultiStringMaybe);
+          } else {
+            return this.goto(this.parseLiteralString);
+          }
+        }
+        parseLiteralString() {
+          do {
+            if (this.char === CHAR_APOS) {
+              return this.return();
+            } else if (this.atEndOfLine()) {
+              throw this.error(new TomlError("Unterminated string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        parseLiteralMultiStringMaybe() {
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralMultiString);
+          } else {
+            return this.returnNow();
+          }
+        }
+        parseLiteralMultiString() {
+          if (this.char === CTRL_M) {
+            return null;
+          } else if (this.char === CTRL_J) {
+            return this.next(this.parseLiteralMultiStringContent);
+          } else {
+            return this.goto(this.parseLiteralMultiStringContent);
+          }
+        }
+        parseLiteralMultiStringContent() {
+          do {
+            if (this.char === CHAR_APOS) {
+              return this.next(this.parseLiteralMultiEnd);
+            } else if (this.char === Parser.END) {
+              throw this.error(new TomlError("Unterminated multi-line string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        parseLiteralMultiEnd() {
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralMultiEnd2);
+          } else {
+            this.state.buf += "'";
+            return this.goto(this.parseLiteralMultiStringContent);
+          }
+        }
+        parseLiteralMultiEnd2() {
+          if (this.char === CHAR_APOS) {
+            return this.return();
+          } else {
+            this.state.buf += "''";
+            return this.goto(this.parseLiteralMultiStringContent);
+          }
+        }
+        /* STRINGS double quoted */
+        parseDoubleString() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseMultiStringMaybe);
+          } else {
+            return this.goto(this.parseBasicString);
+          }
+        }
+        parseBasicString() {
+          do {
+            if (this.char === CHAR_BSOL) {
+              return this.call(this.parseEscape, this.recordEscapeReplacement);
+            } else if (this.char === CHAR_QUOT) {
+              return this.return();
+            } else if (this.atEndOfLine()) {
+              throw this.error(new TomlError("Unterminated string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        recordEscapeReplacement(replacement) {
+          this.state.buf += replacement;
+          return this.goto(this.parseBasicString);
+        }
+        parseMultiStringMaybe() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseMultiString);
+          } else {
+            return this.returnNow();
+          }
+        }
+        parseMultiString() {
+          if (this.char === CTRL_M) {
+            return null;
+          } else if (this.char === CTRL_J) {
+            return this.next(this.parseMultiStringContent);
+          } else {
+            return this.goto(this.parseMultiStringContent);
+          }
+        }
+        parseMultiStringContent() {
+          do {
+            if (this.char === CHAR_BSOL) {
+              return this.call(this.parseMultiEscape, this.recordMultiEscapeReplacement);
+            } else if (this.char === CHAR_QUOT) {
+              return this.next(this.parseMultiEnd);
+            } else if (this.char === Parser.END) {
+              throw this.error(new TomlError("Unterminated multi-line string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        errorControlCharInString() {
+          let displayCode = "\\u00";
+          if (this.char < 16) {
+            displayCode += "0";
+          }
+          displayCode += this.char.toString(16);
+          return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode} instead`));
+        }
+        recordMultiEscapeReplacement(replacement) {
+          this.state.buf += replacement;
+          return this.goto(this.parseMultiStringContent);
+        }
+        parseMultiEnd() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseMultiEnd2);
+          } else {
+            this.state.buf += '"';
+            return this.goto(this.parseMultiStringContent);
+          }
+        }
+        parseMultiEnd2() {
+          if (this.char === CHAR_QUOT) {
+            return this.return();
+          } else {
+            this.state.buf += '""';
+            return this.goto(this.parseMultiStringContent);
+          }
+        }
+        parseMultiEscape() {
+          if (this.char === CTRL_M || this.char === CTRL_J) {
+            return this.next(this.parseMultiTrim);
+          } else if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return this.next(this.parsePreMultiTrim);
+          } else {
+            return this.goto(this.parseEscape);
+          }
+        }
+        parsePreMultiTrim() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === CTRL_M || this.char === CTRL_J) {
+            return this.next(this.parseMultiTrim);
+          } else {
+            throw this.error(new TomlError("Can't escape whitespace"));
+          }
+        }
+        parseMultiTrim() {
+          if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+            return null;
+          } else {
+            return this.returnNow();
+          }
+        }
+        parseEscape() {
+          if (this.char in escapes) {
+            return this.return(escapes[this.char]);
+          } else if (this.char === CHAR_u) {
+            return this.call(this.parseSmallUnicode, this.parseUnicodeReturn);
+          } else if (this.char === CHAR_U) {
+            return this.call(this.parseLargeUnicode, this.parseUnicodeReturn);
+          } else {
+            throw this.error(new TomlError("Unknown escape character: " + this.char));
+          }
+        }
+        parseUnicodeReturn(char) {
+          try {
+            const codePoint = parseInt(char, 16);
+            if (codePoint >= SURROGATE_FIRST && codePoint <= SURROGATE_LAST) {
+              throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
+            }
+            return this.returnNow(String.fromCodePoint(codePoint));
+          } catch (err) {
+            throw this.error(TomlError.wrap(err));
+          }
+        }
+        parseSmallUnicode() {
+          if (!isHexit(this.char)) {
+            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
+          } else {
+            this.consume();
+            if (this.state.buf.length >= 4) return this.return();
+          }
+        }
+        parseLargeUnicode() {
+          if (!isHexit(this.char)) {
+            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
+          } else {
+            this.consume();
+            if (this.state.buf.length >= 8) return this.return();
+          }
+        }
+        /* NUMBERS */
+        parseNumberSign() {
+          this.consume();
+          return this.next(this.parseMaybeSignedInfOrNan);
+        }
+        parseMaybeSignedInfOrNan() {
+          if (this.char === CHAR_i) {
+            return this.next(this.parseInf);
+          } else if (this.char === CHAR_n) {
+            return this.next(this.parseNan);
+          } else {
+            return this.callNow(this.parseNoUnder, this.parseNumberIntegerStart);
+          }
+        }
+        parseNumberIntegerStart() {
+          if (this.char === CHAR_0) {
+            this.consume();
+            return this.next(this.parseNumberIntegerExponentOrDecimal);
+          } else {
+            return this.goto(this.parseNumberInteger);
+          }
+        }
+        parseNumberIntegerExponentOrDecimal() {
+          if (this.char === CHAR_PERIOD) {
+            this.consume();
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else {
+            return this.returnNow(Integer(this.state.buf));
+          }
+        }
+        parseNumberInteger() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder);
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else if (this.char === CHAR_PERIOD) {
+            this.consume();
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        parseNoUnder() {
+          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD || this.char === CHAR_E || this.char === CHAR_e) {
+            throw this.error(new TomlError("Unexpected character, expected digit"));
+          } else if (this.atEndOfWord()) {
+            throw this.error(new TomlError("Incomplete number"));
+          }
+          return this.returnNow();
+        }
+        parseNoUnderHexOctBinLiteral() {
+          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD) {
+            throw this.error(new TomlError("Unexpected character, expected digit"));
+          } else if (this.atEndOfWord()) {
+            throw this.error(new TomlError("Incomplete number"));
+          }
+          return this.returnNow();
+        }
+        parseNumberFloat() {
+          if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else {
+            return this.returnNow(Float(this.state.buf));
+          }
+        }
+        parseNumberExponentSign() {
+          if (isDigit(this.char)) {
+            return this.goto(this.parseNumberExponent);
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            this.consume();
+            this.call(this.parseNoUnder, this.parseNumberExponent);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected -, + or digit"));
+          }
+        }
+        parseNumberExponent() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder);
+          } else {
+            return this.returnNow(Float(this.state.buf));
+          }
+        }
+        /* NUMBERS or DATETIMES  */
+        parseNumberOrDateTime() {
+          if (this.char === CHAR_0) {
+            this.consume();
+            return this.next(this.parseNumberBaseOrDateTime);
+          } else {
+            return this.goto(this.parseNumberOrDateTimeOnly);
+          }
+        }
+        parseNumberOrDateTimeOnly() {
+          if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder, this.parseNumberInteger);
+          } else if (isDigit(this.char)) {
+            this.consume();
+            if (this.state.buf.length > 4) this.next(this.parseNumberInteger);
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else if (this.char === CHAR_PERIOD) {
+            this.consume();
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else if (this.char === CHAR_HYPHEN) {
+            return this.goto(this.parseDateTime);
+          } else if (this.char === CHAR_COLON) {
+            return this.goto(this.parseOnlyTimeHour);
+          } else {
+            return this.returnNow(Integer(this.state.buf));
+          }
+        }
+        parseDateTimeOnly() {
+          if (this.state.buf.length < 4) {
+            if (isDigit(this.char)) {
+              return this.consume();
+            } else if (this.char === CHAR_COLON) {
+              return this.goto(this.parseOnlyTimeHour);
+            } else {
+              throw this.error(new TomlError("Expected digit while parsing year part of a date"));
+            }
+          } else {
+            if (this.char === CHAR_HYPHEN) {
+              return this.goto(this.parseDateTime);
+            } else {
+              throw this.error(new TomlError("Expected hyphen (-) while parsing year part of date"));
+            }
+          }
+        }
+        parseNumberBaseOrDateTime() {
+          if (this.char === CHAR_b) {
+            this.consume();
+            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerBin);
+          } else if (this.char === CHAR_o) {
+            this.consume();
+            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerOct);
+          } else if (this.char === CHAR_x) {
+            this.consume();
+            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerHex);
+          } else if (this.char === CHAR_PERIOD) {
+            return this.goto(this.parseNumberInteger);
+          } else if (isDigit(this.char)) {
+            return this.goto(this.parseDateTimeOnly);
+          } else {
+            return this.returnNow(Integer(this.state.buf));
+          }
+        }
+        parseIntegerHex() {
+          if (isHexit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnderHexOctBinLiteral);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        parseIntegerOct() {
+          if (isOctit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnderHexOctBinLiteral);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        parseIntegerBin() {
+          if (isBit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnderHexOctBinLiteral);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        /* DATETIME */
+        parseDateTime() {
+          if (this.state.buf.length < 4) {
+            throw this.error(new TomlError("Years less than 1000 must be zero padded to four characters"));
+          }
+          this.state.result = this.state.buf;
+          this.state.buf = "";
+          return this.next(this.parseDateMonth);
+        }
+        parseDateMonth() {
+          if (this.char === CHAR_HYPHEN) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Months less than 10 must be zero padded to two characters"));
+            }
+            this.state.result += "-" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseDateDay);
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseDateDay() {
+          if (this.char === CHAR_T || this.char === CHAR_SP) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Days less than 10 must be zero padded to two characters"));
+            }
+            this.state.result += "-" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseStartTimeHour);
+          } else if (this.atEndOfWord()) {
+            return this.returnNow(createDate(this.state.result + "-" + this.state.buf));
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseStartTimeHour() {
+          if (this.atEndOfWord()) {
+            return this.returnNow(createDate(this.state.result));
+          } else {
+            return this.goto(this.parseTimeHour);
+          }
+        }
+        parseTimeHour() {
+          if (this.char === CHAR_COLON) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
+            }
+            this.state.result += "T" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseTimeMin);
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseTimeMin() {
+          if (this.state.buf.length < 2 && isDigit(this.char)) {
+            this.consume();
+          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
+            this.state.result += ":" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseTimeSec);
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseTimeSec() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (this.state.buf.length === 2) {
+              this.state.result += ":" + this.state.buf;
+              this.state.buf = "";
+              return this.next(this.parseTimeZoneOrFraction);
+            }
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseOnlyTimeHour() {
+          if (this.char === CHAR_COLON) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
+            }
+            this.state.result = this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseOnlyTimeMin);
+          } else {
+            throw this.error(new TomlError("Incomplete time"));
+          }
+        }
+        parseOnlyTimeMin() {
+          if (this.state.buf.length < 2 && isDigit(this.char)) {
+            this.consume();
+          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
+            this.state.result += ":" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseOnlyTimeSec);
+          } else {
+            throw this.error(new TomlError("Incomplete time"));
+          }
+        }
+        parseOnlyTimeSec() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (this.state.buf.length === 2) {
+              return this.next(this.parseOnlyTimeFractionMaybe);
+            }
+          } else {
+            throw this.error(new TomlError("Incomplete time"));
+          }
+        }
+        parseOnlyTimeFractionMaybe() {
+          this.state.result += ":" + this.state.buf;
+          if (this.char === CHAR_PERIOD) {
+            this.state.buf = "";
+            this.next(this.parseOnlyTimeFraction);
+          } else {
+            return this.return(createTime(this.state.result));
+          }
+        }
+        parseOnlyTimeFraction() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.atEndOfWord()) {
+            if (this.state.buf.length === 0) throw this.error(new TomlError("Expected digit in milliseconds"));
+            return this.returnNow(createTime(this.state.result + "." + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+          }
+        }
+        parseTimeZoneOrFraction() {
+          if (this.char === CHAR_PERIOD) {
+            this.consume();
+            this.next(this.parseDateTimeFraction);
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            this.consume();
+            this.next(this.parseTimeZoneHour);
+          } else if (this.char === CHAR_Z) {
+            this.consume();
+            return this.return(createDateTime(this.state.result + this.state.buf));
+          } else if (this.atEndOfWord()) {
+            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+          }
+        }
+        parseDateTimeFraction() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.state.buf.length === 1) {
+            throw this.error(new TomlError("Expected digit in milliseconds"));
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            this.consume();
+            this.next(this.parseTimeZoneHour);
+          } else if (this.char === CHAR_Z) {
+            this.consume();
+            return this.return(createDateTime(this.state.result + this.state.buf));
+          } else if (this.atEndOfWord()) {
+            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+          }
+        }
+        parseTimeZoneHour() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (/\d\d$/.test(this.state.buf)) return this.next(this.parseTimeZoneSep);
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
+          }
+        }
+        parseTimeZoneSep() {
+          if (this.char === CHAR_COLON) {
+            this.consume();
+            this.next(this.parseTimeZoneMin);
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected colon"));
+          }
+        }
+        parseTimeZoneMin() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (/\d\d$/.test(this.state.buf)) return this.return(createDateTime(this.state.result + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
+          }
+        }
+        /* BOOLEAN */
+        parseBoolean() {
+          if (this.char === CHAR_t) {
+            this.consume();
+            return this.next(this.parseTrue_r);
+          } else if (this.char === CHAR_f) {
+            this.consume();
+            return this.next(this.parseFalse_a);
+          }
+        }
+        parseTrue_r() {
+          if (this.char === CHAR_r) {
+            this.consume();
+            return this.next(this.parseTrue_u);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseTrue_u() {
+          if (this.char === CHAR_u) {
+            this.consume();
+            return this.next(this.parseTrue_e);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseTrue_e() {
+          if (this.char === CHAR_e) {
+            return this.return(true);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_a() {
+          if (this.char === CHAR_a) {
+            this.consume();
+            return this.next(this.parseFalse_l);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_l() {
+          if (this.char === CHAR_l) {
+            this.consume();
+            return this.next(this.parseFalse_s);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_s() {
+          if (this.char === CHAR_s) {
+            this.consume();
+            return this.next(this.parseFalse_e);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_e() {
+          if (this.char === CHAR_e) {
+            return this.return(false);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        /* INLINE LISTS */
+        parseInlineList() {
+          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
+            return null;
+          } else if (this.char === Parser.END) {
+            throw this.error(new TomlError("Unterminated inline array"));
+          } else if (this.char === CHAR_NUM) {
+            return this.call(this.parseComment);
+          } else if (this.char === CHAR_RSQB) {
+            return this.return(this.state.resultArr || InlineList());
+          } else {
+            return this.callNow(this.parseValue, this.recordInlineListValue);
+          }
+        }
+        recordInlineListValue(value) {
+          if (this.state.resultArr) {
+            const listType = this.state.resultArr[_contentType];
+            const valueType = tomlType(value);
+            if (listType !== valueType) {
+              throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType} and ${valueType}`));
+            }
+          } else {
+            this.state.resultArr = InlineList(tomlType(value));
+          }
+          if (isFloat(value) || isInteger(value)) {
+            this.state.resultArr.push(value.valueOf());
+          } else {
+            this.state.resultArr.push(value);
+          }
+          return this.goto(this.parseInlineListNext);
+        }
+        parseInlineListNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
+            return null;
+          } else if (this.char === CHAR_NUM) {
+            return this.call(this.parseComment);
+          } else if (this.char === CHAR_COMMA) {
+            return this.next(this.parseInlineList);
+          } else if (this.char === CHAR_RSQB) {
+            return this.goto(this.parseInlineList);
+          } else {
+            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
+          }
+        }
+        /* INLINE TABLE */
+        parseInlineTable() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
+            throw this.error(new TomlError("Unterminated inline array"));
+          } else if (this.char === CHAR_RCUB) {
+            return this.return(this.state.resultTable || InlineTable());
+          } else {
+            if (!this.state.resultTable) this.state.resultTable = InlineTable();
+            return this.callNow(this.parseAssign, this.recordInlineTableValue);
+          }
+        }
+        recordInlineTableValue(kv) {
+          let target = this.state.resultTable;
+          let finalKey = kv.key.pop();
+          for (let kw of kv.key) {
+            if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            }
+            target = target[kw] = target[kw] || Table();
+          }
+          if (hasKey(target, finalKey)) {
+            throw this.error(new TomlError("Can't redefine existing key"));
+          }
+          if (isInteger(kv.value) || isFloat(kv.value)) {
+            target[finalKey] = kv.value.valueOf();
+          } else {
+            target[finalKey] = kv.value;
+          }
+          return this.goto(this.parseInlineTableNext);
+        }
+        parseInlineTableNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
+            throw this.error(new TomlError("Unterminated inline array"));
+          } else if (this.char === CHAR_COMMA) {
+            return this.next(this.parseInlineTable);
+          } else if (this.char === CHAR_RCUB) {
+            return this.goto(this.parseInlineTable);
+          } else {
+            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
+          }
+        }
+      }
+      return TOMLParser;
+    }
+  }
+});
+
+// ../../node_modules/@iarna/toml/parse-pretty-error.js
+var require_parse_pretty_error = __commonJS({
+  "../../node_modules/@iarna/toml/parse-pretty-error.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    module2.exports = prettyError;
+    function prettyError(err, buf) {
+      if (err.pos == null || err.line == null) return err;
+      let msg = err.message;
+      msg += ` at row ${err.line + 1}, col ${err.col + 1}, pos ${err.pos}:
+`;
+      if (buf && buf.split) {
+        const lines = buf.split(/\n/);
+        const lineNumWidth = String(Math.min(lines.length, err.line + 3)).length;
+        let linePadding = " ";
+        while (linePadding.length < lineNumWidth) linePadding += " ";
+        for (let ii = Math.max(0, err.line - 1); ii < Math.min(lines.length, err.line + 2); ++ii) {
+          let lineNum = String(ii + 1);
+          if (lineNum.length < lineNumWidth) lineNum = " " + lineNum;
+          if (err.line === ii) {
+            msg += lineNum + "> " + lines[ii] + "\n";
+            msg += linePadding + "  ";
+            for (let hh = 0; hh < err.col; ++hh) {
+              msg += " ";
+            }
+            msg += "^\n";
+          } else {
+            msg += lineNum + ": " + lines[ii] + "\n";
+          }
+        }
+      }
+      err.message = msg + "\n";
+      return err;
+    }
+  }
+});
+
+// ../../node_modules/@iarna/toml/parse-string.js
+var require_parse_string = __commonJS({
+  "../../node_modules/@iarna/toml/parse-string.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    module2.exports = parseString;
+    var TOMLParser = require_toml_parser();
+    var prettyError = require_parse_pretty_error();
+    function parseString(str2) {
+      if (global.Buffer && global.Buffer.isBuffer(str2)) {
+        str2 = str2.toString("utf8");
+      }
+      const parser = new TOMLParser();
+      try {
+        parser.parse(str2);
+        return parser.finish();
+      } catch (err) {
+        throw prettyError(err, str2);
+      }
+    }
+  }
+});
+
+// ../../node_modules/@iarna/toml/parse-async.js
+var require_parse_async = __commonJS({
+  "../../node_modules/@iarna/toml/parse-async.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    module2.exports = parseAsync;
+    var TOMLParser = require_toml_parser();
+    var prettyError = require_parse_pretty_error();
+    function parseAsync(str2, opts) {
+      if (!opts) opts = {};
+      const index = 0;
+      const blocksize = opts.blocksize || 40960;
+      const parser = new TOMLParser();
+      return new Promise((resolve2, reject) => {
+        setImmediate(parseAsyncNext, index, blocksize, resolve2, reject);
+      });
+      function parseAsyncNext(index2, blocksize2, resolve2, reject) {
+        if (index2 >= str2.length) {
+          try {
+            return resolve2(parser.finish());
+          } catch (err) {
+            return reject(prettyError(err, str2));
+          }
+        }
+        try {
+          parser.parse(str2.slice(index2, index2 + blocksize2));
+          setImmediate(parseAsyncNext, index2 + blocksize2, blocksize2, resolve2, reject);
+        } catch (err) {
+          reject(prettyError(err, str2));
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/@iarna/toml/parse-stream.js
+var require_parse_stream = __commonJS({
+  "../../node_modules/@iarna/toml/parse-stream.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    module2.exports = parseStream;
+    var stream = require("stream");
+    var TOMLParser = require_toml_parser();
+    function parseStream(stm) {
+      if (stm) {
+        return parseReadable(stm);
+      } else {
+        return parseTransform(stm);
+      }
+    }
+    function parseReadable(stm) {
+      const parser = new TOMLParser();
+      stm.setEncoding("utf8");
+      return new Promise((resolve2, reject) => {
+        let readable;
+        let ended = false;
+        let errored = false;
+        function finish() {
+          ended = true;
+          if (readable) return;
+          try {
+            resolve2(parser.finish());
+          } catch (err) {
+            reject(err);
+          }
+        }
+        function error(err) {
+          errored = true;
+          reject(err);
+        }
+        stm.once("end", finish);
+        stm.once("error", error);
+        readNext();
+        function readNext() {
+          readable = true;
+          let data;
+          while ((data = stm.read()) !== null) {
+            try {
+              parser.parse(data);
+            } catch (err) {
+              return error(err);
+            }
+          }
+          readable = false;
+          if (ended) return finish();
+          if (errored) return;
+          stm.once("readable", readNext);
+        }
+      });
+    }
+    function parseTransform() {
+      const parser = new TOMLParser();
+      return new stream.Transform({
+        objectMode: true,
+        transform(chunk, encoding, cb) {
+          try {
+            parser.parse(chunk.toString(encoding));
+          } catch (err) {
+            this.emit("error", err);
+          }
+          cb();
+        },
+        flush(cb) {
+          try {
+            this.push(parser.finish());
+          } catch (err) {
+            this.emit("error", err);
+          }
+          cb();
+        }
+      });
+    }
+  }
+});
+
+// ../../node_modules/@iarna/toml/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/@iarna/toml/parse.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    module2.exports = require_parse_string();
+    module2.exports.async = require_parse_async();
+    module2.exports.stream = require_parse_stream();
+    module2.exports.prettyError = require_parse_pretty_error();
+  }
+});
+
+// ../../node_modules/@iarna/toml/stringify.js
+var require_stringify = __commonJS({
+  "../../node_modules/@iarna/toml/stringify.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    module2.exports = stringify2;
+    module2.exports.value = stringifyInline;
+    function stringify2(obj) {
+      if (obj === null) throw typeError("null");
+      if (obj === void 0) throw typeError("undefined");
+      if (typeof obj !== "object") throw typeError(typeof obj);
+      if (typeof obj.toJSON === "function") obj = obj.toJSON();
+      if (obj == null) return null;
+      const type2 = tomlType2(obj);
+      if (type2 !== "table") throw typeError(type2);
+      return stringifyObject("", "", obj);
+    }
+    function typeError(type2) {
+      return new Error("Can only stringify objects, not " + type2);
+    }
+    function arrayOneTypeError() {
+      return new Error("Array values can't have mixed types");
+    }
+    function getInlineKeys(obj) {
+      return Object.keys(obj).filter((key) => isInline(obj[key]));
+    }
+    function getComplexKeys(obj) {
+      return Object.keys(obj).filter((key) => !isInline(obj[key]));
+    }
+    function toJSON(obj) {
+      let nobj = Array.isArray(obj) ? [] : Object.prototype.hasOwnProperty.call(obj, "__proto__") ? { ["__proto__"]: void 0 } : {};
+      for (let prop of Object.keys(obj)) {
+        if (obj[prop] && typeof obj[prop].toJSON === "function" && !("toISOString" in obj[prop])) {
+          nobj[prop] = obj[prop].toJSON();
+        } else {
+          nobj[prop] = obj[prop];
+        }
+      }
+      return nobj;
+    }
+    function stringifyObject(prefix, indent, obj) {
+      obj = toJSON(obj);
+      var inlineKeys;
+      var complexKeys;
+      inlineKeys = getInlineKeys(obj);
+      complexKeys = getComplexKeys(obj);
+      var result = [];
+      var inlineIndent = indent || "";
+      inlineKeys.forEach((key) => {
+        var type2 = tomlType2(obj[key]);
+        if (type2 !== "undefined" && type2 !== "null") {
+          result.push(inlineIndent + stringifyKey(key) + " = " + stringifyAnyInline(obj[key], true));
+        }
+      });
+      if (result.length > 0) result.push("");
+      var complexIndent = prefix && inlineKeys.length > 0 ? indent + "  " : "";
+      complexKeys.forEach((key) => {
+        result.push(stringifyComplex(prefix, complexIndent, key, obj[key]));
+      });
+      return result.join("\n");
+    }
+    function isInline(value) {
+      switch (tomlType2(value)) {
+        case "undefined":
+        case "null":
+        case "integer":
+        case "nan":
+        case "float":
+        case "boolean":
+        case "string":
+        case "datetime":
+          return true;
+        case "array":
+          return value.length === 0 || tomlType2(value[0]) !== "table";
+        case "table":
+          return Object.keys(value).length === 0;
+        /* istanbul ignore next */
+        default:
+          return false;
+      }
+    }
+    function tomlType2(value) {
+      if (value === void 0) {
+        return "undefined";
+      } else if (value === null) {
+        return "null";
+      } else if (typeof value === "bigint" || Number.isInteger(value) && !Object.is(value, -0)) {
+        return "integer";
+      } else if (typeof value === "number") {
+        return "float";
+      } else if (typeof value === "boolean") {
+        return "boolean";
+      } else if (typeof value === "string") {
+        return "string";
+      } else if ("toISOString" in value) {
+        return isNaN(value) ? "undefined" : "datetime";
+      } else if (Array.isArray(value)) {
+        return "array";
+      } else {
+        return "table";
+      }
+    }
+    function stringifyKey(key) {
+      var keyStr = String(key);
+      if (/^[-A-Za-z0-9_]+$/.test(keyStr)) {
+        return keyStr;
+      } else {
+        return stringifyBasicString(keyStr);
+      }
+    }
+    function stringifyBasicString(str2) {
+      return '"' + escapeString2(str2).replace(/"/g, '\\"') + '"';
+    }
+    function stringifyLiteralString(str2) {
+      return "'" + str2 + "'";
+    }
+    function numpad(num, str2) {
+      while (str2.length < num) str2 = "0" + str2;
+      return str2;
+    }
+    function escapeString2(str2) {
+      return str2.replace(/\\/g, "\\\\").replace(/[\b]/g, "\\b").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\f/g, "\\f").replace(/\r/g, "\\r").replace(/([\u0000-\u001f\u007f])/, (c) => "\\u" + numpad(4, c.codePointAt(0).toString(16)));
+    }
+    function stringifyMultilineString(str2) {
+      let escaped = str2.split(/\n/).map((str3) => {
+        return escapeString2(str3).replace(/"(?="")/g, '\\"');
+      }).join("\n");
+      if (escaped.slice(-1) === '"') escaped += "\\\n";
+      return '"""\n' + escaped + '"""';
+    }
+    function stringifyAnyInline(value, multilineOk) {
+      let type2 = tomlType2(value);
+      if (type2 === "string") {
+        if (multilineOk && /\n/.test(value)) {
+          type2 = "string-multiline";
+        } else if (!/[\b\t\n\f\r']/.test(value) && /"/.test(value)) {
+          type2 = "string-literal";
+        }
+      }
+      return stringifyInline(value, type2);
+    }
+    function stringifyInline(value, type2) {
+      if (!type2) type2 = tomlType2(value);
+      switch (type2) {
+        case "string-multiline":
+          return stringifyMultilineString(value);
+        case "string":
+          return stringifyBasicString(value);
+        case "string-literal":
+          return stringifyLiteralString(value);
+        case "integer":
+          return stringifyInteger(value);
+        case "float":
+          return stringifyFloat(value);
+        case "boolean":
+          return stringifyBoolean(value);
+        case "datetime":
+          return stringifyDatetime(value);
+        case "array":
+          return stringifyInlineArray(value.filter((_) => tomlType2(_) !== "null" && tomlType2(_) !== "undefined" && tomlType2(_) !== "nan"));
+        case "table":
+          return stringifyInlineTable(value);
+        /* istanbul ignore next */
+        default:
+          throw typeError(type2);
+      }
+    }
+    function stringifyInteger(value) {
+      return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, "_");
+    }
+    function stringifyFloat(value) {
+      if (value === Infinity) {
+        return "inf";
+      } else if (value === -Infinity) {
+        return "-inf";
+      } else if (Object.is(value, NaN)) {
+        return "nan";
+      } else if (Object.is(value, -0)) {
+        return "-0.0";
+      }
+      var chunks = String(value).split(".");
+      var int2 = chunks[0];
+      var dec = chunks[1] || 0;
+      return stringifyInteger(int2) + "." + dec;
+    }
+    function stringifyBoolean(value) {
+      return String(value);
+    }
+    function stringifyDatetime(value) {
+      return value.toISOString();
+    }
+    function isNumber(type2) {
+      return type2 === "float" || type2 === "integer";
+    }
+    function arrayType(values) {
+      var contentType = tomlType2(values[0]);
+      if (values.every((_) => tomlType2(_) === contentType)) return contentType;
+      if (values.every((_) => isNumber(tomlType2(_)))) return "float";
+      return "mixed";
+    }
+    function validateArray(values) {
+      const type2 = arrayType(values);
+      if (type2 === "mixed") {
+        throw arrayOneTypeError();
+      }
+      return type2;
+    }
+    function stringifyInlineArray(values) {
+      values = toJSON(values);
+      const type2 = validateArray(values);
+      var result = "[";
+      var stringified = values.map((_) => stringifyInline(_, type2));
+      if (stringified.join(", ").length > 60 || /\n/.test(stringified)) {
+        result += "\n  " + stringified.join(",\n  ") + "\n";
+      } else {
+        result += " " + stringified.join(", ") + (stringified.length > 0 ? " " : "");
+      }
+      return result + "]";
+    }
+    function stringifyInlineTable(value) {
+      value = toJSON(value);
+      var result = [];
+      Object.keys(value).forEach((key) => {
+        result.push(stringifyKey(key) + " = " + stringifyAnyInline(value[key], false));
+      });
+      return "{ " + result.join(", ") + (result.length > 0 ? " " : "") + "}";
+    }
+    function stringifyComplex(prefix, indent, key, value) {
+      var valueType = tomlType2(value);
+      if (valueType === "array") {
+        return stringifyArrayOfTables(prefix, indent, key, value);
+      } else if (valueType === "table") {
+        return stringifyComplexTable(prefix, indent, key, value);
+      } else {
+        throw typeError(valueType);
+      }
+    }
+    function stringifyArrayOfTables(prefix, indent, key, values) {
+      values = toJSON(values);
+      validateArray(values);
+      var firstValueType = tomlType2(values[0]);
+      if (firstValueType !== "table") throw typeError(firstValueType);
+      var fullKey = prefix + stringifyKey(key);
+      var result = "";
+      values.forEach((table) => {
+        if (result.length > 0) result += "\n";
+        result += indent + "[[" + fullKey + "]]\n";
+        result += stringifyObject(fullKey + ".", indent, table);
+      });
+      return result;
+    }
+    function stringifyComplexTable(prefix, indent, key, value) {
+      var fullKey = prefix + stringifyKey(key);
+      var result = "";
+      if (getInlineKeys(value).length > 0) {
+        result += indent + "[" + fullKey + "]\n";
+      }
+      return result + stringifyObject(fullKey + ".", indent, value);
+    }
+  }
+});
+
+// ../../node_modules/@iarna/toml/toml.js
+var require_toml = __commonJS({
+  "../../node_modules/@iarna/toml/toml.js"(exports2) {
+    "use strict";
+    init_cjs_shims();
+    exports2.parse = require_parse();
+    exports2.stringify = require_stringify();
+  }
+});
+
+// ../converters/dist/from-gemini.js
+function fromGemini(content, metadata, explicitSubtype) {
+  let parsed;
+  try {
+    const tomlData = TOML.parse(content);
+    parsed = tomlData;
+  } catch (error) {
+    throw new Error(`Failed to parse Gemini TOML: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!parsed.prompt) {
+    throw new Error('Gemini command must have a "prompt" field');
+  }
+  const sections = [];
+  sections.push({
+    type: "metadata",
+    data: {
+      title: metadata.name || metadata.id,
+      description: parsed.description || "Gemini custom command"
+    }
+  });
+  sections.push({
+    type: "instructions",
+    title: "Prompt",
+    content: parsed.prompt,
+    priority: "high"
+  });
+  const canonicalContent = {
+    format: "canonical",
+    version: "1.0",
+    sections
+  };
+  const pkg = {
+    id: metadata.id,
+    version: metadata.version || "1.0.0",
+    name: metadata.name || metadata.id,
+    description: parsed.description || "Gemini custom command",
+    author: metadata.author || "unknown",
+    tags: metadata.tags || ["gemini", "command"],
+    format: "gemini",
+    subtype: explicitSubtype || "slash-command",
+    content: canonicalContent,
+    sourceFormat: "gemini",
+    metadata: {
+      description: parsed.description
+    }
+  };
+  return pkg;
+}
+var TOML;
+var init_from_gemini = __esm({
+  "../converters/dist/from-gemini.js"() {
+    "use strict";
+    init_cjs_shims();
+    TOML = __toESM(require_toml(), 1);
+  }
+});
+
 // ../converters/dist/validation.js
 function loadSchema(format, subtype) {
   const cacheKey = subtype ? `${format}:${subtype}` : format;
@@ -4629,6 +6700,7 @@ function loadSchema(format, subtype) {
       "copilot": "copilot.schema.json",
       "kiro": "kiro-steering.schema.json",
       "agents-md": "agents-md.schema.json",
+      "gemini": "gemini.schema.json",
       "canonical": "canonical.schema.json"
     };
     schemaFilename = schemaMap[format] || `${format}.schema.json`;
@@ -6047,6 +8119,181 @@ var init_to_agents_md = __esm({
   }
 });
 
+// ../converters/dist/to-gemini.js
+function toGemini(pkg, options = {}) {
+  var _a;
+  const warnings = [];
+  let qualityScore = 100;
+  try {
+    const prompt3 = buildPrompt(pkg.content, warnings);
+    const geminiCommand = {
+      prompt: prompt3
+    };
+    if (pkg.description) {
+      geminiCommand.description = pkg.description;
+    } else if ((_a = pkg.metadata) == null ? void 0 : _a.description) {
+      geminiCommand.description = pkg.metadata.description;
+    }
+    const tomlContent = TOML2.stringify(geminiCommand);
+    const validation = validateFormat("gemini", geminiCommand);
+    const validationErrors = validation.errors.map((e) => e.message);
+    const validationWarnings = validation.warnings.map((w) => w.message);
+    if (validationWarnings.length > 0) {
+      warnings.push(...validationWarnings);
+    }
+    const lossyConversion = warnings.some((w) => w.includes("not supported") || w.includes("skipped"));
+    if (lossyConversion) {
+      qualityScore -= 10;
+    }
+    if (validationErrors.length > 0) {
+      qualityScore -= validationErrors.length * 5;
+    }
+    return {
+      content: tomlContent,
+      format: "gemini",
+      warnings: warnings.length > 0 ? warnings : void 0,
+      validationErrors: validationErrors.length > 0 ? validationErrors : void 0,
+      lossyConversion,
+      qualityScore: Math.max(0, qualityScore)
+    };
+  } catch (error) {
+    warnings.push(`Conversion error: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      content: "",
+      format: "gemini",
+      warnings,
+      lossyConversion: true,
+      qualityScore: 0
+    };
+  }
+}
+function buildPrompt(content, warnings) {
+  const lines = [];
+  for (const section of content.sections) {
+    const sectionContent = convertSection7(section, warnings);
+    if (sectionContent) {
+      lines.push(sectionContent);
+      lines.push("");
+    }
+  }
+  return lines.join("\n").trim();
+}
+function convertSection7(section, warnings) {
+  switch (section.type) {
+    case "metadata":
+      return "";
+    case "instructions":
+      return convertInstructions7(section);
+    case "rules":
+      return convertRules7(section);
+    case "examples":
+      return convertExamples7(section);
+    case "persona":
+      return convertPersona3(section);
+    case "context":
+      return convertContext7(section);
+    case "tools":
+      warnings.push("Tools section skipped (not supported by Gemini)");
+      return "";
+    case "hook":
+      warnings.push("Hook section skipped (not supported by Gemini)");
+      return "";
+    case "custom":
+      if (!section.editorType || section.editorType === "gemini") {
+        return section.content;
+      }
+      warnings.push(`Custom ${section.editorType} section skipped`);
+      return "";
+    default:
+      warnings.push(`Unknown section type: ${section.type}`);
+      return "";
+  }
+}
+function convertInstructions7(section) {
+  const lines = [];
+  if (section.priority === "high") {
+    lines.push("**Important:**");
+    lines.push("");
+  }
+  lines.push(section.content);
+  return lines.join("\n");
+}
+function convertRules7(section) {
+  const lines = [];
+  lines.push(`# ${section.title}`);
+  lines.push("");
+  section.items.forEach((rule, index) => {
+    const prefix = section.ordered ? `${index + 1}.` : "-";
+    lines.push(`${prefix} ${rule.content}`);
+    if (rule.rationale) {
+      lines.push(`   - *Rationale: ${rule.rationale}*`);
+    }
+    if (rule.examples) {
+      rule.examples.forEach((example) => {
+        lines.push(`   - Example: \`${example}\``);
+      });
+    }
+  });
+  return lines.join("\n");
+}
+function convertExamples7(section) {
+  const lines = [];
+  lines.push(`# ${section.title}`);
+  lines.push("");
+  section.examples.forEach((example) => {
+    const prefix = example.good === false ? "\u274C Bad" : "\u2705 Good";
+    lines.push(`## ${prefix}: ${example.description}`);
+    lines.push("");
+    const lang = example.language || "";
+    lines.push("```" + lang);
+    lines.push(example.code);
+    lines.push("```");
+    lines.push("");
+  });
+  return lines.join("\n");
+}
+function convertPersona3(section) {
+  const { name, role, icon, style, expertise } = section.data;
+  const lines = [];
+  lines.push("# Role");
+  lines.push("");
+  if (icon && typeof icon === "string" && name && typeof name === "string" && typeof role === "string") {
+    lines.push(`${icon} **${name}** - ${role}`);
+  } else if (name && typeof name === "string" && typeof role === "string") {
+    lines.push(`**${name}** - ${role}`);
+  } else if (typeof role === "string") {
+    lines.push(role);
+  }
+  if (style && Array.isArray(style) && style.length > 0) {
+    lines.push("");
+    lines.push(`**Style:** ${style.join(", ")}`);
+  }
+  if (expertise && Array.isArray(expertise) && expertise.length > 0) {
+    lines.push("");
+    lines.push("**Expertise:**");
+    expertise.forEach((area) => {
+      lines.push(`- ${area}`);
+    });
+  }
+  return lines.join("\n");
+}
+function convertContext7(section) {
+  const lines = [];
+  lines.push(`# ${section.title}`);
+  lines.push("");
+  lines.push(section.content);
+  return lines.join("\n");
+}
+var TOML2;
+var init_to_gemini = __esm({
+  "../converters/dist/to-gemini.js"() {
+    "use strict";
+    init_cjs_shims();
+    TOML2 = __toESM(require_toml(), 1);
+    init_validation();
+  }
+});
+
 // ../converters/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
@@ -6057,6 +8304,7 @@ __export(dist_exports, {
   fromContinue: () => fromContinue,
   fromCopilot: () => fromCopilot,
   fromCursor: () => fromCursor,
+  fromGemini: () => fromGemini,
   fromKiro: () => fromKiro,
   fromWindsurf: () => fromWindsurf,
   normalizeFormat: () => normalizeFormat,
@@ -6067,6 +8315,7 @@ __export(dist_exports, {
   toContinue: () => toContinue,
   toCopilot: () => toCopilot,
   toCursor: () => toCursor,
+  toGemini: () => toGemini,
   toKiro: () => toKiro,
   toWindsurf: () => toWindsurf,
   validateConversion: () => validateConversion,
@@ -6085,6 +8334,7 @@ var init_dist = __esm({
     init_from_kiro();
     init_from_windsurf();
     init_from_agents_md();
+    init_from_gemini();
     init_to_cursor();
     init_to_claude();
     init_to_continue();
@@ -6092,6 +8342,7 @@ var init_dist = __esm({
     init_to_kiro();
     init_to_windsurf();
     init_to_agents_md();
+    init_to_gemini();
     init_taxonomy_utils();
     init_validation();
   }
@@ -6630,7 +8881,7 @@ async function handleCollectionInstall(collectionSpec, options) {
   }
 }
 function createCollectionsCommand() {
-  const command = new import_commander9.Command("collections");
+  const command = new import_commander10.Command("collections");
   command.description("Manage package collections").alias("collection").action(async (options) => {
     await handleCollectionsList(options);
   });
@@ -6649,12 +8900,12 @@ function createCollectionsCommand() {
   });
   return command;
 }
-var import_commander9, import_registry_client4;
+var import_commander10, import_registry_client4;
 var init_collections = __esm({
   "src/commands/collections.ts"() {
     "use strict";
     init_cjs_shims();
-    import_commander9 = require("commander");
+    import_commander10 = require("commander");
     import_registry_client4 = require("@pr-pm/registry-client");
     init_user_config();
     init_install();
@@ -6686,6 +8937,7 @@ function getPackageIcon2(format, subtype) {
     "continue": "\u27A1\uFE0F",
     "copilot": "\u2708\uFE0F",
     "kiro": "\u{1F3AF}",
+    "gemini": "\u2728",
     "mcp": "\u{1F517}",
     "agents.md": "\u{1F4DD}",
     "generic": "\u{1F4E6}"
@@ -6700,6 +8952,7 @@ function getPackageLabel2(format, subtype) {
     "continue": "Continue",
     "copilot": "GitHub Copilot",
     "kiro": "Kiro",
+    "gemini": "Gemini",
     "mcp": "MCP",
     "agents.md": "Agents.md",
     "generic": ""
@@ -7394,7 +9647,7 @@ async function installFromLockfile(options) {
   }
 }
 function createInstallCommand() {
-  const command = new import_commander10.Command("install");
+  const command = new import_commander11.Command("install");
   command.description("Install a package from the registry, or install all packages from prpm.lock if no package specified").argument("[package]", "Package to install (e.g., react-rules or react-rules@1.2.0). If omitted, installs all packages from prpm.lock").option("--version <version>", "Specific version to install").option("--as <format>", "Convert and install in specific format (cursor, claude, continue, windsurf, copilot, kiro, agents.md, canonical)").option("--format <format>", "Alias for --as").option("--location <path>", "Custom location for installed files (Agents.md or nested Cursor rules)").option("--subtype <subtype>", "Specify subtype when converting (skill, agent, rule, etc.)").option("--frozen-lockfile", "Fail if lock file needs to be updated (for CI)").action(async (packageSpec, options) => {
     const convertTo = options.format || options.as;
     if (convertTo && !["cursor", "claude", "continue", "windsurf", "copilot", "kiro", "agents.md", "canonical"].includes(convertTo)) {
@@ -7419,12 +9672,12 @@ function createInstallCommand() {
   });
   return command;
 }
-var import_commander10, import_registry_client5, import_stream, import_promises, tar, import_path8;
+var import_commander11, import_registry_client5, import_stream, import_promises, tar, import_path8;
 var init_install = __esm({
   "src/commands/install.ts"() {
     "use strict";
     init_cjs_shims();
-    import_commander10 = require("commander");
+    import_commander11 = require("commander");
     import_registry_client5 = require("@pr-pm/registry-client");
     init_user_config();
     init_filesystem();
@@ -9004,7 +11257,7 @@ var require_source = __commonJS({
 
 // src/index.ts
 init_cjs_shims();
-var import_commander27 = require("commander");
+var import_commander28 = require("commander");
 var import_fs13 = require("fs");
 var import_path16 = require("path");
 
@@ -9606,6 +11859,7 @@ function getPackageIcon(format, subtype) {
     "continue": "\u27A1\uFE0F",
     "copilot": "\u2708\uFE0F",
     "kiro": "\u{1F3AF}",
+    "gemini": "\u2728",
     "mcp": "\u{1F517}",
     "agents.md": "\u{1F4DD}",
     "generic": "\u{1F4E6}"
@@ -9620,6 +11874,7 @@ function getPackageLabel(format, subtype) {
     "continue": "Continue",
     "copilot": "GitHub Copilot",
     "kiro": "Kiro",
+    "gemini": "Gemini",
     "mcp": "MCP",
     "agents.md": "Agents.md",
     "generic": ""
@@ -9923,9 +12178,135 @@ function createSearchCommand() {
   return command;
 }
 
-// src/commands/info.ts
+// src/commands/ai-search.ts
 init_cjs_shims();
 var import_commander8 = require("commander");
+init_user_config();
+init_telemetry();
+init_errors();
+function displayAIResults(response) {
+  const { results, total_matches, execution_time_ms, query } = response;
+  console.log("\n" + "\u2550".repeat(80));
+  console.log(`\u2728 AI Search Results for "${query}"`);
+  console.log(`   ${total_matches} matches found in ${execution_time_ms}ms`);
+  console.log("\u2550".repeat(80) + "\n");
+  results.forEach((result, idx) => {
+    const matchPercent = Math.round(result.similarity_score * 100);
+    const matchColor = matchPercent >= 80 ? "\x1B[32m" : matchPercent >= 60 ? "\x1B[33m" : "\x1B[36m";
+    const downloads = result.total_downloads >= 1e3 ? `${(result.total_downloads / 1e3).toFixed(1)}k` : result.total_downloads;
+    console.log(`\x1B[1m${idx + 1}. ${result.name}\x1B[0m ${matchColor}${matchPercent}% match\x1B[0m`);
+    if (result.ai_use_case_description) {
+      console.log(`   \u{1F4A1} ${result.ai_use_case_description}`);
+    } else if (result.description) {
+      console.log(`   ${result.description}`);
+    }
+    if (result.ai_best_for) {
+      console.log(`   \u2728 Best for: ${result.ai_best_for}`);
+    }
+    console.log(`   \u{1F4E6} ${result.format} ${result.subtype} | \u{1F4E5} ${downloads} downloads`);
+    if (result.ai_similar_to && result.ai_similar_to.length > 0) {
+      console.log(`   \u{1F517} Similar to: ${result.ai_similar_to.slice(0, 3).join(", ")}`);
+    }
+    console.log();
+  });
+  console.log("\u2550".repeat(80));
+}
+async function handleAISearch(query, options) {
+  const startTime = Date.now();
+  let success = false;
+  let error;
+  let response = null;
+  try {
+    if (!query || query.trim().length === 0) {
+      console.log("\u274C Please provide a search query");
+      console.log("\n\u{1F4A1} Examples:");
+      console.log('   prpm ai-search "build a REST API with authentication"');
+      console.log('   prpm ai-search "Python testing best practices"');
+      console.log('   prpm ai-search "React component architecture patterns"');
+      console.log('   prpm ai-search "setting up CI/CD pipeline"');
+      return;
+    }
+    console.log(`\u2728 AI searching for "${query}"...`);
+    const config = await getConfig();
+    const searchRequest = {
+      query,
+      limit: options.limit || 10
+    };
+    if (options.format || options.subtype) {
+      searchRequest.filters = {};
+      if (options.format) searchRequest.filters.format = options.format;
+      if (options.subtype) searchRequest.filters.subtype = options.subtype;
+    }
+    const registryUrl = config.registryUrl || "https://registry.prpm.dev";
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (config.token) {
+      headers["Authorization"] = `Bearer ${config.token}`;
+    }
+    const res = await fetch(`${registryUrl}/api/v1/ai-search`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(searchRequest)
+    });
+    if (!res.ok) {
+      const errorText = await res.text().catch(() => "Unknown error");
+      throw new Error(`API error ${res.status}: ${errorText}`);
+    }
+    response = await res.json();
+    if (!response || response.results.length === 0) {
+      console.log("\n\u274C No packages found for your query");
+      console.log("\nTry:");
+      console.log("  - Rephrasing your query");
+      console.log("  - Being more specific about your use case");
+      console.log("  - Using traditional search: \x1B[36mprpm search <query>\x1B[0m");
+      return;
+    }
+    displayAIResults(response);
+    console.log("\n\u{1F4A1} \x1B[1mQuick Actions:\x1B[0m");
+    console.log("   Install: \x1B[36mprpm install <package-name>\x1B[0m");
+    console.log("   More info: \x1B[36mprpm info <package-name>\x1B[0m");
+    console.log("   View in browser: \x1B[36mhttps://prpm.dev/search\x1B[0m\n");
+    success = true;
+  } catch (err) {
+    error = err instanceof Error ? err.message : String(err);
+    if (!error.includes("Authentication") && !error.includes("subscription")) {
+      console.error(`
+\u274C AI search failed: ${error}`);
+      console.log("\n\u{1F4A1} Tip: Try traditional search instead:");
+      console.log(`   \x1B[36mprpm search ${query}\x1B[0m
+`);
+    }
+    throw new CLIError(error, 1);
+  } finally {
+    await telemetry.track({
+      command: "ai-search",
+      success,
+      error,
+      duration: Date.now() - startTime,
+      data: {
+        query: query.substring(0, 100),
+        format: options.format,
+        subtype: options.subtype,
+        resultCount: success && response ? response.results.length : 0,
+        executionTime: response == null ? void 0 : response.execution_time_ms
+      }
+    });
+    await telemetry.shutdown();
+  }
+}
+function createAISearchCommand() {
+  const command = new import_commander8.Command("ai-search");
+  command.description("AI-powered semantic search (100% Free, no login required)").argument("<query>", "Natural language search query").option("--limit <number>", "Number of results to return (default: 10)", "10").option("--format <format>", "Filter by package format (cursor, claude, continue, etc.)").option("--subtype <subtype>", "Filter by package subtype (rule, agent, skill, etc.)").action(async (query, options) => {
+    const limit = options.limit ? parseInt(options.limit, 10) : 10;
+    await handleAISearch(query, { limit, format: options.format, subtype: options.subtype });
+  });
+  return command;
+}
+
+// src/commands/info.ts
+init_cjs_shims();
+var import_commander9 = require("commander");
 var import_registry_client3 = require("@pr-pm/registry-client");
 init_user_config();
 init_telemetry();
@@ -9990,7 +12371,7 @@ async function handleInfo(packageName) {
   }
 }
 function createInfoCommand() {
-  const command = new import_commander8.Command("info");
+  const command = new import_commander9.Command("info");
   command.description("Display detailed package information").argument("<package>", "Package ID to get information about").action(async (packageId) => {
     await handleInfo(packageId);
   });
@@ -10002,7 +12383,7 @@ init_install();
 
 // src/commands/publish.ts
 init_cjs_shims();
-var import_commander11 = require("commander");
+var import_commander12 = require("commander");
 var import_promises5 = require("fs/promises");
 var import_path12 = require("path");
 var tar2 = __toESM(require("tar"));
@@ -11222,14 +13603,14 @@ ${"=".repeat(60)}`);
   }
 }
 function createPublishCommand() {
-  return new import_commander11.Command("publish").description("Publish packages and collections to the registry").option("--access <type>", "Package access (public or private) - overrides manifest setting").option("--tag <tag>", "NPM-style tag (e.g., latest, beta)", "latest").option("--dry-run", "Validate package without publishing").option("--package <name>", "Publish only a specific package from multi-package manifest").option("--collection <id>", "Publish only a specific collection from manifest").action(async (options) => {
+  return new import_commander12.Command("publish").description("Publish packages and collections to the registry").option("--access <type>", "Package access (public or private) - overrides manifest setting").option("--tag <tag>", "NPM-style tag (e.g., latest, beta)", "latest").option("--dry-run", "Validate package without publishing").option("--package <name>", "Publish only a specific package from multi-package manifest").option("--collection <id>", "Publish only a specific collection from manifest").action(async (options) => {
     await handlePublish(options);
   });
 }
 
 // src/commands/login.ts
 init_cjs_shims();
-var import_commander12 = require("commander");
+var import_commander13 = require("commander");
 var jwt = __toESM(require("jsonwebtoken"));
 init_telemetry();
 init_user_config();
@@ -11396,14 +13777,14 @@ async function handleLogin(options) {
   }
 }
 function createLoginCommand() {
-  return new import_commander12.Command("login").description("Login to the PRMP registry").option("--token <token>", "Login with a personal access token").action(async (options) => {
+  return new import_commander13.Command("login").description("Login to the PRMP registry").option("--token <token>", "Login with a personal access token").action(async (options) => {
     await handleLogin(options);
   });
 }
 
 // src/commands/whoami.ts
 init_cjs_shims();
-var import_commander13 = require("commander");
+var import_commander14 = require("commander");
 init_user_config();
 var import_registry_client7 = require("@pr-pm/registry-client");
 init_telemetry();
@@ -11461,7 +13842,7 @@ async function handleWhoami() {
   }
 }
 function createWhoamiCommand() {
-  return new import_commander13.Command("whoami").description("Show current logged-in user").action(async () => {
+  return new import_commander14.Command("whoami").description("Show current logged-in user").action(async () => {
     await handleWhoami();
   });
 }
@@ -11471,7 +13852,7 @@ init_collections();
 
 // src/commands/outdated.ts
 init_cjs_shims();
-var import_commander14 = require("commander");
+var import_commander15 = require("commander");
 var import_registry_client8 = require("@pr-pm/registry-client");
 init_user_config();
 init_lockfile();
@@ -11571,14 +13952,14 @@ function getUpdateType(current, latest) {
   return "patch";
 }
 function createOutdatedCommand() {
-  return new import_commander14.Command("outdated").description("Check for package updates").action(async () => {
+  return new import_commander15.Command("outdated").description("Check for package updates").action(async () => {
     await handleOutdated();
   });
 }
 
 // src/commands/update.ts
 init_cjs_shims();
-var import_commander15 = require("commander");
+var import_commander16 = require("commander");
 var import_registry_client9 = require("@pr-pm/registry-client");
 init_user_config();
 init_lockfile();
@@ -11668,14 +14049,14 @@ function getUpdateType2(current, latest) {
   return "patch";
 }
 function createUpdateCommand() {
-  return new import_commander15.Command("update").description("Update packages to latest compatible versions (minor/patch only)").argument("[package]", "Specific package to update (optional)").option("--all", "Update all packages").action(async (packageName, options) => {
+  return new import_commander16.Command("update").description("Update packages to latest compatible versions (minor/patch only)").argument("[package]", "Specific package to update (optional)").option("--all", "Update all packages").action(async (packageName, options) => {
     await handleUpdate(packageName, options);
   });
 }
 
 // src/commands/upgrade.ts
 init_cjs_shims();
-var import_commander16 = require("commander");
+var import_commander17 = require("commander");
 var import_registry_client10 = require("@pr-pm/registry-client");
 init_user_config();
 init_lockfile();
@@ -11765,14 +14146,14 @@ function getUpdateType3(current, latest) {
   return "patch";
 }
 function createUpgradeCommand() {
-  return new import_commander16.Command("upgrade").description("Upgrade packages to latest versions (including major updates)").argument("[package]", "Specific package to upgrade (optional)").option("--all", "Upgrade all packages").option("--force", "Skip warning for major version upgrades").action(async (packageName, options) => {
+  return new import_commander17.Command("upgrade").description("Upgrade packages to latest versions (including major updates)").argument("[package]", "Specific package to upgrade (optional)").option("--all", "Upgrade all packages").option("--force", "Skip warning for major version upgrades").action(async (packageName, options) => {
     await handleUpgrade(packageName, options);
   });
 }
 
 // src/commands/schema.ts
 init_cjs_shims();
-var import_commander17 = require("commander");
+var import_commander18 = require("commander");
 init_errors();
 async function handleSchema() {
   try {
@@ -11789,7 +14170,7 @@ async function handleSchema() {
   }
 }
 function createSchemaCommand() {
-  const command = new import_commander17.Command("schema");
+  const command = new import_commander18.Command("schema");
   command.description("Display the PRPM manifest JSON schema").action(async () => {
     await handleSchema();
   });
@@ -11798,7 +14179,7 @@ function createSchemaCommand() {
 
 // src/commands/init.ts
 init_cjs_shims();
-var import_commander18 = require("commander");
+var import_commander19 = require("commander");
 var import_promises6 = require("fs/promises");
 var import_path13 = require("path");
 var import_fs11 = require("fs");
@@ -12394,7 +14775,7 @@ Current files (${config.files.length}):`);
   console.log("  3. Run `prpm publish` to publish your package\n");
 }
 function createInitCommand() {
-  const command = new import_commander18.Command("init");
+  const command = new import_commander19.Command("init");
   command.description("Initialize a new PRPM package with interactive prompts").option("-y, --yes", "Skip prompts and use defaults").option("--private", "Create a private package").option("-f, --force", "Overwrite existing prpm.json").action(async (options) => {
     try {
       await initPackage(options);
@@ -12408,7 +14789,7 @@ function createInitCommand() {
 
 // src/commands/config.ts
 init_cjs_shims();
-var import_commander19 = require("commander");
+var import_commander20 = require("commander");
 init_user_config();
 init_errors();
 async function handleConfigGet(key) {
@@ -12499,7 +14880,7 @@ async function handleConfigDelete(key) {
   }
 }
 function createConfigCommand() {
-  const command = new import_commander19.Command("config").description("Manage CLI configuration");
+  const command = new import_commander20.Command("config").description("Manage CLI configuration");
   command.command("list").alias("ls").description("List all configuration values").action(async () => {
     await handleConfigList();
   });
@@ -12520,7 +14901,7 @@ function createConfigCommand() {
 
 // src/commands/catalog.ts
 init_cjs_shims();
-var import_commander20 = require("commander");
+var import_commander21 = require("commander");
 var import_promises7 = require("fs/promises");
 var import_path14 = require("path");
 init_telemetry();
@@ -12812,14 +15193,14 @@ async function handleCatalog(directories, options) {
   }
 }
 function createCatalogCommand() {
-  return new import_commander20.Command("catalog").description("Discover and catalog existing packages from directories").argument("[directories...]", "Directories to scan for packages (defaults to current directory)", ["."]).option("-o, --output <path>", "Output path for prpm.json (default: ./prpm.json)").option("-a, --append", "Append to existing prpm.json instead of overwriting").option("--dry-run", "Show what would be cataloged without making changes").action(async (directories, options) => {
+  return new import_commander21.Command("catalog").description("Discover and catalog existing packages from directories").argument("[directories...]", "Directories to scan for packages (defaults to current directory)", ["."]).option("-o, --output <path>", "Output path for prpm.json (default: ./prpm.json)").option("-a, --append", "Append to existing prpm.json instead of overwriting").option("--dry-run", "Show what would be cataloged without making changes").action(async (directories, options) => {
     await handleCatalog(directories, options);
   });
 }
 
 // src/commands/playground.ts
 init_cjs_shims();
-var import_commander21 = require("commander");
+var import_commander22 = require("commander");
 init_user_config();
 init_telemetry();
 var readline4 = __toESM(require("readline"));
@@ -13259,7 +15640,7 @@ async function handlePlayground(options) {
   }
 }
 function createPlaygroundCommand() {
-  const command = new import_commander21.Command("playground");
+  const command = new import_commander22.Command("playground");
   command.description("Test a package or custom prompt with AI models in the playground").option("-p, --package <name>", "Package name to test").option("--input <text>", "Input text to send to the model (omit for interactive mode)").option(
     "-m, --model <model>",
     "AI model to use (sonnet, opus, gpt-4o, gpt-4o-mini, gpt-4-turbo)",
@@ -13328,7 +15709,7 @@ Note: Playground usage requires credits. Run 'prpm credits' to check balance.
 
 // src/commands/credits.ts
 init_cjs_shims();
-var import_commander22 = require("commander");
+var import_commander23 = require("commander");
 init_user_config();
 init_telemetry();
 init_errors();
@@ -13455,7 +15836,7 @@ async function handleCredits(options) {
   }
 }
 function createCreditsCommand() {
-  const command = new import_commander22.Command("credits");
+  const command = new import_commander23.Command("credits");
   command.description("Check playground credits balance and transaction history").option("-h, --history", "Show transaction history instead of balance", false).option("-l, --limit <number>", "Number of transactions to show in history", "10").addHelpText(
     "after",
     `
@@ -13490,7 +15871,7 @@ Get more credits:
 
 // src/commands/subscribe.ts
 init_cjs_shims();
-var import_commander23 = require("commander");
+var import_commander24 = require("commander");
 init_user_config();
 init_telemetry();
 var import_child_process2 = require("child_process");
@@ -13649,7 +16030,7 @@ async function handleSubscribe() {
   }
 }
 function createSubscribeCommand() {
-  const command = new import_commander23.Command("subscribe");
+  const command = new import_commander24.Command("subscribe");
   command.description("Subscribe to PRPM+ for monthly playground credits and benefits").addHelpText(
     "after",
     `
@@ -13690,7 +16071,7 @@ Note: You can cancel anytime from https://prpm.dev/settings/billing
 
 // src/commands/buy-credits.ts
 init_cjs_shims();
-var import_commander24 = require("commander");
+var import_commander25 = require("commander");
 init_user_config();
 init_telemetry();
 var import_child_process3 = require("child_process");
@@ -13831,7 +16212,7 @@ async function handleBuyCredits(options) {
   }
 }
 function createBuyCreditsCommand() {
-  const command = new import_commander24.Command("buy-credits");
+  const command = new import_commander25.Command("buy-credits");
   command.description("Purchase one-time playground credits (never expire)").option(
     "-p, --package <package>",
     "Credit package to purchase (small, medium, large)"
@@ -13884,7 +16265,7 @@ Note: Purchased credits are one-time and never expire, unlike monthly credits.
 
 // src/commands/starred.ts
 init_cjs_shims();
-var import_commander25 = require("commander");
+var import_commander26 = require("commander");
 var import_registry_client11 = require("@pr-pm/registry-client");
 init_user_config();
 init_telemetry();
@@ -14000,14 +16381,14 @@ Total: ${packages.length + collections.length} starred items`);
   }
 }
 function createStarredCommand() {
-  const command = new import_commander25.Command("starred");
+  const command = new import_commander26.Command("starred");
   command.description("List your starred packages and collections").option("--packages", "Show only starred packages").option("--collections", "Show only starred collections").option("--format <format>", "Filter packages by format (cursor, claude, continue, windsurf, etc.)").option("--limit <number>", "Maximum number of items to fetch (default: 100)", (val) => parseInt(val, 10)).action(handleStarred);
   return command;
 }
 
 // src/commands/convert.ts
 init_cjs_shims();
-var import_commander26 = require("commander");
+var import_commander27 = require("commander");
 var import_promises8 = require("fs/promises");
 var import_path15 = require("path");
 var import_fs12 = require("fs");
@@ -14234,7 +16615,7 @@ async function handleConvert(sourcePath, options) {
   }
 }
 function createConvertCommand() {
-  const command = new import_commander26.Command("convert").description("Convert AI prompt files between formats").argument("<source>", "Source file path to convert").option("-t, --to <format>", "Target format (cursor, claude, windsurf, kiro, copilot, continue, agents.md)").option("-s, --subtype <subtype>", "Target subtype (agent, skill, slash-command, rule, prompt, etc.)").option("-o, --output <path>", "Output path (defaults to format-specific location)").option("-y, --yes", "Skip confirmation prompts").action(async (source, options) => {
+  const command = new import_commander27.Command("convert").description("Convert AI prompt files between formats").argument("<source>", "Source file path to convert").option("-t, --to <format>", "Target format (cursor, claude, windsurf, kiro, copilot, continue, agents.md)").option("-s, --subtype <subtype>", "Target subtype (agent, skill, slash-command, rule, prompt, etc.)").option("-o, --output <path>", "Output path (defaults to format-specific location)").option("-y, --yes", "Skip confirmation prompts").action(async (source, options) => {
     try {
       if (!options.to) {
         throw new CLIError("Target format is required. Use --to <format>");
@@ -14283,11 +16664,12 @@ function getVersion() {
     return "0.0.0";
   }
 }
-var program = new import_commander27.Command();
+var program = new import_commander28.Command();
 program.name("prpm").description("Prompt Package Manager - Install and manage prompt-based files").version(getVersion());
 program.addCommand(createInitCommand());
 program.addCommand(createCatalogCommand());
 program.addCommand(createSearchCommand());
+program.addCommand(createAISearchCommand());
 program.addCommand(createInstallCommand());
 program.addCommand(createInfoCommand());
 program.addCommand(createTrendingCommand());