@coderline/alphatab-language-server 1.7.0-alpha.1626

package/dist/types/alphatab/src/importer/BinaryStylesheet.d.ts

@@ -0,0 +1,70 @@
+import { type Score } from "./../model/Score";
+import type { IWriteable } from "./../io/IWriteable";
+/**
+ * @internal
+ */
+declare enum DataType {
+    Boolean = 0,
+    Integer = 1,
+    Float = 2,
+    String = 3,
+    Point = 4,
+    Size = 5,
+    Rectangle = 6,
+    Color = 7
+}
+/**
+ * A BinaryStylesheet from Guitar Pro 6 and 7 files.
+ * The BinaryStylesheet is a simple binary key-value store for additional settings
+ * related to the display of the music sheet.
+ *
+ * File:
+ *     int32 (big endian) | Number of KeyValuePairs
+ *     KeyValuePair[]     | The raw records
+ *
+ * KeyValuePair:
+ *     1 Byte  | length of the key
+ *     n Bytes | key as utf8 encoded string
+ *     1 Byte  | Data Type
+ *     n Bytes | Value
+ *
+ * Values based on Data Type:
+ *     0 = bool
+ *         0===false
+ *     1 = int32 (big endian)
+ *     2 = float (big endian, IEEE)
+ *     3 = string
+ *       int16 (big endian) | length of string
+ *       n bytes            | utf-8 encoded string
+ *     4 = point
+ *       int32 (big endian) | X-coordinate
+ *       int32 (big endian) | Y-coordinate
+ *     5 = size
+ *       int32 (big endian) | Width
+ *       int32 (big endian) | Height
+ *     6 = rectangle
+ *       int32 (big endian) | X-coordinate
+ *       int32 (big endian) | Y-coordinate
+ *       int32 (big endian) | Width
+ *       int32 (big endian) | Height
+ *     7 = color
+ *       1 byte | Red
+ *       1 byte | Green
+ *       1 byte | Blue
+ *       1 byte | Alpha
+ * @internal
+ */
+export declare class BinaryStylesheet {
+    private readonly _types;
+    readonly raw: Map<string, unknown>;
+    constructor(data?: Uint8Array);
+    private _read;
+    apply(score: Score): void;
+    private _toTextAlign;
+    addValue(key: string, value: unknown, type?: DataType): void;
+    writeTo(writer: IWriteable): void;
+    private _getDataType;
+    static writeForScore(score: Score): Uint8Array;
+    private static _addHeaderAndFooter;
+}
+export {};

package/dist/types/alphatab/src/importer/CapellaImporter.d.ts

@@ -0,0 +1,10 @@
+import { ScoreImporter } from "./ScoreImporter";
+import type { Score } from "./../model/Score";
+/**
+ * This ScoreImporter can read Capella (cap/capx) files.
+ * @internal
+ */
+export declare class CapellaImporter extends ScoreImporter {
+    get name(): string;
+    readScore(): Score;
+}

package/dist/types/alphatab/src/importer/CapellaParser.d.ts

