postcss-merge-rules 9.0.0 → 9.0.2

package/src/lib/declarations.js

@@ -0,0 +1,146 @@
+import { isConflictingProp } from './propertyRelations.js';
+
+/** @import {Declaration} from 'postcss' */
+
+/**
+ * @param {Declaration} a
+ * @param {Declaration} b
+ * @return {boolean}
+ */
+function declarationIsEqual(a, b) {
+  return (
+    a.important === b.important && a.prop === b.prop && a.value === b.value
+  );
+}
+
+/**
+ * @param {Declaration[]} array
+ * @param {Declaration} decl
+ * @return {number}
+ */
+export function indexOfDeclaration(array, decl) {
+  return array.findIndex((d) => declarationIsEqual(d, decl));
+}
+
+/**
+ * @param {Declaration[]} a
+ * @param {Declaration[]} b
+ * @param {boolean} [not=false]
+ * @return {Declaration[]}
+ */
+export function intersect(a, b, not) {
+  return a.filter((c) => {
+    const index = indexOfDeclaration(b, c) !== -1;
+    return not ? !index : index;
+  });
+}
+
+/**
+ * @param {Declaration[]} a
+ * @param {Declaration[]} b
+ * @return {boolean}
+ */
+export function sameDeclarationsAndOrder(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  return a.every((d, index) => declarationIsEqual(d, b[index]));
+}
+
+/**
+ * @param {Declaration} candidate
+ * @param {number} candidateIndex
+ * @param {Declaration[]} hoistCandidates
+ * @param {Declaration[]} earlierRuleDeclarations
+ * @return {boolean}
+ */
+function hoistingPreservesOverrideOrder(
+  candidate,
+  candidateIndex,
+  hoistCandidates,
+  earlierRuleDeclarations
+) {
+  const indexInEarlierRule = indexOfDeclaration(
+    earlierRuleDeclarations,
+    candidate
+  );
+  const overridesInEarlierRule = earlierRuleDeclarations
+    .slice(indexInEarlierRule + 1)
+    .filter((d) => isConflictingProp(d.prop, candidate.prop));
+  if (overridesInEarlierRule.length === 0) {
+    return true;
+  }
+  const overridesAmongCandidates = hoistCandidates
+    .slice(candidateIndex + 1)
+    .filter((d) => isConflictingProp(d.prop, candidate.prop));
+  if (overridesInEarlierRule.length !== overridesAmongCandidates.length) {
+    return false;
+  }
+  return overridesInEarlierRule.every((d, index) =>
+    declarationIsEqual(d, overridesAmongCandidates[index])
+  );
+}
+
+/**
+ * @param {Declaration} candidate
+ * @param {Declaration[]} laterDeclarations
+ * @param {Set<number>} claimedIndices
+ * @return {boolean}
+ */
+function claimMatchInLaterRule(candidate, laterDeclarations, claimedIndices) {
+  const matchIndex = laterDeclarations.findIndex(
+    (d, index) =>
+      !claimedIndices.has(index) && isConflictingProp(d.prop, candidate.prop)
+  );
+  if (matchIndex === -1) {
+    return false;
+  }
+  if (!declarationIsEqual(laterDeclarations[matchIndex], candidate)) {
+    return false;
+  }
+  if (
+    candidate.prop.toLowerCase() !== 'direction' &&
+    candidate.prop.toLowerCase() !== 'unicode-bidi' &&
+    laterDeclarations.some(
+      (declaration) => declaration.prop.toLowerCase() === 'all'
+    )
+  ) {
+    return false;
+  }
+  claimedIndices.add(matchIndex);
+  return true;
+}
+
+/**
+ * @param {Declaration[]} hoistCandidates
+ * @param {Declaration[]} earlierRuleDeclarations
+ * @param {Declaration[]} laterRuleDeclarations
+ * @return {{intersection: Declaration[], claimedIndices: Set<number>}}
+ */
+export function filterRuleIntersections(
+  hoistCandidates,
+  earlierRuleDeclarations,
+  laterRuleDeclarations
+) {
+  let remainingCandidates = hoistCandidates;
+  for (;;) {
+    const claimedIndices = new Set();
+    const survivors = remainingCandidates.filter(
+      (candidate, candidateIndex) =>
+        hoistingPreservesOverrideOrder(
+          candidate,
+          candidateIndex,
+          remainingCandidates,
+          earlierRuleDeclarations
+        ) &&
+        claimMatchInLaterRule(candidate, laterRuleDeclarations, claimedIndices)
+    );
+    if (
+      survivors.length === remainingCandidates.length ||
+      survivors.length === 0
+    ) {
+      return { intersection: survivors, claimedIndices };
+    }
+    remainingCandidates = survivors;
+  }
+}

