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

package/dist/types/alphatab/src/synth/vorbis/VorbisStreamDecoder.d.ts

@@ -0,0 +1,260 @@
+import type { VorbisStream } from "./VorbisStream";
+import type { OggPacket } from "./OggReader";
+import { IntBitReader } from "./IntBitReader";
+/**
+ * @internal
+ */
+export declare class VorbisSetupHeader {
+    codebooks: VorbisCodebook[];
+    timeDomainTransforms: VorbisTimeDomainTransform[];
+    floors: VorbisFloor[];
+    residues: VorbisResidue[];
+    mappings: VorbisMapping[];
+    modes: VorbisMode[];
+}
+/**
+ * @internal
+ */
+interface IFastList {
+    get(index: number): number;
+}
+/**
+ * @internal
+ */
+export declare class VorbisCodebook {
+    private _lengths;
+    private _maxBits;
+    private _overflowList;
+    private _prefixList;
+    private _prefixBitLength;
+    private _lookupTable;
+    dimensions: number;
+    entries: number;
+    mapType: number;
+    constructor(packet: IntBitReader, huffman: Huffman);
+    get(entry: number, dim: number): number;
+    decodeScalar(packet: IntBitReader): number;
+    private _initTree;
+    private _computeCodewords;
+    private _addEntry;
+    private _initLookupTable;
+    private _lookup1Values;
+}
+/**
+ * @internal
+ */
+declare class HuffmanListNode {
+    value: number;
+    length: number;
+    bits: number;
+    mask: number;
+}
+/**
+ * @internal
+ */
+export declare class Huffman {
+    static readonly maxTableBits = 10;
+    tableBits: number;
+    prefixTree: (HuffmanListNode | null)[];
+    overflowList: (HuffmanListNode | null)[] | null;
+    generateTable(values: IFastList, lengthList: Int32Array, codeList: Int32Array | null): void;
+}
+/**
+ * @internal
+ */
+export declare class VorbisTimeDomainTransform {
+    constructor(packet: IntBitReader);
+}
+/**
+ * @internal
+ */
+export interface IVorbisFloorData {
+    readonly executeChannel: boolean;
+    forceEnergy: boolean;
+    forceNoEnergy: boolean;
+}
+/**
+ * @internal
+ */
+export interface IVorbisFloor {
+    unpack(packet: IntBitReader, blockSize: number, channel: number): IVorbisFloorData;
+    apply(floorData: IVorbisFloorData, blockSize: number, residue: Float32Array): void;
+}
+/**
+ * @internal
+ */
+export declare class VorbisFloor0 implements IVorbisFloor {
+    private _order;
+    private _rate;
+    private _barkMapSize;
+    private _ampBits;
+    private _ampOfs;
+    private _ampDiv;
+    private _books;
+    private _bookBits;
+    private _wMap;
+    private _barkMaps;
+    constructor(packet: IntBitReader, block0Size: number, block1Size: number, codebooks: VorbisCodebook[]);
+    private _synthesizeBarkCurve;
+    private static _toBARK;
+    private _synthesizeWDelMap;
+    unpack(packet: IntBitReader, _blockSize: number, _channel: number): IVorbisFloorData;
+    apply(floorData: IVorbisFloorData, blockSize: number, residue: Float32Array): void;
+}
+/**
+ * @internal
+ */
+export declare class VorbisFloor1 implements IVorbisFloor {
+    private static readonly _rangeLookup;
+    private static readonly _yBitsLookup;
+    private _partitionClass;
+    private _classDimensions;
+    private _classSubclasses;
+    private _xList;
+    private _classMasterBookIndex;
+    private _hNeigh;
+    private _lNeigh;
+    private _sortIdx;
+    private _multiplier;
+    private _range;
+    private _yBits;
+    private _classMasterbooks;
+    private _subclassBooks;
+    private _subclassBookIndex;
+    constructor(packet: IntBitReader, codebooks: VorbisCodebook[]);
+    unpack(packet: IntBitReader, _blockSize: number, _channel: number): IVorbisFloorData;
+    apply(floorData: IVorbisFloorData, blockSize: number, residue: Float32Array): void;
+    private _unwrapPosts;
+    private _renderPoint;
+    private _renderLineMulti;
+    private static readonly _inverseDbTable;
+}
+/**
+ * @internal
+ */
+export declare class VorbisFloor implements IVorbisFloor {
+    floor: IVorbisFloor;
+    constructor(packet: IntBitReader, block0Size: number, block1Size: number, codebooks: VorbisCodebook[]);
+    apply(floorData: IVorbisFloorData, blockSize: number, residue: Float32Array): void;
+    unpack(packet: IntBitReader, blockSize: number, channel: number): IVorbisFloorData;
+}
+/**
+ * @internal
+ */
+export interface IVorbisResidue {
+    decode(packet: IntBitReader, doNotDecodeChannel: boolean[], blockSize: number, buffer: Float32Array[]): void;
+}
+/**
+ * @internal
+ */
+export declare class VorbisResidue0 implements IVorbisResidue {
+    private _channels;
+    private _begin;
+    private _end;
+    private _partitionSize;
+    private _classifications;
+    private _maxStages;
+    private _books;
+    private _classBook;
+    private _cascade;
+    private _decodeMap;
+    constructor(packet: IntBitReader, channels: number, codebooks: VorbisCodebook[]);
+    private static _icount;
+    decode(packet: IntBitReader, doNotDecodeChannel: boolean[], blockSize: number, buffer: Float32Array[]): void;
+    protected writeVectors(codebook: VorbisCodebook, packet: IntBitReader, residue: Float32Array[], channel: number, offset: number, partitionSize: number): boolean;
+}
+/**
+ * @internal
+ */
+export declare class VorbisResidue1 extends VorbisResidue0 {
+    protected writeVectors(codebook: VorbisCodebook, packet: IntBitReader, residue: Float32Array[], channel: number, offset: number, partitionSize: number): boolean;
+}
+/**
+ * @internal
+ */
+export declare class VorbisResidue2 extends VorbisResidue0 {
+    private _realChannels;
+    constructor(packet: IntBitReader, channels: number, codebooks: VorbisCodebook[]);
+    decode(packet: IntBitReader, doNotDecodeChannel: boolean[], blockSize: number, buffer: Float32Array[]): void;
+    protected writeVectors(codebook: VorbisCodebook, packet: IntBitReader, residue: Float32Array[], _channel: number, offset: number, partitionSize: number): boolean;
+}
+/**
+ * @internal
+ */
+export declare class VorbisResidue implements IVorbisResidue {
+    residue: IVorbisResidue;
+    constructor(packet: IntBitReader, channels: number, codebooks: VorbisCodebook[]);
+    decode(packet: IntBitReader, doNotDecodeChannel: boolean[], blockSize: number, buffer: Float32Array[]): void;
+}
+/**
+ * @internal
+ */
+export declare class VorbisMapping {
+    private _mdct;
+    private _couplingAngle;
+    private _couplingMangitude;
+    private _submapFloor;
+    private _submapResidue;
+    private _channelFloor;
+    private _channelResidue;
+    constructor(packet: IntBitReader, channels: number, floors: VorbisFloor[], residues: VorbisResidue[], mdct: Mdct);
+    decodePacket(packet: IntBitReader, blockSize: number, buffer: Float32Array[]): void;
+}
+/**
+ * @internal
+ */
+declare class VorbisModeOverlapInfo {
+    packetStartIndex: number;
+    packetTotalLength: number;
+    packetValidLength: number;
+}
+/**
+ * @internal
+ */
+export declare class VorbisMode {
+    private static readonly _piHalf;
+    private _channels;
+    private _blockFlag;
+    private _blockSize;
+    private _mapping;
+    private _windows;
+    private _overlapInfo;
+    constructor(packet: IntBitReader, channels: number, block0Size: number, block1Size: number, mappings: VorbisMapping[]);
+    decode(reader: IntBitReader, buffer: Float32Array[]): VorbisModeOverlapInfo;
+    private _getPacketInfo;
+    private static _calcWindow;
+    private static _calcOverlap;
+}
+/**
+ * @internal
+ */
+export declare class Mdct {
+    private _setupCache;
+    reverse(samples: Float32Array, sampleCount: number): void;
+}
+/**
+ * @internal
+ */
+export declare class VorbisStreamDecoder {
+    private _stream;
+    private _setup;
+    private _packets;
+    private _packetIndex;
+    private _nextPacketBuf;
+    private _prevPacketBuf;
+    private _prevPacketStart;
+    private _prevPacketEnd;
+    private _prevPacketStop;
+    private _currentPosition;
+    private _hasPosition;
+    private _eosFound;
+    private _modeFieldBits;
+    constructor(stream: VorbisStream, setup: VorbisSetupHeader, packets: OggPacket[]);
+    decode(): Float32Array<ArrayBuffer>;
+    read(buffer: Float32Array, offset: number, count: number): number;
+    private _copyBuffer;
+    private _readNextPacket;
+    private static _overlapBuffers;
+    private _decodeNextPacket;
+}
+export {};