@@ -0,0 +1,75 @@
+import { Score } from "./../model/Score";
+import type { Settings } from "./../Settings";
+/**
+ * @internal
+ */
+export declare class CapellaParser {
+    score: Score;
+    private _trackChannel;
+    private _beamingMode;
+    private _galleryObjects;
+    private _voiceCounts;
+    private _isFirstSystem;
+    private _initialTempo;
+    parseXml(xml: string, settings: Settings): void;
+    private _consolidate;
+    private static _applyEffectRange;
+    private _parseDom;
+    private _staffLookup;
+    private _parseLayout;
+    private _brackets;
+    private _parseBrackets;
+    private _parseBracket;
+    private _parseLayoutStaves;
+    private _staffLayoutLookup;
+    private _staffLayouts;
+    private _parseStaffLayout;
+    private _parseClef;
+    private _parseClefOttava;
+    private _parseSystems;
+    private _parseSystem;
+    private _parseStaves;
+    private _timeSignature;
+    private _currentStaffLayout;
+    private _parseStaff;
+    private _parseTime;
+    private _parseVoices;
+    private _getOrCreateBar;
+    private _addNewBar;
+    private _voiceStates;
+    private _currentVoiceState;
+    private _currentBar;
+    private _currentVoice;
+    private _newBar;
+    private _parseVoice;
+    private _initFromPreviousBeat;
+    private _getLastBeat;
+    private _ensureVoice;
+    private _parseChord;
+    private _parseHeads;
+    private _tieStarts;
+    private _tieStartIds;
+    private _slurs;
+    private _crescendo;
+    private _parseHead;
+    private _parseBeatDrawObject;
+    private _parseBarDrawObject;
+    private _applyVolta;
+    private _parseLyric;
+    private _parseRestDurations;
+    private _parseDurationValue;
+    private _parseDuration;
+    private _parsePageObjects;
+    private _parseGallery;
+    private _parseDrawObj;
+    private _parseTrill;
+    private _parseOctaveClef;
+    private _parseVolta;
+    private _parseWedge;
+    private _parseTupletBracket;
+    private _parseWavyLine;
+    private _parseSlur;
+    private _parseGuitar;
+    private _parseText;
+    private _parseInfo;
+}

package/dist/types/alphatab/src/importer/Gp3To5Importer.d.ts

@@ -0,0 +1,95 @@
+import { ScoreImporter } from "./ScoreImporter";
+import type { IReadable } from "./../io/IReadable";
+import { Bar } from "./../model/Bar";
+import { Beat } from "./../model/Beat";
+import { Color } from "./../model/Color";
+import { DynamicValue } from "./../model/DynamicValue";
+import { HarmonicType } from "./../model/HarmonicType";
+import { Note } from "./../model/Note";
+import { Score } from "./../model/Score";
+import { Track } from "./../model/Track";
+import { Voice } from "./../model/Voice";
+import type { IWriteable } from "./../io/IWriteable";
+/**
+ * @internal
+ */
+export declare class Gp3To5Importer extends ScoreImporter {
+    private static readonly _versionString;
+    private _versionNumber;
+    private _score;
+    private _globalTripletFeel;
+    private _lyricsTrack;
+    private _lyrics;
+    private _barCount;
+    private _trackCount;
+    private _playbackInfos;
+    private _doubleBars;
+    private _clefsPerTrack;
+    private _keySignatures;
+    private _beatTextChunksByTrack;
+    private _directionLookup;
+    private _initialTempo;
+    get name(): string;
+    readScore(): Score;
+    private _readDirection;
+    readVersion(): void;
+    readScoreInformation(): void;
+    readLyrics(): void;
+    readPageSetup(): void;
+    readPlaybackInfos(): void;
+    readMasterBars(): void;
+    readMasterBar(): void;
+    readTracks(): void;
+    readTrack(): void;
+    readBars(): void;
+    readBar(track: Track): void;
+    readVoice(track: Track, bar: Bar): void;
+    readBeat(track: Track, bar: Bar, voice: Voice): void;
+    readChord(beat: Beat): void;
+    readBeatEffects(beat: Beat): HarmonicType;
+    readTremoloBarEffect(beat: Beat): void;
+    private static _toStrokeValue;
+    private _readRseBank;
+    readMixTableChange(beat: Beat): void;
+    readNote(track: Track, bar: Bar, voice: Voice, beat: Beat, stringIndex: number): Note;
+    toDynamicValue(value: number): DynamicValue;
+    readNoteEffects(_track: Track, voice: Voice, beat: Beat, note: Note): void;
+    private static readonly _bendStep;
+    readBend(note: Note): void;
+    readGrace(voice: Voice, note: Note): void;
+    readTremoloPicking(beat: Beat): void;
+    readSlide(note: Note): void;
+    readArtificialHarmonic(note: Note): void;
+    readTrill(note: Note): void;
+}
+/**
+ * @internal
+ */
+export declare class GpBinaryHelpers {
+    static gpReadColor(data: IReadable, readAlpha?: boolean): Color;
+    static gpReadBool(data: IReadable): boolean;
+    /**
+     * Skips an integer (4byte) and reads a string using
+     * a bytesize
+     */
+    static gpReadStringIntUnused(data: IReadable, encoding: string): string;
+    /**
+     * Reads an integer as size, and then the string itself
+     */
+    static gpReadStringInt(data: IReadable, encoding: string): string;
+    /**
+     * Reads an integer as size, skips a byte and reads the string itself
+     */
+    static gpReadStringIntByte(data: IReadable, encoding: string): string;
+    static gpReadString(data: IReadable, length: number, encoding: string): string;
+    static gpWriteString(data: IWriteable, s: string): void;
+    /**
+     * Reads a byte as size and the string itself.
+     * Additionally it is ensured the specified amount of bytes is read.
+     * @param data the data to read from.
+     * @param length the amount of bytes to read
+     * @param encoding The encoding to use to decode the byte into a string
+     * @returns
+     */
+    static gpReadStringByteLength(data: IReadable, length: number, encoding: string): string;
+}

