jamdesk 1.1.37 → 1.1.39

package/vendored/lib/search-client.ts

@@ -1,5 +1,12 @@
 // Client-side search with Orama (BM25 ranking)
 import { create, insertMultiple, search as oramaSearch, type Orama } from '@orama/orama';
+import { LANGUAGE_CODES, resolveLocaleWithLoweredSet } from './language-utils';
+
+// Lowercased canonical language codes — used to detect slug-prefix locales when
+// the search-data.json predates the locale field (legacy fallback).
+const KNOWN_LANGUAGE_CODES_LOWERED: ReadonlySet<string> = new Set(
+  LANGUAGE_CODES.map((c) => c.toLowerCase()),
+);
 
 export interface SearchResult {
   id: string;
@@ -9,6 +16,8 @@ export interface SearchResult {
   slug: string;
   section?: string;
   type?: 'api' | 'component' | 'guide' | 'help' | 'quickstart';
+  /** Language of the document. Empty string for default-language pages. */
+  locale: string;
 }
 
 type OramaDb = Orama<{
@@ -19,6 +28,7 @@ type OramaDb = Orama<{
   slug: 'string';
   section: 'string';
   type: 'string';
+  locale: 'enum';
 }>;
 
 // Orama database instance
@@ -33,6 +43,19 @@ let initPromise: Promise<void> | null = null;
 let lastEtag = '';
 let lastParsedData: SearchResult[] | null = null;
 
+/**
+ * Locales the URL-resolver treats as real translations for the current
+ * project. Populated from the index's `locale` field when present, falling
+ * back to slug-prefix derivation for legacy (pre-feature) search-data.json
+ * so French pages don't leak English results while customers rebuild.
+ *
+ * `indexHasLocaleField` is the separate gate that controls whether the Orama
+ * `where` clause is used — set only when the new index format is detected.
+ * Slug-prefix fallback runs in `search()` whenever the where clause is off.
+ */
+let projectLocalesLowered: ReadonlySet<string> = new Set();
+let indexHasLocaleField = false;
+
 /**
  * Cheap fingerprint: count + first/last IDs + a sample of content lengths.
  * Detects new/removed pages AND content edits (which change content length).
@@ -60,20 +83,52 @@ async function buildIndex(data: SearchResult[], etag: string): Promise<void> {
       slug: 'string',
       section: 'string',
       type: 'string',
+      locale: 'enum',
     },
   });
 
-  const normalizedData = data.map(item => ({
-    id: item.id,
-    title: item.title,
-    description: item.description || '',
-    content: item.content,
-    slug: item.slug,
-    section: item.section || '',
-    type: item.type || 'guide',
-  }));
+  // Distinguish new-format docs (have a `locale` field, possibly '') from
+  // legacy ones (field missing entirely). Once the `?? ''` fallback runs in
+  // the map below the two are indistinguishable, so check the raw input first.
+  // A single doc with the field is enough — the build script always emits the
+  // field for every doc when it emits any.
+  indexHasLocaleField = data.some(
+    (d) => typeof (d as { locale?: unknown }).locale === 'string',
+  );
+
+  const seenLocales = new Set<string>();
+  const slugPrefixLocales = new Set<string>();
+  const normalizedData = data.map(item => {
+    const raw = item.locale;
+    if (typeof raw === 'string' && raw.length > 0) seenLocales.add(raw);
+    // Track first-segment slug prefixes that match a known language code,
+    // used as the URL-to-locale whitelist when the index lacks the field.
+    const firstSeg = item.slug.split('/', 1)[0]?.toLowerCase();
+    if (firstSeg && KNOWN_LANGUAGE_CODES_LOWERED.has(firstSeg)) {
+      slugPrefixLocales.add(firstSeg);
+    }
+    return {
+      id: item.id,
+      title: item.title,
+      description: item.description || '',
+      content: item.content,
+      slug: item.slug,
+      section: item.section || '',
+      type: item.type || 'guide',
+      locale: raw ?? '',
+    };
+  });
 
   await insertMultiple(db, normalizedData);
+
+  // Trust the index's own locale set when present (handles the dodo case
+  // where `de/` is a directory, not a translation — `seenLocales` won't
+  // include `de`). Fall back to slug-prefix derivation for legacy indexes so
+  // the URL still maps to a sensible locale during the rebuild window.
+  projectLocalesLowered = indexHasLocaleField
+    ? new Set(Array.from(seenLocales, (l) => l.toLowerCase()))
+    : slugPrefixLocales;
+
   committedFingerprint = buildingFingerprint;
   lastParsedData = data;
   lastEtag = etag;
@@ -104,7 +159,11 @@ export function getLastData(etag: string | null): SearchResult[] | null {
   return lastParsedData;
 }
 
-export async function search(query: string, limit = 10): Promise<SearchResult[]> {
+export async function search(
+  query: string,
+  limit = 10,
+  language?: string,
+): Promise<SearchResult[]> {
   if (!db) {
     console.warn('Search database not initialized');
     return [];
@@ -114,9 +173,15 @@ export async function search(query: string, limit = 10): Promise<SearchResult[]>
     return [];
   }
 
+  const targetLocale = language ?? '';
+
+  // Fetch extra when post-filtering by slug prefix so we can still reach
+  // `limit` after dropping cross-locale hits.
+  const fetchLimit = indexHasLocaleField ? limit : Math.min(limit * 5, 50);
+
   const results = await oramaSearch(db, {
     term: query,
-    limit,
+    limit: fetchLimit,
     tolerance: 1, // Allow 1 typo for fuzzy matching
     boost: {
       title: 2,
@@ -124,9 +189,32 @@ export async function search(query: string, limit = 10): Promise<SearchResult[]>
       description: 1,
       content: 0.5,
     },
+    ...(indexHasLocaleField ? { where: { locale: { eq: targetLocale } } } : {}),
   });
 
-  return results.hits.map(hit => hit.document as unknown as SearchResult);
+  const docs = results.hits.map(hit => hit.document as unknown as SearchResult);
+
+  // Slug-prefix fallback for un-rebuilt indexes: the index has no locale
+  // field, so the where clause was skipped above. Filter by slug prefix
+  // instead so French pages don't see English results during the rebuild
+  // window. Inverted on default-language pages: drop slugs whose prefix
+  // matches any known project locale.
+  if (!indexHasLocaleField) {
+    if (targetLocale) {
+      const prefix = `${targetLocale}/`;
+      return docs.filter(d => d.slug.startsWith(prefix)).slice(0, limit);
+    }
+    if (projectLocalesLowered.size > 0) {
+      return docs
+        .filter(d => {
+          const firstSeg = d.slug.split('/', 1)[0]?.toLowerCase();
+          return !firstSeg || !projectLocalesLowered.has(firstSeg);
+        })
+        .slice(0, limit);
+    }
+  }
+
+  return docs.slice(0, limit);
 }
 
 /** @internal Used by tests only */
@@ -134,3 +222,20 @@ export function isInitialized(): boolean {
   return db !== null;
 }
 
+/**
+ * Resolve the locale that the search filter should target for a given pathname,
+ * gated by the locales actually present in the currently-committed index
+ * (or, in legacy mode, by slug-prefix derivation).
+ *
+ * Returns:
+ *   - `''` when there is no committed index yet, OR the pathname has no
+ *     language prefix, OR the prefix is not a known project locale.
+ *   - The canonical language code when the prefix matches.
+ *
+ * Caller (SearchModal) should pass the result to `search()`. Empty string and
+ * undefined are equivalent — both target the default-language doc set.
+ */
+export function resolveActiveLocale(pathname: string): string {
+  if (projectLocalesLowered.size === 0) return '';
+  return resolveLocaleWithLoweredSet(pathname, projectLocalesLowered);
+}

package/vendored/lib/static-artifacts.ts

@@ -8,6 +8,11 @@
 import type { NavigationConfig } from './docs-types.js';
 import { RECURSE_KEYS } from './enhance-navigation.js';
 import { filterVisibility } from './visibility-filter.js';
+import {
+  buildLoweredLocaleSet,
+  resolveLocaleFromPath,
+  resolveLocaleWithLoweredSet,
+} from './language-utils.js';
 
 /**
  * Page metadata for artifact generation.
@@ -585,6 +590,8 @@ export interface SearchDocument {
   slug: string;
   section?: string;
   type: string;
+  /** Language of the document. Empty string for default-language pages. */
+  locale: string;
 }
 
 /**
@@ -602,6 +609,14 @@ export interface SearchPageInfo {
   };
 }
 
+/** Whitelist-gated alias of `resolveLocaleFromPath`, named for the search-index domain. */
+export function detectLocaleFromSlug(
+  slug: string,
+  projectLanguages: readonly string[],
+): string {
+  return resolveLocaleFromPath(slug, projectLanguages);
+}
+
 /**
  * Infer page type from slug path.
  */
@@ -668,15 +683,23 @@ export function extractSections(content: string): Array<{ heading: string; conte
  * Generate search data from page content.
  *
  * @param pages - Array of page info with content
+ * @param projectLanguages - Language codes declared in docs.json.navigation.languages.
+ *   Used as the locale whitelist; slugs whose prefix is not in this list are
+ *   tagged as default-language (locale='').
  * @returns JSON string of search documents
  */
-export function generateSearchData(pages: SearchPageInfo[]): string {
+export function generateSearchData(
+  pages: SearchPageInfo[],
+  projectLanguages: readonly string[],
+): string {
   const documents: SearchDocument[] = [];
+  const loweredLanguages = buildLoweredLocaleSet(projectLanguages);
 
   for (const page of pages) {
     const pathWithoutExt = page.path.replace(/\.mdx?$/, '');
     const slug = pathWithoutExt.replace(/\\/g, '/');
     const pageType = inferPageType(slug);
+    const locale = resolveLocaleWithLoweredSet(slug, loweredLanguages);
     // Filter for="agents" content out of the search index — the site
     // search is a human-facing surface, so agent-only content must not
     // leak into autocomplete.
@@ -694,6 +717,7 @@ export function generateSearchData(pages: SearchPageInfo[]): string {
           slug,
           section: section.heading || undefined,
           type: pageType,
+          locale,
         });
       }
     });

package/vendored/lib/static-file-route.ts

@@ -6,6 +6,9 @@
  * duplication across 12 route files (6 at root + 6 at /docs).
  */
 
+import fs from 'fs';
+import path from 'path';
+
 import { NextRequest, NextResponse } from 'next/server';
 
 import { log } from '@/lib/logger';
@@ -55,6 +58,16 @@ export function createStaticFileHandler(
 
   return async function GET(request: NextRequest): Promise<NextResponse> {
     if (!isIsrMode()) {
+      // Dev fallback: `dev-project.cjs` writes static artifacts (search-data.json,
+      // sitemap.xml, ...) into `public/`. Next.js prefers route handlers over
+      // public/ files when both exist, so without this branch the dev server
+      // 404s on these paths and breaks the SearchModal init.
+      const localPath = path.join(process.cwd(), 'public', filename);
+      if (fs.existsSync(localPath)) {
+        return new NextResponse(fs.readFileSync(localPath), {
+          headers: { 'Content-Type': contentType, 'Cache-Control': 'no-cache' },
+        });
+      }
       return new NextResponse('Not found', { status: 404 });
     }
 

package/vendored/lib/vector-store.ts

@@ -11,6 +11,7 @@
  */
 import { Index, FusionAlgorithm, WeightingStrategy, QueryMode } from '@upstash/vector';
 import type { EmbeddingChunk } from './embedding-chunker.js';
+import { logger } from '../shared/logger';
 
 export interface ChunkMetadata {
   [key: string]: unknown;
@@ -18,6 +19,10 @@ export interface ChunkMetadata {
   sectionHeading: string;
   pageTitle: string;
   content: string;
+  /** Locale code (lowercased, e.g. "en", "es", "pt-br"). Absent for chunks
+   *  written by single-language projects (no `i18n.languages` config) — the
+   *  filter is gated per-project so unfiltered queries return all chunks. */
+  locale?: string;
 }
 
 /** Upstash limit per upsert call */
@@ -78,20 +83,24 @@ export async function upsertChunks(
   for (let i = 0; i < chunks.length; i += BATCH_SIZE) {
     const batch = chunks.slice(i, i + BATCH_SIZE);
     await ns.upsert(
-      batch.map(c => ({
-        id: c.id,
-        // Prefix + body goes to Upstash for embedding/BM25; metadata.content
-        // stays prefix-free so consumers display clean body text.
-        data: c.prefix + c.content,
-        metadata: {
+      batch.map(c => {
+        const metadata: ChunkMetadata = {
           pageSlug: c.pageSlug,
           sectionHeading: c.sectionHeading,
           pageTitle: c.pageTitle,
           content: c.content.length > MAX_METADATA_CONTENT_CHARS
             ? c.content.slice(0, MAX_METADATA_CONTENT_CHARS) + '...'
             : c.content,
-        } satisfies ChunkMetadata,
-      })),
+        };
+        if (c.locale) metadata.locale = c.locale; // omit when null
+        return {
+          id: c.id,
+          // Prefix + body goes to Upstash for embedding/BM25; metadata.content
+          // stays prefix-free so consumers display clean body text.
+          data: c.prefix + c.content,
+          metadata,
+        };
+      }),
     );
   }
 }
@@ -130,13 +139,12 @@ export function extractTopicQuery(queryText: string): string | null {
 /** Query with hybrid mode, falling back to dense-only if hybrid is not supported */
 async function queryWithFallback(
   ns: ReturnType<typeof getNamespace>,
-  params: { data: string; topK: number; includeMetadata: true },
+  params: { data: string; topK: number; includeMetadata: true; filter?: string },
 ): Promise<Array<{ id: string | number; score: number; metadata?: ChunkMetadata }>> {
   try {
     return await ns.query<ChunkMetadata>({ ...params, ...HYBRID_QUERY_OPTS });
   } catch (err) {
-    // Hybrid not supported on this index — fall back to dense-only
-    console.warn('[vector-store] Hybrid query failed, falling back to dense-only:', String(err));
+    logger.warn('vector-store: hybrid query failed, falling back to dense-only', { error: String(err) });
     return await ns.query<ChunkMetadata>({ ...params, queryMode: QueryMode.DENSE });
   }
 }
@@ -184,6 +192,10 @@ function filterAndMerge(
  * request-pattern words (e.g. "give me a javascript example") from diluting
  * the topic signal in the embedding.
  *
+ * When `options.locale` is set, a strict Upstash filter expression is applied
+ * so only chunks for that locale are returned. No retry-without-filter on 0
+ * results — migration safety lives in the per-project gate (Task A5).
+ *
  * Returns up to `topK` results with their similarity scores,
  * filtering out any results with missing metadata.
  */
@@ -191,25 +203,66 @@ export async function querySimilarChunks(
   projectId: string,
   queryText: string,
   topK = 5,
+  options: { locale?: string } = {},
 ): Promise<Array<ChunkMetadata & { score: number }>> {
   const ns = getNamespace(projectId);
-  const queryParams = { topK, includeMetadata: true as const };
+  const locale = options.locale ? normalizeLocaleForFilter(options.locale) : undefined;
+  // Defense-in-depth: A5 rejects malformed locales at the API boundary. If a
+  // truthy locale here normalizes to empty, A5's guard was bypassed (test or
+  // internal caller) — surface it loudly rather than silently dropping the filter.
+  if (options.locale && !locale) {
+    logger.warn('vector-store: locale normalized to empty — filter skipped', { rawLocale: options.locale });
+  }
+  const filter = locale ? buildLocaleFilter(locale) : undefined;
+  // When filtering, raise effective topK by ~33% so we still get ~topK chunks
+  // back from a mixed-language namespace where filtering cuts the candidate set.
+  const effectiveTopK = filter ? Math.ceil(topK * 1.33) : topK;
+  const queryParams = { topK: effectiveTopK, includeMetadata: true as const, filter };
 
   const topicQuery = extractTopicQuery(queryText);
 
   // Dual-query: topic query is the PRIMARY source (better topical relevance);
   // the full query fills remaining slots with unique results only.
+  let merged: Array<ChunkMetadata & { score: number }>;
   if (topicQuery) {
     const [fullResults, topicResults] = await Promise.all([
       queryWithFallback(ns, { data: queryText, ...queryParams }),
       queryWithFallback(ns, { data: topicQuery, ...queryParams }),
     ]);
+    merged = filterAndMerge([topicResults, fullResults], topK);
+  } else {
+    const results = await queryWithFallback(ns, { data: queryText, ...queryParams });
+    merged = filterAndMerge([results], topK);
+  }
 
-    // Topic results first for best topical relevance
-    return filterAndMerge([topicResults, fullResults], topK);
+  // Telemetry: a filtered query that returns materially fewer chunks than
+  // requested signals the locale filter is hurting recall (project skewed away
+  // from the requested locale, or filter syntax matched a near-empty subset).
+  // Surface it so we can decide whether to widen the carve-out, increase the
+  // 1.33× boost, or rebuild the project's index.
+  if (filter && merged.length < Math.ceil(topK / 2)) {
+    logger.warn('vector-store: locale filter under-fills topK', {
+      projectId, locale, returned: merged.length, requested: topK,
+    });
   }
 
-  // Simple single-query path for short/simple queries
-  const results = await queryWithFallback(ns, { data: queryText, ...queryParams });
-  return filterAndMerge([results], topK);
+  return merged;
+}
+
+/**
+ * Validate + normalize a locale code for use inside an Upstash filter
+ * expression. We allow [a-z0-9_-] (covers `en`, `pt-br`, `zh-Hans` after
+ * lowercasing) and lowercase to match how chunks were stored. Any other
+ * character is dropped — defense against filter injection from a malformed
+ * client request. The route layer rejects bad locales at the API boundary
+ * (Task A5), so this strip is belt-and-suspenders.
+ */
+function normalizeLocaleForFilter(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9_-]/g, '');
+}
+
+/** Single source of truth for the Upstash filter expression. The smoke-test
+ *  script reuses this so production and verification stay in sync. */
+export function buildLocaleFilter(locale: string): string {
+  return `locale = "${locale}"`;
 }

package/vendored/scripts/build-search-index.cjs

@@ -25,6 +25,56 @@ const { create, insertMultiple } = require('@orama/orama');
 const { persist } = require('@orama/plugin-data-persistence');
 const { filterVisibility } = require('./visibility-filter.cjs');
 
+// Shared canonical list of language codes — keep in sync with
+// lib/language-utils.ts. The sync test in
+// __tests__/lib/language-codes-sync.test.ts catches drift.
+const LANGUAGE_CODES = require('../lib/language-codes.json');
+
+const LANGUAGE_CODE_BY_LOWER = (() => {
+  const m = new Map();
+  for (const k of LANGUAGE_CODES) {
+    const lower = k.toLowerCase();
+    if (!m.has(lower)) m.set(lower, k);
+  }
+  return m;
+})();
+
+/** Mirrors lib/language-utils.ts:extractLanguageFromPath. */
+function extractLanguageFromPath(pathname) {
+  if (!pathname) return undefined;
+  const parts = pathname.replace(/^\/docs\/?/, '').replace(/^\//, '').split('/').filter(Boolean);
+  if (parts.length === 0) return undefined;
+  return LANGUAGE_CODE_BY_LOWER.get(parts[0].toLowerCase());
+}
+
+/** Mirrors lib/language-utils.ts:resolveLocaleFromPath. */
+function resolveLocaleFromPath(pathname, projectLanguages) {
+  const candidate = extractLanguageFromPath(pathname);
+  if (!candidate) return '';
+  const lowered = new Set(projectLanguages.map((l) => l.toLowerCase()));
+  return lowered.has(candidate.toLowerCase()) ? candidate : '';
+}
+
+/**
+ * Read the project's declared languages from its docs.json. Returns [] when
+ * the file is missing or malformed — the script proceeds with no whitelist,
+ * which means every doc gets locale='' (matches single-language behavior).
+ */
+function readProjectLanguages(contentDir) {
+  try {
+    const docsJsonPath = path.join(contentDir, 'docs.json');
+    if (!fs.existsSync(docsJsonPath)) return [];
+    const config = JSON.parse(fs.readFileSync(docsJsonPath, 'utf-8'));
+    const langs = config?.navigation?.languages ?? [];
+    return langs
+      .map((l) => (l && typeof l.language === 'string' ? l.language : null))
+      .filter((c) => typeof c === 'string');
+  } catch (err) {
+    console.warn(`Could not read languages from ${contentDir}/docs.json: ${err.message}`);
+    return [];
+  }
+}
+
 // Concurrency control for parallel file processing
 const CONCURRENCY = parseInt(process.env.SEARCH_INDEX_CONCURRENCY || '') || os.cpus().length * 2;
 
@@ -214,6 +264,11 @@ async function buildSearchIndex() {
     process.exit(1);
   }
 
+  const projectLanguages = readProjectLanguages(contentDir);
+  if (projectLanguages.length > 0) {
+    console.log(`Project languages: ${projectLanguages.join(', ')}`);
+  }
+
   // First, collect all MDX file paths
   const mdxFiles = [];
 
@@ -255,30 +310,40 @@ async function buildSearchIndex() {
   async function processFile({ filePath, slug }) {
     await semaphore.acquire();
     try {
-      const fileContents = await fsPromises.readFile(filePath, 'utf8');
-      const { data, content } = parseFrontmatterLenient(fileContents);
-      // Filter for="agents" content out of the search index.
-      const visibleContent = filterVisibility(content, 'humans');
-      const sections = extractSections(visibleContent);
-
-      const docs = [];
-      const normalizedSlug = slug.replace(/\\/g, '/');
-      const pageType = inferPageType(normalizedSlug);
-      sections.forEach((section, idx) => {
-        const cleanContent = stripMarkdown(section.content);
-        if (cleanContent.trim()) {
-          docs.push({
-            id: `${slug}-${idx}`,
-            title: data.title || slug.split('/').pop() || '',
-            description: data.description,
-            content: cleanContent.substring(0, 300),
-            slug: normalizedSlug,
-            section: section.heading || undefined,
-            type: pageType,
-          });
-        }
-      });
-      return docs;
+      try {
+        const fileContents = await fsPromises.readFile(filePath, 'utf8');
+        const { data, content } = parseFrontmatterLenient(fileContents);
+        // Filter for="agents" content out of the search index.
+        const visibleContent = filterVisibility(content, 'humans');
+        const sections = extractSections(visibleContent);
+
+        const docs = [];
+        const normalizedSlug = slug.replace(/\\/g, '/');
+        const pageType = inferPageType(normalizedSlug);
+        const locale = resolveLocaleFromPath(normalizedSlug, projectLanguages);
+        sections.forEach((section, idx) => {
+          const cleanContent = stripMarkdown(section.content);
+          if (cleanContent.trim()) {
+            docs.push({
+              id: `${slug}-${idx}`,
+              title: data.title || slug.split('/').pop() || '',
+              description: data.description,
+              content: cleanContent.substring(0, 300),
+              slug: normalizedSlug,
+              section: section.heading || undefined,
+              type: pageType,
+              locale,
+            });
+          }
+        });
+        return docs;
+      } catch (err) {
+        // One malformed MDX file (bad YAML, etc.) used to abort the entire index
+        // build — leaving the project searchless. Skip the file with a warning
+        // so the rest of the docs remain searchable.
+        console.warn(`⚠ Skipping ${filePath} in search index: ${err.message}`);
+        return [];
+      }
     } finally {
       semaphore.release();
     }
@@ -318,6 +383,7 @@ async function buildOramaIndex(searchData, outputDir) {
       slug: 'string',
       section: 'string',
       type: 'string',
+      locale: 'enum',
     },
   });
 
@@ -330,6 +396,7 @@ async function buildOramaIndex(searchData, outputDir) {
     slug: item.slug,
     section: item.section || '',
     type: item.type || 'guide',
+    locale: item.locale || '',
   }));
 
   await insertMultiple(db, normalizedData);

package/vendored/themes/base.css

@@ -378,6 +378,11 @@
   text-decoration: none;
 }
 
+/* Restore spacing between stacked .not-prose blocks — prose sibling rules skip them. */
+.prose > .not-prose + .not-prose {
+  margin-top: 1.5rem;
+}
+
 html {
   /* Prevent horizontal overflow on mobile */
   overflow-x: hidden;

package/vendored/workspace-package-lock.json

@@ -2152,9 +2152,9 @@
       }
     },
     "node_modules/baseline-browser-mapping": {
-      "version": "2.10.22",
-      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.22.tgz",
-      "integrity": "sha512-6qruVrb5rse6WylFkU0FhBKKGuecWseqdpQfhkawn6ztyk2QlfwSRjsDxMCLJrkfmfN21qvhl9ABgaMeRkuwww==",
+      "version": "2.10.23",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.23.tgz",
+      "integrity": "sha512-xwVXGqevyKPsiuQdLj+dZMVjidjJV508TBqexND5HrF89cGdCYCJFB3qhcxRHSeMctdCfbR1jrxBajhDy7o29g==",
       "license": "Apache-2.0",
       "bin": {
         "baseline-browser-mapping": "dist/cli.cjs"
@@ -5586,9 +5586,9 @@
       }
     },
     "node_modules/postcss": {
-      "version": "8.5.11",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.11.tgz",
-      "integrity": "sha512-5dDj8+lmvA8XB78SmzGI8NlQoksv7IfutGWeVZxiixHbO+p4LDPT3wuG/D9sM/wrjZZ9I+Siy/e117vbFPxSZg==",
+      "version": "8.5.12",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.12.tgz",
+      "integrity": "sha512-W62t/Se6rA0Az3DfCL0AqJwXuKwBeYg6nOaIgzP+xZ7N5BFCI7DYi1qs6ygUYT6rvfi6t9k65UMLJC+PHZpDAA==",
       "funding": [
         {
           "type": "opencollective",