@c4a/extract-ts 0.6.2 → 0.6.4

package/index.js

@@ -320,26 +320,26 @@ var require_directives = __commonJS((exports) => {
           return false;
       }
     }
-    tagName(source2, onError) {
-      if (source2 === "!")
+    tagName(source, onError) {
+      if (source === "!")
         return "!";
-      if (source2[0] !== "!") {
-        onError(`Not a valid tag: ${source2}`);
+      if (source[0] !== "!") {
+        onError(`Not a valid tag: ${source}`);
         return null;
       }
-      if (source2[1] === "<") {
-        const verbatim = source2.slice(2, -1);
+      if (source[1] === "<") {
+        const verbatim = source.slice(2, -1);
         if (verbatim === "!" || verbatim === "!!") {
-          onError(`Verbatim tags aren't resolved, so ${source2} is invalid.`);
+          onError(`Verbatim tags aren't resolved, so ${source} is invalid.`);
           return null;
         }
-        if (source2[source2.length - 1] !== ">")
+        if (source[source.length - 1] !== ">")
           onError("Verbatim tags must end with a >");
         return verbatim;
       }
-      const [, handle, suffix] = source2.match(/^(.*!)([^!]*)$/s);
+      const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);
       if (!suffix)
-        onError(`The ${source2} tag has no suffix`);
+        onError(`The ${source} tag has no suffix`);
       const prefix = this.tags[handle];
       if (prefix) {
         try {
@@ -350,8 +350,8 @@ var require_directives = __commonJS((exports) => {
         }
       }
       if (handle === "!")
-        return source2;
-      onError(`Could not resolve tag: ${source2}`);
+        return source;
+      onError(`Could not resolve tag: ${source}`);
       return null;
     }
     tagString(tag) {
@@ -423,21 +423,21 @@ var require_anchors = __commonJS((exports) => {
     const sourceObjects = new Map;
     let prevAnchors = null;
     return {
-      onAnchor: (source2) => {
-        aliasObjects.push(source2);
+      onAnchor: (source) => {
+        aliasObjects.push(source);
         prevAnchors ?? (prevAnchors = anchorNames(doc));
         const anchor = findNewAnchor(prefix, prevAnchors);
         prevAnchors.add(anchor);
         return anchor;
       },
       setAnchors: () => {
-        for (const source2 of aliasObjects) {
-          const ref = sourceObjects.get(source2);
+        for (const source of aliasObjects) {
+          const ref = sourceObjects.get(source);
           if (typeof ref === "object" && ref.anchor && (identity.isScalar(ref.node) || identity.isCollection(ref.node))) {
             ref.node.anchor = ref.anchor;
           } else {
             const error = new Error("Failed to resolve repeated object (this should not happen)");
-            error.source = source2;
+            error.source = source;
             throw error;
           }
         }
@@ -571,9 +571,9 @@ var require_Alias = __commonJS((exports) => {
   var toJS = require_toJS();
 
   class Alias extends Node.NodeBase {
-    constructor(source2) {
+    constructor(source) {
       super(identity.ALIAS);
-      this.source = source2;
+      this.source = source;
       Object.defineProperty(this, "tag", {
         set() {
           throw new Error("Alias nodes cannot have tags");
@@ -608,15 +608,15 @@ var require_Alias = __commonJS((exports) => {
       if (!ctx)
         return { source: this.source };
       const { anchors: anchors2, doc, maxAliasCount } = ctx;
-      const source2 = this.resolve(doc, ctx);
-      if (!source2) {
+      const source = this.resolve(doc, ctx);
+      if (!source) {
         const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
         throw new ReferenceError(msg);
       }
-      let data = anchors2.get(source2);
+      let data = anchors2.get(source);
       if (!data) {
-        toJS.toJS(source2, null, ctx);
-        data = anchors2.get(source2);
+        toJS.toJS(source, null, ctx);
+        data = anchors2.get(source);
       }
       if (data?.res === undefined) {
         const msg = "This should not happen: Alias anchor was not resolved?";
@@ -625,7 +625,7 @@ var require_Alias = __commonJS((exports) => {
       if (maxAliasCount >= 0) {
         data.count += 1;
         if (data.aliasCount === 0)
-          data.aliasCount = getAliasCount(doc, source2, anchors2);
+          data.aliasCount = getAliasCount(doc, source, anchors2);
         if (data.count * data.aliasCount > maxAliasCount) {
           const msg = "Excessive alias count indicates a resource exhaustion attack";
           throw new ReferenceError(msg);
@@ -649,8 +649,8 @@ var require_Alias = __commonJS((exports) => {
   }
   function getAliasCount(doc, node2, anchors2) {
     if (identity.isAlias(node2)) {
-      const source2 = node2.resolve(doc);
-      const anchor = anchors2 && source2 && anchors2.get(source2);
+      const source = node2.resolve(doc);
+      const anchor = anchors2 && source && anchors2.get(source);
       return anchor ? anchor.count * anchor.aliasCount : 0;
     } else if (identity.isCollection(node2)) {
       let count = 0;
@@ -1640,10 +1640,10 @@ var require_merge = __commonJS((exports) => {
       mergeValue(ctx, map, value);
   }
   function mergeValue(ctx, map, value) {
-    const source2 = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
-    if (!identity.isMap(source2))
+    const source = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
+    if (!identity.isMap(source))
       throw new Error("Merge sources must be maps or map aliases");
-    const srcMap = source2.toJSON(null, ctx, Map);
+    const srcMap = source.toJSON(null, ctx, Map);
     for (const [key, value2] of srcMap) {
       if (map instanceof Map) {
         if (!map.has(key))
@@ -2194,7 +2194,7 @@ var require_null = __commonJS((exports) => {
     tag: "tag:yaml.org,2002:null",
     test: /^(?:~|[Nn]ull|NULL)?$/,
     resolve: () => new Scalar.Scalar(null),
-    stringify: ({ source: source2 }, ctx) => typeof source2 === "string" && nullTag.test.test(source2) ? source2 : ctx.options.nullStr
+    stringify: ({ source }, ctx) => typeof source === "string" && nullTag.test.test(source) ? source : ctx.options.nullStr
   };
   exports.nullTag = nullTag;
 });
@@ -2208,11 +2208,11 @@ var require_bool = __commonJS((exports) => {
     tag: "tag:yaml.org,2002:bool",
     test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
     resolve: (str) => new Scalar.Scalar(str[0] === "t" || str[0] === "T"),
-    stringify({ source: source2, value }, ctx) {
-      if (source2 && boolTag.test.test(source2)) {
-        const sv = source2[0] === "t" || source2[0] === "T";
+    stringify({ source, value }, ctx) {
+      if (source && boolTag.test.test(source)) {
+        const sv = source[0] === "t" || source[0] === "T";
         if (value === sv)
-          return source2;
+          return source;
       }
       return value ? ctx.options.trueStr : ctx.options.falseStr;
     }
@@ -2623,10 +2623,10 @@ var require_omap = __commonJS((exports) => {
 // ../../node_modules/.bun/yaml@2.8.2/node_modules/yaml/dist/schema/yaml-1.1/bool.js
 var require_bool2 = __commonJS((exports) => {
   var Scalar = require_Scalar();
-  function boolStringify({ value, source: source2 }, ctx) {
+  function boolStringify({ value, source }, ctx) {
     const boolObj = value ? trueTag : falseTag;
-    if (source2 && boolObj.test.test(source2))
-      return source2;
+    if (source && boolObj.test.test(source))
+      return source;
     return value ? ctx.options.trueStr : ctx.options.falseStr;
   }
   var trueTag = {
@@ -3839,7 +3839,7 @@ var require_resolve_end = __commonJS((exports) => {
       let hasSpace = false;
       let sep = "";
       for (const token of end) {
-        const { source: source2, type } = token;
+        const { source, type } = token;
         switch (type) {
           case "space":
             hasSpace = true;
@@ -3847,7 +3847,7 @@ var require_resolve_end = __commonJS((exports) => {
           case "comment": {
             if (reqSpace && !hasSpace)
               onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
-            const cb = source2.substring(1) || " ";
+            const cb = source.substring(1) || " ";
             if (!comment)
               comment = cb;
             else
@@ -3857,13 +3857,13 @@ var require_resolve_end = __commonJS((exports) => {
           }
           case "newline":
             if (comment)
-              sep += source2;
+              sep += source;
             hasSpace = true;
             break;
           default:
             onError(token, "UNEXPECTED_TOKEN", `Unexpected ${type} at node end`);
         }
-        offset += source2.length;
+        offset += source.length;
       }
     }
     return { comment, offset };
@@ -4251,13 +4251,13 @@ var require_resolve_block_scalar = __commonJS((exports) => {
       onError(props[0], "IMPOSSIBLE", "Block scalar header not found");
       return null;
     }
-    const { source: source2 } = props[0];
-    const mode = source2[0];
+    const { source } = props[0];
+    const mode = source[0];
     let indent = 0;
     let chomp = "";
     let error = -1;
-    for (let i = 1;i < source2.length; ++i) {
-      const ch = source2[i];
+    for (let i = 1;i < source.length; ++i) {
+      const ch = source[i];
       if (!chomp && (ch === "-" || ch === "+"))
         chomp = ch;
       else {
@@ -4269,10 +4269,10 @@ var require_resolve_block_scalar = __commonJS((exports) => {
       }
     }
     if (error !== -1)
-      onError(error, "UNEXPECTED_TOKEN", `Block scalar header includes extra characters: ${source2}`);
+      onError(error, "UNEXPECTED_TOKEN", `Block scalar header includes extra characters: ${source}`);
     let hasSpace = false;
     let comment = "";
-    let length = source2.length;
+    let length = source.length;
     for (let i = 1;i < props.length; ++i) {
       const token = props[i];
       switch (token.type) {
@@ -4304,8 +4304,8 @@ var require_resolve_block_scalar = __commonJS((exports) => {
     }
     return { mode, indent, chomp, comment, length };
   }
-  function splitLines(source2) {
-    const split = source2.split(/\n( *)/);
+  function splitLines(source) {
+    const split = source.split(/\n( *)/);
     const first = split[0];
     const m = first.match(/^( *)/);
     const line0 = m?.[1] ? [m[1], first.slice(m[1].length)] : ["", first];
@@ -4322,22 +4322,22 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
   var Scalar = require_Scalar();
   var resolveEnd = require_resolve_end();
   function resolveFlowScalar(scalar, strict, onError) {
-    const { offset, type, source: source2, end } = scalar;
+    const { offset, type, source, end } = scalar;
     let _type;
     let value;
     const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
     switch (type) {
       case "scalar":
         _type = Scalar.Scalar.PLAIN;
-        value = plainValue(source2, _onError);
+        value = plainValue(source, _onError);
         break;
       case "single-quoted-scalar":
         _type = Scalar.Scalar.QUOTE_SINGLE;
-        value = singleQuotedValue(source2, _onError);
+        value = singleQuotedValue(source, _onError);
         break;
       case "double-quoted-scalar":
         _type = Scalar.Scalar.QUOTE_DOUBLE;
-        value = doubleQuotedValue(source2, _onError);
+        value = doubleQuotedValue(source, _onError);
         break;
       default:
         onError(scalar, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`);
@@ -4345,10 +4345,10 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
           value: "",
           type: null,
           comment: "",
-          range: [offset, offset + source2.length, offset + source2.length]
+          range: [offset, offset + source.length, offset + source.length]
         };
     }
-    const valueEnd = offset + source2.length;
+    const valueEnd = offset + source.length;
     const re = resolveEnd.resolveEnd(end, valueEnd, strict, onError);
     return {
       value,
@@ -4357,9 +4357,9 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
       range: [offset, valueEnd, re.offset]
     };
   }
-  function plainValue(source2, onError) {
+  function plainValue(source, onError) {
     let badChar = "";
-    switch (source2[0]) {
+    switch (source[0]) {
       case "\t":
         badChar = "a tab character";
         break;
@@ -4371,25 +4371,25 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
         break;
       case "|":
       case ">": {
-        badChar = `block scalar indicator ${source2[0]}`;
+        badChar = `block scalar indicator ${source[0]}`;
         break;
       }
       case "@":
       case "`": {
-        badChar = `reserved character ${source2[0]}`;
+        badChar = `reserved character ${source[0]}`;
         break;
       }
     }
     if (badChar)
       onError(0, "BAD_SCALAR_START", `Plain value cannot start with ${badChar}`);
-    return foldLines(source2);
+    return foldLines(source);
   }
-  function singleQuotedValue(source2, onError) {
-    if (source2[source2.length - 1] !== "'" || source2.length === 1)
-      onError(source2.length, "MISSING_CHAR", "Missing closing 'quote");
-    return foldLines(source2.slice(1, -1)).replace(/''/g, "'");
+  function singleQuotedValue(source, onError) {
+    if (source[source.length - 1] !== "'" || source.length === 1)
+      onError(source.length, "MISSING_CHAR", "Missing closing 'quote");
+    return foldLines(source.slice(1, -1)).replace(/''/g, "'");
   }
-  function foldLines(source2) {
+  function foldLines(source) {
     let first, line;
     try {
       first = new RegExp(`(.*?)(?<![ 	])[ 	]*\r?
@@ -4400,14 +4400,14 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
       first = /(.*?)[ \t]*\r?\n/sy;
       line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
     }
-    let match = first.exec(source2);
+    let match = first.exec(source);
     if (!match)
-      return source2;
+      return source;
     let res = match[1];
     let sep = " ";
     let pos = first.lastIndex;
     line.lastIndex = pos;
-    while (match = line.exec(source2)) {
+    while (match = line.exec(source)) {
       if (match[1] === "") {
         if (sep === `
 `)
@@ -4423,68 +4423,68 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
     }
     const last = /[ \t]*(.*)/sy;
     last.lastIndex = pos;
-    match = last.exec(source2);
+    match = last.exec(source);
     return res + sep + (match?.[1] ?? "");
   }
-  function doubleQuotedValue(source2, onError) {
+  function doubleQuotedValue(source, onError) {
     let res = "";
-    for (let i = 1;i < source2.length - 1; ++i) {
-      const ch = source2[i];
-      if (ch === "\r" && source2[i + 1] === `
+    for (let i = 1;i < source.length - 1; ++i) {
+      const ch = source[i];
+      if (ch === "\r" && source[i + 1] === `
 `)
         continue;
       if (ch === `
 `) {
-        const { fold, offset } = foldNewline(source2, i);
+        const { fold, offset } = foldNewline(source, i);
         res += fold;
         i = offset;
       } else if (ch === "\\") {
-        let next = source2[++i];
+        let next = source[++i];
         const cc = escapeCodes[next];
         if (cc)
           res += cc;
         else if (next === `
 `) {
-          next = source2[i + 1];
+          next = source[i + 1];
           while (next === " " || next === "\t")
-            next = source2[++i + 1];
-        } else if (next === "\r" && source2[i + 1] === `
+            next = source[++i + 1];
+        } else if (next === "\r" && source[i + 1] === `
 `) {
-          next = source2[++i + 1];
+          next = source[++i + 1];
           while (next === " " || next === "\t")
-            next = source2[++i + 1];
+            next = source[++i + 1];
         } else if (next === "x" || next === "u" || next === "U") {
           const length = { x: 2, u: 4, U: 8 }[next];
-          res += parseCharCode(source2, i + 1, length, onError);
+          res += parseCharCode(source, i + 1, length, onError);
           i += length;
         } else {
-          const raw = source2.substr(i - 1, 2);
+          const raw = source.substr(i - 1, 2);
           onError(i - 1, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
           res += raw;
         }
       } else if (ch === " " || ch === "\t") {
         const wsStart = i;
-        let next = source2[i + 1];
+        let next = source[i + 1];
         while (next === " " || next === "\t")
-          next = source2[++i + 1];
+          next = source[++i + 1];
         if (next !== `
-` && !(next === "\r" && source2[i + 2] === `
+` && !(next === "\r" && source[i + 2] === `
 `))
-          res += i > wsStart ? source2.slice(wsStart, i + 1) : ch;
+          res += i > wsStart ? source.slice(wsStart, i + 1) : ch;
       } else {
         res += ch;
       }
     }
-    if (source2[source2.length - 1] !== '"' || source2.length === 1)
-      onError(source2.length, "MISSING_CHAR", 'Missing closing "quote');
+    if (source[source.length - 1] !== '"' || source.length === 1)
+      onError(source.length, "MISSING_CHAR", 'Missing closing "quote');
     return res;
   }
-  function foldNewline(source2, offset) {
+  function foldNewline(source, offset) {
     let fold = "";
-    let ch = source2[offset + 1];
+    let ch = source[offset + 1];
     while (ch === " " || ch === "\t" || ch === `
 ` || ch === "\r") {
-      if (ch === "\r" && source2[offset + 2] !== `
+      if (ch === "\r" && source[offset + 2] !== `
 `)
         break;
       if (ch === `
@@ -4492,7 +4492,7 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
         fold += `
 `;
       offset += 1;
-      ch = source2[offset + 1];
+      ch = source[offset + 1];
     }
     if (!fold)
       fold = " ";
@@ -4519,12 +4519,12 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
     "\\": "\\",
     "\t": "\t"
   };
-  function parseCharCode(source2, offset, length, onError) {
-    const cc = source2.substr(offset, length);
+  function parseCharCode(source, offset, length, onError) {
+    const cc = source.substr(offset, length);
     const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
     const code = ok ? parseInt(cc, 16) : NaN;
     if (isNaN(code)) {
-      const raw = source2.substr(offset - 2, length + 2);
+      const raw = source.substr(offset - 2, length + 2);
       onError(offset - 2, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
       return raw;
     }
@@ -4719,13 +4719,13 @@ var require_compose_node = __commonJS((exports) => {
     }
     return node2;
   }
-  function composeAlias({ options }, { offset, source: source2, end }, onError) {
-    const alias = new Alias.Alias(source2.substring(1));
+  function composeAlias({ options }, { offset, source, end }, onError) {
+    const alias = new Alias.Alias(source.substring(1));
     if (alias.source === "")
       onError(offset, "BAD_ALIAS", "Alias cannot be an empty string");
     if (alias.source.endsWith(":"))
-      onError(offset + source2.length - 1, "BAD_ALIAS", "Alias ending in : is ambiguous", true);
-    const valueEnd = offset + source2.length;
+      onError(offset + source.length - 1, "BAD_ALIAS", "Alias ending in : is ambiguous", true);
+    const valueEnd = offset + source.length;
     const re = resolveEnd.resolveEnd(end, valueEnd, options.strict, onError);
     alias.range = [offset, valueEnd, re.offset];
     if (re.comment)
@@ -4790,21 +4790,21 @@ var require_composer = __commonJS((exports) => {
       return [src, src + 1];
     if (Array.isArray(src))
       return src.length === 2 ? src : [src[0], src[1]];
-    const { offset, source: source2 } = src;
-    return [offset, offset + (typeof source2 === "string" ? source2.length : 1)];
+    const { offset, source } = src;
+    return [offset, offset + (typeof source === "string" ? source.length : 1)];
   }
   function parsePrelude(prelude) {
     let comment = "";
     let atComment = false;
     let afterEmptyLine = false;
     for (let i = 0;i < prelude.length; ++i) {
-      const source2 = prelude[i];
-      switch (source2[0]) {
+      const source = prelude[i];
+      switch (source[0]) {
         case "#":
           comment += (comment === "" ? "" : afterEmptyLine ? `
 
 ` : `
-`) + (source2.substring(1) || " ");
+`) + (source.substring(1) || " ");
           atComment = true;
           afterEmptyLine = false;
           break;
@@ -4829,8 +4829,8 @@ var require_composer = __commonJS((exports) => {
       this.prelude = [];
       this.errors = [];
       this.warnings = [];
-      this.onError = (source2, code, message, warning) => {
-        const pos = getErrorPos(source2);
+      this.onError = (source, code, message, warning) => {
+        const pos = getErrorPos(source);
         if (warning)
           this.warnings.push(new errors2.YAMLWarning(pos, code, message));
         else
@@ -4993,7 +4993,7 @@ var require_cst_scalar = __commonJS((exports) => {
   }
   function createScalarToken(value, context) {
     const { implicitKey = false, indent, inFlow = false, offset = -1, type = "PLAIN" } = context;
-    const source2 = stringifyString.stringifyString({ type, value }, {
+    const source = stringifyString.stringifyString({ type, value }, {
       implicitKey,
       indent: indent > 0 ? " ".repeat(indent) : "",
       inFlow,
@@ -5003,13 +5003,13 @@ var require_cst_scalar = __commonJS((exports) => {
       { type: "newline", offset: -1, indent, source: `
 ` }
     ];
-    switch (source2[0]) {
+    switch (source[0]) {
       case "|":
       case ">": {
-        const he = source2.indexOf(`
+        const he = source.indexOf(`
 `);
-        const head = source2.substring(0, he);
-        const body = source2.substring(he + 1) + `
+        const head = source.substring(0, he);
+        const body = source.substring(he + 1) + `
 `;
         const props = [
           { type: "block-scalar-header", offset, indent, source: head }
@@ -5020,11 +5020,11 @@ var require_cst_scalar = __commonJS((exports) => {
         return { type: "block-scalar", offset, indent, props, source: body };
       }
       case '"':
-        return { type: "double-quoted-scalar", offset, indent, source: source2, end };
+        return { type: "double-quoted-scalar", offset, indent, source, end };
       case "'":
-        return { type: "single-quoted-scalar", offset, indent, source: source2, end };
+        return { type: "single-quoted-scalar", offset, indent, source, end };
       default:
-        return { type: "scalar", offset, indent, source: source2, end };
+        return { type: "scalar", offset, indent, source, end };
     }
   }
   function setScalarValue(token, value, context = {}) {
@@ -5050,32 +5050,32 @@ var require_cst_scalar = __commonJS((exports) => {
         default:
           type = "PLAIN";
       }
-    const source2 = stringifyString.stringifyString({ type, value }, {
+    const source = stringifyString.stringifyString({ type, value }, {
       implicitKey: implicitKey || indent === null,
       indent: indent !== null && indent > 0 ? " ".repeat(indent) : "",
       inFlow,
       options: { blockQuote: true, lineWidth: -1 }
     });
-    switch (source2[0]) {
+    switch (source[0]) {
       case "|":
       case ">":
-        setBlockScalarValue(token, source2);
+        setBlockScalarValue(token, source);
         break;
       case '"':
-        setFlowScalarValue(token, source2, "double-quoted-scalar");
+        setFlowScalarValue(token, source, "double-quoted-scalar");
         break;
       case "'":
-        setFlowScalarValue(token, source2, "single-quoted-scalar");
+        setFlowScalarValue(token, source, "single-quoted-scalar");
         break;
       default:
-        setFlowScalarValue(token, source2, "scalar");
+        setFlowScalarValue(token, source, "scalar");
     }
   }
-  function setBlockScalarValue(token, source2) {
-    const he = source2.indexOf(`
+  function setBlockScalarValue(token, source) {
+    const he = source.indexOf(`
 `);
-    const head = source2.substring(0, he);
-    const body = source2.substring(he + 1) + `
+    const head = source.substring(0, he);
+    const body = source.substring(he + 1) + `
 `;
     if (token.type === "block-scalar") {
       const header = token.props[0];
@@ -5112,32 +5112,32 @@ var require_cst_scalar = __commonJS((exports) => {
         }
     return false;
   }
-  function setFlowScalarValue(token, source2, type) {
+  function setFlowScalarValue(token, source, type) {
     switch (token.type) {
       case "scalar":
       case "double-quoted-scalar":
       case "single-quoted-scalar":
         token.type = type;
-        token.source = source2;
+        token.source = source;
         break;
       case "block-scalar": {
         const end = token.props.slice(1);
-        let oa = source2.length;
+        let oa = source.length;
         if (token.props[0].type === "block-scalar-header")
           oa -= token.props[0].source.length;
         for (const tok of end)
           tok.offset += oa;
         delete token.props;
-        Object.assign(token, { type, source: source2, end });
+        Object.assign(token, { type, source, end });
         break;
       }
       case "block-map":
       case "block-seq": {
-        const offset = token.offset + source2.length;
+        const offset = token.offset + source.length;
         const nl = { type: "newline", offset, indent: token.indent, source: `
 ` };
         delete token.items;
-        Object.assign(token, { type, source: source2, end: [nl] });
+        Object.assign(token, { type, source, end: [nl] });
         break;
       }
       default: {
@@ -5146,7 +5146,7 @@ var require_cst_scalar = __commonJS((exports) => {
         for (const key of Object.keys(token))
           if (key !== "type" && key !== "offset")
             delete token[key];
-        Object.assign(token, { type, indent, source: source2, end });
+        Object.assign(token, { type, indent, source, end });
       }
     }
   }
@@ -5297,8 +5297,8 @@ var require_cst = __commonJS((exports) => {
         return JSON.stringify(token);
     }
   }
-  function tokenType(source2) {
-    switch (source2) {
+  function tokenType(source) {
+    switch (source) {
       case BOM:
         return "byte-order-mark";
       case DOCUMENT:
@@ -5334,7 +5334,7 @@ var require_cst = __commonJS((exports) => {
       case ",":
         return "comma";
     }
-    switch (source2[0]) {
+    switch (source[0]) {
       case " ":
       case "\t":
         return "space";
@@ -5410,11 +5410,11 @@ var require_lexer = __commonJS((exports) => {
       this.next = null;
       this.pos = 0;
     }
-    *lex(source2, incomplete = false) {
-      if (source2) {
-        if (typeof source2 !== "string")
+    *lex(source, incomplete = false) {
+      if (source) {
+        if (typeof source !== "string")
           throw TypeError("source is not a string");
-        this.buffer = this.buffer ? this.buffer + source2 : source2;
+        this.buffer = this.buffer ? this.buffer + source : source;
         this.lineEndPos = null;
       }
       this.atEnd = !incomplete;
@@ -6088,29 +6088,29 @@ var require_parser = __commonJS((exports) => {
       this.lexer = new lexer.Lexer;
       this.onNewLine = onNewLine;
     }
-    *parse(source2, incomplete = false) {
+    *parse(source, incomplete = false) {
       if (this.onNewLine && this.offset === 0)
         this.onNewLine(0);
-      for (const lexeme of this.lexer.lex(source2, incomplete))
+      for (const lexeme of this.lexer.lex(source, incomplete))
         yield* this.next(lexeme);
       if (!incomplete)
         yield* this.end();
     }
-    *next(source2) {
-      this.source = source2;
+    *next(source) {
+      this.source = source;
       if (node_process.env.LOG_TOKENS)
-        console.log("|", cst.prettyToken(source2));
+        console.log("|", cst.prettyToken(source));
       if (this.atScalar) {
         this.atScalar = false;
         yield* this.step();
-        this.offset += source2.length;
+        this.offset += source.length;
         return;
       }
-      const type = cst.tokenType(source2);
+      const type = cst.tokenType(source);
       if (!type) {
-        const message = `Not a YAML token: ${source2}`;
-        yield* this.pop({ type: "error", offset: this.offset, message, source: source2 });
-        this.offset += source2.length;
+        const message = `Not a YAML token: ${source}`;
+        yield* this.pop({ type: "error", offset: this.offset, message, source });
+        this.offset += source.length;
       } else if (type === "scalar") {
         this.atNewLine = false;
         this.atScalar = true;
@@ -6123,17 +6123,17 @@ var require_parser = __commonJS((exports) => {
             this.atNewLine = true;
             this.indent = 0;
             if (this.onNewLine)
-              this.onNewLine(this.offset + source2.length);
+              this.onNewLine(this.offset + source.length);
             break;
           case "space":
-            if (this.atNewLine && source2[0] === " ")
-              this.indent += source2.length;
+            if (this.atNewLine && source[0] === " ")
+              this.indent += source.length;
             break;
           case "explicit-key-ind":
           case "map-value-ind":
           case "seq-item-ind":
             if (this.atNewLine)
-              this.indent += source2.length;
+              this.indent += source.length;
             break;
           case "doc-mode":
           case "flow-error-end":
@@ -6141,7 +6141,7 @@ var require_parser = __commonJS((exports) => {
           default:
             this.atNewLine = false;
         }
-        this.offset += source2.length;
+        this.offset += source.length;
       }
     }
     *end() {
@@ -6850,26 +6850,26 @@ var require_public_api = __commonJS((exports) => {
     const lineCounter$1 = options.lineCounter || prettyErrors && new lineCounter.LineCounter || null;
     return { lineCounter: lineCounter$1, prettyErrors };
   }
-  function parseAllDocuments(source2, options = {}) {
+  function parseAllDocuments(source, options = {}) {
     const { lineCounter: lineCounter2, prettyErrors } = parseOptions(options);
     const parser$1 = new parser.Parser(lineCounter2?.addNewLine);
     const composer$1 = new composer.Composer(options);
-    const docs = Array.from(composer$1.compose(parser$1.parse(source2)));
+    const docs = Array.from(composer$1.compose(parser$1.parse(source)));
     if (prettyErrors && lineCounter2)
       for (const doc of docs) {
-        doc.errors.forEach(errors2.prettifyError(source2, lineCounter2));
-        doc.warnings.forEach(errors2.prettifyError(source2, lineCounter2));
+        doc.errors.forEach(errors2.prettifyError(source, lineCounter2));
+        doc.warnings.forEach(errors2.prettifyError(source, lineCounter2));
       }
     if (docs.length > 0)
       return docs;
     return Object.assign([], { empty: true }, composer$1.streamInfo());
   }
-  function parseDocument(source2, options = {}) {
+  function parseDocument(source, options = {}) {
     const { lineCounter: lineCounter2, prettyErrors } = parseOptions(options);
     const parser$1 = new parser.Parser(lineCounter2?.addNewLine);
     const composer$1 = new composer.Composer(options);
     let doc = null;
-    for (const _doc of composer$1.compose(parser$1.parse(source2), true, source2.length)) {
+    for (const _doc of composer$1.compose(parser$1.parse(source), true, source.length)) {
       if (!doc)
         doc = _doc;
       else if (doc.options.logLevel !== "silent") {
@@ -6878,8 +6878,8 @@ var require_public_api = __commonJS((exports) => {
       }
     }
     if (prettyErrors && lineCounter2) {
-      doc.errors.forEach(errors2.prettifyError(source2, lineCounter2));
-      doc.warnings.forEach(errors2.prettifyError(source2, lineCounter2));
+      doc.errors.forEach(errors2.prettifyError(source, lineCounter2));
+      doc.warnings.forEach(errors2.prettifyError(source, lineCounter2));
     }
     return doc;
   }
@@ -7096,156 +7096,6 @@ var FactRelation;
   FactRelation2["Supersedes"] = "supersedes";
   FactRelation2["References"] = "references";
 })(FactRelation ||= {});
-// ../core/src/types/serverConfig.ts
-var DEFAULT_SERVER_CONFIG = {
-  server: {
-    port: 5100,
-    host: "::"
-  },
-  git_hosts: [],
-  daemon_scheduler: {
-    enabled: true,
-    host: "localhost",
-    port: 5110,
-    workspace: "./data/daemon-workspace",
-    max_daemons: 20
-  },
-  doc_db: {
-    provider: "sqlite",
-    sqlite: {
-      path: "./data/c4a.db"
-    },
-    mongodb: {
-      uri: "mongodb://localhost:27017/c4a?directConnection=true",
-      database: "c4a"
-    }
-  },
-  graph_db: {
-    provider: "neo4j",
-    neo4j: {
-      uri: "bolt://localhost:7687",
-      username: "neo4j",
-      password: ""
-    },
-    nebulagraph: {
-      uri: "localhost:9669",
-      username: "root",
-      password: "nebula",
-      space: "c4a"
-    },
-    duckdb: {
-      path: "./data/c4a-graph.duckdb"
-    }
-  },
-  vector_db: {
-    provider: "lancedb",
-    collection_prefix: "c4a_",
-    qdrant: {
-      url: "http://localhost:6333",
-      api_key: ""
-    },
-    milvus: {
-      address: "localhost:19530"
-    },
-    lancedb: {
-      path: "./data/lancedb"
-    }
-  },
-  llm: {
-    provider: "openai",
-    openai: {
-      api_key: "",
-      base_url: "",
-      default_model: "gpt-5.3-codex",
-      wire_api: "chat"
-    },
-    anthropic: {
-      api_key: "",
-      base_url: "",
-      default_model: "claude-opus-4-6"
-    },
-    google: {
-      api_key: "",
-      base_url: "",
-      default_model: "gemini-3-pro-preview"
-    }
-  },
-  task: {
-    concurrency: {
-      code_index: 2,
-      doc_index: 2,
-      remote_clone: 2,
-      modeling: 1
-    },
-    default_timeout_ms: 150 * 60 * 1000,
-    memory_ttl_ms: 48 * 60 * 60 * 1000,
-    cleanup_interval_ms: 10 * 60 * 1000,
-    log_max_entries: 500
-  },
-  indexing: {
-    task_timeout_ms: 150 * 60 * 1000,
-    file_timeout_ms: 15 * 60 * 1000
-  },
-  intent_router: {
-    provider: "huggingface",
-    huggingface: {
-      model_id: "context4ai/intent-router-onnx",
-      cache_dir: "./models/intent-router"
-    },
-    xenova: {
-      model_id: "context4ai/intent-router-onnx",
-      cache_dir: "./models/intent-router"
-    }
-  },
-  embedding: {
-    provider: "huggingface",
-    huggingface: {
-      model_id: "Xenova/all-MiniLM-L6-v2",
-      dtype: "q8",
-      cache_dir: "./models/embedding"
-    },
-    xenova: {
-      model_id: "Xenova/bge-m3",
-      dtype: "q8",
-      cache_dir: "./models/embedding"
-    },
-    openai: {
-      api_key: "",
-      base_url: "",
-      model_id: "text-embedding-3-small"
-    },
-    google: {
-      api_key: "",
-      model_id: "text-embedding-004"
-    }
-  },
-  reranker: {
-    enabled: false,
-    provider: "huggingface",
-    huggingface: {
-      model_id: "onnx-community/bge-reranker-v2-m3-ONNX",
-      dtype: "q8",
-      cache_dir: "./models/reranker"
-    },
-    xenova: {
-      model_id: "onnx-community/bge-reranker-v2-m3-ONNX",
-      dtype: "q8",
-      cache_dir: "./models/reranker"
-    },
-    max_rerank: 20
-  }
-};
-// ../core/src/types/daemon.ts
-var CODE_PACKAGE_FILES = new Set([
-  "package.json",
-  "pyproject.toml",
-  "setup.py",
-  "go.mod",
-  "cargo.toml",
-  "pom.xml",
-  "build.gradle",
-  "build.gradle.kts"
-]);
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -12386,9 +12236,9 @@ class ExtractionPluginRegistry {
   register(plugin) {
     this.#plugins.push(plugin);
   }
-  resolve(source2) {
-    const declaredLanguage = source2.language?.toLowerCase();
-    const manifestLanguages = new Set(source2.manifests.flatMap((manifest) => MANIFEST_LANGUAGE_CANDIDATES[manifest.type] ?? []));
+  resolve(source) {
+    const declaredLanguage = source.language?.toLowerCase();
+    const manifestLanguages = new Set(source.manifests.flatMap((manifest) => MANIFEST_LANGUAGE_CANDIDATES[manifest.type] ?? []));
     const candidates = this.#plugins.filter((plugin) => {
       const pluginLanguages = plugin.languages.map((language) => language.toLowerCase());
       if (declaredLanguage) {
@@ -12400,7 +12250,7 @@ class ExtractionPluginRegistry {
       return pluginLanguages.some((language) => manifestLanguages.has(language));
     });
     for (const plugin of candidates) {
-      if (plugin.canHandle(source2)) {
+      if (plugin.canHandle(source)) {
         return plugin;
       }
     }
@@ -12503,29 +12353,29 @@ var resetParser = () => {
   parsedBytesSinceReset = 0;
   parserDead = false;
 };
-var tryParse = async (source2, isTsx) => {
+var tryParse = async (source, isTsx) => {
   const { parser, tsLanguage, tsxLanguage } = await initParser();
   parser.setLanguage(isTsx ? tsxLanguage : tsLanguage);
-  const tree = parser.parse(source2);
-  parsedBytesSinceReset += source2.length;
+  const tree = parser.parse(source);
+  parsedBytesSinceReset += source.length;
   if (tree.rootNode.hasError()) {
     return null;
   }
   return tree;
 };
-var parseFile = async (source2, isTsx) => {
+var parseFile = async (source, isTsx) => {
   if (parserDead)
     return null;
   if (parsedBytesSinceReset > PARSER_RESET_THRESHOLD) {
     resetParser();
   }
   try {
-    return await tryParse(source2, isTsx);
+    return await tryParse(source, isTsx);
   } catch {
     resetParser();
   }
   try {
-    return await tryParse(source2, isTsx);
+    return await tryParse(source, isTsx);
   } catch (error) {
     console.warn("[extract] Parser unrecoverable after retry, skipping remaining files:", error);
     parserDead = true;
@@ -12596,11 +12446,11 @@ var collectImportBindings = (root) => {
     const stringNode = node2.namedChildren.find((child) => child.type === "string");
     if (!stringNode)
       continue;
-    const source2 = stripQuotes(stringNode.text);
+    const source = stripQuotes(stringNode.text);
     const clause = node2.namedChildren.find((child) => child.type === "import_clause");
     for (const part of clause?.namedChildren ?? []) {
       if (part.type === "identifier") {
-        bindings.set(part.text, { source: source2, importedName: "default" });
+        bindings.set(part.text, { source, importedName: "default" });
         continue;
       }
       if (part.type !== "named_imports")
@@ -12608,7 +12458,7 @@ var collectImportBindings = (root) => {
       for (const specifier of part.namedChildren.filter((child) => child.type === "import_specifier")) {
         const parsed = parseImportSpecifier(specifier);
         if (parsed) {
-          bindings.set(parsed.localName, { source: source2, importedName: parsed.importedName });
+          bindings.set(parsed.localName, { source, importedName: parsed.importedName });
         }
       }
     }
@@ -12648,8 +12498,8 @@ var traceFile = async (filePath, fs, state) => {
   const promise = (async () => {
     state.inFlight.add(filePath);
     state.files.add(filePath);
-    const source2 = await fs.readFile(filePath);
-    const tree = await parseFile(source2, filePath.endsWith(".tsx"));
+    const source = await fs.readFile(filePath);
+    const tree = await parseFile(source, filePath.endsWith(".tsx"));
     if (!tree)
       return [];
     const root = tree.rootNode;
@@ -12778,10 +12628,10 @@ var BUILTIN_TYPES = new Set([
   "never",
   "any"
 ]);
-var countLines = (source2) => {
-  if (!source2)
+var countLines = (source) => {
+  if (!source)
     return 0;
-  const parts = source2.split(/\r\n|\r|\n/);
+  const parts = source.split(/\r\n|\r|\n/);
   return parts[parts.length - 1] === "" ? parts.length - 1 : parts.length;
 };
 var createRelation = (type, from, to, isExternal, line) => ({
@@ -13278,14 +13128,14 @@ var collectImportBindings2 = async (root, filePath, fs, resolver, relations) =>
   return bindings;
 };
 var analyzeFile = async (filePath, fs, resolver = { mappings: [] }) => {
-  const source2 = await fs.readFile(filePath);
-  const tree = await parseFile(source2, filePath.endsWith(".tsx"));
+  const source = await fs.readFile(filePath);
+  const tree = await parseFile(source, filePath.endsWith(".tsx"));
   if (!tree) {
     return {
       declarations: new Map,
       importBindings: new Map,
       relations: [],
-      lines: countLines(source2)
+      lines: countLines(source)
     };
   }
   const root = tree.rootNode;
@@ -13313,7 +13163,7 @@ var analyzeFile = async (filePath, fs, resolver = { mappings: [] }) => {
     declarations,
     importBindings,
     relations,
-    lines: countLines(source2)
+    lines: countLines(source)
   };
 };
 
@@ -13425,8 +13275,8 @@ class TypeScriptPlugin {
   languages = ["typescript", "tsx"];
   packageManagers = ["npm"];
   #lastDetection = null;
-  canHandle(source2) {
-    return source2.manifests.some((manifest) => manifest.type === "package.json");
+  canHandle(source) {
+    return source.manifests.some((manifest) => manifest.type === "package.json");
   }
   async detectEntries(manifest, fs) {
     const result = await detectEntries(manifest, fs);
@@ -13446,6 +13296,324 @@ class TypeScriptPlugin {
     return result;
   }
 }
+// src/reactRouter.ts
+import * as ts from "typescript";
+function compact(value) {
+  return value.replace(/\s+/gu, " ").trim();
+}
+function scalarValue(node2) {
+  if (!node2)
+    return;
+  if (ts.isStringLiteralLike(node2) || ts.isNoSubstitutionTemplateLiteral(node2))
+    return node2.text;
+  if (ts.isNumericLiteral(node2))
+    return Number(node2.text);
+  if (node2.kind === ts.SyntaxKind.TrueKeyword)
+    return true;
+  if (node2.kind === ts.SyntaxKind.FalseKeyword)
+    return false;
+  return;
+}
+function findDynamicImport(node2) {
+  let result;
+  const visit = (child) => {
+    if (result)
+      return;
+    if (ts.isCallExpression(child) && child.expression.kind === ts.SyntaxKind.ImportKeyword && child.arguments[0] && ts.isStringLiteralLike(child.arguments[0])) {
+      result = child.arguments[0].text;
+      return;
+    }
+    ts.forEachChild(child, visit);
+  };
+  visit(node2);
+  return result;
+}
+function parseSource(source, filePath) {
+  const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  const imports = new Map;
+  const constants2 = new Map;
+  for (const statement of sourceFile.statements) {
+    if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+      const moduleSource = statement.moduleSpecifier.text;
+      const clause = statement.importClause;
+      if (clause?.name)
+        imports.set(clause.name.text, moduleSource);
+      const bindings = clause?.namedBindings;
+      if (bindings && ts.isNamedImports(bindings)) {
+        for (const element of bindings.elements)
+          imports.set(element.name.text, moduleSource);
+      }
+      if (bindings && ts.isNamespaceImport(bindings))
+        imports.set(bindings.name.text, moduleSource);
+    }
+    if (!ts.isVariableStatement(statement))
+      continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
+        continue;
+      const scalar = scalarValue(declaration.initializer);
+      if (scalar !== undefined)
+        constants2.set(declaration.name.text, scalar);
+      const dynamicImport = findDynamicImport(declaration.initializer);
+      if (dynamicImport)
+        imports.set(declaration.name.text, dynamicImport);
+    }
+  }
+  return { sourceFile, imports, constants: constants2 };
+}
+function locationFor(filePath, sourceFile, node2) {
+  const start = sourceFile.getLineAndCharacterOfPosition(node2.getStart(sourceFile));
+  const end = sourceFile.getLineAndCharacterOfPosition(node2.getEnd());
+  return { path: filePath, startLine: start.line + 1, startColumn: start.character + 1, endLine: end.line + 1, endColumn: end.character + 1 };
+}
+function joinRoutePath(parent, child, index) {
+  if (index || !child || child === "/")
+    return parent || "/";
+  if (child.startsWith("/"))
+    return child.replace(/\/{2,}/gu, "/");
+  return `${parent.replace(/\/$/u, "")}/${child.replace(/^\//u, "")}`.replace(/\/{2,}/gu, "/");
+}
+function routeConditions(node2, sourceFile) {
+  const conditions = [];
+  let current = node2;
+  while (current?.parent) {
+    const parent = current.parent;
+    if (ts.isConditionalExpression(parent)) {
+      const condition = compact(parent.condition.getText(sourceFile));
+      conditions.push(current === parent.whenTrue ? condition : `!(${condition})`);
+    } else if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken && current === parent.right) {
+      conditions.push(compact(parent.left.getText(sourceFile)));
+    }
+    if (ts.isFunctionLike(parent))
+      break;
+    current = parent;
+  }
+  return [...new Set(conditions.reverse())];
+}
+function jsxAttributes(node2) {
+  const result = new Map;
+  for (const property of node2.attributes.properties)
+    if (ts.isJsxAttribute(property))
+      result.set(property.name.getText(), property);
+  return result;
+}
+function jsxExpression(attribute) {
+  const initializer = attribute?.initializer;
+  return initializer && ts.isJsxExpression(initializer) ? initializer.expression : undefined;
+}
+function jsxScalar(attribute, constants2) {
+  if (!attribute)
+    return;
+  if (!attribute.initializer)
+    return true;
+  if (ts.isStringLiteral(attribute.initializer))
+    return attribute.initializer.text;
+  const expression = jsxExpression(attribute);
+  return scalarValue(expression) ?? (expression && ts.isIdentifier(expression) ? constants2.get(expression.text) : undefined);
+}
+function descendantTags(node2) {
+  const tags = new Set;
+  const visit = (child) => {
+    if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
+      const opening = ts.isJsxElement(child) ? child.openingElement : child;
+      const tag = opening.tagName.getText();
+      if (child !== node2 && tag === "Route")
+        return;
+      if (!["Route", "Routes", "Suspense", "Fragment", "React.Fragment", "Navigate"].includes(tag))
+        tags.add(tag);
+    }
+    ts.forEachChild(child, visit);
+  };
+  visit(node2);
+  return [...tags];
+}
+function navigateTarget(node2, sourceFile) {
+  let target;
+  const visit = (child) => {
+    if (target)
+      return;
+    if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
+      const opening = ts.isJsxElement(child) ? child.openingElement : child;
+      if (child !== node2 && opening.tagName.getText() === "Route")
+        return;
+      if (opening.tagName.getText() === "Navigate") {
+        const attribute = jsxAttributes(opening).get("to");
+        const scalar = jsxScalar(attribute, new Map);
+        if (typeof scalar === "string")
+          target = scalar;
+        const expression = jsxExpression(attribute);
+        if (!target && expression) {
+          const text = expression.getText(sourceFile);
+          target = text.match(/pathname\s*:\s*['"]([^'"]+)['"]/u)?.[1] ?? compact(text);
+        }
+      }
+    }
+    ts.forEachChild(child, visit);
+  };
+  visit(node2);
+  return target;
+}
+function leadingNote(node2, sourceFile) {
+  const prefix = sourceFile.text.slice(Math.max(0, node2.getFullStart() - 600), node2.getStart(sourceFile));
+  const comments = [...prefix.matchAll(/\/\*+([\s\S]*?)\*\/|\/\/([^\n]*)/gu)];
+  const value = comments.at(-1)?.[1] ?? comments.at(-1)?.[2];
+  return value ? compact(value.replace(/^\s*\*\s?/gmu, "")) : undefined;
+}
+function componentSource(component, imports) {
+  const identifier = component?.match(/[A-Za-z_$][\w$]*/u)?.[0];
+  return identifier ? imports.get(identifier) : undefined;
+}
+function objectProperty(object2, name) {
+  for (const property of object2.properties) {
+    if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property))
+      continue;
+    const key = property.name && (ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name)) ? property.name.text : undefined;
+    if (key !== name)
+      continue;
+    return ts.isPropertyAssignment(property) ? property.initializer : property.name;
+  }
+  return;
+}
+function extractReactRouterRoutes(source, filePath, options = {}) {
+  const parsed = parseSource(source, filePath);
+  const routeIdPrefix = options.routeIdPrefix ?? filePath;
+  const mountPath = options.mountPath ?? "/";
+  const ignoredCandidates = new Set(options.ignoredComponentCandidates ?? []);
+  const routes = [];
+  const relativePath = (fullPath) => {
+    if (mountPath === "/")
+      return fullPath;
+    if (fullPath === mountPath)
+      return "/";
+    return fullPath.startsWith(`${mountPath.replace(/\/$/u, "")}/`) ? fullPath.slice(mountPath.length) : fullPath;
+  };
+  const pushRoute = (input) => {
+    const fullPath = joinRoutePath(input.parentPath, input.path, input.index);
+    const candidates = input.candidates ?? (input.component ? [input.component] : []);
+    const location = locationFor(filePath, parsed.sourceFile, input.node);
+    const sourceModule = componentSource(input.component ?? candidates[0], parsed.imports);
+    const note = leadingNote(input.node, parsed.sourceFile);
+    routes.push({
+      id: `${routeIdPrefix}:${fullPath}:${location.startLine}`,
+      kind: input.redirectTo ? "redirect" : input.component || candidates.length > 0 ? "page" : "group",
+      relativePath: relativePath(fullPath),
+      fullPath,
+      index: input.index,
+      ...input.component ? { component: input.component } : candidates[0] ? { component: candidates[0] } : {},
+      ...sourceModule ? { componentSource: sourceModule } : {},
+      componentCandidates: candidates,
+      ...input.redirectTo ? { redirectTo: input.redirectTo } : {},
+      conditions: routeConditions(input.node, parsed.sourceFile),
+      ...note ? { note } : {},
+      location
+    });
+    if (input.children)
+      visitRouteObjects(input.children, fullPath);
+  };
+  const visitRouteObjects = (array, parentPath) => {
+    for (const element of array.elements) {
+      if (!ts.isObjectLiteralExpression(element))
+        continue;
+      const index = scalarValue(objectProperty(element, "index")) === true;
+      const pathValue = scalarValue(objectProperty(element, "path"));
+      const componentNode = objectProperty(element, "Component") ?? objectProperty(element, "element") ?? objectProperty(element, "lazy");
+      const component = componentNode ? compact(componentNode.getText(parsed.sourceFile)) : undefined;
+      const redirectNode = objectProperty(element, "redirectTo") ?? objectProperty(element, "to");
+      const redirect = scalarValue(redirectNode);
+      const children = objectProperty(element, "children");
+      pushRoute({
+        node: element,
+        parentPath,
+        path: typeof pathValue === "string" ? pathValue : "",
+        index,
+        ...component ? { component } : {},
+        ...typeof redirect === "string" ? { redirectTo: redirect } : {},
+        ...children && ts.isArrayLiteralExpression(children) ? { children } : {}
+      });
+    }
+  };
+  const visit = (node2, parentPath) => {
+    if (ts.isJsxElement(node2) || ts.isJsxSelfClosingElement(node2)) {
+      const opening = ts.isJsxElement(node2) ? node2.openingElement : node2;
+      if (opening.tagName.getText() === "Route") {
+        const attributes = jsxAttributes(opening);
+        const index = jsxScalar(attributes.get("index"), parsed.constants) === true;
+        const pathValue = jsxScalar(attributes.get("path"), parsed.constants);
+        const componentNode = jsxExpression(attributes.get("Component"));
+        const elementNode = jsxExpression(attributes.get("element"));
+        const component = componentNode ? compact(componentNode.getText(parsed.sourceFile)) : undefined;
+        const candidateNode = elementNode ?? componentNode ?? node2;
+        const candidates = (component ? [component] : descendantTags(candidateNode)).filter((candidate) => !ignoredCandidates.has(candidate));
+        const fullPath = joinRoutePath(parentPath, typeof pathValue === "string" ? pathValue : "", index);
+        const redirectTo = navigateTarget(candidateNode, parsed.sourceFile);
+        pushRoute({ node: node2, parentPath, path: typeof pathValue === "string" ? pathValue : "", index, ...component ? { component } : {}, candidates, ...redirectTo ? { redirectTo } : {} });
+        if (ts.isJsxElement(node2))
+          for (const child of node2.children)
+            visit(child, fullPath);
+        return;
+      }
+    }
+    if (ts.isCallExpression(node2)) {
+      const callee = node2.expression.getText(parsed.sourceFile);
+      if ((callee === "createBrowserRouter" || callee === "createHashRouter" || callee === "useRoutes") && node2.arguments[0] && ts.isArrayLiteralExpression(node2.arguments[0])) {
+        visitRouteObjects(node2.arguments[0], mountPath);
+      }
+    }
+    ts.forEachChild(node2, (child) => visit(child, parentPath));
+  };
+  visit(parsed.sourceFile, mountPath);
+  return routes.sort((left, right) => left.fullPath.localeCompare(right.fullPath) || left.location.startLine - right.location.startLine || left.location.startColumn - right.location.startColumn);
+}
+// src/moduleExports.ts
+import * as ts2 from "typescript";
+function exportedDeclarationName(statement) {
+  const exported = ts2.canHaveModifiers(statement) && ts2.getModifiers(statement)?.some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword);
+  if (!exported)
+    return;
+  if ((ts2.isFunctionDeclaration(statement) || ts2.isClassDeclaration(statement) || ts2.isInterfaceDeclaration(statement) || ts2.isTypeAliasDeclaration(statement) || ts2.isEnumDeclaration(statement)) && statement.name) {
+    return statement.name.text;
+  }
+  return;
+}
+function extractTypeScriptModuleExports(source, filePath = "module.ts") {
+  const sourceFile = ts2.createSourceFile(filePath, source, ts2.ScriptTarget.Latest, true, filePath.endsWith("x") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS);
+  const named = new Set;
+  const wildcard = new Set;
+  const targets = new Set;
+  for (const statement of sourceFile.statements) {
+    if (ts2.isExportDeclaration(statement)) {
+      const target = statement.moduleSpecifier && ts2.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : undefined;
+      if (target)
+        targets.add(target);
+      if (!statement.exportClause) {
+        if (target)
+          wildcard.add(target);
+      } else if (ts2.isNamedExports(statement.exportClause)) {
+        for (const element of statement.exportClause.elements)
+          named.add(element.name.text);
+      } else if (ts2.isNamespaceExport(statement.exportClause)) {
+        named.add(statement.exportClause.name.text);
+      }
+      continue;
+    }
+    const declarationName = exportedDeclarationName(statement);
+    if (declarationName)
+      named.add(declarationName);
+    if (ts2.isVariableStatement(statement) && ts2.getModifiers(statement)?.some((modifier) => modifier.kind === ts2.SyntaxKind.ExportKeyword)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (ts2.isIdentifier(declaration.name))
+          named.add(declaration.name.text);
+      }
+    }
+  }
+  return {
+    named: [...named].sort(),
+    wildcard: [...wildcard].sort(),
+    targets: [...targets].sort()
+  };
+}
 export {
+  extractTypeScriptModuleExports,
+  extractReactRouterRoutes,
   TypeScriptPlugin
 };