react-native-audio-api 0.4.8-rc1 → 0.4.8

package/src/web-core/AudioBuffer.tsx

@@ -0,0 +1,79 @@
+import { IndexSizeError } from '../errors';
+
+export default class AudioBuffer {
+  readonly length: number;
+  readonly duration: number;
+  readonly sampleRate: number;
+  readonly numberOfChannels: number;
+
+  /** @internal */
+  public readonly buffer: globalThis.AudioBuffer;
+
+  constructor(buffer: globalThis.AudioBuffer) {
+    this.buffer = buffer;
+    this.length = buffer.length;
+    this.duration = buffer.duration;
+    this.sampleRate = buffer.sampleRate;
+    this.numberOfChannels = buffer.numberOfChannels;
+  }
+
+  public getChannelData(channel: number): number[] {
+    if (channel < 0 || channel >= this.numberOfChannels) {
+      throw new IndexSizeError(
+        `The channel number provided (${channel}) is outside the range [0, ${this.numberOfChannels - 1}]`
+      );
+    }
+
+    return Array.from(this.buffer.getChannelData(channel));
+  }
+
+  public copyFromChannel(
+    destination: number[],
+    channelNumber: number,
+    startInChannel: number = 0
+  ): void {
+    if (channelNumber < 0 || channelNumber >= this.numberOfChannels) {
+      throw new IndexSizeError(
+        `The channel number provided (${channelNumber}) is outside the range [0, ${this.numberOfChannels - 1}]`
+      );
+    }
+
+    if (startInChannel < 0 || startInChannel >= this.length) {
+      throw new IndexSizeError(
+        `The startInChannel number provided (${startInChannel}) is outside the range [0, ${this.length - 1}]`
+      );
+    }
+
+    const array = new Float32Array(destination);
+
+    this.buffer.copyFromChannel(array, channelNumber, startInChannel);
+
+    for (let i = 0; i < destination.length; i++) {
+      destination[i] = array[i];
+    }
+  }
+
+  public copyToChannel(
+    source: number[],
+    channelNumber: number,
+    startInChannel: number = 0
+  ): void {
+    if (channelNumber < 0 || channelNumber >= this.numberOfChannels) {
+      throw new IndexSizeError(
+        `The channel number provided (${channelNumber}) is outside the range [0, ${this.numberOfChannels - 1}]`
+      );
+    }
+
+    if (startInChannel < 0 || startInChannel >= this.length) {
+      throw new IndexSizeError(
+        `The startInChannel number provided (${startInChannel}) is outside the range [0, ${this.length - 1}]`
+      );
+    }
+
+    this.buffer.copyToChannel(
+      new Float32Array(source),
+      channelNumber,
+      startInChannel
+    );
+  }
+}

package/src/web-core/AudioBufferSourceNode.tsx

@@ -0,0 +1,94 @@
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import AudioParam from './AudioParam';
+import AudioBuffer from './AudioBuffer';
+import { InvalidStateError, RangeError } from '../errors';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class AudioBufferSourceNode extends AudioScheduledSourceNode {
+  readonly playbackRate: AudioParam;
+  readonly detune: AudioParam;
+
+  constructor(
+    context: BaseAudioContext,
+    node: globalThis.AudioBufferSourceNode
+  ) {
+    super(context, node);
+
+    this.detune = new AudioParam(node.detune);
+    this.playbackRate = new AudioParam(node.playbackRate);
+  }
+
+  public get buffer(): AudioBuffer | null {
+    const buffer = (this.node as globalThis.AudioBufferSourceNode).buffer;
+
+    if (!buffer) {
+      return null;
+    }
+
+    return new AudioBuffer(buffer);
+  }
+
+  public set buffer(buffer: AudioBuffer | null) {
+    if (!buffer) {
+      (this.node as globalThis.AudioBufferSourceNode | null) = null;
+      return;
+    }
+
+    (this.node as globalThis.AudioBufferSourceNode).buffer = buffer.buffer;
+  }
+
+  public get loop(): boolean {
+    return (this.node as globalThis.AudioBufferSourceNode).loop;
+  }
+
+  public set loop(value: boolean) {
+    (this.node as globalThis.AudioBufferSourceNode).loop = value;
+  }
+
+  public get loopStart(): number {
+    return (this.node as globalThis.AudioBufferSourceNode).loopStart;
+  }
+
+  public set loopStart(value: number) {
+    (this.node as globalThis.AudioBufferSourceNode).loopStart = value;
+  }
+
+  public get loopEnd(): number {
+    return (this.node as globalThis.AudioBufferSourceNode).loopEnd;
+  }
+
+  public set loopEnd(value: number) {
+    (this.node as globalThis.AudioBufferSourceNode).loopEnd = value;
+  }
+
+  public start(when?: number, offset?: number, duration?: number): void {
+    if (when && when < 0) {
+      throw new RangeError(
+        `when must be a finite non-negative number: ${when}`
+      );
+    }
+
+    if (offset && offset < 0) {
+      throw new RangeError(
+        `offset must be a finite non-negative number: ${offset}`
+      );
+    }
+
+    if (duration && duration < 0) {
+      throw new RangeError(
+        `duration must be a finite non-negative number: ${duration}`
+      );
+    }
+
+    if (this.hasBeenStarted) {
+      throw new InvalidStateError('Cannot call start more than once');
+    }
+
+    this.hasBeenStarted = true;
+    (this.node as globalThis.AudioBufferSourceNode).start(
+      when,
+      offset,
+      duration
+    );
+  }
+}

