npm - @mocoto/mahoraga - Versions diffs - 0.14.0 - Mend

@mocoto/mahoraga 0.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4928) hide show

package/dist/core/messages/en/core/plugin-messages.d.ts ADDED Viewed

@@ -0,0 +1,329 @@
+export declare const ReactMensagens: {
+    readonly linkTargetBlank: "Link with target=\"_blank\" without rel=\"noreferrer\"/\"noopener\".";
+    readonly dangerouslySetInnerHTML: "Use of dangerouslySetInnerHTML found; validate the need.";
+    readonly imgWithoutAlt: "Image without alt attribute (accessibility).";
+    readonly httpFetch: "HTTP call without TLS detected; prefer HTTPS.";
+    readonly hardcodedCredential: "Possible hardcoded credential; use environment variables.";
+    readonly locationHrefRedirect: "Direct assignment to location.href; validate origin to prevent open redirect.";
+    readonly listItemNoKey: "Item in list (map) without key attribute.";
+    readonly indexAsKey: "Using index as key (may cause reordering issues).";
+    readonly inlineHandlerJsx: "Inline handler detected in JSX; prefer stable functions (useCallback) or extract outside render.";
+    readonly deprecatedLifecycleMethod: (name: string) => string;
+    readonly complexInlineStyles: "Complex inline styles detected. Consider using CSS modules or styled-components for better performance and organization.";
+};
+export declare const ReactHooksMensagens: {
+    readonly useEffectNoDeps: "useEffect without dependency array (evaluate deps to avoid loops).";
+    readonly memoCallbackNoDeps: "Hook without dependency array (useMemo/useCallback).";
+    readonly hookInConditional: "Hook declared inside conditional (breaks Rules of Hooks).";
+};
+export declare const TailwindMensagens: {
+    readonly conflictingClasses: (key: string, tokens: string[]) => string;
+    readonly repeatedClass: (token: string) => string;
+    readonly importantUsage: (token: string) => string;
+    readonly variantConflict: (prop: string, variants: string[]) => string;
+    readonly dangerousArbitraryValue: (token: string) => string;
+    readonly arbitraryValue: (token: string) => string;
+};
+export declare const CssMensagens: {
+    readonly duplicatePropertySame: (prop: string) => string;
+    readonly duplicatePropertyDifferent: (prop: string, prev: string, curr: string) => string;
+    readonly importantUsage: "Use of !important detected; prefer adequate specificity.";
+    readonly httpImport: "HTTP import detected; prefer HTTPS or local bundling.";
+    readonly httpUrl: "External resource via HTTP in url(); prefer HTTPS.";
+    readonly unifySelectors: (selectors: string[], propsCount: number) => string;
+    readonly idSelectorPreferClass: (selector: string) => string;
+    readonly invalidProperty: (prop: string) => string;
+    readonly malformedSelector: (selector: string) => string;
+    readonly emptyRule: "Empty CSS rule detected. Remove rules without declarations.";
+    readonly vendorPrefixDeprecated: (prop: string) => string;
+    readonly cssHackDetected: (hack: string) => string;
+};
+export declare const HtmlMensagens: {
+    readonly doctype: "Document without <!DOCTYPE html> declared.";
+    readonly htmlLang: "<html> element without lang attribute (accessibility).";
+    readonly metaCharset: "Missing <meta charset=\"utf-8\"> in document.";
+    readonly viewport: "Missing viewport meta for responsiveness.";
+    readonly title: "Document without <title> defined.";
+    readonly linkTargetBlank: "Link with target=\"_blank\" without rel=\"noreferrer\"/\"noopener\".";
+    readonly linkNoHref: "Link without valid href or handler (UX). Use <button> or role=\"button\".";
+    readonly imgWithoutAlt: "Image without alt attribute or accessibility (WCAG 2.1).";
+    readonly imgWithoutLoading: "Image without loading attribute (performance). Consider loading=\"lazy\".";
+    readonly imgWithoutDimensions: "Image without width/height (layout shift). Set dimensions to prevent CLS.";
+    readonly formWithoutMethod: "Form without method specified (GET/POST).";
+    readonly formWithoutAction: "Form without action or data-attribute for processing.";
+    readonly inputWithoutLabel: "Input without name, id or aria-label (accessibility/usability).";
+    readonly passwordWithoutAutocomplete: "Password field without autocomplete specified (security).";
+    readonly inputWithoutType: "Input without type specified (assumes text, but be explicit).";
+    readonly inlineHandler: "Inline handler detected (on*). Prefer external listeners or data-attributes with JS.";
+    readonly inlineScript: "Inline script detected. Prefer external files for better caching and CSP.";
+    readonly inlineStyle: "Inline style detected. Prefer external CSS files for better caching.";
+    readonly scriptWithoutDefer: "Script without defer/async. May block rendering; consider defer.";
+    readonly headingSkipped: (current: number, expected: number) => string;
+    readonly buttonWithoutText: "Button without text or aria-label (accessibility).";
+    readonly tableWithoutCaption: "Table without <caption> or aria-label (accessibility).";
+    readonly iframeWithoutTitle: "Iframe without title (accessibility).";
+    readonly largeInlineScript: "Very large inline script. Move to external file.";
+    readonly multipleH1: "Multiple <h1> detected. Use only one per page for SEO/accessibility.";
+};
+export declare const XmlMensagens: {
+    readonly xmlPrologAusente: "XML without <?xml ...?> declaration (optional, but improves compatibility).";
+    readonly doctypeDetectado: "XML contains <!DOCTYPE>. Watch out for XXE vectors (external entities).";
+    readonly doctypeExternoDetectado: "XML contains DOCTYPE with external identifier (SYSTEM/PUBLIC). High XXE risk if parser is not secure.";
+    readonly entidadeDetectada: "XML contains <!ENTITY>. Review if there is expansion/XXE risk.";
+    readonly entidadeExternaDetectada: "XML contains external entity (SYSTEM/PUBLIC). High XXE risk if parser is not secure.";
+    readonly entidadeParametroDetectada: "XML contains parameter entity (<!ENTITY % ...>). May be used for XXE/DTD injection; review carefully.";
+    readonly xincludeDetectado: "XML contains XInclude (<xi:include>). May load external resources; validate origin and parser.";
+    readonly namespaceUndeclared: (prefix: string) => string;
+    readonly invalidXmlStructure: "Invalid XML structure detected (unclosed or poorly nested tags).";
+    readonly encodingMismatch: (declared: string, detected: string) => string;
+    readonly largeEntityExpansion: "Possible entity with very large expansion. Risk of Billion Laughs attack.";
+    readonly cdataInAttribute: "CDATA detected in attribute value (invalid in XML).";
+    readonly missingEncoding: "XML missing encoding declaration in prolog.";
+    readonly missingRootElement: "XML without a root element detected.";
+    readonly unterminatedElement: "Unterminated XML element found.";
+    readonly mismatchedCase: "Case mismatch in XML tags.";
+    readonly unmatchedTag: "Closing tag does not match opening tag.";
+    readonly selfClosingMismatch: "Inconsistency: self-closing tag vs separate closing tag.";
+    readonly deepNesting: "Excessive XML element nesting (>20 levels).";
+    readonly tooManyAttributes: "Too many attributes on a single element.";
+    readonly attributeQuotesMissing: "Attribute value without quotes - invalid XML.";
+    readonly namespaceMismatch: "Namespace inconsistency detected.";
+    readonly cdataOveruse: "Excessive CDATA usage - consider character escaping instead.";
+    readonly processingInstructionInContent: "Processing instruction (<? ?>) found in content.";
+    readonly xsdValidationMissing: "XML without XSD (XML Schema Definition) reference.";
+    readonly oversizedXml: "XML too large - consider streaming processing.";
+    readonly deprecatedXmlConstruct: "Deprecated XML construct detected.";
+};
+export declare const FormatadorMensagens: {
+    readonly naoFormatado: (parser: string, detalhes?: string) => string;
+    readonly parseErro: (parser: string, err: string) => string;
+};
+export declare const SvgMensagens: {
+    readonly naoPareceSvg: "File .svg does not contain a valid <svg> tag.";
+    readonly semViewBox: "SVG without viewBox detected (may harm responsiveness).";
+    readonly scriptInline: "SVG contains <script>. Security risk: avoid SVGs with embedded script.";
+    readonly eventoInline: "SVG contains inline handlers (on*). Avoid inline events in assets.";
+    readonly javascriptUrl: "SVG contains javascript: in URL/href. Security risk.";
+    readonly podeOtimizar: (originalBytes: number, optimizedBytes: number, mudancas: string[]) => string;
+};
+export declare const CssInJsMensagens: {
+    readonly detectedStyledComponents: "styled-components patterns detected (CSS-in-JS).";
+    readonly detectedStyledJsx: "styled-jsx patterns detected (CSS-in-JS in React).";
+    readonly globalStyles: (fonte: "styled-components" | "styled-jsx") => string;
+    readonly importantUsage: "Use of !important in CSS-in-JS detected; prefer adequate specificity.";
+    readonly httpUrl: "External resource via HTTP in url(); prefer HTTPS.";
+    readonly bestPracticesDescricao: "Detects bad practices in CSS-in-JS";
+    readonly detectorGlobalStyles: "Global styles detected";
+    readonly sugestaoEvitarGlobalStyles: "Avoid global styles - use CSS Modules or scoped styles";
+    readonly importantDetected: "!important in CSS-in-JS";
+    readonly sugestaoEspecificidade: "Refactor specificity instead of using !important";
+    readonly httpUrlDetected: "HTTP URL in CSS-in-JS";
+    readonly sugestaoHttps: "Use HTTPS for external resources";
+    readonly mixedStyling: "Mixing className and inline styles";
+    readonly sugestaoMixedStyling: "Choose one approach: CSS-in-JS or inline styles";
+    readonly missingThemeAccess: "Direct theme token access not found - use useTheme or ThemeProvider";
+    readonly missingThemeAccessSugestao: "Consider using the theme system (ThemeProvider + useTheme) for consistency";
+    readonly inlineStylesOverObjectStyles: "Inline styles detected instead of styled components/style objects";
+    readonly inlineStylesOverObjectStylesSugestao: "Extract inline styles to styled components or style objects";
+    readonly hardcodedBreakpoint: "Hardcoded breakpoint detected - prefer theme breakpoints";
+    readonly hardcodedBreakpointSugestao: "Define breakpoints in the theme and reuse consistently";
+    readonly missingPseudoClasses: "Interactive states without pseudo-classes (hover, focus, active)";
+    readonly missingPseudoClassesSugestao: "Add pseudo-classes for visual feedback on interactive elements";
+    readonly runtimeCostWarning: "Dynamic styles usage that may have runtime cost";
+    readonly runtimeCostWarningSugestao: "Consider using static classes or CSS variables for dynamic styles";
+    readonly noStylesExtracted: "Styles may not be extracted to static CSS (lower performance)";
+    readonly noStylesExtractedSugestao: "Enable static CSS extraction in your bundler setup";
+    readonly conditionalRenderingStyles: "Complex conditional styles detected - may affect performance";
+    readonly conditionalRenderingStylesSugestao: "Use variants or conditional classes instead of complex dynamic styles";
+    readonly taggedTemplateWithoutExpression: "Template literal without expressions detected - use string literal";
+    readonly taggedTemplateWithoutExpressionSugestao: "Use plain CSS string instead of tagged template for static styles";
+};
+export declare const CssInJsPontuacaoMensagens: {
+    readonly notDetected: "CSS-in-JS not detected";
+    readonly detected: "CSS-in-JS detected";
+    readonly noGlobalStyles: "No global styles";
+    readonly globalStylesIssue: "Global styles detected";
+    readonly noImportant: "No !important";
+    readonly importantUsageCount: (count: number) => string;
+    readonly noHttpUrls: "No HTTP URLs";
+    readonly httpUrlCount: (count: number) => string;
+    readonly consistentStyling: "Consistent styling approach";
+    readonly mixedStylingIssue: "Mixing className and inline styles";
+    readonly themeUsage: "Theme system usage";
+    readonly noThemeSystem: "No theme system - consider using ThemeProvider";
+};
+export declare const CssInJsCorrecaoMensagens: {
+    readonly description: "Automatic corrections for CSS-in-JS issues";
+    readonly correctionSuggested: (tipo: string) => string;
+    readonly sugestaoFormat: (original: string, sugerido: string, confianca: number) => string;
+    readonly extractGlobalCss: "// Consider moving to a separate global CSS file";
+};
+export declare const PythonMensagens: {
+    readonly missingTypeHints: "Function without type hints detected; add type hints for better readability.";
+    readonly hardcodedString: (string: string) => string;
+    readonly httpWithoutVerify: "HTTP request without verify=True detected; validate SSL certificates.";
+    readonly sqlInjection: "Possible SQL injection detected; use prepared statements.";
+    readonly broadExcept: "Generic exception (except:) detected; be specific.";
+    readonly bareRaise: "raise without context detected; always pass the exception to maintain stack trace.";
+    readonly passInExcept: "pass in except block; implement appropriate error handling.";
+    readonly printInsteadOfLog: "print() detected; prefer logging module for production.";
+    readonly evalUsage: "eval() detected; avoid using eval - security vulnerability.";
+    readonly execUsage: "exec() detected; avoid using exec - security vulnerability.";
+    readonly subprocessShellTrue: "subprocess with shell=True detected; risk of command injection. Prefer args list and shell=False.";
+    readonly pickleUsage: "pickle load(s) detected; never deserialize untrusted data (RCE). Prefer safe formats (JSON).";
+    readonly yamlUnsafeLoad: "yaml.load without safe Loader detected; prefer yaml.safe_load (prevents execution).";
+    readonly globalKeyword: "Use of global keyword detected; prefer passing as parameter.";
+    readonly mutableDefault: "Argument with mutable default value (list/dict) detected; use None as default.";
+    readonly listComprehensionOpportunity: "Loop that could be list comprehension detected.";
+    readonly loopingOverDict: "Iteration over dict without .items(); consider using .items().";
+    readonly assertUsage: "assert detected in production code.";
+    readonly insecureHashLib: "Insecure hash algorithm (md5/sha1) detected.";
+    readonly requestWithoutTimeout: "HTTP request without timeout.";
+    readonly tempfileSecurity: "Insecure temporary file creation (mktemp).";
+    readonly loggingWithoutException: "except block without logging exception.";
+    readonly typingImportMissing: "Function using types (List, Dict, Optional, etc.) without typing import.";
+    readonly commentedCode: "Commented-out code detected.";
+    readonly todoFixme: "TODO/FIXME comment found.";
+    readonly wildcardImport: "Wildcard import (from x import *) detected.";
+    readonly relativeImportDeep: "Deep relative import detected.";
+    readonly tooManyReturns: "Function with too many return paths.";
+    readonly tooManyBranches: "Function too complex (too many if/elif/else branches).";
+    readonly longLine: "Line exceeds PEP 8 limit (79 chars).";
+    readonly shadowBuiltin: "Variable shadows Python built-in.";
+    readonly unusedVariable: "Variable defined but never used.";
+    readonly redefinedLoopVar: "Loop variable overwritten in loop body.";
+    readonly considerEnum: "Consider using Enum for string constants group.";
+    readonly dataclassOpportunity: "Class could be a dataclass.";
+    readonly returnOutsideFunction: "Return outside function.";
+    readonly asyncWithoutAwait: "Async function without any await.";
+    readonly fstringWithoutExpression: "f-string without expression (wasted computation).";
+    readonly dictIteration: "Iterating dict without .items() in complex context.";
+};
+export declare const GoMensagens: {
+    readonly uncheckedError: "Unchecked error after function call that may return an error.";
+    readonly printWithoutFormat: "fmt.Print* used without format string; prefer fmt.Printf with format.";
+    readonly deferInLoop: "defer inside a loop may leak resources; move outside the loop.";
+    readonly hardcodedSecret: "Possible hardcoded secret detected; use environment variables.";
+    readonly unbufferedChanSend: "Send on unbuffered channel in same goroutine - deadlock risk.";
+    readonly magicNumber: "Magic number detected; extract to named constant.";
+    readonly longFunction: "Function too long; consider refactoring into smaller functions.";
+    readonly missingDeferClose: "Resource not closed with defer; add defer resource.Close().";
+    readonly globalVar: "Global variable detected; consider dependency injection.";
+    readonly ignoredError: "Error return explicitly ignored with _; consider checking the error.";
+    readonly sqlInjection: "SQL query built via string concatenation; risk of SQL injection. Use parameterized queries.";
+    readonly commandInjection: "Command constructed with variable interpolation; risk of command injection.";
+    readonly pathTraversal: "File operation using user input; risk of path traversal. Validate/sanitize the path.";
+    readonly namingConvention: (funcName: string) => string;
+    readonly longVariableName: (varName: string) => string;
+    readonly incompleteImportPath: (path: string) => string;
+    readonly goodErrorWrapping: "Good practice: error wrapping with %w in fmt.Errorf";
+};
+export declare const RustMensagens: {
+    readonly unwrapUsage: ".unwrap() detected; prefer pattern matching with Result/Option.";
+    readonly emptyExpect: ".expect() with empty message; provide a descriptive message.";
+    readonly unsafeBlock: "unsafe block detected; avoid unsafe whenever possible.";
+    readonly transmuteUsage: "transmute usage detected; prefer safe TryFrom/From conversions.";
+    readonly noTrimOnInput: "read_line without trim; value may contain newline.";
+    readonly vecWithoutCapacity: "Vec.push() on Vec created without with_capacity; pre-allocate for performance.";
+    readonly mutexAcrossAwait: "Mutex lock held across .await; deadlock risk.";
+    readonly printlnInLib: "println! in library code; use logging framework.";
+    readonly magicNumber: "Magic number detected; extract to constant.";
+    readonly hardcodedSecret: "Possible hardcoded secret detected; use environment variables.";
+    readonly longFunction: "Function too long; consider refactoring into smaller functions.";
+    readonly genericExpect: ".expect() with generic message; provide context about why the value should be Some/Ok.";
+    readonly unwrapInResult: ".unwrap() in function returning Result; use ? operator instead.";
+    readonly stubMacro: (name: string) => string;
+    readonly todoFound: "todo!() macro found; implement before shipping.";
+    readonly rawPointer: "Raw pointer used inside unsafe block; ensure safety invariants are documented.";
+    readonly reprC: "#[repr(C)] detected; ensure it is necessary for FFI compatibility.";
+    readonly missingDoc: (fnName: string) => string;
+    readonly namingConvention: (constName: string) => string;
+    readonly redundantReturn: "Redundant return at end of function; Rust uses implicit return (last expression).";
+    readonly wildcardImport: (importPath: string) => string;
+};
+export declare const JavaMensagens: {
+    readonly sysoutDetected: "System.out/err.print detected; use logging framework (SLF4J, Logback).";
+    readonly printStackTrace: "e.printStackTrace() detected; use logger to record exceptions.";
+    readonly hardcodedSecret: "Possible hardcoded secret detected; use environment variables.";
+    readonly sqlConcatenation: "SQL concatenation detected; use PreparedStatement.";
+    readonly nullAssignment: "Null assignment detected; consider Optional.";
+    readonly emptyCatch: "Empty catch block detected; at least log the error.";
+    readonly genericCatch: "Generic exception caught (Exception/Throwable); be specific.";
+    readonly mutableStatic: "Mutable static field detected; prefer final or encapsulation.";
+    readonly longMethod: "Method too long; consider extracting smaller methods.";
+    readonly lateinitWithoutCheck: "lateinit var without ::isInitialized check before use.";
+};
+export declare const PhpMensagens: {
+    readonly sqlInjection: "Possible SQL injection detected; use prepared statements (PDO).";
+    readonly evalUsage: "eval() detected; security vulnerability - avoid using.";
+    readonly assertString: "assert() with string detected; risk of code injection.";
+    readonly unserializeUsage: "unserialize() detected; RCE risk if data is untrusted.";
+    readonly extractUsage: "extract() detected; risk of variable overwriting.";
+    readonly urlFetch: "file_get_contents with URL detected; validate and restrict URLs.";
+    readonly commandExecution: "Command execution function detected; risk of command injection.";
+    readonly requestUsage: "$_REQUEST detected; prefer $_GET, $_POST or $_SERVER for clarity.";
+    readonly hardcodedSecret: "Possible hardcoded secret detected; use environment variables.";
+    readonly deprecatedMysql: "Deprecated mysql_* function detected; migrate to PDO or MySQLi.";
+    readonly shortOpenTag: "Short open tag (<?) detected; prefer <?php for compatibility.";
+    readonly errorSuppression: "Error suppression operator (@) detected; handle errors properly.";
+    readonly longFunction: "Function too long; consider refactoring.";
+    readonly debugOutput: "var_dump/print_r/die detected in production code; remove or use logger.";
+    readonly camelCaseFunction: "CamelCase function name; consider snake_case for PHP convention.";
+    readonly looseComparison: "Loose comparison (==) in security context; use ===.";
+    readonly insecureFileInclude: "File inclusion with variable; risk of path traversal.";
+    readonly xssOutput: "echo/print of unsanitized input; XSS risk.";
+    readonly csrfMissing: "Form without CSRF token detected.";
+    readonly openRedirect: "Redirect (Location) with user input; open redirect risk.";
+    readonly dangerousIniSet: "ini_set() with dangerous option detected.";
+    readonly registerGlobals: "register_globals detected; deprecated and insecure.";
+    readonly passwordHashWithoutVerify: "password_hash() used without matching password_verify().";
+    readonly weakPasswordHash: "Weak password hash (md5/sha1) detected; use password_hash().";
+    readonly sessionFixation: "session_start() without session_regenerate_id(); fixation risk.";
+    readonly secondOrderInjection: "Possible second-order injection in query with user data.";
+    readonly missingStrictTypes: "PHP file without declare(strict_types=1); add for strict typing.";
+    readonly deprecatedFunction: "Deprecated function detected; replace with modern alternative.";
+    readonly magicNumber: "Magic number detected; extract to named constant.";
+    readonly highComplexity: "Function with high cyclomatic complexity; consider refactoring.";
+    readonly missingErrorHandling: "File/network operation without proper error handling.";
+    readonly unfilteredSuperglobal: "Superglobal access without sanitization/filtering.";
+    readonly globalKeyword: "Use of global keyword; prefer dependency injection.";
+    readonly methodNamingConvention: "Public/protected method should use camelCase (PSR-12).";
+    readonly longParameterList: "Long parameter list (>5); consider using a config object.";
+};
+export declare const SeverityNiveis: {
+    readonly error: "error";
+    readonly warning: "warning";
+    readonly info: "info";
+    readonly suggestion: "suggestion";
+};
+export declare const AnalystTipos: {
+    readonly react: "react/rule";
+    readonly reactHooks: "react-hooks/rule";
+    readonly tailwind: "tailwindcss/rule";
+    readonly css: "css/rule";
+    readonly html: "html/rule";
+    readonly python: "python/rule";
+    readonly xml: "xml/rule";
+    readonly formatador: "formatter/rule";
+    readonly svg: "svg/rule";
+    readonly cssInJs: "css-in-js/rule";
+    readonly go: "go/rule";
+    readonly rust: "rust/rule";
+    readonly php: "php/rule";
+};
+export declare const AnalystOrigens: {
+    readonly react: "analyst-react";
+    readonly reactHooks: "analyst-react-hooks";
+    readonly tailwind: "analyst-tailwind";
+    readonly css: "analyst-css";
+    readonly html: "analyst-html";
+    readonly python: "analyst-python";
+    readonly xml: "analyst-xml";
+    readonly formatador: "analyst-formatter";
+    readonly svg: "analyst-svg";
+    readonly cssInJs: "analyst-css-in-js";
+    readonly go: "analyst-go";
+    readonly rust: "analyst-rust";
+    readonly php: "analyst-php";
+};
+//# sourceMappingURL=plugin-messages.d.ts.map