package/dist/types/alphatab/src/synth/vorbis/VorbisStreamReader.d.ts

@@ -0,0 +1,49 @@
+import type { OggPacket } from "./OggReader";
+import { VorbisStream } from "./VorbisStream";
+/**
+ * @internal
+ */
+export declare class VorbisStreamReader {
+    static readonly vorbisHeaderMarker: Uint8Array<ArrayBuffer>;
+    private readonly _packets;
+    private _packetIndex;
+    constructor(packets: OggPacket[]);
+    read(): VorbisStream | null;
+    private _nextPacket;
+    private _readStream;
+    /**
+     * https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-610004.2
+     * @param packetType
+     * @param reader
+     * @returns
+     */
+    private _commonHeaderDecode;
+    /**
+     * https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-610004.2
+     * @param packetType
+     * @param reader
+     * @returns
+     */
+    private _commonHeaderDecodeBit;
+    /**
+     * https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-630004.2.2
+     * @param stream
+     * @param packet
+     * @returns
+     */
+    private _readIdentificationHeader;
+    private static _isAllowedBlockSize;
+    /**
+     * https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-820005
+     * @param packet
+     * @returns
+     */
+    private _readComments;
+    /**
+     * https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-650004.2.4
+     * @param setup
+     * @param packet
+     * @returns
+     */
+    private _readSetupHeader;
+}

