@bcts/dcbor-cli 1.0.0-alpha.13

package/dist/src-Ce085uR8.mjs

@@ -0,0 +1,407 @@
+import { bytesToHex, cborData, decodeCbor, diagnosticOpt, errorMsg, errorToString, hexOpt, hexToBytes, registerTags } from "@bcts/dcbor";
+import { composeDcborArray, composeDcborMap, composeErrorMessage, fullErrorMessage, parseDcborItem } from "@bcts/dcbor-parse";
+import { FormatPathsOptsBuilder, formatPathsWithCaptures, parse, pathsWithCaptures } from "@bcts/dcbor-pattern";
+
+//#region src/format.ts
+/**
+* Format utilities for dcbor-cli
+* Contains InputFormat, OutputFormat enums and formatOutput function
+* Equivalent to the format-related code in Rust's main.rs
+*/
+/**
+* Format CBOR output in the specified format
+* Equivalent to Rust's format_output function
+*/
+function formatOutput(cbor, outFormat, annotate) {
+	try {
+		switch (outFormat) {
+			case "diag": if (annotate) return {
+				ok: true,
+				value: diagnosticOpt(cbor, {
+					annotate: true,
+					flat: true
+				})
+			};
+			else return {
+				ok: true,
+				value: diagnosticOpt(cbor, { flat: true })
+			};
+			case "hex": if (annotate) return {
+				ok: true,
+				value: hexOpt(cbor, { annotate: true })
+			};
+			else return {
+				ok: true,
+				value: bytesToHex(cborData(cbor))
+			};
+			case "bin": return {
+				ok: true,
+				value: bytesToHex(cborData(cbor))
+			};
+			case "none": return {
+				ok: true,
+				value: ""
+			};
+			default: return {
+				ok: false,
+				error: errorMsg(`Unknown output format: ${outFormat}`)
+			};
+		}
+	} catch (e) {
+		return {
+			ok: false,
+			error: errorMsg(e instanceof Error ? e.message : String(e))
+		};
+	}
+}
+/**
+* Read binary data from a buffer
+*/
+function readData(data) {
+	return data;
+}
+/**
+* Read string data from a buffer
+*/
+function readString(data) {
+	return new TextDecoder().decode(data);
+}
+
+//#endregion
+//#region src/cmd/array.ts
+/**
+* Compose a dCBOR array from the provided elements
+* Equivalent to Rust's cmd/array.rs
+*/
+/**
+* Execute array command
+*/
+function execArray(args) {
+	const result = composeDcborArray(args.elements);
+	if (!result.ok) return {
+		ok: false,
+		error: errorMsg(composeErrorMessage(result.error))
+	};
+	return formatOutput(result.value, args.out, args.annotate);
+}
+/**
+* Create an Exec implementation for array command
+*/
+function createArrayCommand(args) {
+	return { exec: () => execArray(args) };
+}
+
+//#endregion
+//#region src/cmd/default.ts
+/**
+* Default parsing and validation behavior
+* Equivalent to Rust's cmd/default.rs
+*/
+/**
+* Execute default command with a reader function for stdin
+*/
+function execDefaultWithReader(args, readString$1, readData$1) {
+	let cbor;
+	try {
+		switch (args.in) {
+			case "diag":
+				if (args.input !== void 0) {
+					const result = parseDcborItem(args.input);
+					if (!result.ok) return {
+						ok: false,
+						error: errorMsg(fullErrorMessage(result.error, args.input))
+					};
+					cbor = result.value;
+				} else {
+					const diag = readString$1();
+					const result = parseDcborItem(diag);
+					if (!result.ok) return {
+						ok: false,
+						error: errorMsg(fullErrorMessage(result.error, diag))
+					};
+					cbor = result.value;
+				}
+				break;
+			case "hex":
+				if (args.input !== void 0) cbor = decodeCbor(hexToBytes(args.input));
+				else cbor = decodeCbor(hexToBytes(readString$1().trim()));
+				break;
+			case "bin":
+				cbor = decodeCbor(readData$1());
+				break;
+			default: return {
+				ok: false,
+				error: errorMsg(`Unknown input format: ${args.in}`)
+			};
+		}
+	} catch (e) {
+		return {
+			ok: false,
+			error: errorMsg(e instanceof Error ? e.message : String(e))
+		};
+	}
+	return formatOutput(cbor, args.out, args.annotate);
+}
+/**
+* Execute default command (reads from stdin if input not provided)
+*/
+function execDefault(args, stdinContent) {
+	return execDefaultWithReader(args, () => stdinContent ?? "", () => {
+		if (stdinContent) return new TextEncoder().encode(stdinContent);
+		return new Uint8Array(0);
+	});
+}
+/**
+* Create an Exec implementation for default command
+*/
+function createDefaultCommand(args, stdinContent) {
+	return { exec: () => execDefault(args, stdinContent) };
+}
+
+//#endregion
+//#region src/cmd/map.ts
+/**
+* Compose a dCBOR map from the provided keys and values
+* Equivalent to Rust's cmd/map.rs
+*/
+/**
+* Execute map command
+*/
+function execMap(args) {
+	const result = composeDcborMap(args.kvPairs);
+	if (!result.ok) return {
+		ok: false,
+		error: errorMsg(composeErrorMessage(result.error))
+	};
+	return formatOutput(result.value, args.out, args.annotate);
+}
+/**
+* Create an Exec implementation for map command
+*/
+function createMapCommand(args) {
+	return { exec: () => execMap(args) };
+}
+
+//#endregion
+//#region src/cmd/match.ts
+/**
+* Match dCBOR data against a pattern
+* Equivalent to Rust's cmd/match.rs
+*/
+/**
+* Format a parse error with context
+*/
+function formatPatternError(error, patternStr) {
+	switch (error.type) {
+		case "UnrecognizedToken": {
+			const start = Math.min(error.span.start, patternStr.length);
+			const end = Math.min(error.span.end, patternStr.length);
+			return `Failed to parse pattern at position ${start}..${end}: unrecognized token '${start < patternStr.length ? patternStr.slice(start, end) : "<end of input>"}'\nPattern: ${patternStr}\n         ${" ".repeat(start)}^`;
+		}
+		case "ExtraData": {
+			const start = Math.min(error.span.start, patternStr.length);
+			return `Failed to parse pattern: extra data at position ${start}\nPattern: ${patternStr}\n         ${" ".repeat(start)}^`;
+		}
+		case "UnexpectedToken": {
+			const start = Math.min(error.span.start, patternStr.length);
+			return `Failed to parse pattern at position ${start}: unexpected token\nPattern: ${patternStr}\n         ${" ".repeat(start)}^`;
+		}
+		default: return `Failed to parse pattern: ${error.type}`;
+	}
+}
+/**
+* Execute match command
+*/
+function execMatch(args, stdinContent) {
+	let inputData;
+	if (args.input !== void 0) inputData = new TextEncoder().encode(args.input);
+	else if (stdinContent !== void 0) inputData = new TextEncoder().encode(stdinContent);
+	else inputData = new Uint8Array(0);
+	let cbor;
+	try {
+		switch (args.in) {
+			case "diag": {
+				const inputStr = new TextDecoder().decode(inputData).trim();
+				const result = parseDcborItem(inputStr);
+				if (!result.ok) return {
+					ok: false,
+					error: errorMsg(fullErrorMessage(result.error, inputStr))
+				};
+				cbor = result.value;
+				break;
+			}
+			case "hex":
+				cbor = decodeCbor(hexToBytes(new TextDecoder().decode(inputData).trim()));
+				break;
+			case "bin":
+				cbor = decodeCbor(inputData);
+				break;
+			default: return {
+				ok: false,
+				error: errorMsg(`Unknown input format: ${args.in}`)
+			};
+		}
+	} catch (e) {
+		return {
+			ok: false,
+			error: errorMsg(e instanceof Error ? e.message : String(e))
+		};
+	}
+	const patternResult = parse(args.pattern);
+	if (!patternResult.ok) return {
+		ok: false,
+		error: errorMsg(formatPatternError(patternResult.error, args.pattern))
+	};
+	const pattern = patternResult.value;
+	const { paths, captures } = pathsWithCaptures(pattern, cbor);
+	if (paths.length === 0) return {
+		ok: false,
+		error: errorMsg("No match")
+	};
+	switch (args.out) {
+		case "paths": {
+			const formatOptions = FormatPathsOptsBuilder.new().indent(!args.noIndent).lastElementOnly(args.lastOnly).build();
+			if (args.captures) return {
+				ok: true,
+				value: formatPathsWithCaptures(paths, captures, formatOptions)
+			};
+			else return {
+				ok: true,
+				value: formatPathsWithCaptures(paths, /* @__PURE__ */ new Map(), formatOptions)
+			};
+		}
+		case "diag":
+		case "hex":
+		case "bin": {
+			const outputFormat = args.out;
+			const elementsToOutput = args.lastOnly ? paths.map((path) => path[path.length - 1]).filter(Boolean) : paths.map((path) => path[0]).filter(Boolean);
+			const results = [];
+			for (const element of elementsToOutput) {
+				const result = formatOutput(element, outputFormat, args.annotate);
+				if (!result.ok) return result;
+				results.push(result.value);
+			}
+			return {
+				ok: true,
+				value: results.join("\n")
+			};
+		}
+		default: return {
+			ok: false,
+			error: errorMsg(`Unknown output format: ${args.out}`)
+		};
+	}
+}
+/**
+* Create an Exec implementation for match command
+*/
+function createMatchCommand(args, stdinContent) {
+	return { exec: () => execMatch(args, stdinContent) };
+}
+
+//#endregion
+//#region src/run.ts
+/**
+* Main run function for dcbor-cli
+* Equivalent to Rust's run function in main.rs
+*/
+/**
+* Main execution function
+* Equivalent to Rust's run<I, T, R, W> function
+*/
+function run(options) {
+	registerTags();
+	const { command, stdinContent } = options;
+	let output;
+	let isBinary = false;
+	switch (command.type) {
+		case "array": {
+			const result = execArray({
+				elements: command.elements,
+				out: command.out,
+				annotate: command.annotate
+			});
+			if (!result.ok) return {
+				ok: false,
+				error: new Error(errorToString(result.error))
+			};
+			output = result.value;
+			isBinary = command.out === "bin";
+			break;
+		}
+		case "map": {
+			const result = execMap({
+				kvPairs: command.kvPairs,
+				out: command.out,
+				annotate: command.annotate
+			});
+			if (!result.ok) return {
+				ok: false,
+				error: new Error(errorToString(result.error))
+			};
+			output = result.value;
+			isBinary = command.out === "bin";
+			break;
+		}
+		case "match": {
+			const result = execMatch({
+				pattern: command.pattern,
+				input: command.input,
+				in: command.in,
+				out: command.out,
+				noIndent: command.noIndent,
+				lastOnly: command.lastOnly,
+				annotate: command.annotate,
+				captures: command.captures
+			}, stdinContent);
+			if (!result.ok) return {
+				ok: false,
+				error: new Error(errorToString(result.error))
+			};
+			output = result.value;
+			isBinary = command.out === "bin";
+			break;
+		}
+		case "default": {
+			const result = execDefault({
+				input: command.input,
+				in: command.in,
+				out: command.out,
+				annotate: command.annotate
+			}, stdinContent);
+			if (!result.ok) return {
+				ok: false,
+				error: new Error(errorToString(result.error))
+			};
+			output = result.value;
+			isBinary = command.out === "bin";
+			break;
+		}
+		default: return {
+			ok: false,
+			error: /* @__PURE__ */ new Error("Unknown command type")
+		};
+	}
+	return {
+		ok: true,
+		value: {
+			output,
+			isBinary
+		}
+	};
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* @bcts/dcbor-cli - Command line parser/validator for deterministic CBOR (dCBOR)
+*
+* A command line tool for composing, parsing and validating Gordian dCBOR.
+*
+* @packageDocumentation
+*/
+const VERSION = "1.0.0-alpha.13";
+
+//#endregion
+export { createMapCommand as a, execDefault as c, execArray as d, formatOutput as f, execMatch as i, execDefaultWithReader as l, readString as m, run as n, execMap as o, readData as p, createMatchCommand as r, createDefaultCommand as s, VERSION as t, createArrayCommand as u };
+//# sourceMappingURL=src-Ce085uR8.mjs.map

package/dist/src-Ce085uR8.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"src-Ce085uR8.mjs","names":["cbor: Cbor","readString","readData","inputData: Uint8Array","cbor: Cbor","parsePattern","outputFormat: OutputFormat","results: string[]","output: string"],"sources":["../src/format.ts","../src/cmd/array.ts","../src/cmd/default.ts","../src/cmd/map.ts","../src/cmd/match.ts","../src/run.ts","../src/index.ts"],"sourcesContent":["/**\n * Format utilities for dcbor-cli\n * Contains InputFormat, OutputFormat enums and formatOutput function\n * Equivalent to the format-related code in Rust's main.rs\n */\n/* eslint-disable @typescript-eslint/restrict-template-expressions */\n\nimport {\n  type Cbor,\n  type Result,\n  diagnosticOpt,\n  hexOpt,\n  bytesToHex,\n  cborData,\n  errorMsg,\n} from \"@bcts/dcbor\";\n\n/**\n * Input format options\n */\nexport type InputFormat = \"diag\" | \"hex\" | \"bin\";\n\n/**\n * Output format options\n */\nexport type OutputFormat = \"diag\" | \"hex\" | \"bin\" | \"none\";\n\n/**\n * Format CBOR output in the specified format\n * Equivalent to Rust's format_output function\n */\nexport function formatOutput(\n  cbor: Cbor,\n  outFormat: OutputFormat,\n  annotate: boolean,\n): Result<string> {\n  try {\n    switch (outFormat) {\n      case \"diag\":\n        // Use flat: true for compact single-line output (matching Rust CLI behavior)\n        if (annotate) {\n          return { ok: true, value: diagnosticOpt(cbor, { annotate: true, flat: true }) };\n        } else {\n          return { ok: true, value: diagnosticOpt(cbor, { flat: true }) };\n        }\n\n      case \"hex\":\n        if (annotate) {\n          return { ok: true, value: hexOpt(cbor, { annotate: true }) };\n        } else {\n          return { ok: true, value: bytesToHex(cborData(cbor)) };\n        }\n\n      case \"bin\":\n        // For binary output, return hex representation\n        // The caller will handle converting to actual binary\n        return { ok: true, value: bytesToHex(cborData(cbor)) };\n\n      case \"none\":\n        return { ok: true, value: \"\" };\n\n      default:\n        return { ok: false, error: errorMsg(`Unknown output format: ${outFormat}`) };\n    }\n  } catch (e) {\n    return { ok: false, error: errorMsg(e instanceof Error ? e.message : String(e)) };\n  }\n}\n\n/**\n * Read binary data from a buffer\n */\nexport function readData(data: Uint8Array): Uint8Array {\n  return data;\n}\n\n/**\n * Read string data from a buffer\n */\nexport function readString(data: Uint8Array): string {\n  return new TextDecoder().decode(data);\n}\n","/**\n * Compose a dCBOR array from the provided elements\n * Equivalent to Rust's cmd/array.rs\n */\n\nimport { type Result, errorMsg } from \"@bcts/dcbor\";\nimport { composeDcborArray, composeErrorMessage } from \"@bcts/dcbor-parse\";\nimport type { Exec } from \"./index.js\";\nimport { type OutputFormat, formatOutput } from \"../format.js\";\n\n/**\n * Command arguments for array composition\n */\nexport interface ArrayCommandArgs {\n  /** Each element is parsed as a dCBOR item in diagnostic notation */\n  elements: string[];\n  /** The output format (default: hex) */\n  out: OutputFormat;\n  /** Output with annotations */\n  annotate: boolean;\n}\n\n/**\n * Execute array command\n */\nexport function execArray(args: ArrayCommandArgs): Result<string> {\n  const result = composeDcborArray(args.elements);\n  if (!result.ok) {\n    return { ok: false, error: errorMsg(composeErrorMessage(result.error)) };\n  }\n  return formatOutput(result.value, args.out, args.annotate);\n}\n\n/**\n * Create an Exec implementation for array command\n */\nexport function createArrayCommand(args: ArrayCommandArgs): Exec {\n  return {\n    exec: () => execArray(args),\n  };\n}\n","/**\n * Default parsing and validation behavior\n * Equivalent to Rust's cmd/default.rs\n */\n/* eslint-disable @typescript-eslint/restrict-template-expressions, @typescript-eslint/strict-boolean-expressions */\n\nimport { type Cbor, type Result, decodeCbor, hexToBytes, errorMsg } from \"@bcts/dcbor\";\nimport { parseDcborItem, fullErrorMessage } from \"@bcts/dcbor-parse\";\nimport type { Exec } from \"./index.js\";\nimport { type InputFormat, type OutputFormat, formatOutput } from \"../format.js\";\n\n/**\n * Command arguments for default parsing behavior\n */\nexport interface DefaultCommandArgs {\n  /** Input dCBOR in the format specified by `in`. Optional - reads from stdin if not provided */\n  input?: string | undefined;\n  /** The input format (default: diag) */\n  in: InputFormat;\n  /** The output format (default: hex) */\n  out: OutputFormat;\n  /** Output with annotations */\n  annotate: boolean;\n}\n\n/**\n * Execute default command with a reader function for stdin\n */\nexport function execDefaultWithReader(\n  args: DefaultCommandArgs,\n  readString: () => string,\n  readData: () => Uint8Array,\n): Result<string> {\n  let cbor: Cbor;\n\n  try {\n    switch (args.in) {\n      case \"diag\": {\n        if (args.input !== undefined) {\n          const result = parseDcborItem(args.input);\n          if (!result.ok) {\n            return {\n              ok: false,\n              error: errorMsg(fullErrorMessage(result.error, args.input)),\n            };\n          }\n          cbor = result.value;\n        } else {\n          const diag = readString();\n          const result = parseDcborItem(diag);\n          if (!result.ok) {\n            return {\n              ok: false,\n              error: errorMsg(fullErrorMessage(result.error, diag)),\n            };\n          }\n          cbor = result.value;\n        }\n        break;\n      }\n      case \"hex\": {\n        if (args.input !== undefined) {\n          cbor = decodeCbor(hexToBytes(args.input));\n        } else {\n          const hexStr = readString().trim();\n          cbor = decodeCbor(hexToBytes(hexStr));\n        }\n        break;\n      }\n      case \"bin\": {\n        const data = readData();\n        cbor = decodeCbor(data);\n        break;\n      }\n      default:\n        return { ok: false, error: errorMsg(`Unknown input format: ${args.in}`) };\n    }\n  } catch (e) {\n    return { ok: false, error: errorMsg(e instanceof Error ? e.message : String(e)) };\n  }\n\n  return formatOutput(cbor, args.out, args.annotate);\n}\n\n/**\n * Execute default command (reads from stdin if input not provided)\n */\nexport function execDefault(args: DefaultCommandArgs, stdinContent?: string): Result<string> {\n  return execDefaultWithReader(\n    args,\n    () => stdinContent ?? \"\",\n    () => {\n      if (stdinContent) {\n        return new TextEncoder().encode(stdinContent);\n      }\n      return new Uint8Array(0);\n    },\n  );\n}\n\n/**\n * Create an Exec implementation for default command\n */\nexport function createDefaultCommand(args: DefaultCommandArgs, stdinContent?: string): Exec {\n  return {\n    exec: () => execDefault(args, stdinContent),\n  };\n}\n","/**\n * Compose a dCBOR map from the provided keys and values\n * Equivalent to Rust's cmd/map.rs\n */\n\nimport { type Result, errorMsg } from \"@bcts/dcbor\";\nimport { composeDcborMap, composeErrorMessage } from \"@bcts/dcbor-parse\";\nimport type { Exec } from \"./index.js\";\nimport { type OutputFormat, formatOutput } from \"../format.js\";\n\n/**\n * Command arguments for map composition\n */\nexport interface MapCommandArgs {\n  /** Alternating keys and values parsed as dCBOR items in diagnostic notation */\n  kvPairs: string[];\n  /** The output format (default: hex) */\n  out: OutputFormat;\n  /** Output with annotations */\n  annotate: boolean;\n}\n\n/**\n * Execute map command\n */\nexport function execMap(args: MapCommandArgs): Result<string> {\n  const result = composeDcborMap(args.kvPairs);\n  if (!result.ok) {\n    return { ok: false, error: errorMsg(composeErrorMessage(result.error)) };\n  }\n  return formatOutput(result.value, args.out, args.annotate);\n}\n\n/**\n * Create an Exec implementation for map command\n */\nexport function createMapCommand(args: MapCommandArgs): Exec {\n  return {\n    exec: () => execMap(args),\n  };\n}\n","/**\n * Match dCBOR data against a pattern\n * Equivalent to Rust's cmd/match.rs\n */\n/* eslint-disable @typescript-eslint/restrict-template-expressions, @typescript-eslint/switch-exhaustiveness-check */\n\nimport { type Cbor, type Result, decodeCbor, hexToBytes, errorMsg } from \"@bcts/dcbor\";\nimport { parseDcborItem, fullErrorMessage } from \"@bcts/dcbor-parse\";\nimport {\n  parse as parsePattern,\n  pathsWithCaptures,\n  formatPathsWithCaptures,\n  FormatPathsOptsBuilder,\n  type Error as PatternParseError,\n} from \"@bcts/dcbor-pattern\";\nimport type { Exec } from \"./index.js\";\nimport { type OutputFormat, formatOutput } from \"../format.js\";\nimport type { InputFormat } from \"../format.js\";\n\n/**\n * Match output format options\n */\nexport type MatchOutputFormat = \"paths\" | \"diag\" | \"hex\" | \"bin\";\n\n/**\n * Command arguments for match command\n */\nexport interface MatchCommandArgs {\n  /** The pattern to match against */\n  pattern: string;\n  /** dCBOR input (hex, diag, or binary). If not provided, reads from stdin */\n  input?: string | undefined;\n  /** Input format (default: diag) */\n  in: InputFormat;\n  /** Output format (default: paths) */\n  out: MatchOutputFormat;\n  /** Disable indentation of path elements */\n  noIndent: boolean;\n  /** Show only the last element of each path */\n  lastOnly: boolean;\n  /** Add annotations to output */\n  annotate: boolean;\n  /** Include capture information in output */\n  captures: boolean;\n}\n\n/**\n * Format a parse error with context\n */\nfunction formatPatternError(error: PatternParseError, patternStr: string): string {\n  switch (error.type) {\n    case \"UnrecognizedToken\": {\n      const start = Math.min(error.span.start, patternStr.length);\n      const end = Math.min(error.span.end, patternStr.length);\n      const errorText = start < patternStr.length ? patternStr.slice(start, end) : \"<end of input>\";\n      return `Failed to parse pattern at position ${start}..${end}: unrecognized token '${errorText}'\\nPattern: ${patternStr}\\n         ${\" \".repeat(start)}^`;\n    }\n\n    case \"ExtraData\": {\n      const start = Math.min(error.span.start, patternStr.length);\n      return `Failed to parse pattern: extra data at position ${start}\\nPattern: ${patternStr}\\n         ${\" \".repeat(start)}^`;\n    }\n\n    case \"UnexpectedToken\": {\n      const start = Math.min(error.span.start, patternStr.length);\n      return `Failed to parse pattern at position ${start}: unexpected token\\nPattern: ${patternStr}\\n         ${\" \".repeat(start)}^`;\n    }\n\n    default:\n      return `Failed to parse pattern: ${error.type}`;\n  }\n}\n\n/**\n * Execute match command\n */\nexport function execMatch(args: MatchCommandArgs, stdinContent?: string): Result<string> {\n  // Read input data\n  let inputData: Uint8Array;\n  if (args.input !== undefined) {\n    inputData = new TextEncoder().encode(args.input);\n  } else if (stdinContent !== undefined) {\n    inputData = new TextEncoder().encode(stdinContent);\n  } else {\n    inputData = new Uint8Array(0);\n  }\n\n  // Parse input based on format\n  let cbor: Cbor;\n  try {\n    switch (args.in) {\n      case \"diag\": {\n        const inputStr = new TextDecoder().decode(inputData).trim();\n        const result = parseDcborItem(inputStr);\n        if (!result.ok) {\n          return {\n            ok: false,\n            error: errorMsg(fullErrorMessage(result.error, inputStr)),\n          };\n        }\n        cbor = result.value;\n        break;\n      }\n      case \"hex\": {\n        const inputStr = new TextDecoder().decode(inputData).trim();\n        cbor = decodeCbor(hexToBytes(inputStr));\n        break;\n      }\n      case \"bin\": {\n        cbor = decodeCbor(inputData);\n        break;\n      }\n      default:\n        return { ok: false, error: errorMsg(`Unknown input format: ${args.in}`) };\n    }\n  } catch (e) {\n    return { ok: false, error: errorMsg(e instanceof Error ? e.message : String(e)) };\n  }\n\n  // Parse pattern\n  const patternResult = parsePattern(args.pattern);\n  if (!patternResult.ok) {\n    return {\n      ok: false,\n      error: errorMsg(formatPatternError(patternResult.error, args.pattern)),\n    };\n  }\n  const pattern = patternResult.value;\n\n  // Execute pattern matching\n  const { paths, captures } = pathsWithCaptures(pattern, cbor);\n\n  // Check for matches\n  if (paths.length === 0) {\n    return { ok: false, error: errorMsg(\"No match\") };\n  }\n\n  // Format output based on requested format\n  switch (args.out) {\n    case \"paths\": {\n      // Build format options from command line arguments\n      const formatOptions = FormatPathsOptsBuilder.new()\n        .indent(!args.noIndent)\n        .lastElementOnly(args.lastOnly)\n        .build();\n\n      // Show captures only if explicitly requested\n      if (args.captures) {\n        return {\n          ok: true,\n          value: formatPathsWithCaptures(paths, captures, formatOptions),\n        };\n      } else {\n        // Show paths without captures\n        return {\n          ok: true,\n          value: formatPathsWithCaptures(paths, new Map(), formatOptions),\n        };\n      }\n    }\n\n    case \"diag\":\n    case \"hex\":\n    case \"bin\": {\n      // For data format outputs, extract the matched elements\n      const outputFormat: OutputFormat = args.out;\n\n      const elementsToOutput = args.lastOnly\n        ? paths.map((path) => path[path.length - 1]).filter(Boolean)\n        : paths.map((path) => path[0]).filter(Boolean);\n\n      const results: string[] = [];\n      for (const element of elementsToOutput) {\n        const result = formatOutput(element, outputFormat, args.annotate);\n        if (!result.ok) {\n          return result;\n        }\n        results.push(result.value);\n      }\n\n      return { ok: true, value: results.join(\"\\n\") };\n    }\n\n    default:\n      return { ok: false, error: errorMsg(`Unknown output format: ${args.out}`) };\n  }\n}\n\n/**\n * Create an Exec implementation for match command\n */\nexport function createMatchCommand(args: MatchCommandArgs, stdinContent?: string): Exec {\n  return {\n    exec: () => execMatch(args, stdinContent),\n  };\n}\n","/**\n * Main run function for dcbor-cli\n * Equivalent to Rust's run function in main.rs\n */\n\nimport { registerTags, errorToString } from \"@bcts/dcbor\";\nimport type { InputFormat, OutputFormat } from \"./format.js\";\nimport { execArray, execDefault, execMap, execMatch, type MatchOutputFormat } from \"./cmd/index.js\";\n\n/**\n * Command type discriminator\n */\nexport type Command =\n  | { type: \"array\"; elements: string[]; out: OutputFormat; annotate: boolean }\n  | { type: \"map\"; kvPairs: string[]; out: OutputFormat; annotate: boolean }\n  | {\n      type: \"match\";\n      pattern: string;\n      input?: string | undefined;\n      in: InputFormat;\n      out: MatchOutputFormat;\n      noIndent: boolean;\n      lastOnly: boolean;\n      annotate: boolean;\n      captures: boolean;\n    }\n  | {\n      type: \"default\";\n      input?: string | undefined;\n      in: InputFormat;\n      out: OutputFormat;\n      annotate: boolean;\n    };\n\nexport interface RunOptions {\n  command: Command;\n  stdinContent?: string | undefined;\n}\n\nexport interface RunResult {\n  output: string;\n  isBinary: boolean;\n}\n\n/**\n * Main execution function\n * Equivalent to Rust's run<I, T, R, W> function\n */\nexport function run(\n  options: RunOptions,\n): { ok: true; value: RunResult } | { ok: false; error: Error } {\n  // Register BC components tags\n  registerTags();\n\n  const { command, stdinContent } = options;\n\n  let output: string;\n  let isBinary = false;\n\n  switch (command.type) {\n    case \"array\": {\n      const result = execArray({\n        elements: command.elements,\n        out: command.out,\n        annotate: command.annotate,\n      });\n      if (!result.ok) {\n        return { ok: false, error: new Error(errorToString(result.error)) };\n      }\n      output = result.value;\n      isBinary = command.out === \"bin\";\n      break;\n    }\n\n    case \"map\": {\n      const result = execMap({\n        kvPairs: command.kvPairs,\n        out: command.out,\n        annotate: command.annotate,\n      });\n      if (!result.ok) {\n        return { ok: false, error: new Error(errorToString(result.error)) };\n      }\n      output = result.value;\n      isBinary = command.out === \"bin\";\n      break;\n    }\n\n    case \"match\": {\n      const result = execMatch(\n        {\n          pattern: command.pattern,\n          input: command.input,\n          in: command.in,\n          out: command.out,\n          noIndent: command.noIndent,\n          lastOnly: command.lastOnly,\n          annotate: command.annotate,\n          captures: command.captures,\n        },\n        stdinContent,\n      );\n      if (!result.ok) {\n        return { ok: false, error: new Error(errorToString(result.error)) };\n      }\n      output = result.value;\n      isBinary = command.out === \"bin\";\n      break;\n    }\n\n    case \"default\": {\n      const result = execDefault(\n        {\n          input: command.input,\n          in: command.in,\n          out: command.out,\n          annotate: command.annotate,\n        },\n        stdinContent,\n      );\n      if (!result.ok) {\n        return { ok: false, error: new Error(errorToString(result.error)) };\n      }\n      output = result.value;\n      isBinary = command.out === \"bin\";\n      break;\n    }\n\n    default:\n      return { ok: false, error: new Error(\"Unknown command type\") };\n  }\n\n  return { ok: true, value: { output, isBinary } };\n}\n","/**\n * @bcts/dcbor-cli - Command line parser/validator for deterministic CBOR (dCBOR)\n *\n * A command line tool for composing, parsing and validating Gordian dCBOR.\n *\n * @packageDocumentation\n */\n\nexport const VERSION = \"1.0.0-alpha.13\";\n\n// Export format utilities\nexport { formatOutput, readData, readString } from \"./format.js\";\nexport type { InputFormat, OutputFormat } from \"./format.js\";\n\n// Export command modules\nexport {\n  // Exec interface\n  type Exec,\n  // Array command\n  type ArrayCommandArgs,\n  execArray,\n  createArrayCommand,\n  // Map command\n  type MapCommandArgs,\n  execMap,\n  createMapCommand,\n  // Default command\n  type DefaultCommandArgs,\n  execDefault,\n  execDefaultWithReader,\n  createDefaultCommand,\n  // Match command\n  type MatchOutputFormat,\n  type MatchCommandArgs,\n  execMatch,\n  createMatchCommand,\n} from \"./cmd/index.js\";\n\n// Export the run function for programmatic use\nexport { run } from \"./run.js\";\nexport type { RunOptions, RunResult, Command } from \"./run.js\";\n"],"mappings":"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"}