@codeperfect/eslint-plugin 1.0.0 → 2.1.0

package/dist/domain/docs/single-line-jsdoc/rule.js

@@ -0,0 +1,201 @@
+import { normalizeMaxLineLength, reportIfSingleLine, } from "./single-line-jsdoc-utilities.js";
+/**
+ * Resolves the token after a comment when available.
+ * @param sourceCode Source code accessors.
+ * @param comment Comment node to inspect.
+ * @returns Token range metadata when available.
+ * @example
+ * ```typescript
+ * getTokenAfterRange({} as SourceCodeAccess, {} as SourceComment);
+ * ```
+ */
+const getTokenAfterRange = (sourceCode, comment) => {
+    if (typeof sourceCode.getTokenAfter !== "function") {
+        return void 0;
+    }
+    const tokenAfter = sourceCode.getTokenAfter(comment, {
+        includeComments: false,
+    });
+    if (tokenAfter?.range === void 0) {
+        return void 0;
+    }
+    return { range: tokenAfter.range };
+};
+/**
+ * Function-like node types handled directly.
+ * @example
+ * ```typescript
+ * functionLikeTypes.has("TSFunctionType");
+ * ```
+ */
+const functionLikeTypes = new Set([
+    "TSCallSignatureDeclaration",
+    "TSConstructSignatureDeclaration",
+    "TSFunctionType",
+]);
+/**
+ * Checks if a node is a function expression or arrow function.
+ * @param node Node to inspect.
+ * @returns True when the node is a function expression.
+ * @example
+ * ```typescript
+ * isFunctionExpression({ type: "FunctionExpression" } as EstreeNode);
+ * ```
+ */
+const isFunctionExpression = (node) => node?.type === "FunctionExpression" ||
+    node?.type === "ArrowFunctionExpression";
+/**
+ * Checks if a node is a function declaration or TS declaration signature.
+ * @param node Node to inspect.
+ * @returns True when the node is a function declaration.
+ * @example
+ * ```typescript
+ * isFunctionDeclaration({ type: "FunctionDeclaration" } as EstreeNode);
+ * ```
+ */
+const isFunctionDeclaration = (node) => node?.type === "FunctionDeclaration" || node?.type === "TSDeclareFunction";
+/**
+ * Checks if a node is a method-like declaration.
+ * @param node Node to inspect.
+ * @returns True when the node is a method-like declaration.
+ * @example
+ * ```typescript
+ * isMethodLike({ type: "MethodDefinition" } as EstreeNode);
+ * ```
+ */
+const isMethodLike = (node) => node?.type === "MethodDefinition" || node?.type === "TSMethodSignature";
+/**
+ * Checks if a node is a property with a function initializer.
+ * @param node Node to inspect.
+ * @returns True when the property value is a function.
+ * @example
+ * ```typescript
+ * isPropertyWithFunctionValue({ type: "Property" } as EstreeNode);
+ * ```
+ */
+const isPropertyWithFunctionValue = (node) => {
+    if (node.type !== "PropertyDefinition" && node.type !== "Property") {
+        return false;
+    }
+    const { value } = node;
+    return isFunctionExpression(value);
+};
+/**
+ * Checks if a variable declaration contains a function initializer.
+ * @param node Node to inspect.
+ * @returns True when any initializer is a function.
+ * @example
+ * ```typescript
+ * isVariableWithFunctionInit({ type: "VariableDeclaration" } as EstreeNode);
+ * ```
+ */
+const isVariableWithFunctionInit = (node) => {
+    if (node.type !== "VariableDeclaration") {
+        return false;
+    }
+    const { declarations } = node;
+    const initialized = declarations ?? [];
+    return initialized.some((declaration) => isFunctionExpression(declaration.init));
+};
+/**
+ * Checks if an export wraps a function-like declaration.
+ * @param node Node to inspect.
+ * @returns True when the exported declaration is function-like.
+ * @example
+ * ```typescript
+ * isExportedFunctionLike({ type: "ExportNamedDeclaration" } as EstreeNode);
+ * ```
+ */
+const isExportedFunctionLike = (node) => {
+    if (node.type !== "ExportNamedDeclaration" &&
+        node.type !== "ExportDefaultDeclaration") {
+        return false;
+    }
+    const { declaration } = node;
+    return isFunctionLikeNode(declaration);
+};
+/**
+ * Checks if a node represents any supported function-like declaration.
+ * @param node Node to inspect.
+ * @returns True when the node is function-like.
+ * @example
+ * ```typescript
+ * isFunctionLikeNode({ type: "FunctionDeclaration" } as EstreeNode);
+ * ```
+ */
+const isFunctionLikeNode = (node) => {
+    if (node === null || node === void 0) {
+        return false;
+    }
+    return (isFunctionDeclaration(node) ||
+        isFunctionExpression(node) ||
+        isMethodLike(node) ||
+        functionLikeTypes.has(node.type) ||
+        isPropertyWithFunctionValue(node) ||
+        isVariableWithFunctionInit(node) ||
+        isExportedFunctionLike(node));
+};
+/**
+ * Determines whether a JSDoc comment should be skipped for function targets.
+ * @param context Rule context.
+ * @param comment Comment node to inspect.
+ * @returns True when the comment targets a function-like node.
+ * @example
+ * ```typescript
+ * shouldSkipForFunction({} as Rule.RuleContext, {} as SourceComment);
+ * ```
+ */
+const shouldSkipForFunction = (context, comment) => {
+    const sourceCode = context.sourceCode;
+    if (typeof sourceCode.getNodeByRangeIndex !== "function") {
+        return false;
+    }
+    const tokenAfter = getTokenAfterRange(sourceCode, comment);
+    if (tokenAfter === void 0) {
+        return false;
+    }
+    const [rangeStart] = tokenAfter.range;
+    const node = sourceCode.getNodeByRangeIndex(rangeStart);
+    return isFunctionLikeNode(node);
+};
+/** Rule module enforcing single-line JSDoc when it fits. */
+export const singleLineJsdocRule = {
+    create(context) {
+        const { options, sourceCode } = context;
+        const maxLineLength = normalizeMaxLineLength(options);
+        const comments = sourceCode.getAllComments();
+        for (const comment of comments) {
+            if (!shouldSkipForFunction(context, comment)) {
+                reportIfSingleLine(context, comment, maxLineLength);
+            }
+        }
+        return {};
+    },
+    meta: {
+        defaultOptions: [{ maxLineLength: 80 }],
+        docs: {
+            description: "Require JSDoc comments to use a single line when they fit.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/single-line-jsdoc.md",
+        },
+        fixable: "code",
+        messages: {
+            singleLine: "Use a single-line JSDoc comment when it fits on one line.",
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    maxLineLength: {
+                        description: "Maximum line length that still allows a JSDoc block to be collapsed to a single line.",
+                        minimum: 1,
+                        type: "number",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "layout",
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/docs/single-line-jsdoc/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\nimport type { Comment as EstreeComment, Node as EstreeNode } from \"estree\";\n\nimport {\n  normalizeMaxLineLength,\n  reportIfSingleLine,\n} from \"./single-line-jsdoc-utilities\";\n\n/** Type union for nodes that may be missing. */\ntype MaybeNode = EstreeNode | NodeWithType | null | undefined;\n\n/** Shape for export nodes that wrap a declaration. */\ninterface NodeWithDeclaration {\n  /** Declaration wrapped by the export. */\n  declaration?: MaybeNode;\n}\n/** Shape for nodes that have declarations. */\ninterface NodeWithDeclarations {\n  /** Variable declarations for a declaration list. */\n  declarations?: VariableDeclarationEntry[];\n}\n/** Shape for minimal nodes that only expose a type. */\ninterface NodeWithType {\n  /** Node type discriminator. */\n  type: string;\n}\n/** Shape for nodes that have a value. */\ninterface NodeWithValue {\n  /** Value node used for property initializers. */\n  value?: MaybeNode;\n}\n/** SourceCode accessors used by this rule. */\ninterface SourceCodeAccess {\n  /** Returns the node at a range index. */\n  getNodeByRangeIndex: (index: number) => EstreeNode | null;\n  /** Returns the first token after a comment. */\n  getTokenAfter: (\n    node: EstreeComment,\n    options?: TokenAfterOptions,\n  ) => null | TokenWithOptionalRange;\n}\n/** Type alias for comment nodes provided by ESLint. */\ntype SourceComment = EstreeComment;\n/** Options used when fetching tokens after comments. */\ninterface TokenAfterOptions {\n  /** Whether to include comment tokens. */\n  includeComments?: boolean;\n}\n/** Shape for tokens that may include a range. */\ninterface TokenWithOptionalRange {\n  /** Token range used for lookups. */\n  range?: [number, number];\n}\n/** Shape for tokens with range metadata. */\ninterface TokenWithRange {\n  /** Token range used for lookups. */\n  range: [number, number];\n}\n/** Shape for variable declaration entries. */\ninterface VariableDeclarationEntry {\n  /** Optional initializer for the declaration. */\n  init?: MaybeNode;\n}\n\n/**\n * Resolves the token after a comment when available.\n * @param sourceCode Source code accessors.\n * @param comment Comment node to inspect.\n * @returns Token range metadata when available.\n * @example\n * ```typescript\n * getTokenAfterRange({} as SourceCodeAccess, {} as SourceComment);\n * ```\n */\nconst getTokenAfterRange = (\n  sourceCode: SourceCodeAccess,\n  comment: SourceComment,\n): TokenWithRange | undefined => {\n  if (typeof sourceCode.getTokenAfter !== \"function\") {\n    return void 0;\n  }\n\n  const tokenAfter = sourceCode.getTokenAfter(comment, {\n    includeComments: false,\n  });\n  if (tokenAfter?.range === void 0) {\n    return void 0;\n  }\n  return { range: tokenAfter.range };\n};\n\n/**\n * Function-like node types handled directly.\n * @example\n * ```typescript\n * functionLikeTypes.has(\"TSFunctionType\");\n * ```\n */\nconst functionLikeTypes = new Set<string>([\n  \"TSCallSignatureDeclaration\",\n  \"TSConstructSignatureDeclaration\",\n  \"TSFunctionType\",\n]);\n\n/**\n * Checks if a node is a function expression or arrow function.\n * @param node Node to inspect.\n * @returns True when the node is a function expression.\n * @example\n * ```typescript\n * isFunctionExpression({ type: \"FunctionExpression\" } as EstreeNode);\n * ```\n */\nconst isFunctionExpression = (node: MaybeNode): boolean =>\n  node?.type === \"FunctionExpression\" ||\n  node?.type === \"ArrowFunctionExpression\";\n\n/**\n * Checks if a node is a function declaration or TS declaration signature.\n * @param node Node to inspect.\n * @returns True when the node is a function declaration.\n * @example\n * ```typescript\n * isFunctionDeclaration({ type: \"FunctionDeclaration\" } as EstreeNode);\n * ```\n */\nconst isFunctionDeclaration = (node: MaybeNode): boolean =>\n  node?.type === \"FunctionDeclaration\" || node?.type === \"TSDeclareFunction\";\n\n/**\n * Checks if a node is a method-like declaration.\n * @param node Node to inspect.\n * @returns True when the node is a method-like declaration.\n * @example\n * ```typescript\n * isMethodLike({ type: \"MethodDefinition\" } as EstreeNode);\n * ```\n */\nconst isMethodLike = (node: MaybeNode): boolean =>\n  node?.type === \"MethodDefinition\" || node?.type === \"TSMethodSignature\";\n\n/**\n * Checks if a node is a property with a function initializer.\n * @param node Node to inspect.\n * @returns True when the property value is a function.\n * @example\n * ```typescript\n * isPropertyWithFunctionValue({ type: \"Property\" } as EstreeNode);\n * ```\n */\nconst isPropertyWithFunctionValue = (node: EstreeNode): boolean => {\n  if (node.type !== \"PropertyDefinition\" && node.type !== \"Property\") {\n    return false;\n  }\n\n  const { value } = node as NodeWithValue;\n  return isFunctionExpression(value);\n};\n\n/**\n * Checks if a variable declaration contains a function initializer.\n * @param node Node to inspect.\n * @returns True when any initializer is a function.\n * @example\n * ```typescript\n * isVariableWithFunctionInit({ type: \"VariableDeclaration\" } as EstreeNode);\n * ```\n */\nconst isVariableWithFunctionInit = (node: EstreeNode): boolean => {\n  if (node.type !== \"VariableDeclaration\") {\n    return false;\n  }\n\n  const { declarations } = node as NodeWithDeclarations;\n  const initialized = declarations ?? [];\n\n  return initialized.some((declaration) =>\n    isFunctionExpression(declaration.init),\n  );\n};\n\n/**\n * Checks if an export wraps a function-like declaration.\n * @param node Node to inspect.\n * @returns True when the exported declaration is function-like.\n * @example\n * ```typescript\n * isExportedFunctionLike({ type: \"ExportNamedDeclaration\" } as EstreeNode);\n * ```\n */\nconst isExportedFunctionLike = (node: EstreeNode): boolean => {\n  if (\n    node.type !== \"ExportNamedDeclaration\" &&\n    node.type !== \"ExportDefaultDeclaration\"\n  ) {\n    return false;\n  }\n\n  const { declaration } = node as NodeWithDeclaration;\n\n  return isFunctionLikeNode(declaration);\n};\n\n/**\n * Checks if a node represents any supported function-like declaration.\n * @param node Node to inspect.\n * @returns True when the node is function-like.\n * @example\n * ```typescript\n * isFunctionLikeNode({ type: \"FunctionDeclaration\" } as EstreeNode);\n * ```\n */\nconst isFunctionLikeNode = (node: MaybeNode): boolean => {\n  if (node === null || node === void 0) {\n    return false;\n  }\n\n  return (\n    isFunctionDeclaration(node) ||\n    isFunctionExpression(node) ||\n    isMethodLike(node) ||\n    functionLikeTypes.has(node.type) ||\n    isPropertyWithFunctionValue(node as EstreeNode) ||\n    isVariableWithFunctionInit(node as EstreeNode) ||\n    isExportedFunctionLike(node as EstreeNode)\n  );\n};\n\n/**\n * Determines whether a JSDoc comment should be skipped for function targets.\n * @param context Rule context.\n * @param comment Comment node to inspect.\n * @returns True when the comment targets a function-like node.\n * @example\n * ```typescript\n * shouldSkipForFunction({} as Rule.RuleContext, {} as SourceComment);\n * ```\n */\nconst shouldSkipForFunction = (\n  context: Rule.RuleContext,\n  comment: SourceComment,\n): boolean => {\n  const sourceCode = context.sourceCode as SourceCodeAccess;\n  if (typeof sourceCode.getNodeByRangeIndex !== \"function\") {\n    return false;\n  }\n\n  const tokenAfter = getTokenAfterRange(sourceCode, comment);\n  if (tokenAfter === void 0) {\n    return false;\n  }\n\n  const [rangeStart] = tokenAfter.range;\n  const node = sourceCode.getNodeByRangeIndex(rangeStart);\n  return isFunctionLikeNode(node);\n};\n\n/** Rule module enforcing single-line JSDoc when it fits. */\nexport const singleLineJsdocRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    const { options, sourceCode } = context;\n    const maxLineLength = normalizeMaxLineLength(options);\n    const comments = sourceCode.getAllComments();\n\n    for (const comment of comments) {\n      if (!shouldSkipForFunction(context, comment)) {\n        reportIfSingleLine(context, comment, maxLineLength);\n      }\n    }\n\n    return {};\n  },\n  meta: {\n    defaultOptions: [{ maxLineLength: 80 }],\n    docs: {\n      description: \"Require JSDoc comments to use a single line when they fit.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/single-line-jsdoc.md\",\n    },\n    fixable: \"code\",\n    messages: {\n      singleLine: \"Use a single-line JSDoc comment when it fits on one line.\",\n    },\n    schema: [\n      {\n        additionalProperties: false,\n        properties: {\n          maxLineLength: {\n            description:\n              \"Maximum line length that still allows a JSDoc block to be collapsed to a single line.\",\n            minimum: 1,\n            type: \"number\",\n          },\n        },\n        type: \"object\",\n      },\n    ],\n    type: \"layout\",\n  },\n};\n"]}

package/dist/domain/docs/single-line-jsdoc/rule.node-lookups.d.ts

@@ -0,0 +1,4 @@
+/** Companion module for single-line-jsdoc lookup edge-case tests. */
+declare const singleLineJsdocRuleNodeLookups: import("eslint").Rule.RuleModule;
+export { singleLineJsdocRuleNodeLookups };
+//# sourceMappingURL=rule.node-lookups.d.ts.map

package/dist/domain/docs/single-line-jsdoc/rule.node-lookups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.node-lookups.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/single-line-jsdoc/rule.node-lookups.ts"],"names":[],"mappings":"AAEA,qEAAqE;AACrE,QAAA,MAAM,8BAA8B,kCAAsB,CAAC;AAE3D,OAAO,EAAE,8BAA8B,EAAE,CAAC"}

package/dist/domain/docs/single-line-jsdoc/rule.node-lookups.js

@@ -0,0 +1,5 @@
+import { singleLineJsdocRule } from "./rule.js";
+/** Companion module for single-line-jsdoc lookup edge-case tests. */
+const singleLineJsdocRuleNodeLookups = singleLineJsdocRule;
+export { singleLineJsdocRuleNodeLookups };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5ub2RlLWxvb2t1cHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL2RvY3Mvc2luZ2xlLWxpbmUtanNkb2MvcnVsZS5ub2RlLWxvb2t1cHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sUUFBUSxDQUFDO0FBRTdDLHFFQUFxRTtBQUNyRSxNQUFNLDhCQUE4QixHQUFHLG1CQUFtQixDQUFDO0FBRTNELE9BQU8sRUFBRSw4QkFBOEIsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgc2luZ2xlTGluZUpzZG9jUnVsZSB9IGZyb20gXCIuL3J1bGVcIjtcclxuXHJcbi8qKiBDb21wYW5pb24gbW9kdWxlIGZvciBzaW5nbGUtbGluZS1qc2RvYyBsb29rdXAgZWRnZS1jYXNlIHRlc3RzLiAqL1xyXG5jb25zdCBzaW5nbGVMaW5lSnNkb2NSdWxlTm9kZUxvb2t1cHMgPSBzaW5nbGVMaW5lSnNkb2NSdWxlO1xyXG5cclxuZXhwb3J0IHsgc2luZ2xlTGluZUpzZG9jUnVsZU5vZGVMb29rdXBzIH07XHJcbiJdfQ==

package/dist/domain/docs/single-line-jsdoc/single-line-jsdoc-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-line-jsdoc-content.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/single-line-jsdoc/single-line-jsdoc-content.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,qCAAqC;AACrC,KAAK,OAAO,GAAG,UAAU,CACvB,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,gBAAgB,CAAC,CACjD,CAAC,MAAM,CAAC,CAAC;AAyFV;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB,GAAI,SAAS,OAAO,KAAG,MAAM,GAAG,SAYxD,CAAC;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAC/B,YAAY,EAAE,OAAO,EAAE,CAAC"}

package/dist/domain/docs/single-line-jsdoc/single-line-jsdoc-content.js

@@ -0,0 +1,95 @@
+/**
+ * Defines stripJsdocLine.
+ * @param line Input line value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * stripJsdocLine();
+ * ```
+ */
+const stripJsdocLine = (line) => line.replace(/^\s*\*? ?/u, "").trimEnd();
+/**
+ * Defines trimEmptyEdges.
+ * @param lines Input lines value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * trimEmptyEdges();
+ * ```
+ */
+const trimEmptyEdges = (lines) => {
+    let start = 0;
+    let end = lines.length - 1;
+    while (start <= end && lines[start]?.length === 0) {
+        start += 1;
+    }
+    while (end >= start && lines[end]?.length === 0) {
+        end -= 1;
+    }
+    return lines.slice(start, end + 1);
+};
+/**
+ * Gets getContentLines.
+ * @param commentValue Input commentValue value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getContentLines();
+ * ```
+ */
+const getContentLines = (commentValue) => {
+    const lines = commentValue
+        .split(/\r?\n/u)
+        .map((line) => stripJsdocLine(line))
+        .map((line) => line.trim());
+    return trimEmptyEdges(lines);
+};
+/**
+ * Checks shouldSkipContent.
+ * @param lines Input lines value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * shouldSkipContent();
+ * ```
+ */
+const shouldSkipContent = (lines) => {
+    if (lines.length === 0) {
+        return true;
+    }
+    if (lines.some((line) => line.length === 0)) {
+        return true;
+    }
+    return lines.some((line) => line.startsWith("@"));
+};
+/**
+ * Defines collapseContent.
+ * @param lines Input lines value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * collapseContent();
+ * ```
+ */
+const collapseContent = (lines) => lines.join(" ").replaceAll(/\s+/gu, " ").trim();
+/**
+ * Gets getCollapsedContent.
+ * @param comment Input comment value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getCollapsedContent();
+ * ```
+ */
+const getCollapsedContent = (comment) => {
+    const contentLines = getContentLines(comment.value);
+    if (shouldSkipContent(contentLines)) {
+        return void 0;
+    }
+    if (contentLines.length !== 1) {
+        return void 0;
+    }
+    return collapseContent(contentLines);
+};
+export { getCollapsedContent };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{docs → domain/docs}/single-line-jsdoc/single-line-jsdoc-utilities.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from "eslint";
-import type { Comment } from "./single-line-jsdoc-content";
+import type { Comment } from "./single-line-jsdoc-content.js";
 /**
  * Normalizes normalizeMaxLineLength.
  * @param options Input options value.

package/dist/domain/docs/single-line-jsdoc/single-line-jsdoc-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-line-jsdoc-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/single-line-jsdoc/single-line-jsdoc-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAa3D;;;;;;;;GAQG;AACH,QAAA,MAAM,sBAAsB,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,MAU7D,CAAC;AAiHF;;;;;;;;;GASG;AACH,QAAA,MAAM,kBAAkB,GACtB,SAAS,IAAI,CAAC,WAAW,EACzB,SAAS,OAAO,EAChB,eAAe,MAAM,KACpB,IAsBF,CAAC;AAEF,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/domain/docs/single-line-jsdoc/single-line-jsdoc-utilities.js

@@ -0,0 +1,140 @@
+import { getCollapsedContent } from "./single-line-jsdoc-content.js";
+/** Default value used by this module. */
+const DEFAULT_MAX_LINE_LENGTH = 80;
+/**
+ * Normalizes normalizeMaxLineLength.
+ * @param options Input options value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * normalizeMaxLineLength();
+ * ```
+ */
+const normalizeMaxLineLength = (options) => {
+    const rawOptions = options[0];
+    const maxLineLength = rawOptions?.maxLineLength;
+    if (typeof maxLineLength === "number" && Number.isFinite(maxLineLength)) {
+        const normalized = Math.floor(maxLineLength);
+        return normalized > 0 ? normalized : DEFAULT_MAX_LINE_LENGTH;
+    }
+    return DEFAULT_MAX_LINE_LENGTH;
+};
+/**
+ * Checks isMultilineComment.
+ * @param comment Input comment value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isMultilineComment();
+ * ```
+ */
+const isMultilineComment = (comment) => {
+    const { loc, value } = comment;
+    if (loc === null || loc === void 0) {
+        return /\r|\n/u.test(value);
+    }
+    return loc.start.line !== loc.end.line;
+};
+/**
+ * Build a single-line JSDoc string from content.
+ * @param content Input content value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const text = buildSingleLineText("ok");
+ * ```
+ */
+const buildSingleLineText = (content) => `/** ${content} */`;
+/**
+ * Creates a fixer for replacing a JSDoc range.
+ * @param range Input range value.
+ * @param replacementText Input replacementText value.
+ * @returns Fixer function for ESLint.
+ * @example
+ * ```typescript
+ * const fixer = createFix([0, 1], "/** ok *\\/");
+ * ```
+ */
+const createFix = (range, replacementText) => {
+    return (fixer) => fixer.replaceTextRange(range, replacementText);
+};
+/**
+ * Checks isJsdocComment.
+ * @param comment Input comment value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isJsdocComment();
+ * ```
+ */
+const isJsdocComment = (comment) => comment.type === "Block" && comment.value.startsWith("*");
+/**
+ * Gets getStartColumn.
+ * @param comment Input comment value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getStartColumn();
+ * ```
+ */
+const getStartColumn = (comment) => {
+    const { loc } = comment;
+    if (loc === null || loc === void 0) {
+        return void 0;
+    }
+    return loc.start.column;
+};
+/**
+ * Builds a single-line replacement when it fits.
+ * @param comment Input comment value.
+ * @param maxLineLength Input maxLineLength value.
+ * @returns Replacement text when available.
+ * @example
+ * ```typescript
+ * const text = getSingleLineReplacement(comment, 80);
+ * ```
+ */
+const getSingleLineReplacement = (comment, maxLineLength) => {
+    if (!isMultilineComment(comment)) {
+        return void 0;
+    }
+    const content = getCollapsedContent(comment);
+    const startColumn = getStartColumn(comment);
+    if (content === void 0 || startColumn === void 0) {
+        return void 0;
+    }
+    const singleLineText = buildSingleLineText(content);
+    return startColumn + singleLineText.length > maxLineLength
+        ? void 0
+        : singleLineText;
+};
+/**
+ * Reports a comment when it can be collapsed to a single line.
+ * @param context Input context value.
+ * @param comment Input comment value.
+ * @param maxLineLength Input maxLineLength value.
+ * @example
+ * ```typescript
+ * reportIfSingleLine(context, comment, 80);
+ * ```
+ */
+const reportIfSingleLine = (context, comment, maxLineLength) => {
+    if (!isJsdocComment(comment)) {
+        return;
+    }
+    const singleLineText = getSingleLineReplacement(comment, maxLineLength);
+    if (singleLineText === void 0) {
+        return;
+    }
+    const { loc, range } = comment;
+    if (loc === null || loc === void 0 || range === void 0) {
+        return;
+    }
+    context.report({
+        fix: createFix(range, singleLineText),
+        loc,
+        messageId: "singleLine",
+    });
+};
+export { normalizeMaxLineLength, reportIfSingleLine };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"single-line-jsdoc-utilities.js","sourceRoot":"","sources":["../../../../src/domain/docs/single-line-jsdoc/single-line-jsdoc-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { Comment } from \"./single-line-jsdoc-content\";\n\nimport { getCollapsedContent } from \"./single-line-jsdoc-content\";\n\n/** Default value used by this module. */\nconst DEFAULT_MAX_LINE_LENGTH = 80;\n\n/** Type definition for rule data. */\ninterface SingleLineJsdocOptions {\n  /** MaxLineLength helper value. */\n  maxLineLength?: number;\n}\n\n/**\n * Normalizes normalizeMaxLineLength.\n * @param options Input options value.\n * @returns Return value output.\n * @example\n * ```typescript\n * normalizeMaxLineLength();\n * ```\n */\nconst normalizeMaxLineLength = (options: readonly unknown[]): number => {\n  const rawOptions = options[0] as SingleLineJsdocOptions | undefined;\n  const maxLineLength = rawOptions?.maxLineLength;\n\n  if (typeof maxLineLength === \"number\" && Number.isFinite(maxLineLength)) {\n    const normalized = Math.floor(maxLineLength);\n    return normalized > 0 ? normalized : DEFAULT_MAX_LINE_LENGTH;\n  }\n\n  return DEFAULT_MAX_LINE_LENGTH;\n};\n\n/**\n * Checks isMultilineComment.\n * @param comment Input comment value.\n * @returns Return value output.\n * @example\n * ```typescript\n * isMultilineComment();\n * ```\n */\nconst isMultilineComment = (comment: Comment): boolean => {\n  const { loc, value } = comment;\n\n  if (loc === null || loc === void 0) {\n    return /\\r|\\n/u.test(value);\n  }\n\n  return loc.start.line !== loc.end.line;\n};\n\n/**\n * Build a single-line JSDoc string from content.\n * @param content Input content value.\n * @returns Return value output.\n * @example\n * ```typescript\n * const text = buildSingleLineText(\"ok\");\n * ```\n */\nconst buildSingleLineText = (content: string): string => `/** ${content} */`;\n\n/**\n * Creates a fixer for replacing a JSDoc range.\n * @param range Input range value.\n * @param replacementText Input replacementText value.\n * @returns Fixer function for ESLint.\n * @example\n * ```typescript\n * const fixer = createFix([0, 1], \"/** ok *\\\\/\");\n * ```\n */\nconst createFix = (\n  range: [number, number],\n  replacementText: string,\n): Rule.ReportFixer => {\n  return (fixer: Rule.RuleFixer): Rule.Fix =>\n    fixer.replaceTextRange(range, replacementText);\n};\n\n/**\n * Checks isJsdocComment.\n * @param comment Input comment value.\n * @returns Return value output.\n * @example\n * ```typescript\n * isJsdocComment();\n * ```\n */\nconst isJsdocComment = (comment: Comment): boolean =>\n  comment.type === \"Block\" && comment.value.startsWith(\"*\");\n\n/**\n * Gets getStartColumn.\n * @param comment Input comment value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getStartColumn();\n * ```\n */\nconst getStartColumn = (comment: Comment): number | undefined => {\n  const { loc } = comment;\n\n  if (loc === null || loc === void 0) {\n    return void 0;\n  }\n\n  return loc.start.column;\n};\n\n/**\n * Builds a single-line replacement when it fits.\n * @param comment Input comment value.\n * @param maxLineLength Input maxLineLength value.\n * @returns Replacement text when available.\n * @example\n * ```typescript\n * const text = getSingleLineReplacement(comment, 80);\n * ```\n */\nconst getSingleLineReplacement = (\n  comment: Comment,\n  maxLineLength: number,\n): string | undefined => {\n  if (!isMultilineComment(comment)) {\n    return void 0;\n  }\n\n  const content = getCollapsedContent(comment);\n  const startColumn = getStartColumn(comment);\n\n  if (content === void 0 || startColumn === void 0) {\n    return void 0;\n  }\n\n  const singleLineText = buildSingleLineText(content);\n\n  return startColumn + singleLineText.length > maxLineLength\n    ? void 0\n    : singleLineText;\n};\n\n/**\n * Reports a comment when it can be collapsed to a single line.\n * @param context Input context value.\n * @param comment Input comment value.\n * @param maxLineLength Input maxLineLength value.\n * @example\n * ```typescript\n * reportIfSingleLine(context, comment, 80);\n * ```\n */\nconst reportIfSingleLine = (\n  context: Rule.RuleContext,\n  comment: Comment,\n  maxLineLength: number,\n): void => {\n  if (!isJsdocComment(comment)) {\n    return;\n  }\n\n  const singleLineText = getSingleLineReplacement(comment, maxLineLength);\n\n  if (singleLineText === void 0) {\n    return;\n  }\n\n  const { loc, range } = comment;\n\n  if (loc === null || loc === void 0 || range === void 0) {\n    return;\n  }\n\n  context.report({\n    fix: createFix(range, singleLineText),\n    loc,\n    messageId: \"singleLine\",\n  });\n};\n\nexport { normalizeMaxLineLength, reportIfSingleLine };\n"]}

package/dist/domain/docs/test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../../src/domain/docs/test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,qCAAqC;AACrC,UAAU,cAAc;IACtB,wBAAwB;IACxB,GAAG,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;CAC3C;AAED,qCAAqC;AACrC,KAAK,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,CAAC;AAE7D;;;;;;;GAOG;AACH,QAAA,MAAM,WAAW,QAAO,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAqBpD,CAAC;AAcH;;;;;;;;GAQG;AACH,QAAA,MAAM,UAAU,GAAI,YAAY,SAAS,KAAG,MAAM,GAAG,SASpD,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,QAAQ,GAAI,SAAS,cAAc,EAAE,KAAG,IAAI,CAAC,GAAG,EAiBrD,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,UAAU,GAAI,YAAY,MAAM,EAAE,OAAO,IAAI,CAAC,GAAG,EAAE,KAAG,MAgB3D,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC"}

package/dist/domain/docs/test-helpers.js

@@ -0,0 +1,107 @@
+/**
+ * Creates createFixer.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createFixer();
+ * ```
+ */
+const createFixer = () => ({
+    insertTextAfter: (syntaxElement, text) => {
+        void syntaxElement;
+        return { range: [0, 0], text };
+    },
+    insertTextAfterRange: (range, text) => ({ range, text }),
+    insertTextBefore: (syntaxElement, text) => {
+        void syntaxElement;
+        return { range: [0, 0], text };
+    },
+    insertTextBeforeRange: (range, text) => ({ range, text }),
+    remove: (syntaxElement) => {
+        void syntaxElement;
+        return { range: [0, 0], text: "" };
+    },
+    removeRange: (range) => ({ range, text: "" }),
+    replaceText: (syntaxElement, text) => {
+        void syntaxElement;
+        return { range: [0, 0], text };
+    },
+    replaceTextRange: (range, text) => ({ range, text }),
+});
+/**
+ * Checks isFixIterable.
+ * @param fixResult Input fixResult value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isFixIterable();
+ * ```
+ */
+const isFixIterable = (fixResult) => Symbol.iterator in fixResult;
+/**
+ * Gets getFixText.
+ * @param fixResult Input fixResult value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getFixText();
+ * ```
+ */
+const getFixText = (fixResult) => {
+    if (fixResult === void 0) {
+        return void 0;
+    }
+    if (isFixIterable(fixResult)) {
+        return [...fixResult][0]?.text;
+    }
+    return fixResult.text;
+};
+/**
+ * Gets getFixes.
+ * @param reports Input reports value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getFixes();
+ * ```
+ */
+const getFixes = (reports) => {
+    const fixer = createFixer();
+    const fixes = [];
+    for (const report of reports) {
+        const fixResult = report.fix?.(fixer) ?? void 0;
+        if (fixResult !== void 0) {
+            if (isFixIterable(fixResult)) {
+                fixes.push(...fixResult);
+            }
+            else {
+                fixes.push(fixResult);
+            }
+        }
+    }
+    return fixes;
+};
+/**
+ * Applies applyFixes.
+ * @param sourceText Input sourceText value.
+ * @param fixes Input fixes value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * applyFixes();
+ * ```
+ */
+const applyFixes = (sourceText, fixes) => {
+    const sorted = fixes.toSorted((left, right) => right.range[0] - left.range[0]);
+    let output = sourceText;
+    for (const fix of sorted) {
+        output = [
+            output.slice(0, fix.range[0]),
+            fix.text,
+            output.slice(fix.range[1]),
+        ].join("");
+    }
+    return output;
+};
+export { applyFixes, createFixer, getFixes, getFixText };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC1oZWxwZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2RvbWFpbi9kb2NzL3Rlc3QtaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFXQTs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxXQUFXLEdBQUcsR0FBb0MsRUFBRSxDQUFDLENBQUM7SUFDMUQsZUFBZSxFQUFFLENBQUMsYUFBYSxFQUFFLElBQUksRUFBWSxFQUFFO1FBQ2pELEtBQUssYUFBYSxDQUFDO1FBQ25CLE9BQU8sRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLENBQUM7SUFDakMsQ0FBQztJQUNELG9CQUFvQixFQUFFLENBQUMsS0FBSyxFQUFFLElBQUksRUFBWSxFQUFFLENBQUMsQ0FBQyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsQ0FBQztJQUNsRSxnQkFBZ0IsRUFBRSxDQUFDLGFBQWEsRUFBRSxJQUFJLEVBQVksRUFBRTtRQUNsRCxLQUFLLGFBQWEsQ0FBQztRQUNuQixPQUFPLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLElBQUksRUFBRSxDQUFDO0lBQ2pDLENBQUM7SUFDRCxxQkFBcUIsRUFBRSxDQUFDLEtBQUssRUFBRSxJQUFJLEVBQVksRUFBRSxDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUM7SUFDbkUsTUFBTSxFQUFFLENBQUMsYUFBYSxFQUFZLEVBQUU7UUFDbEMsS0FBSyxhQUFhLENBQUM7UUFDbkIsT0FBTyxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLENBQUM7SUFDckMsQ0FBQztJQUNELFdBQVcsRUFBRSxDQUFDLEtBQUssRUFBWSxFQUFFLENBQUMsQ0FBQyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLENBQUM7SUFDdkQsV0FBVyxFQUFFLENBQUMsYUFBYSxFQUFFLElBQUksRUFBWSxFQUFFO1FBQzdDLEtBQUssYUFBYSxDQUFDO1FBQ25CLE9BQU8sRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLENBQUM7SUFDakMsQ0FBQztJQUNELGdCQUFnQixFQUFFLENBQUMsS0FBSyxFQUFFLElBQUksRUFBWSxFQUFFLENBQUMsQ0FBQyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsQ0FBQztDQUMvRCxDQUFDLENBQUM7QUFFSDs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sYUFBYSxHQUFHLENBQUMsU0FBb0IsRUFBbUMsRUFBRSxDQUM5RSxNQUFNLENBQUMsUUFBUSxJQUFJLFNBQVMsQ0FBQztBQUUvQjs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sVUFBVSxHQUFHLENBQUMsU0FBcUIsRUFBc0IsRUFBRTtJQUMvRCxJQUFJLFNBQVMsS0FBSyxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3pCLE9BQU8sS0FBSyxDQUFDLENBQUM7SUFDaEIsQ0FBQztJQUNELElBQUksYUFBYSxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUM7UUFDN0IsT0FBTyxDQUFDLEdBQUcsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsSUFBSSxDQUFDO0lBQ2pDLENBQUM7SUFFRCxPQUFPLFNBQVMsQ0FBQyxJQUFJLENBQUM7QUFDeEIsQ0FBQyxDQUFDO0FBRUY7Ozs7Ozs7O0dBUUc7QUFDSCxNQUFNLFFBQVEsR0FBRyxDQUFDLE9BQXlCLEVBQWMsRUFBRTtJQUN6RCxNQUFNLEtBQUssR0FBRyxXQUFXLEVBQUUsQ0FBQztJQUM1QixNQUFNLEtBQUssR0FBZSxFQUFFLENBQUM7SUFFN0IsS0FBSyxNQUFNLE1BQU0sSUFBSSxPQUFPLEVBQUUsQ0FBQztRQUM3QixNQUFNLFNBQVMsR0FBRyxNQUFNLENBQUMsR0FBRyxFQUFFLENBQUMsS0FBSyxDQUFDLElBQUksS0FBSyxDQUFDLENBQUM7UUFFaEQsSUFBSSxTQUFTLEtBQUssS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUN6QixJQUFJLGFBQWEsQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDO2dCQUM3QixLQUFLLENBQUMsSUFBSSxDQUFDLEdBQUcsU0FBUyxDQUFDLENBQUM7WUFDM0IsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLEtBQUssQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7WUFDeEIsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0lBRUQsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDLENBQUM7QUFFRjs7Ozs7Ozs7O0dBU0c7QUFDSCxNQUFNLFVBQVUsR0FBRyxDQUFDLFVBQWtCLEVBQUUsS0FBaUIsRUFBVSxFQUFFO0lBQ25FLE1BQU0sTUFBTSxHQUFHLEtBQUssQ0FBQyxRQUFRLENBQzNCLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRSxFQUFFLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUNoRCxDQUFDO0lBRUYsSUFBSSxNQUFNLEdBQUcsVUFBVSxDQUFDO0lBRXhCLEtBQUssTUFBTSxHQUFHLElBQUksTUFBTSxFQUFFLENBQUM7UUFDekIsTUFBTSxHQUFHO1lBQ1AsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUM3QixHQUFHLENBQUMsSUFBSTtZQUNSLE1BQU0sQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQztTQUMzQixDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUNiLENBQUM7SUFFRCxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDLENBQUM7QUFFRixPQUFPLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxRQUFRLEVBQUUsVUFBVSxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFJ1bGUgfSBmcm9tIFwiZXNsaW50XCI7XG5cbi8qKiBUeXBlIGRlZmluaXRpb24gZm9yIHJ1bGUgZGF0YS4gKi9cbmludGVyZmFjZSBGaXhSZXBvcnRFbnRyeSB7XG4gIC8qKiBGaXggaGVscGVyIHZhbHVlLiAqL1xuICBmaXg/OiBudWxsIHwgUnVsZS5SZXBvcnRGaXhlciB8IHVuZGVmaW5lZDtcbn1cblxuLyoqIFR5cGUgZGVmaW5pdGlvbiBmb3IgcnVsZSBkYXRhLiAqL1xudHlwZSBGaXhSZXN1bHQgPSBFeGNsdWRlPFJldHVyblR5cGU8UnVsZS5SZXBvcnRGaXhlcj4sIG51bGw+O1xuXG4vKipcbiAqIENyZWF0ZXMgY3JlYXRlRml4ZXIuXG4gKiBAcmV0dXJucyBSZXR1cm4gdmFsdWUgb3V0cHV0LlxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIGNyZWF0ZUZpeGVyKCk7XG4gKiBgYGBcbiAqL1xuY29uc3QgY3JlYXRlRml4ZXIgPSAoKTogUGFyYW1ldGVyczxSdWxlLlJlcG9ydEZpeGVyPlswXSA9PiAoe1xuICBpbnNlcnRUZXh0QWZ0ZXI6IChzeW50YXhFbGVtZW50LCB0ZXh0KTogUnVsZS5GaXggPT4ge1xuICAgIHZvaWQgc3ludGF4RWxlbWVudDtcbiAgICByZXR1cm4geyByYW5nZTogWzAsIDBdLCB0ZXh0IH07XG4gIH0sXG4gIGluc2VydFRleHRBZnRlclJhbmdlOiAocmFuZ2UsIHRleHQpOiBSdWxlLkZpeCA9PiAoeyByYW5nZSwgdGV4dCB9KSxcbiAgaW5zZXJ0VGV4dEJlZm9yZTogKHN5bnRheEVsZW1lbnQsIHRleHQpOiBSdWxlLkZpeCA9PiB7XG4gICAgdm9pZCBzeW50YXhFbGVtZW50O1xuICAgIHJldHVybiB7IHJhbmdlOiBbMCwgMF0sIHRleHQgfTtcbiAgfSxcbiAgaW5zZXJ0VGV4dEJlZm9yZVJhbmdlOiAocmFuZ2UsIHRleHQpOiBSdWxlLkZpeCA9PiAoeyByYW5nZSwgdGV4dCB9KSxcbiAgcmVtb3ZlOiAoc3ludGF4RWxlbWVudCk6IFJ1bGUuRml4ID0+IHtcbiAgICB2b2lkIHN5bnRheEVsZW1lbnQ7XG4gICAgcmV0dXJuIHsgcmFuZ2U6IFswLCAwXSwgdGV4dDogXCJcIiB9O1xuICB9LFxuICByZW1vdmVSYW5nZTogKHJhbmdlKTogUnVsZS5GaXggPT4gKHsgcmFuZ2UsIHRleHQ6IFwiXCIgfSksXG4gIHJlcGxhY2VUZXh0OiAoc3ludGF4RWxlbWVudCwgdGV4dCk6IFJ1bGUuRml4ID0+IHtcbiAgICB2b2lkIHN5bnRheEVsZW1lbnQ7XG4gICAgcmV0dXJuIHsgcmFuZ2U6IFswLCAwXSwgdGV4dCB9O1xuICB9LFxuICByZXBsYWNlVGV4dFJhbmdlOiAocmFuZ2UsIHRleHQpOiBSdWxlLkZpeCA9PiAoeyByYW5nZSwgdGV4dCB9KSxcbn0pO1xuXG4vKipcbiAqIENoZWNrcyBpc0ZpeEl0ZXJhYmxlLlxuICogQHBhcmFtIGZpeFJlc3VsdCBJbnB1dCBmaXhSZXN1bHQgdmFsdWUuXG4gKiBAcmV0dXJucyBSZXR1cm4gdmFsdWUgb3V0cHV0LlxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIGlzRml4SXRlcmFibGUoKTtcbiAqIGBgYFxuICovXG5jb25zdCBpc0ZpeEl0ZXJhYmxlID0gKGZpeFJlc3VsdDogRml4UmVzdWx0KTogZml4UmVzdWx0IGlzIEl0ZXJhYmxlPFJ1bGUuRml4PiA9PlxuICBTeW1ib2wuaXRlcmF0b3IgaW4gZml4UmVzdWx0O1xuXG4vKipcbiAqIEdldHMgZ2V0Rml4VGV4dC5cbiAqIEBwYXJhbSBmaXhSZXN1bHQgSW5wdXQgZml4UmVzdWx0IHZhbHVlLlxuICogQHJldHVybnMgUmV0dXJuIHZhbHVlIG91dHB1dC5cbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBnZXRGaXhUZXh0KCk7XG4gKiBgYGBcbiAqL1xuY29uc3QgZ2V0Rml4VGV4dCA9IChmaXhSZXN1bHQ/OiBGaXhSZXN1bHQpOiBzdHJpbmcgfCB1bmRlZmluZWQgPT4ge1xuICBpZiAoZml4UmVzdWx0ID09PSB2b2lkIDApIHtcbiAgICByZXR1cm4gdm9pZCAwO1xuICB9XG4gIGlmIChpc0ZpeEl0ZXJhYmxlKGZpeFJlc3VsdCkpIHtcbiAgICByZXR1cm4gWy4uLmZpeFJlc3VsdF1bMF0/LnRleHQ7XG4gIH1cblxuICByZXR1cm4gZml4UmVzdWx0LnRleHQ7XG59O1xuXG4vKipcbiAqIEdldHMgZ2V0Rml4ZXMuXG4gKiBAcGFyYW0gcmVwb3J0cyBJbnB1dCByZXBvcnRzIHZhbHVlLlxuICogQHJldHVybnMgUmV0dXJuIHZhbHVlIG91dHB1dC5cbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBnZXRGaXhlcygpO1xuICogYGBgXG4gKi9cbmNvbnN0IGdldEZpeGVzID0gKHJlcG9ydHM6IEZpeFJlcG9ydEVudHJ5W10pOiBSdWxlLkZpeFtdID0+IHtcbiAgY29uc3QgZml4ZXIgPSBjcmVhdGVGaXhlcigpO1xuICBjb25zdCBmaXhlczogUnVsZS5GaXhbXSA9IFtdO1xuXG4gIGZvciAoY29uc3QgcmVwb3J0IG9mIHJlcG9ydHMpIHtcbiAgICBjb25zdCBmaXhSZXN1bHQgPSByZXBvcnQuZml4Py4oZml4ZXIpID8/IHZvaWQgMDtcblxuICAgIGlmIChmaXhSZXN1bHQgIT09IHZvaWQgMCkge1xuICAgICAgaWYgKGlzRml4SXRlcmFibGUoZml4UmVzdWx0KSkge1xuICAgICAgICBmaXhlcy5wdXNoKC4uLmZpeFJlc3VsdCk7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICBmaXhlcy5wdXNoKGZpeFJlc3VsdCk7XG4gICAgICB9XG4gICAgfVxuICB9XG5cbiAgcmV0dXJuIGZpeGVzO1xufTtcblxuLyoqXG4gKiBBcHBsaWVzIGFwcGx5Rml4ZXMuXG4gKiBAcGFyYW0gc291cmNlVGV4dCBJbnB1dCBzb3VyY2VUZXh0IHZhbHVlLlxuICogQHBhcmFtIGZpeGVzIElucHV0IGZpeGVzIHZhbHVlLlxuICogQHJldHVybnMgUmV0dXJuIHZhbHVlIG91dHB1dC5cbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBhcHBseUZpeGVzKCk7XG4gKiBgYGBcbiAqL1xuY29uc3QgYXBwbHlGaXhlcyA9IChzb3VyY2VUZXh0OiBzdHJpbmcsIGZpeGVzOiBSdWxlLkZpeFtdKTogc3RyaW5nID0+IHtcbiAgY29uc3Qgc29ydGVkID0gZml4ZXMudG9Tb3J0ZWQoXG4gICAgKGxlZnQsIHJpZ2h0KSA9PiByaWdodC5yYW5nZVswXSAtIGxlZnQucmFuZ2VbMF0sXG4gICk7XG5cbiAgbGV0IG91dHB1dCA9IHNvdXJjZVRleHQ7XG5cbiAgZm9yIChjb25zdCBmaXggb2Ygc29ydGVkKSB7XG4gICAgb3V0cHV0ID0gW1xuICAgICAgb3V0cHV0LnNsaWNlKDAsIGZpeC5yYW5nZVswXSksXG4gICAgICBmaXgudGV4dCxcbiAgICAgIG91dHB1dC5zbGljZShmaXgucmFuZ2VbMV0pLFxuICAgIF0uam9pbihcIlwiKTtcbiAgfVxuXG4gIHJldHVybiBvdXRwdXQ7XG59O1xuXG5leHBvcnQgeyBhcHBseUZpeGVzLCBjcmVhdGVGaXhlciwgZ2V0Rml4ZXMsIGdldEZpeFRleHQgfTtcbiJdfQ==