npm - @unified-latex/unified-latex-cli - Versions diffs - 1.0.9 - Mend

@unified-latex/unified-latex-cli 1.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (30) hide show

package/index.cjs.map +7 -0
package/index.d.ts +50 -0
package/index.d.ts.map +1 -0
package/index.js +704 -0
package/index.js.map +7 -0
package/libs/html/format.d.ts +7 -0
package/libs/html/format.d.ts.map +1 -0
package/libs/lints/index.d.ts +28 -0
package/libs/lints/index.d.ts.map +1 -0
package/libs/macros/attach-macro-args-plugin.d.ts +14 -0
package/libs/macros/attach-macro-args-plugin.d.ts.map +1 -0
package/libs/macros/expand-macros-plugin.d.ts +15 -0
package/libs/macros/expand-macros-plugin.d.ts.map +1 -0
package/libs/macros/parse-macro-expansion.d.ts +11 -0
package/libs/macros/parse-macro-expansion.d.ts.map +1 -0
package/libs/stats/enclosing-position.d.ts +15 -0
package/libs/stats/enclosing-position.d.ts.map +1 -0
package/libs/stats/index.d.ts +12 -0
package/libs/stats/index.d.ts.map +1 -0
package/libs/unified-args/index.d.ts +8 -0
package/libs/unified-args/index.d.ts.map +1 -0
package/libs/unified-args/options.d.ts +44 -0
package/libs/unified-args/options.d.ts.map +1 -0
package/libs/unified-args/schema.d.ts +11 -0
package/libs/unified-args/schema.d.ts.map +1 -0
package/libs/unified-latex.d.ts +12 -0
package/libs/unified-latex.d.ts.map +1 -0
package/package.json +73 -0
package/unified-latex-cli.mjs +704 -0
package/unified-latex-cli.mjs.map +7 -0

package/unified-latex-cli.mjs ADDED Viewed