package/src/web-core/AudioContext.tsx

@@ -0,0 +1,114 @@
+import { ContextState, PeriodicWaveConstraints } from '../types';
+import { RangeError, InvalidAccessError } from '../errors';
+import BaseAudioContext from './BaseAudioContext';
+import AnalyserNode from './AnalyserNode';
+import AudioDestinationNode from './AudioDestinationNode';
+import AudioBuffer from './AudioBuffer';
+import AudioBufferSourceNode from './AudioBufferSourceNode';
+import BiquadFilterNode from './BiquadFilterNode';
+import GainNode from './GainNode';
+import OscillatorNode from './OscillatorNode';
+import PeriodicWave from './PeriodicWave';
+import StereoPannerNode from './StereoPannerNode';
+
+export default class AudioContext implements BaseAudioContext {
+  readonly context: globalThis.AudioContext;
+
+  readonly destination: AudioDestinationNode;
+  readonly sampleRate: number;
+
+  constructor(_sampleRate?: number) {
+    this.context = new window.AudioContext();
+
+    this.sampleRate = this.context.sampleRate;
+    this.destination = new AudioDestinationNode(this, this.context.destination);
+  }
+
+  public get currentTime(): number {
+    return this.context.currentTime;
+  }
+
+  public get state(): ContextState {
+    return this.context.state as ContextState;
+  }
+
+  createOscillator(): OscillatorNode {
+    return new OscillatorNode(this, this.context.createOscillator());
+  }
+
+  createGain(): GainNode {
+    return new GainNode(this, this.context.createGain());
+  }
+
+  createStereoPanner(): StereoPannerNode {
+    return new StereoPannerNode(this, this.context.createStereoPanner());
+  }
+
+  createBiquadFilter(): BiquadFilterNode {
+    return new BiquadFilterNode(this, this.context.createBiquadFilter());
+  }
+
+  createBufferSource(): AudioBufferSourceNode {
+    return new AudioBufferSourceNode(this, this.context.createBufferSource());
+  }
+
+  createBuffer(
+    numOfChannels: number,
+    length: number,
+    sampleRate: number
+  ): AudioBuffer {
+    if (numOfChannels < 1 || numOfChannels >= 32) {
+      throw new RangeError(
+        `The number of channels provided (${numOfChannels}) is outside the range [1, 32]`
+      );
+    }
+
+    if (length <= 0) {
+      throw new RangeError(
+        `The number of frames provided (${length}) is less than or equal to the minimum bound (0)`
+      );
+    }
+
+    if (sampleRate <= 0) {
+      throw new RangeError(
+        `The sample rate provided (${sampleRate}) is outside the range [3000, 768000]`
+      );
+    }
+
+    return new AudioBuffer(
+      this.context.createBuffer(numOfChannels, length, sampleRate)
+    );
+  }
+
+  createPeriodicWave(
+    real: number[],
+    imag: number[],
+    constraints?: PeriodicWaveConstraints
+  ): PeriodicWave {
+    if (real.length !== imag.length) {
+      throw new InvalidAccessError(
+        `The lengths of the real (${real.length}) and imaginary (${imag.length}) arrays must match.`
+      );
+    }
+
+    return new PeriodicWave(
+      this.context.createPeriodicWave(real, imag, constraints)
+    );
+  }
+
+  createAnalyser(): AnalyserNode {
+    return new AnalyserNode(this, this.context.createAnalyser());
+  }
+
+  async decodeAudioDataSource(source: string): Promise<AudioBuffer> {
+    const arrayBuffer = await fetch(source).then((response) =>
+      response.arrayBuffer()
+    );
+
+    return new AudioBuffer(await this.context.decodeAudioData(arrayBuffer));
+  }
+
+  async close(): Promise<void> {
+    await this.context.close();
+  }
+}