package/src/lib/rule-meta.js

@@ -0,0 +1,58 @@
+/** @import {Declaration, Rule} from 'postcss' */
+
+/**
+ * @typedef {Object} RuleMeta
+ * @property {string[]} selectors
+ * @property {Declaration[]} declarations
+ * @property {boolean} dirty
+ */
+
+/**
+ * @param {import('postcss').ChildNode} node
+ * @return {node is Declaration}
+ */
+function isDeclaration(node) {
+  return node.type === 'decl';
+}
+
+/**
+ * @param {Rule} rule
+ * @param {WeakMap<Rule, RuleMeta>} [ruleMeta]
+ * @return {RuleMeta}
+ */
+export function getMeta(rule, ruleMeta) {
+  if (ruleMeta && rule) {
+    let meta = ruleMeta.get(rule);
+    if (!meta && rule.nodes) {
+      meta = {
+        selectors: rule.selectors,
+        declarations: rule.nodes.filter(isDeclaration),
+        dirty: false,
+      };
+      ruleMeta.set(rule, meta);
+    }
+    return meta ?? { selectors: [], declarations: [], dirty: false };
+  }
+  return {
+    selectors: rule?.selectors ?? [],
+    declarations: rule?.nodes?.filter(isDeclaration) ?? [],
+    dirty: false,
+  };
+}
+
+/**
+ * @param {Rule} rule
+ * @param {WeakMap<Rule, RuleMeta>} ruleMeta
+ */
+export function flush(rule, ruleMeta) {
+  const meta = ruleMeta.get(rule);
+  if (meta && meta.dirty) {
+    rule.selector = meta.selectors.join(',');
+    meta.dirty = false;
+  }
+}
+
+/** @param {Rule} rule @return {Declaration[]} */
+export function getDecls(rule) {
+  return rule.nodes.filter(isDeclaration);
+}

package/src/lib/rule-rewrite.js

