/*
 * Copyright (c) 2022 Vladimir Skrypnikov (Pheonix KageDesu)
 * <http://kdworkshop.net/>
 *

* License: Creative Commons 4.0 Attribution, Share Alike, Commercial

 */

/*:
 * @plugindesc (v.1.0)[PRO] Fonts Manager - custom fonts and colors
 * @author Pheonix KageDesu
 * @target MZ MV
 * @url http://kdworkshop.net/plugins/fonts-manager
 *
 * @help
 * ---------------------------------------------------------------------------
 * Help content: (below)
 * 1. How add and use custom font
 * 2. Font to Item name or Actor name
 * 3. Global fonts
 * 4. Global colors
 * 5. Global font and color both
 * 6. Custom pallete
 * 7. Extra palletes and switch between
 * ---------------------------------------------------------------------------
 * 1. How add and use custom font
 *
 *  Copy font file to project directory/fonts folder
 *  Open Plugin Parameters -> Fonts to load and add filename
 *  You should write full filname, with extension
 *  Example: myCoolFont.tff
 *
 *  Use control character \FF[X] for use your font in messages
 *      X - font index in Fonts to load list
 *  \FF[0] - return to default font
 *
 *  Alternative way \FF[myCoolFont]
 *  (supports only font names without spaces)
 * ---------------------------------------------------------------------------
 * 2. Font to Item name or Actor name
 *
 * Add to Note or Item\Weapon\Armor or Actor
 *
 * <FF:X>
 * <FF:name>
 *
 * ---------------------------------------------------------------------------
 * 3. Global fonts
 *  ! This future is expremental...not works always
 *  
 *  Set Plugin Parameter Fonts to load -> Is Global? to ON
 *
 *  Add |fX| to any text (in end) in database for change this text font
 *
 * RPG Maker will change font for any text with |fX|, where X - font index.
 * Example: Sword|f2|
 *
 * You can use this with third party plugins
 *
 * ---------------------------------------------------------------------------
 * 4. Global colors
 * ! This future is expremental...not works always
 *
 *  Same as Gloal fonts but for Colors
 *
 * Set Plugin Parameter Custom pallete -> Is Global? to ON
 *
 * Add |cX| to any text (in end) in database for change this text color
 *
 * Will change color for any text with |cX|, where X - color index.
 * Example: Sword|c2|
 *
 * You can use this with third party plugins
 * ---------------------------------------------------------------------------
 * 5. Global font and color both
 *
 * If you want change font and color in global level, use |fXcX|
 * Example: Sword|f3c1|
 *
 * ---------------------------------------------------------------------------
 * 6. Custom pallete
 * 
 * You can change default colors for character codes \C[X] to you own
 * See Plugin Parameters -> Custom pallete
 *
 * ---------------------------------------------------------------------------
 * 7. Extra palletes and switch between
 *
 *  Add more color palletes via Plugin Parameter -> More palletes
 * 
 *  And switch between then during game using script call:
 *  switchColorPallete(index);
 *
 *  index = 0 -> return to default one
 *
 * ===========================================================================
 * 
 * ---------------------------------------------------------------------------
 * If you like my Plugins, want more and offten updates,
 * please support me on Boosty (and get extra plugins)!
 * 
 * Boosty Page:
 *      https://boosty.to/kagedesu
 * YouTube Channel:
 *      https://www.youtube.com/channel/UCA3R61ojF5vp5tGwJ1YqdgQ?
 *
 * You can use this plugin in your game thanks to all who supports me!
 * 

* License: Creative Commons 4.0 Attribution, Share Alike, Commercial

 *
 * @param fontsToLoad:strA
 * @type text[]
 * @text Fonts to load
 * @default []
 * @desc Filename+.ext (in fonts folder). Are available by name (\\FF[test]) (without ext.) and Index (\\FF[2], |f2|)
 * 
 * @param isGlobal:b
 * @parent fontsToLoad:strA
 * @text Is Global?
 * @type boolean
 * @on Yes, |fX| available
 * @off No
 * @default true
 * @desc RPG Maker will change font for any text with |fX|, where X - font index. Example: Sword|f2|
 * 
 * @param isAutoLoad:b
 * @parent fontsToLoad:strA
 * @text Is Auto Load?
 * @type boolean
 * @on Auto
 * @off No
 * @default false
 * @desc [PC, MAC, LINUX] Auto load fonts (fonts folder). Available only by names (uses filename without ext as font name)
 * 
 * @param spacer|defaultFonts @text‏‏‎ ‎@desc ===============================================
 * 
 * @param defaultSetup
 * @text Default Fonts
 * 
 * @param allItemsFont
 * @parent defaultSetup
 * @text Items
 * @default
 * @desc Font name for all Items (names) in game. For all default Windows.
 * 
 * @param allArmorsFont
 * @parent defaultSetup
 * @text Armors
 * @default
 * @desc Font name for all Armors (names) in game. For all default Windows.
 * 
 * @param allWeaponsFont
 * @parent defaultSetup
 * @text Weapons
 * @default
 * @desc Font name for all Weapons (names) in game. For all default Windows.
 * 
 * @param allSkillsFont
 * @parent defaultSetup
 * @text Skills
 * @default
 * @desc Font name for all Skills (names) in game. For all default Windows.
 * 
 * @param allActorNamesFont
 * @parent defaultSetup
 * @text Actor name
 * @default
 * @desc Font name for all names (Actors names) in game. For all default Windows.
 * 
 * @param allActorClassFont
 * @parent defaultSetup
 * @text Actor class
 * @default
 * @desc Font name for all classes in game. For all default Windows.
 * 
 * @param allActorNickFont
 * @parent defaultSetup
 * @text Actor nickname
 * @default
 * @desc Font name for nicknames in game. For all default Windows.
 * 
 * @param allActorLevelFont
 * @parent defaultSetup
 * @text Actor level
 * @default
 * @desc Font name for level in game. For all default Windows.
 * 
 * @param spacer|colors @text‏‏‎ ‎@desc ===============================================
 * 
 * @param pallete:strA
 * @type text[]
 * @text Custom pallete
 * @default []
 * @desc Colors (hex) for replace \C[X]. Availble by Index. Example: #ba1a8f
 * 
 * @param userPalletes:structA
 * @parent pallete:strA
 * @type struct<Pallete>[]
 * @text More palletes
 * @default []
 * @desc You can switch palletes in game, script call: switchColorPallete(index);
 * 
 * @param isGlobalColors:b
 * @parent pallete:strA
 * @text Is Global?
 * @type boolean
 * @on Yes, |cX| available
 * @off No
 * @default true
 * @desc Will change color for any text with |cX|, where X - color index. Example: Sword|c2|
 * 
 * @param spacer|endHolder @text‏‏‎ ‎@desc ===============================================
 * 
 * @command EMPTY_HOLDER
 * @text ‏
 * @desc
 * @default
 */
