@rhseung/ps-cli 1.0.0 → 1.2.1

package/dist/commands/init.js

@@ -0,0 +1,1635 @@
+#!/usr/bin/env node
+import {
+  getSupportedLanguages
+} from "../chunk-TQXMB7XV.js";
+import {
+  getAutoOpenEditor,
+  getDefaultLanguage,
+  getEditor,
+  getProblemDir,
+  getSolvedAcHandle,
+  setAutoOpenEditor,
+  setDefaultLanguage,
+  setEditor,
+  setProblemDir,
+  setSolvedAcHandle
+} from "../chunk-63CK6URL.js";
+import {
+  __commonJS,
+  __toESM
+} from "../chunk-FYS2JH42.js";
+
+// node_modules/lodash.isequal/index.js
+var require_lodash = __commonJS({
+  "node_modules/lodash.isequal/index.js"(exports, module) {
+    "use strict";
+    var LARGE_ARRAY_SIZE = 200;
+    var HASH_UNDEFINED = "__lodash_hash_undefined__";
+    var COMPARE_PARTIAL_FLAG = 1;
+    var COMPARE_UNORDERED_FLAG = 2;
+    var MAX_SAFE_INTEGER = 9007199254740991;
+    var argsTag = "[object Arguments]";
+    var arrayTag = "[object Array]";
+    var asyncTag = "[object AsyncFunction]";
+    var boolTag = "[object Boolean]";
+    var dateTag = "[object Date]";
+    var errorTag = "[object Error]";
+    var funcTag = "[object Function]";
+    var genTag = "[object GeneratorFunction]";
+    var mapTag = "[object Map]";
+    var numberTag = "[object Number]";
+    var nullTag = "[object Null]";
+    var objectTag = "[object Object]";
+    var promiseTag = "[object Promise]";
+    var proxyTag = "[object Proxy]";
+    var regexpTag = "[object RegExp]";
+    var setTag = "[object Set]";
+    var stringTag = "[object String]";
+    var symbolTag = "[object Symbol]";
+    var undefinedTag = "[object Undefined]";
+    var weakMapTag = "[object WeakMap]";
+    var arrayBufferTag = "[object ArrayBuffer]";
+    var dataViewTag = "[object DataView]";
+    var float32Tag = "[object Float32Array]";
+    var float64Tag = "[object Float64Array]";
+    var int8Tag = "[object Int8Array]";
+    var int16Tag = "[object Int16Array]";
+    var int32Tag = "[object Int32Array]";
+    var uint8Tag = "[object Uint8Array]";
+    var uint8ClampedTag = "[object Uint8ClampedArray]";
+    var uint16Tag = "[object Uint16Array]";
+    var uint32Tag = "[object Uint32Array]";
+    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+    var reIsHostCtor = /^\[object .+?Constructor\]$/;
+    var reIsUint = /^(?:0|[1-9]\d*)$/;
+    var typedArrayTags = {};
+    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+    typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+    var root = freeGlobal || freeSelf || Function("return this")();
+    var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+    var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+    var freeProcess = moduleExports && freeGlobal.process;
+    var nodeUtil = (function() {
+      try {
+        return freeProcess && freeProcess.binding && freeProcess.binding("util");
+      } catch (e) {
+      }
+    })();
+    var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+    function arrayFilter(array, predicate) {
+      var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+      while (++index < length) {
+        var value = array[index];
+        if (predicate(value, index, array)) {
+          result[resIndex++] = value;
+        }
+      }
+      return result;
+    }
+    function arrayPush(array, values) {
+      var index = -1, length = values.length, offset = array.length;
+      while (++index < length) {
+        array[offset + index] = values[index];
+      }
+      return array;
+    }
+    function arraySome(array, predicate) {
+      var index = -1, length = array == null ? 0 : array.length;
+      while (++index < length) {
+        if (predicate(array[index], index, array)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function baseTimes(n, iteratee) {
+      var index = -1, result = Array(n);
+      while (++index < n) {
+        result[index] = iteratee(index);
+      }
+      return result;
+    }
+    function baseUnary(func) {
+      return function(value) {
+        return func(value);
+      };
+    }
+    function cacheHas(cache, key) {
+      return cache.has(key);
+    }
+    function getValue(object, key) {
+      return object == null ? void 0 : object[key];
+    }
+    function mapToArray(map) {
+      var index = -1, result = Array(map.size);
+      map.forEach(function(value, key) {
+        result[++index] = [key, value];
+      });
+      return result;
+    }
+    function overArg(func, transform) {
+      return function(arg) {
+        return func(transform(arg));
+      };
+    }
+    function setToArray(set) {
+      var index = -1, result = Array(set.size);
+      set.forEach(function(value) {
+        result[++index] = value;
+      });
+      return result;
+    }
+    var arrayProto = Array.prototype;
+    var funcProto = Function.prototype;
+    var objectProto = Object.prototype;
+    var coreJsData = root["__core-js_shared__"];
+    var funcToString = funcProto.toString;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    var maskSrcKey = (function() {
+      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+      return uid ? "Symbol(src)_1." + uid : "";
+    })();
+    var nativeObjectToString = objectProto.toString;
+    var reIsNative = RegExp(
+      "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+    );
+    var Buffer = moduleExports ? root.Buffer : void 0;
+    var Symbol = root.Symbol;
+    var Uint8Array = root.Uint8Array;
+    var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+    var splice = arrayProto.splice;
+    var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+    var nativeGetSymbols = Object.getOwnPropertySymbols;
+    var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+    var nativeKeys = overArg(Object.keys, Object);
+    var DataView = getNative(root, "DataView");
+    var Map = getNative(root, "Map");
+    var Promise2 = getNative(root, "Promise");
+    var Set = getNative(root, "Set");
+    var WeakMap = getNative(root, "WeakMap");
+    var nativeCreate = getNative(Object, "create");
+    var dataViewCtorString = toSource(DataView);
+    var mapCtorString = toSource(Map);
+    var promiseCtorString = toSource(Promise2);
+    var setCtorString = toSource(Set);
+    var weakMapCtorString = toSource(WeakMap);
+    var symbolProto = Symbol ? Symbol.prototype : void 0;
+    var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+    function Hash(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function hashClear() {
+      this.__data__ = nativeCreate ? nativeCreate(null) : {};
+      this.size = 0;
+    }
+    function hashDelete(key) {
+      var result = this.has(key) && delete this.__data__[key];
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+    function hashGet(key) {
+      var data = this.__data__;
+      if (nativeCreate) {
+        var result = data[key];
+        return result === HASH_UNDEFINED ? void 0 : result;
+      }
+      return hasOwnProperty.call(data, key) ? data[key] : void 0;
+    }
+    function hashHas(key) {
+      var data = this.__data__;
+      return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+    }
+    function hashSet(key, value) {
+      var data = this.__data__;
+      this.size += this.has(key) ? 0 : 1;
+      data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+      return this;
+    }
+    Hash.prototype.clear = hashClear;
+    Hash.prototype["delete"] = hashDelete;
+    Hash.prototype.get = hashGet;
+    Hash.prototype.has = hashHas;
+    Hash.prototype.set = hashSet;
+    function ListCache(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function listCacheClear() {
+      this.__data__ = [];
+      this.size = 0;
+    }
+    function listCacheDelete(key) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      if (index < 0) {
+        return false;
+      }
+      var lastIndex = data.length - 1;
+      if (index == lastIndex) {
+        data.pop();
+      } else {
+        splice.call(data, index, 1);
+      }
+      --this.size;
+      return true;
+    }
+    function listCacheGet(key) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      return index < 0 ? void 0 : data[index][1];
+    }
+    function listCacheHas(key) {
+      return assocIndexOf(this.__data__, key) > -1;
+    }
+    function listCacheSet(key, value) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      if (index < 0) {
+        ++this.size;
+        data.push([key, value]);
+      } else {
+        data[index][1] = value;
+      }
+      return this;
+    }
+    ListCache.prototype.clear = listCacheClear;
+    ListCache.prototype["delete"] = listCacheDelete;
+    ListCache.prototype.get = listCacheGet;
+    ListCache.prototype.has = listCacheHas;
+    ListCache.prototype.set = listCacheSet;
+    function MapCache(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function mapCacheClear() {
+      this.size = 0;
+      this.__data__ = {
+        "hash": new Hash(),
+        "map": new (Map || ListCache)(),
+        "string": new Hash()
+      };
+    }
+    function mapCacheDelete(key) {
+      var result = getMapData(this, key)["delete"](key);
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+    function mapCacheGet(key) {
+      return getMapData(this, key).get(key);
+    }
+    function mapCacheHas(key) {
+      return getMapData(this, key).has(key);
+    }
+    function mapCacheSet(key, value) {
+      var data = getMapData(this, key), size = data.size;
+      data.set(key, value);
+      this.size += data.size == size ? 0 : 1;
+      return this;
+    }
+    MapCache.prototype.clear = mapCacheClear;
+    MapCache.prototype["delete"] = mapCacheDelete;
+    MapCache.prototype.get = mapCacheGet;
+    MapCache.prototype.has = mapCacheHas;
+    MapCache.prototype.set = mapCacheSet;
+    function SetCache(values) {
+      var index = -1, length = values == null ? 0 : values.length;
+      this.__data__ = new MapCache();
+      while (++index < length) {
+        this.add(values[index]);
+      }
+    }
+    function setCacheAdd(value) {
+      this.__data__.set(value, HASH_UNDEFINED);
+      return this;
+    }
+    function setCacheHas(value) {
+      return this.__data__.has(value);
+    }
+    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+    SetCache.prototype.has = setCacheHas;
+    function Stack(entries) {
+      var data = this.__data__ = new ListCache(entries);
+      this.size = data.size;
+    }
+    function stackClear() {
+      this.__data__ = new ListCache();
+      this.size = 0;
+    }
+    function stackDelete(key) {
+      var data = this.__data__, result = data["delete"](key);
+      this.size = data.size;
+      return result;
+    }
+    function stackGet(key) {
+      return this.__data__.get(key);
+    }
+    function stackHas(key) {
+      return this.__data__.has(key);
+    }
+    function stackSet(key, value) {
+      var data = this.__data__;
+      if (data instanceof ListCache) {
+        var pairs = data.__data__;
+        if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
+          pairs.push([key, value]);
+          this.size = ++data.size;
+          return this;
+        }
+        data = this.__data__ = new MapCache(pairs);
+      }
+      data.set(key, value);
+      this.size = data.size;
+      return this;
+    }
+    Stack.prototype.clear = stackClear;
+    Stack.prototype["delete"] = stackDelete;
+    Stack.prototype.get = stackGet;
+    Stack.prototype.has = stackHas;
+    Stack.prototype.set = stackSet;
+    function arrayLikeKeys(value, inherited) {
+      var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+      for (var key in value) {
+        if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+        (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+        isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+        isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+        isIndex(key, length)))) {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    function assocIndexOf(array, key) {
+      var length = array.length;
+      while (length--) {
+        if (eq(array[length][0], key)) {
+          return length;
+        }
+      }
+      return -1;
+    }
+    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+      var result = keysFunc(object);
+      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+    }
+    function baseGetTag(value) {
+      if (value == null) {
+        return value === void 0 ? undefinedTag : nullTag;
+      }
+      return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+    }
+    function baseIsArguments(value) {
+      return isObjectLike(value) && baseGetTag(value) == argsTag;
+    }
+    function baseIsEqual(value, other, bitmask, customizer, stack) {
+      if (value === other) {
+        return true;
+      }
+      if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+        return value !== value && other !== other;
+      }
+      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+    }
+    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+      var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
+      objTag = objTag == argsTag ? objectTag : objTag;
+      othTag = othTag == argsTag ? objectTag : othTag;
+      var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+      if (isSameTag && isBuffer(object)) {
+        if (!isBuffer(other)) {
+          return false;
+        }
+        objIsArr = true;
+        objIsObj = false;
+      }
+      if (isSameTag && !objIsObj) {
+        stack || (stack = new Stack());
+        return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+      }
+      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+        var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+        if (objIsWrapped || othIsWrapped) {
+          var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+          stack || (stack = new Stack());
+          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+        }
+      }
+      if (!isSameTag) {
+        return false;
+      }
+      stack || (stack = new Stack());
+      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+    }
+    function baseIsNative(value) {
+      if (!isObject(value) || isMasked(value)) {
+        return false;
+      }
+      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+      return pattern.test(toSource(value));
+    }
+    function baseIsTypedArray(value) {
+      return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+    }
+    function baseKeys(object) {
+      if (!isPrototype(object)) {
+        return nativeKeys(object);
+      }
+      var result = [];
+      for (var key in Object(object)) {
+        if (hasOwnProperty.call(object, key) && key != "constructor") {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
+      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+        return false;
+      }
+      var stacked = stack.get(array);
+      if (stacked && stack.get(other)) {
+        return stacked == other;
+      }
+      var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
+      stack.set(array, other);
+      stack.set(other, array);
+      while (++index < arrLength) {
+        var arrValue = array[index], othValue = other[index];
+        if (customizer) {
+          var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+        }
+        if (compared !== void 0) {
+          if (compared) {
+            continue;
+          }
+          result = false;
+          break;
+        }
+        if (seen) {
+          if (!arraySome(other, function(othValue2, othIndex) {
+            if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+              return seen.push(othIndex);
+            }
+          })) {
+            result = false;
+            break;
+          }
+        } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+          result = false;
+          break;
+        }
+      }
+      stack["delete"](array);
+      stack["delete"](other);
+      return result;
+    }
+    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+      switch (tag) {
+        case dataViewTag:
+          if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+            return false;
+          }
+          object = object.buffer;
+          other = other.buffer;
+        case arrayBufferTag:
+          if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+            return false;
+          }
+          return true;
+        case boolTag:
+        case dateTag:
+        case numberTag:
+          return eq(+object, +other);
+        case errorTag:
+          return object.name == other.name && object.message == other.message;
+        case regexpTag:
+        case stringTag:
+          return object == other + "";
+        case mapTag:
+          var convert = mapToArray;
+        case setTag:
+          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+          convert || (convert = setToArray);
+          if (object.size != other.size && !isPartial) {
+            return false;
+          }
+          var stacked = stack.get(object);
+          if (stacked) {
+            return stacked == other;
+          }
+          bitmask |= COMPARE_UNORDERED_FLAG;
+          stack.set(object, other);
+          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+          stack["delete"](object);
+          return result;
+        case symbolTag:
+          if (symbolValueOf) {
+            return symbolValueOf.call(object) == symbolValueOf.call(other);
+          }
+      }
+      return false;
+    }
+    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+      if (objLength != othLength && !isPartial) {
+        return false;
+      }
+      var index = objLength;
+      while (index--) {
+        var key = objProps[index];
+        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+          return false;
+        }
+      }
+      var stacked = stack.get(object);
+      if (stacked && stack.get(other)) {
+        return stacked == other;
+      }
+      var result = true;
+      stack.set(object, other);
+      stack.set(other, object);
+      var skipCtor = isPartial;
+      while (++index < objLength) {
+        key = objProps[index];
+        var objValue = object[key], othValue = other[key];
+        if (customizer) {
+          var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+        }
+        if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+          result = false;
+          break;
+        }
+        skipCtor || (skipCtor = key == "constructor");
+      }
+      if (result && !skipCtor) {
+        var objCtor = object.constructor, othCtor = other.constructor;
+        if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+          result = false;
+        }
+      }
+      stack["delete"](object);
+      stack["delete"](other);
+      return result;
+    }
+    function getAllKeys(object) {
+      return baseGetAllKeys(object, keys, getSymbols);
+    }
+    function getMapData(map, key) {
+      var data = map.__data__;
+      return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+    }
+    function getNative(object, key) {
+      var value = getValue(object, key);
+      return baseIsNative(value) ? value : void 0;
+    }
+    function getRawTag(value) {
+      var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+      try {
+        value[symToStringTag] = void 0;
+        var unmasked = true;
+      } catch (e) {
+      }
+      var result = nativeObjectToString.call(value);
+      if (unmasked) {
+        if (isOwn) {
+          value[symToStringTag] = tag;
+        } else {
+          delete value[symToStringTag];
+        }
+      }
+      return result;
+    }
+    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+      if (object == null) {
+        return [];
+      }
+      object = Object(object);
+      return arrayFilter(nativeGetSymbols(object), function(symbol) {
+        return propertyIsEnumerable.call(object, symbol);
+      });
+    };
+    var getTag = baseGetTag;
+    if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set && getTag(new Set()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {
+      getTag = function(value) {
+        var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+        if (ctorString) {
+          switch (ctorString) {
+            case dataViewCtorString:
+              return dataViewTag;
+            case mapCtorString:
+              return mapTag;
+            case promiseCtorString:
+              return promiseTag;
+            case setCtorString:
+              return setTag;
+            case weakMapCtorString:
+              return weakMapTag;
+          }
+        }
+        return result;
+      };
+    }
+    function isIndex(value, length) {
+      length = length == null ? MAX_SAFE_INTEGER : length;
+      return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+    }
+    function isKeyable(value) {
+      var type = typeof value;
+      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+    }
+    function isMasked(func) {
+      return !!maskSrcKey && maskSrcKey in func;
+    }
+    function isPrototype(value) {
+      var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
+      return value === proto;
+    }
+    function objectToString(value) {
+      return nativeObjectToString.call(value);
+    }
+    function toSource(func) {
+      if (func != null) {
+        try {
+          return funcToString.call(func);
+        } catch (e) {
+        }
+        try {
+          return func + "";
+        } catch (e) {
+        }
+      }
+      return "";
+    }
+    function eq(value, other) {
+      return value === other || value !== value && other !== other;
+    }
+    var isArguments = baseIsArguments(/* @__PURE__ */ (function() {
+      return arguments;
+    })()) ? baseIsArguments : function(value) {
+      return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+    };
+    var isArray = Array.isArray;
+    function isArrayLike(value) {
+      return value != null && isLength(value.length) && !isFunction(value);
+    }
+    var isBuffer = nativeIsBuffer || stubFalse;
+    function isEqual2(value, other) {
+      return baseIsEqual(value, other);
+    }
+    function isFunction(value) {
+      if (!isObject(value)) {
+        return false;
+      }
+      var tag = baseGetTag(value);
+      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+    }
+    function isLength(value) {
+      return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+    }
+    function isObject(value) {
+      var type = typeof value;
+      return value != null && (type == "object" || type == "function");
+    }
+    function isObjectLike(value) {
+      return value != null && typeof value == "object";
+    }
+    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+    function keys(object) {
+      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+    }
+    function stubArray() {
+      return [];
+    }
+    function stubFalse() {
+      return false;
+    }
+    module.exports = isEqual2;
+  }
+});
+
+// node_modules/arr-rotate/index.js
+var require_arr_rotate = __commonJS({
+  "node_modules/arr-rotate/index.js"(exports, module) {
+    "use strict";
+    module.exports = (input, n) => {
+      if (!Array.isArray(input)) {
+        throw new TypeError(`Expected an array, got ${typeof input}`);
+      }
+      const x = input.slice();
+      const num = typeof n === "number" ? n : 0;
+      return x.splice(-num % x.length).concat(x);
+    };
+  }
+});
+
+// src/commands/init.tsx
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { render, Text as Text3, Box as Box3 } from "ink";
+import { mkdir, readFile, writeFile, access } from "fs/promises";
+import { join } from "path";
+
+// node_modules/ink-select-input/build/Indicator.js
+import React from "react";
+import { Box, Text } from "ink";
+
+// node_modules/ink-select-input/node_modules/figures/index.js
+import process3 from "process";
+
+// node_modules/ink-select-input/node_modules/figures/node_modules/is-unicode-supported/index.js
+import process2 from "process";
+function isUnicodeSupported() {
+  if (process2.platform !== "win32") {
+    return process2.env.TERM !== "linux";
+  }
+  return Boolean(process2.env.CI) || Boolean(process2.env.WT_SESSION) || Boolean(process2.env.TERMINUS_SUBLIME) || process2.env.ConEmuTask === "{cmd::Cmder}" || process2.env.TERM_PROGRAM === "Terminus-Sublime" || process2.env.TERM_PROGRAM === "vscode" || process2.env.TERM === "xterm-256color" || process2.env.TERM === "alacritty" || process2.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+
+// node_modules/ink-select-input/node_modules/figures/index.js
+var { platform } = process3;
+var common = {
+  square: "\u2588",
+  squareDarkShade: "\u2593",
+  squareMediumShade: "\u2592",
+  squareLightShade: "\u2591",
+  squareTop: "\u2580",
+  squareBottom: "\u2584",
+  squareLeft: "\u258C",
+  squareRight: "\u2590",
+  squareCenter: "\u25A0",
+  bullet: "\u25CF",
+  dot: "\u2024",
+  ellipsis: "\u2026",
+  pointerSmall: "\u203A",
+  triangleUp: "\u25B2",
+  triangleUpSmall: "\u25B4",
+  triangleDown: "\u25BC",
+  triangleDownSmall: "\u25BE",
+  triangleLeftSmall: "\u25C2",
+  triangleRightSmall: "\u25B8",
+  home: "\u2302",
+  heart: "\u2665",
+  musicNote: "\u266A",
+  musicNoteBeamed: "\u266B",
+  arrowUp: "\u2191",
+  arrowDown: "\u2193",
+  arrowLeft: "\u2190",
+  arrowRight: "\u2192",
+  arrowLeftRight: "\u2194",
+  arrowUpDown: "\u2195",
+  almostEqual: "\u2248",
+  notEqual: "\u2260",
+  lessOrEqual: "\u2264",
+  greaterOrEqual: "\u2265",
+  identical: "\u2261",
+  infinity: "\u221E",
+  subscriptZero: "\u2080",
+  subscriptOne: "\u2081",
+  subscriptTwo: "\u2082",
+  subscriptThree: "\u2083",
+  subscriptFour: "\u2084",
+  subscriptFive: "\u2085",
+  subscriptSix: "\u2086",
+  subscriptSeven: "\u2087",
+  subscriptEight: "\u2088",
+  subscriptNine: "\u2089",
+  oneHalf: "\xBD",
+  oneThird: "\u2153",
+  oneQuarter: "\xBC",
+  oneFifth: "\u2155",
+  oneSixth: "\u2159",
+  oneEighth: "\u215B",
+  twoThirds: "\u2154",
+  twoFifths: "\u2156",
+  threeQuarters: "\xBE",
+  threeFifths: "\u2157",
+  threeEighths: "\u215C",
+  fourFifths: "\u2158",
+  fiveSixths: "\u215A",
+  fiveEighths: "\u215D",
+  sevenEighths: "\u215E",
+  line: "\u2500",
+  lineBold: "\u2501",
+  lineDouble: "\u2550",
+  lineDashed0: "\u2504",
+  lineDashed1: "\u2505",
+  lineDashed2: "\u2508",
+  lineDashed3: "\u2509",
+  lineDashed4: "\u254C",
+  lineDashed5: "\u254D",
+  lineDashed6: "\u2574",
+  lineDashed7: "\u2576",
+  lineDashed8: "\u2578",
+  lineDashed9: "\u257A",
+  lineDashed10: "\u257C",
+  lineDashed11: "\u257E",
+  lineDashed12: "\u2212",
+  lineDashed13: "\u2013",
+  lineDashed14: "\u2010",
+  lineDashed15: "\u2043",
+  lineVertical: "\u2502",
+  lineVerticalBold: "\u2503",
+  lineVerticalDouble: "\u2551",
+  lineVerticalDashed0: "\u2506",
+  lineVerticalDashed1: "\u2507",
+  lineVerticalDashed2: "\u250A",
+  lineVerticalDashed3: "\u250B",
+  lineVerticalDashed4: "\u254E",
+  lineVerticalDashed5: "\u254F",
+  lineVerticalDashed6: "\u2575",
+  lineVerticalDashed7: "\u2577",
+  lineVerticalDashed8: "\u2579",
+  lineVerticalDashed9: "\u257B",
+  lineVerticalDashed10: "\u257D",
+  lineVerticalDashed11: "\u257F",
+  lineDownLeft: "\u2510",
+  lineDownLeftArc: "\u256E",
+  lineDownBoldLeftBold: "\u2513",
+  lineDownBoldLeft: "\u2512",
+  lineDownLeftBold: "\u2511",
+  lineDownDoubleLeftDouble: "\u2557",
+  lineDownDoubleLeft: "\u2556",
+  lineDownLeftDouble: "\u2555",
+  lineDownRight: "\u250C",
+  lineDownRightArc: "\u256D",
+  lineDownBoldRightBold: "\u250F",
+  lineDownBoldRight: "\u250E",
+  lineDownRightBold: "\u250D",
+  lineDownDoubleRightDouble: "\u2554",
+  lineDownDoubleRight: "\u2553",
+  lineDownRightDouble: "\u2552",
+  lineUpLeft: "\u2518",
+  lineUpLeftArc: "\u256F",
+  lineUpBoldLeftBold: "\u251B",
+  lineUpBoldLeft: "\u251A",
+  lineUpLeftBold: "\u2519",
+  lineUpDoubleLeftDouble: "\u255D",
+  lineUpDoubleLeft: "\u255C",
+  lineUpLeftDouble: "\u255B",
+  lineUpRight: "\u2514",
+  lineUpRightArc: "\u2570",
+  lineUpBoldRightBold: "\u2517",
+  lineUpBoldRight: "\u2516",
+  lineUpRightBold: "\u2515",
+  lineUpDoubleRightDouble: "\u255A",
+  lineUpDoubleRight: "\u2559",
+  lineUpRightDouble: "\u2558",
+  lineUpDownLeft: "\u2524",
+  lineUpBoldDownBoldLeftBold: "\u252B",
+  lineUpBoldDownBoldLeft: "\u2528",
+  lineUpDownLeftBold: "\u2525",
+  lineUpBoldDownLeftBold: "\u2529",
+  lineUpDownBoldLeftBold: "\u252A",
+  lineUpDownBoldLeft: "\u2527",
+  lineUpBoldDownLeft: "\u2526",
+  lineUpDoubleDownDoubleLeftDouble: "\u2563",
+  lineUpDoubleDownDoubleLeft: "\u2562",
+  lineUpDownLeftDouble: "\u2561",
+  lineUpDownRight: "\u251C",
+  lineUpBoldDownBoldRightBold: "\u2523",
+  lineUpBoldDownBoldRight: "\u2520",
+  lineUpDownRightBold: "\u251D",
+  lineUpBoldDownRightBold: "\u2521",
+  lineUpDownBoldRightBold: "\u2522",
+  lineUpDownBoldRight: "\u251F",
+  lineUpBoldDownRight: "\u251E",
+  lineUpDoubleDownDoubleRightDouble: "\u2560",
+  lineUpDoubleDownDoubleRight: "\u255F",
+  lineUpDownRightDouble: "\u255E",
+  lineDownLeftRight: "\u252C",
+  lineDownBoldLeftBoldRightBold: "\u2533",
+  lineDownLeftBoldRightBold: "\u252F",
+  lineDownBoldLeftRight: "\u2530",
+  lineDownBoldLeftBoldRight: "\u2531",
+  lineDownBoldLeftRightBold: "\u2532",
+  lineDownLeftRightBold: "\u252E",
+  lineDownLeftBoldRight: "\u252D",
+  lineDownDoubleLeftDoubleRightDouble: "\u2566",
+  lineDownDoubleLeftRight: "\u2565",
+  lineDownLeftDoubleRightDouble: "\u2564",
+  lineUpLeftRight: "\u2534",
+  lineUpBoldLeftBoldRightBold: "\u253B",
+  lineUpLeftBoldRightBold: "\u2537",
+  lineUpBoldLeftRight: "\u2538",
+  lineUpBoldLeftBoldRight: "\u2539",
+  lineUpBoldLeftRightBold: "\u253A",
+  lineUpLeftRightBold: "\u2536",
+  lineUpLeftBoldRight: "\u2535",
+  lineUpDoubleLeftDoubleRightDouble: "\u2569",
+  lineUpDoubleLeftRight: "\u2568",
+  lineUpLeftDoubleRightDouble: "\u2567",
+  lineUpDownLeftRight: "\u253C",
+  lineUpBoldDownBoldLeftBoldRightBold: "\u254B",
+  lineUpDownBoldLeftBoldRightBold: "\u2548",
+  lineUpBoldDownLeftBoldRightBold: "\u2547",
+  lineUpBoldDownBoldLeftRightBold: "\u254A",
+  lineUpBoldDownBoldLeftBoldRight: "\u2549",
+  lineUpBoldDownLeftRight: "\u2540",
+  lineUpDownBoldLeftRight: "\u2541",
+  lineUpDownLeftBoldRight: "\u253D",
+  lineUpDownLeftRightBold: "\u253E",
+  lineUpBoldDownBoldLeftRight: "\u2542",
+  lineUpDownLeftBoldRightBold: "\u253F",
+  lineUpBoldDownLeftBoldRight: "\u2543",
+  lineUpBoldDownLeftRightBold: "\u2544",
+  lineUpDownBoldLeftBoldRight: "\u2545",
+  lineUpDownBoldLeftRightBold: "\u2546",
+  lineUpDoubleDownDoubleLeftDoubleRightDouble: "\u256C",
+  lineUpDoubleDownDoubleLeftRight: "\u256B",
+  lineUpDownLeftDoubleRightDouble: "\u256A",
+  lineCross: "\u2573",
+  lineBackslash: "\u2572",
+  lineSlash: "\u2571"
+};
+var mainSymbols = {
+  ...common,
+  // The main symbols for those do not look that good on Ubuntu.
+  ...platform === "linux" ? {
+    circleQuestionMark: "?\u20DD",
+    questionMarkPrefix: "?\u20DD"
+  } : {
+    circleQuestionMark: "?",
+    questionMarkPrefix: "?"
+  },
+  tick: "\u2714",
+  info: "\u2139",
+  warning: "\u26A0",
+  cross: "\u2718",
+  squareSmall: "\u25FB",
+  squareSmallFilled: "\u25FC",
+  circle: "\u25EF",
+  circleFilled: "\u25C9",
+  circleDotted: "\u25CC",
+  circleDouble: "\u25CE",
+  circleCircle: "\u24DE",
+  circleCross: "\u24E7",
+  circlePipe: "\u24BE",
+  radioOn: "\u25C9",
+  radioOff: "\u25EF",
+  checkboxOn: "\u2612",
+  checkboxOff: "\u2610",
+  checkboxCircleOn: "\u24E7",
+  checkboxCircleOff: "\u24BE",
+  pointer: "\u276F",
+  triangleUpOutline: "\u25B3",
+  triangleLeft: "\u25C0",
+  triangleRight: "\u25B6",
+  lozenge: "\u25C6",
+  lozengeOutline: "\u25C7",
+  hamburger: "\u2630",
+  smiley: "\u32E1",
+  mustache: "\u0DF4",
+  star: "\u2605",
+  play: "\u25B6",
+  nodejs: "\u2B22",
+  oneSeventh: "\u2150",
+  oneNinth: "\u2151",
+  oneTenth: "\u2152"
+};
+var fallbackSymbols = {
+  ...common,
+  tick: "\u221A",
+  info: "i",
+  warning: "\u203C",
+  cross: "\xD7",
+  squareSmall: "\u25A1",
+  squareSmallFilled: "\u25A0",
+  circle: "( )",
+  circleFilled: "(*)",
+  circleDotted: "( )",
+  circleDouble: "( )",
+  circleCircle: "(\u25CB)",
+  circleCross: "(\xD7)",
+  circlePipe: "(\u2502)",
+  circleQuestionMark: "(?)",
+  radioOn: "(*)",
+  radioOff: "( )",
+  checkboxOn: "[\xD7]",
+  checkboxOff: "[ ]",
+  checkboxCircleOn: "(\xD7)",
+  checkboxCircleOff: "( )",
+  questionMarkPrefix: "\uFF1F",
+  pointer: ">",
+  triangleUpOutline: "\u2206",
+  triangleLeft: "\u25C4",
+  triangleRight: "\u25BA",
+  lozenge: "\u2666",
+  lozengeOutline: "\u25CA",
+  hamburger: "\u2261",
+  smiley: "\u263A",
+  mustache: "\u250C\u2500\u2510",
+  star: "\u2736",
+  play: "\u25BA",
+  nodejs: "\u2666",
+  oneSeventh: "1/7",
+  oneNinth: "1/9",
+  oneTenth: "1/10"
+};
+var shouldUseMain = isUnicodeSupported();
+var figures = shouldUseMain ? mainSymbols : fallbackSymbols;
+var figures_default = figures;
+
+// node_modules/ink-select-input/build/Indicator.js
+function Indicator({ isSelected = false }) {
+  return React.createElement(Box, { marginRight: 1 }, isSelected ? React.createElement(Text, { color: "blue" }, figures_default.pointer) : React.createElement(Text, null, " "));
+}
+var Indicator_default = Indicator;
+
+// node_modules/ink-select-input/build/Item.js
+import * as React2 from "react";
+import { Text as Text2 } from "ink";
+function Item({ isSelected = false, label }) {
+  return React2.createElement(Text2, { color: isSelected ? "blue" : void 0 }, label);
+}
+var Item_default = Item;
+
+// node_modules/ink-select-input/build/SelectInput.js
+var import_lodash = __toESM(require_lodash(), 1);
+var import_arr_rotate = __toESM(require_arr_rotate(), 1);
+import React3 from "react";
+import { useState, useEffect, useRef, useCallback } from "react";
+import { Box as Box2, useInput } from "ink";
+function SelectInput({ items = [], isFocused = true, initialIndex = 0, indicatorComponent = Indicator_default, itemComponent = Item_default, limit: customLimit, onSelect, onHighlight }) {
+  const hasLimit = typeof customLimit === "number" && items.length > customLimit;
+  const limit = hasLimit ? Math.min(customLimit, items.length) : items.length;
+  const lastIndex = limit - 1;
+  const [rotateIndex, setRotateIndex] = useState(initialIndex > lastIndex ? lastIndex - initialIndex : 0);
+  const [selectedIndex, setSelectedIndex] = useState(initialIndex ? initialIndex > lastIndex ? lastIndex : initialIndex : 0);
+  const previousItems = useRef(items);
+  useEffect(() => {
+    if (!(0, import_lodash.default)(previousItems.current.map((item) => item.value), items.map((item) => item.value))) {
+      setRotateIndex(0);
+      setSelectedIndex(0);
+    }
+    previousItems.current = items;
+  }, [items]);
+  useInput(useCallback((input, key) => {
+    if (input === "k" || key.upArrow) {
+      const lastIndex2 = (hasLimit ? limit : items.length) - 1;
+      const atFirstIndex = selectedIndex === 0;
+      const nextIndex = hasLimit ? selectedIndex : lastIndex2;
+      const nextRotateIndex = atFirstIndex ? rotateIndex + 1 : rotateIndex;
+      const nextSelectedIndex = atFirstIndex ? nextIndex : selectedIndex - 1;
+      setRotateIndex(nextRotateIndex);
+      setSelectedIndex(nextSelectedIndex);
+      const slicedItems2 = hasLimit ? (0, import_arr_rotate.default)(items, nextRotateIndex).slice(0, limit) : items;
+      if (typeof onHighlight === "function") {
+        onHighlight(slicedItems2[nextSelectedIndex]);
+      }
+    }
+    if (input === "j" || key.downArrow) {
+      const atLastIndex = selectedIndex === (hasLimit ? limit : items.length) - 1;
+      const nextIndex = hasLimit ? selectedIndex : 0;
+      const nextRotateIndex = atLastIndex ? rotateIndex - 1 : rotateIndex;
+      const nextSelectedIndex = atLastIndex ? nextIndex : selectedIndex + 1;
+      setRotateIndex(nextRotateIndex);
+      setSelectedIndex(nextSelectedIndex);
+      const slicedItems2 = hasLimit ? (0, import_arr_rotate.default)(items, nextRotateIndex).slice(0, limit) : items;
+      if (typeof onHighlight === "function") {
+        onHighlight(slicedItems2[nextSelectedIndex]);
+      }
+    }
+    if (key.return) {
+      const slicedItems2 = hasLimit ? (0, import_arr_rotate.default)(items, rotateIndex).slice(0, limit) : items;
+      if (typeof onSelect === "function") {
+        onSelect(slicedItems2[selectedIndex]);
+      }
+    }
+  }, [
+    hasLimit,
+    limit,
+    rotateIndex,
+    selectedIndex,
+    items,
+    onSelect,
+    onHighlight
+  ]), { isActive: isFocused });
+  const slicedItems = hasLimit ? (0, import_arr_rotate.default)(items, rotateIndex).slice(0, limit) : items;
+  return React3.createElement(Box2, { flexDirection: "column" }, slicedItems.map((item, index) => {
+    const isSelected = index === selectedIndex;
+    return (
+      // @ts-expect-error - `key` can't be optional but `item.value` is generic T
+      React3.createElement(
+        Box2,
+        { key: item.key ?? item.value },
+        React3.createElement(indicatorComponent, { isSelected }),
+        React3.createElement(itemComponent, { ...item, isSelected })
+      )
+    );
+  }));
+}
+var SelectInput_default = SelectInput;
+
+// src/commands/init.tsx
+import TextInput from "ink-text-input";
+import { jsx, jsxs } from "react/jsx-runtime";
+function InitCommand({ onComplete }) {
+  const [currentStep, setCurrentStep] = useState2("problem-dir");
+  const [completedSteps, setCompletedSteps] = useState2([]);
+  const [confirmExit, setConfirmExit] = useState2(false);
+  const [exitConfirmInput, setExitConfirmInput] = useState2("");
+  const [initialized, setInitialized] = useState2(false);
+  const [problemDir, setProblemDirValue] = useState2(getProblemDir());
+  const [language, setLanguage] = useState2(getDefaultLanguage());
+  const [editor, setEditorValue] = useState2(getEditor());
+  const [autoOpen, setAutoOpen] = useState2(getAutoOpenEditor());
+  const [handle, setHandle] = useState2(getSolvedAcHandle() || "");
+  const [handleInputMode, setHandleInputMode] = useState2(false);
+  const [created, setCreated] = useState2([]);
+  const [cancelled, setCancelled] = useState2(false);
+  useEffect2(() => {
+    const handleSigInt = () => {
+      if (confirmExit) {
+        setCancelled(true);
+        setCurrentStep("cancelled");
+        setTimeout(() => {
+          onComplete();
+        }, 500);
+        return;
+      }
+      setConfirmExit(true);
+      setExitConfirmInput("");
+    };
+    process.on("SIGINT", handleSigInt);
+    return () => {
+      process.off("SIGINT", handleSigInt);
+    };
+  }, [confirmExit, onComplete]);
+  useEffect2(() => {
+    if (confirmExit && exitConfirmInput.toLowerCase() === "y") {
+      setCancelled(true);
+      setCurrentStep("cancelled");
+      setTimeout(() => {
+        onComplete();
+      }, 500);
+    } else if (confirmExit && exitConfirmInput.toLowerCase() === "n") {
+      setConfirmExit(false);
+      setExitConfirmInput("");
+    }
+  }, [exitConfirmInput, confirmExit, onComplete]);
+  useEffect2(() => {
+    async function loadProjectConfig() {
+      try {
+        const cwd = process.cwd();
+        const projectConfigPath = join(cwd, ".ps-cli.json");
+        await access(projectConfigPath);
+        const configContent = await readFile(projectConfigPath, "utf-8");
+        const projectConfig = JSON.parse(configContent);
+        if (projectConfig.problemDir)
+          setProblemDirValue(projectConfig.problemDir);
+        if (projectConfig.defaultLanguage)
+          setLanguage(projectConfig.defaultLanguage);
+        if (projectConfig.editor) setEditorValue(projectConfig.editor);
+        if (projectConfig.autoOpenEditor !== void 0)
+          setAutoOpen(projectConfig.autoOpenEditor);
+        if (projectConfig.solvedAcHandle)
+          setHandle(projectConfig.solvedAcHandle);
+      } catch (err) {
+      } finally {
+        setInitialized(true);
+      }
+    }
+    loadProjectConfig();
+  }, []);
+  function getStepLabel(step) {
+    switch (step) {
+      case "problem-dir":
+        return "\uBB38\uC81C \uB514\uB809\uD1A0\uB9AC \uC124\uC815";
+      case "language":
+        return "\uAE30\uBCF8 \uC5B8\uC5B4 \uC124\uC815";
+      case "editor":
+        return "\uC5D0\uB514\uD130 \uC124\uC815";
+      case "auto-open":
+        return "\uC790\uB3D9 \uC5D0\uB514\uD130 \uC5F4\uAE30";
+      case "handle":
+        return "Solved.ac \uD578\uB4E4 (\uC120\uD0DD)";
+      default:
+        return "";
+    }
+  }
+  function moveToNextStep(selectedValue, stepLabel) {
+    setCompletedSteps((prev) => [
+      ...prev,
+      { label: stepLabel, value: selectedValue }
+    ]);
+    const stepOrder = [
+      "problem-dir",
+      "language",
+      "editor",
+      "auto-open",
+      "handle",
+      "done"
+    ];
+    const currentIndex = stepOrder.indexOf(currentStep);
+    if (currentIndex < stepOrder.length - 1) {
+      const nextStep = stepOrder[currentIndex + 1];
+      setCurrentStep(nextStep);
+      if (nextStep === "done") {
+        void executeInit();
+      }
+    }
+  }
+  function getStepValue(step) {
+    switch (step) {
+      case "problem-dir":
+        return problemDir === "." ? "\uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8" : problemDir;
+      case "language":
+        return language;
+      case "editor":
+        return editor;
+      case "auto-open":
+        return autoOpen ? "\uC608" : "\uC544\uB2C8\uC624";
+      case "handle":
+        return handle || "(\uC2A4\uD0B5)";
+      default:
+        return "";
+    }
+  }
+  async function executeInit() {
+    try {
+      const cwd = process.cwd();
+      const projectConfigPath = join(cwd, ".ps-cli.json");
+      const projectConfig = {
+        problemDir,
+        defaultLanguage: language,
+        editor,
+        autoOpenEditor: autoOpen,
+        solvedAcHandle: handle || void 0
+      };
+      await writeFile(
+        projectConfigPath,
+        JSON.stringify(projectConfig, null, 2),
+        "utf-8"
+      );
+      setCreated((prev) => [...prev, ".ps-cli.json"]);
+      setProblemDir(problemDir);
+      setDefaultLanguage(language);
+      setEditor(editor);
+      setAutoOpenEditor(autoOpen);
+      if (handle) {
+        setSolvedAcHandle(handle);
+      }
+      if (problemDir !== "." && problemDir !== "") {
+        const problemDirPath = join(cwd, problemDir);
+        try {
+          await mkdir(problemDirPath, { recursive: true });
+          setCreated((prev) => [...prev, `${problemDir}/`]);
+        } catch (err) {
+          const error = err;
+          if (error.code !== "EEXIST") {
+            throw err;
+          }
+        }
+        const gitignorePath = join(cwd, ".gitignore");
+        const gitignorePattern = `${problemDir}/`;
+        try {
+          const gitignoreContent = await readFile(gitignorePath, "utf-8");
+          if (!gitignoreContent.includes(gitignorePattern)) {
+            const updatedContent = gitignoreContent.trim() + (gitignoreContent.trim() ? "\n" : "") + `
+# ps-cli \uBB38\uC81C \uB514\uB809\uD1A0\uB9AC
+${gitignorePattern}
+`;
+            await writeFile(gitignorePath, updatedContent, "utf-8");
+            setCreated((prev) => [...prev, ".gitignore \uC5C5\uB370\uC774\uD2B8"]);
+          }
+        } catch (err) {
+          const error = err;
+          if (error.code === "ENOENT") {
+            await writeFile(
+              gitignorePath,
+              `# ps-cli \uBB38\uC81C \uB514\uB809\uD1A0\uB9AC
+${gitignorePattern}
+`,
+              "utf-8"
+            );
+            setCreated((prev) => [...prev, ".gitignore \uC0DD\uC131"]);
+          } else {
+            console.warn(".gitignore \uC5C5\uB370\uC774\uD2B8 \uC2E4\uD328:", error.message);
+          }
+        }
+      }
+      setTimeout(() => {
+        onComplete();
+      }, 3e3);
+    } catch (err) {
+      const error = err;
+      console.error("\uCD08\uAE30\uD654 \uC911 \uC624\uB958 \uBC1C\uC0DD:", error.message);
+      setCancelled(true);
+      setCurrentStep("cancelled");
+      setTimeout(() => {
+        onComplete();
+      }, 2e3);
+    }
+  }
+  function renderQuestionCard(title, children) {
+    return /* @__PURE__ */ jsxs(
+      Box3,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: "yellow",
+        paddingX: 1,
+        marginTop: 1,
+        children: [
+          /* @__PURE__ */ jsx(Box3, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text3, { color: "yellow", bold: true, children: title }) }),
+          /* @__PURE__ */ jsx(Box3, { flexDirection: "column", children })
+        ]
+      }
+    );
+  }
+  function renderStepContent() {
+    if (cancelled || currentStep === "cancelled") {
+      return /* @__PURE__ */ jsx(
+        Box3,
+        {
+          flexDirection: "column",
+          borderStyle: "round",
+          borderColor: "red",
+          paddingX: 1,
+          children: /* @__PURE__ */ jsx(Text3, { color: "red", bold: true, children: "\u2717 \uCD08\uAE30\uD654\uAC00 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4." })
+        }
+      );
+    }
+    if (confirmExit) {
+      return /* @__PURE__ */ jsx(Box3, { flexDirection: "column", children: /* @__PURE__ */ jsxs(
+        Box3,
+        {
+          flexDirection: "column",
+          borderStyle: "round",
+          borderColor: "red",
+          paddingX: 1,
+          children: [
+            /* @__PURE__ */ jsx(Text3, { color: "red", bold: true, children: "\uC815\uB9D0 \uC885\uB8CC\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C? (y/n)" }),
+            /* @__PURE__ */ jsx(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx(
+              TextInput,
+              {
+                value: exitConfirmInput,
+                onChange: setExitConfirmInput,
+                placeholder: "",
+                showCursor: true
+              }
+            ) })
+          ]
+        }
+      ) });
+    }
+    switch (currentStep) {
+      case "problem-dir": {
+        const items = [
+          { label: "problems", value: "problems" },
+          { label: ". (\uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8)", value: "." }
+        ];
+        return renderQuestionCard(
+          getStepLabel(currentStep),
+          /* @__PURE__ */ jsx(
+            SelectInput_default,
+            {
+              items,
+              indicatorComponent: () => null,
+              itemComponent: ({ label, isSelected }) => /* @__PURE__ */ jsx(Box3, { children: /* @__PURE__ */ jsxs(Text3, { color: isSelected ? "yellow" : "gray", children: [
+                isSelected ? "\u2192 " : "  ",
+                label
+              ] }) }),
+              onSelect: (item) => {
+                setProblemDirValue(item.value);
+                const displayValue = item.value === "." ? "\uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8" : item.value;
+                moveToNextStep(displayValue, getStepLabel(currentStep));
+              }
+            }
+          )
+        );
+      }
+      case "language": {
+        const supportedLanguages = getSupportedLanguages();
+        const items = supportedLanguages.map((lang) => ({
+          label: lang,
+          value: lang
+        }));
+        return renderQuestionCard(
+          getStepLabel(currentStep),
+          /* @__PURE__ */ jsx(
+            SelectInput_default,
+            {
+              items,
+              indicatorComponent: () => null,
+              itemComponent: ({ label, isSelected }) => /* @__PURE__ */ jsx(Box3, { children: /* @__PURE__ */ jsxs(Text3, { color: isSelected ? "yellow" : "gray", children: [
+                isSelected ? "\u2192 " : "  ",
+                label
+              ] }) }),
+              onSelect: (item) => {
+                setLanguage(item.value);
+                moveToNextStep(item.value, getStepLabel(currentStep));
+              }
+            }
+          )
+        );
+      }
+      case "editor": {
+        const items = [
+          { label: "code", value: "code" },
+          { label: "cursor", value: "cursor" },
+          { label: "vim", value: "vim" },
+          { label: "nano", value: "nano" }
+        ];
+        return renderQuestionCard(
+          getStepLabel(currentStep),
+          /* @__PURE__ */ jsx(
+            SelectInput_default,
+            {
+              items,
+              indicatorComponent: () => null,
+              itemComponent: ({ label, isSelected }) => /* @__PURE__ */ jsx(Box3, { children: /* @__PURE__ */ jsxs(Text3, { color: isSelected ? "yellow" : "gray", children: [
+                isSelected ? "\u2192 " : "  ",
+                label
+              ] }) }),
+              onSelect: (item) => {
+                setEditorValue(item.value);
+                moveToNextStep(item.value, getStepLabel(currentStep));
+              }
+            }
+          )
+        );
+      }
+      case "auto-open": {
+        const items = [
+          { label: "\uC608", value: "true" },
+          { label: "\uC544\uB2C8\uC624", value: "false" }
+        ];
+        return renderQuestionCard(
+          getStepLabel(currentStep),
+          /* @__PURE__ */ jsx(
+            SelectInput_default,
+            {
+              items,
+              indicatorComponent: () => null,
+              itemComponent: ({ label, isSelected }) => /* @__PURE__ */ jsx(Box3, { children: /* @__PURE__ */ jsxs(Text3, { color: isSelected ? "yellow" : "gray", children: [
+                isSelected ? "\u2192 " : "  ",
+                label
+              ] }) }),
+              onSelect: (item) => {
+                setAutoOpen(item.value === "true");
+                moveToNextStep(
+                  item.value === "true" ? "\uC608" : "\uC544\uB2C8\uC624",
+                  getStepLabel(currentStep)
+                );
+              }
+            }
+          )
+        );
+      }
+      case "handle": {
+        if (handleInputMode) {
+          return renderQuestionCard(
+            getStepLabel(currentStep),
+            /* @__PURE__ */ jsx(Box3, { children: /* @__PURE__ */ jsx(
+              TextInput,
+              {
+                value: handle,
+                placeholder: "\uD578\uB4E4 \uC785\uB825",
+                onChange: setHandle,
+                onSubmit: (value) => {
+                  setHandleInputMode(false);
+                  moveToNextStep(value || "(\uC2A4\uD0B5)", getStepLabel(currentStep));
+                }
+              }
+            ) })
+          );
+        }
+        const items = [
+          { label: "\uC124\uC815", value: "set" },
+          { label: "\uC2A4\uD0B5", value: "skip" }
+        ];
+        return renderQuestionCard(
+          getStepLabel(currentStep),
+          /* @__PURE__ */ jsx(
+            SelectInput_default,
+            {
+              items,
+              indicatorComponent: () => null,
+              itemComponent: ({ label, isSelected }) => /* @__PURE__ */ jsx(Box3, { children: /* @__PURE__ */ jsxs(Text3, { color: isSelected ? "yellow" : "gray", children: [
+                isSelected ? "\u2192 " : "  ",
+                label
+              ] }) }),
+              onSelect: (item) => {
+                if (item.value === "skip") {
+                  setHandle("");
+                  moveToNextStep("(\uC2A4\uD0B5)", getStepLabel(currentStep));
+                } else {
+                  setHandleInputMode(true);
+                }
+              }
+            }
+          )
+        );
+      }
+      case "done": {
+        return /* @__PURE__ */ jsxs(Box3, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs(
+            Box3,
+            {
+              flexDirection: "column",
+              borderStyle: "round",
+              borderColor: "green",
+              paddingX: 1,
+              marginTop: 1,
+              marginBottom: 1,
+              children: [
+                /* @__PURE__ */ jsx(Box3, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text3, { color: "green", bold: true, children: "\u2713 \uD504\uB85C\uC81D\uD2B8 \uCD08\uAE30\uD654 \uC644\uB8CC" }) }),
+                created.length > 0 && /* @__PURE__ */ jsxs(Box3, { flexDirection: "column", children: [
+                  /* @__PURE__ */ jsx(Text3, { color: "cyan", bold: true, children: "\uC0DD\uC131\uB41C \uD56D\uBAA9:" }),
+                  /* @__PURE__ */ jsx(Box3, { flexDirection: "column", marginTop: 0, paddingLeft: 1, children: created.map((item, idx) => /* @__PURE__ */ jsxs(Text3, { color: "white", children: [
+                    "\u2022 ",
+                    item
+                  ] }, idx)) })
+                ] })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx(Box3, { children: /* @__PURE__ */ jsxs(Text3, { color: "gray", children: [
+            "\uC774\uC81C",
+            " ",
+            /* @__PURE__ */ jsx(Text3, { bold: true, color: "cyan", children: "ps help" }),
+            " ",
+            "\uBA85\uB839\uC5B4\uB97C \uD1B5\uD574 \uB354 \uC790\uC138\uD55C \uC815\uBCF4\uB97C \uD655\uC778\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4."
+          ] }) })
+        ] });
+      }
+      default:
+        return null;
+    }
+  }
+  if (!initialized) {
+    return /* @__PURE__ */ jsx(Box3, { children: /* @__PURE__ */ jsx(Text3, { color: "gray", children: "\uB85C\uB529 \uC911..." }) });
+  }
+  return /* @__PURE__ */ jsxs(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Box3, { marginBottom: completedSteps.length > 0 ? 1 : 0, children: /* @__PURE__ */ jsx(Text3, { color: "cyan", bold: true, children: "\u{1F680} ps-cli \uD504\uB85C\uC81D\uD2B8 \uCD08\uAE30\uD654" }) }),
+    completedSteps.length > 0 && /* @__PURE__ */ jsx(Box3, { flexDirection: "column", children: completedSteps.map((step, idx) => /* @__PURE__ */ jsxs(Box3, { marginBottom: 0, children: [
+      /* @__PURE__ */ jsx(Text3, { color: "green", children: "\u2713 " }),
+      /* @__PURE__ */ jsxs(Text3, { color: "gray", children: [
+        step.label,
+        ": "
+      ] }),
+      /* @__PURE__ */ jsx(Text3, { color: "cyan", bold: true, children: step.value })
+    ] }, idx)) }),
+    renderStepContent()
+  ] });
+}
+async function initCommand() {
+  return new Promise((resolve) => {
+    const { unmount } = render(
+      /* @__PURE__ */ jsx(
+        InitCommand,
+        {
+          onComplete: () => {
+            unmount();
+            resolve();
+          }
+        }
+      )
+    );
+  });
+}
+var initHelp = `
+  \uC0AC\uC6A9\uBC95:
+    $ ps init
+
+  \uC124\uBA85:
+    \uD604\uC7AC \uB514\uB809\uD1A0\uB9AC\uB97C ps-cli \uD504\uB85C\uC81D\uD2B8\uB85C \uB300\uD654\uD615\uC73C\uB85C \uCD08\uAE30\uD654\uD569\uB2C8\uB2E4.
+    - \uB2E8\uACC4\uBCC4\uB85C \uC124\uC815\uC744 \uBB3C\uC5B4\uBD05\uB2C8\uB2E4
+    - \uBB38\uC81C \uB514\uB809\uD1A0\uB9AC, \uAE30\uBCF8 \uC5B8\uC5B4, \uC5D0\uB514\uD130 \uB4F1\uC744 \uC124\uC815\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4
+
+  \uC608\uC81C:
+    $ ps init
+`;
+async function initExecute(args, flags) {
+  if (flags.help) {
+    console.log(initHelp.trim());
+    process.exit(0);
+    return;
+  }
+  await initCommand();
+}
+var initCommandDef = {
+  name: "init",
+  help: initHelp,
+  execute: initExecute
+};
+var init_default = initCommandDef;
+export {
+  init_default as default,
+  initExecute,
+  initHelp
+};