package/dist/types/alphatab/src/importer/Gp7To8Importer.d.ts

@@ -0,0 +1,10 @@
+import { ScoreImporter } from "./ScoreImporter";
+import type { Score } from "./../model/Score";
+/**
+ * This ScoreImporter can read Guitar Pro 7 and 8 (gp) files.
+ * @internal
+ */
+export declare class Gp7To8Importer extends ScoreImporter {
+    get name(): string;
+    readScore(): Score;
+}

package/dist/types/alphatab/src/importer/GpifParser.d.ts

@@ -0,0 +1,131 @@
+import { Duration } from "./../model/Duration";
+import { Score } from "./../model/Score";
+import type { Settings } from "./../Settings";
+/**
+ * This structure represents a duration within a gpif
+ * @internal
+ */
+export declare class GpifRhythm {
+    id: string;
+    dots: number;
+    tupletDenominator: number;
+    tupletNumerator: number;
+    value: Duration;
+}
+/**
+ * This class can parse a score.gpif xml file into the model structure
+ * @internal
+ */
+export declare class GpifParser {
+    private static readonly _invalidId;
+    /**
+     * GPX range: 0-100
+     * Internal range: 0 - 60
+     */
+    private static readonly _bendPointPositionFactor;
+    /**
+     * GPIF: 25 per quarternote
+     * Internal Range: 1 per quarter note
+     */
+    private static readonly _bendPointValueFactor;
+    private static readonly _sampleRate;
+    score: Score;
+    private _backingTrackAssetId;
+    private _masterTrackAutomations;
+    private _automationsPerTrackIdAndBarIndex;
+    private _sustainPedalsPerTrackIdAndBarIndex;
+    private _tracksMapping;
+    private _tracksById;
+    private _masterBars;
+    private _barsOfMasterBar;
+    private _barsById;
+    private _voicesOfBar;
+    private _voiceById;
+    private _beatsOfVoice;
+    private _rhythmOfBeat;
+    private _beatById;
+    private _rhythmById;
+    private _noteById;
+    private _notesOfBeat;
+    private _tappedNotes;
+    private _lyricsByTrack;
+    private _soundsByTrack;
+    private _hasAnacrusis;
+    private _articulationByName;
+    private _skipApplyLyrics;
+    private _backingTrackPadding;
+    private _doubleBars;
+    private _keySignatures;
+    loadAsset?: (fileName: string) => Uint8Array | undefined;
+    parseXml(xml: string, settings: Settings): void;
+    private _parseDom;
+    private _parseAssets;
+    private _parseBackingTrackAsset;
+    private _parseScoreNode;
+    private static _parseIntSafe;
+    private static _parseFloatSafe;
+    private static _splitSafe;
+    private _parseBackingTrackNode;
+    private _parseMasterTrackNode;
+    private _parseAutomations;
+    private _parseAutomation;
+    private _parseTracksNode;
+    private _parseTrack;
+    private _parseTrackAutomations;
+    private _parseNotationPatch;
+    private _parseInstrumentSet;
+    private _parseElements;
+    private _parseElement;
+    private _parseArticulations;
+    private _parseArticulation;
+    private _parseTechniqueSymbol;
+    private _parseNoteHead;
+    private _parseStaves;
+    private _parseStaff;
+    private _parseStaffProperties;
+    private _parseStaffProperty;
+    private _parseLyrics;
+    private _parseLyricsLine;
+    private _parseDiagramCollectionForTrack;
+    private _parseDiagramCollectionForStaff;
+    private _parseDiagramItemForTrack;
+    private _parseDiagramItemForStaff;
+    private _parseDiagramItemForChord;
+    private _parseTrackProperties;
+    private _parseTrackProperty;
+    private _parseGeneralMidi;
+    private _parseSounds;
+    private _parseSound;
+    private _parseSoundMidi;
+    private _parsePartSounding;
+    private _transposeKeySignaturePerTrack;
+    private _parseTranspose;
+    private _parseRSE;
+    private _parseChannelStrip;
+    private _parseChannelStripParameters;
+    private _parseMasterBarsNode;
+    private _parseMasterBar;
+    private _parseDirections;
+    private _parseFermatas;
+    private _parseFermata;
+    private _parseBars;
+    private _parseBar;
+    private _parseVoices;
+    private _parseVoice;
+    private _parseBeats;
+    private _parseBeat;
+    private _parseBeatLyrics;
+    private _parseBeatXProperties;
+    private _parseBarXProperties;
+    private _parseMasterBarXProperties;
+    private _parseBeatProperties;
+    private _parseNotes;
+    private _parseNote;
+    private _parseNoteProperties;
+    private _parseConcertPitch;
+    private _toBendValue;
+    private _toBendOffset;
+    private _parseRhythms;
+    private _parseRhythm;
+    private _buildModel;
+}