package/src/web-core/AudioDestinationNode.tsx

@@ -0,0 +1,3 @@
+import AudioNode from './AudioNode';
+
+export default class AudioDestinationNode extends AudioNode {}

package/src/web-core/AudioNode.tsx

@@ -0,0 +1,40 @@
+import BaseAudioContext from './BaseAudioContext';
+import { ChannelCountMode, ChannelInterpretation } from '../types';
+
+export default class AudioNode {
+  readonly context: BaseAudioContext;
+  readonly numberOfInputs: number;
+  readonly numberOfOutputs: number;
+  readonly channelCount: number;
+  readonly channelCountMode: ChannelCountMode;
+  readonly channelInterpretation: ChannelInterpretation;
+
+  protected readonly node: globalThis.AudioNode;
+
+  constructor(context: BaseAudioContext, node: globalThis.AudioNode) {
+    this.context = context;
+    this.node = node;
+    this.numberOfInputs = this.node.numberOfInputs;
+    this.numberOfOutputs = this.node.numberOfOutputs;
+    this.channelCount = this.node.channelCount;
+    this.channelCountMode = this.node.channelCountMode;
+    this.channelInterpretation = this.node.channelInterpretation;
+  }
+
+  public connect(destination: AudioNode): void {
+    if (this.context !== destination.context) {
+      throw new Error('The AudioNodes are from different BaseAudioContexts');
+    }
+
+    this.node.connect(destination.node);
+  }
+
+  public disconnect(destination?: AudioNode): void {
+    if (destination === undefined) {
+      this.node.disconnect();
+      return;
+    }
+
+    this.node.disconnect(destination.node);
+  }
+}

package/src/web-core/AudioParam.tsx

@@ -0,0 +1,106 @@
+import { RangeError } from '../errors';
+
+export default class AudioParam {
+  readonly defaultValue: number;
+  readonly minValue: number;
+  readonly maxValue: number;
+
+  private readonly param: globalThis.AudioParam;
+
+  constructor(param: globalThis.AudioParam) {
+    this.param = param;
+    this.defaultValue = param.defaultValue;
+    this.minValue = param.minValue;
+    this.maxValue = param.maxValue;
+  }
+
+  public get value(): number {
+    return this.param.value;
+  }
+
+  public set value(value: number) {
+    this.param.value = value;
+  }
+
+  public setValueAtTime(value: number, startTime: number): void {
+    if (startTime < 0) {
+      throw new RangeError(
+        `Time must be a finite non-negative number: ${startTime}`
+      );
+    }
+
+    this.param.setValueAtTime(value, startTime);
+  }
+
+  public linearRampToValueAtTime(value: number, endTime: number): void {
+    if (endTime < 0) {
+      throw new RangeError(
+        `Time must be a finite non-negative number: ${endTime}`
+      );
+    }
+
+    this.param.linearRampToValueAtTime(value, endTime);
+  }
+
+  public exponentialRampToValueAtTime(value: number, endTime: number): void {
+    if (endTime < 0) {
+      throw new RangeError(
+        `Time must be a finite non-negative number: ${endTime}`
+      );
+    }
+
+    this.param.exponentialRampToValueAtTime(value, endTime);
+  }
+
+  public setTargetAtTime(
+    target: number,
+    startTime: number,
+    timeConstant: number
+  ): void {
+    if (startTime < 0) {
+      throw new RangeError(
+        `Time must be a finite non-negative number: ${startTime}`
+      );
+    }
+
+    this.param.setTargetAtTime(target, startTime, timeConstant);
+  }
+
+  public setValueCurveAtTime(
+    values: number[],
+    startTime: number,
+    duration: number
+  ): void {
+    if (startTime < 0) {
+      throw new RangeError(
+        `Time must be a finite non-negative number: ${startTime}`
+      );
+    }
+
+    this.param.setValueCurveAtTime(
+      new Float32Array(values),
+      startTime,
+      duration
+    );
+  }
+
+  public cancelScheduledValues(cancelTime: number): void {
+    if (cancelTime < 0) {
+      throw new RangeError(
+        `Time must be a finite non-negative number: ${cancelTime}`
+      );
+    }
+
+    this.param.cancelScheduledValues(cancelTime);
+  }
+
+  public cancelAndHoldAtTime(cancelTime: number): void {
+    if (cancelTime < 0) {
+      throw new RangeError(
+        `Time must be a finite non-negative number: ${cancelTime}`
+      );
+    }
+
+    this.param.cancelAndHoldAtTime(cancelTime);
+  }
+}

