@storyteller-platform/align 0.0.1

package/dist/common/ffmpeg.cjs

@@ -0,0 +1,232 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ffmpeg_exports = {};
+__export(ffmpeg_exports, {
+  getTrackDuration: () => getTrackDuration,
+  getTrackInfo: () => getTrackInfo,
+  splitFile: () => splitFile,
+  transcodeFile: () => transcodeFile
+});
+module.exports = __toCommonJS(ffmpeg_exports);
+var import_node_child_process = require("node:child_process");
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_node_util = require("node:util");
+var import_memoize = __toESM(require("memoize"), 1);
+var import_mime = require("../process/mime.cjs");
+var import_shell = require("./shell.cjs");
+const execPromise = (0, import_node_util.promisify)(import_node_child_process.exec);
+async function execCmd(command, logger, signal) {
+  let stdout = "";
+  let stderr = "";
+  try {
+    ;
+    ({ stdout, stderr } = await execPromise(command, {
+      maxBuffer: 50 * 1024 * 1024,
+      signal: signal ?? void 0
+    }));
+    return stdout;
+  } catch (error) {
+    if (error instanceof RangeError && error.message.includes("stdout maxBuffer length exceeded")) {
+      throw new Error(
+        "stdout maxBuffer length exceeded. This likely means that youre trying to process a very large file, and the ffmpeg process is running out of memory. Maybe check the image size of your cover art."
+      );
+    }
+    logger == null ? void 0 : logger.error(error);
+    logger == null ? void 0 : logger.info(stdout);
+    throw new Error(stderr);
+  }
+}
+const getTrackInfo = (0, import_memoize.default)(async function getTrackInfo2(path, logger) {
+  const stdout = await execCmd(
+    `ffprobe -i ${(0, import_shell.quotePath)(path)} -show_format -of json`,
+    logger
+  );
+  const info = JSON.parse(stdout);
+  return parseTrackInfo(info.format);
+});
+async function getTrackDuration(path, logger) {
+  const info = await getTrackInfo(path, logger);
+  return info["duration"];
+}
+function parseTrackInfo(format) {
+  return {
+    filename: format.filename,
+    nbStreams: format.nb_streams,
+    nbPrograms: format.nb_programs,
+    formatName: format.format_name,
+    formatLongName: format.format_long_name,
+    startTime: parseFloat(format.start_time),
+    duration: parseFloat(format.duration),
+    size: parseInt(format.size, 10),
+    bitRate: parseInt(format.bit_rate, 10),
+    probeScore: format.probe_score,
+    ...format.tags && {
+      tags: {
+        majorBrand: format.tags.major_brand,
+        minorVersion: format.tags.minor_version,
+        compatibleBrands: format.tags.compatible_brands,
+        title: format.tags.title,
+        track: format.tags.track,
+        album: format.tags.album,
+        genre: format.tags.genre,
+        artist: format.tags.artist,
+        encoder: format.tags.encoder,
+        mediaType: format.tags.media_type
+      }
+    }
+  };
+}
+const hasCoverArt = (0, import_memoize.default)(async function hasCoverArt2(path) {
+  try {
+    const { stdout } = await execPromise(
+      `ffprobe -v quiet -show_streams -of json ${(0, import_shell.quotePath)(path)}`
+    );
+    const { streams } = JSON.parse(stdout);
+    return streams.some((stream) => stream.disposition.attached_pic === 1);
+  } catch {
+    return null;
+  }
+});
+async function constructExtractCoverArtCommand(source, destExtension) {
+  if (destExtension === ".wav" || !await hasCoverArt(source)) {
+    return "";
+  }
+  const command = "ffmpeg";
+  const args = [
+    "-nostdin",
+    "-i",
+    (0, import_shell.quotePath)(source),
+    "-map",
+    "0:v",
+    "-c:v",
+    "copy",
+    "-vframes",
+    "1",
+    "-f",
+    "image2",
+    "-update",
+    "1",
+    "pipe:1"
+  ];
+  return `${command} ${args.join(" ")} | `;
+}
+function commonFfmpegArguments(sourceExtension, destExtension, codec, bitrate) {
+  const args = ["-vn"];
+  if (codec) {
+    args.push(
+      "-c:a",
+      codec,
+      ...codec === "libopus" ? ["-b:a", bitrate && /^\d+[kK]$/i.test(bitrate) ? bitrate : "32K"] : [],
+      ...codec === "libmp3lame" && bitrate ? ["-q:a", bitrate] : []
+    );
+  } else if ((0, import_mime.areSameType)(sourceExtension, destExtension) || destExtension == ".mp4") {
+    args.push("-c:a", "copy");
+  }
+  args.push("-map", "0:a");
+  if (destExtension === ".mp4") {
+    args.push("-map_chapters", "-1");
+  }
+  return args;
+}
+async function splitFile(input, output, start, end, encoding, signal, logger) {
+  if (start === end) return false;
+  logger == null ? void 0 : logger.info(
+    `Splitting ${input} start: ${start} end: ${end}${(encoding == null ? void 0 : encoding.codec) ? ` codec: ${encoding.codec}` : ""}`
+  );
+  const command = "ffmpeg";
+  const args = [
+    "-nostdin",
+    "-ss",
+    start,
+    "-to",
+    end,
+    "-i",
+    (0, import_shell.quotePath)(input),
+    ...commonFfmpegArguments(
+      (0, import_node_path.extname)(input),
+      (0, import_node_path.extname)(output),
+      (encoding == null ? void 0 : encoding.codec) ?? null,
+      (encoding == null ? void 0 : encoding.bitrate) ?? null
+    ),
+    (0, import_shell.quotePath)(output)
+  ];
+  const coverArtCommand = await constructExtractCoverArtCommand(
+    input,
+    (0, import_node_path.extname)(output)
+  );
+  await execCmd(
+    `${coverArtCommand}${command} ${args.join(" ")}`,
+    logger,
+    signal
+  );
+  return true;
+}
+async function transcodeFile(input, output, encoding, signal, logger) {
+  if (!(encoding == null ? void 0 : encoding.codec) && (0, import_mime.areSameType)(input, output)) {
+    logger == null ? void 0 : logger.info(
+      `Input and output container and codec are the same, copying ${input} to output directory`
+    );
+    await (0, import_promises.copyFile)(input, output);
+    return;
+  }
+  logger == null ? void 0 : logger.info(
+    `Transcoding ${input}${(encoding == null ? void 0 : encoding.codec) ? ` codec: ${encoding.codec}` : ""}`
+  );
+  const command = "ffmpeg";
+  const args = [
+    "-nostdin",
+    "-i",
+    (0, import_shell.quotePath)(input),
+    ...commonFfmpegArguments(
+      (0, import_node_path.extname)(input),
+      (0, import_node_path.extname)(output),
+      (encoding == null ? void 0 : encoding.codec) ?? null,
+      (encoding == null ? void 0 : encoding.bitrate) ?? null
+    ),
+    (0, import_shell.quotePath)(output)
+  ];
+  const coverArtCommand = await constructExtractCoverArtCommand(
+    input,
+    (0, import_node_path.extname)(output)
+  );
+  await execCmd(
+    `${coverArtCommand}${command} ${args.join(" ")}`,
+    logger,
+    signal
+  );
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getTrackDuration,
+  getTrackInfo,
+  splitFile,
+  transcodeFile
+});