package/dist/types/alphatab/src/importer/GpxFileSystem.d.ts

@@ -0,0 +1,82 @@
+import { BitReader } from "./../io/BitReader";
+import { type IReadable } from "./../io/IReadable";
+/**
+ * this public class represents a file within the GpxFileSystem
+ * @internal
+ */
+export declare class GpxFile {
+    fileName: string;
+    fileSize: number;
+    data: Uint8Array | null;
+}
+/**
+ * This public class represents the file system structure
+ * stored within a GPX container file.
+ * @internal
+ */
+export declare class GpxFileSystem {
+    static readonly HeaderBcFs: string;
+    static readonly HeaderBcFz: string;
+    /**
+     * You can set a file filter method using this setter. On parsing
+     * the filestructure this function can determine based on the filename
+     * whether this file will be available after loading.
+     * This way we can reduce the amount of memory we store.
+     */
+    fileFilter: (fileName: string) => boolean;
+    /**
+     * Gets the list of files stored in this FileSystem.
+     */
+    files: GpxFile[];
+    /**
+     * Creates a new GpxFileSystem instance
+     */
+    constructor();
+    /**
+     * Load a complete FileSystem to the memory.
+     * @param s the binary source to read from.
+     * @returns
+     */
+    load(s: IReadable): void;
+    /**
+     * Reads the 4 byte header as a string.
+     * @param src the BitInput to read from
+     * @returns a string with 4 characters representing the header.
+     */
+    readHeader(src: BitReader): string;
+    /**
+     * Decompresses the given bitinput using the GPX compression format. Only use this method
+     * if you are sure the binary data is compressed using the GPX format. Otherwise unexpected
+     * behavior can occure.
+     * @param src the bitInput to read the data from
+     * @param skipHeader true if the header should NOT be included in the result byteset, otherwise false
+     * @returns the decompressed byte data. if skipHeader is set to false the BCFS header is included.
+     */
+    decompress(src: BitReader, skipHeader?: boolean): Uint8Array;
+    /**
+     * Reads a block from the given data source.
+     * @param data the data source
+     * @returns
+     */
+    private _readBlock;
+    /**
+     * Reads an uncompressed data block into the model.
+     * @param data the data store to read from.
+     */
+    private _readUncompressedBlock;
+    /**
+     * Reads a zeroterminated ascii string from the given source
+     * @param data the data source to read from
+     * @param offset the offset to start reading from
+     * @param length the max length to read
+     * @returns the ascii string read from the datasource.
+     */
+    private _getString;
+    /**
+     * Reads an 4 byte signed integer from the given source
+     * @param data the data source to read from
+     * @param offset offset the offset to start reading from
+     * @returns
+     */
+    private _getInteger;
+}

