@stylelint/language-server 1.0.0

package/build/server/utils/objects/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/server/utils/objects/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,kCAAkC,CAAC"}

package/build/server/utils/objects/is-object.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns true if the value is a true object (i.e. not a primitive type).
+ */
+export declare function isObject(value: unknown): value is object;
+/**
+ * Returns true if the value is a plain object with no own enumerable properties.
+ */
+export declare function isEmptyObject(value: unknown): boolean;

package/build/server/utils/objects/is-object.js

@@ -0,0 +1,13 @@
+/**
+ * Returns true if the value is a true object (i.e. not a primitive type).
+ */
+export function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * Returns true if the value is a plain object with no own enumerable properties.
+ */
+export function isEmptyObject(value) {
+    return isObject(value) && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+//# sourceMappingURL=is-object.js.map

package/build/server/utils/objects/is-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-object.js","sourceRoot":"","sources":["../../../../src/server/utils/objects/is-object.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAc;IACtC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AACpD,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc;IAC3C,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC;AACpF,CAAC"}

package/build/server/utils/objects/merge-assign.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copies all enumerable properties from one or two source objects to a target
+ * object, recursing for nested objects. Merges arrays by concatenating them.
+ * @param target The target object to assign to.
+ * @param source1 The first source object from which to copy properties.
+ * @param source2 The second source object from which to copy properties.
+ */
+export declare function mergeAssign<T extends object, U extends object, V extends object>(target: T, source1: U | undefined, source2?: V): T & U & V;

package/build/server/utils/objects/merge-assign.js

@@ -0,0 +1,38 @@
+import { isObject } from './is-object.js';
+/**
+ * Copies all enumerable properties from one or two source objects to a target
+ * object, recursing for nested objects. Merges arrays by concatenating them.
+ * @param target The target object to assign to.
+ * @param source1 The first source object from which to copy properties.
+ * @param source2 The second source object from which to copy properties.
+ */
+export function mergeAssign(target, source1, source2) {
+    const targetAsUnion = target;
+    for (const object of [source1, source2]) {
+        if (!object) {
+            continue;
+        }
+        for (const key of Object.getOwnPropertyNames(object)) {
+            if (key === '__proto__' || key === 'constructor') {
+                continue;
+            }
+            const value = object[key];
+            if (isObject(value)) {
+                if (Array.isArray(value)) {
+                    const existing = targetAsUnion[key];
+                    targetAsUnion[key] = (Array.isArray(existing) ? existing.concat(value) : value);
+                    continue;
+                }
+                if (!targetAsUnion[key]) {
+                    targetAsUnion[key] = {};
+                }
+                targetAsUnion[key] = mergeAssign(targetAsUnion[key], value);
+            }
+            else {
+                targetAsUnion[key] = value;
+            }
+        }
+    }
+    return targetAsUnion;
+}
+//# sourceMappingURL=merge-assign.js.map

package/build/server/utils/objects/merge-assign.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-assign.js","sourceRoot":"","sources":["../../../../src/server/utils/objects/merge-assign.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAC1B,MAAS,EACT,OAAsB,EACtB,OAAW;IAEX,MAAM,aAAa,GAAG,MAAmB,CAAC;IAE1C,KAAK,MAAM,MAAM,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;QACzC,IAAI,CAAC,MAAM,EAAE,CAAC;YACb,SAAS;QACV,CAAC;QAED,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAA4B,EAAE,CAAC;YACjF,IAAI,GAAG,KAAK,WAAW,IAAI,GAAG,KAAK,aAAa,EAAE,CAAC;gBAClD,SAAS;YACV,CAAC;YAED,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YAE1B,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gBACrB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC1B,MAAM,QAAQ,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;oBAEpC,aAAa,CAAC,GAAG,CAAC,GAAG,CACpB,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAE,KAAiB,CAC1C,CAAC;oBAE7B,SAAS;gBACV,CAAC;gBAED,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;oBACzB,aAAa,CAAC,GAAG,CAAC,GAAG,EAA6B,CAAC;gBACpD,CAAC;gBAED,aAAa,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,aAAa,CAAC,GAAG,CAAW,EAAE,KAAK,CAErD,CAAC;YACjB,CAAC;iBAAM,CAAC;gBACP,aAAa,CAAC,GAAG,CAAC,GAAG,KAAgC,CAAC;YACvD,CAAC;QACF,CAAC;IACF,CAAC;IAED,OAAO,aAAa,CAAC;AACtB,CAAC"}

package/build/server/utils/objects/merge-options-with-defaults.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Merges options with default values and returns a new object. Nested objects
+ * are also merged. Properties not present in the defaults are not copied.
+ */
+export declare function mergeOptionsWithDefaults<T extends object>(options: unknown, defaults: T): T;

package/build/server/utils/objects/merge-options-with-defaults.js

@@ -0,0 +1,56 @@
+import rfdc from 'rfdc';
+import { isObject } from './is-object.js';
+const deepClone = rfdc();
+/**
+ * Merges options with default values and returns a new object. Nested objects
+ * are also merged. Properties not present in the defaults are not copied.
+ */
+function mergeOptionsWithDefaultsInner(options, defaults, seen, mapped, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+circulars) {
+    if (!isObject(options)) {
+        return deepClone(defaults);
+    }
+    const result = {};
+    for (const key of Object.keys(defaults)) {
+        const fromDefaults = defaults[key];
+        const fromOptions = options[key];
+        if (fromOptions !== undefined) {
+            if (isObject(fromOptions)) {
+                if (seen.has(fromOptions)) {
+                    circulars.add([fromOptions, result, key]);
+                    continue;
+                }
+                seen.add(fromOptions);
+                const value = Array.isArray(fromOptions)
+                    ? fromOptions.map((item) => deepClone(item))
+                    : isObject(fromDefaults) && !Array.isArray(fromDefaults)
+                        ? mergeOptionsWithDefaultsInner(fromOptions, fromDefaults, seen, mapped, circulars)
+                        : deepClone(fromOptions);
+                mapped.set(fromOptions, value);
+                result[key] = value;
+                continue;
+            }
+            result[key] = fromOptions;
+            continue;
+        }
+        result[key] = deepClone(fromDefaults);
+    }
+    return result;
+}
+/**
+ * Merges options with default values and returns a new object. Nested objects
+ * are also merged. Properties not present in the defaults are not copied.
+ */
+export function mergeOptionsWithDefaults(options, defaults) {
+    // Track references to avoid circular infinite recursion.
+    const seen = new WeakSet();
+    const mapped = new WeakMap();
+    const circulars = new Set();
+    const result = mergeOptionsWithDefaultsInner(options, defaults, seen, mapped, circulars);
+    for (const [circular, obj, key] of circulars) {
+        obj[key] = mapped.get(circular);
+    }
+    return result;
+}
+//# sourceMappingURL=merge-options-with-defaults.js.map

package/build/server/utils/objects/merge-options-with-defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-options-with-defaults.js","sourceRoot":"","sources":["../../../../src/server/utils/objects/merge-options-with-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,MAAM,SAAS,GAAG,IAAI,EAAE,CAAC;AAIzB;;;GAGG;AACH,SAAS,6BAA6B,CACrC,OAAgB,EAChB,QAAW,EACX,IAAqB,EACrB,MAAgC;AAChC,8DAA8D;AAC9D,SAA6B;IAE7B,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACxB,OAAO,SAAS,CAAC,QAAQ,CAAC,CAAC;IAC5B,CAAC;IAED,MAAM,MAAM,GAAG,EAAO,CAAC;IAEvB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAgB,EAAE,CAAC;QACxD,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;QAEnC,MAAM,WAAW,GAAY,OAAO,CAAC,GAA2B,CAAC,CAAC;QAElE,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC/B,IAAI,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;gBAC3B,IAAI,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;oBAC3B,SAAS,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;oBAE1C,SAAS;gBACV,CAAC;gBAED,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;gBAEtB,MAAM,KAAK,GAAY,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC;oBAChD,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,IAAa,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;oBACrD,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC;wBACvD,CAAC,CAAC,6BAA6B,CAAC,WAAW,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC;wBACnF,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;gBAE3B,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;gBAE/B,MAAM,CAAC,GAAG,CAAC,GAAG,KAAmB,CAAC;gBAElC,SAAS;YACV,CAAC;YAED,MAAM,CAAC,GAAG,CAAC,GAAG,WAAyB,CAAC;YAExC,SAAS;QACV,CAAC;QAED,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;IACvC,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,wBAAwB,CAAmB,OAAgB,EAAE,QAAW;IACvF,yDAAyD;IACzD,MAAM,IAAI,GAAG,IAAI,OAAO,EAAU,CAAC;IACnC,MAAM,MAAM,GAAG,IAAI,OAAO,EAAiC,CAAC;IAC5D,MAAM,SAAS,GAAG,IAAI,GAAG,EAAuD,CAAC;IAEjF,MAAM,MAAM,GAAG,6BAA6B,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;IAEzF,KAAK,MAAM,CAAC,QAAQ,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,SAAS,EAAE,CAAC;QAC9C,GAAG,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACjC,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC"}

package/build/server/utils/sets.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the intersection of the given sets. If one of the sets is
+ * `undefined`, the other set is returned. If both sets are `undefined`,
+ * returns `undefined`.
+ */
+export declare function intersect<T>(set1: Set<T> | undefined, set2: Set<T> | undefined): Set<T> | undefined;

package/build/server/utils/sets.js

@@ -0,0 +1,22 @@
+/**
+ * Returns the intersection of the given sets. If one of the sets is
+ * `undefined`, the other set is returned. If both sets are `undefined`,
+ * returns `undefined`.
+ */
+export function intersect(set1, set2) {
+    if (!set1) {
+        return set2;
+    }
+    if (!set2) {
+        return set1;
+    }
+    const [smallerSet, largerSet] = set1.size < set2.size ? [set1, set2] : [set2, set1];
+    const result = new Set();
+    for (const item of smallerSet) {
+        if (largerSet.has(item)) {
+            result.add(item);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=sets.js.map

package/build/server/utils/sets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sets.js","sourceRoot":"","sources":["../../../src/server/utils/sets.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,UAAU,SAAS,CACxB,IAAwB,EACxB,IAAwB;IAExB,IAAI,CAAC,IAAI,EAAE,CAAC;QACX,OAAO,IAAI,CAAC;IACb,CAAC;IAED,IAAI,CAAC,IAAI,EAAE,CAAC;QACX,OAAO,IAAI,CAAC;IACb,CAAC;IAED,MAAM,CAAC,UAAU,EAAE,SAAS,CAAC,GAAG,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAEpF,MAAM,MAAM,GAAG,IAAI,GAAG,EAAK,CAAC;IAE5B,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC/B,IAAI,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACzB,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAClB,CAAC;IACF,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC"}

package/build/server/utils/strings.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Upper-cases the first letter of a string.
+ */
+export declare const upperCaseFirstChar: (str: string) => string;
+/**
+ * Pads a string to a certain length with spaces.
+ */
+export declare const padString: (str: string, length: number) => string;
+/**
+ * Pads a number to a certain length with zeros.
+ */
+export declare const padNumber: (number: number, length: number) => string;

package/build/server/utils/strings.js

@@ -0,0 +1,20 @@
+/**
+ * Upper-cases the first letter of a string.
+ */
+export const upperCaseFirstChar = (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+};
+/**
+ * Pads a string to a certain length with spaces.
+ */
+export const padString = (str, length) => {
+    return str + ' '.repeat(length - str.length);
+};
+/**
+ * Pads a number to a certain length with zeros.
+ */
+export const padNumber = (number, length) => {
+    const str = String(number);
+    return '0'.repeat(length - str.length) + str;
+};
+//# sourceMappingURL=strings.js.map

package/build/server/utils/strings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings.js","sourceRoot":"","sources":["../../../src/server/utils/strings.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,GAAW,EAAU,EAAE;IACzD,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACnD,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,GAAW,EAAE,MAAc,EAAU,EAAE;IAChE,OAAO,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC;AAC9C,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,MAAc,EAAE,MAAc,EAAU,EAAE;IACnE,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IAE3B,OAAO,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC;AAC9C,CAAC,CAAC"}

package/build/server/utils/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Makes all properties of type `T` optional except for those in `K`.
+ */
+export type OptionalExcept<T extends Record<never, never>, K extends keyof T> = Pick<T, K> & Partial<Pick<T, K>>;
+/**
+ * Makes all properties of type `T` required except for those in `K`.
+ */
+export type RequiredExcept<T extends Record<never, never>, K extends keyof T> = Pick<T, Exclude<keyof T, K>> & Required<Pick<T, K>>;
+/**
+ * Extracts keys from a type `T` the values of which are type `V`.
+ */
+export type ExtractKeysOfValueType<T, V> = {
+    [K in keyof T]-?: T[K] extends V ? K : never;
+}[keyof T];
+/**
+ * Given a function `T`, returns a function type with the same parameters, but
+ * with the return type `Promise<R> | R` where `R` is the return type of `T`.
+ */
+export type MaybeAsync<T extends (...args: any[]) => any> = (...args: Parameters<T>) => Promise<ReturnType<T>> | ReturnType<T>;
+export type { PublicOnly, PublicOnlyIfObject } from '../../shared/types.js';
+/**
+ * Given a type `T`, returns a type with only the public properties of `T` and
+ * its descendants.
+ */
+export type PublicOnlyDeep<T> = {
+    [K in keyof T]: T[K] extends Function ? T[K] : T[K] extends object ? PublicOnlyDeep<T[K]> : T[K];
+};

package/build/server/utils/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build/server/utils/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/server/utils/types.ts"],"names":[],"mappings":""}

package/build/server/worker/types.d.ts

@@ -0,0 +1,63 @@
+import type stylelint from 'stylelint';
+import type { LinterResult, RuleMetadataSnapshot, RunnerOptions } from '../stylelint/types.js';
+export declare const stylelintNotFoundError = "STYLELINT_NOT_FOUND";
+export type WorkerLintPayload = {
+    options: stylelint.LinterOptions;
+    stylelintPath?: string;
+    runnerOptions?: RunnerOptions;
+};
+export type WorkerResolvePayload = {
+    stylelintPath?: string;
+    codeFilename?: string;
+    runnerOptions?: RunnerOptions;
+};
+export type WorkerResolveConfigPayload = {
+    filePath: string;
+    stylelintPath?: string;
+    runnerOptions?: RunnerOptions;
+};
+export type WorkerLintResult = {
+    resolvedPath: string;
+    linterResult: LinterResult;
+    ruleMetadata?: RuleMetadataSnapshot;
+};
+export type WorkerResolveResult = {
+    resolvedPath: string;
+    entryPath: string;
+    version?: string;
+};
+export type WorkerResolveConfigResult = {
+    resolvedPath: string;
+    config: stylelint.Config | undefined;
+};
+export type WorkerRequest = {
+    id: string;
+    type: 'lint';
+    payload: WorkerLintPayload;
+} | {
+    id: string;
+    type: 'resolve';
+    payload: WorkerResolvePayload;
+} | {
+    id: string;
+    type: 'resolveConfig';
+    payload: WorkerResolveConfigPayload;
+} | {
+    id: string;
+    type: 'shutdown';
+};
+export type SerializedWorkerError = {
+    name?: string;
+    message: string;
+    stack?: string;
+    code?: string;
+};
+export type WorkerResponse = {
+    id: string;
+    success: true;
+    result?: WorkerLintResult | WorkerResolveResult | WorkerResolveConfigResult | undefined;
+} | {
+    id: string;
+    success: false;
+    error: SerializedWorkerError;
+};

package/build/server/worker/types.js

@@ -0,0 +1,2 @@
+export const stylelintNotFoundError = 'STYLELINT_NOT_FOUND';
+//# sourceMappingURL=types.js.map

package/build/server/worker/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/server/worker/types.ts"],"names":[],"mappings":"AAIA,MAAM,CAAC,MAAM,sBAAsB,GAAG,qBAAqB,CAAC"}

package/build/server/worker/worker-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/build/server/worker/worker-entry.js

@@ -0,0 +1,320 @@
+// @no-unit-test -- This is an entry point that cannot feasibly be unit tested.
+import fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { GlobalPathResolverService } from '../services/stylelint-runtime/global-path-resolver.service.js';
+import { PackageRootService } from '../services/stylelint-runtime/package-root.service.js';
+import { ProcessRunnerService } from '../services/stylelint-runtime/process-runner.service.js';
+import { loadStylelint } from '../stylelint/load-stylelint.js';
+import { stylelintNotFoundError, } from './types.js';
+import { createWorkerLoggingService } from './worker-logging.service.js';
+const toAbsoluteDir = (dir) => path.isAbsolute(dir) ? dir : path.resolve(process.cwd(), dir);
+const workspaceRequire = createRequire(path.join(process.cwd(), '__stylelint_worker_index__.js'));
+const workerLoggingService = createWorkerLoggingService();
+const globalPathResolver = new GlobalPathResolverService(os, path, new ProcessRunnerService(), workerLoggingService);
+const packageRootFinder = new PackageRootService();
+const state = {};
+const createLinterResultSubset = (linterResult) => {
+    const subset = {
+        results: (Array.isArray(linterResult.results) ? linterResult.results : []).map(({ source, warnings, invalidOptionWarnings, ignored }) => ({
+            source,
+            warnings: warnings ?? [],
+            invalidOptionWarnings: invalidOptionWarnings ?? [],
+            ignored,
+        })),
+    };
+    const report = linterResult.report;
+    if (typeof report === 'string') {
+        subset.report = report;
+    }
+    const code = linterResult.code;
+    if (typeof code === 'string') {
+        subset.code = code;
+    }
+    if (!report && !code) {
+        const output = linterResult.output;
+        if (typeof output === 'string') {
+            subset.output = output;
+        }
+    }
+    if (linterResult.ruleMetadata) {
+        subset.ruleMetadata = linterResult.ruleMetadata;
+    }
+    return subset;
+};
+const isPromiseLike = (value) => typeof value === 'object' && value !== null && 'then' in value;
+const sendMessage = (message) => {
+    if (typeof process.send === 'function') {
+        process.send(message);
+    }
+};
+const serializeError = (error) => {
+    if (error instanceof Error) {
+        const rawCode = error.code;
+        const serialized = {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+            code: typeof rawCode === 'number' ? String(rawCode) : rawCode,
+        };
+        return serialized;
+    }
+    return {
+        name: 'Error',
+        message: typeof error === 'string' ? error : 'Unknown error',
+    };
+};
+const createNotFoundError = () => {
+    const error = new Error('Stylelint could not be resolved from the current workspace.');
+    error.code = stylelintNotFoundError;
+    return error;
+};
+/**
+ * Creates a snapshot of the rule metadata from the provided Stylelint module.
+ */
+async function snapshotRuleMetadata(stylelintModule) {
+    const rulesSource = stylelintModule.rules;
+    if (!rulesSource) {
+        return undefined;
+    }
+    let resolvedRules;
+    if (typeof rulesSource === 'function') {
+        resolvedRules = await rulesSource();
+    }
+    else if (isPromiseLike(rulesSource)) {
+        resolvedRules = await rulesSource;
+    }
+    else {
+        resolvedRules = rulesSource;
+    }
+    if (!resolvedRules || typeof resolvedRules !== 'object') {
+        return undefined;
+    }
+    const metadata = {};
+    for (const [name, ruleOrPromise] of Object.entries(resolvedRules)) {
+        const rulePromise = isPromiseLike(ruleOrPromise)
+            ? ruleOrPromise
+            : Promise.resolve(ruleOrPromise);
+        const rule = await rulePromise;
+        const meta = rule?.meta;
+        if (meta) {
+            metadata[name] = meta;
+        }
+    }
+    return Object.keys(metadata).length ? metadata : undefined;
+}
+/**
+ * Reads the version of the Stylelint package from its package.json.
+ */
+async function readPackageVersion(packageRoot) {
+    if (!packageRoot) {
+        return undefined;
+    }
+    try {
+        const manifestPath = path.join(packageRoot, 'package.json');
+        const rawManifest = await fs.readFile(manifestPath, 'utf8');
+        const manifest = JSON.parse(rawManifest);
+        return manifest.version;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Attempts to resolve Stylelint from the global modules path for the specified package manager.
+ */
+async function resolveFromGlobal(packageManager, resolver) {
+    if (!packageManager) {
+        return undefined;
+    }
+    const globalModulesPath = await globalPathResolver.resolve(packageManager);
+    if (!globalModulesPath) {
+        return undefined;
+    }
+    return await resolver(globalModulesPath);
+}
+/**
+ * Determines how the worker should resolve the Stylelint module for linting requests.
+ * @param stylelintPath Optional explicit path provided by the caller.
+ * @param codeFilename Optional file currently being linted to guide module resolution.
+ */
+async function resolveStylelintTarget(stylelintPath, codeFilename, runnerOptions) {
+    if (stylelintPath) {
+        const normalizedPath = path.isAbsolute(stylelintPath)
+            ? stylelintPath
+            : path.resolve(process.cwd(), stylelintPath);
+        const resolvedPath = (await packageRootFinder.find(normalizedPath)) ?? normalizedPath;
+        return {
+            specifier: normalizedPath,
+            entryPath: normalizedPath,
+            requireFn: workspaceRequire,
+            resolvedPath,
+        };
+    }
+    const candidateDirs = new Set();
+    if (codeFilename) {
+        candidateDirs.add(path.dirname(codeFilename));
+    }
+    candidateDirs.add(process.cwd());
+    const tryResolveFromDir = async (dir) => {
+        const baseDir = toAbsoluteDir(dir);
+        const requireFn = createRequire(path.join(baseDir, '__stylelint_worker_index__.js'));
+        try {
+            const entryPath = requireFn.resolve('stylelint');
+            const resolvedPath = (await packageRootFinder.find(entryPath)) ?? entryPath;
+            return {
+                specifier: 'stylelint',
+                entryPath,
+                requireFn,
+                resolvedPath,
+            };
+        }
+        catch (error) {
+            if (error.code !== 'MODULE_NOT_FOUND') {
+                throw error;
+            }
+            return undefined;
+        }
+    };
+    for (const dir of candidateDirs) {
+        const resolved = await tryResolveFromDir(dir);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    const globalResolved = await resolveFromGlobal(runnerOptions?.packageManager, tryResolveFromDir);
+    if (globalResolved) {
+        return globalResolved;
+    }
+    throw createNotFoundError();
+}
+/**
+ * Ensures that the Stylelint module is loaded and ready for use.
+ */
+async function ensureStylelint(stylelintPath, codeFilename, runnerOptions) {
+    const target = await resolveStylelintTarget(stylelintPath, codeFilename, runnerOptions);
+    if (state.stylelint && state.resolvedPath === target.resolvedPath) {
+        return;
+    }
+    try {
+        const { stylelint: loaded } = await loadStylelint(packageRootFinder, target.specifier, target.requireFn, target.entryPath);
+        state.stylelint = loaded;
+        state.entryPath = target.entryPath;
+        state.resolvedPath = target.resolvedPath;
+        state.ruleMetadata = await snapshotRuleMetadata(loaded);
+        state.version = await readPackageVersion(target.resolvedPath);
+    }
+    catch (error) {
+        const code = error.code;
+        const isModuleNotFound = code === 'MODULE_NOT_FOUND' || code === stylelintNotFoundError;
+        if (isModuleNotFound) {
+            throw createNotFoundError();
+        }
+        throw error;
+    }
+}
+/**
+ * Handles a resolve request from the parent process.
+ */
+async function handleResolve(request) {
+    await ensureStylelint(request.payload.stylelintPath, request.payload.codeFilename, request.payload.runnerOptions);
+    if (!state.resolvedPath || !state.entryPath) {
+        throw createNotFoundError();
+    }
+    sendMessage({
+        id: request.id,
+        success: true,
+        result: {
+            resolvedPath: state.resolvedPath,
+            entryPath: state.entryPath,
+            version: state.version,
+        },
+    });
+}
+/**
+ * Handles a lint request from the parent process.
+ */
+async function handleLint(request) {
+    await ensureStylelint(request.payload.stylelintPath, request.payload.options.codeFilename, request.payload.runnerOptions);
+    if (!state.stylelint || !state.resolvedPath) {
+        throw createNotFoundError();
+    }
+    const linterResult = await state.stylelint.lint(request.payload.options);
+    const subsetResult = createLinterResultSubset(linterResult);
+    sendMessage({
+        id: request.id,
+        success: true,
+        result: {
+            resolvedPath: state.resolvedPath,
+            linterResult: subsetResult,
+            ruleMetadata: state.ruleMetadata,
+        },
+    });
+}
+/**
+ * Handles a resolveConfig request from the parent process.
+ */
+async function handleResolveConfig(request) {
+    await ensureStylelint(request.payload.stylelintPath, request.payload.filePath, request.payload.runnerOptions);
+    if (!state.stylelint || !state.resolvedPath) {
+        throw createNotFoundError();
+    }
+    // resolveConfig was added in Stylelint 14.2.0.
+    const resolveConfigFn = state.stylelint.resolveConfig;
+    let config;
+    if (typeof resolveConfigFn === 'function') {
+        config = await resolveConfigFn(request.payload.filePath);
+    }
+    sendMessage({
+        id: request.id,
+        success: true,
+        result: {
+            resolvedPath: state.resolvedPath,
+            config,
+        },
+    });
+}
+const handleMessage = async (request) => {
+    if (!request) {
+        return;
+    }
+    try {
+        switch (request.type) {
+            case 'resolve': {
+                await handleResolve(request);
+                break;
+            }
+            case 'resolveConfig': {
+                await handleResolveConfig(request);
+                break;
+            }
+            case 'lint': {
+                await handleLint(request);
+                break;
+            }
+            case 'shutdown': {
+                sendMessage({ id: request.id, success: true });
+                process.exitCode = 0;
+                return;
+            }
+            default:
+                throw new Error(`Unknown worker request type: ${request.type}`);
+        }
+    }
+    catch (error) {
+        sendMessage({
+            id: request.id,
+            success: false,
+            error: serializeError(error),
+        });
+    }
+};
+process.on('message', (request) => {
+    void handleMessage(request);
+});
+process.on('disconnect', () => {
+    process.exitCode = 0;
+});
+//# sourceMappingURL=worker-entry.js.map