@html-validate/commitlint-config 3.6.8 → 3.6.9

package/dist/commitlint.js

@@ -18,6 +18,9 @@ var __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? requir
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x2 + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -1968,6 +1971,465 @@ var require_semver2 = __commonJS({
   }
 });
 
+// node_modules/conventional-commits-parser/dist/types.js
+var init_types = __esm({
+  "node_modules/conventional-commits-parser/dist/types.js"() {
+  }
+});
+
+// node_modules/conventional-commits-parser/dist/regex.js
+function escape2(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function join(parts, joiner) {
+  return parts.map((val) => escape2(val.trim())).filter(Boolean).join(joiner);
+}
+function getNotesRegex(noteKeywords, notesPattern) {
+  if (!noteKeywords) {
+    return nomatchRegex;
+  }
+  const noteKeywordsSelection = join(noteKeywords, "|");
+  if (!notesPattern) {
+    return new RegExp(`^[\\s|*]*(${noteKeywordsSelection})[:\\s]+(.*)`, "i");
+  }
+  return notesPattern(noteKeywordsSelection);
+}
+function getReferencePartsRegex(issuePrefixes, issuePrefixesCaseSensitive) {
+  if (!issuePrefixes) {
+    return nomatchRegex;
+  }
+  const flags = issuePrefixesCaseSensitive ? "g" : "gi";
+  return new RegExp(`(?:.*?)??\\s*([\\w-\\.\\/]*?)??(${join(issuePrefixes, "|")})([\\w-]+)(?=\\s|$|[,;)\\]])`, flags);
+}
+function getReferencesRegex(referenceActions) {
+  if (!referenceActions) {
+    return /()(.+)/gi;
+  }
+  const joinedKeywords = join(referenceActions, "|");
+  return new RegExp(`(${joinedKeywords})(?:\\s+(.*?))(?=(?:${joinedKeywords})|$)`, "gi");
+}
+function getParserRegexes(options = {}) {
+  const notes = getNotesRegex(options.noteKeywords, options.notesPattern);
+  const referenceParts = getReferencePartsRegex(options.issuePrefixes, options.issuePrefixesCaseSensitive);
+  const references = getReferencesRegex(options.referenceActions);
+  return {
+    notes,
+    referenceParts,
+    references,
+    mentions: /@([\w-]+)/g,
+    url: /\b(?:https?):\/\/(?:www\.)?([-a-zA-Z0-9@:%_+.~#?&//=])+\b/
+  };
+}
+var nomatchRegex;
+var init_regex = __esm({
+  "node_modules/conventional-commits-parser/dist/regex.js"() {
+    nomatchRegex = /(?!.*)/;
+  }
+});
+
+// node_modules/conventional-commits-parser/dist/utils.js
+function trimNewLines(input) {
+  const matches = input.match(/[^\r\n]/);
+  if (typeof matches?.index !== "number") {
+    return "";
+  }
+  const firstIndex = matches.index;
+  let lastIndex = input.length - 1;
+  while (input[lastIndex] === "\r" || input[lastIndex] === "\n") {
+    lastIndex--;
+  }
+  return input.substring(firstIndex, lastIndex + 1);
+}
+function appendLine(src, line) {
+  return src ? `${src}
+${line || ""}` : line || "";
+}
+function getCommentFilter(char) {
+  return char ? (line) => !line.startsWith(char) : () => true;
+}
+function truncateToScissor(lines, commentChar) {
+  const scissorIndex = lines.indexOf(`${commentChar} ${SCISSOR}`);
+  if (scissorIndex === -1) {
+    return lines;
+  }
+  return lines.slice(0, scissorIndex);
+}
+function gpgFilter(line) {
+  return !line.match(/^\s*gpg:/);
+}
+function assignMatchedCorrespondence(target, matches, correspondence) {
+  const { groups } = matches;
+  for (let i2 = 0, len = correspondence.length, key; i2 < len; i2++) {
+    key = correspondence[i2];
+    target[key] = (groups ? groups[key] : matches[i2 + 1]) || null;
+  }
+  return target;
+}
+var SCISSOR;
+var init_utils = __esm({
+  "node_modules/conventional-commits-parser/dist/utils.js"() {
+    SCISSOR = "------------------------ >8 ------------------------";
+  }
+});
+
+// node_modules/conventional-commits-parser/dist/options.js
+var defaultOptions;
+var init_options = __esm({
+  "node_modules/conventional-commits-parser/dist/options.js"() {
+    defaultOptions = {
+      noteKeywords: ["BREAKING CHANGE", "BREAKING-CHANGE"],
+      issuePrefixes: ["#"],
+      referenceActions: [
+        "close",
+        "closes",
+        "closed",
+        "fix",
+        "fixes",
+        "fixed",
+        "resolve",
+        "resolves",
+        "resolved"
+      ],
+      headerPattern: /^(\w*)(?:\(([\w$@.\-*/ ]*)\))?: (.*)$/,
+      headerCorrespondence: [
+        "type",
+        "scope",
+        "subject"
+      ],
+      revertPattern: /^Revert\s"([\s\S]*)"\s*This reverts commit (\w*)\.?/,
+      revertCorrespondence: ["header", "hash"],
+      fieldPattern: /^-(.*?)-$/
+    };
+  }
+});
+
+// node_modules/conventional-commits-parser/dist/CommitParser.js
+function createCommitObject(initialData = {}) {
+  return {
+    merge: null,
+    revert: null,
+    header: null,
+    body: null,
+    footer: null,
+    notes: [],
+    mentions: [],
+    references: [],
+    ...initialData
+  };
+}
+var CommitParser;
+var init_CommitParser = __esm({
+  "node_modules/conventional-commits-parser/dist/CommitParser.js"() {
+    init_regex();
+    init_utils();
+    init_options();
+    CommitParser = class {
+      options;
+      regexes;
+      lines = [];
+      lineIndex = 0;
+      commit = createCommitObject();
+      constructor(options = {}) {
+        this.options = {
+          ...defaultOptions,
+          ...options
+        };
+        this.regexes = getParserRegexes(this.options);
+      }
+      currentLine() {
+        return this.lines[this.lineIndex];
+      }
+      nextLine() {
+        return this.lines[this.lineIndex++];
+      }
+      isLineAvailable() {
+        return this.lineIndex < this.lines.length;
+      }
+      parseReference(input, action) {
+        const { regexes } = this;
+        if (regexes.url.test(input)) {
+          return null;
+        }
+        const matches = regexes.referenceParts.exec(input);
+        if (!matches) {
+          return null;
+        }
+        let [raw, repository = null, prefix2, issue] = matches;
+        let owner = null;
+        if (repository) {
+          const slashIndex = repository.indexOf("/");
+          if (slashIndex !== -1) {
+            owner = repository.slice(0, slashIndex);
+            repository = repository.slice(slashIndex + 1);
+          }
+        }
+        return {
+          raw,
+          action,
+          owner,
+          repository,
+          prefix: prefix2,
+          issue
+        };
+      }
+      parseReferences(input) {
+        const { regexes } = this;
+        const regex = input.match(regexes.references) ? regexes.references : /()(.+)/gi;
+        const references = [];
+        let matches;
+        let action;
+        let sentence;
+        let reference;
+        while (true) {
+          matches = regex.exec(input);
+          if (!matches) {
+            break;
+          }
+          action = matches[1] || null;
+          sentence = matches[2] || "";
+          while (true) {
+            reference = this.parseReference(sentence, action);
+            if (!reference) {
+              break;
+            }
+            references.push(reference);
+          }
+        }
+        return references;
+      }
+      skipEmptyLines() {
+        let line = this.currentLine();
+        while (line !== void 0 && !line.trim()) {
+          this.nextLine();
+          line = this.currentLine();
+        }
+      }
+      parseMerge() {
+        const { commit, options } = this;
+        const correspondence = options.mergeCorrespondence || [];
+        const merge = this.currentLine();
+        const matches = merge && options.mergePattern ? merge.match(options.mergePattern) : null;
+        if (matches) {
+          this.nextLine();
+          commit.merge = matches[0] || null;
+          assignMatchedCorrespondence(commit, matches, correspondence);
+          return true;
+        }
+        return false;
+      }
+      parseHeader(isMergeCommit) {
+        if (isMergeCommit) {
+          this.skipEmptyLines();
+        }
+        const { commit, options } = this;
+        const correspondence = options.headerCorrespondence || [];
+        const header = commit.header ?? this.nextLine();
+        let matches = null;
+        if (header) {
+          if (options.breakingHeaderPattern) {
+            matches = header.match(options.breakingHeaderPattern);
+          }
+          if (!matches && options.headerPattern) {
+            matches = header.match(options.headerPattern);
+          }
+        }
+        if (header) {
+          commit.header = header;
+        }
+        if (matches) {
+          assignMatchedCorrespondence(commit, matches, correspondence);
+        }
+      }
+      parseMeta() {
+        const { options, commit } = this;
+        if (!options.fieldPattern || !this.isLineAvailable()) {
+          return false;
+        }
+        let matches;
+        let field = null;
+        let parsed = false;
+        while (this.isLineAvailable()) {
+          matches = this.currentLine().match(options.fieldPattern);
+          if (matches) {
+            field = matches[1] || null;
+            this.nextLine();
+            continue;
+          }
+          if (field) {
+            parsed = true;
+            commit[field] = appendLine(commit[field], this.currentLine());
+            this.nextLine();
+          } else {
+            break;
+          }
+        }
+        return parsed;
+      }
+      parseNotes() {
+        const { regexes, commit } = this;
+        if (!this.isLineAvailable()) {
+          return false;
+        }
+        const matches = this.currentLine().match(regexes.notes);
+        let references = [];
+        if (matches) {
+          const note = {
+            title: matches[1],
+            text: matches[2]
+          };
+          commit.notes.push(note);
+          commit.footer = appendLine(commit.footer, this.currentLine());
+          this.nextLine();
+          while (this.isLineAvailable()) {
+            if (this.parseMeta()) {
+              return true;
+            }
+            if (this.parseNotes()) {
+              return true;
+            }
+            references = this.parseReferences(this.currentLine());
+            if (references.length) {
+              commit.references.push(...references);
+            } else {
+              note.text = appendLine(note.text, this.currentLine());
+            }
+            commit.footer = appendLine(commit.footer, this.currentLine());
+            this.nextLine();
+            if (references.length) {
+              break;
+            }
+          }
+          return true;
+        }
+        return false;
+      }
+      parseBodyAndFooter(isBody) {
+        const { commit } = this;
+        if (!this.isLineAvailable()) {
+          return isBody;
+        }
+        const references = this.parseReferences(this.currentLine());
+        const isStillBody = !references.length && isBody;
+        if (isStillBody) {
+          commit.body = appendLine(commit.body, this.currentLine());
+        } else {
+          commit.references.push(...references);
+          commit.footer = appendLine(commit.footer, this.currentLine());
+        }
+        this.nextLine();
+        return isStillBody;
+      }
+      parseBreakingHeader() {
+        const { commit, options } = this;
+        if (!options.breakingHeaderPattern || commit.notes.length || !commit.header) {
+          return;
+        }
+        const matches = commit.header.match(options.breakingHeaderPattern);
+        if (matches) {
+          commit.notes.push({
+            title: "BREAKING CHANGE",
+            text: matches[3]
+          });
+        }
+      }
+      parseMentions(input) {
+        const { commit, regexes } = this;
+        let matches;
+        for (; ; ) {
+          matches = regexes.mentions.exec(input);
+          if (!matches) {
+            break;
+          }
+          commit.mentions.push(matches[1]);
+        }
+      }
+      parseRevert(input) {
+        const { commit, options } = this;
+        const correspondence = options.revertCorrespondence || [];
+        const matches = options.revertPattern ? input.match(options.revertPattern) : null;
+        if (matches) {
+          commit.revert = assignMatchedCorrespondence({}, matches, correspondence);
+        }
+      }
+      cleanupCommit() {
+        const { commit } = this;
+        if (commit.body) {
+          commit.body = trimNewLines(commit.body);
+        }
+        if (commit.footer) {
+          commit.footer = trimNewLines(commit.footer);
+        }
+        commit.notes.forEach((note) => {
+          note.text = trimNewLines(note.text);
+        });
+        const referencesSet = /* @__PURE__ */ new Set();
+        commit.references = commit.references.filter((reference) => {
+          const uid = `${reference.action} ${reference.raw}`.toLocaleLowerCase();
+          const ok = !referencesSet.has(uid);
+          if (ok) {
+            referencesSet.add(uid);
+          }
+          return ok;
+        });
+      }
+      /**
+       * Parse commit message string into an object.
+       * @param input - Commit message string.
+       * @returns Commit object.
+       */
+      parse(input) {
+        if (!input.trim()) {
+          throw new TypeError("Expected a raw commit");
+        }
+        const { commentChar } = this.options;
+        const commentFilter = getCommentFilter(commentChar);
+        const rawLines = trimNewLines(input).split(/\r?\n/);
+        const lines = commentChar ? truncateToScissor(rawLines, commentChar).filter((line) => commentFilter(line) && gpgFilter(line)) : rawLines.filter((line) => gpgFilter(line));
+        const commit = createCommitObject();
+        this.lines = lines;
+        this.lineIndex = 0;
+        this.commit = commit;
+        const isMergeCommit = this.parseMerge();
+        this.parseHeader(isMergeCommit);
+        if (commit.header) {
+          commit.references = this.parseReferences(commit.header);
+        }
+        let isBody = true;
+        while (this.isLineAvailable()) {
+          this.parseMeta();
+          if (this.parseNotes()) {
+            isBody = false;
+          }
+          if (!this.parseBodyAndFooter(isBody)) {
+            isBody = false;
+          }
+        }
+        this.parseBreakingHeader();
+        this.parseMentions(input);
+        this.parseRevert(input);
+        this.cleanupCommit();
+        return commit;
+      }
+    };
+  }
+});
+
+// node_modules/conventional-commits-parser/dist/stream.js
+var init_stream = __esm({
+  "node_modules/conventional-commits-parser/dist/stream.js"() {
+    init_CommitParser();
+  }
+});
+
+// node_modules/conventional-commits-parser/dist/index.js
+var init_dist = __esm({
+  "node_modules/conventional-commits-parser/dist/index.js"() {
+    init_types();
+    init_CommitParser();
+    init_stream();
+  }
+});
+
 // node_modules/array-ify/index.js
 var require_array_ify = __commonJS({
   "node_modules/array-ify/index.js"(exports, module) {
@@ -14976,7 +15438,7 @@ var require_util2 = __commonJS({
       return path11;
     }
     exports.normalize = normalize2;
-    function join(aRoot, aPath) {
+    function join2(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -15008,7 +15470,7 @@ var require_util2 = __commonJS({
       }
       return joined;
     }
-    exports.join = join;
+    exports.join = join2;
     exports.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -15181,7 +15643,7 @@ var require_util2 = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join(urlGenerate(parsed), sourceURL);
+        sourceURL = join2(urlGenerate(parsed), sourceURL);
       }
       return normalize2(sourceURL);
     }
@@ -31670,12 +32132,12 @@ ${lanes.join("\n")}
               }
             }
           });
-          forEach(decimalEscapes, (escape2) => {
-            if (escape2.value > numberOfCapturingGroups) {
+          forEach(decimalEscapes, (escape3) => {
+            if (escape3.value > numberOfCapturingGroups) {
               if (numberOfCapturingGroups) {
-                error2(Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_only_0_capturing_groups_in_this_regular_expression, escape2.pos, escape2.end - escape2.pos, numberOfCapturingGroups);
+                error2(Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_only_0_capturing_groups_in_this_regular_expression, escape3.pos, escape3.end - escape3.pos, numberOfCapturingGroups);
               } else {
-                error2(Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_no_capturing_groups_in_this_regular_expression, escape2.pos, escape2.end - escape2.pos);
+                error2(Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_no_capturing_groups_in_this_regular_expression, escape3.pos, escape3.end - escape3.pos);
               }
             }
           });
@@ -63867,19 +64329,19 @@ ${lanes.join("\n")}
           errors
         );
       }
-      function convertOptionsFromJson(optionsNameMap, jsonOptions, basePath, defaultOptions, diagnostics, errors) {
+      function convertOptionsFromJson(optionsNameMap, jsonOptions, basePath, defaultOptions2, diagnostics, errors) {
         if (!jsonOptions) {
           return;
         }
         for (const id in jsonOptions) {
           const opt = optionsNameMap.get(id);
           if (opt) {
-            (defaultOptions || (defaultOptions = {}))[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);
+            (defaultOptions2 || (defaultOptions2 = {}))[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);
           } else {
             errors.push(createUnknownOptionError(id, diagnostics));
           }
         }
-        return defaultOptions;
+        return defaultOptions2;
       }
       function createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, message2, ...args) {
         return sourceFile && node ? createDiagnosticForNodeInSourceFile(sourceFile, node, message2, ...args) : createCompilerDiagnostic(message2, ...args);
@@ -161033,22 +161495,22 @@ ${lanes.join("\n")}
         result.tscBuild = true;
         return result;
       }
-      function createSolutionBuilder(host, rootNames, defaultOptions) {
+      function createSolutionBuilder(host, rootNames, defaultOptions2) {
         return createSolutionBuilderWorker(
           /*watch*/
           false,
           host,
           rootNames,
-          defaultOptions
+          defaultOptions2
         );
       }
-      function createSolutionBuilderWithWatch(host, rootNames, defaultOptions, baseWatchOptions) {
+      function createSolutionBuilderWithWatch(host, rootNames, defaultOptions2, baseWatchOptions) {
         return createSolutionBuilderWorker(
           /*watch*/
           true,
           host,
           rootNames,
-          defaultOptions,
+          defaultOptions2,
           baseWatchOptions
         );
       }
@@ -172148,10 +172610,10 @@ interface Symbol {
         }));
         const diagnostics = [];
         const options = transpileOptions.compilerOptions ? fixupCompilerOptions(transpileOptions.compilerOptions, diagnostics) : {};
-        const defaultOptions = getDefaultCompilerOptions2();
-        for (const key in defaultOptions) {
-          if (hasProperty(defaultOptions, key) && options[key] === void 0) {
-            options[key] = defaultOptions[key];
+        const defaultOptions2 = getDefaultCompilerOptions2();
+        for (const key in defaultOptions2) {
+          if (hasProperty(defaultOptions2, key) && options[key] === void 0) {
+            options[key] = defaultOptions2[key];
           }
         }
         for (const option of transpileOptionValueCompilerOptions) {
@@ -234023,7 +234485,7 @@ function isIgnored(commit = "", opts = {}) {
 }
 
 // node_modules/@commitlint/parse/lib/index.js
-import { CommitParser } from "conventional-commits-parser";
+init_dist();
 
 // node_modules/conventional-changelog-angular/src/parser.js
 function createParserOpts() {
@@ -237355,7 +237817,7 @@ function output(process5) {
 }
 
 // node_modules/@conventional-changelog/git-client/dist/GitClient.js
-var SCISSOR = "------------------------ >8 ------------------------";
+var SCISSOR2 = "------------------------ >8 ------------------------";
 var GitClient = class {
   cwd;
   debug;
@@ -237414,8 +237876,8 @@ var GitClient = class {
   async *getRawCommits(params = {}) {
     const { path: path11, from = "", to = "HEAD", format: format4 = "%B", ignore, reverse, merges, since } = params;
     const shouldNotIgnore = ignore ? (chunk2) => !ignore.test(chunk2) : () => true;
-    const stdout = this.execStream("log", `--format=${format4}%n${SCISSOR}`, since && `--since=${since instanceof Date ? since.toISOString() : since}`, reverse && "--reverse", merges && "--merges", merges === false && "--no-merges", [from, to].filter(Boolean).join(".."), ...path11 ? ["--", ...toArray(path11)] : []);
-    const commitsStream = splitStream(stdout, `${SCISSOR}
+    const stdout = this.execStream("log", `--format=${format4}%n${SCISSOR2}`, since && `--since=${since instanceof Date ? since.toISOString() : since}`, reverse && "--reverse", merges && "--merges", merges === false && "--no-merges", [from, to].filter(Boolean).join(".."), ...path11 ? ["--", ...toArray(path11)] : []);
+    const commitsStream = splitStream(stdout, `${SCISSOR2}
 `);
     let chunk;
     for await (chunk of commitsStream) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@html-validate/commitlint-config",
-  "version": "3.6.8",
+  "version": "3.6.9",
   "description": "Commitlint sharable config used by the various HTML-validate packages",
   "keywords": [
     "commitlint"