@sdk-it/core 0.30.0 → 0.31.1

package/dist/lib/program.test.js

@@ -1,289 +0,0 @@
-import { strict as assert } from "node:assert";
-import { describe, it } from "node:test";
-import ts from "typescript";
-import { isInterfaceType } from "./program.ts";
-describe("isInterfaceType Helper Function - Error-First Testing", () => {
-  describe("Error Cases and Invalid Inputs", () => {
-    it("throws TypeError when type.symbol is undefined", () => {
-      const mockType = {
-        isClassOrInterface: () => true,
-        symbol: void 0
-      };
-      assert.throws(
-        () => {
-          isInterfaceType(mockType);
-        },
-        TypeError,
-        "Should throw TypeError when accessing flags on undefined symbol"
-      );
-    });
-    it("throws TypeError when type.symbol is null", () => {
-      const mockType = {
-        isClassOrInterface: () => true,
-        symbol: null
-      };
-      assert.throws(
-        () => {
-          isInterfaceType(mockType);
-        },
-        TypeError,
-        "Should throw TypeError when accessing flags on null symbol"
-      );
-    });
-    it("handles malformed type object missing isClassOrInterface method", () => {
-      const mockType = {
-        // Missing isClassOrInterface method
-        symbol: {
-          flags: ts.SymbolFlags.Interface
-        }
-      };
-      assert.throws(
-        () => {
-          isInterfaceType(mockType);
-        },
-        TypeError,
-        "Should throw when isClassOrInterface is not a function"
-      );
-    });
-    it("handles type with symbol missing flags property", () => {
-      const mockType = {
-        isClassOrInterface: () => true,
-        symbol: {}
-        // Missing flags property
-      };
-      const result = isInterfaceType(mockType);
-      assert.strictEqual(
-        result,
-        false,
-        "Should return false when flags property is missing"
-      );
-    });
-    it("handles type with symbol having non-numeric flags", () => {
-      const mockType = {
-        isClassOrInterface: () => true,
-        symbol: {
-          flags: "invalid"
-        }
-      };
-      const result = isInterfaceType(mockType);
-      assert.strictEqual(
-        result,
-        false,
-        "Should return false when flags is not a number"
-      );
-    });
-  });
-  describe("System Invariants", () => {
-    it("INVARIANT: Interface flag must be present for true result", () => {
-      const interfaceType = {
-        isClassOrInterface: () => true,
-        symbol: {
-          flags: ts.SymbolFlags.Interface
-        }
-      };
-      const result = isInterfaceType(interfaceType);
-      assert.strictEqual(
-        result,
-        true,
-        "INVARIANT VIOLATED: Interface flag present but function returned false"
-      );
-    });
-    it("INVARIANT: Non-interface flags must result in false", () => {
-      const nonInterfaceFlags = [
-        ts.SymbolFlags.Class,
-        ts.SymbolFlags.Function,
-        ts.SymbolFlags.Variable,
-        ts.SymbolFlags.Property,
-        ts.SymbolFlags.Enum,
-        ts.SymbolFlags.Module,
-        ts.SymbolFlags.Namespace
-        // Removed TypeAliasExcludes which seems to have the Interface bit
-      ];
-      nonInterfaceFlags.forEach((flag) => {
-        const mockType = {
-          isClassOrInterface: () => true,
-          symbol: {
-            flags: flag
-          }
-        };
-        const result = isInterfaceType(mockType);
-        assert.strictEqual(
-          result,
-          false,
-          `INVARIANT VIOLATED: Non-interface flag ${ts.SymbolFlags[flag]} (${flag}) returned true`
-        );
-      });
-    });
-    it("INVARIANT: isClassOrInterface() false must always result in false", () => {
-      const mockType = {
-        isClassOrInterface: () => false,
-        symbol: {
-          flags: ts.SymbolFlags.Interface
-        }
-      };
-      const result = isInterfaceType(mockType);
-      assert.strictEqual(
-        result,
-        false,
-        "INVARIANT VIOLATED: isClassOrInterface() false should always result in false"
-      );
-    });
-  });
-  describe("Complex Flag Combinations", () => {
-    it("correctly handles combined flags including Interface", () => {
-      const combinedFlags = [
-        ts.SymbolFlags.Interface | ts.SymbolFlags.Type,
-        ts.SymbolFlags.Interface | ts.SymbolFlags.Alias,
-        ts.SymbolFlags.Interface | ts.SymbolFlags.Class,
-        // Edge case
-        ts.SymbolFlags.Interface | ts.SymbolFlags.Function
-      ];
-      combinedFlags.forEach((flags, index) => {
-        const mockType = {
-          isClassOrInterface: () => true,
-          symbol: { flags }
-        };
-        const result = isInterfaceType(mockType);
-        assert.strictEqual(
-          result,
-          true,
-          `Combined flags case ${index + 1}: Interface flag present, should return true`
-        );
-      });
-    });
-    it("correctly handles combined flags excluding Interface", () => {
-      const combinedFlagsNoInterface = [
-        ts.SymbolFlags.Function | ts.SymbolFlags.Variable,
-        ts.SymbolFlags.Enum | ts.SymbolFlags.Module
-        // Removed Class | Type which seems to include the Interface bit
-      ];
-      combinedFlagsNoInterface.forEach((flags, index) => {
-        if ((flags & ts.SymbolFlags.Interface) !== 0) {
-          return;
-        }
-        const mockType = {
-          isClassOrInterface: () => true,
-          symbol: { flags }
-        };
-        const result = isInterfaceType(mockType);
-        assert.strictEqual(
-          result,
-          false,
-          `Combined flags case ${index + 1}: No Interface flag, should return false`
-        );
-      });
-    });
-    it("handles edge case with maximum flag value", () => {
-      const mockType = {
-        isClassOrInterface: () => true,
-        symbol: {
-          flags: Number.MAX_SAFE_INTEGER
-        }
-      };
-      const hasInterfaceFlag = (Number.MAX_SAFE_INTEGER & ts.SymbolFlags.Interface) !== 0;
-      const result = isInterfaceType(mockType);
-      assert.strictEqual(
-        result,
-        hasInterfaceFlag,
-        "Edge case with maximum flag value should follow bitwise logic"
-      );
-    });
-    it("handles zero flags correctly", () => {
-      const mockType = {
-        isClassOrInterface: () => true,
-        symbol: {
-          flags: 0
-        }
-      };
-      const result = isInterfaceType(mockType);
-      assert.strictEqual(result, false, "Zero flags should result in false");
-    });
-  });
-  describe("Boundary Conditions", () => {
-    it("tests exact Interface flag value", () => {
-      const mockType = {
-        isClassOrInterface: () => true,
-        symbol: {
-          flags: ts.SymbolFlags.Interface
-        }
-      };
-      const result = isInterfaceType(mockType);
-      assert.strictEqual(
-        result,
-        true,
-        "Exact Interface flag should return true"
-      );
-    });
-    it("tests Interface flag minus one", () => {
-      const mockType = {
-        isClassOrInterface: () => true,
-        symbol: {
-          flags: ts.SymbolFlags.Interface - 1
-        }
-      };
-      const result = isInterfaceType(mockType);
-      assert.strictEqual(
-        result,
-        false,
-        "Interface flag minus one should not match"
-      );
-    });
-    it("tests Interface flag plus one", () => {
-      const flagValue = ts.SymbolFlags.Interface + 1;
-      const mockType = {
-        isClassOrInterface: () => true,
-        symbol: {
-          flags: flagValue
-        }
-      };
-      const hasInterfaceFlag = (flagValue & ts.SymbolFlags.Interface) !== 0;
-      const result = isInterfaceType(mockType);
-      assert.strictEqual(
-        result,
-        hasInterfaceFlag,
-        "Interface flag plus one should follow bitwise logic"
-      );
-    });
-  });
-  describe("Happy Path Scenarios", () => {
-    it("correctly identifies interface types", () => {
-      const mockType = {
-        isClassOrInterface: () => true,
-        symbol: {
-          flags: ts.SymbolFlags.Interface
-        }
-      };
-      const result = isInterfaceType(mockType);
-      assert.strictEqual(
-        result,
-        true,
-        "Should correctly identify interface types"
-      );
-    });
-    it("correctly rejects class types", () => {
-      const mockType = {
-        isClassOrInterface: () => true,
-        symbol: {
-          flags: ts.SymbolFlags.Class
-        }
-      };
-      const result = isInterfaceType(mockType);
-      assert.strictEqual(result, false, "Should correctly reject class types");
-    });
-    it("correctly rejects primitive types", () => {
-      const mockType = {
-        isClassOrInterface: () => false,
-        symbol: {
-          flags: ts.SymbolFlags.None
-        }
-      };
-      const result = isInterfaceType(mockType);
-      assert.strictEqual(
-        result,
-        false,
-        "Should correctly reject primitive types"
-      );
-    });
-  });
-});
-//# sourceMappingURL=program.test.js.map

