Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.
TypeScript accessibilityalternativecloudflarecloudflare-workersdesignfreefrontendopen-sourceradix-uireactremixweb-developmentwebflowwebsite-builderwebsite-developmentwebsiteswebstudio
feat: Breakpoint simulator (#5608)
Oleg Isonend87142965cd3
diff --git a/apps/builder/app/canvas/shared/styles.test.ts b/apps/builder/app/canvas/shared/styles.test.tsindex 3e8859cfa8..9a260929b8 100644--- a/apps/builder/app/canvas/shared/styles.test.ts+++ b/apps/builder/app/canvas/shared/styles.test.ts@@ -9,6 +9,10 @@ import {createRegularStyleSheet,FakeStyleElement,} from "@webstudio-is/css-engine";++// polyfill CSS.escape for Node environment+import "css.escape";+import { __testing__ } from "./styles";const {@@ -20,7 +24,10 @@ const {computeEditableCursorRules,computeStylesDiff,toDeclarationParams,+ toVarValue,+ hasExpressionChildren,renderStateStyles,+ simulateConditionBreakpoints,} = __testing__;const createTestSheet = () =>@@ -744,3 +751,215 @@ describe("getPresetStyleSelector", () => {);});});++describe("hasExpressionChildren", () => {+ const createInstance = (+ id: string,+ children: Instance["children"] = []+ ): Instance => ({+ id,+ type: "instance",+ component: "Box",+ children,+ });++ test("returns false for instance with no children", () => {+ expect(hasExpressionChildren(createInstance("box"))).toBe(false);+ });++ test("returns false for instance with only id children", () => {+ expect(+ hasExpressionChildren(+ createInstance("box", [+ { type: "id", value: "child-1" },+ { type: "id", value: "child-2" },+ ])+ )+ ).toBe(false);+ });++ test("returns false for instance with text children", () => {+ expect(+ hasExpressionChildren(+ createInstance("box", [{ type: "text", value: "hello" }])+ )+ ).toBe(false);+ });++ test("returns true for instance with expression child", () => {+ expect(+ hasExpressionChildren(+ createInstance("box", [{ type: "expression", value: "someExpr" }])+ )+ ).toBe(true);+ });++ test("returns true when expression is mixed with other children", () => {+ expect(+ hasExpressionChildren(+ createInstance("box", [+ { type: "text", value: "hello" },+ { type: "expression", value: "expr" },+ { type: "id", value: "child" },+ ])+ )+ ).toBe(true);+ });+});++describe("toVarValue", () => {+ test("returns var type with escaped property name", () => {+ const result = toVarValue(+ createStyleDecl({+ styleSourceId: "source-1",+ state: ":hover",+ property: "color",+ }),+ mockTransformValue+ );+ expect(result.type).toBe("var");+ expect(result.value).toBe(CSS.escape("source-1-:hover-color"));+ });++ test("uses style decl value as fallback by default", () => {+ const result = toVarValue(+ createStyleDecl({+ value: { type: "keyword", value: "red" },+ }),+ mockTransformValue+ );+ expect(result.fallback).toEqual({ type: "keyword", value: "red" });+ });++ test("uses explicit fallback when provided", () => {+ const result = toVarValue(+ createStyleDecl({+ value: { type: "keyword", value: "red" },+ }),+ mockTransformValue,+ { type: "keyword", value: "blue" }+ );+ expect(result.fallback).toEqual({ type: "keyword", value: "blue" });+ });++ test("handles missing state", () => {+ const result = toVarValue(+ createStyleDecl({+ styleSourceId: "local",+ state: undefined,+ property: "display",+ }),+ mockTransformValue+ );+ expect(result.value).toBe(CSS.escape("local--display"));+ });++ test("handles pseudo-element state", () => {+ const result = toVarValue(+ createStyleDecl({+ styleSourceId: "abc",+ state: "::before",+ property: "content",+ }),+ mockTransformValue+ );+ expect(result.value).toBe(CSS.escape("abc-::before-content"));+ });+});++describe("simulateConditionBreakpoints", () => {+ const base = { id: "base", label: "Base" };+ const dark = {+ id: "dark",+ label: "Dark",+ condition: "prefers-color-scheme:dark",+ };+ const light = {+ id: "light",+ label: "Light",+ condition: "prefers-color-scheme:light",+ };+ const tablet = { id: "tablet", label: "Tablet", maxWidth: 991 };+ const portrait = {+ id: "portrait",+ label: "Portrait",+ condition: "orientation:portrait",+ };++ test("passes breakpoints through when no condition is selected", () => {+ const result = simulateConditionBreakpoints({+ breakpoints: [base, dark, tablet],+ selectedBreakpoint: base,+ });+ expect(result).toEqual(+ new Map([+ ["base", base],+ ["dark", dark],+ ["tablet", tablet],+ ])+ );+ });++ test("simulates matching condition as all", () => {+ const result = simulateConditionBreakpoints({+ breakpoints: [base, dark, light],+ selectedBreakpoint: dark,+ });+ expect(result.get("dark")).toEqual({ mediaType: "all" });+ });++ test("simulates non-matching same-feature condition as not all", () => {+ const result = simulateConditionBreakpoints({+ breakpoints: [base, dark, light],+ selectedBreakpoint: dark,+ });+ expect(result.get("light")).toEqual({ mediaType: "not all" });+ });++ test("does not affect base breakpoint", () => {+ const result = simulateConditionBreakpoints({+ breakpoints: [base, dark, light],+ selectedBreakpoint: dark,+ });+ expect(result.get("base")).toEqual(base);+ });++ test("does not affect unrelated condition breakpoints", () => {+ const result = simulateConditionBreakpoints({+ breakpoints: [base, dark, portrait],+ selectedBreakpoint: dark,+ });+ expect(result.get("portrait")).toEqual(portrait);+ });++ test("does not affect width-based breakpoints", () => {+ const result = simulateConditionBreakpoints({+ breakpoints: [base, dark, tablet],+ selectedBreakpoint: dark,+ });+ expect(result.get("tablet")).toEqual(tablet);+ });++ test("handles undefined selected breakpoint", () => {+ const result = simulateConditionBreakpoints({+ breakpoints: [base, dark],+ selectedBreakpoint: undefined,+ });+ expect(result).toEqual(+ new Map([+ ["base", base],+ ["dark", dark],+ ])+ );+ });++ test("handles breakpoint with empty string condition", () => {+ const emptyCondition = { id: "empty", label: "Empty", condition: "" };+ const result = simulateConditionBreakpoints({+ breakpoints: [base, emptyCondition, dark],+ selectedBreakpoint: dark,+ });+ // Empty condition doesn't parse, so it passes through unchanged+ expect(result.get("empty")).toEqual(emptyCondition);+ });+});diff --git a/apps/builder/app/canvas/shared/styles.ts b/apps/builder/app/canvas/shared/styles.tsindex 983dee45a2..731d73439a 100644--- a/apps/builder/app/canvas/shared/styles.ts+++ b/apps/builder/app/canvas/shared/styles.ts@@ -14,9 +14,10 @@ import {addFontRules,} from "@webstudio-is/sdk";import { collapsedAttribute, idAttribute } from "@webstudio-is/react-sdk";-import { isPseudoElement } from "@webstudio-is/css-data";+import { isPseudoElement, parseMediaCondition } from "@webstudio-is/css-data";import {StyleValue,+ type MediaRuleOptions,type StyleSheetRegular,type TransformValue,type VarValue,@@ -31,6 +32,7 @@ import {$instances,$props,$registeredComponentMetas,+ $selectedBreakpoint,$selectedInstanceSelector,$selectedStyleState,$styleSourceSelections,@@ -413,6 +415,38 @@ const $descendantSelectors = computed(computeDescendantSelectors);+/**+ * Transform breakpoint options to simulate condition-based breakpoints.+ * When a condition breakpoint is selected (e.g. prefers-color-scheme:dark),+ * breakpoints with the same feature+value render as base (always apply),+ * same feature but different value render as "not all" (never apply),+ * and all others are unchanged.+ */+const simulateConditionBreakpoints = ({+ breakpoints,+ selectedBreakpoint,+}: {+ breakpoints: Iterable<Breakpoint>;+ selectedBreakpoint: Breakpoint | undefined;+}): Map<string, MediaRuleOptions> => {+ const result = new Map<string, MediaRuleOptions>();+ const simulated = selectedBreakpoint?.condition+ ? parseMediaCondition(selectedBreakpoint.condition)+ : undefined;+ for (const breakpoint of breakpoints) {+ if (simulated && breakpoint.condition) {+ const parsed = parseMediaCondition(breakpoint.condition);+ if (parsed?.feature === simulated.feature) {+ const mediaType = parsed.value === simulated.value ? "all" : "not all";+ result.set(breakpoint.id, { mediaType });+ continue;+ }+ }+ result.set(breakpoint.id, breakpoint);+ }+ return result;+};+/*** track new or deleted styles and style source selections items* and update style sheet accordingly@@ -430,9 +464,17 @@ export const subscribeStyles = () => {});};- const unsubscribeBreakpoints = $breakpoints.subscribe((breakpoints) => {- for (const breakpoint of breakpoints.values()) {- userSheet.addMediaRule(breakpoint.id, breakpoint);+ const unsubscribeBreakpoints = computed(+ [$breakpoints, $selectedBreakpoint],+ (breakpoints, selectedBreakpoint) =>+ [breakpoints, selectedBreakpoint] as const+ ).subscribe(([breakpoints, selectedBreakpoint]) => {+ const mediaRules = simulateConditionBreakpoints({+ breakpoints: breakpoints.values(),+ selectedBreakpoint,+ });+ for (const [id, options] of mediaRules) {+ userSheet.addMediaRule(id, options);}renderUserSheetInTheNextFrame();});@@ -826,5 +868,8 @@ export const __testing__ = {computeEditableCursorRules,computeStylesDiff,toDeclarationParams,+ toVarValue,+ hasExpressionChildren,renderStateStyles,+ simulateConditionBreakpoints,};diff --git a/apps/builder/package.json b/apps/builder/package.jsonindex eb9c29d64b..ef715e8e4a 100644--- a/apps/builder/package.json+++ b/apps/builder/package.json@@ -134,6 +134,7 @@"@types/react-dom": "^18.2.25","@vitest/coverage-v8": "3.1.2","@webstudio-is/tsconfig": "workspace:*",+ "css.escape": "^1.5.1","fast-glob": "^3.3.2","html-tags": "^4.0.0","react-router-dom": "^6.30.0",diff --git a/packages/css-data/src/index.ts b/packages/css-data/src/index.tsindex 0cb3b42c91..566d74f38b 100644--- a/packages/css-data/src/index.ts+++ b/packages/css-data/src/index.ts@@ -19,6 +19,7 @@ export * from "./property-parsers";export * from "./parse-css-value";export * from "./parse-css";export * from "./shorthands";+export * from "./media-condition-simulator";export { shorthandProperties } from "./__generated__/shorthand-properties";export { properties as propertiesData } from "./__generated__/properties";diff --git a/packages/css-data/src/media-condition-simulator.test.ts b/packages/css-data/src/media-condition-simulator.test.tsnew file mode 100644index 0000000000..fbb270f9ee--- /dev/null+++ b/packages/css-data/src/media-condition-simulator.test.ts@@ -0,0 +1,45 @@+import { describe, test, expect } from "vitest";+import { parseMediaCondition } from "./media-condition-simulator";++describe("parseMediaCondition", () => {+ test("parses simple condition without parentheses", () => {+ const result = parseMediaCondition("prefers-color-scheme:dark");+ expect(result).toEqual({ feature: "prefers-color-scheme", value: "dark" });+ });++ test("parses condition with parentheses", () => {+ const result = parseMediaCondition("(prefers-color-scheme: dark)");+ expect(result).toEqual({ feature: "prefers-color-scheme", value: "dark" });+ });++ test("parses width condition", () => {+ const result = parseMediaCondition("min-width:768px");+ expect(result).toEqual({ feature: "min-width", value: "768px" });+ });++ test("parses hover condition", () => {+ const result = parseMediaCondition("hover:none");+ expect(result).toEqual({ feature: "hover", value: "none" });+ });++ test("parses orientation condition", () => {+ const result = parseMediaCondition("orientation:portrait");+ expect(result).toEqual({ feature: "orientation", value: "portrait" });+ });++ test("normalizes feature and value to lowercase", () => {+ const result = parseMediaCondition("Prefers-Color-Scheme:DARK");+ expect(result).toEqual({ feature: "prefers-color-scheme", value: "dark" });+ });++ test("handles spaces around colon", () => {+ const result = parseMediaCondition("prefers-color-scheme : dark");+ expect(result).toEqual({ feature: "prefers-color-scheme", value: "dark" });+ });++ test("returns undefined for invalid condition", () => {+ expect(parseMediaCondition("invalid")).toBeUndefined();+ expect(parseMediaCondition("")).toBeUndefined();+ expect(parseMediaCondition(":::")).toBeUndefined();+ });+});diff --git a/packages/css-data/src/media-condition-simulator.ts b/packages/css-data/src/media-condition-simulator.tsnew file mode 100644index 0000000000..ae861113de--- /dev/null+++ b/packages/css-data/src/media-condition-simulator.ts@@ -0,0 +1,29 @@+import * as csstree from "css-tree";++/**+ * Parse a condition string like "prefers-color-scheme:dark" into feature and value.+ */+export const parseMediaCondition = (+ condition: string+): { feature: string; value: string } | undefined => {+ try {+ const queryText = condition.startsWith("(") ? condition : `(${condition})`;+ const ast = csstree.parse(queryText, { context: "mediaQuery" });++ let feature: string | undefined;+ let value: string | undefined;++ csstree.walk(ast, (node) => {+ if (node.type === "Feature" && node.value) {+ feature = node.name.toLowerCase();+ value = csstree.generate(node.value).toLowerCase();+ }+ });++ if (feature !== undefined && value !== undefined) {+ return { feature, value };+ }+ } catch {+ return;+ }+};diff --git a/packages/css-engine/src/core/compare-media.test.ts b/packages/css-engine/src/core/compare-media.test.tsindex 166b2d0526..681d5f2b03 100644--- a/packages/css-engine/src/core/compare-media.test.ts+++ b/packages/css-engine/src/core/compare-media.test.ts@@ -119,4 +119,76 @@ describe("Compare media", () => {const sorted = initial.sort(compareMedia);expect(sorted).toStrictEqual(expected);});++ test("simulated conditions (mediaType only) sorted after base", () => {+ const initial = [+ {},+ { mediaType: "all" as const },+ { mediaType: "not all" as const },+ ];+ const expected = [+ {},+ { mediaType: "all" as const },+ { mediaType: "not all" as const },+ ];+ const sorted = initial.sort(compareMedia);+ expect(sorted).toStrictEqual(expected);+ });++ test("simulated conditions sorted before width-based", () => {+ const initial = [+ {},+ { minWidth: 1024 },+ { mediaType: "all" as const },+ { maxWidth: 768 },+ ];+ const expected = [+ {},+ { mediaType: "all" as const },+ { maxWidth: 768 },+ { minWidth: 1024 },+ ];+ const sorted = initial.sort(compareMedia);+ expect(sorted).toStrictEqual(expected);+ });++ test("simulated conditions mixed with real conditions", () => {+ const initial = [+ {},+ { condition: "prefers-color-scheme:dark" },+ { mediaType: "all" as const },+ { mediaType: "not all" as const },+ { condition: "hover:hover" },+ ];+ // Both real conditions and simulated conditions sort together+ // Real conditions have their condition string, simulated have ""+ const expected = [+ {},+ { mediaType: "all" as const },+ { mediaType: "not all" as const },+ { condition: "hover:hover" },+ { condition: "prefers-color-scheme:dark" },+ ];+ const sorted = initial.sort(compareMedia);+ expect(sorted).toStrictEqual(expected);+ });++ test("full simulation scenario: base, simulated dark, hidden light, width", () => {+ const initial = [+ {},+ { maxWidth: 991 },+ { mediaType: "all" as const }, // simulated dark (always applies)+ { mediaType: "not all" as const }, // simulated light (hidden)+ { minWidth: 1280 },+ ];+ const expected = [+ {},+ { mediaType: "all" as const },+ { mediaType: "not all" as const },+ { maxWidth: 991 },+ { minWidth: 1280 },+ ];+ const sorted = initial.sort(compareMedia);+ expect(sorted).toStrictEqual(expected);+ });});diff --git a/packages/css-engine/src/core/compare-media.ts b/packages/css-engine/src/core/compare-media.tsindex 352a7ace7f..05f3010e82 100644--- a/packages/css-engine/src/core/compare-media.ts+++ b/packages/css-engine/src/core/compare-media.ts@@ -1,5 +1,28 @@import type { MediaRuleOptions } from "./rules";+/**+ * Check if a media rule is a simulated condition breakpoint.+ * Simulated conditions have an explicit mediaType ("all" or "not all")+ * but no condition, minWidth, or maxWidth.+ *+ * Note: This assumes that options with ONLY mediaType set are always simulated+ * conditions, not legitimate "screen-only" or "print-only" queries.+ * This is safe because the codebase doesn't use standalone mediaType options+ * for any other purpose.+ */+const isSimulatedCondition = (options: MediaRuleOptions) =>+ options.mediaType !== undefined &&+ options.condition === undefined &&+ options.minWidth === undefined &&+ options.maxWidth === undefined;++/**+ * Check if a media rule is a condition-based breakpoint+ * (either real or simulated).+ */+const isCondition = (options: MediaRuleOptions) =>+ options.condition !== undefined || isSimulatedCondition(options);+/*** Sort media queries for CSS cascade order.* Width-based: minWidth descending, then maxWidth ascending@@ -11,19 +34,22 @@ export const compareMedia = (optionA: MediaRuleOptions,optionB: MediaRuleOptions) => {- // If both have custom conditions, sort alphabetically- if (optionA.condition !== undefined && optionB.condition !== undefined) {- return optionA.condition.localeCompare(optionB.condition);+ const aIsCondition = isCondition(optionA);+ const bIsCondition = isCondition(optionB);++ // If both are conditions (real or simulated), sort alphabetically by condition+ if (aIsCondition && bIsCondition) {+ return (optionA.condition ?? "").localeCompare(optionB.condition ?? "");}- // Custom condition comes after base but before width-based- if (optionA.condition !== undefined) {+ // Condition comes after base but before width-based+ if (aIsCondition) {if (optionB.minWidth === undefined && optionB.maxWidth === undefined) {return 1; // optionA (condition) after optionB (base)}return -1; // optionA (condition) before optionB (width)}- if (optionB.condition !== undefined) {+ if (bIsCondition) {if (optionA.minWidth === undefined && optionA.maxWidth === undefined) {return -1; // optionA (base) before optionB (condition)}diff --git a/packages/css-engine/src/core/index.ts b/packages/css-engine/src/core/index.tsindex faef6f4b5f..687a5487bc 100644--- a/packages/css-engine/src/core/index.ts+++ b/packages/css-engine/src/core/index.ts@@ -2,6 +2,7 @@ export type {StyleMap,NestingRule,MediaRule,+ MediaRuleOptions,PlaintextRule,FontFaceRule,} from "./rules";diff --git a/packages/css-engine/src/core/rules.ts b/packages/css-engine/src/core/rules.tsindex be935c88b4..509cf81d4d 100644--- a/packages/css-engine/src/core/rules.ts+++ b/packages/css-engine/src/core/rules.ts@@ -301,19 +301,17 @@ export type MediaRuleOptions = {minWidth?: number;maxWidth?: number;condition?: string;- mediaType?: "all" | "screen" | "print";+ mediaType?: "all" | "not all" | "screen" | "print";};export class MediaRule {#name: string;options: MediaRuleOptions;rules: Map<string, PlaintextRule>;- #mediaType;constructor(name: string, options: MediaRuleOptions = {}) {this.#name = name;this.options = options;this.rules = new Map();- this.#mediaType = options.mediaType ?? "all";}insertRule(rule: PlaintextRule) {this.rules.set(rule.cssText, rule);@@ -354,7 +352,7 @@ export class MediaRule {return "";}let conditionText = "";- const { minWidth, maxWidth, condition } = this.options;+ const { minWidth, maxWidth, condition, mediaType = "all" } = this.options;// condition and minWidth/maxWidth are mutually exclusive// If condition is set, use it exclusively (minWidth/maxWidth must be undefined)@@ -370,9 +368,7 @@ export class MediaRule {}}- return `@media ${this.#mediaType}${conditionText} {\n${rules.join(- "\n"- )}\n}`;+ return `@media ${mediaType}${conditionText} {\n${rules.join("\n")}\n}`;}}diff --git a/packages/css-engine/src/core/style-sheet-regular.test.ts b/packages/css-engine/src/core/style-sheet-regular.test.tsindex 5ef9386395..83aa0da0cc 100644--- a/packages/css-engine/src/core/style-sheet-regular.test.ts+++ b/packages/css-engine/src/core/style-sheet-regular.test.ts@@ -501,6 +501,51 @@ describe("Style Sheet Regular", () => {`);});+ test("update condition media rule to simulated mediaType", () => {+ const sheet = createRegularStyleSheet();+ sheet.addMediaRule("base", {});+ sheet.addMediaRule("dark", { condition: "prefers-color-scheme:dark" });+ sheet.addMediaRule("light", { condition: "prefers-color-scheme:light" });+ sheet.addNestingRule(".c").setDeclaration({+ breakpoint: "base",+ selector: "",+ property: "color",+ value: { type: "keyword", value: "red" },+ });+ sheet.addNestingRule(".c").setDeclaration({+ breakpoint: "dark",+ selector: "",+ property: "color",+ value: { type: "keyword", value: "blue" },+ });+ sheet.addNestingRule(".c").setDeclaration({+ breakpoint: "light",+ selector: "",+ property: "color",+ value: { type: "keyword", value: "green" },+ });+ // simulate selecting "dark" breakpoint+ sheet.addMediaRule("dark", { mediaType: "all" });+ sheet.addMediaRule("light", { mediaType: "not all" });+ expect(sheet.cssText).toMatchInlineSnapshot(`+ "@media all {+ .c {+ color: red+ }+ }+ @media all {+ .c {+ color: blue+ }+ }+ @media not all {+ .c {+ color: green+ }+ }"+ `);+ });+test("don't override media queries", () => {const sheet = createRegularStyleSheet();sheet.addMediaRule(mediaId0, mediaRuleOptions0);diff --git a/pnpm-lock.yaml b/pnpm-lock.yamlindex ffa55da188..ba354db96f 100644--- a/pnpm-lock.yaml+++ b/pnpm-lock.yaml@@ -452,6 +452,9 @@ importers:'@webstudio-is/tsconfig':specifier: workspace:*version: link:../../packages/tsconfig+ css.escape:+ specifier: ^1.5.1+ version: 1.5.1fast-glob:specifier: ^3.3.2version: 3.3.2@@ -6164,6 +6167,9 @@ packages:resolution: {integrity: sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==}engines: {node: '>= 6'}+ resolution: {integrity: sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==}+resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==}engines: {node: '>=4'}@@ -6806,20 +6812,22 @@ packages:resolution: {integrity: sha512-92vPiMb/iqpmEgsOoIDvTjc50wf9CCCvMzsi6W0JLPeUKE8TWP1a73PgqSrqy7iAZxaSD1YdzU7QZR5LF51MJw==}engines: {node: '>=16 || 14 >=14.17'}+ deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting [email protected]hasBin: trueresolution: {integrity: sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==}+ deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting [email protected]hasBin: trueresolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}- deprecated: Glob versions prior to v9 are no longer supported+ deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting [email protected]resolution: {integrity: sha512-ull455NHSHI/Y1FqGaaYFaLGkNMMJbavMrEGFXG/PGrg6y7sutWHUHrz6gy6WEBH6akM1M414dWKCNs+IhKdiQ==}engines: {node: '>=12'}- deprecated: Glob versions prior to v9 are no longer supported+ deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting [email protected]resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==}@@ -8830,6 +8838,7 @@ packages:resolution: {integrity: sha512-jdIBIN6LTIe2jqzay/2vtYLlBHa3JF42ot3h1dW8Q0PaAG4v8rm0cvpVePtau5C6OKXGGcgO9q2AMNSWxiLqKw==}engines: {node: '>=10'}+ deprecated: Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting [email protected]resolution: {integrity: sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==}@@ -13699,6 +13708,8 @@ snapshots:+ [email protected]: {}+