/*:ru
 * @plugindesc (v.1.0)[PRO] Использование разных шрифтов
 * @author Pheonix KageDesu
 * @target MZ MV
 * @url http://kdworkshop.net/plugins/fonts-manager
 *
 * @help
 * ---------------------------------------------------------------------------
 * Разделы помощи: (ниже)
 * 1. Как добавить свой шрифт
 * 2. Задать шрифт через заметку
 * 3. Глобальный символ
 * 4. Глобальные цвета
 * 5. Глобальная пара (цвет и шрифт)
 * 6. Палитры цветов
 * 7. Доп. палитры и переключение между ними
 * ---------------------------------------------------------------------------
 * 1. Как добавить свой шрифт
 *
 *  Поместите файл шрифта в папку fonts    
 *  Откройте параметры плагина -> Fonts to load и добавьте ваши файлы
 *  Вписывать нужно полное имя файла с расширением
 *  Пример: myCoolFont.tff
 *
 *  Исп. символ \FF[X] для активации шрифта в сообщении
 *      X - номер шрифта из параметра Fonts to load
 *  \FF[0] - переключиться на стандартный шрифт
 *
 *  Альтернативый вариант: \FF[myCoolFont]
 *  (поддерживает только имена шрифтов без пробелов)
 * ---------------------------------------------------------------------------
 * 2. Задать шрифт через заметку
 *
 * Заметки для оружия, брони, предметов или персонажа (имя)
 *
 * <FF:номер шрифта>
 * <FF:имя шрифта>
 *
 * ---------------------------------------------------------------------------
 * 3. Глобальный символ
 *  ! Возможны сбои в работе в некоторых местах или плагинах
 *  
 *  Установите параметр плагина Fonts to load -> Is Global? на ВКЛ.
 *
 *  Добавьте |fX| к любому слову (в конец) в базе данных для смены шрифта
 *
 * RPG Maker будет везде менять шрифта текста с символом |fX|, где X - номер шрифта.
 * Пример: Меч|f2|
 *
 * Данный метод может работать и со сторонними плагинами
 *
 * ---------------------------------------------------------------------------
 * 4. Глобальные цвета
 * ! Возможны сбои в работе в некоторых местах или плагинах
 *
 *  Аналогично глобальному символу шрифтов, только для цвета
 *
 * Установите параметр плагина Custom pallete -> Is Global? на ВКЛ.
 *
 * Добавьте |cX| к любому слову (в конец) в базе данных для смены цвета
 *
 * RPG Maker будет везде менять цвет текста с символом |cX|, где X - номер цвета.
 * Пример: Меч|c2|
 *
 * Данный метод может работать и со сторонними плагинами
 * ---------------------------------------------------------------------------
 * 5. Глобальная пара (цвет и шрифт)
 *
 * Если хотите совместить шрифт и цвет, исп. |fXcX|
 * Пример: Меч|f3c1|
 *
 * ---------------------------------------------------------------------------
 * 6. Палитры цветов
 * 
 * Можно заменить стандартные цвета, исп. при символе \C[X] на собственные
 * См. параметры плагина -> Custom pallete
 *
 * ---------------------------------------------------------------------------
 * 7. Доп. палитры и переключение между ними
 *
 *  Можно добавить палитры через параметр плагина -> More palletes
 * 
 *  Для смены цветовых палитр во время игры, исп. вызов скрипта:
 *  switchColorPallete(индекс);
 *
 *  индекс = 0 -> стандартная цветовая палитра
 *
 * ===========================================================================
 * 
 * ---------------------------------------------------------------------------
 * Если Вам нравятся мои плагины, поддержите меня на Boosty!
 * 
 * Boosty Page:
 *      https://boosty.to/kagedesu
 * YouTube Channel:
 *      https://www.youtube.com/channel/UCA3R61ojF5vp5tGwJ1YqdgQ?
 * 

* Лицензия: Creative Commons 4.0 Attribution, Share Alike, Commercial

 *
 * @param fontsToLoad:strA
 * @type text[]
 * @text Fonts to load
 * @default []
 * @desc Имя файла полностью (из папки fonts). Исп. (\\FF[имя]) (без разр.) или по индексу (\\FF[2], |f2|)
 * 
 * @param isGlobal:b
 * @parent fontsToLoad:strA
 * @text Is Global?
 * @type boolean
 * @on Да
 * @off Нет
 * @default true
 * @desc Использовать символ для смены шрифта |fX|, где X - номер шрифта. Пример: Sword|f2|
 * 
 * @param isAutoLoad:b
 * @parent fontsToLoad:strA
 * @text Is Auto Load?
 * @type boolean
 * @on Авто
 * @off Нет
 * @default false
 * @desc [PC, MAC, LINUX] Автозагрузка шрифтов (из папки fonts). Доступность по именам.
 * 
 * @param spacer|defaultFonts @text‏‏‎ ‎@desc ===============================================
 * 
 * @param defaultSetup
 * @text Default Fonts
 * 
 * @param allItemsFont
 * @parent defaultSetup
 * @text Items
 * @default
 * @desc Имя шрифта для всех предметов в игре. Для всех стандартных окон.
 * 
 * @param allArmorsFont
 * @parent defaultSetup
 * @text Armors
 * @default
 * @desc Имя шрифта для всей брони в игре. Для всех стандартных окон.
 * 
 * @param allWeaponsFont
 * @parent defaultSetup
 * @text Weapons
 * @default
 * @desc Имя шрифта для всего оружия в игре. Для всех стандартных окон.
 * 
 * @param allSkillsFont
 * @parent defaultSetup
 * @text Skills
 * @default
 * @desc Имя шрифта для всех навыков в игре. Для всех стандартных окон.
 * 
 * @param allActorNamesFont
 * @parent defaultSetup
 * @text Actor name
 * @default
 * @desc Имя шрифта для имён персонажей в игре. Для всех стандартных окон.
 * 
 * @param allActorClassFont
 * @parent defaultSetup
 * @text Actor class
 * @default
 * @desc Имя шрифта для названия классов в игре. Для всех стандартных окон.
 * 
 * @param allActorNickFont
 * @parent defaultSetup
 * @text Actor nickname
 * @default
 * @desc Имя шрифта для псевдонимов персонажей в игре. Для всех стандартных окон.
 * 
 * @param allActorLevelFont
 * @parent defaultSetup
 * @text Actor level
 * @default
 * @desc Имя шрифта для текста уровня персонажей в игре. Для всех стандартных окон.
 * 
 * @param spacer|colors @text‏‏‎ ‎@desc ===============================================
 * 
 * @param pallete:strA
 * @type text[]
 * @text Custom pallete
 * @default []
 * @desc Цвета (HEX формат) на замену станадртных номеров \C[X]. Пример: #ba1a8f
 * 
 * @param userPalletes:structA
 * @parent pallete:strA
 * @type struct<Pallete>[]
 * @text More palletes
 * @default []
 * @desc Можно менять палитры в игре, вызов скрипта: switchColorPallete(index);
 * 
 * @param isGlobalColors:b
 * @parent pallete:strA
 * @text Is Global?
 * @type boolean
 * @on Да
 * @off Нет
 * @default true
 * @desc Разрешить смену цвета символом |cX|, где X - номер цвета. Пример: Sword|c2|
 * 
 * 
 * @param spacer|endHolder @text‏‏‎ ‎@desc ===============================================
 * 
 * @command EMPTY_HOLDER
 * @text ‏
 * @desc
 * @default
 */
