@litfamily/litcodex 1.0.0

package/marketplace/plugins/litcodex/components/rules/dist/static-injection.js

@@ -0,0 +1,183 @@
+import { existsSync, readFileSync } from "node:fs";
+import { configFromEnvironment } from "./config.js";
+import { withOptionalContextBudget, withPromptBudget } from "./event-budget.js";
+import { formatAdditionalContextOutput, prepareAdditionalContext } from "./hook-output.js";
+import { loadOutputStyleText } from "./output-style-injection.js";
+import { completePostCompactRecovery, hydrateEngineState, persistEngineState, retryPostCompactRecovery, } from "./persistent-cache.js";
+import { withPostCompactBudget } from "./post-compact-budget.js";
+import { buildPostCompactReadDirective, listPostCompactDirectivePaths } from "./post-compact-directive.js";
+import { parseRule } from "./rules/parser.js";
+import { isNeverTruncatedRule } from "./rules/truncator.js";
+import { createRulesEngine } from "./rules-engine-factory.js";
+import { getShellRuntimeAwareness, SHELL_AWARENESS_DEDUP_KEY } from "./shell-awareness.js";
+import { filterRulesAlreadyInTranscript, filterRulesNotInTranscriptText } from "./transcript-rule-filter.js";
+import { readTranscriptSearchText } from "./transcript-search.js";
+export function runStaticInjection(cwd, transcriptPath, eventName, cachePath, options, completedPostCompactChannel, transcriptSearchOptions = {}, model) {
+    const config = configFromEnvironment(options.env);
+    if (config.disabled || config.mode === "off" || config.mode === "dynamic") {
+        if (completedPostCompactChannel !== undefined) {
+            completePostCompactRecovery(cachePath, completedPostCompactChannel);
+        }
+        return "";
+    }
+    if (completedPostCompactChannel !== undefined) {
+        return runPostCompactRecovery({
+            cwd,
+            transcriptPath,
+            eventName,
+            cachePath,
+            options,
+            channel: completedPostCompactChannel,
+            model: model ?? "",
+            config,
+        });
+    }
+    const effectiveConfig = eventName === "UserPromptSubmit" ? withPromptBudget(config) : config;
+    const engine = createRulesEngine(options, effectiveConfig);
+    hydrateEngineState(engine, cachePath);
+    engine.state.cwd = cwd;
+    const loaded = engine.loadStaticRules(cwd);
+    const rules = filterRulesAlreadyInTranscript(loaded.rules.filter((rule) => !engine.isStaticInjected(rule)), transcriptPath, (rule) => {
+        engine.markStaticInjected(rule);
+    }, transcriptSearchOptions);
+    const shellAwareness = engine.state.staticDedup.has(SHELL_AWARENESS_DEDUP_KEY)
+        ? ""
+        : getShellRuntimeAwareness(options.env);
+    const outputStyle = loadOutputStyleText(options.env);
+    if (rules.length === 0 && shellAwareness.length === 0 && outputStyle.length === 0) {
+        persistEngineState(engine, cachePath);
+        return "";
+    }
+    const contextBudget = withOptionalContextBudget(effectiveConfig, [shellAwareness, outputStyle], rules.length > 0);
+    Object.assign(effectiveConfig, contextBudget.config);
+    const formatted = engine.formatStaticResult(rules);
+    const combinedContext = combineStaticContext(formatted.block, ...contextBudget.blocks);
+    const deliveredContext = prepareAdditionalContext(combinedContext);
+    if (formatted.block.length > 0 && deliveredContext.startsWith(formatted.block.trim())) {
+        for (const rule of formatted.rules) {
+            engine.markStaticInjected(rule);
+        }
+    }
+    const shellContextPrefix = combineStaticContext(formatted.block, shellAwareness);
+    if (shellAwareness.length > 0 &&
+        contextBudget.blocks.includes(shellAwareness) &&
+        deliveredContext.startsWith(shellContextPrefix.trim())) {
+        engine.state.staticDedup.add(SHELL_AWARENESS_DEDUP_KEY);
+    }
+    persistEngineState(engine, cachePath);
+    return formatAdditionalContextOutput(eventName, combinedContext);
+}
+function runPostCompactRecovery(input) {
+    const effectiveConfig = withPostCompactBudget(input.config, {
+        model: input.model,
+        transcriptPath: input.transcriptPath,
+    });
+    const engine = createRulesEngine(input.options, effectiveConfig);
+    hydrateEngineState(engine, input.cachePath);
+    engine.state.cwd = input.cwd;
+    const loaded = engine.loadStaticRules(input.cwd);
+    const transcriptText = readRecoveryTranscriptText(input.transcriptPath);
+    const missingRules = filterRulesNotInTranscriptText(loaded.rules.filter((rule) => !engine.isStaticInjected(rule)), transcriptText, (rule) => {
+        engine.markStaticInjected(rule);
+    });
+    const dynamicRulePaths = recoverDynamicRulePaths(engine, transcriptText, loaded.rules);
+    const shellAwareness = engine.state.staticDedup.has(SHELL_AWARENESS_DEDUP_KEY)
+        ? ""
+        : getShellRuntimeAwareness(input.options.env);
+    const outputStyle = loadOutputStyleText(input.options.env);
+    if (missingRules.length === 0 &&
+        dynamicRulePaths.length === 0 &&
+        shellAwareness.length === 0 &&
+        outputStyle.length === 0) {
+        persistEngineState(engine, input.cachePath, input.channel);
+        return "";
+    }
+    const fullBodyRules = missingRules.filter((rule) => isNeverTruncatedRule(ruleDisplayPath(rule)));
+    const listedRules = missingRules.filter((rule) => !isNeverTruncatedRule(ruleDisplayPath(rule)));
+    const directiveCandidate = buildPostCompactReadDirective([...listedRules.map((rule) => rule.path), ...dynamicRulePaths], effectiveConfig.maxResultChars);
+    const directiveBudget = withOptionalContextBudget(effectiveConfig, [directiveCandidate], fullBodyRules.length > 0);
+    Object.assign(effectiveConfig, directiveBudget.config);
+    const directive = directiveBudget.blocks[0] ?? "";
+    const contextBudget = withOptionalContextBudget(effectiveConfig, [shellAwareness, outputStyle], fullBodyRules.length > 0 || directive.length > 0);
+    Object.assign(effectiveConfig, contextBudget.config);
+    const formatted = fullBodyRules.length === 0 ? { block: "", rules: [] } : engine.formatStaticResult(fullBodyRules);
+    const combinedContext = combineStaticContext(formatted.block, directive, ...contextBudget.blocks);
+    const deliveredContext = prepareAdditionalContext(combinedContext);
+    const formattedDelivered = formatted.block.length > 0 && deliveredContext.startsWith(formatted.block.trim());
+    if (formattedDelivered) {
+        for (const rule of formatted.rules) {
+            engine.markStaticInjected(rule);
+        }
+    }
+    const directiveContextPrefix = combineStaticContext(formatted.block, directive);
+    const directiveDelivered = directive.length > 0 && deliveredContext.startsWith(directiveContextPrefix.trim());
+    const directivePaths = new Set(listPostCompactDirectivePaths(directive));
+    if (directiveDelivered) {
+        for (const rule of listedRules) {
+            if (directivePaths.has(rule.path)) {
+                engine.markStaticInjected(rule);
+            }
+        }
+    }
+    const shellContextPrefix = combineStaticContext(formatted.block, directive, shellAwareness);
+    if (shellAwareness.length > 0 &&
+        contextBudget.blocks.includes(shellAwareness) &&
+        deliveredContext.startsWith(shellContextPrefix.trim())) {
+        engine.state.staticDedup.add(SHELL_AWARENESS_DEDUP_KEY);
+    }
+    persistEngineState(engine, input.cachePath, input.channel);
+    const recoveryRequired = fullBodyRules.length > 0 || listedRules.length > 0 || dynamicRulePaths.length > 0;
+    if (recoveryRequired && !formattedDelivered && (!directiveDelivered || fullBodyRules.length > 0)) {
+        retryPostCompactRecovery(input.cachePath, input.channel);
+    }
+    return formatAdditionalContextOutput(input.eventName, combinedContext);
+}
+function readRecoveryTranscriptText(transcriptPath) {
+    if (transcriptPath === null) {
+        return null;
+    }
+    return (readTranscriptSearchText(transcriptPath, { latestCompactedReplacementOnly: true }) ??
+        readTranscriptSearchText(transcriptPath));
+}
+function recoverDynamicRulePaths(engine, transcriptText, staticRules) {
+    const staticRulePaths = new Set(staticRules.map((rule) => rule.realPath));
+    const recoveredPaths = new Set();
+    for (const dedupKeys of engine.state.dynamicDedup.values()) {
+        for (const dedupKey of dedupKeys) {
+            const separatorIndex = dedupKey.lastIndexOf("::");
+            if (separatorIndex <= 0) {
+                continue;
+            }
+            const rulePath = dedupKey.slice(0, separatorIndex);
+            if (staticRulePaths.has(rulePath)) {
+                continue;
+            }
+            if (!existsSync(rulePath)) {
+                continue;
+            }
+            if (dynamicRuleContentSurvived(rulePath, transcriptText)) {
+                continue;
+            }
+            recoveredPaths.add(rulePath);
+        }
+    }
+    return [...recoveredPaths].sort();
+}
+function dynamicRuleContentSurvived(rulePath, transcriptText) {
+    if (transcriptText === null) {
+        return false;
+    }
+    try {
+        const body = parseRule(readFileSync(rulePath, "utf8")).body.trim().slice(0, 2_000);
+        return (body.length > 0 && transcriptText.includes(`Instructions from: ${rulePath}`) && transcriptText.includes(body));
+    }
+    catch {
+        return false;
+    }
+}
+function ruleDisplayPath(rule) {
+    return rule.relativePath.length > 0 ? rule.relativePath : rule.path;
+}
+function combineStaticContext(...blocks) {
+    return blocks.filter((block) => block.trim().length > 0).join("\n\n");
+}