package/dist/common/ffmpeg.d.cts

@@ -0,0 +1,33 @@
+import { Logger } from 'pino';
+import { AudioEncoding } from '../process/AudioEncoding.cjs';
+
+declare const getTrackInfo: (path: string, logger?: Logger) => Promise<TrackInfo>;
+declare function getTrackDuration(path: string, logger?: Logger): Promise<number>;
+type TrackInfo = {
+    filename: string;
+    nbStreams: number;
+    nbPrograms: number;
+    formatName: string;
+    formatLongName: string;
+    startTime: number;
+    duration: number;
+    size: number;
+    bitRate: number;
+    probeScore: number;
+    tags?: {
+        majorBrand: string;
+        minorVersion: string;
+        compatibleBrands: string;
+        title: string;
+        track: string;
+        album: string;
+        genre: string;
+        artist: string;
+        encoder: string;
+        mediaType: string;
+    };
+};
+declare function splitFile(input: string, output: string, start: number, end: number, encoding?: AudioEncoding | null, signal?: AbortSignal | null, logger?: Logger | null): Promise<boolean>;
+declare function transcodeFile(input: string, output: string, encoding?: AudioEncoding | null, signal?: AbortSignal | null, logger?: Logger | null): Promise<true | undefined>;
+
+export { getTrackDuration, getTrackInfo, splitFile, transcodeFile };

