@askviraj/linter 1.1.5 → 1.1.6

package/node_modules/@html-eslint/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@html-eslint/core",
-  "version": "0.64.0",
+  "version": "0.65.0",
   "description": "Core HTML validation logic for html-eslint",
   "author": {
     "name": "yeonjuan",
@@ -49,7 +49,7 @@
     "lint"
   ],
   "dependencies": {
-    "@html-eslint/types": "^0.64.0",
+    "@html-eslint/types": "^0.65.0",
     "html-standard": "^0.0.13"
   },
   "devDependencies": {
@@ -58,5 +58,5 @@
   "engines": {
     "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
   },
-  "gitHead": "d0babaf320a0d5c3b72f6d8c7bf49b2841a0b84f"
+  "gitHead": "9557d60cbcb4fcfb1c21e11bbe802af3e83cc1ff"
 }

package/node_modules/@html-eslint/eslint-plugin/lib/rules/no-duplicate-attrs.js

@@ -11,10 +11,16 @@
  * } from "../types"
  */
 
+const { NODE_TYPES } = require("@html-eslint/parser");
 const { RULE_CATEGORY } = require("../constants");
 const { createVisitors } = require("./utils/visitors");
 const { getRuleUrl } = require("./utils/rule");
-const { hasTemplate } = require("./utils/node");
+const {
+  getBranchSegments,
+  getControlTokenRanges,
+  isControlToken,
+  areInMutuallyExclusiveBranches,
+} = require("./utils/branch-segments");
 
 const MESSAGE_IDS = {
   DUPLICATE_ATTRS: "duplicateAttrs",
@@ -45,45 +51,163 @@ module.exports = {
   },
 
   create(context) {
+    const branchSegments = getBranchSegments(context);
+    const controlTokenRanges = getControlTokenRanges(context);
+
     /**
      * @param {Attribute} node
+     * @param {string} attrName
      * @returns {SuggestionReportDescriptor[]}
      */
-    function getSuggestions(node) {
+    function getSuggestions(node, attrName) {
       return [
         {
           messageId: MESSAGE_IDS.REMOVE_ATTR,
           fix: (fixer) => fixer.removeRange(node.range),
           data: {
-            attrName: node.key.value,
+            attrName,
           },
         },
       ];
     }
 
+    /**
+     * Determine the attribute's effective (template-stripped) name and a source
+     * position safe to use for branch-exclusivity comparison.
+     *
+     * When a template engine is configured, a template token with no separating
+     * whitespace gets glued onto the following node's text by es-html-parser —
+     * e.g. `{%if x%}data-id="1"` produces a key whose raw `.value` is `"{%if
+     * x%}data-id"`, not `"data-id"`. Using that raw value would mean the same
+     * logical attribute name never compares equal across branches, and using
+     * the whole Attribute node's `.range` for position would place it _before_
+     * the branch segment starts (since the glued token's start becomes the
+     * node's start). Both would defeat branch exclusivity detection entirely,
+     * independent of whether the source happens to have a space after the token
+     * — but real template engines (Twig included) do not require one.
+     *
+     * `attr.key.parts` splits the key into `Part` entries (real text) and
+     * `Template` entries (embedded template tokens). We reconstruct the real
+     * name from the `Part` entries and use the first `Part` entry's position
+     * for comparisons — a position that always falls inside the branch content,
+     * regardless of spacing.
+     *
+     * This is only safe when every `Template` entry glued into the key is a
+     * recognized branch-control token (`{% if %}`, `{% else %}`, `{% endif %}`,
+     * etc.) — a structural marker whose presence doesn't change the attribute
+     * name itself. If a `Template` entry is a plain value-interpolation token
+     * instead (e.g. `data-{{name}}`), the attribute name is genuinely dynamic
+     * and can't be safely compared at all, so the whole attribute is skipped,
+     * matching the rule's original conservative behavior for such cases.
+     *
+     * @param {Attribute} attr
+     * @returns {{ key: string; displayName: string; pos: number } | null}
+     */
+    function getComparable(attr) {
+      const parts = attr.key.parts || [];
+
+      if (parts.length === 0) {
+        // No template involvement in the key at all — the common case.
+        return {
+          key: attr.key.value.toLowerCase(),
+          displayName: attr.key.value,
+          pos: attr.range[0],
+        };
+      }
+
+      const partEntries = parts.filter((p) => p.type === NODE_TYPES.Part);
+      const templateEntries = parts.filter((p) => p.type !== NODE_TYPES.Part);
+
+      const allGluedTokensAreControlTokens = templateEntries.every((t) =>
+        isControlToken(t.range, controlTokenRanges)
+      );
+      if (!allGluedTokensAreControlTokens) {
+        // At least one embedded template token is a genuine value
+        // interpolation (e.g. `data-{{name}}`) rather than a structural
+        // if/else/endif marker — the name is dynamic and can't be compared.
+        return null;
+      }
+
+      if (partEntries.length === 0) {
+        // The "attribute" is entirely template syntax with no real name at
+        // all (e.g. es-html-parser exposing a bare `{% endif %}` as its own
+        // pseudo-attribute). Not a genuine attribute — nothing to compare.
+        return null;
+      }
+
+      const displayName = partEntries.map((p) => p.value).join("");
+      return {
+        key: displayName.toLowerCase(),
+        displayName,
+        pos: partEntries[0].range[0],
+      };
+    }
+
     /** @param {Tag | StyleTag | ScriptTag} node */
     function check(node) {
-      if (Array.isArray(node.attributes)) {
-        const attrsSet = new Set();
-        node.attributes.forEach((attr) => {
-          if (hasTemplate(attr.key)) {
-            return;
-          }
-          if (attrsSet.has(attr.key.value.toLowerCase())) {
+      if (!Array.isArray(node.attributes)) return;
+
+      // Maps a normalized attribute name to the list of { attr, pos } entries
+      // for that name that have NOT yet been reported as duplicates.
+      //
+      // Invariant: every pair of entries in any list is mutually exclusive
+      // (they live in different branches of the same template if-block).
+      //
+      // When a new occurrence arrives we check it against the whole stored
+      // list.  If it is exclusive with ALL of them, the invariant still holds
+      // and we add it without reporting.  If it is NOT exclusive with at least
+      // one of them, it is a genuine runtime duplicate and we report it.
+      //
+      // This list-based approach correctly handles edge cases such as:
+      //
+      //   <span {% if c1 %} class="a"{% else %} class="b"{% endif %}
+      //         {% if c1 %} class="c"{% endif %}>
+      //
+      // where class[a] and class[c] (both in the same branch) are real
+      // duplicates even though class[a]/class[b] and class[b]/class[c] are
+      // individually exclusive.
+      /** @type {Map<string, { attr: Attribute; pos: number }[]>} */
+      const attrsMap = new Map();
+
+      node.attributes.forEach((attr) => {
+        const comparable = getComparable(attr);
+        if (!comparable) return;
+        const { key, displayName, pos } = comparable;
+
+        if (attrsMap.has(key)) {
+          const prevList = /** @type {{ attr: Attribute; pos: number }[]} */ (
+            attrsMap.get(key)
+          );
+
+          // Build the candidate full list and test pairwise exclusivity,
+          // comparing positions rather than whole attribute ranges (see
+          // getComparable for why).
+          const candidate = [...prevList, { attr, pos }];
+          const nodesForCheck = candidate.map((c) => ({
+            range: /** @type {[number, number]} */ ([c.pos, c.pos]),
+          }));
+          if (areInMutuallyExclusiveBranches(nodesForCheck, branchSegments)) {
+            // All pairs (including the new attr) are branch-exclusive: no
+            // report, and add attr to the list to track further occurrences.
+            prevList.push({ attr, pos });
+          } else {
             context.report({
               node: attr,
               data: {
-                attrName: attr.key.value,
+                attrName: displayName,
               },
               messageId: MESSAGE_IDS.DUPLICATE_ATTRS,
-              suggest: getSuggestions(attr),
+              suggest: getSuggestions(attr, displayName),
             });
-          } else {
-            attrsSet.add(attr.key.value.toLowerCase());
+            // Do NOT add to prevList: a confirmed duplicate should not
+            // suppress future occurrences via the invariant.
           }
-        });
-      }
+        } else {
+          attrsMap.set(key, [{ attr, pos }]);
+        }
+      });
     }
+
     return createVisitors(context, {
       Tag: check,
       StyleTag: check,

package/node_modules/@html-eslint/eslint-plugin/lib/rules/no-duplicate-id.js

@@ -15,6 +15,10 @@ const {
 } = require("./utils/settings");
 const { getSourceCode } = require("./utils/source-code");
 const { getRuleUrl } = require("./utils/rule");
+const {
+  getBranchSegments,
+  areInMutuallyExclusiveBranches,
+} = require("./utils/branch-segments");
 
 const MESSAGE_IDS = {
   DUPLICATE_ID: "duplicateId",
@@ -40,7 +44,13 @@ module.exports = {
   },
 
   create(context) {
+    // Read branch segments once per file.  For non-HTML files (JS tagged
+    // template literal paths) this will be [] and the check degrades
+    // gracefully to the original behavior.
+    const branchSegments = getBranchSegments(context);
+
     const htmlIdAttrsMap = new Map();
+
     /** @param {Map<string, AttributeValue[]>} map */
     function createTagVisitor(map) {
       /** @param {Tag} node */
@@ -61,10 +71,19 @@ module.exports = {
       };
     }
 
-    /** @param {Map<string, AttributeValue[]>} map */
-    function report(map) {
+    /**
+     * @param {Map<string, AttributeValue[]>} map
+     * @param {typeof branchSegments} segments
+     */
+    function report(map, segments) {
       map.forEach((attrs) => {
         if (Array.isArray(attrs) && attrs.length > 1) {
+          // If every occurrence lives in a different branch of the same
+          // template if-block they are mutually exclusive at runtime — the
+          // same id can never appear twice in the rendered output.
+          if (areInMutuallyExclusiveBranches(attrs, segments)) {
+            return;
+          }
           attrs.forEach((attr) => {
             context.report({
               node: attr,
@@ -79,7 +98,7 @@ module.exports = {
     return {
       Tag: createTagVisitor(htmlIdAttrsMap),
       "Document:exit"() {
-        report(htmlIdAttrsMap);
+        report(htmlIdAttrsMap, branchSegments);
       },
       TaggedTemplateExpression(node) {
         const idAttrsMap = new Map();
@@ -88,7 +107,7 @@ module.exports = {
             Tag: createTagVisitor(idAttrsMap),
           });
         }
-        report(idAttrsMap);
+        report(idAttrsMap, branchSegments);
       },
       TemplateLiteral(node) {
         const idAttrsMap = new Map();
@@ -97,7 +116,7 @@ module.exports = {
             Tag: createTagVisitor(idAttrsMap),
           });
         }
-        report(idAttrsMap);
+        report(idAttrsMap, branchSegments);
       },
     };
   },

package/node_modules/@html-eslint/eslint-plugin/lib/rules/no-duplicate-in-head.js

@@ -12,6 +12,10 @@ const {
 } = require("./utils/settings");
 const { getSourceCode } = require("./utils/source-code");
 const { getRuleUrl } = require("./utils/rule");
+const {
+  getBranchSegments,
+  areInMutuallyExclusiveBranches,
+} = require("./utils/branch-segments");
 
 const MESSAGE_IDS = {
   DUPLICATE_TAG: "duplicateTag",
@@ -72,6 +76,8 @@ module.exports = {
   },
 
   create(context) {
+    const branchSegments = getBranchSegments(context);
+
     const htmlTagsMap = new Map();
     let headCount = 0;
 
@@ -124,10 +130,16 @@ module.exports = {
       };
     }
 
-    /** @param {Map<string, Tag[]>} map */
-    function report(map) {
+    /**
+     * @param {Map<string, Tag[]>} map
+     * @param {typeof branchSegments} segments
+     */
+    function report(map, segments) {
       map.forEach((tags, tagKey) => {
         if (Array.isArray(tags) && tags.length > 1) {
+          if (areInMutuallyExclusiveBranches(tags, segments)) {
+            return;
+          }
           tags.slice(1).forEach((tag) => {
             context.report({
               node: tag,
@@ -146,7 +158,7 @@ module.exports = {
       "Tag:exit": htmlVisitor["Tag:exit"],
 
       "Document:exit"() {
-        report(htmlTagsMap);
+        report(htmlTagsMap, branchSegments);
       },
 
       TaggedTemplateExpression(node) {
@@ -156,7 +168,7 @@ module.exports = {
         if (shouldCheckTaggedTemplateExpression(node, context)) {
           const visitor = createTagVisitor(tagsMap, headCountRef);
           parseTemplateLiteral(node.quasi, getSourceCode(context), visitor);
-          report(tagsMap);
+          report(tagsMap, branchSegments);
         }
       },
 
@@ -167,7 +179,7 @@ module.exports = {
         if (shouldCheckTemplateLiteral(node, context)) {
           const visitor = createTagVisitor(tagsMap, headCountRef);
           parseTemplateLiteral(node, getSourceCode(context), visitor);
-          report(tagsMap);
+          report(tagsMap, branchSegments);
         }
       },
     };

package/node_modules/@html-eslint/eslint-plugin/lib/rules/utils/branch-segments.js

@@ -0,0 +1,147 @@
+/**
+ * Rule-side helpers for branch-based duplicate suppression.
+ *
+ * The parser attaches a `branchSegments` array to the root Program node during
+ * its branch-annotation pass (see packages/parser/lib/branch-annotation.js and
+ * packages/parser/lib/parser.js).
+ *
+ * Each segment is: { groupId: number; branchIndex: number; start: number; end:
+ * number }
+ *
+ * All segments that share the same `groupId` belong to one {% if %} block.
+ * `branchIndex` is 0 for the if-body, 1 for the first elseif/else, etc. `start`
+ * / `end` are character offsets into the original source (same coordinate space
+ * as AST node `range` values).
+ *
+ * A set of nodes is "mutually exclusive" when, for every pair (A, B), there
+ * exists at least one if-block group where both A and B fall inside it but in
+ * _different_ branches. When every pair is exclusive the nodes can never all be
+ * present in the rendered output simultaneously, so "duplicate" rules should
+ * suppress their report.
+ */
+
+/** @import {Context} from "../../types" */
+
+const { getSourceCode } = require("./source-code");
+
+/**
+ * Retrieve the pre-computed branch segments from the AST root. Returns an empty
+ * array for non-HTML files or files parsed without a template engine syntax
+ * configuration.
+ *
+ * `branchSegments` is attached dynamically to the Program node by
+ * packages/parser/lib/parser.js and is not part of the standard typed Program
+ * definition, so ast is cast to `any` to access it.
+ *
+ * @param {Context<any[]>} context
+ * @returns {{
+ *   groupId: number;
+ *   branchIndex: number;
+ *   start: number;
+ *   end: number;
+ * }[]}
+ */
+function getBranchSegments(context) {
+  const { ast } = /** @type {{ ast: any }} */ (getSourceCode(context));
+  return (ast && ast.branchSegments) || [];
+}
+
+/**
+ * Retrieve the pre-computed branch-control token ranges from the AST root. Each
+ * range is the [start, end] span of a template token that was classified as a
+ * branch-control token (an `{% if %}`, `{% else %}`, `{% endif %}`, or similar
+ * structural marker) as opposed to a plain value-interpolation token (e.g. `{{
+ * name }}`).
+ *
+ * Rules use this to safely strip a branch-control token that ends up glued onto
+ * the text of a following node (e.g. an attribute key) with no separating
+ * whitespace, while continuing to treat a glued _interpolation_ token
+ * conservatively (the name is genuinely dynamic and can't be compared).
+ *
+ * @param {Context<any[]>} context
+ * @returns {[number, number][]}
+ */
+function getControlTokenRanges(context) {
+  const { ast } = /** @type {{ ast: any }} */ (getSourceCode(context));
+  return (ast && ast.branchControlRanges) || [];
+}
+
+/**
+ * @param {[number, number]} range
+ * @param {[number, number][]} controlTokenRanges
+ * @returns {boolean}
+ */
+function isControlToken(range, controlTokenRanges) {
+  return controlTokenRanges.some(
+    ([start, end]) => start === range[0] && end === range[1]
+  );
+}
+
+/**
+ * Return true when every pair of nodes in `nodes` is located in different
+ * branches of the same template if-block, meaning they can never all be present
+ * in the rendered output at the same time.
+ *
+ * Each element of `nodes` must have a `.range` property ([start, end]).
+ *
+ * @param {{ range: [number, number] }[]} nodes
+ * @param {{
+ *   groupId: number;
+ *   branchIndex: number;
+ *   start: number;
+ *   end: number;
+ * }[]} branchSegments
+ * @returns {boolean}
+ */
+function areInMutuallyExclusiveBranches(nodes, branchSegments) {
+  if (nodes.length <= 1) return false;
+  if (!branchSegments || branchSegments.length === 0) return false;
+
+  // Group segments by their if-block groupId so we can query one block at a time.
+  /** @type {Map<number, typeof branchSegments>} */
+  const groups = new Map();
+  for (const seg of branchSegments) {
+    let list = groups.get(seg.groupId);
+    if (!list) {
+      list = [];
+      groups.set(seg.groupId, list);
+    }
+    list.push(seg);
+  }
+
+  // For every pair (i, j), verify that at least one if-block group places
+  // the two nodes in different branches.  If any pair has no such group, the
+  // nodes are NOT all mutually exclusive and we must not suppress the report.
+  for (let i = 0; i < nodes.length; i++) {
+    for (let j = i + 1; j < nodes.length; j++) {
+      const posA = nodes[i].range[0];
+      const posB = nodes[j].range[0];
+      let foundExclusiveGroup = false;
+
+      for (const segments of groups.values()) {
+        let branchA = -1;
+        let branchB = -1;
+        for (const seg of segments) {
+          if (posA >= seg.start && posA < seg.end) branchA = seg.branchIndex;
+          if (posB >= seg.start && posB < seg.end) branchB = seg.branchIndex;
+        }
+        // Both nodes must be *inside* this group's branches, but in different ones.
+        if (branchA !== -1 && branchB !== -1 && branchA !== branchB) {
+          foundExclusiveGroup = true;
+          break;
+        }
+      }
+
+      if (!foundExclusiveGroup) return false;
+    }
+  }
+
+  return true;
+}
+
+module.exports = {
+  getBranchSegments,
+  getControlTokenRanges,
+  isControlToken,
+  areInMutuallyExclusiveBranches,
+};

package/node_modules/@html-eslint/eslint-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@html-eslint/eslint-plugin",
-  "version": "0.64.0",
+  "version": "0.65.0",
   "type": "commonjs",
   "description": "ESLint plugin for HTML",
   "author": {
@@ -43,11 +43,11 @@
   ],
   "dependencies": {
     "@eslint/plugin-kit": "^0.4.1",
-    "@html-eslint/core": "^0.64.0",
-    "@html-eslint/parser": "^0.64.0",
-    "@html-eslint/template-parser": "^0.64.0",
-    "@html-eslint/template-syntax-parser": "^0.64.0",
-    "@html-eslint/types": "^0.64.0",
+    "@html-eslint/core": "^0.65.0",
+    "@html-eslint/parser": "^0.65.0",
+    "@html-eslint/template-parser": "^0.65.0",
+    "@html-eslint/template-syntax-parser": "^0.65.0",
+    "@html-eslint/types": "^0.65.0",
     "@rviscomi/capo.js": "^2.1.0",
     "html-standard": "^0.0.13"
   },
@@ -64,5 +64,5 @@
   "engines": {
     "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
   },
-  "gitHead": "d0babaf320a0d5c3b72f6d8c7bf49b2841a0b84f"
+  "gitHead": "9557d60cbcb4fcfb1c21e11bbe802af3e83cc1ff"
 }

package/node_modules/@html-eslint/eslint-plugin/types/rules/no-duplicate-attrs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-duplicate-attrs.d.ts","sourceRoot":"","sources":["../../lib/rules/no-duplicate-attrs.js"],"names":[],"mappings":"wBAuBW,WAAW,EAAE,CAAC;;gCAbf,UAAU"}
+{"version":3,"file":"no-duplicate-attrs.d.ts","sourceRoot":"","sources":["../../lib/rules/no-duplicate-attrs.js"],"names":[],"mappings":"wBA6BW,WAAW,EAAE,CAAC;;gCAnBf,UAAU"}

package/node_modules/@html-eslint/eslint-plugin/types/rules/no-duplicate-id.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-duplicate-id.d.ts","sourceRoot":"","sources":["../../lib/rules/no-duplicate-id.js"],"names":[],"mappings":"wBAsBW,WAAW,EAAE,CAAC;;gCAjBI,UAAU"}
+{"version":3,"file":"no-duplicate-id.d.ts","sourceRoot":"","sources":["../../lib/rules/no-duplicate-id.js"],"names":[],"mappings":"wBA0BW,WAAW,EAAE,CAAC;;gCArBI,UAAU"}

package/node_modules/@html-eslint/eslint-plugin/types/rules/no-duplicate-in-head.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-duplicate-in-head.d.ts","sourceRoot":"","sources":["../../lib/rules/no-duplicate-in-head.js"],"names":[],"mappings":"wBAwDW,WAAW,EAAE,CAAC;;gCAtDI,UAAU"}
+{"version":3,"file":"no-duplicate-in-head.d.ts","sourceRoot":"","sources":["../../lib/rules/no-duplicate-in-head.js"],"names":[],"mappings":"wBA4DW,WAAW,EAAE,CAAC;;gCA1DI,UAAU"}

package/node_modules/@html-eslint/eslint-plugin/types/rules/utils/branch-segments.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Retrieve the pre-computed branch segments from the AST root. Returns an empty
+ * array for non-HTML files or files parsed without a template engine syntax
+ * configuration.
+ *
+ * `branchSegments` is attached dynamically to the Program node by
+ * packages/parser/lib/parser.js and is not part of the standard typed Program
+ * definition, so ast is cast to `any` to access it.
+ *
+ * @param {Context<any[]>} context
+ * @returns {{
+ *   groupId: number;
+ *   branchIndex: number;
+ *   start: number;
+ *   end: number;
+ * }[]}
+ */
+export function getBranchSegments(context: Context<any[]>): {
+    groupId: number;
+    branchIndex: number;
+    start: number;
+    end: number;
+}[];
+/**
+ * Retrieve the pre-computed branch-control token ranges from the AST root. Each
+ * range is the [start, end] span of a template token that was classified as a
+ * branch-control token (an `{% if %}`, `{% else %}`, `{% endif %}`, or similar
+ * structural marker) as opposed to a plain value-interpolation token (e.g. `{{
+ * name }}`).
+ *
+ * Rules use this to safely strip a branch-control token that ends up glued onto
+ * the text of a following node (e.g. an attribute key) with no separating
+ * whitespace, while continuing to treat a glued _interpolation_ token
+ * conservatively (the name is genuinely dynamic and can't be compared).
+ *
+ * @param {Context<any[]>} context
+ * @returns {[number, number][]}
+ */
+export function getControlTokenRanges(context: Context<any[]>): [number, number][];
+/**
+ * @param {[number, number]} range
+ * @param {[number, number][]} controlTokenRanges
+ * @returns {boolean}
+ */
+export function isControlToken(range: [number, number], controlTokenRanges: [number, number][]): boolean;
+/**
+ * Return true when every pair of nodes in `nodes` is located in different
+ * branches of the same template if-block, meaning they can never all be present
+ * in the rendered output at the same time.
+ *
+ * Each element of `nodes` must have a `.range` property ([start, end]).
+ *
+ * @param {{ range: [number, number] }[]} nodes
+ * @param {{
+ *   groupId: number;
+ *   branchIndex: number;
+ *   start: number;
+ *   end: number;
+ * }[]} branchSegments
+ * @returns {boolean}
+ */
+export function areInMutuallyExclusiveBranches(nodes: {
+    range: [number, number];
+}[], branchSegments: {
+    groupId: number;
+    branchIndex: number;
+    start: number;
+    end: number;
+}[]): boolean;
+import type { Context } from "../../types";
+//# sourceMappingURL=branch-segments.d.ts.map

package/node_modules/@html-eslint/eslint-plugin/types/rules/utils/branch-segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-segments.d.ts","sourceRoot":"","sources":["../../../lib/rules/utils/branch-segments.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;GAgBG;AACH,2CARW,QAAQ,GAAG,EAAE,CAAC,GACZ;IACR,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb,EAAE,CAKL;AAED;;;;;;;;;;;;;;GAcG;AACH,+CAHW,QAAQ,GAAG,EAAE,CAAC,GACZ,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAK9B;AAED;;;;GAIG;AACH,sCAJW,CAAC,MAAM,EAAE,MAAM,CAAC,sBAChB,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAChB,OAAO,CAMnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,sDATW;IAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,EAAE,kBAC7B;IACN,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb,EAAE,GACO,OAAO,CA8CnB;6BArH0B,aAAa"}