@@ -0,0 +1,170 @@
+import { intersect, indexOfDeclaration } from './declarations.js';
+import { flush, getMeta } from './rule-meta.js';
+
+/** @import {Declaration, Rule} from 'postcss' */
+
+/**
+ * @param {Rule} first
+ * @param {Rule} second
+ * @return {boolean}
+ */
+export function mergeParents(first, second) {
+  if (!first.parent || !second.parent || first.parent === second.parent) {
+    return false;
+  }
+  second.remove();
+  first.parent.append(second);
+  return true;
+}
+
+/** @param {Rule} second @return {Rule | null} */
+function getNextRule(second) {
+  let nextRule = second.next();
+  if (!nextRule) {
+    const parentSibling =
+      /** @type {import('postcss').Container | undefined} */ (
+        /** @type {import('postcss').Container<import('postcss').ChildNode>} */ (
+          second.parent
+        ).next()
+      );
+    nextRule = parentSibling && parentSibling.nodes && parentSibling.nodes[0];
+  }
+  return nextRule?.type === 'rule' ? nextRule : null;
+}
+
+/**
+ * @param {...Rule} rules
+ * @return {number}
+ */
+function ruleLength(...rules) {
+  return rules.map((r) => (r.nodes.length ? String(r) : '')).join('').length;
+}
+
+/**
+ * @param {Rule} first
+ * @param {Rule} second
+ * @param {Declaration[]} intersection
+ * @param {string[]} browsers
+ * @param {Map<string, boolean>} compatibilityCache
+ * @param {WeakSet<Rule>} ruleCache
+ * @param {WeakMap<Rule, import('./rule-meta.js').RuleMeta>} ruleMeta
+ * @param {(a: Rule, b: Rule, browsers: string[], compatibilityCache: Map<string, boolean>, ruleCache: WeakSet<Rule>, ruleMeta: WeakMap<Rule, import('./rule-meta.js').RuleMeta>) => boolean} canMerge
+ * @param {(rule: Rule, oldParent: import('postcss').Container, newParent: import('postcss').Container) => void} [onMove]
+ * @return {{first: Rule, second: Rule, intersection: Declaration[], moved: boolean}}
+ */
+export function mergeWithNextRule(
+  first,
+  second,
+  intersection,
+  browsers,
+  compatibilityCache,
+  ruleCache,
+  ruleMeta,
+  canMerge,
+  onMove
+) {
+  const nextRule = getNextRule(second);
+  if (
+    !nextRule ||
+    !canMerge(
+      second,
+      nextRule,
+      browsers,
+      compatibilityCache,
+      ruleCache,
+      ruleMeta
+    )
+  ) {
+    return { first, second, intersection, moved: false };
+  }
+  const nextIntersection = intersect(
+    getMeta(second, ruleMeta).declarations,
+    getMeta(nextRule, ruleMeta).declarations
+  );
+  if (nextIntersection.length <= intersection.length) {
+    return { first, second, intersection, moved: false };
+  }
+  const oldParent = nextRule.parent;
+  const newParent = second.parent;
+  const moved = mergeParents(second, nextRule);
+  if (moved && oldParent && newParent) onMove?.(nextRule, oldParent, newParent);
+  return {
+    first: second,
+    second: nextRule,
+    intersection: nextIntersection,
+    moved,
+  };
+}
+
+/**
+ * @param {Rule} first
+ * @param {Rule} second
+ * @param {Declaration[]} intersection
+ * @param {Set<number>} claimedIndices
+ * @param {WeakSet<Rule>} ruleCache
+ * @param {WeakMap<Rule, import('./rule-meta.js').RuleMeta>} ruleMeta
+ * @return {{rule: Rule, replacements: Rule[]}}
+ */
+export function buildMergedRule(
+  first,
+  second,
+  intersection,
+  claimedIndices,
+  ruleCache,
+  ruleMeta
+) {
+  const receivingBlock = second.clone();
+  const firstSelectors = getMeta(first, ruleMeta).selectors;
+  const secondSelectors = getMeta(second, ruleMeta).selectors;
+  receivingBlock.selector = [...firstSelectors, ...secondSelectors].join();
+  receivingBlock.nodes = [];
+  /** @type {import('postcss').Container<import('postcss').ChildNode>} */ (
+    second.parent
+  ).insertBefore(second, receivingBlock);
+  const firstClone = first.clone({ selectors: firstSelectors });
+  const secondClone = second.clone({ selectors: secondSelectors });
+  firstClone.walkDecls((decl) => {
+    if (indexOfDeclaration(intersection, decl) !== -1) {
+      decl.remove();
+      receivingBlock.append(decl);
+    }
+  });
+  let laterIndex = 0;
+  secondClone.walkDecls((decl) => {
+    if (claimedIndices.has(laterIndex++)) {
+      decl.remove();
+    }
+  });
+  flush(first, ruleMeta);
+  flush(second, ruleMeta);
+  const merged = ruleLength(firstClone, receivingBlock, secondClone);
+  const original = ruleLength(first, second);
+  if (merged < original) {
+    first.replaceWith(firstClone);
+    second.replaceWith(secondClone);
+    for (const rule of [firstClone, receivingBlock, secondClone]) {
+      if (rule.nodes.length === 0) rule.remove();
+    }
+    if (!secondClone.parent) {
+      ruleCache?.add(receivingBlock);
+      return {
+        rule: receivingBlock,
+        replacements: [firstClone, receivingBlock].filter((rule) =>
+          Boolean(rule.parent)
+        ),
+      };
+    }
+    ruleCache?.add(receivingBlock);
+    ruleCache?.add(secondClone);
+    ruleMeta?.delete(first);
+    ruleMeta?.delete(second);
+    return {
+      rule: secondClone,
+      replacements: [firstClone, receivingBlock, secondClone].filter((rule) =>
+        Boolean(rule.parent)
+      ),
+    };
+  }
+  receivingBlock.remove();
+  return { rule: second, replacements: [] };
+}

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AASI,OAAQ,KAAA,YAAY,MAAM,cAAc,CAAA;AAExC,OAAQ,KAAA,EAAC,WAAW,EAAO,MAAM,SAAS,CAAA;AAmD3C,YAAkB,QAAQ,GAC1B;;;;IAAqB,SAAS,EAAnB,MAAM,EAAE,CACnB;;;;IAA0B,YAAY,EAA3B,WAAW,EAAE,CACxB;;;;IAAoB,KAAK,EAAd,OAAO,CACpB;CAAA,CAAA;AA8lBE,YAAwD,mBAAmB,GAAjE;IAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE,CAAqB;AAC3E,YAAgE,mBAAmB,GAAzE,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC,CAAqB;AACnF,YAAqD,OAAO,GAAlD,mBAAmB,GAAG,mBAAmB,CAAS;AAH/D;;;;GAIG;AAEH;;;GAGG;AACH,iBAAS,aAAa,CAAC,IAAI,GAHhB,OAGqB,GAFpB,OAAO,SAAS,EAAE,MAAM,CAoCnC;kBAlCQ,aAAa;iBAmCX,IAAI;;AAEf,QAAA,MAAM,aAAa,sBAAgB,CAAC;AAEpC,OAAO,EAAE,aAAa,IAAI,OAAO,EAAE,aAAa,IAAI,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAoBI,OAAQ,KAAA,YAAY,MAAM,cAAc,CAAA;AAExC,OAAQ,KAAA,EAAC,WAAW,EAAO,MAAM,SAAS,CAAA;AAE3C,YAAkB,QAAQ,GAC1B;;;;IAAqB,SAAS,EAAnB,MAAM,EAAE,CACnB;;;;IAA0B,YAAY,EAA3B,WAAW,EAAE,CACxB;;;;IAAoB,KAAK,EAAd,OAAO,CACpB;CAAA,CAAA;AAoqBE,YAAwD,mBAAmB,GAAjE;IAAE,oBAAoB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE,CAAqB;AAC3E,YAAgE,mBAAmB,GAAzE,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC,CAAqB;AACnF,YAAqD,OAAO,GAAlD,mBAAmB,GAAG,mBAAmB,CAAS;AAH/D;;;;GAIG;AAEH;;;GAGG;AACH,iBAAS,aAAa,CAAC,IAAI,GAHhB,OAGqB,GAFpB,OAAO,SAAS,EAAE,MAAM,CAmCnC;kBAjCQ,aAAa;iBAkCX,IAAI;;AAEf,QAAA,MAAM,aAAa,sBAAgB,CAAC;AAEpC,OAAO,EAAE,aAAa,IAAI,OAAO,EAAE,aAAa,IAAI,gBAAgB,EAAE,CAAC"}