package/dist/common/ffmpeg.d.ts

@@ -0,0 +1,33 @@
+import { Logger } from 'pino';
+import { AudioEncoding } from '../process/AudioEncoding.js';
+
+declare const getTrackInfo: (path: string, logger?: Logger) => Promise<TrackInfo>;
+declare function getTrackDuration(path: string, logger?: Logger): Promise<number>;
+type TrackInfo = {
+    filename: string;
+    nbStreams: number;
+    nbPrograms: number;
+    formatName: string;
+    formatLongName: string;
+    startTime: number;
+    duration: number;
+    size: number;
+    bitRate: number;
+    probeScore: number;
+    tags?: {
+        majorBrand: string;
+        minorVersion: string;
+        compatibleBrands: string;
+        title: string;
+        track: string;
+        album: string;
+        genre: string;
+        artist: string;
+        encoder: string;
+        mediaType: string;
+    };
+};
+declare function splitFile(input: string, output: string, start: number, end: number, encoding?: AudioEncoding | null, signal?: AbortSignal | null, logger?: Logger | null): Promise<boolean>;
+declare function transcodeFile(input: string, output: string, encoding?: AudioEncoding | null, signal?: AbortSignal | null, logger?: Logger | null): Promise<true | undefined>;
+
+export { getTrackDuration, getTrackInfo, splitFile, transcodeFile };

package/dist/common/ffmpeg.js

