@stryke/capnp 0.3.0 → 0.4.0

package/bin/capnpc.js

@@ -0,0 +1,1146 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// bin/capnpc.ts
+import { writeFatal, writeInfo, writeSuccess } from "@storm-software/config-tools/logger/console";
+import { exitWithError, exitWithSuccess, findWorkspaceRootSafe as findWorkspaceRootSafe2, handleProcess } from "@storm-software/config-tools/utilities";
+
+// ../fs/src/list-files.ts
+import defu from "defu";
+import { glob } from "glob";
+var DEFAULT_OPTIONS = {
+  dot: true
+};
+async function list(filesGlob, options) {
+  return glob(filesGlob, defu(options ?? {}, DEFAULT_OPTIONS));
+}
+__name(list, "list");
+async function listFiles(filesGlob, options) {
+  const result = (await list(filesGlob, defu({
+    withFileTypes: true
+  }, options ?? {}))).filter((ret) => ret.isFile());
+  if (!options?.withFileTypes) {
+    return result.map((file) => file.fullpath());
+  }
+  return result;
+}
+__name(listFiles, "listFiles");
+
+// ../fs/src/read-file.ts
+import { parse as parseToml } from "@ltd/j-toml";
+
+// ../type-checks/src/get-object-tag.ts
+var getObjectTag = /* @__PURE__ */ __name((value) => {
+  if (value == null) {
+    return value === void 0 ? "[object Undefined]" : "[object Null]";
+  }
+  return Object.prototype.toString.call(value);
+}, "getObjectTag");
+
+// ../type-checks/src/is-plain-object.ts
+var isObjectLike = /* @__PURE__ */ __name((obj) => {
+  return typeof obj === "object" && obj !== null;
+}, "isObjectLike");
+var isPlainObject = /* @__PURE__ */ __name((obj) => {
+  if (!isObjectLike(obj) || getObjectTag(obj) !== "[object Object]") {
+    return false;
+  }
+  if (Object.getPrototypeOf(obj) === null) {
+    return true;
+  }
+  let proto = obj;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(obj) === proto;
+}, "isPlainObject");
+
+// ../type-checks/src/is-object.ts
+var isObject = /* @__PURE__ */ __name((value) => {
+  try {
+    return typeof value === "object" || Boolean(value) && value?.constructor === Object || isPlainObject(value);
+  } catch {
+    return false;
+  }
+}, "isObject");
+
+// ../type-checks/src/is-string.ts
+var isString = /* @__PURE__ */ __name((value) => {
+  try {
+    return typeof value === "string";
+  } catch {
+    return false;
+  }
+}, "isString");
+
+// ../json/src/storm-json.ts
+import { parse as parse2 } from "jsonc-parser";
+import { Buffer as Buffer2 } from "node:buffer";
+import SuperJSON from "superjson";
+
+// ../types/src/base.ts
+var EMPTY_STRING = "";
+var $NestedValue = Symbol("NestedValue");
+
+// ../json/src/utils/strip-comments.ts
+var singleComment = Symbol("singleComment");
+var multiComment = Symbol("multiComment");
+function stripWithoutWhitespace() {
+  return "";
+}
+__name(stripWithoutWhitespace, "stripWithoutWhitespace");
+function stripWithWhitespace(value, start, end) {
+  return value.slice(start, end).replace(/\S/g, " ");
+}
+__name(stripWithWhitespace, "stripWithWhitespace");
+function isEscaped(value, quotePosition) {
+  let index = quotePosition - 1;
+  let backslashCount = 0;
+  while (value[index] === "\\") {
+    index -= 1;
+    backslashCount += 1;
+  }
+  return Boolean(backslashCount % 2);
+}
+__name(isEscaped, "isEscaped");
+function stripComments(value, { whitespace = true, trailingCommas = false } = {}) {
+  if (typeof value !== "string") {
+    throw new TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof value}\``);
+  }
+  const strip = whitespace ? stripWithWhitespace : stripWithoutWhitespace;
+  let isInsideString = false;
+  let isInsideComment = false;
+  let offset = 0;
+  let buffer = "";
+  let result = "";
+  let commaIndex = -1;
+  for (let index = 0; index < value.length; index++) {
+    const currentCharacter = value[index];
+    const nextCharacter = value[index + 1];
+    if (!isInsideComment && currentCharacter === '"') {
+      const escaped = isEscaped(value, index);
+      if (!escaped) {
+        isInsideString = !isInsideString;
+      }
+    }
+    if (isInsideString) {
+      continue;
+    }
+    if (!isInsideComment && currentCharacter + (nextCharacter ?? EMPTY_STRING) === "//") {
+      buffer += value.slice(offset, index);
+      offset = index;
+      isInsideComment = singleComment;
+      index++;
+    } else if (isInsideComment === singleComment && currentCharacter + (nextCharacter ?? EMPTY_STRING) === "\r\n") {
+      index++;
+      isInsideComment = false;
+      buffer += strip(value, offset, index);
+      offset = index;
+    } else if (isInsideComment === singleComment && currentCharacter === "\n") {
+      isInsideComment = false;
+      buffer += strip(value, offset, index);
+      offset = index;
+    } else if (!isInsideComment && currentCharacter + (nextCharacter ?? EMPTY_STRING) === "/*") {
+      buffer += value.slice(offset, index);
+      offset = index;
+      isInsideComment = multiComment;
+      index++;
+    } else if (isInsideComment === multiComment && currentCharacter + (nextCharacter ?? EMPTY_STRING) === "*/") {
+      index++;
+      isInsideComment = false;
+      buffer += strip(value, offset, index + 1);
+      offset = index + 1;
+    } else if (trailingCommas && !isInsideComment) {
+      if (commaIndex !== -1) {
+        if (currentCharacter === "}" || currentCharacter === "]") {
+          buffer += value.slice(offset, index);
+          result += strip(buffer, 0, 1) + buffer.slice(1);
+          buffer = "";
+          offset = index;
+          commaIndex = -1;
+        } else if (currentCharacter !== " " && currentCharacter !== "	" && currentCharacter !== "\r" && currentCharacter !== "\n") {
+          buffer += value.slice(offset, index);
+          offset = index;
+          commaIndex = -1;
+        }
+      } else if (currentCharacter === ",") {
+        result += buffer + value.slice(offset, index);
+        buffer = "";
+        offset = index;
+        commaIndex = index;
+      }
+    }
+  }
+  return result + buffer + (isInsideComment ? strip(value.slice(offset)) : value.slice(offset));
+}
+__name(stripComments, "stripComments");
+
+// ../json/src/utils/parse.ts
+var suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
+var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+var JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(?:\.\d{1,17})?(?:E[+-]?\d+)?\s*$/i;
+function jsonParseTransform(key, value) {
+  if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
+    console.warn(`Dropping "${key}" key to prevent prototype pollution.`);
+    return;
+  }
+  return value;
+}
+__name(jsonParseTransform, "jsonParseTransform");
+function parse(value, options = {}) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  let stripped = stripComments(value);
+  if (stripped[0] === '"' && stripped[stripped.length - 1] === '"' && !stripped.includes("\\")) {
+    return stripped.slice(1, -1);
+  }
+  stripped = stripped.trim();
+  if (stripped.length <= 9) {
+    switch (stripped.toLowerCase()) {
+      case "true": {
+        return true;
+      }
+      case "false": {
+        return false;
+      }
+      case "undefined": {
+        return void 0;
+      }
+      case "null": {
+        return null;
+      }
+      case "nan": {
+        return Number.NaN;
+      }
+      case "infinity": {
+        return Number.POSITIVE_INFINITY;
+      }
+      case "-infinity": {
+        return Number.NEGATIVE_INFINITY;
+      }
+    }
+  }
+  if (!JsonSigRx.test(stripped)) {
+    if (options.strict) {
+      throw new Error("Invalid JSON");
+    }
+    return stripped;
+  }
+  try {
+    if (suspectProtoRx.test(stripped) || suspectConstructorRx.test(stripped)) {
+      if (options.strict) {
+        throw new Error("Possible prototype pollution");
+      }
+      return JSON.parse(stripped, jsonParseTransform);
+    }
+    return JSON.parse(stripped);
+  } catch (error) {
+    if (options.strict) {
+      throw error;
+    }
+    return value;
+  }
+}
+__name(parse, "parse");
+
+// ../json/src/utils/parse-error.ts
+import { printParseErrorCode } from "jsonc-parser";
+import { LinesAndColumns } from "lines-and-columns";
+
+// ../json/src/utils/code-frames.ts
+var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+function getMarkerLines(loc, source, opts = {}) {
+  const startLoc = {
+    column: 0,
+    line: -1,
+    ...loc.start
+  };
+  const endLoc = {
+    ...startLoc,
+    ...loc.end
+  };
+  const { linesAbove = 2, linesBelow = 3 } = opts || {};
+  const startLine = startLoc.line;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line;
+  const endColumn = endLoc.column;
+  let start = Math.max(startLine - (linesAbove + 1), 0);
+  let end = Math.min(source.length, endLine + linesBelow);
+  if (startLine === -1) {
+    start = 0;
+  }
+  if (endLine === -1) {
+    end = source.length;
+  }
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
+  if (lineDiff) {
+    for (let i = 0; i <= lineDiff; i++) {
+      const lineNumber = i + startLine;
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (i === 0) {
+        const sourceLength = source[lineNumber - 1]?.length ?? 0;
+        markerLines[lineNumber] = [
+          startColumn,
+          sourceLength - startColumn + 1
+        ];
+      } else if (i === lineDiff) {
+        markerLines[lineNumber] = [
+          0,
+          endColumn
+        ];
+      } else {
+        const sourceLength = source[lineNumber - i]?.length ?? 0;
+        markerLines[lineNumber] = [
+          0,
+          sourceLength
+        ];
+      }
+    }
+  } else if (startColumn === endColumn) {
+    markerLines[startLine] = startColumn ? [
+      startColumn,
+      0
+    ] : true;
+  } else {
+    markerLines[startLine] = [
+      startColumn,
+      endColumn - startColumn
+    ];
+  }
+  return {
+    start,
+    end,
+    markerLines
+  };
+}
+__name(getMarkerLines, "getMarkerLines");
+function codeFrameColumns(rawLines, loc, opts = {}) {
+  const lines = rawLines.split(NEWLINE);
+  const { start, end, markerLines } = getMarkerLines(loc, lines, opts);
+  const numberMaxWidth = String(end).length;
+  const highlightedLines = opts.highlight ? opts.highlight(rawLines) : rawLines;
+  const frame = highlightedLines.split(NEWLINE).slice(start, end).map((line, index) => {
+    const number = start + 1 + index;
+    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+    const gutter = ` ${paddedNumber} | `;
+    const hasMarker = Boolean(markerLines[number] ?? false);
+    if (hasMarker) {
+      let markerLine = "";
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = [
+          "\n ",
+          gutter.replace(/\d/g, " "),
+          markerSpacing,
+          "^".repeat(numberOfMarkers)
+        ].join("");
+      }
+      return [
+        ">",
+        gutter,
+        line,
+        markerLine
+      ].join("");
+    }
+    return ` ${gutter}${line}`;
+  }).join("\n");
+  return frame;
+}
+__name(codeFrameColumns, "codeFrameColumns");
+
+// ../json/src/utils/parse-error.ts
+function formatParseError(input, parseError) {
+  const { error, offset, length } = parseError;
+  const result = new LinesAndColumns(input).locationForIndex(offset);
+  let line = result?.line ?? 0;
+  let column = result?.column ?? 0;
+  line++;
+  column++;
+  return `${printParseErrorCode(error)} in JSON at ${line}:${column}
+${codeFrameColumns(input, {
+    start: {
+      line,
+      column
+    },
+    end: {
+      line,
+      column: column + length
+    }
+  })}
+`;
+}
+__name(formatParseError, "formatParseError");
+
+// ../type-checks/src/is-number.ts
+var isNumber = /* @__PURE__ */ __name((value) => {
+  try {
+    return value instanceof Number || typeof value === "number" || Number(value) === value;
+  } catch {
+    return false;
+  }
+}, "isNumber");
+
+// ../type-checks/src/is-undefined.ts
+var isUndefined = /* @__PURE__ */ __name((value) => {
+  return value === void 0;
+}, "isUndefined");
+
+// ../json/src/utils/stringify.ts
+var invalidKeyChars = [
+  "@",
+  "/",
+  "#",
+  "$",
+  " ",
+  ":",
+  ";",
+  ",",
+  ".",
+  "!",
+  "?",
+  "&",
+  "=",
+  "+",
+  "-",
+  "*",
+  "%",
+  "^",
+  "~",
+  "|",
+  "\\",
+  '"',
+  "'",
+  "`",
+  "{",
+  "}",
+  "[",
+  "]",
+  "(",
+  ")",
+  "<",
+  ">"
+];
+var stringify = /* @__PURE__ */ __name((value, spacing = 2) => {
+  const space = isNumber(spacing) ? " ".repeat(spacing) : spacing;
+  switch (value) {
+    case null: {
+      return "null";
+    }
+    case void 0: {
+      return '"undefined"';
+    }
+    case true: {
+      return "true";
+    }
+    case false: {
+      return "false";
+    }
+    case Number.POSITIVE_INFINITY: {
+      return "infinity";
+    }
+    case Number.NEGATIVE_INFINITY: {
+      return "-infinity";
+    }
+  }
+  if (Array.isArray(value)) {
+    return `[${space}${value.map((v) => stringify(v, space)).join(`,${space}`)}${space}]`;
+  }
+  if (value instanceof Uint8Array) {
+    return value.toString();
+  }
+  switch (typeof value) {
+    case "number": {
+      return `${value}`;
+    }
+    case "string": {
+      return JSON.stringify(value);
+    }
+    case "object": {
+      const keys = Object.keys(value).filter((key) => !isUndefined(value[key]));
+      return `{${space}${keys.map((key) => `${invalidKeyChars.some((invalidKeyChar) => key.includes(invalidKeyChar)) ? `"${key}"` : key}: ${space}${stringify(value[key], space)}`).join(`,${space}`)}${space}}`;
+    }
+    default:
+      return "null";
+  }
+}, "stringify");
+
+// ../json/src/storm-json.ts
+var StormJSON = class _StormJSON extends SuperJSON {
+  static {
+    __name(this, "StormJSON");
+  }
+  static #instance;
+  static get instance() {
+    if (!_StormJSON.#instance) {
+      _StormJSON.#instance = new _StormJSON();
+    }
+    return _StormJSON.#instance;
+  }
+  /**
+  * Deserialize the given value with superjson using the given metadata
+  */
+  static deserialize(payload) {
+    return _StormJSON.instance.deserialize(payload);
+  }
+  /**
+  * Serialize the given value with superjson
+  */
+  static serialize(object) {
+    return _StormJSON.instance.serialize(object);
+  }
+  /**
+  * Parse the given string value with superjson using the given metadata
+  *
+  * @param value - The string value to parse
+  * @returns The parsed data
+  */
+  static parse(value) {
+    return parse(value);
+  }
+  /**
+  * Serializes the given data to a JSON string.
+  * By default the JSON string is formatted with a 2 space indentation to be easy readable.
+  *
+  * @param value - Object which should be serialized to JSON
+  * @param _options - JSON serialize options
+  * @returns the formatted JSON representation of the object
+  */
+  static stringify(value, _options) {
+    const customTransformer = _StormJSON.instance.customTransformerRegistry.findApplicable(value);
+    let result = value;
+    if (customTransformer && customTransformer.isApplicable(value)) {
+      result = customTransformer.serialize(result);
+    }
+    return stringify(result);
+  }
+  /**
+  * Parses the given JSON string and returns the object the JSON content represents.
+  * By default javascript-style comments and trailing commas are allowed.
+  *
+  * @param strData - JSON content as string
+  * @param options - JSON parse options
+  * @returns Object the JSON content represents
+  */
+  static parseJson(strData, options) {
+    try {
+      if (options?.expectComments === false) {
+        return _StormJSON.instance.parse(strData);
+      }
+    } catch {
+    }
+    const errors = [];
+    const opts = {
+      allowTrailingComma: true,
+      ...options
+    };
+    const result = parse2(strData, errors, opts);
+    if (errors.length > 0 && errors[0]) {
+      throw new Error(formatParseError(strData, errors[0]));
+    }
+    return result;
+  }
+  /**
+  * Register a custom schema with superjson
+  *
+  * @param name - The name of the schema
+  * @param serialize - The function to serialize the schema
+  * @param deserialize - The function to deserialize the schema
+  * @param isApplicable - The function to check if the schema is applicable
+  */
+  static register(name, serialize, deserialize, isApplicable) {
+    _StormJSON.instance.registerCustom({
+      isApplicable,
+      serialize,
+      deserialize
+    }, name);
+  }
+  /**
+  * Register a class with superjson
+  *
+  * @param classConstructor - The class constructor to register
+  */
+  static registerClass(classConstructor, options) {
+    _StormJSON.instance.registerClass(classConstructor, {
+      identifier: isString(options) ? options : options?.identifier || classConstructor.name,
+      allowProps: options && isObject(options) && options?.allowProps && Array.isArray(options.allowProps) ? options.allowProps : [
+        "__typename"
+      ]
+    });
+  }
+  constructor() {
+    super({
+      dedupe: true
+    });
+  }
+};
+StormJSON.instance.registerCustom({
+  isApplicable: /* @__PURE__ */ __name((v) => Buffer2.isBuffer(v), "isApplicable"),
+  serialize: /* @__PURE__ */ __name((v) => v.toString("base64"), "serialize"),
+  deserialize: /* @__PURE__ */ __name((v) => Buffer2.from(v, "base64"), "deserialize")
+}, "Bytes");
+
+// ../type-checks/src/is-error.ts
+var isError = /* @__PURE__ */ __name((obj) => {
+  if (!isObject(obj)) {
+    return false;
+  }
+  const tag = getObjectTag(obj);
+  return tag === "[object Error]" || tag === "[object DOMException]" || typeof obj?.message === "string" && typeof obj?.name === "string" && !isPlainObject(obj);
+}, "isError");
+
+// ../fs/src/read-file.ts
+import { existsSync, readFileSync as readFileSyncFs } from "node:fs";
+import { readFile as readFileFs } from "node:fs/promises";
+var readFile = /* @__PURE__ */ __name(async (filePath) => {
+  try {
+    if (!filePath) {
+      throw new Error("No file path provided to read data");
+    }
+    return await readFileFs(filePath, {
+      encoding: "utf8"
+    });
+  } catch {
+    throw new Error("An error occurred writing data to file");
+  }
+}, "readFile");
+async function readJsonFile(path, options) {
+  const content = await readFile(path);
+  if (options) {
+    options.endsWithNewline = content.codePointAt(content.length - 1) === 10;
+  }
+  try {
+    return StormJSON.parseJson(content, options);
+  } catch (error) {
+    if (isError(error)) {
+      error.message = error.message.replace("JSON", path);
+      throw error;
+    }
+    throw new Error(`Failed to parse JSON: ${path}`);
+  }
+}
+__name(readJsonFile, "readJsonFile");
+
+// ../path/src/file-path-fns.ts
+import { relative } from "node:path";
+
+// ../path/src/is-file.ts
+import { lstatSync, statSync } from "node:fs";
+
+// ../path/src/join-paths.ts
+var _DRIVE_LETTER_START_RE = /^[A-Z]:\//i;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+__name(normalizeWindowsPath, "normalizeWindowsPath");
+var _UNC_REGEX = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Z]:[/\\]/i;
+var _DRIVE_LETTER_RE = /^[A-Z]:$/i;
+var isAbsolute = /* @__PURE__ */ __name(function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+}, "isAbsolute");
+var correctPaths = /* @__PURE__ */ __name(function(path) {
+  if (!path || path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+}, "correctPaths");
+var joinPaths = /* @__PURE__ */ __name(function(...segments) {
+  let path = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path.length > 0) {
+      const pathTrailing = path[path.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path += seg.slice(1);
+      } else {
+        path += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path += seg;
+    }
+  }
+  return correctPaths(path);
+}, "joinPaths");
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) {
+      } else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+__name(normalizeString, "normalizeString");
+
+// ../path/src/regex.ts
+var DRIVE_LETTER_START_REGEX = /^[A-Z]:\//i;
+var DRIVE_LETTER_REGEX = /^[A-Z]:$/i;
+var UNC_REGEX = /^[/\\]{2}/;
+var ABSOLUTE_PATH_REGEX = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^~[/\\]|^[A-Z]:[/\\]/i;
+
+// ../path/src/slash.ts
+function slash(path) {
+  if (path.startsWith("\\\\?\\")) {
+    return path;
+  }
+  return path.replace(/\\/g, "/");
+}
+__name(slash, "slash");
+
+// ../path/src/is-file.ts
+function isAbsolutePath(path) {
+  return ABSOLUTE_PATH_REGEX.test(slash(path));
+}
+__name(isAbsolutePath, "isAbsolutePath");
+
+// ../path/src/correct-path.ts
+function normalizeWindowsPath2(input = "") {
+  if (!input) {
+    return input;
+  }
+  return slash(input).replace(DRIVE_LETTER_START_REGEX, (r) => r.toUpperCase());
+}
+__name(normalizeWindowsPath2, "normalizeWindowsPath");
+function correctPath(path) {
+  if (!path || path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath2(path);
+  const isUNCPath = path.match(UNC_REGEX);
+  const isPathAbsolute = isAbsolutePath(path);
+  const trailingSeparator = path.endsWith("/");
+  path = normalizeString2(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (DRIVE_LETTER_REGEX.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return !path.startsWith("/") && isPathAbsolute && !DRIVE_LETTER_REGEX.test(path) ? `/${path}` : path;
+}
+__name(correctPath, "correctPath");
+function normalizeString2(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) {
+      } else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+__name(normalizeString2, "normalizeString");
+
+// ../path/src/get-workspace-root.ts
+import { findWorkspaceRootSafe } from "@storm-software/config-tools";
+
+// ../path/src/file-path-fns.ts
+function findFileName(filePath, options = {}) {
+  const { requireExtension = false, withExtension = true } = options;
+  const result = normalizeWindowsPath2(filePath)?.split(filePath?.includes("\\") ? "\\" : "/")?.pop() ?? "";
+  if (requireExtension === true && !result.includes(".")) {
+    return EMPTY_STRING;
+  }
+  if (withExtension === false && result.includes(".")) {
+    return result.substring(0, result.lastIndexOf(".")) || EMPTY_STRING;
+  }
+  return result;
+}
+__name(findFileName, "findFileName");
+function findFilePath(filePath) {
+  const normalizedPath = normalizeWindowsPath2(filePath);
+  const result = normalizedPath.replace(findFileName(normalizedPath, {
+    requireExtension: true
+  }), "");
+  return result === "/" ? result : result.replace(/\/$/, "");
+}
+__name(findFilePath, "findFilePath");
+
+// bin/capnpc.ts
+import { Command, Option } from "commander";
+import ts from "typescript";
+
+// ../path/src/exists.ts
+import { existsSync as existsSyncFs } from "node:fs";
+import { access, constants } from "node:fs/promises";
+var existsSync2 = /* @__PURE__ */ __name((filePath) => {
+  return existsSyncFs(filePath);
+}, "existsSync");
+var exists = /* @__PURE__ */ __name(async (filePath) => {
+  return access(filePath, constants.F_OK).then(() => true).catch(() => false);
+}, "exists");
+
+// ../fs/src/helpers.ts
+import { parseTar, parseTarGzip } from "nanotar";
+import { createWriteStream, mkdirSync, rmSync } from "node:fs";
+import { mkdir, readFile as readFile2, rm } from "node:fs/promises";
+async function createDirectory(path) {
+  if (await exists(path)) {
+    return;
+  }
+  return mkdir(path, {
+    recursive: true
+  });
+}
+__name(createDirectory, "createDirectory");
+
+// ../fs/src/write-file.ts
+import { stringify as stringifyToml } from "@ltd/j-toml";
+import defu2 from "defu";
+import { writeFileSync as writeFileSyncFs } from "node:fs";
+import { writeFile as writeFileFs } from "node:fs/promises";
+var writeFile = /* @__PURE__ */ __name(async (filePath, content = "", options = {}) => {
+  if (!filePath) {
+    throw new Error("No file path provided to read data");
+  }
+  const directory = findFilePath(correctPath(filePath));
+  if (!existsSync2(directory)) {
+    if (options.createDirectory !== false) {
+      await createDirectory(directory);
+    } else {
+      throw new Error(`Directory ${directory} does not exist`);
+    }
+  }
+  return writeFileFs(filePath, content || "", options);
+}, "writeFile");
+
+// src/compile.ts
+import { compileAll } from "capnp-es/compiler";
+import { Buffer as Buffer3 } from "node:buffer";
+import { exec } from "node:child_process";
+import { existsSync as existsSync3 } from "node:fs";
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return Buffer3.alloc(0);
+  }
+  const chunks = [];
+  process.stdin.on("data", (chunk) => {
+    chunks.push(chunk);
+  });
+  await new Promise((resolve) => {
+    process.stdin.on("end", resolve);
+  });
+  const reqBuffer = Buffer3.alloc(chunks.reduce((l, chunk) => l + chunk.byteLength, 0));
+  let i = 0;
+  for (const chunk of chunks) {
+    chunk.copy(reqBuffer, i);
+    i += chunk.byteLength;
+  }
+  return reqBuffer;
+}
+__name(readStdin, "readStdin");
+async function capnpc(options) {
+  try {
+    const { outputPath, tsconfig, sourcePath = [] } = options;
+    let dataBuf = await readStdin();
+    if (dataBuf.byteLength === 0) {
+      const opts = [];
+      if (outputPath) {
+        opts.push(`-o-:${outputPath}`);
+      } else {
+        opts.push("-o-");
+      }
+      dataBuf = await new Promise((resolve) => {
+        exec(`capnpc ${opts.join(" ")} ${sourcePath.join(" ")}`, {
+          encoding: "buffer"
+        }, (error, stdout, stderr) => {
+          if (stderr.length > 0) {
+            process.stderr.write(stderr);
+          }
+          if (error) {
+            throw error;
+          }
+          resolve(stdout);
+        });
+      });
+    }
+    const result = await compileAll(dataBuf, {
+      ts: options.ts ?? true,
+      js: options.js ?? false,
+      dts: options.dts ?? true,
+      tsconfig: tsconfig?.options
+    });
+    for (const [fileName, content] of result.files) {
+      let filePath = fileName;
+      if (!existsSync3(findFilePath(filePath))) {
+        const fullPath = `/${filePath}`;
+        if (existsSync3(findFilePath(fullPath))) {
+          filePath = fullPath;
+        }
+      }
+      if (outputPath) {
+        filePath = joinPaths(outputPath, fileName);
+      }
+      if (!existsSync3(findFilePath(filePath))) {
+        await createDirectory(findFilePath(filePath));
+      }
+      await writeFile(
+        filePath,
+        // https://github.com/microsoft/TypeScript/issues/54632
+        content.replace(/^\s+/gm, (match) => " ".repeat(match.length / 2))
+      );
+    }
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+      if (error.stack) {
+        console.error(error.stack);
+      }
+    } else {
+      console.error("An unknown error occurred:", error);
+    }
+    throw error;
+  }
+}
+__name(capnpc, "capnpc");
+
+// bin/capnpc.ts
+function createProgram() {
+  writeInfo("\u26A1 Running Storm Cap'n Proto Compiler Tools", {
+    logLevel: "all"
+  });
+  const root = findWorkspaceRootSafe2(process.cwd());
+  process.env.STORM_WORKSPACE_ROOT ??= root;
+  process.env.NX_WORKSPACE_ROOT_PATH ??= root;
+  if (root) {
+    process.chdir(root);
+  }
+  const program = new Command("storm-capnpc");
+  program.version("1.0.0", "-v --version", "display CLI version");
+  const tsOption = new Option("--ts", "An indicator to generate TypeScript files").default(true);
+  const jsOption = new Option("--js", "An indicator to generate JavaScript files").default(false);
+  const dtsOption = new Option("--dts", "An indicator to generate TypeScript declaration files").default(true);
+  const importPathOption = new Option("-I --import-path <dir...>", "Add <dir> to the list of directories searched for non-relative imports").default([]).argParser((val) => {
+    if (val.startsWith("-I") || val.startsWith("--import-path")) {
+      return val.split(",").map((dir) => dir.trim());
+    }
+    return [
+      val.trim()
+    ];
+  });
+  const generateId = new Option("-i --generate-id", "Generate a new 64-bit unique ID for use in a Cap'n Proto schema").default(true);
+  const standardImportOption = new Option("--standard-import", "Add default import paths; use only those specified by -I").default(true);
+  const outputPathOption = new Option("-o --output-path <path>", "The directory to output the generated files to").default(process.cwd());
+  const sourceOption = new Option("--source-path <path...>", "The directories containing the Cap'n Proto schema files to compile (default: current working directory)").default([
+    joinPaths(process.cwd(), "**/*.capnp")
+  ]).argParser((val) => {
+    if (val.startsWith("--source") || val.startsWith("-s")) {
+      return val.split(",").map((dir) => dir.trim());
+    }
+    return [
+      val.trim()
+    ];
+  });
+  const tsconfigPathOption = new Option("--tsconfig-path <path>", "The path to the TypeScript configuration file to use for compilation").default(joinPaths(process.cwd(), "tsconfig.json"));
+  program.command("compile", {
+    isDefault: true
+  }).description("Run the Storm Cap'n Proto compiler").addOption(sourceOption).addOption(outputPathOption).addOption(importPathOption).addOption(tsconfigPathOption).addOption(generateId).addOption(standardImportOption).addOption(tsOption).addOption(jsOption).addOption(dtsOption).action(compileAction).showSuggestionAfterError(true).showHelpAfterError(true);
+  return program;
+}
+__name(createProgram, "createProgram");
+async function compileAction(options) {
+  writeInfo(`\u{1F4E6} Storm Cap'n Proto Compiler will output ${options.ts ? "TypeScript code" : ""}${options.js ? options.ts ? ", JavaScript code" : "JavaScript code" : ""}${options.dts ? options.ts || options.js ? ", TypeScript declarations" : "TypeScript declarations" : ""} files to ${options.outputPath}...`, {
+    logLevel: "all"
+  });
+  const resolvedTsconfig = await readJsonFile(options.tsconfigPath);
+  const tsconfig = ts.parseJsonConfigFileContent(resolvedTsconfig, ts.sys, findFilePath(options.tsconfigPath));
+  const sourcefiles = [];
+  for (const sourcePath of options.sourcePath) {
+    if (!sourcePath) {
+      writeFatal(`\u274C The source path "${sourcePath}" is invalid. Please provide a valid path.`, {
+        logLevel: "all"
+      });
+      return;
+    }
+    sourcefiles.push(...await listFiles(sourcePath));
+  }
+  if (sourcefiles.length === 0) {
+    writeFatal(`\u274C No Cap'n Proto schema files found in the specified source paths: ${options.sourcePath.join(", ")}. Please ensure that the paths are correct and contain .capnp files.`, {
+      logLevel: "all"
+    });
+    return;
+  }
+  const result = await capnpc({
+    ...options,
+    tsconfig,
+    sourcePath: sourcefiles
+  });
+  if (result.files.size === 0) {
+    writeInfo("\u26A0\uFE0F No files were generated. Please check your schema files.", {
+      logLevel: "all"
+    });
+    return;
+  }
+  writeSuccess("\u26A1 Storm Cap'n Proto Compiler completed successfully.", {
+    logLevel: "all"
+  });
+}
+__name(compileAction, "compileAction");
+void (async () => {
+  try {
+    handleProcess();
+    const program = createProgram();
+    await program.parseAsync(process.argv);
+    exitWithSuccess();
+  } catch (error) {
+    writeFatal(`A fatal error occurred while running the Storm Cap'n Proto compiler tool:
+${error?.message ? error.message : JSON.stringify(error)}${error?.stack ? `
+Stack Trace: ${error.stack}` : ""}`, {
+      logLevel: "all"
+    });
+    exitWithError();
+    process.exit(1);
+  }
+})();
+export {
+  createProgram
+};