package/types/lib/declarations.d.ts

@@ -0,0 +1,31 @@
+import type { Declaration } from 'postcss';
+/**
+ * @param {Declaration[]} array
+ * @param {Declaration} decl
+ * @return {number}
+ */
+export declare function indexOfDeclaration(array: Declaration[], decl: Declaration): number;
+/**
+ * @param {Declaration[]} a
+ * @param {Declaration[]} b
+ * @param {boolean} [not=false]
+ * @return {Declaration[]}
+ */
+export declare function intersect(a: Declaration[], b: Declaration[], not?: boolean): Declaration[];
+/**
+ * @param {Declaration[]} a
+ * @param {Declaration[]} b
+ * @return {boolean}
+ */
+export declare function sameDeclarationsAndOrder(a: Declaration[], b: Declaration[]): boolean;
+/**
+ * @param {Declaration[]} hoistCandidates
+ * @param {Declaration[]} earlierRuleDeclarations
+ * @param {Declaration[]} laterRuleDeclarations
+ * @return {{intersection: Declaration[], claimedIndices: Set<number>}}
+ */
+export declare function filterRuleIntersections(hoistCandidates: Declaration[], earlierRuleDeclarations: Declaration[], laterRuleDeclarations: Declaration[]): {
+    intersection: Declaration[];
+    claimedIndices: Set<number>;
+};
+//# sourceMappingURL=declarations.d.ts.map

