@hosanna/chordpro 1.1.0

package/dist/chunk-6VAMM7S3.mjs

@@ -0,0 +1,388 @@
+// src/parser/txt-to-chordpro.ts
+var DEFAULT_OPTIONS = {
+  source: "auto",
+  detectSections: true,
+  strictChordDetection: true,
+  dehyphenateSyllables: "auto",
+  keepRepeatMarkers: true,
+  partTagNames: { start: "start_of_part", end: "end_of_part" }
+};
+var CHORD_ROOT = "(?:[A-G]|D[o\xF3]|R[e\xE9]|Mi|F[a\xE1]|Sol|L[a\xE1]|Si)";
+var CHORD_BODY = CHORD_ROOT + "(?:#|b)?(?:maj|min|m\\(maj7\\)|mM|m7b5|dim|aug|alt|\u0394|\xB0|\xF8|M|m|\\+|-)?(?:2|4|5|6\\/9|6|7|9|11|13)?(?:[Mm+])?(?:sus(?:2|4)?)?(?:add(?:2|4|6|9|11|13))?(?:(?:omit|no)(?:3|5))?(?:\\((?:[#b]?(?:5|9|11|13)|sus(?:2|4)?|add(?:2|4|9|11|13)|alt|omit(?:3|5)|no(?:3|5))(?:[,/]\\s*[#b]?(?:5|9|11|13))*\\))*(?:[#b](?:5|9|11|13))*(?:\\/" + CHORD_ROOT + "(?:#|b)?)?";
+var CHORD_TOKEN_REGEX = new RegExp(`^${CHORD_BODY}$`, "i");
+var NO_CHORD_TOKEN_REGEX = /^N\.?C\.?$/i;
+var CHORD_SCAN_REGEX = new RegExp(
+  `(?<=^|\\s)(${CHORD_BODY}|N\\.?C\\.?)(?=\\s|$)`,
+  "gi"
+);
+var PUNCTUATION_TOKENS = /* @__PURE__ */ new Set([
+  "|",
+  "%",
+  "-",
+  ".",
+  "...",
+  "/",
+  "x2",
+  "x3",
+  "x4",
+  "x5",
+  "x6",
+  "x7",
+  "x8",
+  "2x",
+  "3x",
+  "4x",
+  "5x",
+  "6x",
+  "7x",
+  "8x"
+]);
+function isValidChordToken(token) {
+  const clean = token.replace(/^[(]/, "").replace(/[)]$/, "");
+  return CHORD_TOKEN_REGEX.test(clean) || NO_CHORD_TOKEN_REGEX.test(clean);
+}
+function isChordLine(line, strict) {
+  const trimmed = line.trim();
+  if (!trimmed) return false;
+  const tokens = trimmed.split(/\s+/).filter((t) => !PUNCTUATION_TOKENS.has(t.toLowerCase()));
+  if (tokens.length === 0) return false;
+  const validCount = tokens.filter(isValidChordToken).length;
+  return strict ? validCount === tokens.length : validCount / tokens.length >= 0.8;
+}
+function isAlreadyInlineChordPro(line) {
+  const matches = [...line.matchAll(/\[([^\]]+)\]/g)];
+  if (matches.length === 0) return false;
+  return matches.every((m) => isValidChordToken(m[1]));
+}
+var METADATA_MAP = {
+  title: "title",
+  t: "title",
+  titulo: "title",
+  t\u00EDtulo: "title",
+  subtitle: "subtitle",
+  st: "subtitle",
+  artist: "artist",
+  a: "artist",
+  artista: "artist",
+  interprete: "artist",
+  int\u00E9rprete: "artist",
+  composer: "composer",
+  music: "composer",
+  compositor: "composer",
+  lyricist: "lyricist",
+  words: "lyricist",
+  letra: "lyricist",
+  letrista: "lyricist",
+  album: "album",
+  \u00E1lbum: "album",
+  key: "key",
+  tom: "key",
+  capo: "capo",
+  capotraste: "capo",
+  capodastro: "capo",
+  tuning: "tuning",
+  afinacao: "tuning",
+  afina\u00E7\u00E3o: "tuning",
+  tempo: "tempo",
+  andamento: "tempo",
+  bpm: "tempo",
+  time: "time",
+  compasso: "time",
+  year: "year",
+  ano: "year",
+  copyright: "copyright",
+  duration: "duration",
+  duracao: "duration",
+  dura\u00E7\u00E3o: "duration"
+};
+function stripAccents(s) {
+  return s.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+var SECTION_KEYWORDS = {
+  verse: ["verso", "verse"],
+  chorus: ["refrao", "chorus", "coro"],
+  bridge: [
+    "ponte",
+    "bridge",
+    "pre-refrao",
+    "prerefrao",
+    "prechorus",
+    "pre chorus",
+    "pre-chorus"
+  ],
+  part: [
+    "intro",
+    "introducao",
+    "introducao1",
+    "outro",
+    "final",
+    "coda",
+    "instrumental",
+    "interlude",
+    "interludio",
+    "solo",
+    "solo de guitarra",
+    "solo de violao",
+    "riff"
+  ]
+};
+var SECTION_TAGS = {
+  verse: { start: "start_of_verse", end: "end_of_verse" },
+  chorus: { start: "start_of_chorus", end: "end_of_chorus" },
+  bridge: { start: "start_of_bridge", end: "end_of_bridge" },
+  // 'part' tag names are configurable via options.partTagNames
+  part: { start: "start_of_part", end: "end_of_part" }
+};
+var BRACKET_HEADER_REGEX = /^\[([^\]]+)]$/;
+function classifySectionLabel(rawLabel) {
+  let s = rawLabel.trim().replace(/:$/, "").trim();
+  const base = s.replace(/\s*\d+\s*$/, "").trim();
+  const normalized = stripAccents(base).toLowerCase();
+  for (const kind of Object.keys(SECTION_KEYWORDS)) {
+    if (SECTION_KEYWORDS[kind].some(
+      (kw) => normalized === kw || normalized.startsWith(kw)
+    )) {
+      return { kind, label: s };
+    }
+  }
+  return null;
+}
+var REPEAT_NOTATION_REGEX = /\s*\(?\b(\d+)\s*[xX]\b\)?\s*$|\s+[xX](\d+)\s*$/;
+function extractRepeatNotation(line) {
+  const match = line.match(REPEAT_NOTATION_REGEX);
+  if (match) {
+    return {
+      cleanLine: line.slice(0, match.index).replace(/\s+$/, ""),
+      marker: match[0].trim()
+    };
+  }
+  return { cleanLine: line, marker: null };
+}
+function countSyllableHyphens(line) {
+  const matches = line.match(/[^\s-]-[^\s-]/g);
+  return matches ? matches.length : 0;
+}
+function dehyphenate(line) {
+  return line.replace(/([^\s-])-([^\s-])/g, "$1 $2");
+}
+function detectSourceFormat(input) {
+  const lines = input.split("\n");
+  let ugScore = 0;
+  let ccScore = 0;
+  let sawChordLine = false;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (BRACKET_HEADER_REGEX.test(line)) ugScore += 2;
+    if (/^(capo|tuning|key)\s*:/i.test(line)) ugScore += 2;
+    if (/\s[xX]\d+\s*$/.test(raw)) ugScore += 1;
+    if (/^(tom|capotraste|capodastro|int[ée]rprete|compositor|letrista)\s*:/i.test(
+      line
+    ))
+      ccScore += 2;
+    if (/^\(?\d+x\)?\s*$/i.test(line)) ccScore += 1;
+    if (isChordLine(line, true)) {
+      sawChordLine = true;
+      if (countSyllableHyphens(line) === 0) {
+      }
+    } else if (countSyllableHyphens(line) >= 2) {
+      ccScore += 2;
+    }
+  }
+  if (!sawChordLine) return "plain";
+  if (ccScore > ugScore) return "cifraclub";
+  if (ugScore > 0) return "ultimate-guitar";
+  return "plain";
+}
+function mergeChordsIntoLyric(chordLine, lyricLine, trailingMarker) {
+  const matches = [...chordLine.matchAll(CHORD_SCAN_REGEX)];
+  let combined = "";
+  let lastIndex = 0;
+  for (const match of matches) {
+    const token = match[0];
+    const index = match.index ?? 0;
+    const rendered = NO_CHORD_TOKEN_REGEX.test(token) ? token.toUpperCase() : token;
+    combined += lyricLine.substring(lastIndex, index);
+    combined += `[${rendered}]`;
+    lastIndex = index;
+  }
+  combined += lyricLine.substring(lastIndex);
+  if (trailingMarker) {
+    combined += ` ${trailingMarker}`;
+  }
+  return combined;
+}
+function classify(lines, opts, effectiveSource) {
+  const result = [];
+  const shouldDehyphenateGlobally = opts.dehyphenateSyllables === true || opts.dehyphenateSyllables === "auto" && effectiveSource === "cifraclub";
+  const hyphenThreshold = effectiveSource === "cifraclub" ? 1 : 2;
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i].replace(/\r$/, "");
+    const trimmed = raw.trim();
+    if (trimmed === "") {
+      result.push({ kind: "blank" });
+      continue;
+    }
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      result.push({ kind: "directive", rendered: trimmed });
+      continue;
+    }
+    if (isAlreadyInlineChordPro(trimmed)) {
+      result.push({ kind: "inline-chordpro", rendered: raw });
+      continue;
+    }
+    const bracketMatch = trimmed.match(BRACKET_HEADER_REGEX);
+    if (bracketMatch) {
+      const classified = classifySectionLabel(bracketMatch[1]);
+      if (classified) {
+        result.push({ kind: "section-header", section: classified });
+        continue;
+      }
+    }
+    const metaMatch = trimmed.match(/^([A-Za-zÀ-ÿ ]+):\s*(.*)/);
+    if (metaMatch) {
+      const key = stripAccents(metaMatch[1].toLowerCase().trim());
+      const value = metaMatch[2];
+      if (METADATA_MAP[key]) {
+        result.push({
+          kind: "metadata",
+          rendered: `{${METADATA_MAP[key]}: ${value}}`
+        });
+        continue;
+      }
+    }
+    if (trimmed.startsWith("#")) {
+      result.push({
+        kind: "comment",
+        rendered: `{comment: ${trimmed.slice(1).trim()}}`
+      });
+      continue;
+    }
+    if (trimmed.length <= 28 && !isChordLine(trimmed, opts.strictChordDetection)) {
+      const classified = classifySectionLabel(trimmed);
+      if (classified) {
+        result.push({ kind: "section-header", section: classified });
+        continue;
+      }
+    }
+    if (isChordLine(trimmed, opts.strictChordDetection)) {
+      const nextRaw = i + 1 < lines.length ? lines[i + 1].replace(/\r$/, "") : null;
+      const nextIsChord = nextRaw !== null && isChordLine(nextRaw.trim(), opts.strictChordDetection);
+      const nextIsBlank = nextRaw !== null && nextRaw.trim() === "";
+      if (nextRaw === null || nextIsChord || nextIsBlank) {
+        const tokens = trimmed.split(/\s+/);
+        result.push({
+          kind: "chord-only",
+          rendered: tokens.map(
+            (t) => NO_CHORD_TOKEN_REGEX.test(t) ? `[${t.toUpperCase()}]` : `[${t}]`
+          ).join(" ")
+        });
+        continue;
+      }
+      let lyricLine = nextRaw;
+      let marker = null;
+      if (opts.keepRepeatMarkers) {
+        const extracted = extractRepeatNotation(lyricLine);
+        lyricLine = extracted.cleanLine;
+        marker = extracted.marker;
+      }
+      const hyphenCount = countSyllableHyphens(lyricLine);
+      if (shouldDehyphenateGlobally && hyphenCount >= hyphenThreshold) {
+        lyricLine = dehyphenate(lyricLine);
+      } else if (hyphenCount >= 2 && effectiveSource !== "ultimate-guitar") {
+        lyricLine = dehyphenate(lyricLine);
+      }
+      const merged = mergeChordsIntoLyric(raw, lyricLine, marker);
+      result.push({ kind: "chord-lyric", rendered: merged });
+      i++;
+      continue;
+    }
+    result.push({ kind: "lyric", rendered: raw });
+  }
+  return result;
+}
+function render(lines, opts) {
+  const out = [];
+  let openSection = null;
+  const tagsFor = (kind) => kind === "part" ? opts.partTagNames : SECTION_TAGS[kind];
+  const closeSection = () => {
+    if (openSection) {
+      out.push(`{${tagsFor(openSection.kind).end}}`);
+      openSection = null;
+    }
+  };
+  for (const line of lines) {
+    if (line.kind === "section-header" && line.section) {
+      if (opts.detectSections) {
+        closeSection();
+        const tags = tagsFor(line.section.kind);
+        out.push(`{${tags.start}: ${line.section.label}}`);
+        openSection = line.section;
+      } else {
+        out.push(`{comment: ${line.section.label}}`);
+      }
+      continue;
+    }
+    if (line.kind === "blank") {
+      if (opts.detectSections) closeSection();
+      out.push("");
+      continue;
+    }
+    out.push(line.rendered ?? "");
+  }
+  if (opts.detectSections) closeSection();
+  return out.join("\n").replace(/\n{3,}/g, "\n\n").trim() + "\n";
+}
+function extractTitle(chordpro) {
+  const match = chordpro.match(/\{title:\s*(.*)\}/i);
+  return match ? match[1].trim() : null;
+}
+function slugifyTitle(title) {
+  if (!title) return "cifra_convertida";
+  return stripAccents(title).trim().replace(/\s+/g, "_").replace(/[^a-zA-Z0-9_]/g, "") || "cifra";
+}
+function convertToChordProDetailed(input, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const warnings = [];
+  if (!input || !input.trim()) {
+    return {
+      chordpro: "",
+      title: null,
+      detectedSource: "plain",
+      warnings: ["Empty input."]
+    };
+  }
+  const detectedSource = opts.source === "auto" ? detectSourceFormat(input) : opts.source;
+  const lines = input.split("\n");
+  const parsed = classify(lines, opts, detectedSource);
+  const chordpro = render(parsed, opts);
+  const title = extractTitle(chordpro);
+  if (!title)
+    warnings.push("No {title: ...} directive was detected in the input.");
+  const shorthandTokens = /* @__PURE__ */ new Set();
+  for (const raw of lines) {
+    if (isChordLine(raw.trim(), opts.strictChordDetection)) {
+      for (const m of raw.matchAll(CHORD_SCAN_REGEX)) {
+        if (/^[A-G][#b]?4$/i.test(m[0]) || /^[A-G][#b]?9$/i.test(m[0])) {
+          shorthandTokens.add(m[0]);
+        }
+      }
+    }
+  }
+  if (shorthandTokens.size > 0) {
+    warnings.push(
+      `Ambiguous bare-number chords passed through as-is (not reinterpreted as sus/add): ${[...shorthandTokens].join(", ")}. On Brazilian/Portuguese sheets "G4" usually means Gsus4 - convert manually if your chord engine expects that spelling.`
+    );
+  }
+  return { chordpro, title, detectedSource, warnings };
+}
+function toChordPro(input, options) {
+  return convertToChordProDetailed(input, options).chordpro;
+}
+
+export {
+  detectSourceFormat,
+  slugifyTitle,
+  convertToChordProDetailed,
+  toChordPro
+};