package/src/web-core/AudioScheduledSourceNode.tsx

@@ -0,0 +1,37 @@
+import AudioNode from './AudioNode';
+import { RangeError, InvalidStateError } from '../errors';
+
+export default class AudioScheduledSourceNode extends AudioNode {
+  protected hasBeenStarted: boolean = false;
+
+  public start(when: number = 0): void {
+    if (when < 0) {
+      throw new RangeError(
+        `when must be a finite non-negative number: ${when}`
+      );
+    }
+
+    if (this.hasBeenStarted) {
+      throw new InvalidStateError('Cannot call start more than once');
+    }
+
+    this.hasBeenStarted = true;
+    (this.node as globalThis.AudioScheduledSourceNode).start(when);
+  }
+
+  public stop(when: number = 0): void {
+    if (when < 0) {
+      throw new RangeError(
+        `when must be a finite non-negative number: ${when}`
+      );
+    }
+
+    if (!this.hasBeenStarted) {
+      throw new InvalidStateError(
+        'Cannot call stop without calling start first'
+      );
+    }
+
+    (this.node as globalThis.AudioScheduledSourceNode).stop(when);
+  }
+}

package/src/web-core/BaseAudioContext.tsx

@@ -0,0 +1,37 @@
+import { ContextState, PeriodicWaveConstraints } from '../types';
+import AnalyserNode from './AnalyserNode';
+import AudioDestinationNode from './AudioDestinationNode';
+import AudioBuffer from './AudioBuffer';
+import AudioBufferSourceNode from './AudioBufferSourceNode';
+import BiquadFilterNode from './BiquadFilterNode';
+import GainNode from './GainNode';
+import OscillatorNode from './OscillatorNode';
+import PeriodicWave from './PeriodicWave';
+import StereoPannerNode from './StereoPannerNode';
+
+export default interface BaseAudioContext {
+  readonly context: globalThis.BaseAudioContext;
+
+  readonly destination: AudioDestinationNode;
+  readonly sampleRate: number;
+
+  get currentTime(): number;
+  get state(): ContextState;
+  createOscillator(): OscillatorNode;
+  createGain(): GainNode;
+  createStereoPanner(): StereoPannerNode;
+  createBiquadFilter(): BiquadFilterNode;
+  createBufferSource(): AudioBufferSourceNode;
+  createBuffer(
+    numOfChannels: number,
+    length: number,
+    sampleRate: number
+  ): AudioBuffer;
+  createPeriodicWave(
+    real: number[],
+    imag: number[],
+    constraints?: PeriodicWaveConstraints
+  ): PeriodicWave;
+  createAnalyser(): AnalyserNode;
+  decodeAudioDataSource(source: string): Promise<AudioBuffer>;
+}

package/src/web-core/BiquadFilterNode.tsx