@@ -0,0 +1,196 @@
+import "../chunk-BIEQXUOY.js";
+import { exec } from "node:child_process";
+import { copyFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { promisify } from "node:util";
+import memoize from "memoize";
+import { areSameType } from "../process/mime.js";
+import { quotePath } from "./shell.js";
+const execPromise = promisify(exec);
+async function execCmd(command, logger, signal) {
+  let stdout = "";
+  let stderr = "";
+  try {
+    ;
+    ({ stdout, stderr } = await execPromise(command, {
+      maxBuffer: 50 * 1024 * 1024,
+      signal: signal ?? void 0
+    }));
+    return stdout;
+  } catch (error) {
+    if (error instanceof RangeError && error.message.includes("stdout maxBuffer length exceeded")) {
+      throw new Error(
+        "stdout maxBuffer length exceeded. This likely means that youre trying to process a very large file, and the ffmpeg process is running out of memory. Maybe check the image size of your cover art."
+      );
+    }
+    logger == null ? void 0 : logger.error(error);
+    logger == null ? void 0 : logger.info(stdout);
+    throw new Error(stderr);
+  }
+}
+const getTrackInfo = memoize(async function getTrackInfo2(path, logger) {
+  const stdout = await execCmd(
+    `ffprobe -i ${quotePath(path)} -show_format -of json`,
+    logger
+  );
+  const info = JSON.parse(stdout);
+  return parseTrackInfo(info.format);
+});
+async function getTrackDuration(path, logger) {
+  const info = await getTrackInfo(path, logger);
+  return info["duration"];
+}
+function parseTrackInfo(format) {
+  return {
+    filename: format.filename,
+    nbStreams: format.nb_streams,
+    nbPrograms: format.nb_programs,
+    formatName: format.format_name,
+    formatLongName: format.format_long_name,
+    startTime: parseFloat(format.start_time),
+    duration: parseFloat(format.duration),
+    size: parseInt(format.size, 10),
+    bitRate: parseInt(format.bit_rate, 10),
+    probeScore: format.probe_score,
+    ...format.tags && {
+      tags: {
+        majorBrand: format.tags.major_brand,
+        minorVersion: format.tags.minor_version,
+        compatibleBrands: format.tags.compatible_brands,
+        title: format.tags.title,
+        track: format.tags.track,
+        album: format.tags.album,
+        genre: format.tags.genre,
+        artist: format.tags.artist,
+        encoder: format.tags.encoder,
+        mediaType: format.tags.media_type
+      }
+    }
+  };
+}
+const hasCoverArt = memoize(async function hasCoverArt2(path) {
+  try {
+    const { stdout } = await execPromise(
+      `ffprobe -v quiet -show_streams -of json ${quotePath(path)}`
+    );
+    const { streams } = JSON.parse(stdout);
+    return streams.some((stream) => stream.disposition.attached_pic === 1);
+  } catch {
+    return null;
+  }
+});
+async function constructExtractCoverArtCommand(source, destExtension) {
+  if (destExtension === ".wav" || !await hasCoverArt(source)) {
+    return "";
+  }
+  const command = "ffmpeg";
+  const args = [
+    "-nostdin",
+    "-i",
+    quotePath(source),
+    "-map",
+    "0:v",
+    "-c:v",
+    "copy",
+    "-vframes",
+    "1",
+    "-f",
+    "image2",
+    "-update",
+    "1",
+    "pipe:1"
+  ];
+  return `${command} ${args.join(" ")} | `;
+}
+function commonFfmpegArguments(sourceExtension, destExtension, codec, bitrate) {
+  const args = ["-vn"];
+  if (codec) {
+    args.push(
+      "-c:a",
+      codec,
+      ...codec === "libopus" ? ["-b:a", bitrate && /^\d+[kK]$/i.test(bitrate) ? bitrate : "32K"] : [],
+      ...codec === "libmp3lame" && bitrate ? ["-q:a", bitrate] : []
+    );
+  } else if (areSameType(sourceExtension, destExtension) || destExtension == ".mp4") {
+    args.push("-c:a", "copy");
+  }
+  args.push("-map", "0:a");
+  if (destExtension === ".mp4") {
+    args.push("-map_chapters", "-1");
+  }
+  return args;
+}
+async function splitFile(input, output, start, end, encoding, signal, logger) {
+  if (start === end) return false;
+  logger == null ? void 0 : logger.info(
+    `Splitting ${input} start: ${start} end: ${end}${(encoding == null ? void 0 : encoding.codec) ? ` codec: ${encoding.codec}` : ""}`
+  );
+  const command = "ffmpeg";
+  const args = [
+    "-nostdin",
+    "-ss",
+    start,
+    "-to",
+    end,
+    "-i",
+    quotePath(input),
+    ...commonFfmpegArguments(
+      extname(input),
+      extname(output),
+      (encoding == null ? void 0 : encoding.codec) ?? null,
+      (encoding == null ? void 0 : encoding.bitrate) ?? null
+    ),
+    quotePath(output)
+  ];
+  const coverArtCommand = await constructExtractCoverArtCommand(
+    input,
+    extname(output)
+  );
+  await execCmd(
+    `${coverArtCommand}${command} ${args.join(" ")}`,
+    logger,
+    signal
+  );
+  return true;
+}
+async function transcodeFile(input, output, encoding, signal, logger) {
+  if (!(encoding == null ? void 0 : encoding.codec) && areSameType(input, output)) {
+    logger == null ? void 0 : logger.info(
+      `Input and output container and codec are the same, copying ${input} to output directory`
+    );
+    await copyFile(input, output);
+    return;
+  }
+  logger == null ? void 0 : logger.info(
+    `Transcoding ${input}${(encoding == null ? void 0 : encoding.codec) ? ` codec: ${encoding.codec}` : ""}`
+  );
+  const command = "ffmpeg";
+  const args = [
+    "-nostdin",
+    "-i",
+    quotePath(input),
+    ...commonFfmpegArguments(
+      extname(input),
+      extname(output),
+      (encoding == null ? void 0 : encoding.codec) ?? null,
+      (encoding == null ? void 0 : encoding.bitrate) ?? null
+    ),
+    quotePath(output)
+  ];
+  const coverArtCommand = await constructExtractCoverArtCommand(
+    input,
+    extname(output)
+  );
+  await execCmd(
+    `${coverArtCommand}${command} ${args.join(" ")}`,
+    logger,
+    signal
+  );
+  return true;
+}
+export {
+  getTrackDuration,
+  getTrackInfo,
+  splitFile,
+  transcodeFile
+};

package/dist/common/logging.cjs

@@ -0,0 +1,45 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logging_exports = {};
+__export(logging_exports, {
+  createLogger: () => createLogger
+});
+module.exports = __toCommonJS(logging_exports);
+var import_pino = __toESM(require("pino"), 1);
+var import_pino_pretty = __toESM(require("pino-pretty"), 1);
+function createLogger(level = "info") {
+  return (0, import_pino.default)(
+    { level },
+    (0, import_pino_pretty.default)({ ignore: "pid,hostname", translateTime: "SYS:standard" })
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLogger
+});

package/dist/common/logging.d.cts

@@ -0,0 +1,5 @@
+import pino, { LevelWithSilent } from 'pino';
+
+declare function createLogger(level?: LevelWithSilent): pino.Logger<never, boolean>;
+
+export { createLogger };

package/dist/common/logging.d.ts

@@ -0,0 +1,5 @@
+import pino, { LevelWithSilent } from 'pino';
+
+declare function createLogger(level?: LevelWithSilent): pino.Logger<never, boolean>;
+
+export { createLogger };

package/dist/common/logging.js

@@ -0,0 +1,12 @@
+import "../chunk-BIEQXUOY.js";
+import pino from "pino";
+import PinoPretty from "pino-pretty";
+function createLogger(level = "info") {
+  return pino(
+    { level },
+    PinoPretty({ ignore: "pid,hostname", translateTime: "SYS:standard" })
+  );
+}
+export {
+  createLogger
+};

package/dist/common/parse.cjs

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parse_exports = {};
+__export(parse_exports, {
+  granularityParser: () => granularityParser,
+  languageParser: () => languageParser,
+  loggingParser: () => loggingParser,
+  parallelismParser: () => parallelismParser
+});
+module.exports = __toCommonJS(parse_exports);
+var import_core = require("@optique/core");
+const loggingParser = (0, import_core.object)({
+  noProgress: (0, import_core.option)("--no-progress", {
+    description: import_core.message`Disable the progress bar`
+  }),
+  logLevel: (0, import_core.withDefault)(
+    (0, import_core.option)(
+      "--log-level",
+      (0, import_core.choice)(["silent", "debug", "info", "warn", "error"]),
+      {
+        description: import_core.message`Log level. If enabled, will disable progress bar.`
+      }
+    ),
+    "silent"
+  ),
+  time: (0, import_core.option)("--time", {
+    description: import_core.message`Whether to print timing statistics`
+  })
+});
+const granularityParser = (0, import_core.object)({
+  granularity: (0, import_core.withDefault)(
+    (0, import_core.option)("--granularity", "-g", (0, import_core.choice)(["word", "sentence"])),
+    "sentence"
+  )
+});
+const languageParser = (0, import_core.object)({
+  language: (0, import_core.optional)(
+    (0, import_core.option)("--language", (0, import_core.locale)(), {
+      description: import_core.message`BCP 47 language tag representing the primary language of the audio (e.g. en-US)`
+    })
+  )
+});
+const parallelismParser = (0, import_core.object)({
+  parallelism: (0, import_core.withDefault)(
+    (0, import_core.option)("--parallel", (0, import_core.integer)(), {
+      description: import_core.message`How many files to attempt to transcode in parallel.`
+    }),
+    1
+  )
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  granularityParser,
+  languageParser,
+  loggingParser,
+  parallelismParser
+});

package/dist/common/parse.d.cts

@@ -0,0 +1,28 @@
+import * as _optique_core from '@optique/core';
+
+declare const loggingParser: _optique_core.Parser<"sync", {
+    readonly noProgress: boolean;
+    readonly logLevel: "silent" | "debug" | "info" | "warn" | "error";
+    readonly time: boolean;
+}, {
+    readonly noProgress: _optique_core.ValueParserResult<boolean> | undefined;
+    readonly logLevel: [_optique_core.ValueParserResult<"silent" | "debug" | "info" | "warn" | "error"> | undefined] | undefined;
+    readonly time: _optique_core.ValueParserResult<boolean> | undefined;
+}>;
+declare const granularityParser: _optique_core.Parser<"sync", {
+    readonly granularity: "word" | "sentence";
+}, {
+    readonly granularity: [_optique_core.ValueParserResult<"word" | "sentence"> | undefined] | undefined;
+}>;
+declare const languageParser: _optique_core.Parser<"sync", {
+    readonly language: Intl.Locale | undefined;
+}, {
+    readonly language: [_optique_core.ValueParserResult<Intl.Locale> | undefined] | undefined;
+}>;
+declare const parallelismParser: _optique_core.Parser<"sync", {
+    readonly parallelism: number;
+}, {
+    readonly parallelism: [_optique_core.ValueParserResult<number> | undefined] | undefined;
+}>;
+
+export { granularityParser, languageParser, loggingParser, parallelismParser };