/*~struct~Pallete:
* @param pallete:strA
* @type text[]
* @text Pallete
* @default []
* @desc Colors (hex) for replace \\C[X]. Availble by Index. Example: #ba1a8f
*/



var Imported = Imported || {};
Imported.PKD_FontsManager = true;

window.PKD_FTSM = {};

var PKD_FTSM = {};
PKD_FTSM.Version = 100;

//?VERSION
PKD_FTSM.isPro = function() { return false; };

// * For parameters
PKD_FTSM.PP = {};
PKD_FTSM.Utils = {};

// * Загрзука параметров
PKD_FTSM.LoadPluginSettings = () => {
    PKD_FTSM.PP._loader = new KDParamLoaderLite("PKD_FontsManager");
};

PKD_FTSM.LoadAllFonts = () => {
    try {
        let list = PKD_FTSM.PP.fontsToLoad();
        for (const i of list) {
            PKD_FTSM.Utils.loadFont(i);
        }
    } catch (e) {
        console.warn(e);
    }
};



//------------------------------------------------------------------------------
//FontLoader_NWJS

//[ENCODE]

var FontLoader_NWJS = function () {
    throw new Error('This is a static class');
};
FontLoader_NWJS.init = function () {
    var fs = require('fs');
    this._files = fs.readdirSync(this.localFileDirectoryPath());
    this._ready = false;
};

FontLoader_NWJS.isReady = function () {
    return (this._ready == true);
};

FontLoader_NWJS.loadAll = function () {
    if (FontLoader_NWJS.isReady()) return;
    for (var i = 0; i < this._files.length; i++) {
        let filename  = this._files[i];
        console.log("[Auto] Try load font file: " + filename);
        PKD_FTSM.Utils.loadFont(filename);
    }
    this._ready = true;
};

FontLoader_NWJS._localFileDirectoryPath = null;
FontLoader_NWJS.localFileDirectoryPath = function () {
    if (this._localFileDirectoryPath == null) {
        const path = require('path');
        const base = path.dirname(process.mainModule.filename);
        this._localFileDirectoryPath = path.join(base, 'fonts/');
    }
    return this._localFileDirectoryPath;
};

window.FontLoader_NWJS = FontLoader_NWJS;

//END FontLoader_NWJS
//------------------------------------------------------------------------------