@@ -0,0 +1,62 @@
+import AudioParam from './AudioParam';
+import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
+import { BiquadFilterType } from '../types';
+import { InvalidAccessError } from '../errors';
+
+export default class BiquadFilterNode extends AudioNode {
+  readonly frequency: AudioParam;
+  readonly detune: AudioParam;
+  readonly Q: AudioParam;
+  readonly gain: AudioParam;
+
+  constructor(
+    context: BaseAudioContext,
+    biquadFilter: globalThis.BiquadFilterNode
+  ) {
+    super(context, biquadFilter);
+    this.frequency = new AudioParam(biquadFilter.frequency);
+    this.detune = new AudioParam(biquadFilter.detune);
+    this.Q = new AudioParam(biquadFilter.Q);
+    this.gain = new AudioParam(biquadFilter.gain);
+  }
+
+  public get type(): BiquadFilterType {
+    return (this.node as globalThis.BiquadFilterNode).type;
+  }
+
+  public set type(value: BiquadFilterType) {
+    (this.node as globalThis.BiquadFilterNode).type = value;
+  }
+
+  public getFrequencyResponse(
+    frequencyArray: number[],
+    magResponseOutput: number[],
+    phaseResponseOutput: number[]
+  ) {
+    if (
+      frequencyArray.length !== magResponseOutput.length ||
+      frequencyArray.length !== phaseResponseOutput.length
+    ) {
+      throw new InvalidAccessError(
+        `The lengths of the arrays are not the same frequencyArray: ${frequencyArray.length}, magResponseOutput: ${magResponseOutput.length}, phaseResponseOutput: ${phaseResponseOutput.length}`
+      );
+    }
+    const magData = new Float32Array(magResponseOutput);
+    const phaseData = new Float32Array(phaseResponseOutput);
+
+    (this.node as globalThis.BiquadFilterNode).getFrequencyResponse(
+      new Float32Array(frequencyArray),
+      magData,
+      phaseData
+    );
+
+    for (let i = 0; i < magData.length; i++) {
+      magResponseOutput[i] = magData[i];
+    }
+
+    for (let i = 0; i < phaseData.length; i++) {
+      phaseResponseOutput[i] = phaseData[i];
+    }
+  }
+}

package/src/web-core/GainNode.tsx

@@ -0,0 +1,12 @@
+import BaseAudioContext from './BaseAudioContext';
+import AudioNode from './AudioNode';
+import AudioParam from './AudioParam';
+
+export default class GainNode extends AudioNode {
+  readonly gain: AudioParam;
+
+  constructor(context: BaseAudioContext, gain: globalThis.GainNode) {
+    super(context, gain);
+    this.gain = new AudioParam(gain.gain);
+  }
+}

package/src/web-core/OscillatorNode.tsx

@@ -0,0 +1,36 @@
+import { OscillatorType } from '../types';
+import { InvalidStateError } from '../errors';
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import BaseAudioContext from './BaseAudioContext';
+import AudioParam from './AudioParam';
+import PeriodicWave from './PeriodicWave';
+
+export default class OscillatorNode extends AudioScheduledSourceNode {
+  readonly frequency: AudioParam;
+  readonly detune: AudioParam;
+
+  constructor(context: BaseAudioContext, node: globalThis.OscillatorNode) {
+    super(context, node);
+
+    this.detune = new AudioParam(node.detune);
+    this.frequency = new AudioParam(node.frequency);
+  }
+
+  public get type(): OscillatorType {
+    return (this.node as globalThis.OscillatorNode).type;
+  }
+
+  public set type(value: OscillatorType) {
+    if (value === 'custom') {
+      throw new InvalidStateError(
+        "'type' cannot be set directly to 'custom'.  Use setPeriodicWave() to create a custom Oscillator type."
+      );
+    }
+
+    (this.node as globalThis.OscillatorNode).type = value;
+  }
+
+  public setPeriodicWave(wave: PeriodicWave): void {
+    (this.node as globalThis.OscillatorNode).setPeriodicWave(wave.periodicWave);
+  }
+}

package/src/web-core/PeriodicWave.tsx

@@ -0,0 +1,8 @@
+export default class PeriodicWave {
+  /** @internal */
+  readonly periodicWave: globalThis.PeriodicWave;
+
+  constructor(periodicWave: globalThis.PeriodicWave) {
+    this.periodicWave = periodicWave;
+  }
+}

package/src/web-core/StereoPannerNode.tsx

@@ -0,0 +1,12 @@
+import BaseAudioContext from './BaseAudioContext';
+import AudioNode from './AudioNode';
+import AudioParam from './AudioParam';
+
+export default class StereoPannerNode extends AudioNode {
+  readonly pan: AudioParam;
+
+  constructor(context: BaseAudioContext, pan: globalThis.StereoPannerNode) {
+    super(context, pan);
+    this.pan = new AudioParam(pan.pan);
+  }
+}

package/lib/module/index.native.js

