@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/commands/inspect-request-values.js

@@ -0,0 +1,599 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSelectorToRequest = addSelectorToRequest;
+exports.resolveCliFilePath = resolveCliFilePath;
+exports.shouldAutoExcludeUsageTarget = shouldAutoExcludeUsageTarget;
+exports.isScopeBroaderThanTarget = isScopeBroaderThanTarget;
+exports.isPathInside = isPathInside;
+exports.samePath = samePath;
+exports.isExistingFile = isExistingFile;
+exports.isExistingDirectory = isExistingDirectory;
+exports.applyInspectMemberOptions = applyInspectMemberOptions;
+exports.readMaxCodeLines = readMaxCodeLines;
+exports.readPositiveIntegerFlag = readPositiveIntegerFlag;
+exports.readNonNegativeIntegerFlag = readNonNegativeIntegerFlag;
+exports.readPositiveInteger = readPositiveInteger;
+exports.readNonNegativeInteger = readNonNegativeInteger;
+exports.readBoolean = readBoolean;
+exports.payloadRequestsRanges = payloadRequestsRanges;
+exports.expandInspectStdinRequests = expandInspectStdinRequests;
+exports.expandInspectEntityRequest = expandInspectEntityRequest;
+exports.pickInspectRequestDefaults = pickInspectRequestDefaults;
+exports.readFlagValue = readFlagValue;
+exports.readFlagValues = readFlagValues;
+exports.isFlagValue = isFlagValue;
+exports.parseModulePlanModules = parseModulePlanModules;
+exports.parseUsageEntities = parseUsageEntities;
+exports.parseUsageEntity = parseUsageEntity;
+exports.parseModulePlanSymbol = parseModulePlanSymbol;
+exports.isInspectOp = isInspectOp;
+exports.toExtensionInspectOp = toExtensionInspectOp;
+exports.assertModulePlanAllowed = assertModulePlanAllowed;
+exports.throwInspectModulePlanUnsupported = throwInspectModulePlanUnsupported;
+exports.inspectArgsContainModulePlan = inspectArgsContainModulePlan;
+exports.firstString = firstString;
+exports.readDuplicateKindArgs = readDuplicateKindArgs;
+exports.readDuplicateKinds = readDuplicateKinds;
+exports.parseDuplicateEntityFilters = parseDuplicateEntityFilters;
+exports.parseDuplicatePathExcludes = parseDuplicatePathExcludes;
+exports.duplicateFilterObject = duplicateFilterObject;
+exports.normalizeDuplicateKinds = normalizeDuplicateKinds;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const errors_1 = require("../shared/errors");
+const inspect_selector_1 = require("./inspect-selector");
+const inspect_usages_detail_1 = require("./inspect-usages-detail");
+const session_workspace_1 = require("./session-workspace");
+function addSelectorToRequest(request, rawSelector, config) {
+    const selector = (0, inspect_selector_1.parseInspectSelector)(rawSelector, config);
+    request.symbolName = selector.symbolName;
+    if (selector.symbolKind) {
+        request.symbolKind = selector.symbolKind;
+    }
+}
+function resolveCliFilePath(cwd, filePath) {
+    return path.normalize(path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath));
+}
+function shouldAutoExcludeUsageTarget(cwd, targetPath, scopes) {
+    const normalizedTarget = path.normalize(targetPath);
+    if (scopes.length === 0) {
+        return !samePath(normalizedTarget, cwd);
+    }
+    return scopes.some((scope) => isScopeBroaderThanTarget(scope, normalizedTarget));
+}
+function isScopeBroaderThanTarget(scopePath, targetPath) {
+    const normalizedScope = path.normalize(scopePath);
+    const normalizedTarget = path.normalize(targetPath);
+    if (samePath(normalizedScope, normalizedTarget)) {
+        return false;
+    }
+    if (isExistingFile(normalizedScope)) {
+        return false;
+    }
+    return isPathInside(normalizedTarget, normalizedScope);
+}
+function isPathInside(filePath, possibleParentPath) {
+    const relative = path.relative(path.normalize(possibleParentPath), path.normalize(filePath));
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function samePath(left, right) {
+    return path.normalize(left).toLowerCase() === path.normalize(right).toLowerCase();
+}
+function isExistingFile(filePath) {
+    try {
+        return fs.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isExistingDirectory(filePath) {
+    try {
+        return fs.statSync(filePath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function applyInspectMemberOptions(request, options) {
+    if (options.memberAll) {
+        request.memberAll = true;
+        return;
+    }
+    if (typeof options.memberOffset === "number") {
+        request.memberOffset = options.memberOffset;
+    }
+    if (typeof options.memberLimit === "number") {
+        request.memberLimit = options.memberLimit;
+    }
+}
+function readMaxCodeLines(cwd, restArgs) {
+    const value = readFlagValue(restArgs, "--max-lines");
+    if (!value) {
+        return (0, session_workspace_1.readSessionNumberPref)(cwd, "inspect.code.maxNonEmptyLines", 120);
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new errors_1.CliError("INVALID_MAX_LINES", "Expected --max-lines to be a positive integer.");
+    }
+    return parsed;
+}
+function readPositiveIntegerFlag(restArgs, flag) {
+    const value = readFlagValue(restArgs, flag);
+    if (!value) {
+        return null;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new errors_1.CliError("INVALID_INSPECT_LIMIT", `Expected ${flag} to be a positive integer.`);
+    }
+    return parsed;
+}
+function readNonNegativeIntegerFlag(restArgs, flag) {
+    const value = readFlagValue(restArgs, flag);
+    if (!value) {
+        return null;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new errors_1.CliError("INVALID_INSPECT_OFFSET", `Expected ${flag} to be a non-negative integer.`);
+    }
+    return parsed;
+}
+function readPositiveInteger(value) {
+    const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function readNonNegativeInteger(value) {
+    const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    return Number.isInteger(parsed) && parsed >= 0 ? parsed : null;
+}
+function readBoolean(value) {
+    return typeof value === "boolean" ? value : null;
+}
+function payloadRequestsRanges(rawPayload) {
+    const rawRequests = expandInspectStdinRequests(rawPayload);
+    return rawRequests.some((rawRequest) => (0, inspect_usages_detail_1.isObject)(rawRequest) && (rawRequest.ranges === true || rawRequest.includeRanges === true));
+}
+function expandInspectStdinRequests(rawPayload) {
+    const topLevelBase = pickInspectRequestDefaults(rawPayload);
+    const rawRequests = Array.isArray(rawPayload.requests) ? rawPayload.requests : [rawPayload];
+    const expanded = [];
+    for (const rawRequest of rawRequests) {
+        if (!(0, inspect_usages_detail_1.isObject)(rawRequest)) {
+            expanded.push(rawRequest);
+            continue;
+        }
+        const request = {
+            ...topLevelBase,
+            ...rawRequest
+        };
+        delete request.requests;
+        const rawEntities = Array.isArray(request.entities) ? request.entities : null;
+        if (!rawEntities) {
+            delete request.entities;
+            expanded.push(request);
+            continue;
+        }
+        const requestOp = (0, inspect_usages_detail_1.readString)(request.op);
+        if (requestOp === "usages" || requestOp === "duplicate" || requestOp === "duplicates") {
+            expanded.push(request);
+            continue;
+        }
+        delete request.entities;
+        for (const rawEntity of rawEntities) {
+            if ((0, inspect_usages_detail_1.isObject)(rawEntity)) {
+                const nestedEntities = Array.isArray(rawEntity.entities) ? rawEntity.entities : null;
+                if (nestedEntities) {
+                    const entityDefaults = {
+                        ...rawEntity
+                    };
+                    delete entityDefaults.entities;
+                    for (const nestedEntity of nestedEntities) {
+                        expanded.push(expandInspectEntityRequest(request, entityDefaults, nestedEntity));
+                    }
+                    continue;
+                }
+                expanded.push({
+                    ...request,
+                    ...rawEntity
+                });
+                continue;
+            }
+            if (typeof rawEntity !== "string" || rawEntity.trim() === "") {
+                expanded.push({
+                    ...request,
+                    entity: rawEntity
+                });
+                continue;
+            }
+            expanded.push({
+                ...request,
+                entity: rawEntity.trim()
+            });
+        }
+    }
+    return expanded;
+}
+function expandInspectEntityRequest(request, entityDefaults, rawEntity) {
+    if ((0, inspect_usages_detail_1.isObject)(rawEntity)) {
+        return {
+            ...request,
+            ...entityDefaults,
+            ...rawEntity
+        };
+    }
+    if (typeof rawEntity === "string" && rawEntity.trim() !== "") {
+        return {
+            ...request,
+            ...entityDefaults,
+            entity: rawEntity.trim()
+        };
+    }
+    return {
+        ...request,
+        ...entityDefaults,
+        entity: rawEntity
+    };
+}
+function pickInspectRequestDefaults(rawPayload) {
+    const defaults = {};
+    for (const key of [
+        "op",
+        "sourceFile",
+        "file",
+        "target",
+        "usageTarget",
+        "dir",
+        "scope",
+        "scopes",
+        "excludeTarget",
+        "includeTarget",
+        "ranges",
+        "includeRanges",
+        "resolveStar",
+        "localOnly",
+        "parent",
+        "offset",
+        "limit",
+        "all",
+        "memberOffset",
+        "memberLimit",
+        "memberAll",
+        "detail",
+        "mode",
+        "kinds",
+        "entities",
+        "entity",
+        "exclude",
+        "excludes",
+        "pathExclude",
+        "pathExcludes",
+        "excludePath",
+        "excludePaths",
+        "toFile",
+        "outputFile",
+        "save",
+        "show",
+        "bundleSave",
+        "bundle",
+        "saveBundle",
+        "previewFiles",
+        "preview",
+        "previewDir",
+        "outputDir",
+        "previewPatch",
+        "modules",
+        "facade",
+        "facadeFile"
+    ]) {
+        if (rawPayload[key] !== undefined) {
+            defaults[key] = rawPayload[key];
+        }
+    }
+    return defaults;
+}
+function readFlagValue(args, flag) {
+    const index = args.indexOf(flag);
+    if (index < 0) {
+        return null;
+    }
+    const value = args[index + 1];
+    return value && !value.startsWith("--") ? value : null;
+}
+function readFlagValues(args, flag) {
+    const values = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] !== flag) {
+            continue;
+        }
+        const value = args[index + 1];
+        if (value && !value.startsWith("--")) {
+            values.push(value);
+        }
+    }
+    return values;
+}
+function isFlagValue(args, value) {
+    const index = args.indexOf(value);
+    return index > 0 && (args[index - 1] === "--parent" ||
+        args[index - 1] === "--max-lines" ||
+        args[index - 1] === "--to-file" ||
+        args[index - 1] === "--save" ||
+        args[index - 1] === "--bundle-save" ||
+        args[index - 1] === "--preview-dir" ||
+        args[index - 1] === "--from-json" ||
+        args[index - 1] === "--from-dsl" ||
+        args[index - 1] === "--from" ||
+        args[index - 1] === "--offset" ||
+        args[index - 1] === "--limit" ||
+        args[index - 1] === "--depth" ||
+        args[index - 1] === "--min-depth" ||
+        args[index - 1] === "--minDepth" ||
+        args[index - 1] === "--only" ||
+        args[index - 1] === "--max-code-lines" ||
+        args[index - 1] === "--maxCodeLines" ||
+        args[index - 1] === "--scope" ||
+        args[index - 1] === "--detail" ||
+        args[index - 1] === "--mode" ||
+        args[index - 1] === "--kind" ||
+        args[index - 1] === "--kinds" ||
+        args[index - 1] === "--entity" ||
+        args[index - 1] === "--entities" ||
+        args[index - 1] === "--exclude" ||
+        args[index - 1] === "--excludes" ||
+        args[index - 1] === "--path-exclude" ||
+        args[index - 1] === "--path-excludes" ||
+        args[index - 1] === "--exclude-path" ||
+        args[index - 1] === "--exclude-paths");
+}
+function parseModulePlanModules(cwd, rawModules, config) {
+    if (!Array.isArray(rawModules)) {
+        return [];
+    }
+    return rawModules
+        .filter(inspect_usages_detail_1.isObject)
+        .map((rawModule) => {
+        const targetFile = (0, inspect_usages_detail_1.readString)(rawModule.target) ?? (0, inspect_usages_detail_1.readString)(rawModule.targetFile) ?? (0, inspect_usages_detail_1.readString)(rawModule.file);
+        const rawSymbols = Array.isArray(rawModule.entities)
+            ? rawModule.entities
+            : Array.isArray(rawModule.symbols)
+                ? rawModule.symbols
+                : [];
+        return {
+            ...(targetFile ? { targetFile: resolveCliFilePath(cwd, targetFile) } : {}),
+            symbols: rawSymbols.map((rawSymbol) => parseModulePlanSymbol(rawSymbol, config)).filter(inspect_usages_detail_1.isObject)
+        };
+    });
+}
+function parseUsageEntities(rawEntities, config) {
+    return rawEntities.flatMap((rawEntity) => parseUsageEntity(rawEntity, config, {})).filter(inspect_usages_detail_1.isObject);
+}
+function parseUsageEntity(rawEntity, config, defaults) {
+    if (typeof rawEntity === "string" && rawEntity.trim() !== "") {
+        const parsed = (0, inspect_selector_1.parseInspectSelector)(rawEntity, config);
+        return [{
+                ...defaults,
+                raw: rawEntity.trim(),
+                symbolName: parsed.symbolName,
+                ...(parsed.symbolKind ? { symbolKind: parsed.symbolKind } : {})
+            }];
+    }
+    if (!(0, inspect_usages_detail_1.isObject)(rawEntity)) {
+        return [];
+    }
+    const parentSelector = (0, inspect_usages_detail_1.readString)(rawEntity.parent);
+    const entityDefaults = { ...defaults };
+    if (parentSelector) {
+        const parsedParent = (0, inspect_selector_1.parseInspectSelector)(parentSelector, config);
+        entityDefaults.parentName = parsedParent.symbolName;
+        if (parsedParent.symbolKind) {
+            entityDefaults.parentKind = parsedParent.symbolKind;
+        }
+    }
+    const nestedEntities = Array.isArray(rawEntity.entities) ? rawEntity.entities : null;
+    if (nestedEntities) {
+        return nestedEntities.flatMap((nestedEntity) => parseUsageEntity(nestedEntity, config, entityDefaults));
+    }
+    const selector = (0, inspect_usages_detail_1.readString)(rawEntity.entity) ?? (0, inspect_usages_detail_1.readString)(rawEntity.selector) ?? (0, inspect_usages_detail_1.readString)(rawEntity.raw);
+    if (!selector) {
+        return [];
+    }
+    const parsed = (0, inspect_selector_1.parseInspectSelector)(selector, config);
+    return [{
+            ...entityDefaults,
+            raw: selector,
+            symbolName: parsed.symbolName,
+            ...(parsed.symbolKind ? { symbolKind: parsed.symbolKind } : {})
+        }];
+}
+function parseModulePlanSymbol(rawSymbol, config) {
+    if (typeof rawSymbol === "string" && rawSymbol.trim() !== "") {
+        const parsed = (0, inspect_selector_1.parseInspectSelector)(rawSymbol, config);
+        return {
+            raw: rawSymbol.trim(),
+            symbolName: parsed.symbolName,
+            ...(parsed.symbolKind ? { symbolKind: parsed.symbolKind } : {})
+        };
+    }
+    if (!(0, inspect_usages_detail_1.isObject)(rawSymbol)) {
+        return null;
+    }
+    const selector = (0, inspect_usages_detail_1.readString)(rawSymbol.entity) ?? (0, inspect_usages_detail_1.readString)(rawSymbol.selector) ?? (0, inspect_usages_detail_1.readString)(rawSymbol.raw);
+    if (selector) {
+        const parsed = (0, inspect_selector_1.parseInspectSelector)(selector, config);
+        return {
+            raw: selector,
+            symbolName: parsed.symbolName,
+            ...(parsed.symbolKind ? { symbolKind: parsed.symbolKind } : {})
+        };
+    }
+    return rawSymbol;
+}
+function isInspectOp(value) {
+    return value === "file" ||
+        value === "exports" ||
+        value === "imports" ||
+        value === "members" ||
+        value === "code" ||
+        value === "deps" ||
+        value === "slice" ||
+        value === "modulePlan" ||
+        value === "usages" ||
+        value === "duplicate" ||
+        value === "duplicates" ||
+        value === "tree" ||
+        value === "aliasCandidates" ||
+        value === "alias-candidates" ||
+        value === "cycles";
+}
+function toExtensionInspectOp(op) {
+    if (op === "deps") {
+        return "dependencies";
+    }
+    if (op === "duplicate") {
+        return "duplicates";
+    }
+    if (op === "cycles") {
+        return "cycles";
+    }
+    if (op === "imports") {
+        return "imports";
+    }
+    if (op === "alias-candidates") {
+        return "aliasCandidates";
+    }
+    return op;
+}
+function assertModulePlanAllowed(op, allowModulePlan) {
+    if (op !== "modulePlan" || allowModulePlan) {
+        return;
+    }
+    throwInspectModulePlanUnsupported();
+}
+function throwInspectModulePlanUnsupported() {
+    throw new errors_1.CliError("INSPECT_MODULE_PLAN_UNSUPPORTED", "inspect is limited to file, exports, members, code, slice, deps, usages, duplicates, graph, tree, cycles, aliasCandidates, and imports. Use aib mutate preview or execute for module extraction mutations.");
+}
+function inspectArgsContainModulePlan(restArgs, stdinPayload) {
+    if (restArgs[0] === "modulePlan") {
+        return true;
+    }
+    if (!restArgs.includes("--stdin") || !(0, inspect_usages_detail_1.isObject)(stdinPayload)) {
+        return false;
+    }
+    const op = (0, inspect_usages_detail_1.readString)(stdinPayload.op);
+    if (op === "modulePlan") {
+        return true;
+    }
+    const requests = Array.isArray(stdinPayload.requests) ? stdinPayload.requests : [];
+    return requests.some((request) => (0, inspect_usages_detail_1.isObject)(request) && (0, inspect_usages_detail_1.readString)(request.op) === "modulePlan");
+}
+function firstString(value) {
+    if (typeof value === "string" && value.trim() !== "") {
+        return value.trim();
+    }
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    const first = value.find((item) => typeof item === "string" && item.trim() !== "");
+    return typeof first === "string" ? first.trim() : null;
+}
+function readDuplicateKindArgs(args, config) {
+    const values = [
+        ...readFlagValues(args, "--kind"),
+        ...readFlagValues(args, "--kinds").flatMap((value) => value.split(","))
+    ];
+    return normalizeDuplicateKinds(values, config);
+}
+function readDuplicateKinds(value, config) {
+    const values = (0, inspect_usages_detail_1.readStringArray)(value) ?? [];
+    return normalizeDuplicateKinds(values.flatMap((item) => item.split(",")), config);
+}
+function parseDuplicateEntityFilters(value, config) {
+    const rawValues = Array.isArray(value)
+        ? value
+        : typeof value === "string"
+            ? value.split(",")
+            : value && typeof value === "object" && !Array.isArray(value)
+                ? [value]
+                : [];
+    return rawValues.flatMap((rawValue) => {
+        if (typeof rawValue === "string") {
+            const trimmed = rawValue.trim();
+            if (!trimmed) {
+                return [];
+            }
+            const selector = (0, inspect_selector_1.parseInspectSelector)(trimmed, config);
+            return [duplicateFilterObject(selector.symbolName, selector.symbolKind ?? null)];
+        }
+        if (!(0, inspect_usages_detail_1.isObject)(rawValue)) {
+            return [];
+        }
+        const rawSelector = (0, inspect_usages_detail_1.readString)(rawValue.entity) ?? (0, inspect_usages_detail_1.readString)(rawValue.selector) ?? (0, inspect_usages_detail_1.readString)(rawValue.name);
+        if (!rawSelector) {
+            return [];
+        }
+        const selector = (0, inspect_selector_1.parseInspectSelector)(rawSelector, config);
+        return [duplicateFilterObject(selector.symbolName, selector.symbolKind ?? null)];
+    });
+}
+function parseDuplicatePathExcludes(cwd, value) {
+    const rawValues = Array.isArray(value)
+        ? value
+        : typeof value === "string"
+            ? value.split(",")
+            : [];
+    return rawValues
+        .filter((rawValue) => typeof rawValue === "string")
+        .map((rawValue) => rawValue.trim())
+        .filter((rawValue) => rawValue.length > 0)
+        .map((rawValue) => path.isAbsolute(rawValue) ? rawValue : path.resolve(cwd, rawValue))
+        .map((rawValue) => rawValue.replace(/\\/g, "/"));
+}
+function duplicateFilterObject(symbolName, symbolKind) {
+    return symbolKind ? { symbolName, symbolKind } : { symbolName };
+}
+function normalizeDuplicateKinds(values, config) {
+    const aliases = new Map();
+    for (const [kind, alias] of Object.entries(config.entityKindAliases)) {
+        aliases.set(kind.toLowerCase(), kind);
+        aliases.set(String(alias).toLowerCase(), kind);
+    }
+    const normalized = values
+        .map((value) => aliases.get(value.trim().toLowerCase()) ?? "")
+        .filter((value) => value !== "");
+    return Array.from(new Set(normalized));
+}

package/dist/commands/inspect-selector-kind.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSPECT_SELECTOR_KINDS = void 0;
+exports.isInspectSelectorKind = isInspectSelectorKind;
+exports.INSPECT_SELECTOR_KINDS = [
+    "class",
+    "interface",
+    "function",
+    "type",
+    "enum",
+    "namespace",
+    "variable",
+    "method",
+    "property",
+    "constructor",
+    "runtime",
+    "export"
+];
+function isInspectSelectorKind(value) {
+    return exports.INSPECT_SELECTOR_KINDS.includes(value);
+}

package/dist/commands/inspect-selector.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInspectSelector = parseInspectSelector;
+const inspect_selector_kind_1 = require("./inspect-selector-kind");
+function parseInspectSelector(raw, config) {
+    const trimmed = raw.trim();
+    if (trimmed === "constructor") {
+        return {
+            raw: trimmed,
+            symbolName: "constructor",
+            symbolKind: "constructor"
+        };
+    }
+    const parsed = parseWithSeparator(trimmed, config.selectorSeparator, config) ??
+        parseWithSeparator(trimmed, ":", config) ??
+        parseWithSeparator(trimmed, "-", config);
+    return parsed ?? {
+        raw: trimmed,
+        symbolName: trimmed,
+        symbolKind: null
+    };
+}
+function parseWithSeparator(raw, separator, config) {
+    const index = raw.indexOf(separator);
+    if (index <= 0) {
+        return null;
+    }
+    const rawKind = raw.slice(0, index).trim();
+    const symbolName = raw.slice(index + separator.length).trim();
+    if (!rawKind || !symbolName) {
+        return null;
+    }
+    const symbolKind = resolveKind(rawKind, config);
+    return symbolKind
+        ? {
+            raw,
+            symbolName,
+            symbolKind
+        }
+        : null;
+}
+function resolveKind(rawKind, config) {
+    const normalized = rawKind.toLowerCase();
+    if ((0, inspect_selector_kind_1.isInspectSelectorKind)(normalized)) {
+        return normalized;
+    }
+    const entityKind = Object.entries(config.entityKindAliases)
+        .find(([, alias]) => alias === rawKind)?.[0];
+    return entityKind ?? null;
+}