@@ -0,0 +1,704 @@
+// libs/unified-latex.ts
+import { unified } from "unified";
+import {
+  unifiedLatexAstComplier,
+  unifiedLatexFromString
+} from "@unified-latex/unified-latex-util-parse";
+import {
+  unifiedLatexStringCompiler
+} from "@unified-latex/unified-latex-util-to-string";
+var processLatexViaUnified = (options2) => {
+  return unified().use(unifiedLatexFromString).use(unifiedLatexStringCompiler, Object.assign({ pretty: true, forceNewlineEnding: true }, options2));
+};
+// libs/unified-args/index.ts
+import process from "node:process";
+import stream from "node:stream";
+import chalk from "chalk";
+import chokidar from "chokidar";
+import {
+  engine
+} from "unified-engine";
+import { unifiedLatexToHast } from "@unified-latex/unified-latex-to-hast";
+// libs/unified-args/options.ts
+import table from "text-table";
+import camelcase from "camelcase";
+import minimist from "minimist";
+import json52 from "json5";
+import { fault } from "fault";
+// libs/lints/index.ts
+import { lints } from "@unified-latex/unified-latex-lint";
+var availableLints = Object.fromEntries(Object.values(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
+import json5 from "json5";
+import {
+  newcommandMacroToName,
+  newcommandMacroToSpec,
+  newcommandMacroToSubstitutionAst
+} from "@unified-latex/unified-latex-util-macros";
+import { parse } from "@unified-latex/unified-latex-util-parse";
+function parseMacroExpansion(def) {
+  if (def.startsWith("\\")) {
+    const macro = parse(def).content[0];
+    const name = 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 = newcommandMacroToSpec(macro);
+    const body = newcommandMacroToSubstitutionAst(macro);
+    return { name, signature, body };
+  }
+  const parsedSpec = json5.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: 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(minimist(flags, minischema));
+  let index2 = -1;
+  while (++index2 < schema.length) {
+    const option = schema[index2];
+    if (option.type === "string" && config[option.long] === "") {
+      throw 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 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 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 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 fault("Unknown short option `-%s`, expected:\n%s", key, inspectAll(known));
+      }
+    }
+  }
+  return true;
+}
+function inspectAll(options2) {
+  return table(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[camelcase(key)] = value;
+    }
+  }
+  return result;
+}
+function parseJSON(value) {
+  return json52.parse("{" + value + "}");
+}
+// libs/stats/index.ts
+import { listPackages } from "@unified-latex/unified-latex-util-packages";
+import { listNewcommands } from "@unified-latex/unified-latex-util-macros";
+import { printRaw } from "@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 = listPackages(tree);
+    const packageNames = packages.map((s) => printRaw(s));
+    if (packages.length > 0) {
+      file.info(`Found ${packages.length} imported packages: ${packageNames.join(", ")}`);
+    }
+    const newcommands = 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 = listPackages(tree).map((s) => printRaw(s));
+    const newcommands = listNewcommands(tree).map((c) => ({
+      name: c.name,
+      signature: c.signature,
+      body: printRaw(c.body),
+      definition: printRaw(c.definition)
+    }));
+    return JSON.stringify({ packages, newcommands }, null, 4) + "\n";
+  };
+};
+// libs/macros/expand-macros-plugin.ts
+import { expandMacros } from "@unified-latex/unified-latex-util-macros";
+import { attachMacroArgs } from "@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) => {
+    attachMacroArgs(tree, macroInfo);
+    expandMacros(tree, macros);
+  };
+};
+// libs/macros/attach-macro-args-plugin.ts
+import { attachMacroArgs as attachMacroArgs2 } from "@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) => {
+    attachMacroArgs2(tree, macroInfo);
+  };
+};
+// libs/html/format.ts
+import rehypeStringify from "rehype-stringify";
+import Prettier from "prettier";
+import { unified as unified2 } from "unified";
+var prettyPrintHtmlPlugin = function() {
+  const processor = unified2().use(rehypeStringify);
+  this.Compiler = (tree, file) => {
+    file.extname = ".html";
+    const html = processor.stringify(tree, file);
+    try {
+      return Prettier.format(html, { parser: "html", useTabs: true });
+    } catch {
+    }
+    return html;
+  };
+};
+// libs/unified-args/index.ts
+var ttyStream = Object.assign(new stream.Readable(), { isTTY: true });
+var exitStatus = 0;
+process.on("exit", onexit);
+process.on("uncaughtException", fail);
+function unifiedArgs(cliConfig) {
+  let config;
+  let watcher;
+  let output;
+  try {
+    config = options(process.argv.slice(2), cliConfig);
+  } catch (error) {
+    const exception = error;
+    return fail(exception, true);
+  }
+  if (config.help) {
+    process.stdout.write([
+      "Usage: " + cliConfig.name + " [options] [path | glob ...]",
+      "",
+      "  " + cliConfig.description,
+      "",
+      "Options:",
+      "",
+      config.helpMessage,
+      ""
+    ].join("\n"), noop);
+    return;
+  }
+  if (config.version) {
+    process.stdout.write(cliConfig.version + "\n", noop);
+    return;
+  }
+  if (config.watch) {
+    output = config.output;
+    config.streamIn = ttyStream;
+    config.out = false;
+    process.stderr.write(chalk.bold("Watching...") + " (press CTRL+C to exit)\n", noop);
+    if (output === true) {
+      config.output = false;
+      process.stderr.write(chalk.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([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 = chokidar.watch(((_a = context.fileSet) == null ? void 0 : _a.origins) || [], {
+      cwd: config.cwd,
+      ignoreInitial: true
+    }).on("error", done).on("change", (filePath) => {
+      config.files = [filePath];
+      engine(config, done);
+    });
+    process.on("SIGINT", onsigint);
+    function onsigint() {
+      process.stderr.write("\n", noop);
+      clean();
+      if (output === true) {
+        config.output = output;
+        config.watch = false;
+        engine(config, done);
+      }
+    }
+  }
+  engine(config, done);
+}
+function fail(error, pretty) {
+  const message = String((pretty ? error : error.stack) || error);
+  exitStatus = 1;
+  process.stderr.write(message.trim() + "\n", noop);
+}
+function onexit() {
+  process.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=unified-latex-cli.mjs.map