package/dist/types/alphatab/src/importer/GpxImporter.d.ts

@@ -0,0 +1,10 @@
+import { ScoreImporter } from "./ScoreImporter";
+import type { Score } from "./../model/Score";
+/**
+ * This ScoreImporter can read Guitar Pro 6 (gpx) files.
+ * @internal
+ */
+export declare class GpxImporter extends ScoreImporter {
+    get name(): string;
+    readScore(): Score;
+}

package/dist/types/alphatab/src/importer/LayoutConfiguration.d.ts

@@ -0,0 +1,38 @@
+import type { Score } from "./../model/Score";
+import type { PartConfiguration } from "./PartConfiguration";
+/**
+ * @internal
+ */
+declare class LayoutConfigurationScoreView {
+    trackViewGroups: LayoutConfigurationTrackViewGroup[];
+}
+/**
+ * @internal
+ */
+declare class LayoutConfigurationTrackViewGroup {
+    isVisible: boolean;
+}
+/**
+ * @internal
+ */
+declare enum GuitarProView {
+    PageVertical = 0,
+    PageGrid = 1,
+    PageParchment = 2,
+    ScreenVertical = 3,
+    ScreenHorizontal = 4,
+    PageHorizontal = 5
+}
+/**
+ * @internal
+ */
+export declare class LayoutConfiguration {
+    zoomLevel: number;
+    view: GuitarProView;
+    muiltiVoiceCursor: boolean;
+    scoreViews: LayoutConfigurationScoreView[];
+    constructor(partConfiguration: PartConfiguration, layoutConfigurationData: Uint8Array);
+    apply(score: Score): void;
+    static writeForScore(score: Score): Uint8Array;
+}
+export {};

package/dist/types/alphatab/src/importer/MusicXmlImporter.d.ts