package/marketplace/plugins/litcodex/components/rules/dist/tool-paths.d.ts

@@ -0,0 +1,6 @@
+export interface CodexPostToolUseLike {
+    tool_name: string;
+    tool_input: unknown;
+    tool_response: unknown;
+}
+export declare function extractCodexToolPaths(input: CodexPostToolUseLike, cwd: string): string[];

package/marketplace/plugins/litcodex/components/rules/dist/tool-paths.js

@@ -0,0 +1,168 @@
+import { existsSync, statSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+const COMMAND_TOOL_NAMES = new Set(["bash", "shell_command", "exec_command"]);
+const TRACKED_TOOL_NAMES = new Set([
+    "read",
+    "read_file",
+    "mcp__filesystem__read_file",
+    "mcp__filesystem__read_multiple_files",
+    "mcp__filesystem__write_file",
+    "mcp__filesystem__edit_file",
+    "write",
+    "edit",
+    "multiedit",
+    "multi_edit",
+    "apply_patch",
+    "bash",
+    "shell_command",
+    "exec_command",
+]);
+export function extractCodexToolPaths(input, cwd) {
+    const toolName = input.tool_name.toLowerCase();
+    if (!TRACKED_TOOL_NAMES.has(toolName) || isFailedToolResponse(input.tool_response)) {
+        return [];
+    }
+    const paths = new Set();
+    const toolInput = isRecord(input.tool_input) ? input.tool_input : {};
+    addCommonPathFields(paths, toolInput, cwd);
+    addPatchPayloadPaths(paths, toolInput, cwd);
+    addPatchRecordPaths(paths, toolInput["files"], cwd);
+    addPatchRecordPaths(paths, toolInput["changes"], cwd);
+    if (COMMAND_TOOL_NAMES.has(toolName)) {
+        const command = stringProperty(toolInput, "command") ?? stringProperty(toolInput, "cmd");
+        const workdir = stringProperty(toolInput, "workdir") ?? stringProperty(toolInput, "cwd");
+        addCommandPaths(paths, command, workdir === undefined ? cwd : resolvePath(cwd, workdir));
+    }
+    return [...paths];
+}
+function addCommonPathFields(paths, input, cwd) {
+    for (const key of ["path", "filePath", "file_path", "target", "targetPath", "target_path"]) {
+        addPath(paths, input[key], cwd, false);
+    }
+    for (const key of ["paths", "filePaths", "file_paths"]) {
+        addPathArray(paths, input[key], cwd, false);
+    }
+}
+function addPatchPayloadPaths(paths, input, cwd) {
+    for (const key of ["input", "patch", "command", "cmd"]) {
+        const value = input[key];
+        if (typeof value === "string") {
+            addPatchHeaderPaths(paths, value, cwd);
+        }
+    }
+}
+function addPatchHeaderPaths(paths, patch, cwd) {
+    for (const line of patch.split("\n")) {
+        for (const prefix of ["*** Add File: ", "*** Update File: ", "*** Move to: "]) {
+            if (line.startsWith(prefix)) {
+                addPath(paths, line.slice(prefix.length).trim(), cwd, false);
+            }
+        }
+    }
+}
+function addPatchRecordPaths(paths, value, cwd) {
+    if (!Array.isArray(value))
+        return;
+    for (const item of value) {
+        if (typeof item === "string") {
+            addPath(paths, item, cwd, false);
+            continue;
+        }
+        if (!isRecord(item))
+            continue;
+        addCommonPathFields(paths, item, cwd);
+        for (const key of ["movePath", "move_path", "to", "from"]) {
+            addPath(paths, item[key], cwd, false);
+        }
+    }
+}
+function addCommandPaths(paths, command, cwd) {
+    if (command === undefined)
+        return;
+    for (const token of tokenizeShell(command)) {
+        if (token.length === 0 || token.startsWith("-") || token.includes("*")) {
+            continue;
+        }
+        addPath(paths, token, cwd, true);
+    }
+}
+function addPathArray(paths, value, cwd, mustExist) {
+    if (!Array.isArray(value))
+        return;
+    for (const item of value) {
+        addPath(paths, item, cwd, mustExist);
+    }
+}
+function addPath(paths, value, cwd, mustExist) {
+    if (typeof value !== "string" || value.length === 0 || looksLikeUrl(value)) {
+        return;
+    }
+    const path = resolvePath(cwd, value);
+    if (mustExist && !isExistingFile(path)) {
+        return;
+    }
+    paths.add(path);
+}
+function resolvePath(cwd, filePath) {
+    return isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
+}
+function isExistingFile(filePath) {
+    try {
+        return existsSync(filePath) && statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function looksLikeUrl(value) {
+    return /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(value);
+}
+function stringProperty(value, key) {
+    const property = value[key];
+    return typeof property === "string" && property.length > 0 ? property : undefined;
+}
+function tokenizeShell(command) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    let escaped = false;
+    for (const character of command) {
+        if (escaped) {
+            current += character;
+            escaped = false;
+            continue;
+        }
+        if (character === "\\") {
+            escaped = true;
+            continue;
+        }
+        if ((character === "'" || character === '"') && quote === null) {
+            quote = character;
+            continue;
+        }
+        if (quote === character) {
+            quote = null;
+            continue;
+        }
+        if (quote === null && /\s/.test(character)) {
+            if (current.length > 0) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += character;
+    }
+    if (current.length > 0) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFailedToolResponse(value) {
+    if (!isRecord(value))
+        return false;
+    return (value["isError"] === true || value["is_error"] === true || value["error"] === true || value["status"] === "error");
+}

package/marketplace/plugins/litcodex/components/rules/dist/transcript-rule-filter.d.ts

@@ -0,0 +1,4 @@
+import type { LoadedRule } from "./rules/types.js";
+import type { TranscriptSearchOptions } from "./transcript-search.js";
+export declare function filterRulesAlreadyInTranscript(rules: ReadonlyArray<LoadedRule>, transcriptPath: string | null, markInjected: (rule: LoadedRule) => void, options?: TranscriptSearchOptions): LoadedRule[];
+export declare function filterRulesNotInTranscriptText(rules: ReadonlyArray<LoadedRule>, transcriptText: string | null, markInjected: (rule: LoadedRule) => void): LoadedRule[];

package/marketplace/plugins/litcodex/components/rules/dist/transcript-rule-filter.js

@@ -0,0 +1,31 @@
+import { readTranscriptSearchText } from "./transcript-search.js";
+export function filterRulesAlreadyInTranscript(rules, transcriptPath, markInjected, options = {}) {
+    if (rules.length === 0 || transcriptPath === null) {
+        return [...rules];
+    }
+    const transcriptText = readTranscriptSearchText(transcriptPath, options) ??
+        (options.latestCompactedReplacementOnly === true ? readTranscriptSearchText(transcriptPath) : null);
+    return filterRulesNotInTranscriptText(rules, transcriptText, markInjected);
+}
+export function filterRulesNotInTranscriptText(rules, transcriptText, markInjected) {
+    if (rules.length === 0 || transcriptText === null) {
+        return [...rules];
+    }
+    const pendingRules = [];
+    for (const rule of rules) {
+        if (isRuleAlreadyInTranscript(rule, transcriptText)) {
+            markInjected(rule);
+            continue;
+        }
+        pendingRules.push(rule);
+    }
+    return pendingRules;
+}
+function isRuleAlreadyInTranscript(rule, transcriptText) {
+    const bodyNeedle = rule.body.trim().slice(0, 2_000);
+    if (bodyNeedle.length === 0 || !transcriptText.includes(bodyNeedle)) {
+        return false;
+    }
+    const markers = [`Instructions from: ${rule.path}`, `Instructions from: ${rule.realPath}`];
+    return markers.some((marker) => transcriptText.includes(marker));
+}

package/marketplace/plugins/litcodex/components/rules/dist/transcript-search.d.ts

@@ -0,0 +1,5 @@
+export interface TranscriptSearchOptions {
+    readonly latestCompactedReplacementOnly?: boolean;
+}
+export declare function readCurrentTurnHookContext(transcriptPath: string, turnId: string): string | null;
+export declare function readTranscriptSearchText(transcriptPath: string, options?: TranscriptSearchOptions): string | null;

package/marketplace/plugins/litcodex/components/rules/dist/transcript-search.js

@@ -0,0 +1,191 @@
+import { realpathSync } from "node:fs";
+import { dirname } from "node:path";
+import { NODE_STABLE_READ_FS, readStableRegularUtf8, snapshotStableDirectoryChain } from "./stable-file-read.js";
+const MAX_TRANSCRIPT_BYTES = 2_000_000;
+export function readCurrentTurnHookContext(transcriptPath, turnId) {
+    try {
+        const transcript = readStableTranscript(transcriptPath);
+        if (transcript === undefined)
+            return null;
+        const records = transcript.split(/\r?\n/).map(parseJsonLine);
+        let boundary = -1;
+        for (let index = records.length - 1; index >= 0; index -= 1) {
+            const record = records[index];
+            if (!isUserTurnRecord(record))
+                continue;
+            if (recordTurnId(record) !== turnId)
+                return null;
+            boundary = index;
+            break;
+        }
+        if (boundary < 0)
+            return null;
+        const values = [];
+        for (const record of records.slice(boundary + 1)) {
+            collectCurrentTurnHookStrings(record, values);
+        }
+        return values.join("\n");
+    }
+    catch (error) {
+        if (!(error instanceof Error))
+            throw error;
+        return null;
+    }
+}
+export function readTranscriptSearchText(transcriptPath, options = {}) {
+    try {
+        const rawTranscript = readStableTranscript(transcriptPath);
+        if (rawTranscript === undefined)
+            return null;
+        if (options.latestCompactedReplacementOnly === true) {
+            return latestCompactedReplacementSearchText(rawTranscript);
+        }
+        return collectTrustedTranscriptText(rawTranscript);
+    }
+    catch (error) {
+        if (!(error instanceof Error)) {
+            throw error;
+        }
+        return null;
+    }
+}
+function readStableTranscript(transcriptPath) {
+    const realPath = realpathSync.native(transcriptPath);
+    // The transcript's containing directory is the trust boundary. Pinning every
+    // shared ancestor up to / made unrelated sibling temp-file churn look like an
+    // attack during parallel test and host activity.
+    const directories = snapshotStableDirectoryChain(realPath, NODE_STABLE_READ_FS, dirname(realPath));
+    if (directories === undefined)
+        return undefined;
+    return readStableRegularUtf8(realPath, MAX_TRANSCRIPT_BYTES, NODE_STABLE_READ_FS, directories);
+}
+function latestCompactedReplacementSearchText(rawTranscript) {
+    const lines = rawTranscript.split(/\r?\n/);
+    let latestCompactedLineIndex = -1;
+    let replacementHistory = null;
+    for (const [index, line] of lines.entries()) {
+        const parsed = parseJsonLine(line);
+        if (!isRecord(parsed) || parsed["type"] !== "compacted") {
+            continue;
+        }
+        const payload = parsed["payload"];
+        if (!isRecord(payload)) {
+            continue;
+        }
+        const candidateReplacementHistory = payload["replacement_history"];
+        if (!Array.isArray(candidateReplacementHistory)) {
+            continue;
+        }
+        latestCompactedLineIndex = index;
+        replacementHistory = candidateReplacementHistory;
+    }
+    if (replacementHistory === null) {
+        return null;
+    }
+    const values = [];
+    collectStrings(replacementHistory, values);
+    for (const line of lines.slice(latestCompactedLineIndex + 1)) {
+        const parsed = parseJsonLine(line);
+        if (parsed !== null) {
+            collectTrustedRecordStrings(parsed, values);
+        }
+    }
+    return values.join("\n");
+}
+function collectTrustedTranscriptText(rawTranscript) {
+    const values = [];
+    for (const line of rawTranscript.split(/\r?\n/)) {
+        const parsed = parseJsonLine(line);
+        if (parsed !== null) {
+            collectTrustedRecordStrings(parsed, values);
+        }
+    }
+    return values.join("\n");
+}
+function collectTrustedRecordStrings(value, output) {
+    if (!isRecord(value)) {
+        return;
+    }
+    const hookSpecificOutput = value["hookSpecificOutput"];
+    if (isRecord(hookSpecificOutput) && typeof hookSpecificOutput["additionalContext"] === "string") {
+        output.push(hookSpecificOutput["additionalContext"]);
+    }
+    if (value["type"] !== "compacted") {
+        return;
+    }
+    const payload = value["payload"];
+    if (!isRecord(payload)) {
+        return;
+    }
+    const replacementHistory = payload["replacement_history"];
+    if (Array.isArray(replacementHistory)) {
+        collectStrings(replacementHistory, output);
+    }
+}
+function collectCurrentTurnHookStrings(value, output) {
+    if (!isRecord(value))
+        return;
+    if (Object.keys(value).length !== 1 || !("hookSpecificOutput" in value))
+        return;
+    const hookSpecificOutput = value["hookSpecificOutput"];
+    if (isRecord(hookSpecificOutput) &&
+        hookSpecificOutput["hookEventName"] === "UserPromptSubmit" &&
+        typeof hookSpecificOutput["additionalContext"] === "string") {
+        output.push(hookSpecificOutput["additionalContext"]);
+    }
+}
+function isUserTurnRecord(value) {
+    if (!isRecord(value))
+        return false;
+    const payload = value["payload"];
+    return isRecord(payload) && payload["type"] === "message" && payload["role"] === "user";
+}
+function recordTurnId(value) {
+    const direct = value["turn_id"];
+    if (typeof direct === "string")
+        return direct;
+    const payload = value["payload"];
+    if (!isRecord(payload))
+        return undefined;
+    const payloadTurn = payload["turn_id"];
+    if (typeof payloadTurn === "string")
+        return payloadTurn;
+    const metadata = payload["internal_chat_message_metadata_passthrough"];
+    return isRecord(metadata) && typeof metadata["turn_id"] === "string" ? metadata["turn_id"] : undefined;
+}
+function parseJsonLine(line) {
+    if (line.trim().length === 0) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(line);
+        return parsed;
+    }
+    catch (error) {
+        if (!(error instanceof Error)) {
+            throw error;
+        }
+        return null;
+    }
+}
+function collectStrings(value, output) {
+    if (typeof value === "string") {
+        output.push(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectStrings(item, output);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    for (const item of Object.values(value)) {
+        collectStrings(item, output);
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/marketplace/plugins/litcodex/components/rules/node_modules/picomatch/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-present, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.