package/dist/types/alphatab/src/util/FontLoadingChecker.d.ts

@@ -0,0 +1,16 @@
+import { type IEventEmitterOfT } from "./../EventEmitter";
+/**
+ * This small utility helps to detect whether a particular font is already loaded.
+ * @target web
+ * @internal
+ */
+export declare class FontLoadingChecker {
+    private _originalFamilies;
+    private _families;
+    private _isStarted;
+    isFontLoaded: boolean;
+    fontLoaded: IEventEmitterOfT<string>;
+    constructor(families: string[]);
+    checkForFontAvailability(): void;
+    private _isFontAvailable;
+}

package/dist/types/alphatab/src/util/Lazy.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @target web
+ * @internal
+ */
+export declare class Lazy<T> {
+    private _factory;
+    private _value;
+    get hasValue(): boolean;
+    constructor(factory: () => T);
+    get value(): T;
+    reset(): void;
+}

package/dist/types/alphatab/src/xml/XmlDocument.d.ts

@@ -0,0 +1,10 @@
+import { XmlNode } from "./XmlNode";
+/**
+ * @internal
+ */
+export declare class XmlDocument extends XmlNode {
+    constructor();
+    parse(xml: string): void;
+    toString(): string;
+    toFormattedString(indention?: string, xmlHeader?: boolean): string;
+}

package/dist/types/alphatab/src/xml/XmlError.d.ts