package/types/lib/declarations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declarations.d.ts","sourceRoot":"","sources":["../../src/lib/declarations.js"],"names":[],"mappings":"AAEI,OAAQ,KAAA,EAAC,WAAW,EAAC,MAAM,SAAS,CAAA;AAaxC;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAJ7B,WAAW,EAIkB,EAAE,IAAI,EAHnC,WAGmC,GAFlC,MAAM,CAIjB;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EALhB,WAAW,EAKK,EAAE,CAAC,EAJnB,WAAW,EAIQ,EAAE,GAAG,AAHhC,CACA,EADQ,OAGwB,GAFvB,WAAW,EAAE,CAOxB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAJ/B,WAAW,EAIoB,EAAE,CAAC,EAHlC,WAAW,EAGuB,GAFjC,OAAO,CAOlB;AAkED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,eAAe,EANN,WAAW,EAML,EACf,uBAAuB,EANd,WAAW,EAMG,EACvB,qBAAqB,EANZ,WAAW,EAMC,GALX;IAAC,YAAY,EAAE,WAAW,EAAE,CAAC;IAAC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAC,CA4BrE"}

package/types/lib/rule-meta.d.ts

@@ -0,0 +1,21 @@
+/** @import {Declaration, Rule} from 'postcss' */
+import type { Declaration, Rule } from 'postcss';
+export type RuleMeta = {
+    selectors: string[];
+    declarations: Declaration[];
+    dirty: boolean;
+};
+/**
+ * @param {Rule} rule
+ * @param {WeakMap<Rule, RuleMeta>} [ruleMeta]
+ * @return {RuleMeta}
+ */
+export declare function getMeta(rule: Rule, ruleMeta?: WeakMap<Rule, RuleMeta>): RuleMeta;
+/**
+ * @param {Rule} rule
+ * @param {WeakMap<Rule, RuleMeta>} ruleMeta
+ */
+export declare function flush(rule: Rule, ruleMeta: WeakMap<Rule, RuleMeta>): void;
+/** @param {Rule} rule @return {Declaration[]} */
+export declare function getDecls(rule: Rule): Declaration[];
+//# sourceMappingURL=rule-meta.d.ts.map

package/types/lib/rule-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-meta.d.ts","sourceRoot":"","sources":["../../src/lib/rule-meta.js"],"names":[],"mappings":"AAAA,iDAAiD;AAA7C,OAAQ,KAAA,EAAC,WAAW,EAAE,IAAI,EAAC,MAAM,SAAS,CAAA;AAG3C,YAAkB,QAAQ,GAC1B;IAAqB,SAAS,EAAnB,MAAM,EAAE,CACnB;IAA0B,YAAY,EAA3B,WAAW,EAAE,CACxB;IAAoB,KAAK,EAAd,OAAO,CACpB;CAAA,CAAA;AAUD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAJjB,IAIiB,EAAE,QAAQ,AAHnC,CACA,EADQ,OAAO,CAAC,IAAI,EAAE,QAAQ,CAGK,GAF1B,QAAQ,CAoBnB;AAED;;;GAGG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAHf,IAGe,EAAE,QAAQ,EAFzB,OAAO,CAAC,IAAI,EAAE,QAAQ,CAEG,QAMnC;AAED,iDAAiD;AACjD,wBAAgB,QAAQ,CAAC,IAAI,EADjB,IACiB,GADG,WAAW,EAAE,CAG5C"}

package/types/lib/rule-rewrite.d.ts

