caseforge 0.1.5 → 0.2.0

package/README.md

@@ -20,13 +20,14 @@ npm install caseforge
 ```
 
 ```ts
-import { toCamelCase, toSnakeCase, toKebabCase, toPascalCase } from "caseforge";
+import { toCamelCase, toSnakeCase, toKebabCase, toPascalCase, toUpperCase } from "caseforge";
 
 // String conversion
 toCamelCase("user_name");     // => "userName"
 toSnakeCase("userName");       // => "user_name"
 toKebabCase("userName");       // => "user-name"
 toPascalCase("user_name");     // => "UserName"
+toUpperCase("userName");       // => "USER_NAME"
 
 // Object conversion with type inference
 const apiResponse = {

package/dist/core/toUpperCase.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Converts a string to UPPER_SNAKE_CASE format at the type level.
+ * @example "userName" -> "USER_NAME"
+ */
+type UpperCase<S extends string, First extends boolean = true> = S extends `${infer C}${infer R}` ? C extends "_" | "-" ? `_${UpperCase<R, false>}` : C extends Uppercase<C> ? First extends true ? `${Uppercase<C>}${UpperCase<R, false>}` : `_${Uppercase<C>}${UpperCase<R, false>}` : `${Uppercase<C>}${UpperCase<R, false>}` : Uppercase<S>;
+/**
+ * Converts all object keys to UPPER_SNAKE_CASE format at the type level.
+ * @example { userName: "John Doe" } -> { USER_NAME: "John Doe" }
+ */
+type UpperCaseKeys<T> = {
+    [K in keyof T as UpperCase<K & string>]: T[K] extends Array<infer U> ? U extends Record<string, unknown> ? Array<UpperCaseKeys<U>> : T[K] : T[K] extends Record<string, unknown> ? UpperCaseKeys<T[K]> : T[K];
+};
+/**
+ * Converts strings or object keys to UPPER_SNAKE_CASE format.
+ * @param input - A string or object to convert.
+ * @returns The UPPER_SNAKE_CASE string or object.
+ */
+export declare function toUpperCase<T extends string>(input: T): UpperCase<T>;
+export declare function toUpperCase<T extends Record<string, unknown>>(input: T): UpperCaseKeys<T>;
+export declare function toUpperCase<T>(input: T): T;
+export {};

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export { toCamelCase } from "./core/toCamelCase";
 export { toKebabCase } from "./core/toKebabCase";
 export { toPascalCase } from "./core/toPascalCase";
 export { toSnakeCase } from "./core/toSnakeCase";
+export { toUpperCase } from "./core/toUpperCase";

package/dist/index.js

@@ -1,3 +1 @@
-var q={LEADING_UPPER:/^[A-Z]/,UPPERCASE:/[A-Z]/g,LEADING_LOWER:/^[a-z]/,SEPARATOR_WITH_CHAR:/[_-]+(.)/g,EDGE_SEPARATORS:/^[_-]+|[_-]+$/g,CONSECUTIVE_SEPARATORS:/[_-]+/g};function L(x){return typeof x==="string"}function W(x){return Array.isArray(x)}function D(x){return typeof x==="object"&&x!==null&&!W(x)}function X(x){return x instanceof Date||x instanceof RegExp||typeof x==="function"}function H(x,z){let J={};for(let[F,Q]of Object.entries(x)){let U=z(F);if(X(Q))J[U]=Q;else if(W(Q))J[U]=Q.map((V)=>D(V)&&!W(V)?H(V,z):V);else if(D(Q))J[U]=H(Q,z);else J[U]=Q}return J}function Y(x){return x.replace(q.LEADING_UPPER,(z)=>z.toLowerCase()).replace(q.SEPARATOR_WITH_CHAR,(z,J)=>J.toUpperCase()).replace(q.EDGE_SEPARATORS,"")}function I(x){if(L(x))return Y(x);if(D(x))return H(x,Y);return x}function Z(x){return x.replace(q.UPPERCASE,(z)=>`-${z.toLowerCase()}`).replace(q.CONSECUTIVE_SEPARATORS,"-").replace(q.EDGE_SEPARATORS,"")}function M(x){if(L(x))return Z(x);if(D(x))return H(x,Z);return x}function $(x){return x.replace(q.SEPARATOR_WITH_CHAR,(z,J)=>J.toUpperCase()).replace(q.EDGE_SEPARATORS,"").replace(q.LEADING_LOWER,(z)=>z.toUpperCase())}function _(x){if(L(x))return $(x);if(D(x))return H(x,$);return x}function B(x){return x.replace(q.UPPERCASE,(z)=>`_${z.toLowerCase()}`).replace(q.CONSECUTIVE_SEPARATORS,"_").replace(q.EDGE_SEPARATORS,"")}function w(x){if(L(x))return B(x);if(D(x))return H(x,B);return x}export{w as toSnakeCase,_ as toPascalCase,M as toKebabCase,I as toCamelCase};
-
-//# debugId=CD7706CD4AFBBFB164756E2164756E21
+var q={LEADING_UPPER:/^[A-Z]/,UPPERCASE:/[A-Z]/g,LEADING_LOWER:/^[a-z]/,SEPARATOR_WITH_CHAR:/[_-]+(.)/g,EDGE_SEPARATORS:/^[_-]+|[_-]+$/g,CONSECUTIVE_SEPARATORS:/[_-]+/g};function J(x){return typeof x==="string"}function X(x){return Array.isArray(x)}function D(x){return typeof x==="object"&&x!==null&&!X(x)}function Y(x){return x instanceof Date||x instanceof RegExp||typeof x==="function"}function H(x,z){let L={};for(let[M,Q]of Object.entries(x)){let V=z(M);if(Y(Q))L[V]=Q;else if(X(Q))L[V]=Q.map((W)=>D(W)&&!X(W)?H(W,z):W);else if(D(Q))L[V]=H(Q,z);else L[V]=Q}return L}function Z(x){return x.replace(q.LEADING_UPPER,(z)=>z.toLowerCase()).replace(q.SEPARATOR_WITH_CHAR,(z,L)=>L.toUpperCase()).replace(q.EDGE_SEPARATORS,"")}function U(x){if(J(x))return Z(x);if(D(x))return H(x,Z);return x}function $(x){return x.replace(q.UPPERCASE,(z)=>`-${z.toLowerCase()}`).replace(q.CONSECUTIVE_SEPARATORS,"-").replace(q.EDGE_SEPARATORS,"")}function w(x){if(J(x))return $(x);if(D(x))return H(x,$);return x}function B(x){return x.replace(q.SEPARATOR_WITH_CHAR,(z,L)=>L.toUpperCase()).replace(q.EDGE_SEPARATORS,"").replace(q.LEADING_LOWER,(z)=>z.toUpperCase())}function _(x){if(J(x))return B(x);if(D(x))return H(x,B);return x}function F(x){return x.replace(q.UPPERCASE,(z)=>`_${z.toLowerCase()}`).replace(q.CONSECUTIVE_SEPARATORS,"_").replace(q.EDGE_SEPARATORS,"")}function d(x){if(J(x))return F(x);if(D(x))return H(x,F);return x}function I(x){return x.replace(q.UPPERCASE,(z)=>`_${z.toLowerCase()}`).replace(q.CONSECUTIVE_SEPARATORS,"_").replace(q.EDGE_SEPARATORS,"").toUpperCase()}function G(x){if(J(x))return I(x);if(D(x))return H(x,I);return x}export{G as toUpperCase,d as toSnakeCase,_ as toPascalCase,w as toKebabCase,U as toCamelCase};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "caseforge",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "caseforge - Effortlessly convert between snake_case, camelCase, and more in TypeScript. Zero dependencies, type-safe, and easy to use for any project.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -30,7 +30,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "bun x tsc --emitDeclarationOnly && bun build src/index.ts --outdir dist --target node --minify --sourcemap=external",
+    "build": "bun x tsc --emitDeclarationOnly && bun build src/index.ts --outdir dist --target node --minify",
     "check": "bunx @biomejs/biome check --write src && bun x tsc --noEmit",
     "prepublishOnly": "bun run check && bun test && bun run build",
     "release:patch:auto": "npm version patch && git push && git push --tags && gh release create v$(node -p 'require(\"./package.json\").version') --generate-notes",

package/dist/index.js.map

@@ -1,16 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/utils/patterns.ts", "../src/utils/typeGuards.ts", "../src/utils/transform.ts", "../src/core/toCamelCase.ts", "../src/core/toKebabCase.ts", "../src/core/toPascalCase.ts", "../src/core/toSnakeCase.ts"],
-  "sourcesContent": [
-    "/**\n * Common regular expression patterns for case conversion.\n */\nexport const PATTERNS = {\n\t/** Matches a leading uppercase letter */\n\tLEADING_UPPER: /^[A-Z]/,\n\n\t/** Matches all uppercase letters */\n\tUPPERCASE: /[A-Z]/g,\n\n\t/** Matches a leading lowercase letter */\n\tLEADING_LOWER: /^[a-z]/,\n\n\t/** Matches separators (_-) followed by any character */\n\tSEPARATOR_WITH_CHAR: /[_-]+(.)/g,\n\n\t/** Matches leading/trailing separators */\n\tEDGE_SEPARATORS: /^[_-]+|[_-]+$/g,\n\n\t/** Matches consecutive separators */\n\tCONSECUTIVE_SEPARATORS: /[_-]+/g,\n} as const;\n",
-    "/**\n * Checks if a value is a string.\n * @param value - The value to check.\n * @returns `true` if the value is a string, `false` otherwise.\n */\nexport function isString(value: unknown): value is string {\n\treturn typeof value === \"string\";\n}\n\n/**\n * Checks if a value is an array.\n * @param value - The value to check.\n * @returns `true` if the value is an array, `false` otherwise.\n */\nexport function isArray(value: unknown): value is unknown[] {\n\treturn Array.isArray(value);\n}\n\n/**\n * Checks if a value is a plain object.\n * @param value - The value to check.\n * @returns `true` if the value is a plain object, `false` otherwise.\n */\nexport function isObject(value: unknown): value is Record<string, unknown> {\n\treturn typeof value === \"object\" && value !== null && !isArray(value);\n}\n\n/**\n * Checks if a value is a built-in object.\n * @param value - The value to check.\n * @returns `true` if the value is a built-in object, `false` otherwise.\n */\nexport function isBuiltIn(value: unknown): boolean {\n\treturn (\n\t\tvalue instanceof Date ||\n\t\tvalue instanceof RegExp ||\n\t\ttypeof value === \"function\"\n\t);\n}\n",
-    "import { isArray, isBuiltIn, isObject } from \"./typeGuards\";\n\n/**\n * Generic object key transformation.\n * @param object - The object to transform.\n * @param transformKey - Function to transform each key.\n * @returns The transformed object.\n */\nexport function transformObject<T>(\n\tobject: Record<string, unknown>,\n\ttransformKey: (key: string) => string,\n): T {\n\tconst result = {} as Record<string, unknown>;\n\n\tfor (const [key, value] of Object.entries(object)) {\n\t\tconst newKey = transformKey(key);\n\n\t\tif (isBuiltIn(value)) {\n\t\t\tresult[newKey] = value;\n\t\t} else if (isArray(value)) {\n\t\t\tresult[newKey] = value.map((item) =>\n\t\t\t\tisObject(item) && !isArray(item)\n\t\t\t\t\t? transformObject(item, transformKey)\n\t\t\t\t\t: item,\n\t\t\t);\n\t\t} else if (isObject(value)) {\n\t\t\tresult[newKey] = transformObject(value, transformKey);\n\t\t} else {\n\t\t\tresult[newKey] = value;\n\t\t}\n\t}\n\n\treturn result as T;\n}\n",
-    "import { PATTERNS } from \"@/utils/patterns\";\nimport { transformObject } from \"@/utils/transform\";\nimport { isObject, isString } from \"@/utils/typeGuards\";\n\n/**\n * Converts a string to camelCase format at the type level.\n * @example \"user_name\" -> \"userName\"\n */\ntype CamelCase<S extends string> = S extends `${infer A}_${infer B}`\n\t? `${Lowercase<A>}${Capitalize<CamelCase<B>>}`\n\t: S extends `${infer A}-${infer B}`\n\t\t? `${Lowercase<A>}${Capitalize<CamelCase<B>>}`\n\t\t: Uncapitalize<S>;\n\n/**\n * Converts all object keys to camelCase format at the type level.\n * @example { user_name: \"John Doe\" } -> { userName: \"John Doe\" }\n */\ntype CamelCaseKeys<T> = {\n\t[K in keyof T as CamelCase<K & string>]: T[K] extends Array<infer U>\n\t\t? U extends Record<string, unknown>\n\t\t\t? Array<CamelCaseKeys<U>>\n\t\t\t: T[K]\n\t\t: T[K] extends Record<string, unknown>\n\t\t\t? CamelCaseKeys<T[K]>\n\t\t\t: T[K];\n};\n\n/**\n * Converts a string to camelCase format.\n * @param str - The string to convert.\n * @returns The camelCase string.\n */\nfunction camelCaseString(str: string): string {\n\treturn str\n\t\t.replace(PATTERNS.LEADING_UPPER, (char) => char.toLowerCase())\n\t\t.replace(PATTERNS.SEPARATOR_WITH_CHAR, (_, char) => char.toUpperCase())\n\t\t.replace(PATTERNS.EDGE_SEPARATORS, \"\");\n}\n\n/**\n * Converts strings or object keys to camelCase format.\n * @param input - A string or object to convert.\n * @returns The camelCase string or object.\n */\nexport function toCamelCase<T extends string>(input: T): CamelCase<T>;\nexport function toCamelCase<T extends Record<string, unknown>>(\n\tinput: T,\n): CamelCaseKeys<T>;\nexport function toCamelCase<T>(input: T): T;\nexport function toCamelCase(input: unknown) {\n\tif (isString(input)) {\n\t\treturn camelCaseString(input);\n\t}\n\tif (isObject(input)) {\n\t\treturn transformObject(input, camelCaseString);\n\t}\n\treturn input;\n}\n",
-    "import { PATTERNS } from \"@/utils/patterns\";\nimport { transformObject } from \"@/utils/transform\";\nimport { isObject, isString } from \"@/utils/typeGuards\";\n\n/**\n * Converts a string to kebab-case format at the type level.\n * @example \"userName\" -> \"user-name\"\n */\ntype KebabCase<\n\tS extends string,\n\tFirst extends boolean = true,\n> = S extends `${infer C}${infer R}`\n\t? C extends \"_\"\n\t\t? `-${KebabCase<R, false>}`\n\t\t: C extends Uppercase<C>\n\t\t\t? First extends true\n\t\t\t\t? `${Lowercase<C>}${KebabCase<R, false>}`\n\t\t\t\t: `-${Lowercase<C>}${KebabCase<R, false>}`\n\t\t\t: `${C}${KebabCase<R, false>}`\n\t: S;\n\n/**\n * Converts all object keys to kebab-case format at the type level.\n * @example { userName: \"John Doe\" } -> { \"user-name\": \"John Doe\" }\n */\ntype KebabCaseKeys<T> = {\n\t[K in keyof T as KebabCase<K & string>]: T[K] extends Array<infer U>\n\t\t? U extends Record<string, unknown>\n\t\t\t? Array<KebabCaseKeys<U>>\n\t\t\t: T[K]\n\t\t: T[K] extends Record<string, unknown>\n\t\t\t? KebabCaseKeys<T[K]>\n\t\t\t: T[K];\n};\n\n/**\n * Converts a string to kebab-case format.\n * @param str - The string to convert.\n * @returns The kebab-case string.\n */\nfunction kebabCaseString(str: string): string {\n\treturn str\n\t\t.replace(PATTERNS.UPPERCASE, (char) => `-${char.toLowerCase()}`)\n\t\t.replace(PATTERNS.CONSECUTIVE_SEPARATORS, \"-\")\n\t\t.replace(PATTERNS.EDGE_SEPARATORS, \"\");\n}\n\n/**\n * Converts strings or object keys to kebab-case format.\n * @param input - A string or object to convert.\n * @returns The kebab-case string or object.\n */\nexport function toKebabCase<T extends string>(input: T): KebabCase<T>;\nexport function toKebabCase<T extends Record<string, unknown>>(\n\tinput: T,\n): KebabCaseKeys<T>;\nexport function toKebabCase<T>(input: T): T;\nexport function toKebabCase(input: unknown) {\n\tif (isString(input)) {\n\t\treturn kebabCaseString(input);\n\t}\n\tif (isObject(input)) {\n\t\treturn transformObject(input, kebabCaseString);\n\t}\n\treturn input;\n}\n",
-    "import { PATTERNS } from \"@/utils/patterns\";\nimport { transformObject } from \"@/utils/transform\";\nimport { isObject, isString } from \"@/utils/typeGuards\";\n\n/**\n * Converts a string to PascalCase format at the type level.\n * @example \"user_name\" -> \"UserName\"\n */\ntype PascalCase<S extends string> = S extends `${infer Head}_${infer Tail}`\n\t? `${Capitalize<Lowercase<Head>>}${PascalCase<Tail>}`\n\t: S extends `${infer Head}-${infer Tail}`\n\t\t? `${Capitalize<Lowercase<Head>>}${PascalCase<Tail>}`\n\t\t: S extends `${infer First}${infer Rest}`\n\t\t\t? `${Capitalize<First>}${Rest}`\n\t\t\t: S;\n\n/**\n * Converts all object keys to PascalCase format at the type level.\n * @example { user_name: \"John Doe\" } -> { UserName: \"John Doe\" }\n */\ntype PascalCaseKeys<T> = {\n\t[K in keyof T as PascalCase<K & string>]: T[K] extends Array<infer U>\n\t\t? U extends Record<string, unknown>\n\t\t\t? Array<PascalCaseKeys<U>>\n\t\t\t: T[K]\n\t\t: T[K] extends Record<string, unknown>\n\t\t\t? PascalCaseKeys<T[K]>\n\t\t\t: T[K];\n};\n\n/**\n * Converts a string to PascalCase format.\n * @param str - The string to convert.\n * @returns The PascalCase string.\n */\nfunction pascalCaseString(str: string): string {\n\treturn str\n\t\t.replace(PATTERNS.SEPARATOR_WITH_CHAR, (_, char) => char.toUpperCase())\n\t\t.replace(PATTERNS.EDGE_SEPARATORS, \"\")\n\t\t.replace(PATTERNS.LEADING_LOWER, (char) => char.toUpperCase());\n}\n\n/**\n * Converts strings or object keys to PascalCase format.\n * @param input - A string or object to convert.\n * @returns The PascalCase string or object.\n */\nexport function toPascalCase<T extends string>(input: T): PascalCase<T>;\nexport function toPascalCase<T extends Record<string, unknown>>(\n\tinput: T,\n): PascalCaseKeys<T>;\nexport function toPascalCase<T>(input: T): T;\nexport function toPascalCase(input: unknown) {\n\tif (isString(input)) {\n\t\treturn pascalCaseString(input);\n\t}\n\tif (isObject(input)) {\n\t\treturn transformObject(input, pascalCaseString);\n\t}\n\treturn input;\n}\n",
-    "import { PATTERNS } from \"@/utils/patterns\";\nimport { transformObject } from \"@/utils/transform\";\nimport { isObject, isString } from \"@/utils/typeGuards\";\n\n/**\n * Converts a string to snake_case format at the type level.\n * @example \"userName\" -> \"user_name\"\n */\ntype SnakeCase<\n\tS extends string,\n\tFirst extends boolean = true,\n> = S extends `${infer C}${infer R}`\n\t? C extends \"_\" | \"-\"\n\t\t? `_${SnakeCase<R, false>}`\n\t\t: C extends Uppercase<C>\n\t\t\t? First extends true\n\t\t\t\t? `${Lowercase<C>}${SnakeCase<R, false>}`\n\t\t\t\t: `_${Lowercase<C>}${SnakeCase<R, false>}`\n\t\t\t: `${C}${SnakeCase<R, false>}`\n\t: S;\n\n/**\n * Converts all object keys to snake_case format at the type level.\n * @example { userName: \"John Doe\" } -> { user_name: \"John Doe\" }\n */\ntype SnakeCaseKeys<T> = {\n\t[K in keyof T as SnakeCase<K & string>]: T[K] extends Array<infer U>\n\t\t? U extends Record<string, unknown>\n\t\t\t? Array<SnakeCaseKeys<U>>\n\t\t\t: T[K]\n\t\t: T[K] extends Record<string, unknown>\n\t\t\t? SnakeCaseKeys<T[K]>\n\t\t\t: T[K];\n};\n\n/**\n * Converts a string to snake_case format.\n * @param str - The string to convert.\n * @returns The snake_case string.\n */\nfunction snakeCaseString(str: string): string {\n\treturn str\n\t\t.replace(PATTERNS.UPPERCASE, (char) => `_${char.toLowerCase()}`)\n\t\t.replace(PATTERNS.CONSECUTIVE_SEPARATORS, \"_\")\n\t\t.replace(PATTERNS.EDGE_SEPARATORS, \"\");\n}\n\n/**\n * Converts strings or object keys to snake_case format.\n * @param input - A string or object to convert.\n * @returns The snake_case string or object.\n */\nexport function toSnakeCase<T extends string>(input: T): SnakeCase<T>;\nexport function toSnakeCase<T extends Record<string, unknown>>(\n\tinput: T,\n): SnakeCaseKeys<T>;\nexport function toSnakeCase<T>(input: T): T;\nexport function toSnakeCase(input: unknown) {\n\tif (isString(input)) {\n\t\treturn snakeCaseString(input);\n\t}\n\tif (isObject(input)) {\n\t\treturn transformObject(input, snakeCaseString);\n\t}\n\treturn input;\n}\n"
-  ],
-  "mappings": "AAGO,IAAM,EAAW,CAEvB,cAAe,SAGf,UAAW,SAGX,cAAe,SAGf,oBAAqB,YAGrB,gBAAiB,iBAGjB,uBAAwB,QACzB,EChBO,SAAS,CAAQ,CAAC,EAAiC,CACzD,OAAO,OAAO,IAAU,SAQlB,SAAS,CAAO,CAAC,EAAoC,CAC3D,OAAO,MAAM,QAAQ,CAAK,EAQpB,SAAS,CAAQ,CAAC,EAAkD,CAC1E,OAAO,OAAO,IAAU,UAAY,IAAU,MAAQ,CAAC,EAAQ,CAAK,EAQ9D,SAAS,CAAS,CAAC,EAAyB,CAClD,OACC,aAAiB,MACjB,aAAiB,QACjB,OAAO,IAAU,WC5BZ,SAAS,CAAkB,CACjC,EACA,EACI,CACJ,IAAM,EAAS,CAAC,EAEhB,QAAY,EAAK,KAAU,OAAO,QAAQ,CAAM,EAAG,CAClD,IAAM,EAAS,EAAa,CAAG,EAE/B,GAAI,EAAU,CAAK,EAClB,EAAO,GAAU,EACX,QAAI,EAAQ,CAAK,EACvB,EAAO,GAAU,EAAM,IAAI,CAAC,IAC3B,EAAS,CAAI,GAAK,CAAC,EAAQ,CAAI,EAC5B,EAAgB,EAAM,CAAY,EAClC,CACJ,EACM,QAAI,EAAS,CAAK,EACxB,EAAO,GAAU,EAAgB,EAAO,CAAY,EAEpD,OAAO,GAAU,EAInB,OAAO,ECCR,SAAS,CAAe,CAAC,EAAqB,CAC7C,OAAO,EACL,QAAQ,EAAS,cAAe,CAAC,IAAS,EAAK,YAAY,CAAC,EAC5D,QAAQ,EAAS,oBAAqB,CAAC,EAAG,IAAS,EAAK,YAAY,CAAC,EACrE,QAAQ,EAAS,gBAAiB,EAAE,EAahC,SAAS,CAAW,CAAC,EAAgB,CAC3C,GAAI,EAAS,CAAK,EACjB,OAAO,EAAgB,CAAK,EAE7B,GAAI,EAAS,CAAK,EACjB,OAAO,EAAgB,EAAO,CAAe,EAE9C,OAAO,ECjBR,SAAS,CAAe,CAAC,EAAqB,CAC7C,OAAO,EACL,QAAQ,EAAS,UAAW,CAAC,IAAS,IAAI,EAAK,YAAY,GAAG,EAC9D,QAAQ,EAAS,uBAAwB,GAAG,EAC5C,QAAQ,EAAS,gBAAiB,EAAE,EAahC,SAAS,CAAW,CAAC,EAAgB,CAC3C,GAAI,EAAS,CAAK,EACjB,OAAO,EAAgB,CAAK,EAE7B,GAAI,EAAS,CAAK,EACjB,OAAO,EAAgB,EAAO,CAAe,EAE9C,OAAO,EC7BR,SAAS,CAAgB,CAAC,EAAqB,CAC9C,OAAO,EACL,QAAQ,EAAS,oBAAqB,CAAC,EAAG,IAAS,EAAK,YAAY,CAAC,EACrE,QAAQ,EAAS,gBAAiB,EAAE,EACpC,QAAQ,EAAS,cAAe,CAAC,IAAS,EAAK,YAAY,CAAC,EAaxD,SAAS,CAAY,CAAC,EAAgB,CAC5C,GAAI,EAAS,CAAK,EACjB,OAAO,EAAiB,CAAK,EAE9B,GAAI,EAAS,CAAK,EACjB,OAAO,EAAgB,EAAO,CAAgB,EAE/C,OAAO,ECnBR,SAAS,CAAe,CAAC,EAAqB,CAC7C,OAAO,EACL,QAAQ,EAAS,UAAW,CAAC,IAAS,IAAI,EAAK,YAAY,GAAG,EAC9D,QAAQ,EAAS,uBAAwB,GAAG,EAC5C,QAAQ,EAAS,gBAAiB,EAAE,EAahC,SAAS,CAAW,CAAC,EAAgB,CAC3C,GAAI,EAAS,CAAK,EACjB,OAAO,EAAgB,CAAK,EAE7B,GAAI,EAAS,CAAK,EACjB,OAAO,EAAgB,EAAO,CAAe,EAE9C,OAAO",
-  "debugId": "CD7706CD4AFBBFB164756E2164756E21",
-  "names": []
-}