@@ -0,0 +1,9 @@
+import { AlphaTabError } from "./../AlphaTabError";
+/**
+ * @internal
+ */
+export declare class XmlError extends AlphaTabError {
+    xml: string;
+    pos: number;
+    constructor(message: string, xml: string, pos: number);
+}

package/dist/types/alphatab/src/xml/XmlNode.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @internal
+ */
+export declare enum XmlNodeType {
+    None = 0,
+    Element = 1,
+    Text = 2,
+    CDATA = 3,
+    Document = 4,
+    DocumentType = 5,
+    Comment = 6
+}
+/**
+ * @internal
+ */
+export declare class XmlNode {
+    nodeType: XmlNodeType;
+    localName: string | null;
+    value: string | null;
+    childNodes: XmlNode[];
+    attributes: Map<string, string>;
+    firstChild: XmlNode | null;
+    firstElement: XmlNode | null;
+    childElements(): Generator<XmlNode, void, unknown>;
+    addChild(node: XmlNode): void;
+    getAttribute(name: string, defaultValue?: string): string;
+    getElementsByTagName(name: string, recursive?: boolean): XmlNode[];
+    private _searchElementsByTagName;
+    findChildElement(name: string): XmlNode | null;
+    addElement(name: string): XmlNode;
+    get innerText(): string;
+    set innerText(value: string);
+    setCData(s: string): void;
+}

package/dist/types/alphatab/src/xml/XmlParser.d.ts

@@ -0,0 +1,39 @@
+import { XmlNode } from "./XmlNode";
+/**
+ * @internal
+ */
+export declare class XmlParser {
+    static readonly CharCodeLF: number;
+    static readonly CharCodeTab: number;
+    static readonly CharCodeCR: number;
+    static readonly CharCodeSpace: number;
+    static readonly CharCodeLowerThan: number;
+    static readonly CharCodeAmp: number;
+    static readonly CharCodeBrackedClose: number;
+    static readonly CharCodeBrackedOpen: number;
+    static readonly CharCodeGreaterThan: number;
+    static readonly CharCodeExclamation: number;
+    static readonly CharCodeUpperD: number;
+    static readonly CharCodeLowerD: number;
+    static readonly CharCodeMinus: number;
+    static readonly CharCodeQuestion: number;
+    static readonly CharCodeSlash: number;
+    static readonly CharCodeEquals: number;
+    static readonly CharCodeDoubleQuote: number;
+    static readonly CharCodeSingleQuote: number;
+    static readonly CharCodeSharp: number;
+    static readonly CharCodeLowerX: number;
+    static readonly CharCodeLowerA: number;
+    static readonly CharCodeLowerZ: number;
+    static readonly CharCodeUpperA: number;
+    static readonly CharCodeUpperZ: number;
+    static readonly CharCode0: number;
+    static readonly CharCode9: number;
+    static readonly CharCodeColon: number;
+    static readonly CharCodeDot: number;
+    static readonly CharCodeUnderscore: number;
+    static readonly CharCodeSemi: number;
+    private static _escapes;
+    static parse(str: string, p: number, parent: XmlNode): number;
+    private static _isValidChar;
+}

package/dist/types/alphatab/src/xml/XmlWriter.d.ts

@@ -0,0 +1,20 @@
+import { type XmlNode } from "./XmlNode";
+/**
+ * @internal
+ */
+export declare class XmlWriter {
+    private _result;
+    private _indention;
+    private _xmlHeader;
+    private _isStartOfLine;
+    private _currentIndention;
+    constructor(indention: string, xmlHeader: boolean);
+    writeNode(xml: XmlNode): void;
+    private _unindend;
+    private _indent;
+    private _writeAttributeValue;
+    static write(xml: XmlNode, indention: string, xmlHeader: boolean): string;
+    private _write;
+    private _writeLine;
+    toString(): string;
+}

package/dist/types/alphatab/src/zip/Crc32.d.ts