@@ -0,0 +1,128 @@
+import { ScoreImporter } from "./ScoreImporter";
+import { Score } from "./../model/Score";
+/**
+ * @internal
+ */
+export declare class MusicXmlImporter extends ScoreImporter {
+    private _score;
+    private _idToTrackInfo;
+    private _indexToTrackInfo;
+    private _staffToContext;
+    private _divisionsPerQuarterNote;
+    private _currentDynamics;
+    get name(): string;
+    readScore(): Score;
+    private _extractMusicXml;
+    private _parseDom;
+    private _parsePartwise;
+    private _parseTimewise;
+    private _parseCredit;
+    private static _sanitizeDisplay;
+    private _parseIdentification;
+    private _parseEncoding;
+    private _parseMovementTitle;
+    private _parsePartList;
+    private _parseScorePart;
+    private _parseScoreInstrument;
+    private _parseScorePartMidiInstrument;
+    private static _interpolatePercent;
+    private static _interpolatePan;
+    private static _interpolate;
+    private _parsePartDisplayAsText;
+    private _parseWork;
+    private _parsePartwisePart;
+    private _parsePartwiseMeasure;
+    private _parseTimewiseMeasure;
+    private _getOrCreateMasterBar;
+    private _parseTimewisePart;
+    /**
+     * The current musical position within the bar.
+     */
+    private _musicalPosition;
+    /**
+     * The last known beat which was parsed. Might be used
+     * to access the current voice/staff (e.g. on rests when we don't have notes)
+     */
+    private _lastBeat;
+    private _parsePartMeasure;
+    private _parsePrint;
+    private _applySimileMarks;
+    private _clearBar;
+    private _parseBarLine;
+    private _parseRepeat;
+    private _nextMasterBarRepeatEnding;
+    private _parseEnding;
+    private _parseBarStyle;
+    private _parseSound;
+    private _parseSwing;
+    private _nextBeatAutomations;
+    private _nextBeatChord;
+    private _nextBeatCrescendo;
+    private _nextBeatLetRing;
+    private _nextBeatPalmMute;
+    private _nextBeatOttavia;
+    private _nextBeatText;
+    private _parseSoundMidiInstrument;
+    private _parseHarmony;
+    private _parseDegree;
+    private _parseHarmonyRoot;
+    private _parseHarmonyKind;
+    private _parseHarmonyFrame;
+    private _parseAttributes;
+    private _simileMarkAllStaves;
+    private _simileMarkPerStaff;
+    private _isBeatSlash;
+    private _parseMeasureStyle;
+    private _parseTranspose;
+    private _parseStaffDetails;
+    private _parseStaffTuning;
+    private _parseClef;
+    private _parseTime;
+    private _keyAllStaves;
+    private _parseKey;
+    private _parseDirection;
+    private _parseOctaveShift;
+    private _parseMetronome;
+    private _hasSameTempo;
+    private _parsePedal;
+    private _parseDynamics;
+    private _parseForward;
+    private _parseBackup;
+    private _getOrCreateStaff;
+    private _getOrCreateBar;
+    private _getOrCreateVoice;
+    private _parseNote;
+    private _parsePlay;
+    private static readonly _b4Value;
+    private _estimateBeamDirection;
+    private _parseNoteHead;
+    private _createRestForGap;
+    private _insertBeatToVoice;
+    private _musicXmlDivisionsToAlphaTabTicks;
+    private _parseBeatDuration;
+    private static _allDurations;
+    private static _allDurationTicks;
+    private _applyBeatDurationFromTicks;
+    private _parseLyric;
+    private _parseNotations;
+    private _getStaffContext;
+    private _parseGlissando;
+    private _parseSlur;
+    private _parseArpeggiate;
+    private _parseFermata;
+    private _parseArticulations;
+    private _parseTechnical;
+    private _parseBends;
+    private _parseFingering;
+    private _currentTrillStep;
+    private _parseOrnaments;
+    private _parseSlide;
+    private _parseTied;
+    private _parseStem;
+    private _parseAccidental;
+    private _calculatePitchedNoteValue;
+    private _parseDuration;
+    private _parseUnpitched;
+    private _parsePitch;
+    private _applyNoteHead;
+}

package/dist/types/alphatab/src/importer/PartConfiguration.d.ts

@@ -0,0 +1,27 @@
+import type { Score } from "./../model/Score";
+/**
+ * @internal
+ */
+declare class PartConfigurationScoreView {
+    isMultiRest: boolean;
+    trackViewGroups: PartConfigurationTrackViewGroup[];
+}
+/**
+ * @internal
+ */
+declare class PartConfigurationTrackViewGroup {
+    showNumbered: boolean;
+    showSlash: boolean;
+    showStandardNotation: boolean;
+    showTablature: boolean;
+}
+/**
+ * @internal
+ */
+export declare class PartConfiguration {
+    scoreViews: PartConfigurationScoreView[];
+    apply(score: Score): void;
+    constructor(partConfigurationData: Uint8Array);
+    static writeForScore(score: Score): Uint8Array;
+}
+export {};