guitarpro-parser 1.0.0

package/dist/index.js

@@ -0,0 +1,1621 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/pitch.ts
+var SHARP_NAMES = {
+  0: "C",
+  1: "C#",
+  2: "D",
+  3: "D#",
+  4: "E",
+  5: "F",
+  6: "F#",
+  7: "G",
+  8: "G#",
+  9: "A",
+  10: "A#",
+  11: "B"
+};
+var FLAT_NAMES = {
+  0: "C",
+  1: "Db",
+  2: "D",
+  3: "Eb",
+  4: "E",
+  5: "F",
+  6: "Gb",
+  7: "G",
+  8: "Ab",
+  9: "A",
+  10: "Bb",
+  11: "B"
+};
+var NATURAL_PITCH_CLASSES = /* @__PURE__ */ new Set([0, 2, 4, 5, 7, 9, 11]);
+function resolveAccidental(pc, preferFlats) {
+  if (NATURAL_PITCH_CLASSES.has(pc)) return "natural";
+  return preferFlats ? "flat" : "sharp";
+}
+function noteFromPitchClass(pc, preferFlats = false, octave) {
+  const name = preferFlats ? FLAT_NAMES[pc] : SHARP_NAMES[pc];
+  return {
+    pitchClass: pc,
+    name,
+    accidental: resolveAccidental(pc, preferFlats),
+    octave
+  };
+}
+function midiToPitchClass(midi) {
+  return (midi % 12 + 12) % 12;
+}
+
+// src/dom.ts
+function getDOMParser() {
+  if (typeof globalThis.DOMParser !== "undefined") {
+    return globalThis.DOMParser;
+  }
+  try {
+    const linkedom = __require("linkedom");
+    return linkedom.DOMParser;
+  } catch {
+    throw new Error(
+      "DOMParser is not available. In Node.js, install linkedom: npm install linkedom"
+    );
+  }
+}
+
+// src/gpx-parser.ts
+var DURATION_BEATS = {
+  whole: 4,
+  half: 2,
+  quarter: 1,
+  eighth: 0.5,
+  "16th": 0.25,
+  "32nd": 0.125,
+  "64th": 0.0625,
+  "128th": 0.03125
+};
+function durationToBeats(duration, dotCount, tuplet) {
+  let beats = DURATION_BEATS[duration] ?? 1;
+  let dotValue = beats;
+  for (let i = 0; i < dotCount; i++) {
+    dotValue /= 2;
+    beats += dotValue;
+  }
+  if (tuplet && tuplet.num > 0) {
+    beats *= tuplet.den / tuplet.num;
+  }
+  return beats;
+}
+function beatDurationMs(beat) {
+  const beatFraction = durationToBeats(beat.duration, beat.dotted, beat.tuplet);
+  const quarterNoteMs = 6e4 / beat.tempo;
+  return beatFraction * quarterNoteMs;
+}
+var BinaryReader = class {
+  constructor(buffer) {
+    this.view = new DataView(buffer);
+    this.bytes = new Uint8Array(buffer);
+    this.pos = 0;
+    this.bitOffset = 0;
+    this.byteLength = buffer.byteLength;
+  }
+  seek(offset) {
+    this.pos = offset;
+    this.bitOffset = 0;
+  }
+  getPosition() {
+    return this.pos;
+  }
+  getUint8() {
+    this.bitOffset = 0;
+    const v = this.view.getUint8(this.pos);
+    this.pos += 1;
+    return v;
+  }
+  getUint32LE(offset) {
+    this.bitOffset = 0;
+    if (offset !== void 0) {
+      return this.view.getUint32(offset, true);
+    }
+    const v = this.view.getUint32(this.pos, true);
+    this.pos += 4;
+    return v;
+  }
+  getString(length) {
+    this.bitOffset = 0;
+    const chars = [];
+    for (let i = 0; i < length; i++) {
+      chars.push(this.view.getUint8(this.pos + i));
+    }
+    this.pos += length;
+    return String.fromCharCode(...chars);
+  }
+  getZeroTerminatedString(offset, maxLength) {
+    const chars = [];
+    for (let i = 0; i < maxLength; i++) {
+      const code = this.view.getUint8(offset + i) & 255;
+      if (code === 0) break;
+      chars.push(code);
+    }
+    return String.fromCharCode(...chars);
+  }
+  getBytes(length, offset) {
+    this.bitOffset = 0;
+    const start = offset !== void 0 ? offset : this.pos;
+    if (offset === void 0) this.pos += length;
+    return new Uint8Array(this.view.buffer, start, length);
+  }
+  /**
+   * Reads `bitLength` bits as an unsigned integer (MSB-first), matching
+   * jDataView.getUnsigned() semantics: a persistent bitOffset carries across
+   * calls, and bits are read big-endian from the byte stream.
+   */
+  getUnsigned(bitLength) {
+    const startBit = (this.pos << 3) + this.bitOffset;
+    const endBit = startBit + bitLength;
+    const startByte = startBit >>> 3;
+    const endByte = endBit + 7 >>> 3;
+    this.bitOffset = endBit & 7;
+    if (this.bitOffset !== 0) {
+      this.pos = endBit >>> 3;
+    } else {
+      this.pos = endBit >>> 3;
+    }
+    let wideValue = 0;
+    for (let i = startByte; i < endByte; i++) {
+      wideValue = wideValue << 8 | (this.bytes[i] ?? 0);
+    }
+    const trailingBits = (endByte << 3) - endBit;
+    wideValue = wideValue >>> trailingBits;
+    if (bitLength < 32) {
+      wideValue = wideValue & (1 << bitLength) - 1;
+    }
+    return wideValue;
+  }
+};
+function readBitsReversed(reader, count) {
+  let bits = 0;
+  for (let i = 0; i < count; i++) {
+    bits |= reader.getUnsigned(1) << i;
+  }
+  return bits;
+}
+function isFileToStore(name) {
+  return name === "score.gpif" || name === "misc.xml";
+}
+function decompressBlock(reader, skipHeader) {
+  const expectedLength = reader.getUint32LE();
+  const temp = new Uint8Array(expectedLength);
+  let pos = 0;
+  try {
+    while (pos < expectedLength) {
+      const flag = reader.getUnsigned(1);
+      if (flag === 1) {
+        const wordSize = reader.getUnsigned(4);
+        const offset = readBitsReversed(reader, wordSize);
+        const size = readBitsReversed(reader, wordSize);
+        const sourcePosition = pos - offset;
+        const readSize = Math.min(offset, size);
+        for (let i = 0; i < readSize; i++) {
+          temp[pos + i] = temp[sourcePosition + i];
+        }
+        pos += readSize;
+      } else {
+        const size = readBitsReversed(reader, 2);
+        for (let i = 0; i < size; i++) {
+          temp[pos++] = reader.getUnsigned(8);
+        }
+      }
+    }
+  } catch {
+  }
+  if (skipHeader) {
+    return temp.buffer.slice(4, temp.byteLength);
+  }
+  return temp.buffer;
+}
+function parseBlockFilesystem(buffer) {
+  const SECTOR_SIZE = 4096;
+  const reader = new BinaryReader(buffer);
+  let offset = SECTOR_SIZE;
+  const files = [];
+  while (offset + SECTOR_SIZE + 3 < reader.byteLength) {
+    const entryType = reader.getUint32LE(offset);
+    if (entryType === 2) {
+      const name = reader.getZeroTerminatedString(offset + 4, 127);
+      const size = reader.getUint32LE(offset + 140);
+      const file = { name, size, data: null };
+      files.push(file);
+      const store = isFileToStore(name);
+      const blocksOffset = offset + 148;
+      const dataChunks = [];
+      let blockCount = 0;
+      let blockId;
+      while ((blockId = reader.getUint32LE(blocksOffset + 4 * blockCount)) !== 0) {
+        const blockOffset = blockId * SECTOR_SIZE;
+        if (store) {
+          const max = blockOffset + SECTOR_SIZE;
+          const blockSize = max > reader.byteLength ? SECTOR_SIZE - (max - reader.byteLength) : SECTOR_SIZE;
+          dataChunks.push(reader.getBytes(blockSize, blockOffset));
+        }
+        blockCount++;
+      }
+      if (store && dataChunks.length > 0) {
+        const totalSize = dataChunks.reduce((s, c) => s + c.length, 0);
+        const combined = new Uint8Array(Math.max(size, totalSize));
+        let writePos = 0;
+        for (const chunk of dataChunks) {
+          combined.set(chunk, writePos);
+          writePos += chunk.length;
+        }
+        file.data = combined.subarray(0, Math.min(size, totalSize));
+      }
+    }
+    offset += SECTOR_SIZE;
+  }
+  return files;
+}
+function decodeGpxBinary(data) {
+  const buf = new ArrayBuffer(data.byteLength);
+  new Uint8Array(buf).set(data);
+  const reader = new BinaryReader(buf);
+  const header = reader.getString(4);
+  let filesystemBuffer;
+  switch (header) {
+    case "BCFZ":
+      filesystemBuffer = decompressBlock(reader, true);
+      break;
+    case "BCFS":
+      {
+        const raw = reader.getBytes(reader.byteLength - 4);
+        const copy = new ArrayBuffer(raw.byteLength);
+        new Uint8Array(copy).set(raw);
+        filesystemBuffer = copy;
+      }
+      break;
+    default:
+      throw new Error(`Bad GPX header: "${header}" (unsupported format)`);
+  }
+  const files = parseBlockFilesystem(filesystemBuffer);
+  const result = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    if (file.data && isFileToStore(file.name)) {
+      const decoder = new TextDecoder("utf-8");
+      result.set(file.name, decoder.decode(file.data));
+    }
+  }
+  return result;
+}
+function childText(el, tag) {
+  const child = el.querySelector(`:scope > ${tag}`);
+  return child?.textContent?.trim() ?? null;
+}
+function parseTimeSignature(time) {
+  if (!time) return { numerator: 4, denominator: 4 };
+  const parts = time.split("/");
+  return {
+    numerator: parseInt(parts[0], 10) || 4,
+    denominator: parseInt(parts[1], 10) || 4
+  };
+}
+function pitchClassFromStringFret(tuningPitches, stringIndex, fret) {
+  const openPitch = tuningPitches[stringIndex] ?? 0;
+  return ((openPitch + fret) % 12 + 12) % 12;
+}
+function parseTuningPitches(pitchesStr) {
+  return pitchesStr.split(/\s+/).filter((s) => s.length > 0).map(Number);
+}
+function findProperty(propertiesEl, name) {
+  if (!propertiesEl) return null;
+  const props = propertiesEl.querySelectorAll(":scope > Property");
+  for (const prop of props) {
+    if (prop.getAttribute("name") === name) return prop;
+  }
+  return null;
+}
+function propValue(propertiesEl, name) {
+  const prop = findProperty(propertiesEl, name);
+  if (!prop) return null;
+  const firstChild = prop.firstElementChild;
+  return firstChild?.textContent?.trim() ?? null;
+}
+function propEnabled(propertiesEl, name) {
+  const prop = findProperty(propertiesEl, name);
+  if (!prop) return null;
+  return prop.querySelector("Enable") !== null;
+}
+function propFlags(propertiesEl, name) {
+  const prop = findProperty(propertiesEl, name);
+  if (!prop) return null;
+  const flagsEl = prop.querySelector("Flags");
+  if (!flagsEl) return null;
+  const val = parseInt(flagsEl.textContent?.trim() ?? "", 10);
+  return isNaN(val) ? null : val;
+}
+function propFloat(propertiesEl, name) {
+  const prop = findProperty(propertiesEl, name);
+  if (!prop) return null;
+  const floatEl = prop.querySelector("Float");
+  if (!floatEl) return null;
+  const val = parseFloat(floatEl.textContent?.trim() ?? "");
+  return isNaN(val) ? null : val;
+}
+function propHType(propertiesEl, name) {
+  const prop = findProperty(propertiesEl, name);
+  if (!prop) return null;
+  const htypeEl = prop.querySelector("HType");
+  return htypeEl?.textContent?.trim() ?? null;
+}
+function transformNoteElement(noteEl, tuningPitches) {
+  const propsEl = noteEl.querySelector(":scope > Properties");
+  const stringIndex = parseInt(propValue(propsEl, "String") ?? "0", 10);
+  const fret = parseInt(propValue(propsEl, "Fret") ?? "0", 10);
+  const pc = pitchClassFromStringFret(tuningPitches, stringIndex, fret);
+  const note = noteFromPitchClass(pc, false);
+  const isBended = propEnabled(propsEl, "Bended");
+  const bend = isBended ? {
+    origin: propFloat(propsEl, "BendOriginValue") ?? 0,
+    destination: propFloat(propsEl, "BendDestinationValue") ?? 0,
+    middle: propFloat(propsEl, "BendMiddleValue") ?? 0
+  } : null;
+  const tieEl = noteEl.querySelector(":scope > Tie");
+  const letRingEl = noteEl.querySelector(":scope > LetRing");
+  const vibratoEl = noteEl.querySelector(":scope > Vibrato");
+  const accentEl = noteEl.querySelector(":scope > Accent");
+  return {
+    string: stringIndex,
+    fret,
+    pitchClass: pc,
+    noteName: note.name,
+    slide: propFlags(propsEl, "Slide"),
+    harmonic: propHType(propsEl, "HarmonicType"),
+    palmMute: propEnabled(propsEl, "PalmMuted") ?? false,
+    muted: propEnabled(propsEl, "Muted") ?? false,
+    letRing: letRingEl !== null,
+    bend,
+    tie: {
+      origin: tieEl ? tieEl.getAttribute("origin") === "true" : false,
+      destination: tieEl ? tieEl.getAttribute("destination") === "true" : false
+    },
+    vibrato: vibratoEl?.textContent?.trim() ?? null,
+    hammerOn: propEnabled(propsEl, "HopoOrigin") ?? false,
+    pullOff: propEnabled(propsEl, "HopoDestination") ?? false,
+    tapped: propEnabled(propsEl, "Tapped") ?? false,
+    accent: accentEl ? parseInt(accentEl.textContent?.trim() ?? "", 10) || null : null
+  };
+}
+function indexElements(container, childTag) {
+  const map = /* @__PURE__ */ new Map();
+  if (!container) return map;
+  const children = container.querySelectorAll(`:scope > ${childTag}`);
+  for (const child of children) {
+    const id = child.getAttribute("id");
+    if (id) map.set(id, child);
+  }
+  return map;
+}
+function splitIds(text) {
+  if (!text) return [];
+  return text.split(/\s+/).filter((s) => s.length > 0);
+}
+function buildTempoMap(masterTrackEl) {
+  const tempoMap = /* @__PURE__ */ new Map();
+  if (!masterTrackEl) return tempoMap;
+  const automationsEl = masterTrackEl.querySelector(":scope > Automations");
+  if (!automationsEl) return tempoMap;
+  const autos = automationsEl.querySelectorAll(":scope > Automation");
+  for (const auto of autos) {
+    const type = childText(auto, "Type");
+    if (type?.toLowerCase() !== "tempo") continue;
+    const barText = childText(auto, "Bar");
+    const valueText = childText(auto, "Value");
+    if (barText === null || valueText === null) continue;
+    const barIndex = parseInt(barText, 10);
+    const value = parseFloat(valueText);
+    if (!isNaN(barIndex) && !isNaN(value)) {
+      tempoMap.set(barIndex, value);
+    }
+  }
+  return tempoMap;
+}
+function tempoAtBar(barIndex, tempoMap, defaultTempo) {
+  for (let i = barIndex; i >= 0; i--) {
+    const t = tempoMap.get(i);
+    if (t !== void 0) return t;
+  }
+  return defaultTempo;
+}
+function gpifToTabSong(doc) {
+  const gpif = doc.querySelector("GPIF");
+  if (!gpif) throw new Error("Invalid GPIF XML: no <GPIF> root element");
+  const scoreEl = gpif.querySelector(":scope > Score");
+  const title = scoreEl ? childText(scoreEl, "Title") ?? "" : "";
+  const artist = scoreEl ? childText(scoreEl, "Artist") ?? "" : "";
+  const album = scoreEl ? childText(scoreEl, "Album") ?? "" : "";
+  const noteMap = indexElements(gpif.querySelector(":scope > Notes"), "Note");
+  const beatMap = indexElements(gpif.querySelector(":scope > Beats"), "Beat");
+  const voiceMap = indexElements(gpif.querySelector(":scope > Voices"), "Voice");
+  const barMap = indexElements(gpif.querySelector(":scope > Bars"), "Bar");
+  const rhythmMap = indexElements(gpif.querySelector(":scope > Rhythms"), "Rhythm");
+  const masterBarsEl = gpif.querySelector(":scope > MasterBars");
+  const masterBarEls = masterBarsEl ? Array.from(masterBarsEl.querySelectorAll(":scope > MasterBar")) : [];
+  const masterTrackEl = gpif.querySelector(":scope > MasterTrack");
+  const tempoMap = buildTempoMap(masterTrackEl);
+  let initialTempo = 120;
+  if (tempoMap.size > 0) {
+    initialTempo = tempoMap.get(0) ?? 120;
+  }
+  const tracksEl = gpif.querySelector(":scope > Tracks");
+  const trackEls = tracksEl ? Array.from(tracksEl.querySelectorAll(":scope > Track")) : [];
+  const tracks = trackEls.map(
+    (trackEl) => transformTrackElement(
+      trackEl,
+      masterBarEls,
+      barMap,
+      voiceMap,
+      beatMap,
+      noteMap,
+      rhythmMap,
+      tempoMap,
+      initialTempo
+    )
+  );
+  return { title, artist, album, tempo: initialTempo, tracks };
+}
+function transformTrackElement(trackEl, masterBarEls, barMap, voiceMap, beatMap, noteMap, rhythmMap, tempoMap, defaultTempo) {
+  const trackId = trackEl.getAttribute("id") ?? "0";
+  const propsEl = trackEl.querySelector(":scope > Properties");
+  let tuningPitches = [40, 45, 50, 55, 59, 64];
+  let capoFret = 0;
+  if (propsEl) {
+    const tuningProp = findProperty(propsEl, "Tuning");
+    if (tuningProp) {
+      const pitchesEl = tuningProp.querySelector("Pitches");
+      if (pitchesEl?.textContent) {
+        tuningPitches = parseTuningPitches(pitchesEl.textContent.trim());
+      }
+    }
+    const capoProp = findProperty(propsEl, "CapoFret");
+    if (capoProp) {
+      const fretEl = capoProp.querySelector("Fret");
+      if (fretEl?.textContent) {
+        const parsed = parseInt(fretEl.textContent.trim(), 10);
+        if (!isNaN(parsed)) capoFret = parsed;
+      }
+    }
+  }
+  const tuning = tuningPitches.map((midi) => noteFromPitchClass(midiToPitchClass(midi))).reverse();
+  const trackIndex = parseInt(trackId, 10);
+  let globalBeatIndex = 0;
+  const bars = [];
+  for (let mbIdx = 0; mbIdx < masterBarEls.length; mbIdx++) {
+    const masterBarEl = masterBarEls[mbIdx];
+    const barsText = childText(masterBarEl, "Bars");
+    const barIds = splitIds(barsText);
+    const barId = barIds[trackIndex] ?? barIds[0];
+    const barEl = barId ? barMap.get(barId) : void 0;
+    if (!barEl) {
+      bars.push(makeEmptyBar(mbIdx, masterBarEl));
+      continue;
+    }
+    const timeText = childText(masterBarEl, "Time");
+    const timeSig = parseTimeSignature(timeText);
+    const keyEl = masterBarEl.querySelector(":scope > Key");
+    const keySig = keyEl ? {
+      accidentalCount: parseInt(childText(keyEl, "AccidentalCount") ?? "0", 10),
+      mode: childText(keyEl, "Mode")?.toLowerCase() ?? "major"
+    } : null;
+    const sectionEl = masterBarEl.querySelector(":scope > Section");
+    const section = sectionEl ? {
+      letter: sectionEl.getAttribute("letter") ?? void 0,
+      text: sectionEl.getAttribute("text") ?? void 0
+    } : null;
+    const repeatEl = masterBarEl.querySelector(":scope > Repeat");
+    const repeatStart = repeatEl ? repeatEl.getAttribute("start") === "true" : false;
+    const repeatEnd = repeatEl ? repeatEl.getAttribute("end") === "true" : false;
+    const repeatCount = repeatEl ? parseInt(repeatEl.getAttribute("count") ?? "0", 10) || 0 : 0;
+    const voicesText = childText(barEl, "Voices");
+    const voiceIds = splitIds(voicesText);
+    const tabBeats = [];
+    const currentTempo = tempoAtBar(mbIdx, tempoMap, defaultTempo);
+    if (voiceIds.length > 0) {
+      const voiceEl = voiceMap.get(voiceIds[0]);
+      if (voiceEl) {
+        const voiceBeatsText = childText(voiceEl, "Beats");
+        const voiceBeatIds = splitIds(voiceBeatsText);
+        for (const beatId of voiceBeatIds) {
+          const beatEl = beatMap.get(beatId);
+          if (!beatEl) continue;
+          const rhythmRef = beatEl.querySelector(":scope > Rhythm")?.getAttribute("ref");
+          const rhythmEl = rhythmRef ? rhythmMap.get(rhythmRef) : void 0;
+          const notesText = childText(beatEl, "Notes");
+          const noteIds = splitIds(notesText);
+          const stringCount = tuningPitches.length;
+          const tabNotes = noteIds.map((nid) => noteMap.get(nid)).filter((n) => n !== void 0).map((n) => transformNoteElement(n, tuningPitches)).map((n) => ({ ...n, string: stringCount - 1 - n.string }));
+          const noteValueText = rhythmEl ? childText(rhythmEl, "NoteValue") : null;
+          const duration = noteValueText?.toLowerCase() ?? "quarter";
+          const tupletEl = rhythmEl?.querySelector(":scope > PrimaryTuplet");
+          const tuplet = tupletEl ? {
+            num: parseInt(tupletEl.getAttribute("num") ?? "1", 10) || 1,
+            den: parseInt(tupletEl.getAttribute("den") ?? "1", 10) || 1
+          } : null;
+          const dotEl = rhythmEl?.querySelector(":scope > AugmentationDot");
+          const dotCount = dotEl ? parseInt(dotEl.getAttribute("count") ?? "0", 10) || 0 : 0;
+          const isRest = tabNotes.length === 0;
+          const dynamicText = childText(beatEl, "Dynamic");
+          tabBeats.push({
+            index: globalBeatIndex++,
+            barIndex: mbIdx,
+            notes: tabNotes,
+            duration,
+            tuplet: tuplet && (tuplet.num !== 1 || tuplet.den !== 1) ? tuplet : null,
+            dotted: dotCount,
+            isRest,
+            dynamic: dynamicText,
+            tempo: currentTempo
+          });
+        }
+      }
+    }
+    bars.push({
+      index: mbIdx,
+      timeSignature: timeSig,
+      keySignature: keySig,
+      section,
+      beats: tabBeats,
+      repeatStart,
+      repeatEnd,
+      repeatCount
+    });
+  }
+  return {
+    id: trackId,
+    name: childText(trackEl, "Name") ?? "Track",
+    shortName: childText(trackEl, "ShortName") ?? "",
+    instrument: trackEl.querySelector(":scope > Instrument")?.getAttribute("ref") ?? null,
+    tuning,
+    capoFret,
+    bars
+  };
+}
+function makeEmptyBar(index, masterBarEl) {
+  const timeText = childText(masterBarEl, "Time");
+  return {
+    index,
+    timeSignature: parseTimeSignature(timeText),
+    keySignature: null,
+    section: null,
+    beats: [],
+    repeatStart: false,
+    repeatEnd: false,
+    repeatCount: 0
+  };
+}
+function parseGpxFile(data) {
+  const files = decodeGpxBinary(data);
+  const gpifXml = files.get("score.gpif");
+  if (!gpifXml) {
+    throw new Error("No score.gpif found in GPX archive");
+  }
+  const DOMParserImpl = getDOMParser();
+  const parser = new DOMParserImpl();
+  const doc = parser.parseFromString(gpifXml, "text/xml");
+  const parseError = doc.querySelector("parsererror");
+  if (parseError) {
+    throw new Error(`Failed to parse GPIF XML: ${parseError.textContent}`);
+  }
+  return gpifToTabSong(doc);
+}
+
+// src/gp5-parser.ts
+var GP5Reader = class {
+  constructor(buffer) {
+    this.view = new DataView(buffer);
+    this.buf = new Uint8Array(buffer);
+    this.pos = 0;
+    this.byteLength = buffer.byteLength;
+  }
+  getPosition() {
+    return this.pos;
+  }
+  skip(n) {
+    this.pos += n;
+  }
+  readByte() {
+    const v = this.buf[this.pos];
+    this.pos += 1;
+    return v;
+  }
+  readSignedByte() {
+    const v = this.view.getInt8(this.pos);
+    this.pos += 1;
+    return v;
+  }
+  readBool() {
+    return this.readByte() !== 0;
+  }
+  readShort() {
+    const v = this.view.getInt16(this.pos, true);
+    this.pos += 2;
+    return v;
+  }
+  readInt() {
+    const v = this.view.getInt32(this.pos, true);
+    this.pos += 4;
+    return v;
+  }
+  readDouble() {
+    const v = this.view.getFloat64(this.pos, true);
+    this.pos += 8;
+    return v;
+  }
+  /** Reads IntByteSizeString: int(strLen+1) + byte(strLen) + chars. */
+  readIntByteSizeString() {
+    const totalSize = this.readInt();
+    const strLen = this.readByte();
+    const str = this.readChars(strLen);
+    const padding = Math.max(0, totalSize - 1 - strLen);
+    this.skip(padding);
+    return str;
+  }
+  /** Reads IntSizeString: int(len) + chars. */
+  readIntString() {
+    const len = this.readInt();
+    if (len <= 0) return "";
+    return this.readChars(len);
+  }
+  /** Reads ByteSizeString with fixed buffer length. */
+  readByteSizeString(fixedLen) {
+    const strLen = this.readByte();
+    const str = this.readChars(Math.min(strLen, fixedLen));
+    const remaining = fixedLen - Math.min(strLen, fixedLen);
+    this.skip(remaining);
+    return str;
+  }
+  readChars(length) {
+    const chars = [];
+    for (let i = 0; i < length; i++) {
+      chars.push(this.buf[this.pos + i]);
+    }
+    this.pos += length;
+    return String.fromCharCode(...chars);
+  }
+};
+function parseVersionString(versionStr) {
+  const match = versionStr.match(/v(\d+)\.(\d+)/);
+  if (!match) return { major: 5, minor: 10, patch: 0 };
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: 0
+  };
+}
+function versionGreaterThan(v, major, minor, patch) {
+  if (v.major !== major) return v.major > major;
+  if (v.minor !== minor) return v.minor > minor;
+  return v.patch > patch;
+}
+var GP_DURATION_MAP = {
+  [-2]: "whole",
+  [-1]: "half",
+  [0]: "quarter",
+  [1]: "eighth",
+  [2]: "16th",
+  [3]: "32nd",
+  [4]: "64th",
+  [5]: "128th"
+};
+function gpDurationToDuration(value) {
+  return GP_DURATION_MAP[value] ?? "quarter";
+}
+var TUPLET_MAP = {
+  3: { num: 3, den: 2 },
+  5: { num: 5, den: 4 },
+  6: { num: 6, den: 4 },
+  7: { num: 7, den: 4 },
+  9: { num: 9, den: 8 },
+  10: { num: 10, den: 8 },
+  11: { num: 11, den: 8 },
+  12: { num: 12, den: 8 },
+  13: { num: 13, den: 8 }
+};
+var HARMONIC_TYPE_MAP = {
+  1: "Natural",
+  2: "Artificial",
+  3: "Tapped",
+  4: "Pinch",
+  5: "Semi"
+};
+function readInfo(r) {
+  const title = r.readIntByteSizeString();
+  const subtitle = r.readIntByteSizeString();
+  const artist = r.readIntByteSizeString();
+  const album = r.readIntByteSizeString();
+  r.readIntByteSizeString();
+  r.readIntByteSizeString();
+  r.readIntByteSizeString();
+  r.readIntByteSizeString();
+  r.readIntByteSizeString();
+  const noticeCount = r.readInt();
+  for (let i = 0; i < noticeCount; i++) {
+    r.readIntByteSizeString();
+  }
+  return { title, subtitle, artist, album };
+}
+function readLyrics(r) {
+  r.readInt();
+  for (let i = 0; i < 5; i++) {
+    r.readInt();
+    r.readIntString();
+  }
+}
+function readRSEMasterEffect(r, version) {
+  if (versionGreaterThan(version, 5, 0, 0)) {
+    r.readInt();
+    r.readInt();
+    readEqualizer(r, 11);
+  }
+}
+function readEqualizer(r, bands) {
+  for (let i = 0; i < bands; i++) {
+    r.readSignedByte();
+  }
+}
+function readPageSetup(r) {
+  r.readInt();
+  r.readInt();
+  r.readInt();
+  r.readInt();
+  r.readInt();
+  r.readInt();
+  r.readInt();
+  r.readShort();
+  for (let i = 0; i < 10; i++) {
+    r.readIntByteSizeString();
+  }
+}
+function readDirections(r) {
+  for (let i = 0; i < 19; i++) {
+    r.readShort();
+  }
+}
+function readMidiChannels(r) {
+  const channels = [];
+  for (let i = 0; i < 64; i++) {
+    const instrument = r.readInt();
+    const volume = r.readByte();
+    const balance = r.readByte();
+    const chorus = r.readByte();
+    const reverb = r.readByte();
+    const phaser = r.readByte();
+    const tremolo = r.readByte();
+    r.skip(2);
+    channels.push({ instrument, volume, balance, chorus, reverb, phaser, tremolo });
+  }
+  return channels;
+}
+function readMeasureHeaders(r, count, _version) {
+  const headers = [];
+  let prevNumerator = 4;
+  let prevDenominator = 4;
+  for (let i = 0; i < count; i++) {
+    if (i > 0) {
+      r.skip(1);
+    }
+    const flags = r.readByte();
+    let numerator = prevNumerator;
+    let denominator = prevDenominator;
+    if (flags & 1) {
+      numerator = r.readSignedByte();
+    }
+    if (flags & 2) {
+      denominator = r.readSignedByte();
+    }
+    const repeatOpen = (flags & 4) !== 0;
+    let repeatClose = -1;
+    if (flags & 8) {
+      repeatClose = r.readSignedByte();
+      if (repeatClose > 0) repeatClose -= 1;
+    }
+    let marker = null;
+    if (flags & 32) {
+      const name = r.readIntByteSizeString();
+      const colorR = r.readByte();
+      const colorG = r.readByte();
+      const colorB = r.readByte();
+      r.skip(1);
+      marker = { name, color: [colorR, colorG, colorB] };
+    }
+    let keySignature = 0;
+    let keyMode = 0;
+    if (flags & 64) {
+      keySignature = r.readSignedByte();
+      keyMode = r.readSignedByte();
+    }
+    const hasDoubleBar = (flags & 128) !== 0;
+    let repeatAlternative = 0;
+    if (flags & 16) {
+      repeatAlternative = r.readByte();
+    }
+    if (flags & 3) {
+      r.skip(4);
+    }
+    if (!(flags & 16)) {
+      r.skip(1);
+    }
+    const tripletFeel = r.readByte();
+    headers.push({
+      numerator,
+      denominator,
+      repeatOpen,
+      repeatClose,
+      repeatAlternative,
+      marker,
+      keySignature,
+      keyMode,
+      hasDoubleBar,
+      tripletFeel
+    });
+    prevNumerator = numerator;
+    prevDenominator = denominator;
+  }
+  return headers;
+}
+function readTrackHeaders(r, count, version) {
+  const tracks = [];
+  for (let i = 0; i < count; i++) {
+    if (i === 0 || versionGreaterThan(version, 5, 0, 0) === false) {
+      r.skip(1);
+    }
+    const flags1 = r.readByte();
+    const isPercussion = (flags1 & 1) !== 0;
+    const name = r.readByteSizeString(40);
+    const numStrings = r.readInt();
+    const tuning = [];
+    for (let s = 0; s < 7; s++) {
+      const val = r.readInt();
+      if (s < numStrings) tuning.push(val);
+    }
+    const port = r.readInt();
+    const channelIndex = r.readInt() - 1;
+    const effectChannel = r.readInt() - 1;
+    const fretCount = r.readInt();
+    const capoFret = r.readInt();
+    r.skip(4);
+    tracks.push({ name, isPercussion, numStrings, tuning, port, channelIndex, effectChannel, fretCount, capoFret });
+    r.readShort();
+    r.readByte();
+    r.readByte();
+    readTrackRSE(r, version);
+  }
+  if (versionGreaterThan(version, 5, 0, 0)) {
+    r.skip(1);
+  } else {
+    r.skip(2);
+  }
+  return tracks;
+}
+function readTrackRSE(r, version) {
+  r.readByte();
+  r.skip(12);
+  r.skip(12);
+  readRSEInstrument(r, version);
+  if (versionGreaterThan(version, 5, 0, 0)) {
+    readEqualizer(r, 4);
+    readRSEInstrumentEffect(r, version);
+  }
+}
+function readRSEInstrument(r, version) {
+  r.readInt();
+  r.readInt();
+  r.readInt();
+  if (versionGreaterThan(version, 5, 0, 0)) {
+    r.readInt();
+  } else {
+    r.readShort();
+    r.skip(1);
+  }
+}
+function readRSEInstrumentEffect(r, version) {
+  if (versionGreaterThan(version, 5, 0, 0)) {
+    r.readIntByteSizeString();
+    r.readIntByteSizeString();
+  }
+}
+function readMeasures(r, measureCount, trackCount, version) {
+  const allMeasures = [];
+  for (let t = 0; t < trackCount; t++) {
+    allMeasures.push([]);
+  }
+  for (let m = 0; m < measureCount; m++) {
+    for (let t = 0; t < trackCount; t++) {
+      const voice1Beats = readVoice(r, version);
+      const voice2Beats = readVoice(r, version);
+      r.readByte();
+      const beats = voice1Beats.length > 0 ? voice1Beats : voice2Beats;
+      allMeasures[t].push(beats);
+    }
+  }
+  return allMeasures;
+}
+function readVoice(r, version) {
+  const beatCount = r.readInt();
+  const beats = [];
+  for (let b = 0; b < beatCount; b++) {
+    beats.push(readBeat(r, version));
+  }
+  return beats;
+}
+function readBeat(r, version) {
+  const flags = r.readByte();
+  let isRest = false;
+  let isEmpty = false;
+  if (flags & 64) {
+    const status = r.readByte();
+    isEmpty = status === 0;
+    isRest = status === 2;
+  }
+  const durationValue = r.readSignedByte();
+  const duration = gpDurationToDuration(durationValue);
+  const dotted = (flags & 1) !== 0;
+  let tuplet = null;
+  if (flags & 32) {
+    const tupletValue = r.readInt();
+    tuplet = TUPLET_MAP[tupletValue] ?? null;
+  }
+  if (flags & 2) {
+    readChord(r, version);
+  }
+  if (flags & 4) {
+    r.readIntByteSizeString();
+  }
+  if (flags & 8) {
+    readBeatEffects(r, version);
+  }
+  if (flags & 16) {
+    readMixTableChange(r, version);
+  }
+  const stringFlags = r.readByte();
+  const notes = [];
+  for (let i = 6; i >= 0; i--) {
+    if (stringFlags & 1 << i) {
+      notes.push(readNote(r, version));
+    }
+  }
+  const flags2 = r.readShort();
+  if (flags2 & 2048) {
+    r.readByte();
+  }
+  return { duration, dotted, tuplet, isRest: isRest || isEmpty, isEmpty, notes };
+}
+function readChord(r, _version) {
+  const header = r.readByte();
+  if (header === 0) {
+    r.readIntByteSizeString();
+    const firstFret = r.readInt();
+    if (firstFret !== 0) {
+      for (let i = 0; i < 6; i++) r.readInt();
+    }
+  } else {
+    r.skip(16);
+    r.readByteSizeString(22);
+    r.readByte();
+    r.readByte();
+    r.readByte();
+    for (let i = 0; i < 6; i++) r.readInt();
+    r.readByte();
+    r.skip(5);
+    r.skip(5);
+    r.skip(5);
+    r.skip(7);
+    r.skip(1);
+    r.skip(7);
+    r.readBool();
+  }
+}
+function readBeatEffects(r, _version) {
+  const flags1 = r.readByte();
+  const flags2 = r.readByte();
+  if (flags1 & 32) {
+    const slapEffect = r.readSignedByte();
+    if (slapEffect === 0) {
+      readBend(r);
+    }
+  }
+  if (flags2 & 4) {
+    readBend(r);
+  }
+  if (flags1 & 64) {
+    r.readByte();
+    r.readByte();
+  }
+  if (flags2 & 2) {
+    r.readSignedByte();
+  }
+}
+function readBend(r) {
+  const type = r.readSignedByte();
+  const value = r.readInt();
+  const pointCount = r.readInt();
+  const points = [];
+  for (let i = 0; i < pointCount; i++) {
+    const position = r.readInt();
+    const pointValue = r.readInt();
+    const vibrato = r.readBool();
+    points.push({ position, value: pointValue, vibrato });
+  }
+  return { type, value, points };
+}
+function readMixTableChange(r, version) {
+  r.readSignedByte();
+  readRSEInstrument(r, version);
+  if (!versionGreaterThan(version, 5, 0, 0)) {
+    r.skip(1);
+  }
+  const volume = r.readSignedByte();
+  const balance = r.readSignedByte();
+  const chorus = r.readSignedByte();
+  const reverb = r.readSignedByte();
+  const phaser = r.readSignedByte();
+  const tremolo = r.readSignedByte();
+  r.readIntByteSizeString();
+  const tempo = r.readInt();
+  if (volume >= 0) r.readSignedByte();
+  if (balance >= 0) r.readSignedByte();
+  if (chorus >= 0) r.readSignedByte();
+  if (reverb >= 0) r.readSignedByte();
+  if (phaser >= 0) r.readSignedByte();
+  if (tremolo >= 0) r.readSignedByte();
+  if (tempo >= 0) {
+    r.readSignedByte();
+    if (versionGreaterThan(version, 5, 0, 0)) {
+      r.readBool();
+    }
+  }
+  r.readByte();
+  r.readSignedByte();
+  readRSEInstrumentEffect(r, version);
+}
+function readNote(r, version) {
+  const flags = r.readByte();
+  const heavyAccent = (flags & 2) !== 0;
+  const accent = (flags & 64) !== 0;
+  let isTied = false;
+  let isDead = false;
+  if (flags & 32) {
+    const noteType = r.readByte();
+    isTied = noteType === 2;
+    isDead = noteType === 3;
+  }
+  let velocity = 8;
+  if (flags & 16) {
+    velocity = r.readSignedByte();
+  }
+  let fret = 0;
+  if (flags & 32) {
+    fret = r.readSignedByte();
+    if (fret < 0 || fret > 99) fret = 0;
+  }
+  if (flags & 128) {
+    r.readSignedByte();
+    r.readSignedByte();
+  }
+  if (flags & 1) {
+    r.readDouble();
+  }
+  r.readByte();
+  let hammerOn = false;
+  let letRing = false;
+  let slide = null;
+  let harmonic = null;
+  let palmMute = false;
+  let vibrato = false;
+  let bend = null;
+  let staccato = false;
+  let trill = null;
+  let tremoloPicking = null;
+  if (flags & 8) {
+    const result = readNoteEffects(r, version);
+    hammerOn = result.hammerOn;
+    letRing = result.letRing;
+    slide = result.slide;
+    harmonic = result.harmonic;
+    palmMute = result.palmMute;
+    vibrato = result.vibrato;
+    bend = result.bend;
+    staccato = result.staccato;
+    trill = result.trill;
+    tremoloPicking = result.tremoloPicking;
+  }
+  return {
+    string: 0,
+    // Will be set by caller based on string index
+    fret,
+    isTied,
+    isDead,
+    velocity,
+    hammerOn,
+    letRing,
+    slide,
+    harmonic,
+    palmMute,
+    vibrato,
+    bend,
+    staccato,
+    heavyAccent,
+    accent,
+    trill,
+    tremoloPicking
+  };
+}
+function readNoteEffects(r, version) {
+  const flags1 = r.readByte();
+  const flags2 = r.readByte();
+  let bend = null;
+  let hammerOn = false;
+  let letRing = false;
+  let slide = null;
+  let harmonic = null;
+  let palmMute = false;
+  let vibrato = false;
+  let staccato = false;
+  let trill = null;
+  let tremoloPicking = null;
+  if (flags1 & 1) {
+    bend = readBend(r);
+  }
+  hammerOn = (flags1 & 2) !== 0;
+  letRing = (flags1 & 8) !== 0;
+  if (flags1 & 16) {
+    readGraceNote(r, version);
+  }
+  staccato = (flags2 & 1) !== 0;
+  palmMute = (flags2 & 2) !== 0;
+  if (flags2 & 4) {
+    tremoloPicking = r.readSignedByte();
+  }
+  if (flags2 & 8) {
+    slide = r.readByte();
+  }
+  if (flags2 & 16) {
+    const harmonicType = r.readSignedByte();
+    harmonic = HARMONIC_TYPE_MAP[harmonicType] ?? null;
+    if (harmonicType === 2) {
+      r.readByte();
+      r.readSignedByte();
+      r.readByte();
+    } else if (harmonicType === 3) {
+      r.readByte();
+    }
+  }
+  if (flags2 & 32) {
+    const trillFret = r.readSignedByte();
+    const trillPeriod = r.readSignedByte();
+    trill = { fret: trillFret, period: trillPeriod };
+  }
+  vibrato = (flags2 & 64) !== 0;
+  return { hammerOn, letRing, slide, harmonic, palmMute, vibrato, bend, staccato, trill, tremoloPicking };
+}
+function readGraceNote(r, version) {
+  r.readByte();
+  r.readByte();
+  r.readByte();
+  r.readByte();
+  if (versionGreaterThan(version, 5, 0, 0)) {
+    r.readByte();
+  } else {
+    r.readByte();
+  }
+}
+function transformToTabSong(info, tempo, measureHeaders, trackHeaders, parsedMeasures, channels) {
+  const tracks = trackHeaders.map((th, trackIdx) => {
+    const tuningPitches = th.tuning;
+    const tuning = tuningPitches.map((midi) => noteFromPitchClass(midiToPitchClass(midi))).reverse();
+    let globalBeatIndex = 0;
+    const bars = [];
+    for (let mIdx = 0; mIdx < measureHeaders.length; mIdx++) {
+      const mh = measureHeaders[mIdx];
+      const beatsData = parsedMeasures[trackIdx]?.[mIdx] ?? [];
+      const tabBeats = [];
+      for (const beatData of beatsData) {
+        if (beatData.isEmpty) continue;
+        const stringCount = th.numStrings;
+        const tabNotes = [];
+        let noteStringIndex = 0;
+        for (const noteData of beatData.notes) {
+          const stringIdx = stringCount - 1 - noteStringIndex;
+          const fret = noteData.fret;
+          const openPitch = tuningPitches[noteStringIndex] ?? 0;
+          const pc = ((openPitch + fret) % 12 + 12) % 12;
+          const note = noteFromPitchClass(pc, false);
+          let bendResult = null;
+          if (noteData.bend) {
+            const points = noteData.bend.points;
+            const origin = points.length > 0 ? points[0].value / 100 : 0;
+            const destination = points.length > 1 ? points[points.length - 1].value / 100 : 0;
+            const middle = points.length > 2 ? points[Math.floor(points.length / 2)].value / 100 : 0;
+            bendResult = { origin, destination, middle };
+          }
+          tabNotes.push({
+            string: stringIdx,
+            fret,
+            pitchClass: pc,
+            noteName: note.name,
+            slide: noteData.slide,
+            harmonic: noteData.harmonic,
+            palmMute: noteData.palmMute,
+            muted: noteData.isDead,
+            letRing: noteData.letRing,
+            bend: bendResult,
+            tie: {
+              origin: false,
+              destination: noteData.isTied
+            },
+            vibrato: noteData.vibrato ? "slight" : null,
+            hammerOn: noteData.hammerOn,
+            pullOff: false,
+            // GP5 uses hammerOn for both — context determines direction
+            tapped: false,
+            accent: noteData.accent ? 1 : noteData.heavyAccent ? 2 : null
+          });
+          noteStringIndex++;
+        }
+        tabBeats.push({
+          index: globalBeatIndex++,
+          barIndex: mIdx,
+          notes: tabNotes,
+          duration: beatData.duration,
+          tuplet: beatData.tuplet,
+          dotted: beatData.dotted ? 1 : 0,
+          isRest: beatData.isRest && tabNotes.length === 0,
+          dynamic: null,
+          tempo
+        });
+      }
+      const section = mh.marker ? { text: mh.marker.name } : null;
+      bars.push({
+        index: mIdx,
+        timeSignature: { numerator: mh.numerator, denominator: mh.denominator },
+        keySignature: mh.keySignature !== 0 ? { accidentalCount: mh.keySignature, mode: mh.keyMode === 1 ? "minor" : "major" } : null,
+        section,
+        beats: tabBeats,
+        repeatStart: mh.repeatOpen,
+        repeatEnd: mh.repeatClose >= 0,
+        repeatCount: mh.repeatClose >= 0 ? mh.repeatClose : 0
+      });
+    }
+    const ch = channels[th.channelIndex];
+    const instrumentName = ch ? `MIDI ${ch.instrument}` : null;
+    return {
+      id: String(trackIdx),
+      name: th.name,
+      shortName: th.name.substring(0, 4),
+      instrument: instrumentName,
+      tuning,
+      capoFret: th.capoFret,
+      bars
+    };
+  });
+  return {
+    title: info.title || info.subtitle || "",
+    artist: info.artist,
+    album: info.album,
+    tempo,
+    tracks
+  };
+}
+function parseGp5File(data) {
+  const buf = new ArrayBuffer(data.byteLength);
+  new Uint8Array(buf).set(data);
+  const r = new GP5Reader(buf);
+  const versionStr = r.readByteSizeString(30);
+  const version = parseVersionString(versionStr);
+  if (version.major !== 5) {
+    throw new Error(`Unsupported Guitar Pro version: ${versionStr} (expected GP5)`);
+  }
+  const info = readInfo(r);
+  readLyrics(r);
+  readRSEMasterEffect(r, version);
+  readPageSetup(r);
+  r.readIntByteSizeString();
+  const tempo = r.readInt();
+  if (versionGreaterThan(version, 5, 0, 0)) {
+    r.readBool();
+  }
+  r.readSignedByte();
+  r.readInt();
+  const channels = readMidiChannels(r);
+  readDirections(r);
+  r.readInt();
+  const measureCount = r.readInt();
+  const trackCount = r.readInt();
+  const measureHeaders = readMeasureHeaders(r, measureCount, version);
+  const trackHeaders = readTrackHeaders(r, trackCount, version);
+  const parsedMeasures = readMeasures(r, measureCount, trackCount, version);
+  return transformToTabSong(info, tempo, measureHeaders, trackHeaders, parsedMeasures, channels);
+}
+
+// src/tab-parser.ts
+function readCentralDirectory(data, view) {
+  let eocdOffset = -1;
+  for (let i = data.byteLength - 22; i >= 0; i--) {
+    if (view.getUint32(i, true) === 101010256) {
+      eocdOffset = i;
+      break;
+    }
+  }
+  if (eocdOffset === -1) return [];
+  const cdOffset = view.getUint32(eocdOffset + 16, true);
+  const cdEntryCount = view.getUint16(eocdOffset + 10, true);
+  const entries = [];
+  let pos = cdOffset;
+  for (let i = 0; i < cdEntryCount; i++) {
+    if (pos + 46 > data.byteLength) break;
+    if (view.getUint32(pos, true) !== 33639248) break;
+    const compressionMethod = view.getUint16(pos + 10, true);
+    const compressedSize = view.getUint32(pos + 20, true);
+    const uncompressedSize = view.getUint32(pos + 24, true);
+    const nameLength = view.getUint16(pos + 28, true);
+    const extraLength = view.getUint16(pos + 30, true);
+    const commentLength = view.getUint16(pos + 32, true);
+    const localHeaderOffset = view.getUint32(pos + 42, true);
+    const nameBytes = data.subarray(pos + 46, pos + 46 + nameLength);
+    const fileName = String.fromCharCode(...nameBytes);
+    entries.push({ fileName, compressionMethod, compressedSize, uncompressedSize, localHeaderOffset });
+    pos += 46 + nameLength + extraLength + commentLength;
+  }
+  return entries;
+}
+function extractFileFromZip(data, targetName) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const entries = readCentralDirectory(data, view);
+  const entry = entries.find((e) => e.fileName === targetName);
+  if (!entry) return null;
+  const localOffset = entry.localHeaderOffset;
+  if (view.getUint32(localOffset, true) !== 67324752) return null;
+  const localNameLength = view.getUint16(localOffset + 26, true);
+  const localExtraLength = view.getUint16(localOffset + 28, true);
+  const dataOffset = localOffset + 30 + localNameLength + localExtraLength;
+  const compressedData = data.subarray(dataOffset, dataOffset + entry.compressedSize);
+  if (entry.compressionMethod === 0) {
+    return compressedData;
+  } else if (entry.compressionMethod === 8) {
+    return decompressDeflateSync(compressedData, entry.uncompressedSize);
+  } else {
+    throw new Error(`Unsupported ZIP compression method: ${entry.compressionMethod}`);
+  }
+}
+function decompressDeflateSync(compressed, expectedSize) {
+  return inflate(compressed, expectedSize);
+}
+function buildFixedLitLenTree() {
+  const lengths = new Uint8Array(288);
+  for (let i = 0; i <= 143; i++) lengths[i] = 8;
+  for (let i = 144; i <= 255; i++) lengths[i] = 9;
+  for (let i = 256; i <= 279; i++) lengths[i] = 7;
+  for (let i = 280; i <= 287; i++) lengths[i] = 8;
+  return buildHuffmanTable(lengths);
+}
+function buildFixedDistTree() {
+  const lengths = new Uint8Array(32);
+  lengths.fill(5);
+  return buildHuffmanTable(lengths);
+}
+function buildHuffmanTable(codeLengths) {
+  const maxBits = Math.max(...codeLengths);
+  const count = new Uint16Array(maxBits + 1);
+  for (const len of codeLengths) {
+    if (len > 0) count[len]++;
+  }
+  const nextCode = new Uint16Array(maxBits + 1);
+  let code = 0;
+  for (let bits = 1; bits <= maxBits; bits++) {
+    code = code + count[bits - 1] << 1;
+    nextCode[bits] = code;
+  }
+  const codes = new Uint16Array(codeLengths.length);
+  const lengths = new Uint8Array(codeLengths.length);
+  for (let i = 0; i < codeLengths.length; i++) {
+    const len = codeLengths[i];
+    if (len > 0) {
+      codes[i] = nextCode[len]++;
+      lengths[i] = len;
+    }
+  }
+  return { codes, lengths };
+}
+var BitReader = class {
+  constructor(data) {
+    this.data = data;
+    this.bytePos = 0;
+    this.bitPos = 0;
+  }
+  readBits(n) {
+    let result = 0;
+    for (let i = 0; i < n; i++) {
+      if (this.bytePos >= this.data.length) return result;
+      result |= (this.data[this.bytePos] >> this.bitPos & 1) << i;
+      this.bitPos++;
+      if (this.bitPos === 8) {
+        this.bitPos = 0;
+        this.bytePos++;
+      }
+    }
+    return result;
+  }
+  alignToByte() {
+    if (this.bitPos > 0) {
+      this.bitPos = 0;
+      this.bytePos++;
+    }
+  }
+  readByte() {
+    return this.data[this.bytePos++];
+  }
+  readBytes(n) {
+    const result = this.data.subarray(this.bytePos, this.bytePos + n);
+    this.bytePos += n;
+    return result;
+  }
+};
+function decodeSymbol(bits, table) {
+  let code = 0;
+  for (let len = 1; len <= 15; len++) {
+    code = code << 1 | bits.readBits(1);
+    for (let i = 0; i < table.codes.length; i++) {
+      if (table.lengths[i] === len && table.codes[i] === code) {
+        return i;
+      }
+    }
+  }
+  throw new Error("Invalid Huffman code");
+}
+var LENGTH_BASE = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
+var LENGTH_EXTRA = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
+var DIST_BASE = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
+var DIST_EXTRA = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
+var CL_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+function inflate(compressed, expectedSize) {
+  const bits = new BitReader(compressed);
+  const output = new Uint8Array(expectedSize);
+  let outPos = 0;
+  let bfinal = 0;
+  while (bfinal === 0) {
+    bfinal = bits.readBits(1);
+    const btype = bits.readBits(2);
+    if (btype === 0) {
+      bits.alignToByte();
+      const len = bits.readByte() | bits.readByte() << 8;
+      bits.readByte();
+      bits.readByte();
+      const block = bits.readBytes(len);
+      output.set(block, outPos);
+      outPos += len;
+    } else {
+      let litLenTree;
+      let distTree;
+      if (btype === 1) {
+        litLenTree = buildFixedLitLenTree();
+        distTree = buildFixedDistTree();
+      } else if (btype === 2) {
+        const hlit = bits.readBits(5) + 257;
+        const hdist = bits.readBits(5) + 1;
+        const hclen = bits.readBits(4) + 4;
+        const clLengths = new Uint8Array(19);
+        for (let i = 0; i < hclen; i++) {
+          clLengths[CL_ORDER[i]] = bits.readBits(3);
+        }
+        const clTree = buildHuffmanTable(clLengths);
+        const allLengths = new Uint8Array(hlit + hdist);
+        let idx = 0;
+        while (idx < hlit + hdist) {
+          const sym = decodeSymbol(bits, clTree);
+          if (sym < 16) {
+            allLengths[idx++] = sym;
+          } else if (sym === 16) {
+            const repeat = bits.readBits(2) + 3;
+            const prev = allLengths[idx - 1];
+            for (let i = 0; i < repeat; i++) allLengths[idx++] = prev;
+          } else if (sym === 17) {
+            const repeat = bits.readBits(3) + 3;
+            for (let i = 0; i < repeat; i++) allLengths[idx++] = 0;
+          } else if (sym === 18) {
+            const repeat = bits.readBits(7) + 11;
+            for (let i = 0; i < repeat; i++) allLengths[idx++] = 0;
+          }
+        }
+        litLenTree = buildHuffmanTable(allLengths.subarray(0, hlit));
+        distTree = buildHuffmanTable(allLengths.subarray(hlit));
+      } else {
+        throw new Error(`Invalid DEFLATE block type: ${btype}`);
+      }
+      while (true) {
+        const sym = decodeSymbol(bits, litLenTree);
+        if (sym < 256) {
+          output[outPos++] = sym;
+        } else if (sym === 256) {
+          break;
+        } else {
+          const lengthIdx = sym - 257;
+          const length = LENGTH_BASE[lengthIdx] + bits.readBits(LENGTH_EXTRA[lengthIdx]);
+          const distSym = decodeSymbol(bits, distTree);
+          const distance = DIST_BASE[distSym] + bits.readBits(DIST_EXTRA[distSym]);
+          for (let i = 0; i < length; i++) {
+            output[outPos] = output[outPos - distance];
+            outPos++;
+          }
+        }
+      }
+    }
+  }
+  return output.subarray(0, outPos);
+}
+function parseGp7File(data) {
+  const gpifData = extractFileFromZip(data, "Content/score.gpif");
+  if (!gpifData) {
+    throw new Error("No Content/score.gpif found in GP7+ archive");
+  }
+  const decoder = new TextDecoder("utf-8");
+  const gpifXml = decoder.decode(gpifData);
+  const DOMParserImpl = getDOMParser();
+  const parser = new DOMParserImpl();
+  const doc = parser.parseFromString(gpifXml, "text/xml");
+  const parseError = doc.querySelector("parsererror");
+  if (parseError) {
+    throw new Error(`Failed to parse GPIF XML: ${parseError.textContent}`);
+  }
+  return gpifToTabSong(doc);
+}
+function detectFormat(data, fileName) {
+  if (data.length < 4) {
+    throw new Error("File too small to be a valid Guitar Pro file");
+  }
+  const header = String.fromCharCode(data[0], data[1], data[2], data[3]);
+  if (header === "BCFZ" || header === "BCFS") {
+    return "gpx";
+  }
+  if (data[0] === 80 && data[1] === 75) {
+    return "gp7";
+  }
+  const strLen = data[0];
+  if (strLen > 10 && strLen < 50 && data.byteLength > strLen + 1) {
+    const versionStr = String.fromCharCode(...Array.from(data.subarray(1, 1 + Math.min(strLen, 40))));
+    if (versionStr.includes("GUITAR PRO")) {
+      return "gp5";
+    }
+  }
+  if (fileName) {
+    const ext = fileName.toLowerCase();
+    if (ext.endsWith(".gpx")) return "gpx";
+    if (ext.endsWith(".gp5") || ext.endsWith(".gp4") || ext.endsWith(".gp3")) return "gp5";
+    if (ext.endsWith(".gp")) return "gp7";
+  }
+  throw new Error("Unrecognized Guitar Pro file format");
+}
+function parseTabFile(data, fileName) {
+  const format = detectFormat(data, fileName);
+  switch (format) {
+    case "gpx":
+      return parseGpxFile(data);
+    case "gp7":
+      return parseGp7File(data);
+    case "gp5":
+      return parseGp5File(data);
+  }
+}
+export {
+  beatDurationMs,
+  detectFormat,
+  durationToBeats,
+  gpifToTabSong,
+  midiToPitchClass,
+  noteFromPitchClass,
+  parseGp5File,
+  parseGpxFile,
+  parseTabFile
+};
+//# sourceMappingURL=index.js.map