@@ -0,0 +1,32 @@
+/**
+ * CRC-32 with reversed data and unreversed output
+ * @internal
+ */
+export declare class Crc32 {
+    private static readonly _crc32Lookup;
+    private static _buildCrc32Lookup;
+    private static readonly _crcInit;
+    /**
+     * The CRC data checksum so far.
+     */
+    private _checkValue;
+    /**
+     * Returns the CRC data checksum computed so far.
+     */
+    get value(): number;
+    /**
+     * Initialise a default instance of Crc32.
+     */
+    constructor();
+    /**
+     * Update CRC data checksum based on a portion of a block of data
+     * @param data The array containing the data to add
+     * @param offset Range start for data (inclusive)
+     * @param count The number of bytes to checksum starting from offset
+     */
+    update(data: Uint8Array, offset: number, count: number): void;
+    /**
+     * Resets the CRC data checksum as if no update was ever called.
+     */
+    reset(): void;
+}

package/dist/types/alphatab/src/zip/Deflater.d.ts

@@ -0,0 +1,74 @@
+/**
+ * This is the Deflater class.  The deflater class compresses input
+ * with the deflate algorithm described in RFC 1951.  It has several
+ * compression levels and three different strategies described below.
+ *
+ * This class is <i>not</i> thread safe.  This is inherent in the API, due
+ * to the split of deflate and setInput.
+ *
+ * author of the original java version : Jochen Hoenicke
+ *
+ * @internal
+ */
+export declare class Deflater {
+    private static readonly _isFlushing;
+    static readonly isFinishing: number;
+    private static readonly _busyState;
+    private static readonly _flushingState;
+    private static readonly _finishingState;
+    private static readonly _finishedState;
+    private _state;
+    private _pending;
+    private _engine;
+    get inputCrc(): number;
+    /**
+     * Creates a new deflater with given compression level
+     * @param level the compression level, a value between NO_COMPRESSION and BEST_COMPRESSION.
+     * beginning and the adler checksum at the end of the output.  This is
+     * useful for the GZIP/PKZIP formats.
+     */
+    constructor();
+    /**
+     * Returns true, if the input buffer is empty.
+     * You should then call setInput().
+     * NOTE: This method can also return true when the stream
+     * was finished.
+     */
+    get isNeedingInput(): boolean;
+    /**
+     * Returns true if the stream was finished and no more output bytes
+     * are available.
+     */
+    get isFinished(): boolean;
+    /**
+     * Resets the deflater. The deflater acts afterwards as if it was
+     * just created with the same compression level and strategy as it
+     * had before.
+     */
+    reset(): void;
+    /**
+     * Sets the data which should be compressed next.  This should be
+     * only called when needsInput indicates that more input is needed.
+     * The given byte array should not be changed, before needsInput() returns
+     * true again.
+     * @param input the buffer containing the input data.
+     * @param offset the start of the data.
+     * @param count the number of data bytes of input.
+     */
+    setInput(input: Uint8Array, offset: number, count: number): void;
+    /**
+     * Deflates the current input block to the given array.
+     * @param output Buffer to store the compressed data.
+     * @param offset Offset into the output array.
+     * @param length The maximum number of bytes that may be stored.
+     * @returns The number of compressed bytes added to the output, or 0 if either
+     * needsInput() or finished() returns true or length is zero.
+     */
+    deflate(output: Uint8Array, offset: number, length: number): number;
+    /**
+     * Finishes the deflater with the current input block.  It is an error
+     * to give more input after this method was called.  This method must
+     * be called to force all bytes to be flushed.
+     */
+    finish(): void;
+}

package/dist/types/alphatab/src/zip/DeflaterConstants.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This class contains constants used for deflation.
+ *
+ * @internal
+ */
+export declare class DeflaterConstants {
+    static readonly maxWbits: number;
+    static readonly wsize: number;
+    static readonly wmask: number;
+    static readonly minMatch: number;
+    static readonly maxMatch: number;
+    static readonly defaultMemLevel: number;
+    static readonly pendingBufSize: number;
+    static readonly hashBits: number;
+    static readonly hashSize: number;
+    static readonly hashShift: number;
+    static readonly hashMask: number;
+    static readonly minLookahead: number;
+    static readonly maxDist: number;
+}