zen-flow 7.0.0 → 7.1.0

package/dist/zenflow.cjs

@@ -2,280 +2,249 @@
 
 var util = require('node:util');
 
-const isObject = (x) => typeof x === "object" && !Array.isArray(x);
+const object = (x) => x !== null && !Array.isArray(x) && typeof x === "object";
 
-const formatFloat = (n) => `${n}F`;
-const formatLiteral = (x) => `"${x}"`;
-const formatId = (id) => typeof id === "string" ? id : "null";
-const formatWeight = (id, weight) => `${id}.weight(${weight})`;
-const formatStack = (stack) => `${stack.id} * ${stack.n}`;
-const formatBonus$1 = (x) => `${x.id} % ${Math.round(x.chance * 100)}`;
-const formatList = (arr, n) => {
+const float = (n) => `${n}F`;
+const literal = (x) => `"${x}"`;
+const list = (n) => (arr) => {
   if (arr.length > n) return `
 	${arr.join(",\n	")}
 `;
   return arr.join(", ");
 };
-const formatArray = (arr, n) => `[${formatList(arr, n)}]`;
-const formatCast = (cast) => cast ? [
-  cast.id,
-  !!cast.consume
+const array = (n) => (arr) => `[${list(n)(arr)}]`;
+const id = (id2) => typeof id2 === "string" ? id2 : "null";
+const weight = (weight2) => (id2) => `${id2}.weight(${weight2})`;
+const stack = (stack2) => `${stack2.id} * ${stack2.n}`;
+const ingredient = (ingredient2) => object(ingredient2) ? stack(ingredient2) : ingredient2;
+const bonus$1 = (bonus2) => `${bonus2.id} % ${Math.round(bonus2.chance * 100)}`;
+const cast = (cast2) => cast2 ? [
+  cast2.id,
+  !!cast2.consume
 ] : [null, false];
-const formatIngredient = (ingredient) => isObject(ingredient) ? formatStack(ingredient) : ingredient;
-const formatArgs = (...args) => {
-  const list = args.filter((x) => x !== void 0).map((x) => {
-    if (Array.isArray(x)) return formatArray(x, 3);
-    if (x === null) return "null";
-    return x;
-  });
-  return formatList(list, 3);
-};
-const formatRecipeShaped = (recipe) => {
-  const r = (...arr) => {
+const shaped = (recipe2) => {
+  const f = (...arr) => {
     for (const x of arr) {
       if (typeof x === "string") return x;
     }
     return null;
   };
   const matrix = [[
-    r(recipe.square, recipe.ring, recipe.corner, recipe[1]),
-    r(recipe.square, recipe.ring, recipe.edge, recipe[2]),
-    r(recipe.ring, recipe.corner, recipe[3])
+    f(recipe2.square, recipe2.ring, recipe2.corner, recipe2[1]),
+    f(recipe2.square, recipe2.ring, recipe2.edge, recipe2[2]),
+    f(recipe2.ring, recipe2.corner, recipe2[3])
   ], [
-    r(recipe.square, recipe.ring, recipe.edge, recipe[4]),
-    r(recipe.square, recipe.center, recipe[5]),
-    r(recipe.ring, recipe.edge, recipe[6])
+    f(recipe2.square, recipe2.ring, recipe2.edge, recipe2[4]),
+    f(recipe2.square, recipe2.center, recipe2[5]),
+    f(recipe2.ring, recipe2.edge, recipe2[6])
   ], [
-    r(recipe.ring, recipe.corner, recipe[7]),
-    r(recipe.ring, recipe.edge, recipe[8]),
-    r(recipe.ring, recipe.corner, recipe[9])
+    f(recipe2.ring, recipe2.corner, recipe2[7]),
+    f(recipe2.ring, recipe2.edge, recipe2[8]),
+    f(recipe2.ring, recipe2.corner, recipe2[9])
   ]];
   if (matrix[0][2] === null && matrix[1][2] === null && matrix[2].every((x) => x === null)) {
     matrix[0].splice(-1);
     matrix[1].splice(-1);
     matrix.splice(-1);
   }
-  return formatArray(matrix.map((row) => formatArray(row.map(formatId), 3)), 2);
-};
-const createCode = (code) => `\\u00A7${code}`;
-const NAME_COLOR = {
-  black: createCode("0"),
-  darkBlue: createCode("1"),
-  darkGreen: createCode("2"),
-  darkAqua: createCode("3"),
-  darkRed: createCode("4"),
-  darkPurple: createCode("5"),
-  gold: createCode("6"),
-  gray: createCode("7"),
-  darkGray: createCode("8"),
-  blue: createCode("9"),
-  green: createCode("a"),
-  aqua: createCode("b"),
-  red: createCode("c"),
-  lightPurple: createCode("d"),
-  yellow: createCode("e"),
-  white: createCode("f")
-};
-const NAME_STYLE = {
-  obfuscated: createCode("k"),
-  bold: createCode("l"),
-  strikethrough: createCode("m"),
-  underline: createCode("n"),
-  italic: createCode("o"),
-  reset: createCode("r")
-};
-const createFormat = (type) => (tooltip) => `format.${type}(${tooltip})`;
-const TOOLTIP_COLOR = {
-  black: createFormat("black"),
-  darkBlue: createFormat("darkBlue"),
-  darkGreen: createFormat("darkGreen"),
-  darkAqua: createFormat("darkAqua"),
-  darkRed: createFormat("darkRed"),
-  darkPurple: createFormat("darkPurple"),
-  gold: createFormat("gold"),
-  gray: createFormat("gray"),
-  darkGray: createFormat("darkGray"),
-  blue: createFormat("blue"),
-  green: createFormat("green"),
-  aqua: createFormat("aqua"),
-  red: createFormat("red"),
-  lightPurple: createFormat("lightPurple"),
-  yellow: createFormat("yellow"),
-  white: createFormat("white")
-};
-const TOOLTIP_STYLE = {
-  obfuscated: createFormat("obfuscated"),
-  bold: createFormat("bold"),
-  strikethrough: createFormat("strikethrough"),
-  underline: createFormat("underline"),
-  italic: createFormat("italic")
-};
-const formatName = (...texts) => formatLiteral(texts.map((text) => {
+  return array(2)(matrix.map((row) => array(3)(row.map(id))));
+};
+const COLOR = {
+  black: "\\u00A70",
+  darkBlue: "\\u00A71",
+  darkGreen: "\\u00A72",
+  darkAqua: "\\u00A73",
+  darkRed: "\\u00A74",
+  darkPurple: "\\u00A75",
+  gold: "\\u00A76",
+  gray: "\\u00A77",
+  darkGray: "\\u00A78",
+  blue: "\\u00A79",
+  green: "\\u00A7a",
+  aqua: "\\u00A7b",
+  red: "\\u00A7c",
+  lightPurple: "\\u00A7d",
+  yellow: "\\u00A7e",
+  white: "\\u00A7f"
+};
+const STYLE = {
+  obfuscated: "\\u00A7k",
+  bold: "\\u00A7l",
+  strikethrough: "\\u00A7m",
+  underline: "\\u00A7n",
+  italic: "\\u00A7o"
+};
+const name = (...texts) => literal(texts.map((text) => {
   if (typeof text === "string") return text;
   return [
-    text.color && NAME_COLOR[text.color],
-    text.style && NAME_STYLE[text.style],
+    text.color && COLOR[text.color],
+    text.style && STYLE[text.style],
     text.text,
-    (text.color ?? text.style) && NAME_STYLE.reset
+    (text.color ?? text.style) && "\\u00A7r"
   ].filter((x) => x !== void 0).join("");
 }).join(""));
-const formatTooltip = (...tooltip) => tooltip.map((text) => {
-  if (typeof text === "string") return formatLiteral(text);
-  let out = formatLiteral(text.text);
-  if (text.style) out = TOOLTIP_STYLE[text.style](out);
-  if (text.color) out = TOOLTIP_COLOR[text.color](out);
+const tooltip = (...tooltips) => tooltips.map((tooltip2) => {
+  if (typeof tooltip2 === "string") return literal(tooltip2);
+  let out = literal(tooltip2.text);
+  if (tooltip2.style) out = `format.${tooltip2.style}(${out})`;
+  if (tooltip2.color) out = `format.${tooltip2.color}(${out})`;
   return out;
 }).join(" + ");
+const recipe = (...args) => list(3)(args.filter((x) => x !== void 0).map((x) => {
+  if (Array.isArray(x)) return array(3)(x);
+  if (x === null) return "null";
+  return x;
+}));
 
-const capitalize = (x) => `${x[0].toUpperCase()}${x.slice(1)}`;
+const capitalise = (x) => `${x[0].toUpperCase()}${x.slice(1)}`;
 
 const clamp = (min, max, n) => Math.max(min, Math.min(max, n));
 
-const addGrinder = (id, recipe) => {
-  const formatBonus = (bonus) => `${bonus.id}, ${clamp(0, 1, bonus.chance)}`;
-  const out = formatArgs(
-    formatIngredient(recipe.input),
-    formatIngredient(id),
-    Math.max(1, recipe.turns),
-    recipe.bonus && formatBonus(recipe.bonus.primary),
-    recipe.bonus?.secondary && formatBonus(recipe.bonus.secondary)
+const addGrinder = (id, recipe$1) => {
+  const bonus = (bonus2) => `${bonus2.id}, ${clamp(0, 1, bonus2.chance)}`;
+  const out = recipe(
+    ingredient(recipe$1.input),
+    ingredient(id),
+    Math.max(1, recipe$1.turns),
+    recipe$1.bonus && bonus(recipe$1.bonus.primary),
+    recipe$1.bonus?.secondary && bonus(recipe$1.bonus.secondary)
   );
   return `mods.appeng.Grinder.addRecipe(${out});`;
 };
 const removeGrinder = (id) => `mods.appeng.Grinder.removeRecipe(${id});`;
-const addInscriber = (id, recipe) => {
-  const out = formatArgs(
-    [recipe.center],
-    recipe.top,
-    recipe.bottom ?? null,
-    formatIngredient(id),
-    formatLiteral(capitalize(recipe.type))
+const addInscriber = (id, recipe$1) => {
+  const out = recipe(
+    [recipe$1.center],
+    recipe$1.top,
+    recipe$1.bottom ?? null,
+    ingredient(id),
+    literal(capitalise(recipe$1.type))
   );
   return `mods.appeng.Inscriber.addRecipe(${out});`;
 };
 const removeInscriber = (id) => `mods.appeng.Inscriber.removeRecipe(${id});`;
 
-const addCompressor = (id, recipe) => {
-  const out = formatArgs(
+const addCompressor = (id, recipe$1) => {
+  const out = recipe(
     id,
-    Math.max(1, recipe.input.n),
-    recipe.input.id,
-    recipe.exact
+    Math.max(1, recipe$1.input.n),
+    recipe$1.input.id,
+    recipe$1.exact
   );
   return `mods.avaritia.Compressor.add(${out});`;
 };
 const removeCompressor = (id) => `mods.avaritia.Compressor.remove(${id});`;
-const addExtreme = (ingredient, recipe) => {
-  const out = formatArgs(
-    formatIngredient(ingredient),
-    recipe.map((row) => formatArray(row.map(formatId), 9))
+const addExtreme = (ingredient$1, recipe$1) => {
+  const out = recipe(
+    ingredient(ingredient$1),
+    recipe$1.map((row) => array(9)(row.map(id)))
   );
   return `mods.avaritia.ExtremeCrafting.addShaped(${out});`;
 };
 const removeExtreme = (id) => `mods.avaritia.ExtremeCrafting.remove(${id});`;
 
-const createBlock = (name, recipe) => {
-  const out = formatArgs(
-    formatLiteral(name),
-    formatLiteral(recipe.id),
-    formatLiteral(recipe.material),
-    typeof recipe.texture === "string" ? formatLiteral(recipe.texture) : formatLiteral(recipe.id),
-    typeof recipe.creativeTab === "string" && formatLiteral(recipe.creativeTab),
-    typeof recipe.renderType === "number" ? recipe.renderType : 1,
-    recipe.drops,
-    recipe.unbreakable,
-    typeof recipe.hardness === "number" && formatFloat(recipe.hardness),
-    typeof recipe.lightLevel === "number" && formatFloat(recipe.lightLevel),
-    recipe.opacity
+const createBlock = (name, recipe$1) => {
+  const out = recipe(
+    literal(name),
+    literal(recipe$1.id),
+    literal(recipe$1.material),
+    typeof recipe$1.texture === "string" ? literal(recipe$1.texture) : literal(recipe$1.id),
+    typeof recipe$1.creativeTab === "string" && literal(recipe$1.creativeTab),
+    typeof recipe$1.renderType === "number" ? recipe$1.renderType : 1,
+    recipe$1.drops,
+    recipe$1.unbreakable,
+    typeof recipe$1.hardness === "number" && float(recipe$1.hardness),
+    typeof recipe$1.lightLevel === "number" && float(recipe$1.lightLevel),
+    recipe$1.opacity
   );
   return `mods.content.Block.registerBlock(${out});`;
 };
-const createItem = (name, recipe) => {
-  const out = formatArgs(
-    formatLiteral(name),
-    formatLiteral(recipe.id),
-    typeof recipe.texture === "string" ? formatLiteral(recipe.texture) : formatLiteral(recipe.id),
-    typeof recipe.creativeTab === "string" ? formatLiteral(recipe.creativeTab) : formatLiteral("misc"),
-    typeof recipe.damage === "number" ? recipe.damage : 0,
-    typeof recipe.stackSize === "number" ? recipe.stackSize : 64,
-    typeof recipe.toolType === "string" ? formatLiteral(recipe.toolType) : formatLiteral("pickaxe"),
-    typeof recipe.level === "number" ? recipe.level : 0,
-    !!recipe.is3d,
-    Array.isArray(recipe.tooltip) ? recipe.tooltip.map(formatLiteral) : []
+const createItem = (name, recipe$1) => {
+  const out = recipe(
+    literal(name),
+    literal(recipe$1.id),
+    typeof recipe$1.texture === "string" ? literal(recipe$1.texture) : literal(recipe$1.id),
+    typeof recipe$1.creativeTab === "string" ? literal(recipe$1.creativeTab) : literal("misc"),
+    typeof recipe$1.damage === "number" ? recipe$1.damage : 0,
+    typeof recipe$1.stackSize === "number" ? recipe$1.stackSize : 64,
+    typeof recipe$1.toolType === "string" ? literal(recipe$1.toolType) : literal("pickaxe"),
+    typeof recipe$1.level === "number" ? recipe$1.level : 0,
+    !!recipe$1.is3d,
+    (recipe$1.tooltip ?? []).map(literal)
   );
   return `mods.content.Item.registerItem(${out});`;
 };
-const createLiquid = (id, recipe) => {
-  const out = formatArgs(
-    formatLiteral(id),
-    recipe.density,
-    !!recipe.gaseous,
-    recipe.luminosity,
-    recipe.temperature,
-    recipe.viscosity,
-    recipe.color,
-    !!recipe.setFire,
-    typeof recipe.castingMaterial === "number" ? recipe.castingMaterial : 0,
-    typeof recipe.texture?.still === "string" ? formatLiteral(recipe.texture.still) : null,
-    typeof recipe.texture?.flowing === "string" ? formatLiteral(recipe.texture.flowing) : null
+const createLiquid = (id, recipe$1) => {
+  const out = recipe(
+    literal(id),
+    recipe$1.density,
+    !!recipe$1.gaseous,
+    recipe$1.luminosity,
+    recipe$1.temperature,
+    recipe$1.viscosity,
+    recipe$1.color,
+    !!recipe$1.setFire,
+    typeof recipe$1.castingMaterial === "number" ? recipe$1.castingMaterial : 0,
+    typeof recipe$1.texture?.still === "string" ? literal(recipe$1.texture.still) : null,
+    typeof recipe$1.texture?.flowing === "string" ? literal(recipe$1.texture.flowing) : null
   );
   return `mods.content.Fluid.registerFluid(${out});`;
 };
-const createMaterial = (material, recipe) => {
-  const out = formatArgs(
-    formatLiteral(material),
-    formatLiteral(recipe.name),
-    formatLiteral(recipe.color.name),
-    recipe.resource,
-    recipe.id,
-    recipe.level,
-    recipe.durability,
-    recipe.speed,
-    recipe.damage,
-    recipe.reinforced,
-    recipe.color.tool,
-    recipe.value,
-    recipe.modifier,
-    recipe.stonebound,
-    !!recipe.buildParts,
-    recipe.modifiers,
-    formatLiteral(recipe.tooltip),
-    recipe.arrow.mass,
-    recipe.arrow.breakChance,
-    recipe.bow.drawSpeed,
-    recipe.bow.speed,
-    Array.isArray(recipe.nativeModifiers) && formatArray([formatArray(recipe.nativeModifiers.map(formatIngredient), 2)], 1),
-    Array.isArray(recipe.nativeEnchantments) && formatLiteral(recipe.nativeEnchantments.join(" "))
+const createMaterial = (material, recipe$1) => {
+  const out = recipe(
+    literal(material),
+    literal(recipe$1.name),
+    literal(recipe$1.color.name),
+    recipe$1.resource,
+    recipe$1.id,
+    recipe$1.level,
+    recipe$1.durability,
+    recipe$1.speed,
+    recipe$1.damage,
+    recipe$1.reinforced,
+    recipe$1.color.tool,
+    recipe$1.value,
+    recipe$1.modifier,
+    recipe$1.stonebound,
+    !!recipe$1.buildParts,
+    recipe$1.modifiers,
+    literal(recipe$1.tooltip),
+    recipe$1.arrow.mass,
+    recipe$1.arrow.breakChance,
+    recipe$1.bow.drawSpeed,
+    recipe$1.bow.speed,
+    Array.isArray(recipe$1.nativeModifiers) && array(1)([array(2)(recipe$1.nativeModifiers.map(ingredient))]),
+    Array.isArray(recipe$1.nativeEnchantments) && literal(recipe$1.nativeEnchantments.join(" "))
   );
   return `mods.content.Material.registerMaterial(${out});`;
 };
 
-const addComposter = (id, recipe) => {
-  const out = formatArgs(
+const addComposter = (id, recipe$1) => {
+  const out = recipe(
     id,
-    clamp(0, 1, recipe.n),
-    typeof recipe.color === "string" && formatLiteral(recipe.color)
+    clamp(0, 1, recipe$1.n),
+    typeof recipe$1.color === "string" && literal(recipe$1.color)
   );
   return `mods.exnihilo.Composting.addRecipe(${out});`;
 };
 const removeComposter = (id) => `mods.exnihilo.Composting.removeRecipe(${id});`;
 const addCrucible = (liquid, id) => {
-  const out = formatArgs(id, formatStack(liquid));
+  const out = recipe(id, stack(liquid));
   return `mods.exnihilo.Crucible.addRecipe(${out});`;
 };
 const removeCrucible = (id) => `mods.exnihilo.Crucible.removeRecipe(${id});`;
 const addCrucibleFuel = (id, n) => {
-  const out = formatArgs(id, clamp(0, 1, n));
+  const out = recipe(id, n);
   return `mods.exnihilo.Crucible.addHeatSource(${out});`;
 };
 const removeCrucibleFuel = (id) => `mods.exnihilo.Crucible.removeHeatSource(${id});`;
-const addHammer = (id, recipe) => {
-  const items = Object.entries(recipe).map((entry) => ({
+const addHammer = (id, recipe$1) => {
+  const items = Object.entries(recipe$1).map((entry) => ({
     id: entry[0],
-    chance: clamp(0, 1, isObject(entry[1]) ? entry[1].n : entry[1]),
-    modifier: isObject(entry[1]) ? entry[1].modifier : 1
+    chance: object(entry[1]) ? entry[1].n : entry[1],
+    modifier: object(entry[1]) ? entry[1].modifier : 1
   })).flat();
-  const out = formatArgs(
+  const out = recipe(
     id,
     items.map((item) => item.id),
     items.map((item) => item.chance),
@@ -284,155 +253,155 @@ const addHammer = (id, recipe) => {
   return `mods.exnihilo.Hammer.addRecipe(${out});`;
 };
 const removeHammer = (id) => `mods.exnihilo.Hammer.removeRecipe(${id});`;
-const addSieve = (id, recipe) => {
-  const items = Object.entries(recipe).map((entry) => Array.from({ length: Math.ceil(entry[1]) }).map((_, i) => ({
+const addSieve = (id, recipe$1) => {
+  const items = Object.entries(recipe$1).map((entry) => Array.from({ length: Math.ceil(entry[1]) }).map((_, i) => ({
     id: entry[0],
     chance: entry[1] - i < 1 ? Math.round(1 / (entry[1] - i)) : 1
   }))).flat();
-  const out = formatArgs(
+  const out = recipe(
     id,
     items.map((item) => item.id),
-    formatArray(items.map((item) => item.chance), 9)
+    array(9)(items.map((item) => item.chance))
   );
   return `mods.exnihilo.Sieve.addRecipe(${out});`;
 };
 const removeSieve = (id) => `mods.exnihilo.Sieve.removeRecipe(${id});`;
 
-const addQED = (ingredient, recipe) => {
-  const out = formatArgs(
-    formatIngredient(ingredient),
-    formatRecipeShaped(recipe)
+const addQED = (ingredient$1, recipe$1) => {
+  const out = recipe(
+    ingredient(ingredient$1),
+    shaped(recipe$1)
   );
   return `mods.extraUtils.QED.addShapedRecipe(${out});`;
 };
 const removeQED = (id) => `mods.extraUtils.QED.removeRecipe(${id});`;
 
-const addCarpenter = (id, recipe) => {
-  const out = formatArgs(
-    formatIngredient(id),
-    formatRecipeShaped(recipe.recipe),
-    recipe.liquid && formatStack(recipe.liquid),
-    Math.max(1, Math.round(recipe.ticks)),
-    recipe.top
+const addCarpenter = (id, recipe$1) => {
+  const out = recipe(
+    ingredient(id),
+    shaped(recipe$1.recipe),
+    recipe$1.liquid && stack(recipe$1.liquid),
+    Math.max(1, Math.round(recipe$1.ticks)),
+    recipe$1.top
   );
   return `mods.forestry.Carpenter.addRecipe(${out});`;
 };
-const removeCarpenter = (id, liquid) => `mods.forestry.Carpenter.removeRecipe(${formatArgs(id, liquid)});`;
-const addCentrifuge = (id, recipe) => {
-  const out = formatArgs(
-    Object.entries(recipe.out).map(([id2, chance]) => formatBonus$1({ id: id2, chance })),
+const removeCarpenter = (id, liquid) => `mods.forestry.Carpenter.removeRecipe(${recipe(id, liquid)});`;
+const addCentrifuge = (id, recipe$1) => {
+  const out = recipe(
+    Object.entries(recipe$1.out).map(([id2, chance]) => bonus$1({ id: id2, chance })),
     id,
-    recipe.ticks
+    recipe$1.ticks
   );
   return `mods.forestry.Centrifuge.addRecipe(${out});`;
 };
 const removeCentrifuge = (id) => `mods.forestry.Centrifuge.removeRecipe(${id});`;
-const addFermenter = (liquid, recipe) => {
-  const out = formatArgs(
+const addFermenter = (liquid, recipe$1) => {
+  const out = recipe(
     liquid.id,
-    recipe.catalyst,
-    recipe.liquid.id,
-    recipe.liquid.n,
-    liquid.n / recipe.liquid.n
+    recipe$1.catalyst,
+    recipe$1.liquid.id,
+    recipe$1.liquid.n,
+    liquid.n / recipe$1.liquid.n
   );
   return `mods.forestry.Fermenter.addRecipe(${out});`;
 };
 const removeFermenter = (id) => `mods.forestry.Fermenter.removeRecipe(${id});`;
-const addFermenterFuel = (id, recipe) => {
-  const out = formatArgs(
+const addFermenterFuel = (id, recipe$1) => {
+  const out = recipe(
     id,
-    recipe.cycles,
-    recipe.burn
+    recipe$1.cycles,
+    recipe$1.burn
   );
   return `mods.forestry.Fermenter.addFuel(${out});`;
 };
 const removeFermenterFuel = (id) => `mods.forestry.Fermenter.removeFuel(${id});`;
-const addMoistener = (id, recipe) => {
-  const out = formatArgs(
+const addMoistener = (id, recipe$1) => {
+  const out = recipe(
     id,
-    recipe.input,
-    recipe.ticks
+    recipe$1.input,
+    recipe$1.ticks
   );
   return `mods.forestry.Moistener.addRecipe(${out});`;
 };
 const removeMoistener = (id) => `mods.forestry.Moistener.removeRecipe(${id});`;
-const addSqueezer = (liquid, recipe) => {
-  const out = formatArgs(
-    formatStack(liquid),
-    formatBonus$1(recipe.bonus),
-    recipe.input.map(formatIngredient),
-    recipe.ticks
+const addSqueezer = (liquid, recipe$1) => {
+  const out = recipe(
+    stack(liquid),
+    bonus$1(recipe$1.bonus),
+    recipe$1.input.map(ingredient),
+    recipe$1.ticks
   );
   return `mods.forestry.Squeezer.addRecipe(${out});`;
 };
-const removeSqueezer = (id, recipe) => `mods.forestry.Squeezer.removeRecipe(${formatArgs(id, recipe)});`;
-const addStill = (liquid, recipe) => {
-  const out = formatArgs(
-    formatStack(liquid),
-    formatStack(recipe.liquid),
-    recipe.ticks
+const removeSqueezer = (id, recipe$1) => `mods.forestry.Squeezer.removeRecipe(${recipe(id, recipe$1)});`;
+const addStill = (liquid, recipe$1) => {
+  const out = recipe(
+    stack(liquid),
+    stack(recipe$1.liquid),
+    recipe$1.ticks
   );
   return `mods.forestry.Still.addRecipe(${out});`;
 };
-const removeStill = (liquid, recipe) => `mods.forestry.Still.removeRecipe(${formatArgs(liquid, recipe)});`;
-const addFabricator = (id, recipe) => {
-  const out = formatArgs(
+const removeStill = (liquid, recipe$1) => `mods.forestry.Still.removeRecipe(${recipe(liquid, recipe$1)});`;
+const addFabricator = (id, recipe$1) => {
+  const out = recipe(
     id,
-    formatRecipeShaped(recipe.recipe),
-    recipe.n,
-    recipe.cast
+    shaped(recipe$1.recipe),
+    recipe$1.n,
+    recipe$1.cast
   );
   return `mods.forestry.ThermionicFabricator.addCast(${out});`;
 };
 const removeFabricator = (id) => `mods.forestry.ThermionicFabricator.removeCast(${id});`;
-const addFabricatorGlass = (id, recipe) => {
-  const out = formatArgs(
-    recipe.n,
+const addFabricatorGlass = (id, recipe$1) => {
+  const out = recipe(
+    recipe$1.n,
     id,
-    recipe.temp
+    recipe$1.temp
   );
   return `mods.forestry.ThermionicFabricator.addSmelting(${out});`;
 };
 const removeFabricatorGlass = (id) => `mods.forestry.ThermionicFabricator.removeSmelting(${id});`;
 
-const addChestLoot = (id, recipe) => {
-  const out = formatArgs(
-    formatLiteral(recipe.chest),
+const addChestLoot = (id, recipe$1) => {
+  const out = recipe(
+    literal(recipe$1.chest),
     id,
-    recipe.chance,
-    recipe.n
+    recipe$1.chance,
+    recipe$1.n
   );
   return `vanilla.loot.addChestLoot(${out});`;
 };
-const removeChestLoot = (id, chest) => `vanilla.loot.removeChestLoot(${formatArgs(formatLiteral(chest), id)});`;
+const removeChestLoot = (id, chest) => `vanilla.loot.removeChestLoot(${recipe(literal(chest), id)});`;
 const addSeed = (id) => `vanilla.seeds.addSeed(${id});`;
 const removeSeed = (id) => `vanilla.seeds.removeSeed(${id});`;
 
-const addShaped = (item, recipe) => {
-  const out = formatArgs(
-    formatIngredient(item),
-    formatRecipeShaped(recipe)
+const addShaped = (item, recipe$1) => {
+  const out = recipe(
+    ingredient(item),
+    shaped(recipe$1)
   );
   return `recipes.addShaped(${out});`;
 };
-const removeShaped = (id, recipe) => {
-  const out = formatArgs(
+const removeShaped = (id, recipe$1) => {
+  const out = recipe(
     id,
-    recipe && formatRecipeShaped(recipe)
+    recipe$1 && shaped(recipe$1)
   );
   return `recipes.removeShaped(${out});`;
 };
-const addShapeless = (item, recipe) => {
-  const out = formatArgs(
-    formatIngredient(item),
-    formatArray(recipe, 3)
+const addShapeless = (item, recipe$1) => {
+  const out = recipe(
+    ingredient(item),
+    array(3)(recipe$1)
   );
   return `recipes.addShapeless(${out});`;
 };
-const removeShapeless = (id, recipe) => {
-  const out = formatArgs(
+const removeShapeless = (id, recipe$1) => {
+  const out = recipe(
     id,
-    recipe && formatArray(recipe, 3)
+    recipe$1 && array(3)(recipe$1)
   );
   return `recipes.removeShapeless(${out});`;
 };
@@ -441,23 +410,23 @@ const add = (item, recipe) => {
   return addShaped(item, recipe);
 };
 const remove = (id) => `recipes.remove(${id});`;
-const addMirror = (item, recipe) => {
-  const out = formatArgs(
-    formatIngredient(item),
-    formatRecipeShaped(recipe)
+const addMirror = (item, recipe$1) => {
+  const out = recipe(
+    ingredient(item),
+    shaped(recipe$1)
   );
   return `recipes.addShapedMirrored(${out});`;
 };
-const addFurnace = (id, recipe) => `furnace.addRecipe(${formatArgs(id, recipe.input, recipe.xp)});`;
-const removeFurnace = (id, recipe) => {
-  if (typeof recipe === "string") return `furnace.remove(${formatArgs(id, recipe)});`;
-  return `furnace.remove(${formatArgs(id)});`;
+const addFurnace = (id, recipe$1) => `furnace.addRecipe(${recipe(id, recipe$1.input, recipe$1.xp)});`;
+const removeFurnace = (id, recipe$1) => {
+  if (typeof recipe$1 === "string") return `furnace.remove(${recipe(id, recipe$1)});`;
+  return `furnace.remove(${recipe(id)});`;
 };
-const addFurnaceFuel = (id, n) => `furnace.setFuel(${formatArgs(id, n)});`;
+const addFurnaceFuel = (id, n) => `furnace.setFuel(${recipe(id, n)});`;
 const removeFurnaceFuel = (id) => addFurnaceFuel(id, 0);
 
-const addBlacklistAutospawner = (id) => `mods.mfr.AutoSpawner.addBlacklist(${formatLiteral(id)});`;
-const removeBlacklistAutospawner = (id) => `mods.mfr.AutoSpawner.removeBlacklist(${formatLiteral(id)});`;
+const addBlacklistAutospawner = (id) => `mods.mfr.AutoSpawner.addBlacklist(${literal(id)});`;
+const removeBlacklistAutospawner = (id) => `mods.mfr.AutoSpawner.removeBlacklist(${literal(id)});`;
 const HARVESTER_TYPE = {
   tree: "tree",
   leaf: "treeLeaf",
@@ -465,23 +434,23 @@ const HARVESTER_TYPE = {
   column: "column",
   treeInverse: "treeFlipped"
 };
-const addHarvester = (id, recipe) => {
-  const out = formatArgs(
+const addHarvester = (id, recipe$1) => {
+  const out = recipe(
     id,
-    recipe.bonus && formatArray(recipe.bonus.map((x) => {
+    recipe$1.bonus && array(3)(recipe$1.bonus.map((x) => {
       if (typeof x === "string") return x;
-      if ("n" in x) return formatStack(x);
-      return formatBonus$1(x);
-    }), 3),
-    formatLiteral(HARVESTER_TYPE[recipe.type])
+      if ("n" in x) return stack(x);
+      return bonus$1(x);
+    })),
+    literal(HARVESTER_TYPE[recipe$1.type])
   );
   return `mods.mfr.Harvester.addHarvestable(${out});`;
 };
-const addLaserOre = (id, weight) => {
-  const out = formatArgs(formatWeight(id, weight));
+const addLaserOre = (id, weight$1) => {
+  const out = recipe(weight(weight$1)(id));
   return `mods.mfr.MiningLaser.addOre(${out});`;
 };
-const removeLaserOre = (id) => `mods.mfr.MiningLaser.removeOre(${formatArgs(id)});`;
+const removeLaserOre = (id) => `mods.mfr.MiningLaser.removeOre(${recipe(id)});`;
 const FOCI = {
   white: 0,
   orange: 1,
@@ -500,31 +469,31 @@ const FOCI = {
   red: 14,
   black: 15
 };
-const addLaserFoci = (id, foci) => `mods.mfr.MiningLaser.addPreferredOre(${formatArgs(FOCI[foci], id)});`;
-const removeLaserFoci = (id, foci) => `mods.mfr.MiningLaser.removePreferredOre(${formatArgs(FOCI[foci], id)});`;
+const addLaserFoci = (id, foci) => `mods.mfr.MiningLaser.addPreferredOre(${recipe(FOCI[foci], id)});`;
+const removeLaserFoci = (id, foci) => `mods.mfr.MiningLaser.removePreferredOre(${recipe(FOCI[foci], id)});`;
 const addLaser = (id, recipe) => [
   addLaserOre(id, recipe.weight),
   addLaserFoci(id, recipe.foci)
 ].join("\n");
 const addPlanter = (id) => `mods.mfr.Planter.addPlantable(${id});`;
-const addBiomeRubberTree = (id) => `mods.mfr.RubberTree.addBiome(${formatArgs(formatLiteral(id))});`;
-const removeBiomeRubberTree = (id) => `mods.mfr.RubberTree.removeBiome(${formatArgs(formatLiteral(id))});`;
-const addSludgeBoiler = (id, weight) => {
-  const out = formatArgs(formatWeight(id, weight));
+const addBiomeRubberTree = (id) => `mods.mfr.RubberTree.addBiome(${recipe(literal(id))});`;
+const removeBiomeRubberTree = (id) => `mods.mfr.RubberTree.removeBiome(${recipe(literal(id))});`;
+const addSludgeBoiler = (id, weight$1) => {
+  const out = recipe(weight(weight$1)(id));
   return `mods.mfr.SludgeBoiler.addDrop(${out});`;
 };
-const removeSludgeBoiler = (id) => `mods.mfr.SludgeBoiler.removeDrop(${formatArgs(id)});`;
+const removeSludgeBoiler = (id) => `mods.mfr.SludgeBoiler.removeDrop(${recipe(id)});`;
 
 const hide = (id) => `mods.nei.NEI.hide(${id});`;
 const show = (id) => `mods.nei.NEI.addEntry(${id});`;
-const rename = (id, name) => `mods.nei.NEI.overrideName(${formatArgs(id, formatLiteral(name))});`;
+const rename = (id, name) => `mods.nei.NEI.overrideName(${recipe(id, literal(name))});`;
 
 const addOreDict = (dict) => (id) => `${dict}.add(${id});`;
 const removeOreDict = (dict) => (id) => `${dict}.remove(${id});`;
 const joinOreDict = (a, b) => `${a}.addAll(${b});`;
 const mirrorOreDict = (a, b) => `${a}.mirror(${b});`;
 
-const withName = (name) => (id) => `${id}.displayName = ${formatName(name)};`;
+const withName = (name$1) => (id) => `${id}.displayName = ${name(name$1)};`;
 const withTag = (tag) => (id) => {
   return `${id}.withTag(${util.inspect(tag).replace(/(:\s?)'([^']+)'/gm, '$1"$2"')})`;
 };
@@ -553,119 +522,119 @@ const ENCHANTMENTS = {
   infinity: 51
 };
 const withEnchantment = (...enchantments) => withTag({ ench: enchantments });
-const withTooltip = (...tooltip) => (id) => `${id}.addTooltip(${formatTooltip(...tooltip)});`;
-const withTooltipShift = (...tooltip) => (id) => `${id}.addShiftTooltip(${formatTooltip(...tooltip)});`;
+const withTooltip = (...tooltip$1) => (id) => `${id}.addTooltip(${tooltip(...tooltip$1)});`;
+const withTooltipShift = (...tooltip$1) => (id) => `${id}.addShiftTooltip(${tooltip(...tooltip$1)});`;
 
-const formatBonus = (bonus) => bonus ? [
-  bonus.id,
-  Math.round(bonus.chance * 100)
+const bonus = (bonus2) => bonus2 ? [
+  bonus2.id,
+  Math.round(bonus2.chance * 100)
 ] : [];
-const addMagmaCrucible = (liquid, recipe) => {
-  const out = formatArgs(
-    recipe.rf,
-    recipe.input,
-    formatStack(liquid)
+const addMagmaCrucible = (liquid, recipe$1) => {
+  const out = recipe(
+    recipe$1.rf,
+    recipe$1.input,
+    stack(liquid)
   );
   return `mods.thermalexpansion.Crucible.addRecipe(${out});`;
 };
 const removeMagmaCrucible = (id) => `mods.thermalexpansion.Crucible.removeRecipe(${id});`;
-const addRedstoneFurnace = (item, recipe) => {
-  const out = formatArgs(
-    recipe.rf,
-    recipe.input,
-    formatIngredient(item)
+const addRedstoneFurnace = (item, recipe$1) => {
+  const out = recipe(
+    recipe$1.rf,
+    recipe$1.input,
+    ingredient(item)
   );
   return `mods.thermalexpansion.Furnace.addRecipe(${out});`;
 };
 const removeRedstoneFurnace = (id) => `mods.thermalexpansion.Furnace.removeRecipe(${id});`;
-const addInsolator = (item, recipe) => {
-  const out = formatArgs(
-    recipe.rf,
-    formatIngredient(recipe.input.left),
-    formatIngredient(recipe.input.right),
-    formatIngredient(item),
-    ...formatBonus(recipe.bonus)
+const addInsolator = (item, recipe$1) => {
+  const out = recipe(
+    recipe$1.rf,
+    ingredient(recipe$1.input.left),
+    ingredient(recipe$1.input.right),
+    ingredient(item),
+    ...bonus(recipe$1.bonus)
   );
   return `mods.thermalexpansion.Insolator.addRecipe(${out});`;
 };
-const removeInsolator = (input) => `mods.thermalexpansion.Insolator.removeRecipe(${formatArgs(input.left, input.right)});`;
-const addPulverizer = (item, recipe) => {
-  const out = formatArgs(
-    recipe.rf,
-    recipe.input,
-    formatIngredient(item),
-    ...formatBonus(recipe.bonus)
+const removeInsolator = (input) => `mods.thermalexpansion.Insolator.removeRecipe(${recipe(input.left, input.right)});`;
+const addPulverizer = (item, recipe$1) => {
+  const out = recipe(
+    recipe$1.rf,
+    recipe$1.input,
+    ingredient(item),
+    ...bonus(recipe$1.bonus)
   );
   return `mods.thermalexpansion.Pulverizer.addRecipe(${out});`;
 };
 const removePulverizer = (id) => `mods.thermalexpansion.Pulverizer.removeRecipe(${id});`;
-const addSawmill = (item, recipe) => {
-  const out = formatArgs(
-    recipe.rf,
-    recipe.input,
-    formatIngredient(item),
-    ...formatBonus(recipe.bonus)
+const addSawmill = (item, recipe$1) => {
+  const out = recipe(
+    recipe$1.rf,
+    recipe$1.input,
+    ingredient(item),
+    ...bonus(recipe$1.bonus)
   );
   return `mods.thermalexpansion.Sawmill.addRecipe(${out});`;
 };
 const removeSawmill = (id) => `mods.thermalexpansion.Sawmill.removeRecipe(${id});`;
-const addInductionSmelter = (item, recipe) => {
-  const out = formatArgs(
-    recipe.rf,
-    formatIngredient(recipe.input[1]),
-    formatIngredient(recipe.input[0]),
-    formatIngredient(item),
-    ...formatBonus(recipe.bonus)
+const addInductionSmelter = (item, recipe$1) => {
+  const out = recipe(
+    recipe$1.rf,
+    ingredient(recipe$1.input[1]),
+    ingredient(recipe$1.input[0]),
+    ingredient(item),
+    ...bonus(recipe$1.bonus)
   );
   return `mods.thermalexpansion.Smelter.addRecipe(${out});`;
 };
-const removeInductionSmelter = (input) => `mods.thermalexpansion.Smelter.removeRecipe(${formatArgs(input.left, input.right)});`;
-const addTransposerFill = (item, recipe) => {
-  const out = formatArgs(
-    recipe.rf,
-    recipe.input,
-    formatIngredient(item),
-    formatStack(recipe.liquid)
+const removeInductionSmelter = (input) => `mods.thermalexpansion.Smelter.removeRecipe(${recipe(input.left, input.right)});`;
+const addTransposerFill = (item, recipe$1) => {
+  const out = recipe(
+    recipe$1.rf,
+    recipe$1.input,
+    ingredient(item),
+    stack(recipe$1.liquid)
   );
   return `mods.thermalexpansion.Transposer.addFillRecipe(${out});`;
 };
-const removeTransposerFill = (input) => `mods.thermalexpansion.Transposer.removeFillRecipe(${formatArgs(input.id, input.liquid)});`;
-const addTransposerExtract = (liquid, recipe) => {
-  const out = formatArgs(
-    recipe.rf,
-    recipe.input,
-    formatStack(liquid),
-    ...formatBonus(recipe.bonus)
+const removeTransposerFill = (input) => `mods.thermalexpansion.Transposer.removeFillRecipe(${recipe(input.id, input.liquid)});`;
+const addTransposerExtract = (liquid, recipe$1) => {
+  const out = recipe(
+    recipe$1.rf,
+    recipe$1.input,
+    stack(liquid),
+    ...bonus(recipe$1.bonus)
   );
   return `mods.thermalexpansion.Transposer.addExtractRecipe(${out});`;
 };
 const removeTransposerExtract = (id) => `mods.thermalexpansion.Transposer.removeExtractRecipe(${id});`;
 
-const addCastingBasin = (id, recipe) => {
-  const out = formatArgs(
+const addCastingBasin = (id, recipe$1) => {
+  const out = recipe(
     id,
-    formatStack(recipe.liquid),
-    ...formatCast(recipe.cast),
-    recipe.ticks
+    stack(recipe$1.liquid),
+    ...cast(recipe$1.cast),
+    recipe$1.ticks
   );
   return `mods.tconstruct.Casting.addBasinRecipe(${out});`;
 };
 const removeCastingBasin = (id) => `mods.tconstruct.Casting.removeBasinRecipe(${id});`;
-const addCastingTable = (id, recipe) => {
-  const out = formatArgs(
+const addCastingTable = (id, recipe$1) => {
+  const out = recipe(
     id,
-    formatStack(recipe.liquid),
-    ...formatCast(recipe.cast),
-    recipe.ticks
+    stack(recipe$1.liquid),
+    ...cast(recipe$1.cast),
+    recipe$1.ticks
   );
   return `mods.tconstruct.Casting.addTableRecipe(${out});`;
 };
 const removeCastingTable = (id) => `mods.tconstruct.Casting.removeTableRecipe(${id});`;
-const addDryingRack = (id, recipe) => {
-  const out = formatArgs(
-    recipe.input,
+const addDryingRack = (id, recipe$1) => {
+  const out = recipe(
+    recipe$1.input,
     id,
-    recipe.ticks
+    recipe$1.ticks
   );
   return `mods.tconstruct.Drying.addRecipe(${out});`;
 };
@@ -689,30 +658,30 @@ const MODIFIERS = {
   baneOfAnthropods: "ModAntiSpider",
   flux: "Flux"
 };
-const removeModifier = (id) => `mods.tconstruct.Modifiers.remove(${formatLiteral(id)});`;
-const addSmelteryFluid = (liquid, recipe) => {
-  const out = formatArgs(
-    recipe.input,
-    formatStack(liquid),
-    recipe.temperature,
-    recipe.render
+const removeModifier = (id) => `mods.tconstruct.Modifiers.remove(${literal(id)});`;
+const addSmelteryFluid = (liquid, recipe$1) => {
+  const out = recipe(
+    recipe$1.input,
+    stack(liquid),
+    recipe$1.temperature,
+    recipe$1.render
   );
   return `mods.tconstruct.Smeltery.addMelting(${out});`;
 };
 const removeSmelteryFluid = (id) => `mods.tconstruct.Smeltery.removeMelting(${id});`;
-const addSmelteryAlloy = (alloy, recipe) => {
-  const out = formatArgs(
-    formatStack(alloy),
-    recipe.map(formatStack)
+const addSmelteryAlloy = (alloy, recipe$1) => {
+  const out = recipe(
+    stack(alloy),
+    recipe$1.map(stack)
   );
   return `mods.tconstruct.Smeltery.addAlloy(${out});`;
 };
 const removeSmelteryAlloy = (id) => `mods.tconstruct.Smeltery.removeAlloy(${id});`;
-const addSmelteryFuel = (id, recipe) => {
-  const out = formatArgs(
+const addSmelteryFuel = (id, recipe$1) => {
+  const out = recipe(
     id,
-    recipe.temperature,
-    recipe.ticks
+    recipe$1.temperature,
+    recipe$1.ticks
   );
   return `mods.tconstruct.Smeltery.addFuel(${out});`;
 };
@@ -747,137 +716,141 @@ const MATERIALS = {
   bedrock: "Bedrockium",
   unstable: "Unstable Induced"
 };
-const addRepairMaterial = (id, recipe) => {
-  const out = formatArgs(
+const addRepairMaterial = (id, recipe$1) => {
+  const out = recipe(
     id,
-    formatLiteral(recipe.material),
-    recipe.n
+    literal(recipe$1.material),
+    recipe$1.n
   );
   return `mods.tconstruct.Tweaks.addRepairMaterial(${out});`;
 };
 const removeRepairMaterial = (id, material) => {
-  const out = formatArgs(
+  const out = recipe(
     id,
-    typeof material === "string" && formatLiteral(material)
+    typeof material === "string" && literal(material)
   );
   return `mods.tconstruct.Tweaks.removeRepairMaterial(${out});`;
 };
-const setMaterialStats = (material, recipe) => {
-  const out = formatArgs(
-    formatLiteral(material),
-    formatLiteral(recipe.name),
-    recipe.level,
-    recipe.durability,
-    recipe.speed * 100,
-    recipe.damage,
-    recipe.modifier,
-    typeof recipe.reinforced === "number" ? recipe.reinforced : 0,
-    typeof recipe.stonebound === "number" ? recipe.stonebound : 0,
-    formatLiteral(recipe.color.name),
-    recipe.color.tool
+const setMaterialStats = (material, recipe$1) => {
+  const out = recipe(
+    literal(material),
+    literal(recipe$1.name),
+    recipe$1.level,
+    recipe$1.durability,
+    recipe$1.speed * 100,
+    recipe$1.damage,
+    recipe$1.modifier,
+    typeof recipe$1.reinforced === "number" ? recipe$1.reinforced : 0,
+    typeof recipe$1.stonebound === "number" ? recipe$1.stonebound : 0,
+    literal(recipe$1.color.name),
+    recipe$1.color.tool
   );
   return `mods.tconstruct.ToolStats.setStats(${out});`;
 };
 const setMaterialName = (material, name) => {
-  const out = formatArgs(
-    formatLiteral(material),
-    formatLiteral(name)
+  const out = recipe(
+    literal(material),
+    literal(name)
   );
   return `mods.tconstruct.ToolStats.setDisplayName(${out});`;
 };
 const setMaterialMiningLevel = (material, n) => {
-  const out = formatArgs(formatLiteral(material), n);
+  const out = recipe(literal(material), n);
   return `mods.tconstruct.ToolStats.setHarvestLevel(${out});`;
 };
 const setMaterialDurability = (material, n) => {
-  const out = formatArgs(formatLiteral(material), n);
+  const out = recipe(literal(material), n);
   return `mods.tconstruct.ToolStats.setDurability(${out});`;
 };
 const setMaterialSpeed = (material, n) => {
-  const out = formatArgs(formatLiteral(material), n * 100);
+  const out = recipe(literal(material), n * 100);
   return `mods.tconstruct.ToolStats.setSpeed(${out});`;
 };
 const setMaterialDamage = (material, n) => {
-  const out = formatArgs(formatLiteral(material), n);
+  const out = recipe(literal(material), n);
   return `mods.tconstruct.ToolStats.setDamage(${out});`;
 };
 const setMaterialHandleModifier = (material, n) => {
-  const out = formatArgs(formatLiteral(material), n);
+  const out = recipe(literal(material), n);
   return `mods.tconstruct.ToolStats.setHandleModifier(${out});`;
 };
 const setMaterialReinforcedLevel = (material, n) => {
-  const out = formatArgs(formatLiteral(material), n);
+  const out = recipe(literal(material), n);
   return `mods.tconstruct.ToolStats.setReinforcedLevel(${out});`;
 };
 const setMaterialLevelStonebound = (material, n) => {
-  const out = formatArgs(formatLiteral(material), n);
+  const out = recipe(literal(material), n);
   return `mods.tconstruct.ToolStats.setStoneboundLevel(${out});`;
 };
 const setMaterialStyle = (material, style) => {
-  const out = formatArgs(
-    formatLiteral(material),
-    formatLiteral(style)
+  const out = recipe(
+    literal(material),
+    literal(style)
   );
   return `mods.tconstruct.ToolStats.setStyle(${out});`;
 };
-const setBowMaterialStats = (material, recipe) => {
-  const out = formatArgs(
-    formatLiteral(material),
-    recipe.durability,
-    recipe.drawSpeed,
-    formatFloat(recipe.flightSpeed)
+const setBowMaterialStats = (material, recipe$1) => {
+  const out = recipe(
+    literal(material),
+    recipe$1.durability,
+    recipe$1.drawSpeed,
+    float(recipe$1.flightSpeed)
   );
   return `mods.tconstruct.ToolStats.setBowStats(${out});`;
 };
 const setBowMaterialDurability = (material, durability) => {
-  const out = formatArgs(formatLiteral(material), durability);
+  const out = recipe(literal(material), durability);
   return `mods.tconstruct.ToolStats.setBowDurability(${out});`;
 };
 const setBowMaterialDrawspeed = (material, drawspeed) => {
-  const out = formatArgs(formatLiteral(material), drawspeed);
+  const out = recipe(literal(material), drawspeed);
   return `mods.tconstruct.ToolStats.setBowDrawspeed(${out});`;
 };
 const setBowMaterialFlightSpeed = (material, flightSpeed) => {
-  const out = formatArgs(
-    formatLiteral(material),
-    formatFloat(flightSpeed)
+  const out = recipe(
+    literal(material),
+    float(flightSpeed)
   );
   return `mods.tconstruct.ToolStats.setBowFlightSpeed(${out});`;
 };
-const setArrowStats = (material, recipe) => {
-  const out = formatArgs(
-    formatLiteral(material),
-    formatFloat(recipe.mass),
-    formatFloat(recipe.breakChance),
-    formatFloat(recipe.accuracy)
+const setArrowStats = (material, recipe$1) => {
+  const out = recipe(
+    literal(material),
+    float(recipe$1.mass),
+    float(recipe$1.breakChance),
+    float(recipe$1.accuracy)
   );
   return `mods.tconstruct.ToolStats.setArrowStats(${out});`;
 };
 const setArrowMass = (material, mass) => {
-  const out = formatArgs(
-    formatLiteral(material),
-    formatFloat(mass)
+  const out = recipe(
+    literal(material),
+    float(mass)
   );
   return `mods.tconstruct.ToolStats.setArrowMass(${out});`;
 };
 const setArrowBreakChance = (material, breakChance) => {
-  const out = formatArgs(
-    formatLiteral(material),
-    formatFloat(breakChance)
+  const out = recipe(
+    literal(material),
+    float(breakChance)
   );
   return `mods.tconstruct.ToolStats.setArrowBreakChance(${out});`;
 };
 const setArrowAccuracy = (material, accuracy) => {
-  const out = formatArgs(
-    formatLiteral(material),
-    formatFloat(accuracy)
+  const out = recipe(
+    literal(material),
+    float(accuracy)
   );
   return `mods.tconstruct.TooLStats.setArrowAccuracy(${out});`;
 };
 
+exports.COLOR = COLOR;
 exports.ENCHANTMENTS = ENCHANTMENTS;
+exports.FOCI = FOCI;
+exports.HARVESTER_TYPE = HARVESTER_TYPE;
 exports.MATERIALS = MATERIALS;
 exports.MODIFIERS = MODIFIERS;
+exports.STYLE = STYLE;
 exports.add = add;
 exports.addBiomeRubberTree = addBiomeRubberTree;
 exports.addBlacklistAutospawner = addBlacklistAutospawner;