@stryke/capnp 0.2.6 → 0.4.0

package/dist/chunk-PV3OG5H3.cjs

@@ -0,0 +1,977 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkUSNT2KNTcjs = require('./chunk-USNT2KNT.cjs');
+
+// ../path/src/exists.ts
+var _fs = require('fs');
+var _promises = require('fs/promises');
+var existsSync = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (filePath) => {
+  return _fs.existsSync.call(void 0, filePath);
+}, "existsSync");
+var exists = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, async (filePath) => {
+  return _promises.access.call(void 0, filePath, _promises.constants.F_OK).then(() => true).catch(() => false);
+}, "exists");
+
+// ../fs/src/helpers.ts
+var _nanotar = require('nanotar');
+
+
+async function createDirectory(path) {
+  if (await exists(path)) {
+    return;
+  }
+  return _promises.mkdir.call(void 0, path, {
+    recursive: true
+  });
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, createDirectory, "createDirectory");
+
+// ../fs/src/write-file.ts
+var _jtoml = require('@ltd/j-toml');
+
+// ../type-checks/src/get-object-tag.ts
+var getObjectTag = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (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__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (obj) => {
+  return typeof obj === "object" && obj !== null;
+}, "isObjectLike");
+var isPlainObject = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (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__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (value) => {
+  try {
+    return typeof value === "object" || Boolean(value) && _optionalChain([value, 'optionalAccess', _ => _.constructor]) === Object || isPlainObject(value);
+  } catch (e) {
+    return false;
+  }
+}, "isObject");
+
+// ../type-checks/src/is-string.ts
+var isString = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (value) => {
+  try {
+    return typeof value === "string";
+  } catch (e2) {
+    return false;
+  }
+}, "isString");
+
+// ../json/src/storm-json.ts
+var _jsoncparser = require('jsonc-parser');
+var _buffer = require('buffer');
+var _superjson = require('superjson'); var _superjson2 = _interopRequireDefault(_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 "";
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, stripWithoutWhitespace, "stripWithoutWhitespace");
+function stripWithWhitespace(value, start, end) {
+  return value.slice(start, end).replace(/\S/g, " ");
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, stripWithWhitespace, "stripWithWhitespace");
+function isEscaped(value, quotePosition) {
+  let index = quotePosition - 1;
+  let backslashCount = 0;
+  while (value[index] === "\\") {
+    index -= 1;
+    backslashCount += 1;
+  }
+  return Boolean(backslashCount % 2);
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, 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 + (_nullishCoalesce(nextCharacter, () => ( EMPTY_STRING))) === "//") {
+      buffer += value.slice(offset, index);
+      offset = index;
+      isInsideComment = singleComment;
+      index++;
+    } else if (isInsideComment === singleComment && currentCharacter + (_nullishCoalesce(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 + (_nullishCoalesce(nextCharacter, () => ( EMPTY_STRING))) === "/*") {
+      buffer += value.slice(offset, index);
+      offset = index;
+      isInsideComment = multiComment;
+      index++;
+    } else if (isInsideComment === multiComment && currentCharacter + (_nullishCoalesce(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));
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, 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;
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, 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;
+  }
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, parse, "parse");
+
+// ../json/src/utils/parse-error.ts
+
+var _linesandcolumns = require('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 = _nullishCoalesce(_optionalChain([source, 'access', _2 => _2[lineNumber - 1], 'optionalAccess', _3 => _3.length]), () => ( 0));
+        markerLines[lineNumber] = [
+          startColumn,
+          sourceLength - startColumn + 1
+        ];
+      } else if (i === lineDiff) {
+        markerLines[lineNumber] = [
+          0,
+          endColumn
+        ];
+      } else {
+        const sourceLength = _nullishCoalesce(_optionalChain([source, 'access', _4 => _4[lineNumber - i], 'optionalAccess', _5 => _5.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
+  };
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, 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(_nullishCoalesce(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;
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, codeFrameColumns, "codeFrameColumns");
+
+// ../json/src/utils/parse-error.ts
+function formatParseError(input, parseError) {
+  const { error, offset, length } = parseError;
+  const result = new (0, _linesandcolumns.LinesAndColumns)(input).locationForIndex(offset);
+  let line = _nullishCoalesce(_optionalChain([result, 'optionalAccess', _6 => _6.line]), () => ( 0));
+  let column = _nullishCoalesce(_optionalChain([result, 'optionalAccess', _7 => _7.column]), () => ( 0));
+  line++;
+  column++;
+  return `${_jsoncparser.printParseErrorCode.call(void 0, error)} in JSON at ${line}:${column}
+${codeFrameColumns(input, {
+    start: {
+      line,
+      column
+    },
+    end: {
+      line,
+      column: column + length
+    }
+  })}
+`;
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, formatParseError, "formatParseError");
+
+// ../type-checks/src/is-number.ts
+var isNumber = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (value) => {
+  try {
+    return value instanceof Number || typeof value === "number" || Number(value) === value;
+  } catch (e3) {
+    return false;
+  }
+}, "isNumber");
+
+// ../type-checks/src/is-undefined.ts
+var isUndefined = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (value) => {
+  return value === void 0;
+}, "isUndefined");
+
+// ../json/src/utils/stringify.ts
+var invalidKeyChars = [
+  "@",
+  "/",
+  "#",
+  "$",
+  " ",
+  ":",
+  ";",
+  ",",
+  ".",
+  "!",
+  "?",
+  "&",
+  "=",
+  "+",
+  "-",
+  "*",
+  "%",
+  "^",
+  "~",
+  "|",
+  "\\",
+  '"',
+  "'",
+  "`",
+  "{",
+  "}",
+  "[",
+  "]",
+  "(",
+  ")",
+  "<",
+  ">"
+];
+var stringify = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (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 _superjson2.default {
+  static {
+    _chunkUSNT2KNTcjs.__name.call(void 0, 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 (_optionalChain([options, 'optionalAccess', _8 => _8.expectComments]) === false) {
+        return _StormJSON.instance.parse(strData);
+      }
+    } catch (e4) {
+    }
+    const errors = [];
+    const opts = {
+      allowTrailingComma: true,
+      ...options
+    };
+    const result = _jsoncparser.parse.call(void 0, 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 : _optionalChain([options, 'optionalAccess', _9 => _9.identifier]) || classConstructor.name,
+      allowProps: options && isObject(options) && _optionalChain([options, 'optionalAccess', _10 => _10.allowProps]) && Array.isArray(options.allowProps) ? options.allowProps : [
+        "__typename"
+      ]
+    });
+  }
+  constructor() {
+    super({
+      dedupe: true
+    });
+  }
+};
+StormJSON.instance.registerCustom({
+  isApplicable: /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (v) => _buffer.Buffer.isBuffer(v), "isApplicable"),
+  serialize: /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (v) => v.toString("base64"), "serialize"),
+  deserialize: /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, (v) => _buffer.Buffer.from(v, "base64"), "deserialize")
+}, "Bytes");
+
+// ../path/src/is-file.ts
+
+
+// ../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());
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, normalizeWindowsPath, "normalizeWindowsPath");
+var _UNC_REGEX = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Z]:[/\\]/i;
+var _DRIVE_LETTER_RE = /^[A-Z]:$/i;
+var isAbsolute = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+}, "isAbsolute");
+var correctPaths = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, 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__ */ _chunkUSNT2KNTcjs.__name.call(void 0, 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;
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, 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, "/");
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, slash, "slash");
+
+// ../path/src/is-file.ts
+function isAbsolutePath(path) {
+  return ABSOLUTE_PATH_REGEX.test(slash(path));
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, 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());
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, 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;
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, 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;
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, normalizeString2, "normalizeString");
+
+// ../path/src/file-path-fns.ts
+var _path = require('path');
+
+// ../path/src/get-workspace-root.ts
+var _configtools = require('@storm-software/config-tools');
+
+// ../path/src/file-path-fns.ts
+function findFileName(filePath, options = {}) {
+  const { requireExtension = false, withExtension = true } = options;
+  const result = _nullishCoalesce(_optionalChain([normalizeWindowsPath2, 'call', _11 => _11(filePath), 'optionalAccess', _12 => _12.split, 'call', _13 => _13(_optionalChain([filePath, 'optionalAccess', _14 => _14.includes, 'call', _15 => _15("\\")]) ? "\\" : "/"), 'optionalAccess', _16 => _16.pop, 'call', _17 => _17()]), () => ( ""));
+  if (requireExtension === true && !result.includes(".")) {
+    return EMPTY_STRING;
+  }
+  if (withExtension === false && result.includes(".")) {
+    return result.substring(0, result.lastIndexOf(".")) || EMPTY_STRING;
+  }
+  return result;
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, findFileName, "findFileName");
+function findFilePath(filePath) {
+  const normalizedPath = normalizeWindowsPath2(filePath);
+  const result = normalizedPath.replace(findFileName(normalizedPath, {
+    requireExtension: true
+  }), "");
+  return result === "/" ? result : result.replace(/\/$/, "");
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, findFilePath, "findFilePath");
+
+// ../fs/src/write-file.ts
+var _defu = require('defu'); var _defu2 = _interopRequireDefault(_defu);
+
+
+var writeFile = /* @__PURE__ */ _chunkUSNT2KNTcjs.__name.call(void 0, async (filePath, content = "", options = {}) => {
+  if (!filePath) {
+    throw new Error("No file path provided to read data");
+  }
+  const directory = findFilePath(correctPath(filePath));
+  if (!existsSync(directory)) {
+    if (options.createDirectory !== false) {
+      await createDirectory(directory);
+    } else {
+      throw new Error(`Directory ${directory} does not exist`);
+    }
+  }
+  return _promises.writeFile.call(void 0, filePath, content || "", options);
+}, "writeFile");
+
+// src/compile.ts
+var _compiler = require('capnp-es/compiler');
+
+var _child_process = require('child_process');
+
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return _buffer.Buffer.alloc(0);
+  }
+  const chunks = [];
+  process.stdin.on("data", (chunk) => {
+    chunks.push(chunk);
+  });
+  await new Promise((resolve) => {
+    process.stdin.on("end", resolve);
+  });
+  const reqBuffer = _buffer.Buffer.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;
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, 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) => {
+        _child_process.exec.call(void 0, `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 _compiler.compileAll.call(void 0, dataBuf, {
+      ts: _nullishCoalesce(options.ts, () => ( true)),
+      js: _nullishCoalesce(options.js, () => ( false)),
+      dts: _nullishCoalesce(options.dts, () => ( true)),
+      tsconfig: _optionalChain([tsconfig, 'optionalAccess', _18 => _18.options])
+    });
+    for (const [fileName, content] of result.files) {
+      let filePath = fileName;
+      if (!_fs.existsSync.call(void 0, findFilePath(filePath))) {
+        const fullPath = `/${filePath}`;
+        if (_fs.existsSync.call(void 0, findFilePath(fullPath))) {
+          filePath = fullPath;
+        }
+      }
+      if (outputPath) {
+        filePath = joinPaths(outputPath, fileName);
+      }
+      if (!_fs.existsSync.call(void 0, 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;
+  }
+}
+_chunkUSNT2KNTcjs.__name.call(void 0, capnpc, "capnpc");
+
+
+
+exports.capnpc = capnpc;