/////////////////////////////////////////////////////////////////////////////
//╒═════════════════════════════════════════════════════════════════════════╛
// ■ FontManager.js
//╒═════════════════════════════════════════════════════════════════════════╛
/////////////////////////////////////////////////////////////////////////////
(function(){
    // * RPG Maker MV not have FontManager (from MZ)
    
    //[ENCODE]

    if(window.FontManager || !Utils.RPGMAKER_NAME.contains("MV")) {
        return;
    }

    function FontManager() {
        throw new Error("This is a static class");
    }

    FontManager._urls = {};
    FontManager._states = {};

    FontManager.load = function(family, filename) {
        if (this._states[family] !== "loaded") {
            if (filename) {
                const url = this.makeUrl(filename);
                this.startLoading(family, url);
            } else {
                this._urls[family] = "";
                this._states[family] = "loaded";
            }
        }
    };

    FontManager.isReady = function() {
        for (const family in this._states) {
            const state = this._states[family];
            if (state === "loading") {
                return false;
            }
            if (state === "error") {
                this.throwLoadError(family);
            }
        }
        return true;
    };

    FontManager.startLoading = function(family, url) {
        const source = "url(" + url + ")";
        const font = new FontFace(family, source);
        this._urls[family] = url;
        this._states[family] = "loading";
        font.load()
            .then(() => {
                document.fonts.add(font);
                this._states[family] = "loaded";
                return 0;
            })
            .catch(() => {
                this._states[family] = "error";
            });
    };

    FontManager.throwLoadError = function(family) {
        const url = this._urls[family];
        const retry = () => this.startLoading(family, url);
        throw ["LoadError", url, retry];
    };

    FontManager.makeUrl = function(filename) {
        return "fonts/" + Utils.encodeURI(filename);
    };

    Utils.encodeURI = function(str) {
        return encodeURIComponent(str).replace(/%2F/g, "/");
    };

    window.FontManager = FontManager;

})();
// ■ END FontManager.js
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////