package/dist/lib/program.test.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/lib/program.test.ts"],
-  "sourcesContent": ["import { strict as assert } from 'node:assert';\nimport { describe, it } from 'node:test';\nimport ts from 'typescript';\n\nimport { isInterfaceType } from './program.ts';\n\ndescribe('isInterfaceType Helper Function - Error-First Testing', () => {\n  // Phase 1: Error-First Testing - Attack Before You Defend\n  describe('Error Cases and Invalid Inputs', () => {\n    it('throws TypeError when type.symbol is undefined', () => {\n      const mockType = {\n        isClassOrInterface: () => true,\n        symbol: undefined,\n      } as unknown as ts.Type;\n\n      assert.throws(\n        () => {\n          isInterfaceType(mockType);\n        },\n        TypeError,\n        'Should throw TypeError when accessing flags on undefined symbol',\n      );\n    });\n\n    it('throws TypeError when type.symbol is null', () => {\n      const mockType = {\n        isClassOrInterface: () => true,\n        symbol: null,\n      } as unknown as ts.Type;\n\n      assert.throws(\n        () => {\n          isInterfaceType(mockType);\n        },\n        TypeError,\n        'Should throw TypeError when accessing flags on null symbol',\n      );\n    });\n\n    it('handles malformed type object missing isClassOrInterface method', () => {\n      const mockType = {\n        // Missing isClassOrInterface method\n        symbol: {\n          flags: ts.SymbolFlags.Interface,\n        },\n      } as unknown as ts.Type;\n\n      assert.throws(\n        () => {\n          isInterfaceType(mockType);\n        },\n        TypeError,\n        'Should throw when isClassOrInterface is not a function',\n      );\n    });\n\n    it('handles type with symbol missing flags property', () => {\n      const mockType = {\n        isClassOrInterface: () => true,\n        symbol: {}, // Missing flags property\n      } as unknown as ts.Type;\n\n      // Should default to falsy flags (undefined & Interface === 0)\n      const result = isInterfaceType(mockType);\n      assert.strictEqual(\n        result,\n        false,\n        'Should return false when flags property is missing',\n      );\n    });\n\n    it('handles type with symbol having non-numeric flags', () => {\n      const mockType = {\n        isClassOrInterface: () => true,\n        symbol: {\n          flags: 'invalid' as unknown,\n        },\n      } as unknown as ts.Type;\n\n      // Bitwise AND with string should result in 0 (falsy)\n      const result = isInterfaceType(mockType);\n      assert.strictEqual(\n        result,\n        false,\n        'Should return false when flags is not a number',\n      );\n    });\n  });\n\n  // Phase 2: System Invariants Testing\n  describe('System Invariants', () => {\n    it('INVARIANT: Interface flag must be present for true result', () => {\n      // Test that ONLY when Interface flag is present, result is true\n      const interfaceType = {\n        isClassOrInterface: () => true,\n        symbol: {\n          flags: ts.SymbolFlags.Interface,\n        },\n      } as unknown as ts.Type;\n\n      const result = isInterfaceType(interfaceType);\n      assert.strictEqual(\n        result,\n        true,\n        'INVARIANT VIOLATED: Interface flag present but function returned false',\n      );\n    });\n\n    it('INVARIANT: Non-interface flags must result in false', () => {\n      // Select a set of flags that are clearly not interface flags\n      const nonInterfaceFlags = [\n        ts.SymbolFlags.Class,\n        ts.SymbolFlags.Function,\n        ts.SymbolFlags.Variable,\n        ts.SymbolFlags.Property,\n        ts.SymbolFlags.Enum,\n        ts.SymbolFlags.Module,\n        ts.SymbolFlags.Namespace,\n        // Removed TypeAliasExcludes which seems to have the Interface bit\n      ];\n\n      nonInterfaceFlags.forEach((flag) => {\n        const mockType = {\n          isClassOrInterface: () => true,\n          symbol: {\n            flags: flag,\n          },\n        } as unknown as ts.Type;\n\n        const result = isInterfaceType(mockType);\n        assert.strictEqual(\n          result,\n          false,\n          `INVARIANT VIOLATED: Non-interface flag ${ts.SymbolFlags[flag]} (${flag}) returned true`,\n        );\n      });\n    });\n\n    it('INVARIANT: isClassOrInterface() false must always result in false', () => {\n      // Even with Interface flag, if isClassOrInterface is false, result must be false\n      const mockType = {\n        isClassOrInterface: () => false,\n        symbol: {\n          flags: ts.SymbolFlags.Interface,\n        },\n      } as unknown as ts.Type;\n\n      const result = isInterfaceType(mockType);\n      assert.strictEqual(\n        result,\n        false,\n        'INVARIANT VIOLATED: isClassOrInterface() false should always result in false',\n      );\n    });\n  });\n\n  // Phase 3: State Transitions and Complex Scenarios\n  describe('Complex Flag Combinations', () => {\n    it('correctly handles combined flags including Interface', () => {\n      const combinedFlags = [\n        ts.SymbolFlags.Interface | ts.SymbolFlags.Type,\n        ts.SymbolFlags.Interface | ts.SymbolFlags.Alias,\n        ts.SymbolFlags.Interface | ts.SymbolFlags.Class, // Edge case\n        ts.SymbolFlags.Interface | ts.SymbolFlags.Function,\n      ];\n\n      combinedFlags.forEach((flags, index) => {\n        const mockType = {\n          isClassOrInterface: () => true,\n          symbol: { flags },\n        } as unknown as ts.Type;\n\n        const result = isInterfaceType(mockType);\n        assert.strictEqual(\n          result,\n          true,\n          `Combined flags case ${index + 1}: Interface flag present, should return true`,\n        );\n      });\n    });\n\n    it('correctly handles combined flags excluding Interface', () => {\n      const combinedFlagsNoInterface = [\n        ts.SymbolFlags.Function | ts.SymbolFlags.Variable,\n        ts.SymbolFlags.Enum | ts.SymbolFlags.Module,\n        // Removed Class | Type which seems to include the Interface bit\n      ];\n\n      combinedFlagsNoInterface.forEach((flags, index) => {\n        // Explicitly check that the flags don't include the Interface bit\n        if ((flags & ts.SymbolFlags.Interface) !== 0) {\n          // Skip this test case if it includes the Interface bit\n          return;\n        }\n\n        const mockType = {\n          isClassOrInterface: () => true,\n          symbol: { flags },\n        } as unknown as ts.Type;\n\n        const result = isInterfaceType(mockType);\n        assert.strictEqual(\n          result,\n          false,\n          `Combined flags case ${index + 1}: No Interface flag, should return false`,\n        );\n      });\n    });\n\n    it('handles edge case with maximum flag value', () => {\n      const mockType = {\n        isClassOrInterface: () => true,\n        symbol: {\n          flags: Number.MAX_SAFE_INTEGER,\n        },\n      } as unknown as ts.Type;\n\n      // If Interface flag bit is set in MAX_SAFE_INTEGER, result should be true\n      const hasInterfaceFlag =\n        (Number.MAX_SAFE_INTEGER & ts.SymbolFlags.Interface) !== 0;\n      const result = isInterfaceType(mockType);\n      assert.strictEqual(\n        result,\n        hasInterfaceFlag,\n        'Edge case with maximum flag value should follow bitwise logic',\n      );\n    });\n\n    it('handles zero flags correctly', () => {\n      const mockType = {\n        isClassOrInterface: () => true,\n        symbol: {\n          flags: 0,\n        },\n      } as unknown as ts.Type;\n\n      const result = isInterfaceType(mockType);\n      assert.strictEqual(result, false, 'Zero flags should result in false');\n    });\n  });\n\n  // Phase 4: Boundary Testing\n  describe('Boundary Conditions', () => {\n    it('tests exact Interface flag value', () => {\n      const mockType = {\n        isClassOrInterface: () => true,\n        symbol: {\n          flags: ts.SymbolFlags.Interface,\n        },\n      } as unknown as ts.Type;\n\n      const result = isInterfaceType(mockType);\n      assert.strictEqual(\n        result,\n        true,\n        'Exact Interface flag should return true',\n      );\n    });\n\n    it('tests Interface flag minus one', () => {\n      const mockType = {\n        isClassOrInterface: () => true,\n        symbol: {\n          flags: ts.SymbolFlags.Interface - 1,\n        },\n      } as unknown as ts.Type;\n\n      const result = isInterfaceType(mockType);\n      assert.strictEqual(\n        result,\n        false,\n        'Interface flag minus one should not match',\n      );\n    });\n\n    it('tests Interface flag plus one', () => {\n      const flagValue = ts.SymbolFlags.Interface + 1;\n      const mockType = {\n        isClassOrInterface: () => true,\n        symbol: {\n          flags: flagValue,\n        },\n      } as unknown as ts.Type;\n\n      // Depends on whether the +1 creates a different valid flag\n      const hasInterfaceFlag = (flagValue & ts.SymbolFlags.Interface) !== 0;\n      const result = isInterfaceType(mockType);\n      assert.strictEqual(\n        result,\n        hasInterfaceFlag,\n        'Interface flag plus one should follow bitwise logic',\n      );\n    });\n  });\n\n  // Phase 5: Happy Path Tests (Last)\n  describe('Happy Path Scenarios', () => {\n    it('correctly identifies interface types', () => {\n      const mockType = {\n        isClassOrInterface: () => true,\n        symbol: {\n          flags: ts.SymbolFlags.Interface,\n        },\n      } as unknown as ts.Type;\n\n      const result = isInterfaceType(mockType);\n      assert.strictEqual(\n        result,\n        true,\n        'Should correctly identify interface types',\n      );\n    });\n\n    it('correctly rejects class types', () => {\n      const mockType = {\n        isClassOrInterface: () => true,\n        symbol: {\n          flags: ts.SymbolFlags.Class,\n        },\n      } as unknown as ts.Type;\n\n      const result = isInterfaceType(mockType);\n      assert.strictEqual(result, false, 'Should correctly reject class types');\n    });\n\n    it('correctly rejects primitive types', () => {\n      const mockType = {\n        isClassOrInterface: () => false,\n        symbol: {\n          flags: ts.SymbolFlags.None,\n        },\n      } as unknown as ts.Type;\n\n      const result = isInterfaceType(mockType);\n      assert.strictEqual(\n        result,\n        false,\n        'Should correctly reject primitive types',\n      );\n    });\n  });\n});\n"],
-  "mappings": "AAAA,SAAS,UAAU,cAAc;AACjC,SAAS,UAAU,UAAU;AAC7B,OAAO,QAAQ;AAEf,SAAS,uBAAuB;AAEhC,SAAS,yDAAyD,MAAM;AAEtE,WAAS,kCAAkC,MAAM;AAC/C,OAAG,kDAAkD,MAAM;AACzD,YAAM,WAAW;AAAA,QACf,oBAAoB,MAAM;AAAA,QAC1B,QAAQ;AAAA,MACV;AAEA,aAAO;AAAA,QACL,MAAM;AACJ,0BAAgB,QAAQ;AAAA,QAC1B;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAED,OAAG,6CAA6C,MAAM;AACpD,YAAM,WAAW;AAAA,QACf,oBAAoB,MAAM;AAAA,QAC1B,QAAQ;AAAA,MACV;AAEA,aAAO;AAAA,QACL,MAAM;AACJ,0BAAgB,QAAQ;AAAA,QAC1B;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAED,OAAG,mEAAmE,MAAM;AAC1E,YAAM,WAAW;AAAA;AAAA,QAEf,QAAQ;AAAA,UACN,OAAO,GAAG,YAAY;AAAA,QACxB;AAAA,MACF;AAEA,aAAO;AAAA,QACL,MAAM;AACJ,0BAAgB,QAAQ;AAAA,QAC1B;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAED,OAAG,mDAAmD,MAAM;AAC1D,YAAM,WAAW;AAAA,QACf,oBAAoB,MAAM;AAAA,QAC1B,QAAQ,CAAC;AAAA;AAAA,MACX;AAGA,YAAM,SAAS,gBAAgB,QAAQ;AACvC,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAED,OAAG,qDAAqD,MAAM;AAC5D,YAAM,WAAW;AAAA,QACf,oBAAoB,MAAM;AAAA,QAC1B,QAAQ;AAAA,UACN,OAAO;AAAA,QACT;AAAA,MACF;AAGA,YAAM,SAAS,gBAAgB,QAAQ;AACvC,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AAGD,WAAS,qBAAqB,MAAM;AAClC,OAAG,6DAA6D,MAAM;AAEpE,YAAM,gBAAgB;AAAA,QACpB,oBAAoB,MAAM;AAAA,QAC1B,QAAQ;AAAA,UACN,OAAO,GAAG,YAAY;AAAA,QACxB;AAAA,MACF;AAEA,YAAM,SAAS,gBAAgB,aAAa;AAC5C,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAED,OAAG,uDAAuD,MAAM;AAE9D,YAAM,oBAAoB;AAAA,QACxB,GAAG,YAAY;AAAA,QACf,GAAG,YAAY;AAAA,QACf,GAAG,YAAY;AAAA,QACf,GAAG,YAAY;AAAA,QACf,GAAG,YAAY;AAAA,QACf,GAAG,YAAY;AAAA,QACf,GAAG,YAAY;AAAA;AAAA,MAEjB;AAEA,wBAAkB,QAAQ,CAAC,SAAS;AAClC,cAAM,WAAW;AAAA,UACf,oBAAoB,MAAM;AAAA,UAC1B,QAAQ;AAAA,YACN,OAAO;AAAA,UACT;AAAA,QACF;AAEA,cAAM,SAAS,gBAAgB,QAAQ;AACvC,eAAO;AAAA,UACL;AAAA,UACA;AAAA,UACA,0CAA0C,GAAG,YAAY,IAAI,CAAC,KAAK,IAAI;AAAA,QACzE;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAED,OAAG,qEAAqE,MAAM;AAE5E,YAAM,WAAW;AAAA,QACf,oBAAoB,MAAM;AAAA,QAC1B,QAAQ;AAAA,UACN,OAAO,GAAG,YAAY;AAAA,QACxB;AAAA,MACF;AAEA,YAAM,SAAS,gBAAgB,QAAQ;AACvC,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AAGD,WAAS,6BAA6B,MAAM;AAC1C,OAAG,wDAAwD,MAAM;AAC/D,YAAM,gBAAgB;AAAA,QACpB,GAAG,YAAY,YAAY,GAAG,YAAY;AAAA,QAC1C,GAAG,YAAY,YAAY,GAAG,YAAY;AAAA,QAC1C,GAAG,YAAY,YAAY,GAAG,YAAY;AAAA;AAAA,QAC1C,GAAG,YAAY,YAAY,GAAG,YAAY;AAAA,MAC5C;AAEA,oBAAc,QAAQ,CAAC,OAAO,UAAU;AACtC,cAAM,WAAW;AAAA,UACf,oBAAoB,MAAM;AAAA,UAC1B,QAAQ,EAAE,MAAM;AAAA,QAClB;AAEA,cAAM,SAAS,gBAAgB,QAAQ;AACvC,eAAO;AAAA,UACL;AAAA,UACA;AAAA,UACA,uBAAuB,QAAQ,CAAC;AAAA,QAClC;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAED,OAAG,wDAAwD,MAAM;AAC/D,YAAM,2BAA2B;AAAA,QAC/B,GAAG,YAAY,WAAW,GAAG,YAAY;AAAA,QACzC,GAAG,YAAY,OAAO,GAAG,YAAY;AAAA;AAAA,MAEvC;AAEA,+BAAyB,QAAQ,CAAC,OAAO,UAAU;AAEjD,aAAK,QAAQ,GAAG,YAAY,eAAe,GAAG;AAE5C;AAAA,QACF;AAEA,cAAM,WAAW;AAAA,UACf,oBAAoB,MAAM;AAAA,UAC1B,QAAQ,EAAE,MAAM;AAAA,QAClB;AAEA,cAAM,SAAS,gBAAgB,QAAQ;AACvC,eAAO;AAAA,UACL;AAAA,UACA;AAAA,UACA,uBAAuB,QAAQ,CAAC;AAAA,QAClC;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAED,OAAG,6CAA6C,MAAM;AACpD,YAAM,WAAW;AAAA,QACf,oBAAoB,MAAM;AAAA,QAC1B,QAAQ;AAAA,UACN,OAAO,OAAO;AAAA,QAChB;AAAA,MACF;AAGA,YAAM,oBACH,OAAO,mBAAmB,GAAG,YAAY,eAAe;AAC3D,YAAM,SAAS,gBAAgB,QAAQ;AACvC,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAED,OAAG,gCAAgC,MAAM;AACvC,YAAM,WAAW;AAAA,QACf,oBAAoB,MAAM;AAAA,QAC1B,QAAQ;AAAA,UACN,OAAO;AAAA,QACT;AAAA,MACF;AAEA,YAAM,SAAS,gBAAgB,QAAQ;AACvC,aAAO,YAAY,QAAQ,OAAO,mCAAmC;AAAA,IACvE,CAAC;AAAA,EACH,CAAC;AAGD,WAAS,uBAAuB,MAAM;AACpC,OAAG,oCAAoC,MAAM;AAC3C,YAAM,WAAW;AAAA,QACf,oBAAoB,MAAM;AAAA,QAC1B,QAAQ;AAAA,UACN,OAAO,GAAG,YAAY;AAAA,QACxB;AAAA,MACF;AAEA,YAAM,SAAS,gBAAgB,QAAQ;AACvC,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAED,OAAG,kCAAkC,MAAM;AACzC,YAAM,WAAW;AAAA,QACf,oBAAoB,MAAM;AAAA,QAC1B,QAAQ;AAAA,UACN,OAAO,GAAG,YAAY,YAAY;AAAA,QACpC;AAAA,MACF;AAEA,YAAM,SAAS,gBAAgB,QAAQ;AACvC,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAED,OAAG,iCAAiC,MAAM;AACxC,YAAM,YAAY,GAAG,YAAY,YAAY;AAC7C,YAAM,WAAW;AAAA,QACf,oBAAoB,MAAM;AAAA,QAC1B,QAAQ;AAAA,UACN,OAAO;AAAA,QACT;AAAA,MACF;AAGA,YAAM,oBAAoB,YAAY,GAAG,YAAY,eAAe;AACpE,YAAM,SAAS,gBAAgB,QAAQ;AACvC,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AAGD,WAAS,wBAAwB,MAAM;AACrC,OAAG,wCAAwC,MAAM;AAC/C,YAAM,WAAW;AAAA,QACf,oBAAoB,MAAM;AAAA,QAC1B,QAAQ;AAAA,UACN,OAAO,GAAG,YAAY;AAAA,QACxB;AAAA,MACF;AAEA,YAAM,SAAS,gBAAgB,QAAQ;AACvC,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAED,OAAG,iCAAiC,MAAM;AACxC,YAAM,WAAW;AAAA,QACf,oBAAoB,MAAM;AAAA,QAC1B,QAAQ;AAAA,UACN,OAAO,GAAG,YAAY;AAAA,QACxB;AAAA,MACF;AAEA,YAAM,SAAS,gBAAgB,QAAQ;AACvC,aAAO,YAAY,QAAQ,OAAO,qCAAqC;AAAA,IACzE,CAAC;AAED,OAAG,qCAAqC,MAAM;AAC5C,YAAM,WAAW;AAAA,QACf,oBAAoB,MAAM;AAAA,QAC1B,QAAQ;AAAA,UACN,OAAO,GAAG,YAAY;AAAA,QACxB;AAAA,MACF;AAEA,YAAM,SAAS,gBAAgB,QAAQ;AACvC,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
-  "names": []
-}