package/dist/core/messages/en/core/plugin-messages.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"plugin-messages.d.ts","sourceRoot":"","sources":["../../../../../src/core/messages/en/core/plugin-messages.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,cAAc;;;;;;;;;;+CAUO,MAAM;;CAE9B,CAAC;AAEX,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC;AAEX,eAAO,MAAM,iBAAiB;uCACJ,MAAM,UAAU,MAAM,EAAE;oCAC3B,MAAM;qCACL,MAAM;qCACN,MAAM,YAAY,MAAM,EAAE;8CACjB,MAAM;qCACf,MAAM;CACpB,CAAC;AAEX,eAAO,MAAM,YAAY;2CACK,MAAM;gDACD,MAAM,QAAQ,MAAM,QAAQ,MAAM;;;;yCAIzC,MAAM,EAAE,cAAc,MAAM;+CACtB,MAAM;qCAChB,MAAM;2CACA,MAAM;;4CAEL,MAAM;qCACb,MAAM;CACpB,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;uCA2BA,MAAM,YAAY,MAAM;;;;;;CAOxC,CAAC;AAEX,eAAO,MAAM,YAAY;;;;;;;;2CAQK,MAAM;;0CAEP,MAAM,YAAY,MAAM;;;;;;;;;;;;;;;;;;CAkB3C,CAAC;AAEX,eAAO,MAAM,mBAAmB;oCACT,MAAM,aAAa,MAAM;iCAK5B,MAAM,OAAO,MAAM;CAC7B,CAAC;AAEX,eAAO,MAAM,YAAY;;;;;;2CAMK,MAAM,kBAAkB,MAAM,YAAY,MAAM,EAAE;CACtE,CAAC;AAEX,eAAO,MAAM,gBAAgB;;;mCAGL,mBAAmB,GAAG,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BhD,CAAC;AAEX,eAAO,MAAM,yBAAyB;;;;;;0CAMP,MAAM;;mCAEb,MAAM;;;;;CAKpB,CAAC;AAEX,eAAO,MAAM,wBAAwB;;yCAEP,MAAM;wCACP,MAAM,YAAY,MAAM,aAAa,MAAM;;CAE9D,CAAC;AAEX,eAAO,MAAM,eAAe;;uCAGF,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CtB,CAAC;AAEX,eAAO,MAAM,WAAW;;;;;;;;;;;;;;0CAcO,MAAM;yCACP,MAAM;0CACL,MAAM;;CAE3B,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;+BAcN,MAAM;;;;kCAIH,MAAM;2CACG,MAAM;;0CAEP,MAAM;CAC3B,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;CAWhB,CAAC;AAEX,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCf,CAAC;AAEX,eAAO,MAAM,cAAc;;;;;CAKjB,CAAC;AAEX,eAAO,MAAM,YAAY;;;;;;;;;;;;;;CAcf,CAAC;AACX,eAAO,MAAM,cAAc;;;;;;;;;;;;;;CAcjB,CAAC"}