@@ -1,21 +0,0 @@
-"use strict";
-
-import { installModule } from "./specs/install.js";
-if (global.__AudioAPIInstaller == null) {
-  installModule();
-}
-export { default as AudioBuffer } from "./core/AudioBuffer.js";
-export { default as AudioBufferSourceNode } from "./core/AudioBufferSourceNode.js";
-export { default as AudioContext } from "./core/AudioContext.js";
-export { default as AudioDestinationNode } from "./core/AudioDestinationNode.js";
-export { default as AudioNode } from "./core/AudioNode.js";
-export { default as AnalyserNode } from "./core/AnalyserNode.js";
-export { default as AudioParam } from "./core/AudioParam.js";
-export { default as AudioScheduledSourceNode } from "./core/AudioScheduledSourceNode.js";
-export { default as BaseAudioContext } from "./core/BaseAudioContext.js";
-export { default as BiquadFilterNode } from "./core/BiquadFilterNode.js";
-export { default as GainNode } from "./core/GainNode.js";
-export { default as OscillatorNode } from "./core/OscillatorNode.js";
-export { default as StereoPannerNode } from "./core/StereoPannerNode.js";
-export { OscillatorType, BiquadFilterType, ChannelCountMode, ChannelInterpretation, ContextState, WindowType } from "./core/types.js";
-//# sourceMappingURL=index.native.js.map

package/lib/module/index.native.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["installModule","global","__AudioAPIInstaller","default","AudioBuffer","AudioBufferSourceNode","AudioContext","AudioDestinationNode","AudioNode","AnalyserNode","AudioParam","AudioScheduledSourceNode","BaseAudioContext","BiquadFilterNode","GainNode","OscillatorNode","StereoPannerNode","OscillatorType","BiquadFilterType","ChannelCountMode","ChannelInterpretation","ContextState","WindowType"],"sourceRoot":"../../src","sources":["index.native.ts"],"mappings":";;AAAA,SAASA,aAAa,QAAQ,oBAAiB;AAE/C,IAAIC,MAAM,CAACC,mBAAmB,IAAI,IAAI,EAAE;EACtCF,aAAa,CAAC,CAAC;AACjB;AAEA,SAASG,OAAO,IAAIC,WAAW,QAAQ,uBAAoB;AAC3D,SAASD,OAAO,IAAIE,qBAAqB,QAAQ,iCAA8B;AAC/E,SAASF,OAAO,IAAIG,YAAY,QAAQ,wBAAqB;AAC7D,SAASH,OAAO,IAAII,oBAAoB,QAAQ,gCAA6B;AAC7E,SAASJ,OAAO,IAAIK,SAAS,QAAQ,qBAAkB;AACvD,SAASL,OAAO,IAAIM,YAAY,QAAQ,wBAAqB;AAC7D,SAASN,OAAO,IAAIO,UAAU,QAAQ,sBAAmB;AACzD,SAASP,OAAO,IAAIQ,wBAAwB,QAAQ,oCAAiC;AACrF,SAASR,OAAO,IAAIS,gBAAgB,QAAQ,4BAAyB;AACrE,SAAST,OAAO,IAAIU,gBAAgB,QAAQ,4BAAyB;AACrE,SAASV,OAAO,IAAIW,QAAQ,QAAQ,oBAAiB;AACrD,SAASX,OAAO,IAAIY,cAAc,QAAQ,0BAAuB;AACjE,SAASZ,OAAO,IAAIa,gBAAgB,QAAQ,4BAAyB;AACrE,SACEC,cAAc,EACdC,gBAAgB,EAChBC,gBAAgB,EAChBC,qBAAqB,EACrBC,YAAY,EACZC,UAAU,QACL,iBAAc","ignoreList":[]}

package/lib/typescript/core/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,aAAa,GAAG,UAAU,CAAC;AAElE,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,UAAU,CAAC;AAE5D,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,UAAU,GACV,UAAU,GACV,UAAU,GACV,WAAW,GACX,SAAS,GACT,OAAO,GACP,SAAS,CAAC;AAEd,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEhD,MAAM,MAAM,cAAc,GACtB,MAAM,GACN,QAAQ,GACR,UAAU,GACV,UAAU,GACV,QAAQ,CAAC;AAEb,MAAM,WAAW,uBAAuB;IACtC,oBAAoB,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC"}