@unified-latex/unified-latex-cli 1.0.11 → 1.1.0

package/index.cjs

@@ -0,0 +1,768 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// libs/unified-latex.ts
+var import_unified = require("unified");
+var import_unified_latex_util_parse = require("@unified-latex/unified-latex-util-parse");
+var import_unified_latex_util_to_string = require("@unified-latex/unified-latex-util-to-string");
+var processLatexViaUnified = (options2) => {
+  return (0, import_unified.unified)().use(import_unified_latex_util_parse.unifiedLatexFromString).use(
+    import_unified_latex_util_to_string.unifiedLatexStringCompiler,
+    Object.assign({ pretty: true, forceNewlineEnding: true }, options2)
+  );
+};
+
+// libs/unified-args/index.ts
+var import_node_process = __toESM(require("node:process"), 1);
+var import_node_stream = __toESM(require("node:stream"), 1);
+var import_chalk = __toESM(require("chalk"), 1);
+var import_chokidar = __toESM(require("chokidar"), 1);
+var import_unified_engine = require("unified-engine");
+var import_unified_latex_to_hast = require("@unified-latex/unified-latex-to-hast");
+
+// libs/unified-args/options.ts
+var import_text_table = __toESM(require("text-table"), 1);
+var import_camelcase = __toESM(require("camelcase"), 1);
+var import_minimist = __toESM(require("minimist"), 1);
+var import_json52 = __toESM(require("json5"), 1);
+var import_fault = require("fault");
+
+// libs/lints/index.ts
+var import_unified_latex_lint = require("@unified-latex/unified-latex-lint");
+var availableLints = Object.fromEntries(
+  Object.values(import_unified_latex_lint.lints).map((lint) => [
+    lint.name.replace(/^unified-latex-lint:/, ""),
+    lint
+  ])
+);
+
+// libs/unified-args/schema.ts
+var schema = [
+  {
+    long: "help",
+    description: "Output usage information",
+    short: "h",
+    type: "boolean",
+    default: false
+  },
+  {
+    long: "version",
+    description: "Output version number",
+    short: "v",
+    type: "boolean",
+    default: false
+  },
+  {
+    long: "output",
+    description: "Specify output location",
+    short: "o",
+    value: "[path]"
+  },
+  {
+    long: "rc-path",
+    description: "Specify configuration file",
+    short: "r",
+    type: "string",
+    value: "<path>"
+  },
+  {
+    long: "ignore-path",
+    description: "Specify ignore file",
+    short: "i",
+    type: "string",
+    value: "<path>"
+  },
+  {
+    long: "ext",
+    description: "Specify extensions",
+    type: "string",
+    value: "<extensions>"
+  },
+  {
+    long: "lint",
+    description: `Lint rules to apply. Use multiple times to specify multiple lints. Available rules: ${Object.keys(
+      availableLints
+    ).join(", ")}`,
+    short: "l",
+    type: "string",
+    value: "<rule>"
+  },
+  {
+    long: "lint-all",
+    description: `Apply all available lint rules`,
+    type: "boolean",
+    default: false
+  },
+  {
+    long: "fix-all",
+    description: "Apply fixes for all applied lints",
+    type: "boolean",
+    default: false
+  },
+  {
+    long: "watch",
+    description: "Watch for changes and reprocess",
+    short: "w",
+    type: "boolean",
+    default: false
+  },
+  {
+    long: "macro",
+    description: "Attach arguments of the specified macro (by default, unrecognized macros are parsed as having no arguments). Accepts a string of the form `\\newcommand{<name>}[<num args>]{<body>}` or a JSON string `{name: <name>, signature: <xparse argument signature>, body: <macro body>}`",
+    short: "m",
+    type: "string",
+    value: "<rule>"
+  },
+  {
+    long: "expand-macro",
+    description: "Expand the specified macro. Accepts a string of the form `\\newcommand{<name>}[<num args>]{<body>}` or a JSON string `{name: <name>, signature: <xparse argument signature>, body: <macro body>}`",
+    short: "e",
+    type: "string",
+    value: "<rule>"
+  },
+  {
+    long: "frail",
+    description: "Exit with 1 on warnings",
+    type: "boolean",
+    default: false
+  },
+  {
+    long: "tree",
+    description: "Specify input and output as syntax tree",
+    type: "boolean",
+    default: false
+  },
+  {
+    long: "report",
+    description: "Specify reporter",
+    type: "string",
+    value: "<reporter>"
+  },
+  {
+    long: "file-path",
+    description: "Specify path to process as",
+    type: "string",
+    value: "<path>"
+  },
+  {
+    long: "ignore-path-resolve-from",
+    description: "Resolve patterns in `ignore-path` from its directory or cwd",
+    type: "string",
+    value: "dir|cwd",
+    default: "dir"
+  },
+  {
+    long: "ignore-pattern",
+    description: "Specify ignore patterns",
+    type: "string",
+    value: "<globs>"
+  },
+  {
+    long: "silently-ignore",
+    description: "Do not fail when given ignored files",
+    type: "boolean"
+  },
+  {
+    long: "tree-in",
+    description: "Specify input as syntax tree",
+    type: "boolean"
+  },
+  {
+    long: "tree-out",
+    description: "Output syntax tree",
+    type: "boolean"
+  },
+  {
+    long: "inspect",
+    description: "Output formatted syntax tree",
+    type: "boolean"
+  },
+  {
+    long: "stats",
+    description: "Show information about the processed file",
+    type: "boolean",
+    default: false
+  },
+  {
+    long: "stats-json",
+    description: "Show information about the processed file and output the information as JSON",
+    type: "boolean",
+    default: false
+  },
+  {
+    long: "html",
+    description: "Convert the output to HTML. Note, for math to render properly, you will need to add a library like MathJax or KaTeX to your HTMl source; you should also expand/replace any macros not recognized by the converter",
+    type: "boolean",
+    default: false
+  },
+  {
+    long: "stdout",
+    description: "[Don't] write the processed file's contents to stdout",
+    type: "boolean",
+    truelike: true
+  },
+  {
+    long: "color",
+    description: "Specify color in report",
+    type: "boolean",
+    default: true
+  },
+  {
+    long: "config",
+    description: "Search for configuration files",
+    type: "boolean",
+    default: true
+  },
+  {
+    long: "ignore",
+    description: "Search for ignore files",
+    type: "boolean",
+    default: true
+  }
+];
+
+// libs/macros/parse-macro-expansion.ts
+var import_json5 = __toESM(require("json5"), 1);
+var import_unified_latex_util_macros = require("@unified-latex/unified-latex-util-macros");
+var import_unified_latex_util_parse2 = require("@unified-latex/unified-latex-util-parse");
+function parseMacroExpansion(def) {
+  if (def.startsWith("\\")) {
+    const macro = (0, import_unified_latex_util_parse2.parse)(def).content[0];
+    const name = (0, import_unified_latex_util_macros.newcommandMacroToName)(macro);
+    if (!name) {
+      throw new Error(
+        `Could extract macro definition from "${def}"; expected the macro to be defined via \\newcommand or similar syntax`
+      );
+    }
+    const signature = (0, import_unified_latex_util_macros.newcommandMacroToSpec)(macro);
+    const body = (0, import_unified_latex_util_macros.newcommandMacroToSubstitutionAst)(macro);
+    return { name, signature, body };
+  }
+  const parsedSpec = import_json5.default.parse(def);
+  if (parsedSpec.name == null || parsedSpec.body == null) {
+    throw new Error(
+      `Expected a "name" field and a "body" field to be defined on ${def}`
+    );
+  }
+  parsedSpec.signature = parsedSpec.signature || "";
+  return {
+    name: parsedSpec.name,
+    signature: parsedSpec.signature,
+    body: (0, import_unified_latex_util_parse2.parse)(parsedSpec.body).content
+  };
+}
+
+// libs/unified-args/options.ts
+var own = {}.hasOwnProperty;
+var minischema = {
+  unknown: handleUnknownArgument,
+  default: {},
+  alias: {},
+  string: [],
+  boolean: []
+};
+var index = -1;
+while (++index < schema.length) {
+  addEach(schema[index]);
+}
+function options(flags, configuration) {
+  const extension = configuration.extensions[0];
+  const name = configuration.name;
+  const config = toCamelCase((0, import_minimist.default)(flags, minischema));
+  let index2 = -1;
+  while (++index2 < schema.length) {
+    const option = schema[index2];
+    if (option.type === "string" && config[option.long] === "") {
+      throw (0, import_fault.fault)("Missing value:%s", inspect(option).join(" "));
+    }
+  }
+  const ext = commaSeparated(config.ext);
+  const report = reporter(config.report);
+  const help = [
+    inspectAll(schema),
+    "",
+    "Examples:",
+    "",
+    "  # Process `input." + extension + "`",
+    "  $ " + name + " input." + extension + " -o output." + extension,
+    "",
+    "  # Pipe",
+    "  $ " + name + " < input." + extension + " > output." + extension,
+    "",
+    "  # Rewrite all applicable files",
+    "  $ " + name + " . -o",
+    "",
+    "  # Lint files and display the lint output (but not the processed file)",
+    "  $ " + name + " . --lint-all --no-stdout"
+  ].join("\n");
+  const settings = parseSettings(config.setting);
+  if (config.html && config.statsJson) {
+    throw new Error("Both --html and --stats-json were specified; only one may be used at a time.");
+  }
+  return {
+    helpMessage: help,
+    cwd: configuration.cwd,
+    processor: configuration.processor,
+    help: config.help,
+    version: config.version,
+    files: config._,
+    filePath: config.filePath,
+    watch: config.watch,
+    extensions: ext.length === 0 ? configuration.extensions : ext,
+    output: config.output,
+    out: config.stdout,
+    tree: config.tree,
+    treeIn: config.treeIn,
+    treeOut: config.treeOut,
+    inspect: config.inspect,
+    rcName: configuration.rcName,
+    packageField: configuration.packageField,
+    rcPath: config.rcPath,
+    detectConfig: config.config,
+    settings,
+    ignoreName: configuration.ignoreName,
+    ignorePath: config.ignorePath,
+    ignorePathResolveFrom: config.ignorePathResolveFrom,
+    ignorePatterns: commaSeparated(config.ignorePattern),
+    silentlyIgnore: config.silentlyIgnore,
+    detectIgnore: config.ignore,
+    pluginPrefix: configuration.pluginPrefix,
+    plugins: [],
+    lints: normalizeLints(config.lint, config),
+    reporter: report[0],
+    reporterOptions: report[1],
+    color: config.color,
+    silent: config.silent,
+    quiet: config.quiet,
+    frail: config.frail,
+    stats: config.stats,
+    statsJson: config.statsJson,
+    expandMacro: normalizeToArray(config.expandMacro).map(
+      parseMacroExpansion
+    ),
+    macro: normalizeToArray(config.macro).map(
+      parseMacroExpansion
+    ),
+    html: config.html
+  };
+}
+function addEach(option) {
+  const value = option.default;
+  minischema.default[option.long] = value === void 0 ? null : value;
+  if (option.type && option.type in minischema) {
+    minischema[option.type].push(option.long);
+  }
+  if (option.short) {
+    minischema.alias[option.short] = option.long;
+  }
+}
+function commaSeparated(value) {
+  return normalizeToArray(value).flatMap((d) => splitOnComma(d));
+}
+function normalizeLints(value, config) {
+  const normalized = normalizeToArray(value).map(splitOnEquals);
+  validateLintNames(normalized);
+  if (config.lintAll) {
+    normalized.push(...Object.keys(availableLints).map((v) => [v]));
+  }
+  const result = Object.fromEntries(
+    normalized.map((value2) => {
+      let params = value2[1] ? parseConfig(value2[1], {}) : void 0;
+      if (config.fixAll) {
+        if (params) {
+          Object.assign(params, { fix: true });
+        } else {
+          params = { fix: true };
+        }
+      }
+      return [value2[0], params];
+    })
+  );
+  return result;
+}
+function reporter(value) {
+  const all = normalizeToArray(value).map(splitOnEquals).map((value2) => [
+    value2[0],
+    value2[1] ? parseConfig(value2[1], {}) : void 0
+  ]);
+  return all[all.length - 1] || [];
+}
+function parseSettings(value) {
+  const normalized = normalizeToArray(value);
+  const cache = {};
+  for (const value2 of normalized) {
+    parseConfig(value2, cache);
+  }
+  return cache;
+}
+function parseConfig(value, cache) {
+  let flags;
+  let flag;
+  try {
+    flags = toCamelCase(parseJSON(value));
+  } catch (error) {
+    const exception = error;
+    throw (0, import_fault.fault)(
+      "Cannot parse `%s` as JSON: %s",
+      value,
+      exception.message.replace(/at(?= position)/, "around")
+    );
+  }
+  for (flag in flags) {
+    if (own.call(flags, flag)) {
+      cache[flag] = flags[flag];
+    }
+  }
+  return cache;
+}
+function validateLintNames(lints2) {
+  for (const lint of lints2) {
+    const name = lint[0];
+    if (!availableLints[name]) {
+      const known = Object.keys(availableLints);
+      throw (0, import_fault.fault)(
+        "Unknown lint rule `%s`, available rules are:\n%s",
+        name,
+        "	" + known.join("\n	")
+      );
+    }
+  }
+  return true;
+}
+function handleUnknownArgument(flag) {
+  if (flag.charAt(0) === "-") {
+    if (flag.charAt(1) === "-") {
+      throw (0, import_fault.fault)(
+        "Unknown option `%s`, expected:\n%s",
+        flag,
+        inspectAll(schema)
+      );
+    }
+    const found = flag.slice(1).split("");
+    const known = schema.filter((d) => d.short);
+    const knownKeys = new Set(known.map((d) => d.short));
+    let index2 = -1;
+    while (++index2 < found.length) {
+      const key = found[index2];
+      if (!knownKeys.has(key)) {
+        throw (0, import_fault.fault)(
+          "Unknown short option `-%s`, expected:\n%s",
+          key,
+          inspectAll(known)
+        );
+      }
+    }
+  }
+  return true;
+}
+function inspectAll(options2) {
+  return (0, import_text_table.default)(options2.map((d) => inspect(d)));
+}
+function inspect(option) {
+  let description = option.description;
+  let long = option.long;
+  if (option.default === true || option.truelike) {
+    description += " (on by default)";
+    long = "[no-]" + long;
+  }
+  return [
+    "",
+    option.short ? "-" + option.short : "",
+    "--" + long + (option.value ? " " + option.value : ""),
+    description
+  ];
+}
+function normalizeToArray(value) {
+  if (!value) {
+    return [];
+  }
+  if (typeof value === "string") {
+    return [value];
+  }
+  return value;
+}
+function splitOnEquals(value) {
+  return value.split("=");
+}
+function splitOnComma(value) {
+  return value.split(",");
+}
+function toCamelCase(object) {
+  const result = {};
+  let key;
+  for (key in object) {
+    if (own.call(object, key)) {
+      let value = object[key];
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        value = toCamelCase(value);
+      }
+      result[(0, import_camelcase.default)(key)] = value;
+    }
+  }
+  return result;
+}
+function parseJSON(value) {
+  return import_json52.default.parse("{" + value + "}");
+}
+
+// libs/stats/index.ts
+var import_unified_latex_util_packages = require("@unified-latex/unified-latex-util-packages");
+var import_unified_latex_util_macros2 = require("@unified-latex/unified-latex-util-macros");
+var import_unified_latex_util_print_raw = require("@unified-latex/unified-latex-util-print-raw");
+
+// libs/stats/enclosing-position.ts
+function enclosingPosition(nodes) {
+  var _a, _b, _c, _d;
+  let start = { line: 1, column: 1, offset: 0 };
+  let end = { line: 1, column: 1, offset: 0 };
+  for (const node of nodes) {
+    if (Number((_a = node.position) == null ? void 0 : _a.start.offset) < Number(start.offset)) {
+      start = (_b = node.position) == null ? void 0 : _b.start;
+    }
+    if (Number((_c = node.position) == null ? void 0 : _c.end.offset) > Number(end.offset)) {
+      end = (_d = node.position) == null ? void 0 : _d.end;
+    }
+  }
+  return { start, end };
+}
+
+// libs/stats/index.ts
+var statsPlugin = function() {
+  return (tree, file) => {
+    const packages = (0, import_unified_latex_util_packages.listPackages)(tree);
+    const packageNames = packages.map((s) => (0, import_unified_latex_util_print_raw.printRaw)(s));
+    if (packages.length > 0) {
+      file.info(
+        `Found ${packages.length} imported packages: ${packageNames.join(", ")}`
+      );
+    }
+    const newcommands = (0, import_unified_latex_util_macros2.listNewcommands)(tree);
+    if (newcommands.length > 0) {
+      file.info(
+        `Found ${newcommands.length} defined commands: ${newcommands.map((c) => `\\${c.name}`).join(", ")}`,
+        enclosingPosition(newcommands.map((c) => c.definition))
+      );
+    }
+  };
+};
+var statsJsonPlugin = function() {
+  this.Compiler = (tree, file) => {
+    file.extname = ".json";
+    file.basename += "-stats";
+    const packages = (0, import_unified_latex_util_packages.listPackages)(tree).map((s) => (0, import_unified_latex_util_print_raw.printRaw)(s));
+    const newcommands = (0, import_unified_latex_util_macros2.listNewcommands)(tree).map((c) => ({
+      name: c.name,
+      signature: c.signature,
+      body: (0, import_unified_latex_util_print_raw.printRaw)(c.body),
+      definition: (0, import_unified_latex_util_print_raw.printRaw)(c.definition)
+    }));
+    return JSON.stringify({ packages, newcommands }, null, 4) + "\n";
+  };
+};
+
+// libs/macros/expand-macros-plugin.ts
+var import_unified_latex_util_macros3 = require("@unified-latex/unified-latex-util-macros");
+var import_unified_latex_util_arguments = require("@unified-latex/unified-latex-util-arguments");
+var expandMacrosPlugin = function(options2) {
+  const { macros = [] } = options2 || {};
+  const macroInfo = Object.fromEntries(
+    macros.map((m) => [m.name, { signature: m.signature }])
+  );
+  return (tree) => {
+    (0, import_unified_latex_util_arguments.attachMacroArgs)(tree, macroInfo);
+    (0, import_unified_latex_util_macros3.expandMacros)(tree, macros);
+  };
+};
+
+// libs/macros/attach-macro-args-plugin.ts
+var import_unified_latex_util_arguments2 = require("@unified-latex/unified-latex-util-arguments");
+var attachMacroArgsPlugin = function(options2) {
+  const { macros = [] } = options2 || {};
+  const macroInfo = Object.fromEntries(
+    macros.map((m) => [m.name, { signature: m.signature }])
+  );
+  return (tree) => {
+    (0, import_unified_latex_util_arguments2.attachMacroArgs)(tree, macroInfo);
+  };
+};
+
+// libs/html/format.ts
+var import_rehype_stringify = __toESM(require("rehype-stringify"), 1);
+var import_prettier = __toESM(require("prettier"), 1);
+var import_unified2 = require("unified");
+var prettyPrintHtmlPlugin = function() {
+  const processor = (0, import_unified2.unified)().use(import_rehype_stringify.default);
+  this.Compiler = (tree, file) => {
+    file.extname = ".html";
+    const html = processor.stringify(tree, file);
+    try {
+      return import_prettier.default.format(html, { parser: "html", useTabs: true });
+    } catch {
+    }
+    return html;
+  };
+};
+
+// libs/unified-args/index.ts
+var ttyStream = Object.assign(new import_node_stream.default.Readable(), { isTTY: true });
+var exitStatus = 0;
+import_node_process.default.on("exit", onexit);
+import_node_process.default.on("uncaughtException", fail);
+function unifiedArgs(cliConfig) {
+  let config;
+  let watcher;
+  let output;
+  try {
+    config = options(import_node_process.default.argv.slice(2), cliConfig);
+  } catch (error) {
+    const exception = error;
+    return fail(exception, true);
+  }
+  if (config.help) {
+    import_node_process.default.stdout.write(
+      [
+        "Usage: " + cliConfig.name + " [options] [path | glob ...]",
+        "",
+        "  " + cliConfig.description,
+        "",
+        "Options:",
+        "",
+        config.helpMessage,
+        ""
+      ].join("\n"),
+      noop
+    );
+    return;
+  }
+  if (config.version) {
+    import_node_process.default.stdout.write(cliConfig.version + "\n", noop);
+    return;
+  }
+  if (config.watch) {
+    output = config.output;
+    config.streamIn = ttyStream;
+    config.out = false;
+    import_node_process.default.stderr.write(
+      import_chalk.default.bold("Watching...") + " (press CTRL+C to exit)\n",
+      noop
+    );
+    if (output === true) {
+      config.output = false;
+      import_node_process.default.stderr.write(
+        import_chalk.default.yellow("Note") + ": Ignoring `--output` until exit.\n",
+        noop
+      );
+    }
+  }
+  if (config.lints) {
+    for (const [lintName, lintArgs] of Object.entries(config.lints)) {
+      const lint = availableLints[lintName];
+      if (!lint) {
+        throw new Error(
+          `Could not find lint named "${lintName}"; available lints are ${Object.keys(
+            availableLints
+          ).join(", ")}`
+        );
+      }
+      config.plugins.push([lint, lintArgs]);
+    }
+  }
+  if (config.stats) {
+    config.plugins.push([statsPlugin]);
+  }
+  if (config.macro.length > 0) {
+    config.plugins.push([attachMacroArgsPlugin, { macros: config.macro }]);
+  }
+  if (config.expandMacro.length > 0) {
+    config.plugins.push([
+      expandMacrosPlugin,
+      { macros: config.expandMacro }
+    ]);
+  }
+  if (config.statsJson) {
+    config.plugins.push([statsJsonPlugin]);
+  }
+  if (config.html) {
+    config.plugins.push([import_unified_latex_to_hast.unifiedLatexToHast]);
+    config.plugins.push([prettyPrintHtmlPlugin]);
+  }
+  const done = function done2(error, code, context) {
+    if (error) {
+      clean();
+      fail(error);
+    } else {
+      exitStatus = code || 0;
+      if (config.watch && !watcher && context) {
+        subscribe(context);
+      }
+    }
+  };
+  function clean() {
+    if (watcher) {
+      watcher.close();
+      watcher = void 0;
+    }
+  }
+  function subscribe(context) {
+    var _a;
+    watcher = import_chokidar.default.watch(((_a = context.fileSet) == null ? void 0 : _a.origins) || [], {
+      cwd: config.cwd,
+      ignoreInitial: true
+    }).on("error", done).on("change", (filePath) => {
+      config.files = [filePath];
+      (0, import_unified_engine.engine)(config, done);
+    });
+    import_node_process.default.on("SIGINT", onsigint);
+    function onsigint() {
+      import_node_process.default.stderr.write("\n", noop);
+      clean();
+      if (output === true) {
+        config.output = output;
+        config.watch = false;
+        (0, import_unified_engine.engine)(config, done);
+      }
+    }
+  }
+  (0, import_unified_engine.engine)(config, done);
+}
+function fail(error, pretty) {
+  const message = String((pretty ? error : error.stack) || error);
+  exitStatus = 1;
+  import_node_process.default.stderr.write(message.trim() + "\n", noop);
+}
+function onexit() {
+  import_node_process.default.exit(exitStatus);
+}
+function noop() {
+}
+
+// index.ts
+unifiedArgs({
+  processor: processLatexViaUnified,
+  name: "unified-latex",
+  description: "LaTeX processor powered by unified-latex",
+  version: "1.0.8",
+  extensions: ["tex"],
+  ignoreName: ".unifiedlatexignore",
+  packageField: "unifiedLatexConfig",
+  rcName: ".unifiedlatexrc",
+  pluginPrefix: "@unified-latex/"
+});
+//# sourceMappingURL=index.cjs.map