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
import { toValue } from "@webstudio-is/css-engine";
import {
createId,
getStyleDeclKey,
ROOT_INSTANCE_ID,
type Breakpoint,
type Instance,
type StyleDecl,
type StyleSource,
type StyleSourceSelection,
type StyleSourceSelections,
type StyleSources,
type Styles,
} from "@webstudio-is/sdk";
import { getUniqueNameWithSuffix } from "./style-utils";
const createNanoId = () => createId("nano");
export type ConflictResolution = "ours" | "theirs" | "merge";
export type RootStyleConflictResolution = "ours" | "theirs";
export type RootStyleConflict = {
existingStyle: StyleDecl;
incomingStyle: StyleDecl;
};
const findLocalStyleSourceIds = ({
instanceId,
styleSourceSelections,
styleSources,
}: {
instanceId: Instance["id"];
styleSourceSelections: Iterable<StyleSourceSelection>;
styleSources: Iterable<StyleSource>;
}) => {
const localStyleSourceIds = new Set(
Array.from(styleSources)
.filter((styleSource) => styleSource.type === "local")
.map((styleSource) => styleSource.id)
);
const selection = Array.from(styleSourceSelections).find(
(candidate) => candidate.instanceId === instanceId
);
return selection?.values.filter((id) => localStyleSourceIds.has(id)) ?? [];
};
export const detectRootStyleConflicts = ({
fragmentStyleSources,
fragmentStyleSourceSelections,
fragmentStyles,
existingStyleSources,
existingStyleSourceSelections,
existingStyles,
mergedBreakpointIds,
}: {
fragmentStyleSources: StyleSource[];
fragmentStyleSourceSelections: StyleSourceSelection[];
fragmentStyles: StyleDecl[];
existingStyleSources: StyleSources;
existingStyleSourceSelections: StyleSourceSelections;
existingStyles: Styles;
mergedBreakpointIds: Map<Breakpoint["id"], Breakpoint["id"]>;
}): RootStyleConflict[] => {
const incomingStyleSourceIds = new Set(
findLocalStyleSourceIds({
instanceId: ROOT_INSTANCE_ID,
styleSourceSelections: fragmentStyleSourceSelections,
styleSources: fragmentStyleSources,
})
);
const existingStyleSourceId = findLocalStyleSourceIds({
instanceId: ROOT_INSTANCE_ID,
styleSourceSelections: existingStyleSourceSelections.values(),
styleSources: existingStyleSources.values(),
}).at(-1);
if (
incomingStyleSourceIds.size === 0 ||
existingStyleSourceId === undefined
) {
return [];
}
const conflicts: RootStyleConflict[] = [];
for (const incomingStyle of fragmentStyles) {
if (incomingStyleSourceIds.has(incomingStyle.styleSourceId) === false) {
continue;
}
const normalizedIncomingStyle = {
...incomingStyle,
styleSourceId: existingStyleSourceId,
breakpointId:
mergedBreakpointIds.get(incomingStyle.breakpointId) ??
incomingStyle.breakpointId,
};
const existingStyle = existingStyles.get(
getStyleDeclKey(normalizedIncomingStyle)
);
if (
existingStyle !== undefined &&
toValue(existingStyle.value) !== toValue(incomingStyle.value)
) {
conflicts.push({ existingStyle, incomingStyle });
}
}
return conflicts;
};
export const getStyleSourceStylesSignature = (
styleSourceId: StyleSource["id"],
styles: StyleDecl[],
breakpoints: Map<Breakpoint["id"], Breakpoint>,
mergedBreakpointIds: Map<Breakpoint["id"], Breakpoint["id"]>
): string => {
const tokenStyles = styles
.filter((decl) => decl.styleSourceId === styleSourceId)
.map((decl) => {
// Get merged breakpoint id to ensure consistent comparison
const breakpointId =
mergedBreakpointIds.get(decl.breakpointId) ?? decl.breakpointId;
const breakpoint = breakpoints.get(breakpointId);
const breakpointKey = breakpoint
? JSON.stringify({ minWidth: breakpoint.minWidth })
: "base";
const state = decl.state ?? "";
return `${breakpointKey}|${state}|${decl.property}:${toValue(decl.value)}`;
})
.sort()
.join(";");
return tokenStyles;
};
/**
* Check if a token with the same name and matching styles already exists.
* Returns the existing token if found, undefined otherwise.
*/
export const findTokenWithMatchingStyles = ({
tokenName,
tokenStyles,
existingTokens,
existingStyles,
breakpoints,
mergedBreakpointIds,
}: {
tokenName: string;
tokenStyles: StyleDecl[];
existingTokens: StyleSource[];
existingStyles: StyleDecl[];
breakpoints: Map<Breakpoint["id"], Breakpoint>;
mergedBreakpointIds: Map<Breakpoint["id"], Breakpoint["id"]>;
}):
| {
hasConflict: false;
matchingToken: Extract<StyleSource, { type: "token" }>;
}
| { hasConflict: true; matchingToken: undefined }
| { hasConflict: false; matchingToken: undefined } => {
// Find tokens with the same name
const tokensWithSameName = existingTokens.filter(
(token): token is Extract<StyleSource, { type: "token" }> =>
token.type === "token" && token.name === tokenName
);
if (tokensWithSameName.length === 0) {
return { hasConflict: false, matchingToken: undefined };
}
// Get the signature of the token we're checking
// Use a temporary ID since we're just comparing styles
const tempId = "temp";
const signature = getStyleSourceStylesSignature(
tempId,
tokenStyles.map((style) => ({ ...style, styleSourceId: tempId })),
breakpoints,
mergedBreakpointIds
);
// Check if any existing token with the same name has matching styles
for (const existing of tokensWithSameName) {
const existingSignature = getStyleSourceStylesSignature(
existing.id,
existingStyles,
breakpoints,
mergedBreakpointIds
);
if (existingSignature === signature) {
return { hasConflict: false, matchingToken: existing };
}
}
// Same name but different styles = conflict
return { hasConflict: true, matchingToken: undefined };
};
export type TokenConflict = {
tokenName: string;
fragmentTokenId: StyleSource["id"];
fragmentToken: Extract<StyleSource, { type: "token" }>;
existingToken: Extract<StyleSource, { type: "token" }>;
};
/**
* Detect all token conflicts before insertion.
* Returns an array of conflicts where fragment tokens have the same name but different styles than existing tokens.
*/
export const detectTokenConflicts = ({
fragmentStyleSources,
fragmentStyles,
referenceTokenIds,
existingStyleSources,
existingStyles,
breakpoints,
mergedBreakpointIds,
}: {
fragmentStyleSources: StyleSource[];
fragmentStyles: StyleDecl[];
referenceTokenIds?: Set<string>;
existingStyleSources: StyleSources;
existingStyles: Styles;
breakpoints: Map<Breakpoint["id"], Breakpoint>;
mergedBreakpointIds: Map<Breakpoint["id"], Breakpoint["id"]>;
}): TokenConflict[] => {
const conflicts: TokenConflict[] = [];
const comparedTokens = Array.from(existingStyleSources.values());
const comparedStyles = Array.from(existingStyles.values());
for (const styleSource of fragmentStyleSources) {
if (
styleSource.type !== "token" ||
referenceTokenIds?.has(styleSource.id)
) {
continue;
}
const result = findTokenWithMatchingStyles({
tokenName: styleSource.name,
tokenStyles: fragmentStyles.filter(
(decl) => decl.styleSourceId === styleSource.id
),
existingTokens: comparedTokens,
existingStyles: comparedStyles,
breakpoints,
mergedBreakpointIds,
});
if (result.hasConflict) {
// Find the first existing token with the same name for display purposes
const existingToken = comparedTokens.find(
(token) => token.type === "token" && token.name === styleSource.name
);
if (existingToken && existingToken.type === "token") {
conflicts.push({
tokenName: styleSource.name,
fragmentTokenId: styleSource.id,
fragmentToken: styleSource,
existingToken,
});
}
continue;
}
if (result.matchingToken === undefined) {
comparedTokens.push(styleSource);
comparedStyles.push(
...fragmentStyles.filter(
(declaration) => declaration.styleSourceId === styleSource.id
)
);
}
}
return conflicts;
};
/**
* Style Source Conflict Resolution Rules:
*
* When inserting a fragment with style sources (tokens), the following rules determine whether to reuse,
* rename, or create new style sources:
*
* 1. Same name + Same styles → Reuse existing style source (no new style source created)
* 2. Same name + Different styles → Add counter suffix (e.g., "myToken-1", "myToken-2") OR use existing based on onConflict
* 3. Different name + Same styles → Insert as new style source with its own name
* 4. Different name + Different styles → Insert as new style source normally
* 5. Name collision safeguard → Always add counter suffix if name already exists
* 6. Style comparison → Only compares CSS signatures when style source names match
*
* All new style sources receive a fresh UUID to prevent ID collisions. The styleSourceIdMap tracks
* originalFragmentStyleSourceId → newStyleSourceId (or existingStyleSourceId if reused) to ensure all
* references (styles, styleSourceSelections) are updated correctly.
*/
export const insertStyleSources = ({
fragmentStyleSources,
fragmentStyles,
referencedTokenIds,
existingStyleSources,
existingStyles,
breakpoints,
mergedBreakpointIds,
conflictResolution = "theirs",
createId = createNanoId,
}: {
fragmentStyleSources: StyleSource[];
fragmentStyles: StyleDecl[];
referencedTokenIds?: Map<string, string>;
existingStyleSources: StyleSources;
existingStyles: Styles;
breakpoints: Map<Breakpoint["id"], Breakpoint>;
mergedBreakpointIds: Map<Breakpoint["id"], Breakpoint["id"]>;
/** How to handle conflicts: "theirs" = add suffix (keep incoming), "ours" = use existing token, "merge" = merge styles (theirs overrides ours) */
conflictResolution?: ConflictResolution;
createId?: () => string;
}): {
styleSourceIds: Set<StyleSource["id"]>;
styleSourceIdMap: Map<StyleSource["id"], StyleSource["id"]>;
updatedStyleSources: StyleSources;
} => {
// Build a map of existing tokens by name
const existingTokensByName = new Map<string, StyleSource[]>();
for (const styleSource of existingStyleSources.values()) {
if (styleSource.type !== "token") {
continue;
}
const tokensWithName = existingTokensByName.get(styleSource.name) ?? [];
tokensWithName.push(styleSource);
existingTokensByName.set(styleSource.name, tokensWithName);
}
const styleSourceIds = new Set<StyleSource["id"]>();
const styleSourceIdMap = new Map<StyleSource["id"], StyleSource["id"]>(); // old id -> new id
const updatedStyleSources = new Map(existingStyleSources);
const comparedStyles = new Map(existingStyles);
const trackIncomingStyles = (fromId: string, toId: string) => {
for (const declaration of fragmentStyles) {
if (declaration.styleSourceId !== fromId) {
continue;
}
const tracked = {
...declaration,
styleSourceId: toId,
breakpointId:
mergedBreakpointIds.get(declaration.breakpointId) ??
declaration.breakpointId,
};
comparedStyles.set(getStyleDeclKey(tracked), tracked);
}
};
for (const styleSource of fragmentStyleSources) {
if (styleSource.type === "local") {
continue;
}
styleSource.type satisfies "token";
const originalFragmentTokenId = styleSource.id;
const referencedTokenId = referencedTokenIds?.get(originalFragmentTokenId);
if (referencedTokenId !== undefined) {
styleSourceIdMap.set(originalFragmentTokenId, referencedTokenId);
continue;
}
const newTokenId = createId();
// Check if there's an existing token with the same name
const tokensWithSameName = existingTokensByName.get(styleSource.name);
if (tokensWithSameName && tokensWithSameName.length > 0) {
// Same name exists - compare styles to decide if we can reuse
const result = findTokenWithMatchingStyles({
tokenName: styleSource.name,
tokenStyles: fragmentStyles.filter(
(decl) => decl.styleSourceId === originalFragmentTokenId
),
existingTokens: tokensWithSameName,
existingStyles: Array.from(comparedStyles.values()),
breakpoints,
mergedBreakpointIds,
});
if (result.matchingToken) {
// Same name AND same styles -> reuse existing token
styleSourceIdMap.set(originalFragmentTokenId, result.matchingToken.id);
continue; // Don't insert, reuse existing
}
if (result.hasConflict) {
// Same name but different styles
if (conflictResolution === "ours") {
// Use the existing token instead of creating a new one
const existingToken = tokensWithSameName[0];
if (existingToken.type !== "token") {
continue;
}
styleSourceIdMap.set(originalFragmentTokenId, existingToken.id);
continue; // Don't insert, use existing
} else if (conflictResolution === "merge") {
// Merge: keep existing token name/id, but merge styles (theirs overrides ours)
const existingToken = tokensWithSameName[0];
if (existingToken.type !== "token") {
continue;
}
// Map the fragment token to the existing token
styleSourceIdMap.set(originalFragmentTokenId, existingToken.id);
// Mark the existing token for style insertion
// This will allow the fragment styles to be added/merged
styleSourceIds.add(originalFragmentTokenId);
trackIncomingStyles(originalFragmentTokenId, existingToken.id);
continue;
} else {
// Default: add counter suffix
const newName = getUniqueNameWithSuffix(
styleSource.name,
Array.from(updatedStyleSources.values())
.filter((source) => source.type === "token")
.map((source) => source.name)
);
const newStyleSource = {
...styleSource,
id: newTokenId,
name: newName,
};
styleSourceIds.add(originalFragmentTokenId);
updatedStyleSources.set(newTokenId, newStyleSource);
styleSourceIdMap.set(originalFragmentTokenId, newTokenId);
trackIncomingStyles(originalFragmentTokenId, newTokenId);
// Add to tracking maps
const tokensWithNewName = existingTokensByName.get(newName) ?? [];
tokensWithNewName.push(newStyleSource);
existingTokensByName.set(newName, tokensWithNewName);
continue;
}
}
}
// Different name (or no existing tokens) -> insert with new ID
const newStyleSource = { ...styleSource, id: newTokenId };
styleSourceIds.add(originalFragmentTokenId);
updatedStyleSources.set(newTokenId, newStyleSource);
styleSourceIdMap.set(originalFragmentTokenId, newTokenId);
trackIncomingStyles(originalFragmentTokenId, newTokenId);
// Add to tracking maps
const tokensWithName = existingTokensByName.get(styleSource.name) ?? [];
tokensWithName.push(newStyleSource);
existingTokensByName.set(styleSource.name, tokensWithName);
}
return {
styleSourceIds,
styleSourceIdMap,
updatedStyleSources,
};
};
export const insertTokenStyleSources = ({
fragmentStyleSources,
fragmentStyles,
referencedTokenIds,
styleSources,
styles,
breakpoints,
mergedBreakpointIds,
conflictResolution = "theirs",
createId,
}: {
fragmentStyleSources: StyleSource[];
fragmentStyles: StyleDecl[];
referencedTokenIds?: Map<string, string>;
styleSources: StyleSources;
styles: Styles;
breakpoints: Map<Breakpoint["id"], Breakpoint>;
mergedBreakpointIds: Map<Breakpoint["id"], Breakpoint["id"]>;
conflictResolution?: ConflictResolution;
createId?: () => string;
}) => {
const { styleSourceIds, styleSourceIdMap, updatedStyleSources } =
insertStyleSources({
fragmentStyleSources,
fragmentStyles,
referencedTokenIds,
existingStyleSources: styleSources,
existingStyles: styles,
breakpoints,
mergedBreakpointIds,
conflictResolution,
createId,
});
for (const [id, styleSource] of updatedStyleSources) {
styleSources.set(id, styleSource);
}
for (const styleDecl of fragmentStyles) {
if (styleSourceIds.has(styleDecl.styleSourceId) === false) {
continue;
}
const newStyleDecl: StyleDecl = {
...styleDecl,
breakpointId:
mergedBreakpointIds.get(styleDecl.breakpointId) ??
styleDecl.breakpointId,
styleSourceId:
styleSourceIdMap.get(styleDecl.styleSourceId) ??
styleDecl.styleSourceId,
};
styles.set(getStyleDeclKey(newStyleDecl), newStyleDecl);
}
return styleSourceIdMap;
};
/**
* Insert local style sources for portal content without changing IDs.
* Portal content IDs are preserved to avoid data bloat.
*/
export const insertPortalLocalStyleSources = ({
fragmentStyleSources,
fragmentStyleSourceSelections,
fragmentStyles,
instanceIds,
styleSources,
styleSourceSelections,
styles,
styleSourceIdMap,
mergedBreakpointIds,
}: {
fragmentStyleSources: StyleSource[];
fragmentStyleSourceSelections: StyleSourceSelection[];
fragmentStyles: StyleDecl[];
instanceIds: Set<Instance["id"]>;
styleSources: StyleSources;
styleSourceSelections: StyleSourceSelections;
styles: Styles;
styleSourceIdMap: Map<StyleSource["id"], StyleSource["id"]>;
mergedBreakpointIds: Map<Breakpoint["id"], Breakpoint["id"]>;
}): void => {
const instanceStyleSourceIds = new Set<StyleSource["id"]>();
for (const styleSourceSelection of fragmentStyleSourceSelections) {
const { instanceId } = styleSourceSelection;
if (instanceIds.has(instanceId) === false) {
continue;
}
const values = styleSourceSelection.values.map(
(styleSourceId) => styleSourceIdMap.get(styleSourceId) ?? styleSourceId
);
styleSourceSelections.set(instanceId, { instanceId, values });
for (const styleSourceId of values) {
instanceStyleSourceIds.add(styleSourceId);
}
}
const localStyleSourceIds = new Set<StyleSource["id"]>();
for (const styleSource of fragmentStyleSources) {
if (
styleSource.type === "local" &&
instanceStyleSourceIds.has(styleSource.id)
) {
localStyleSourceIds.add(styleSource.id);
styleSources.set(styleSource.id, styleSource);
}
}
for (const styleDecl of fragmentStyles) {
if (localStyleSourceIds.has(styleDecl.styleSourceId)) {
const { breakpointId } = styleDecl;
const newStyleDecl: StyleDecl = {
...styleDecl,
breakpointId: mergedBreakpointIds.get(breakpointId) ?? breakpointId,
};
styles.set(getStyleDeclKey(newStyleDecl), newStyleDecl);
}
}
};
type InsertLocalStyleSourcesWithNewIdsOptions = {
fragmentStyleSources: StyleSource[];
fragmentStyleSourceSelections: StyleSourceSelection[];
fragmentStyles: StyleDecl[];
fragmentInstanceIds: Set<Instance["id"]>;
newInstanceIds: Map<Instance["id"], Instance["id"]>;
styleSources: StyleSources;
styleSourceSelections: StyleSourceSelections;
styles: Styles;
createId?: () => string;
} & (
| {
contentMode: true;
breakpoints: Map<Breakpoint["id"], Breakpoint>;
styleSourceIdMap?: Map<StyleSource["id"], StyleSource["id"]>;
mergedBreakpointIds?: Map<Breakpoint["id"], Breakpoint["id"]>;
}
| {
contentMode?: false;
breakpoints?: Map<Breakpoint["id"], Breakpoint>;
styleSourceIdMap: Map<StyleSource["id"], StyleSource["id"]>;
mergedBreakpointIds: Map<Breakpoint["id"], Breakpoint["id"]>;
}
);
/**
* Insert local style sources for copied fragment instances.
* Regular mode duplicates local style sources, remaps token ids, and merges
* :root local styles. Content mode keeps only local styles that can render with
* existing breakpoints and reuses existing token ids.
*/
export const insertLocalStyleSourcesWithNewIds = ({
fragmentStyleSources,
fragmentStyleSourceSelections,
fragmentStyles,
fragmentInstanceIds,
newInstanceIds,
styleSources,
styleSourceSelections,
styles,
createId = createNanoId,
contentMode = false,
breakpoints,
styleSourceIdMap = new Map(),
mergedBreakpointIds = new Map(),
}: InsertLocalStyleSourcesWithNewIdsOptions): void => {
const newLocalStyleSources = new Map<StyleSource["id"], StyleSource>();
for (const styleSource of fragmentStyleSources) {
if (styleSource.type === "local") {
newLocalStyleSources.set(styleSource.id, styleSource);
}
}
const newLocalStyleSourceIds = new Map<
StyleSource["id"],
StyleSource["id"]
>();
const copyableContentModeLocalStyleSourceIds = new Set<StyleSource["id"]>();
if (contentMode) {
for (const styleDecl of fragmentStyles) {
if (
newLocalStyleSources.has(styleDecl.styleSourceId) &&
breakpoints?.has(styleDecl.breakpointId)
) {
copyableContentModeLocalStyleSourceIds.add(styleDecl.styleSourceId);
}
}
}
for (const { instanceId, values } of fragmentStyleSourceSelections) {
if (fragmentInstanceIds.has(instanceId) === false) {
continue;
}
const newInstanceId = newInstanceIds.get(instanceId);
if (contentMode && newInstanceId === undefined) {
continue;
}
const targetInstanceId = newInstanceId ?? instanceId;
const existingStyleSourceIds =
styleSourceSelections.get(targetInstanceId)?.values ?? [];
let existingLocalStyleSource;
for (const styleSourceId of existingStyleSourceIds) {
const styleSource = styleSources.get(styleSourceId);
if (styleSource?.type === "local") {
existingLocalStyleSource = styleSource;
}
}
const newStyleSourceIds = [];
for (let styleSourceId of values) {
const newLocalStyleSource = newLocalStyleSources.get(styleSourceId);
if (newLocalStyleSource) {
if (
contentMode &&
copyableContentModeLocalStyleSourceIds.has(styleSourceId) === false
) {
continue;
}
if (contentMode) {
const existingNewLocalStyleSourceId = newLocalStyleSourceIds.get(
newLocalStyleSource.id
);
if (existingNewLocalStyleSourceId) {
newStyleSourceIds.push(existingNewLocalStyleSourceId);
continue;
}
}
// merge only :root styles and duplicate others
if (
contentMode === false &&
instanceId === ROOT_INSTANCE_ID &&
existingLocalStyleSource
) {
// write local styles into existing local style source
styleSourceId = existingLocalStyleSource.id;
} else {
// create new local styles
const newId = createId();
styleSources.set(newId, { ...newLocalStyleSource, id: newId });
styleSourceId = newId;
}
newLocalStyleSourceIds.set(newLocalStyleSource.id, styleSourceId);
} else {
// Check if this is a token that was mapped to an existing token
const mappedTokenId = styleSourceIdMap.get(styleSourceId);
if (mappedTokenId) {
styleSourceId = mappedTokenId;
}
if (contentMode) {
const styleSource = styleSources.get(styleSourceId);
if (styleSource?.type !== "token") {
continue;
}
}
}
newStyleSourceIds.push(styleSourceId);
}
if (contentMode && newStyleSourceIds.length === 0) {
continue;
}
styleSourceSelections.set(targetInstanceId, {
instanceId: targetInstanceId,
// Global root is shared by every page, so importing a fragment must
// preserve its existing tokens and their cascade order.
values:
contentMode === false && instanceId === ROOT_INSTANCE_ID
? Array.from(
new Set([...existingStyleSourceIds, ...newStyleSourceIds])
)
: newStyleSourceIds,
});
}
for (const styleDecl of fragmentStyles) {
const { breakpointId, styleSourceId } = styleDecl;
if (newLocalStyleSourceIds.has(styleDecl.styleSourceId)) {
const newStyleDecl: StyleDecl = {
...styleDecl,
styleSourceId:
newLocalStyleSourceIds.get(styleSourceId) ?? styleSourceId,
breakpointId: contentMode
? breakpointId
: (mergedBreakpointIds.get(breakpointId) ?? breakpointId),
};
if (
contentMode &&
breakpoints?.has(newStyleDecl.breakpointId) === false
) {
continue;
}
styles.set(getStyleDeclKey(newStyleDecl), newStyleDecl);
}
}
};
export const collectStyleSourcesFromInstances = ({
instanceIds,
styleSourceSelections,
styleSources,
styles,
}: {
instanceIds: Set<Instance["id"]>;
styleSourceSelections: StyleSourceSelections;
styleSources: StyleSources;
styles: Styles;
}): {
styleSourceSelectionsArray: StyleSourceSelection[];
styleSourcesMap: StyleSources;
stylesArray: StyleDecl[];
} => {
const styleSourceSelectionsArray: StyleSourceSelection[] = [];
const styleSourcesMap: StyleSources = new Map();
for (const instanceId of instanceIds) {
const styleSourceSelection = styleSourceSelections.get(instanceId);
if (styleSourceSelection === undefined) {
continue;
}
styleSourceSelectionsArray.push(styleSourceSelection);
for (const styleSourceId of styleSourceSelection.values) {
if (styleSourcesMap.has(styleSourceId)) {
continue;
}
const styleSource = styleSources.get(styleSourceId);
if (styleSource !== undefined) {
styleSourcesMap.set(styleSourceId, styleSource);
}
}
}
const stylesArray: StyleDecl[] = [];
for (const styleDecl of styles.values()) {
if (styleSourcesMap.has(styleDecl.styleSourceId)) {
stylesArray.push(styleDecl);
}
}
return {
styleSourceSelectionsArray,
styleSourcesMap,
stylesArray,
};
};