// Generated by CoffeeScript 2.6.1
//╒═════════════════════════════════════════════════════════════════════════╛
// ■ Bitmap.coffee
//╒═════════════════════════════════════════════════════════════════════════╛
//---------------------------------------------------------------------------
//$[ENCODE]
(function() {
  var ALIAS__drawText_kjkcc, _;
  
  //@[DEFINES]
  _ = Bitmap.prototype;
  //@[ALIAS]
  ALIAS__drawText_kjkcc = _.drawText;
  _.drawText = function(text, x, y, maxWidth, lineHeight, align) {
    this.pBeforeGlobal();
    text = this.pCheckGlobals(text);
    ALIAS__drawText_kjkcc.call(this, text, x, y, maxWidth, lineHeight, align);
    this.pAfterGlobal();
  };
  _.pCheckGlobals = function(text) {
    var e;
    try {
      if (PKD_FTSM.legacy) {
        return text;
      }
      if (PKD_FTSM.PP.isGlobal() && PKD_FTSM.PP.isGlobalColors()) {
        text = this.pCheckGlobalPair(text);
      }
      if (PKD_FTSM.PP.isGlobal()) {
        text = this.pCheckGlobalFont(text);
      }
      if (PKD_FTSM.PP.isGlobalColors()) {
        text = this.pCheckGlobalColor(text);
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return text;
  };
  _.pBeforeGlobal = function() {
    this.__prevFont = null;
    this.__prevColor = null;
  };
  _.pAfterGlobal = function() {
    if (this.__prevFont) {
      this.fontFace = this.__prevFont;
    }
    if (this.__prevColor) {
      this.textColor = this.__prevColor;
    }
  };
  _.pCheckGlobalPair = function(text) {
    var colorIndex, fontIndex, match;
    if ((text != null) && text.toString().includes("|f") && text.toString().includes("c")) {
      match = text.match(/\|f(\d+)c(\d+)\|/);
      if (match != null) {
        fontIndex = match[1];
        colorIndex = match[2];
        text = text.replace(/\|f(\d+)c(\d+)\|/, "");
        text += "|f" + fontIndex + "|";
        text = this.pChangeFontForce(text);
        text += "|c" + colorIndex + "|";
        text = this.pChangeColorForce(text);
      }
    }
    return text;
  };
  _.pCheckGlobalFont = function(text) {
    if ((text != null) && text.toString().includes("|f")) {
      text = this.pChangeFontForce(text);
    }
    return text;
  };
  _.pChangeFontForce = function(text) {
    var e, fontData;
    try {
      this.__prevFont = this.fontFace;
      fontData = this.pGetFontName(text);
      if (fontData != null) {
        this.fontFace = fontData.face;
        text = fontData.text;
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return text;
  };
  _.pCheckGlobalColor = function(text) {
    if ((text != null) && text.toString().includes("|c")) {
      text = this.pChangeColorForce(text);
    }
    return text;
  };
  _.pChangeColorForce = function(text) {
    var colorData, e;
    try {
      this.__prevColor = this.textColor;
      colorData = this.pGetNewColorData(text);
      if (colorData != null) {
        this.textColor = colorData.color;
        text = colorData.text;
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return text;
  };
  _.pGetFontName = function(text) {
    var e, face, index;
    try {
      index = this.pExtractFontIndex(text);
      if (index > 0) {
        face = PKD_FTSM.PP.getFontNameByIndex(index);
        if (face != null) {
          text = text.replace(/\|f\d+\|/, "");
          return {face, text};
        }
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return null;
  };
  _.pGetNewColorData = function(text) {
    var color, e, index;
    try {
      index = this.pExtractColorIndex(text);
      color = PKD_FTSM.Utils.getProperColorByIndex(index);
      if (color != null) {
        text = text.replace(/\|c\d+\|/, "");
        return {color, text};
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return null;
  };
  _.pExtractColorIndex = function(text) {
    var e, index, result;
    try {
      result = text.match(/\|c(\d+)\|/);
      index = parseInt(result[1]);
      return index;
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return 0;
  };
  _.pExtractFontIndex = function(text) {
    var e, index, result;
    try {
      result = text.match(/\|f(\d+)\|/);
      index = parseInt(result[1]);
      return index;
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return 0;
  };
})();

// ■ END Bitmap.coffee
//---------------------------------------------------------------------------


// Generated by CoffeeScript 2.6.1
// * Класс аналог KDCore.ParamLoader, но упрощённый, чтобы всю библиотеку не тащить
var KDParamLoaderLite;

KDParamLoaderLite = (function() {
  class KDParamLoaderLite {
    constructor(pluginName) {
      this.pluginName = pluginName;
      this.paramsRaw = PluginManager.pParametersUnsafe(this.pluginName);
      if (!this.isLoaded()) {
        return;
      }
      this.params = this.parseParameters(this.paramsRaw);
      return;
    }

    isLoaded() {
      return this.paramsRaw != null;
    }

    parseParameters(paramSet) {
      var clearKey, key, params, typeKey, value;
      params = {};
      for (key in paramSet) {
        value = paramSet[key];
        clearKey = this.parseKey(key);
        typeKey = this.parseKeyType(key);
        params[clearKey] = this.parseParamItem(typeKey, value);
      }
      return params;
    }

    parseKey(keyRaw) {
      return keyRaw.split(":")[0];
    }

    parseKeyType(keyRaw) {
      return keyRaw.split(":")[1];
    }

    // * Имя параметра без ключа
    isHasParameter(paramName) {
      if (!this.isLoaded()) {
        return false;
      } else {
        return this.params[paramName] != null;
      }
    }

    // * Возвращает значение параметра (def - по умолчанию, если не найден)
    getParam(paramName, def) {
      var value;
      if (this.isHasParameter(paramName)) {
        value = this.params[paramName];
        if (value != null) {
          return value;
        }
      }
      return def;
    }

    parseParamItem(type, item) {
      var e;
      try {
        if (type == null) {
          return item;
        }
        switch (type) {
          case "int":
          case "i":
            return Number(item);
          case "intA":
            return this.parseArray(item, "int");
          case "bool":
          case "b":
          case "e":
            return eval(item);
          case "struct":
          case "s":
            return this.parseStruct(item);
          case "structA":
            return this.parseStructArray(item);
          case "str":
            return item;
          case "strA":
            return this.parseArray(item, "str");
          case "note":
            return this.parseNote(item);
          case "css":
            if (window.KDCore != null) {
              return item.toCss();
            } else {
              return item;
            }
            return item.toCss();
          case "color":
            if (window.KDCore != null) {
              return KDCore.Color.FromHex(item);
            } else {
              return item;
            }
            break;
          default:
            return item;
        }
      } catch (error) {
        e = error;
        console.warn(e);
        return item;
      }
    }

    parseArray(items, type) {
      var e, elements, i, len, p, parsed;
      try {
        elements = [];
        parsed = JsonEx.parse(items);
        for (i = 0, len = parsed.length; i < len; i++) {
          p = parsed[i];
          try {
            elements.push(this.parseParamItem(type, p));
          } catch (error) {
            e = error;
            console.warn(e);
          }
        }
      } catch (error) {
        e = error;
        console.warn(e);
      }
      return elements;
    }

    parseStruct(item) {
      var e, parsed;
      try {
        parsed = JsonEx.parse(item);
        if (parsed != null) {
          return this.parseParameters(parsed);
        }
      } catch (error) {
        e = error;
        console.warn(e);
      }
      return null;
    }

    parseStructArray(items) {
      var e, elements, i, len, p, parsed;
      try {
        elements = [];
        parsed = JsonEx.parse(items);
        for (i = 0, len = parsed.length; i < len; i++) {
          p = parsed[i];
          try {
            elements.push(this.parseStruct(p));
          } catch (error) {
            e = error;
            console.warn(e);
          }
        }
      } catch (error) {
        e = error;
        console.warn(e);
      }
      return elements;
    }

    parseNote(item) {
      var e, parsed;
      try {
        parsed = JsonEx.parse(item);
        if (parsed != null) {
          return parsed;
        }
      } catch (error) {
        e = error;
        console.warn(e);
      }
      return item;
    }

  };

  KDParamLoaderLite.Version = 100;

  return KDParamLoaderLite;

}).call(this);

(function() {  //╒═════════════════════════════════════════════════════════════════════════╛
  // ■ PluginManager.coffee
  //╒═════════════════════════════════════════════════════════════════════════╛
  //---------------------------------------------------------------------------
  var _;
  //@[DEFINES]
  _ = PluginManager;
  // * Не возвращает {}, а возвращает null, чтобы можно было проверить isLoaded
  _.pParametersUnsafe = function(name) {
    return this._parameters[name.toLowerCase()];
  };
})();

// ■ END PluginManager.coffee
//---------------------------------------------------------------------------


// Generated by CoffeeScript 2.6.1
//╒═════════════════════════════════════════════════════════════════════════╛
// ■ Parameters.coffee
//╒═════════════════════════════════════════════════════════════════════════╛
//---------------------------------------------------------------------------
(function() {
  var _;
  //$[ENCODE]

  //@[DEFINES]
  _ = PKD_FTSM.PP;
  _.isAutoLoad = function() {
    return Utils.isNwjs() && this._loader.getParam("isAutoLoad", false);
  };
  //?VERSION
  _.fontsToLoad = function() {
    return [];
  };
  _.isGlobal = function() {
    return this._loader.getParam("isGlobal", true);
  };
  _.allItemsFont = function() {
    return this._loader.getParam("allItemsFont", null);
  };
  _.allArmorsFont = function() {
    return this._loader.getParam("allArmorsFont", null);
  };
  _.allWeaponsFont = function() {
    return this._loader.getParam("allWeaponsFont", null);
  };
  _.allSkillsFont = function() {
    return this._loader.getParam("allSkillsFont", null);
  };
  _.allActorNamesFont = function() {
    return this._loader.getParam("allActorNamesFont", null);
  };
  _.allActorClassFont = function() {
    return this._loader.getParam("allActorClassFont", null);
  };
  _.allActorNickFont = function() {
    return this._loader.getParam("allActorNickFont", null);
  };
  _.allActorLevelFont = function() {
    return this._loader.getParam("allActorLevelFont", null);
  };
  _.colorPallete = function() {
    return this._loader.getParam("pallete", []);
  };
  //?VERSION
  _.colorPalletes = function() {
    return [];
  };
  _.isGlobalColors = function() {
    return this._loader.getParam("isGlobalColors", true);
  };
  _.getFontNameByIndex = function(index) {
    var e, item;
    try {
      if (index <= 0) {
        return null;
      }
      item = this.fontsToLoad()[index - 1];
      if (item != null) {
        return PKD_FTSM.Utils.getNameWithoutExt(item);
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return null;
  };
  _.getUserColorIndex = function(index) {
    var e, item, items;
    try {
      if (index <= 0) {
        return null;
      }
      items = this.getProperColorPallete();
      if (items == null) {
        return null;
      }
      if (items.length === 0) {
        return null;
      }
      item = items[index - 1];
      if ((item != null) && item !== "" && item.contains("#")) {
        return item;
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return null;
  };
  //?VERSION
  _.getProperColorPallete = function() {
    return this.colorPallete();
  };
})();

// ■ END Parameters.coffee
//---------------------------------------------------------------------------


// Generated by CoffeeScript 2.6.1
(function() {
  window.switchColorPallete = function(index) {
    var e;
    try {
      return $gameSystem.switchColorPallete(index);
    } catch (error) {
      e = error;
      return console.warn(e);
    }
  };
})();


// Generated by CoffeeScript 2.6.1
//╒═════════════════════════════════════════════════════════════════════════╛
// ■ Utils.coffee
//╒═════════════════════════════════════════════════════════════════════════╛
//---------------------------------------------------------------------------
(function() {
  var _;
  //$[ENCODE]

  //@[DEFINES]
  _ = PKD_FTSM.Utils;
  _.isMV = function() {
    return Utils.RPGMAKER_NAME.contains("MV");
  };
  _.getNameWithoutExt = function(filename) {
    return filename.replace(/\.[^\/.]+$/, "");
  };
  _.loadFont = function(filename) {
    var e, fontName;
    try {
      //console.log(filename)
      if (filename == null) {
        return;
      }
      if (filename === "") {
        return;
      }
      //fontExt = filename.split('.').pop()
      fontName = this.getNameWithoutExt(filename);
      return FontManager.load(fontName, filename);
    } catch (error) {
      e = error;
      return console.warn("Unable to load font file: " + filename + " " + e);
    }
  };
  _.convertGlobalAll = function(text) {
    var e;
    try {
      if (text == null) {
        return text;
      }
      if (PKD_FTSM.PP.isGlobal() && PKD_FTSM.PP.isGlobalColors()) {
        text = this.convertGlobalPair(text);
      }
      if (PKD_FTSM.PP.isGlobal()) {
        text = this.convertGlobalColors(text);
      }
      if (PKD_FTSM.PP.isGlobalColors()) {
        text = this.convertGlobalFonts(text);
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return text;
  };
  _.convertGlobalPair = function(text) {
    var e;
    try {
      //word|f1c1| to \\C[1]\\FF[1]word\\FF[0]\\C[0]
      if ((text != null) && text.includes('|f') && text.includes('c')) {
        text = text.replace(/\b([a-zA-Z0-9_]+)\b\|f(\d+)c(\d+)\|/gm, "\\C[$3]\\FF[$2]$1\\FF[0]\\C[0]");
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return text;
  };
  _.convertGlobalFonts = function(text) {
    var e;
    try {
      //word|f1| to \\FF[1]word\\FF[0]
      if ((text != null) && text.includes('|f')) {
        text = text.replace(/\b([a-zA-Z0-9_]+)\b\|f(\d+)\|/gm, "\\FF[$2]$1\\FF[0]");
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return text;
  };
  _.convertGlobalColors = function(text) {
    var e;
    try {
      //word|c1| to \\C[1]word\\C[0]
      if ((text != null) && text.includes('|c')) {
        text = text.replace(/\b([a-zA-Z0-9_]+)\b\|c(\d+)\|/gm, "\\C[$1]$2\\C[0]");
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return text;
  };
  _.getProperColorByIndex = function(index) {
    var e, px, py, skin, userColor;
    try {
      userColor = PKD_FTSM.PP.getUserColorIndex(index);
      if ((userColor != null) && userColor !== "") {
        return userColor;
      } else {
        if (this.isMV()) {
          skin = ImageManager.loadSystem("Window");
          px = 96 + (index % 8) * 12 + 6;
          py = 144 + Math.floor(index / 8) * 12 + 6;
          return skin.getPixel(px, py);
        } else {
          return ColorManager.textColor(index);
        }
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return null;
  };
})();

// ■ END Utils.coffee
//---------------------------------------------------------------------------


// Generated by CoffeeScript 2.6.1
PKD_FTSM.isPro = function() {
  return true;
};


// Generated by CoffeeScript 2.6.1
//╒═════════════════════════════════════════════════════════════════════════╛
// ■ Parameters.coffee
//╒═════════════════════════════════════════════════════════════════════════╛
//---------------------------------------------------------------------------
(function() {
  var _;
  //@[DEFINES]
  _ = PKD_FTSM.PP;
  _.fontsToLoad = function() {
    return this._loader.getParam("fontsToLoad", []);
  };
  _.getProperColorPallete = function() {
    var e, index, pallete, str;
    try {
      index = $gameSystem.pColorPalleteIndex;
      if (index > 0) {
        str = this.colorPalletes();
        pallete = str[index - 1];
        if (pallete != null) {
          return pallete.pallete;
        }
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return this.colorPallete();
  };
  _.colorPalletes = function() {
    return this._loader.getParam("userPalletes", []);
  };
})();

// ■ END Parameters.coffee
//---------------------------------------------------------------------------


// Generated by CoffeeScript 2.6.1
//╒═════════════════════════════════════════════════════════════════════════╛
// ■ Game_System.coffee
//╒═════════════════════════════════════════════════════════════════════════╛
//---------------------------------------------------------------------------
(function() {
  var _;
  //@[DEFINES]
  _ = Game_System.prototype;
  _.switchColorPallete = function(index) {
    if (index <= 0) {
      this.pColorPalleteIndex = null;
    } else {
      this.pColorPalleteIndex = index;
    }
  };
})();

// ■ END Game_System.coffee
//---------------------------------------------------------------------------


// Generated by CoffeeScript 2.6.1
//╒═════════════════════════════════════════════════════════════════════════╛
// ■ Scene_Boot.coffee
//╒═════════════════════════════════════════════════════════════════════════╛
//---------------------------------------------------------------------------
(function() {
  var ALIAS__start, _;
  //@[DEFINES]
  _ = Scene_Boot.prototype;
  //@[ALIAS]
  ALIAS__start = _.start;
  _.start = function() {
    var e;
    ALIAS__start.call(this, ...arguments);
    PKD_FTSM.LoadPluginSettings();
    if (PKD_FTSM.PP.isAutoLoad()) {
      try {
        FontLoader_NWJS.init();
        FontLoader_NWJS.loadAll();
      } catch (error) {
        e = error;
        console.warn(e);
      }
    }
    PKD_FTSM.LoadAllFonts();
  };
})();

// ■ END Scene_Boot.coffee
//---------------------------------------------------------------------------


// Generated by CoffeeScript 2.6.1
//╒═════════════════════════════════════════════════════════════════════════╛
// ■ Window_Base.coffee
//╒═════════════════════════════════════════════════════════════════════════╛
//---------------------------------------------------------------------------
(function() {
  var ALIAS__convertEscapeCharacters, ALIAS__drawItemName, ALIAS__drawTextEx, ALIAS__processColorChange, ALIAS__processEscapeCharacter, ALIAS__textColor, _;
  //@[DEFINES]
  _ = Window_Base.prototype;
  //@[ALIAS]
  ALIAS__drawTextEx = _.drawTextEx;
  _.drawTextEx = function(text, x, y) {
    PKD_FTSM.legacy = true;
    if (text != null) {
      text = PKD_FTSM.Utils.convertGlobalAll(text);
    }
    ALIAS__drawTextEx.call(this, text, x, y);
    PKD_FTSM.legacy = null;
  };
  //@[ALIAS]
  ALIAS__convertEscapeCharacters = _.convertEscapeCharacters;
  _.convertEscapeCharacters = function(text) {
    if (text != null) {
      text = PKD_FTSM.Utils.convertGlobalAll(text);
    }
    return ALIAS__convertEscapeCharacters.call(this, text);
  };
  //@[ALIAS]
  ALIAS__processEscapeCharacter = _.processEscapeCharacter;
  _.processEscapeCharacter = function(code, textState) {
    if (code === 'FF') {
      this.pApplyFontSettings(this.pObtainEscapeParamPlus(textState));
    }
    return ALIAS__processEscapeCharacter.call(this, ...arguments);
  };
  
  //@[ALIAS]
  ALIAS__drawItemName = _.drawItemName;
  _.drawItemName = function(item, x, y, width) {
    var __prevFont, e, fontName;
    try {
      fontName = this.pGetFontForItem(item);
      if (fontName !== null) {
        if (isFinite(fontName)) {
          fontName = PKD_FTSM.PP.getFontNameByIndex(parseInt(fontName));
        }
        __prevFont = this.contents.fontFace;
        this.pApplyFontByName(fontName);
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    ALIAS__drawItemName.call(this, ...arguments);
    if (fontName != null) {
      this.contents.fontFace = __prevFont;
    }
  };
  //?MZ only
  //@[ALIAS]
  ALIAS__processColorChange = _.processColorChange;
  _.processColorChange = function(colorIndex) {
    var userColor;
    userColor = PKD_FTSM.PP.getUserColorIndex(colorIndex);
    if (userColor != null) {
      this.changeTextColor(userColor);
    } else {
      ALIAS__processColorChange.call(this, colorIndex);
    }
  };
  //?MV only
  //@[ALIAS]
  ALIAS__textColor = _.textColor;
  _.textColor = function(colorIndex) {
    var userColor;
    if (colorIndex > 0) {
      userColor = PKD_FTSM.PP.getUserColorIndex(colorIndex);
      if (userColor != null) {
        return userColor;
      }
    }
    return ALIAS__textColor.call(this, ...arguments);
  };
})();

// ■ END Window_Base.coffee
//---------------------------------------------------------------------------


// Generated by CoffeeScript 2.6.1
//╒═════════════════════════════════════════════════════════════════════════╛
// ■ Window_Base.coffee
//╒═════════════════════════════════════════════════════════════════════════╛
//---------------------------------------------------------------------------
(function() {
  var _;
  //@[DEFINES]
  _ = Window_Base.prototype;
  _.pApplyFontSettings = function(fontSymbol) {
    var e, font;
    try {
      if (isFinite(fontSymbol)) {
        font = PKD_FTSM.PP.getFontNameByIndex(Number(fontSymbol));
      } else {
        font = fontSymbol;
      }
      this.pApplyFontByName(font);
    } catch (error) {
      e = error;
      console.warn(e);
      this.contents.fontFace = this.pDefaultFontFace();
    }
  };
  _.pApplyFontByName = function(font) {
    var e;
    try {
      if (!((font != null) || font === "")) {
        this.contents.fontFace = this.pDefaultFontFace();
      } else {
        this.contents.fontFace = font;
      }
    } catch (error) {
      e = error;
      console.warn(e);
      this.contents.fontFace = this.pDefaultFontFace();
    }
  };
  _.pDefaultFontFace = function() {
    if (PKD_FTSM.Utils.isMV()) {
      return this.standardFontFace();
    } else {
      return $gameSystem.mainFontFace();
    }
  };
  _.pGetFontForItem = function(item) {
    var e;
    if (item == null) {
      return null;
    }
    try {
      if ((item.meta != null) && (item.meta.FF != null)) {
        return item.meta.FF;
      } else {
        if (DataManager.isItem(item)) {
          return PKD_FTSM.PP.allItemsFont();
        } else if (DataManager.isArmor(item)) {
          return PKD_FTSM.PP.allArmorsFont();
        } else if (DataManager.isWeapon(item)) {
          return PKD_FTSM.PP.allWeaponsFont();
        } else if (DataManager.isSkill(item)) {
          return PKD_FTSM.PP.allSkillsFont();
        }
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return null;
  };
  _.pObtainEscapeParamPlus = function(textState) {
    var e, param;
    try {
      param = this.obtainEscapeParam(textState);
      if (param !== '') {
        return param;
      } else {
        return this.pObtainEscapeParamText(textState);
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return '';
  };
  _.pObtainEscapeParamText = function(textState) {
    var arr, e, regExp;
    try {
      regExp = /^\[([a-zA-Z0-9_]+)\]/;
      arr = regExp.exec(textState.text.slice(textState.index));
      if (arr != null) {
        textState.index += arr[0].length;
        return arr[1];
      } else {
        return '';
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return '';
  };
})();

// ■ END Window_Base.coffee
//---------------------------------------------------------------------------


// Generated by CoffeeScript 2.6.1
//╒═════════════════════════════════════════════════════════════════════════╛
// ■ Window_StatusBase.coffee
//╒═════════════════════════════════════════════════════════════════════════╛
//---------------------------------------------------------------------------
(function() {
  var ALIAS__drawActorClass, ALIAS__drawActorLevel, ALIAS__drawActorName, ALIAS__drawActorNickname, _;
  //@[DEFINES]
  if (PKD_FTSM.Utils.isMV()) {
    _ = Window_Base.prototype;
  } else {
    _ = Window_StatusBase.prototype;
  }
  //@[ALIAS]
  ALIAS__drawActorName = _.drawActorName;
  _.drawActorName = function(actor, x, y, width) {
    var __prevFont, fontName;
    fontName = this.pGetFontForActorState(actor, 'name');
    if (fontName !== null) {
      __prevFont = this.contents.fontFace;
      this.pApplyFontByName(fontName);
    }
    ALIAS__drawActorName.call(this, ...arguments);
    if (fontName != null) {
      this.contents.fontFace = __prevFont;
    }
  };
  
  //@[ALIAS]
  ALIAS__drawActorClass = _.drawActorClass;
  _.drawActorClass = function(actor, x, y, width) {
    var __prevFont, fontName;
    fontName = this.pGetFontForActorState(actor, 'class');
    if (fontName !== null) {
      __prevFont = this.contents.fontFace;
      this.pApplyFontByName(fontName);
    }
    ALIAS__drawActorClass.call(this, ...arguments);
    if (fontName != null) {
      this.contents.fontFace = __prevFont;
    }
  };
  
  //@[ALIAS]
  ALIAS__drawActorNickname = _.drawActorNickname;
  _.drawActorNickname = function(actor, x, y, width) {
    var __prevFont, fontName;
    fontName = this.pGetFontForActorState(actor, 'nickname');
    if (fontName !== null) {
      __prevFont = this.contents.fontFace;
      this.pApplyFontByName(fontName);
    }
    ALIAS__drawActorNickname.call(this, ...arguments);
    if (fontName != null) {
      this.contents.fontFace = __prevFont;
    }
  };
  
  //@[ALIAS]
  ALIAS__drawActorLevel = _.drawActorLevel;
  _.drawActorLevel = function(actor, x, y) {
    var __prevFont, fontName;
    fontName = this.pGetFontForActorState(actor, 'level');
    if (fontName !== null) {
      __prevFont = this.contents.fontFace;
      this.pApplyFontByName(fontName);
    }
    ALIAS__drawActorLevel.call(this, ...arguments);
    if (fontName != null) {
      this.contents.fontFace = __prevFont;
    }
  };
})();

// ■ END Window_StatusBase.coffee
//---------------------------------------------------------------------------


// Generated by CoffeeScript 2.6.1
//╒═════════════════════════════════════════════════════════════════════════╛
// ■ Window_StatusBase.coffee
//╒═════════════════════════════════════════════════════════════════════════╛
//---------------------------------------------------------------------------
(function() {
  var _;
  //@[DEFINES]
  if (PKD_FTSM.Utils.isMV()) {
    _ = Window_Base.prototype;
  } else {
    _ = Window_StatusBase.prototype;
  }
  _.pGetFontForActorState = function(actor, state) {
    var e, fontName, fontSymbol;
    try {
      fontSymbol = this.pGetFontSymbolForActorState(actor, state);
      if (fontSymbol != null) {
        if (isFinite(fontSymbol)) {
          fontName = PKD_FTSM.PP.getFontNameByIndex(parseInt(fontSymbol));
        } else {
          fontName = fontSymbol;
        }
        return fontName;
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return null;
  };
  _.pGetFontSymbolForActorState = function(actor, state) {
    var e;
    if (actor == null) {
      return null;
    }
    try {
      if (state === 'name' && (actor.actor().meta != null) && (actor.actor().meta.FF != null)) {
        return actor.actor().meta.FF;
      } else {
        switch (state) {
          case 'name':
            return PKD_FTSM.PP.allActorNamesFont();
          case 'class':
            return PKD_FTSM.PP.allActorClassFont();
          case 'nickname':
            return PKD_FTSM.PP.allActorNickFont();
          case 'level':
            return PKD_FTSM.PP.allActorLevelFont();
        }
      }
    } catch (error) {
      e = error;
      console.warn(e);
    }
    return null;
  };
})();

// ■ END Window_StatusBase.coffee
//---------------------------------------------------------------------------

//Plugin PKD_FontsManager builded by PKD PluginBuilder 2.1 - 31.08.2022