@@ -0,0 +1,40 @@
+import type { Declaration, Rule } from 'postcss';
+/** @import {Declaration, Rule} from 'postcss' */
+/**
+ * @param {Rule} first
+ * @param {Rule} second
+ * @return {boolean}
+ */
+export declare function mergeParents(first: Rule, second: Rule): boolean;
+/**
+ * @param {Rule} first
+ * @param {Rule} second
+ * @param {Declaration[]} intersection
+ * @param {string[]} browsers
+ * @param {Map<string, boolean>} compatibilityCache
+ * @param {WeakSet<Rule>} ruleCache
+ * @param {WeakMap<Rule, import('./rule-meta.js').RuleMeta>} ruleMeta
+ * @param {(a: Rule, b: Rule, browsers: string[], compatibilityCache: Map<string, boolean>, ruleCache: WeakSet<Rule>, ruleMeta: WeakMap<Rule, import('./rule-meta.js').RuleMeta>) => boolean} canMerge
+ * @param {(rule: Rule, oldParent: import('postcss').Container, newParent: import('postcss').Container) => void} [onMove]
+ * @return {{first: Rule, second: Rule, intersection: Declaration[], moved: boolean}}
+ */
+export declare function mergeWithNextRule(first: Rule, second: Rule, intersection: Declaration[], browsers: string[], compatibilityCache: Map<string, boolean>, ruleCache: WeakSet<Rule>, ruleMeta: WeakMap<Rule, import('./rule-meta.js').RuleMeta>, canMerge: (a: Rule, b: Rule, browsers: string[], compatibilityCache: Map<string, boolean>, ruleCache: WeakSet<Rule>, ruleMeta: WeakMap<Rule, import('./rule-meta.js').RuleMeta>) => boolean, onMove?: (rule: Rule, oldParent: import('postcss').Container, newParent: import('postcss').Container) => void): {
+    first: Rule;
+    second: Rule;
+    intersection: Declaration[];
+    moved: boolean;
+};
+/**
+ * @param {Rule} first
+ * @param {Rule} second
+ * @param {Declaration[]} intersection
+ * @param {Set<number>} claimedIndices
+ * @param {WeakSet<Rule>} ruleCache
+ * @param {WeakMap<Rule, import('./rule-meta.js').RuleMeta>} ruleMeta
+ * @return {{rule: Rule, replacements: Rule[]}}
+ */
+export declare function buildMergedRule(first: Rule, second: Rule, intersection: Declaration[], claimedIndices: Set<number>, ruleCache: WeakSet<Rule>, ruleMeta: WeakMap<Rule, import('./rule-meta.js').RuleMeta>): {
+    rule: Rule;
+    replacements: Rule[];
+};
+//# sourceMappingURL=rule-rewrite.d.ts.map

package/types/lib/rule-rewrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-rewrite.d.ts","sourceRoot":"","sources":["../../src/lib/rule-rewrite.js"],"names":[],"mappings":"AAGI,OAAQ,KAAA,EAAC,WAAW,EAAE,IAAI,EAAC,MAAM,SAAS,CAAA;AAA9C,iDAAiD;AAEjD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAJvB,IAIuB,EAAE,MAAM,EAH/B,IAG+B,GAF9B,OAAO,CASlB;AAyBD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAZI,IAYJ,EACL,MAAM,EAZG,IAYH,EACN,YAAY,EAZH,WAAW,EAYR,EACZ,QAAQ,EAZC,MAAM,EAYP,EACR,kBAAkB,EAZT,GAAG,CAAC,MAAM,EAAE,OAAO,CAYV,EAClB,SAAS,EAZA,OAAO,CAAC,IAAI,CAYZ,EACT,QAAQ,EAZC,OAAO,CAAC,IAAI,EAAE,OAAO,gBAAgB,EAAE,QAAQ,CAYhD,EACR,QAAQ,EAZC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,gBAAgB,EAAE,QAAQ,CAAC,KAAK,OAY3K,EACR,MAAM,AAZL,CACA,EADQ,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,SAAS,EAAE,SAAS,KAAK,IAYnG,GAXI;IAAC,KAAK,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,IAAI,CAAC;IAAC,YAAY,EAAE,WAAW,EAAE,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAC,CA4CnF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EATI,IASJ,EACL,MAAM,EATG,IASH,EACN,YAAY,EATH,WAAW,EASR,EACZ,cAAc,EATL,GAAG,CAAC,MAAM,CASL,EACd,SAAS,EATA,OAAO,CAAC,IAAI,CASZ,EACT,QAAQ,EATC,OAAO,CAAC,IAAI,EAAE,OAAO,gBAAgB,EAAE,QAAQ,CAShD,GARE;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,YAAY,EAAE,IAAI,EAAE,CAAA;CAAC,CAgE7C"}