@specy/x86 1.1.0 → 2.0.1

package/dist/index.d.mts

@@ -0,0 +1,566 @@
+//#region src/resources.d.ts
+type ResourceSource = string | URL | ArrayBuffer | Uint8Array;
+declare function isNodeRuntime(): boolean;
+declare function toResourceUrl(source: string | URL): URL;
+declare function readResourceBytes(source: ResourceSource): Promise<Uint8Array>;
+declare function defaultResourceUrl(relativePath: string, baseUrl: string): URL;
+//#endregion
+//#region src/assemblers.d.ts
+interface Binary {
+  file: ResourceSource;
+  commands: string;
+}
+interface DiagnosticLine {
+  line: number;
+  error: string;
+}
+type DiagnosticsParser = (assemblerLogs: string) => DiagnosticLine[];
+interface AssemblerMode {
+  id: string;
+  displayName: string;
+  description: string;
+  diagnosticsParser?: DiagnosticsParser;
+  binaries: {
+    assembler: Binary;
+    linker?: Binary;
+  };
+}
+declare const assemblers: {
+  GNU_trunk: {
+    id: string;
+    displayName: string;
+    description: string;
+    diagnosticsParser: typeof gnuDiagnostics;
+    binaries: {
+      assembler: {
+        file: URL;
+        commands: string;
+      };
+      linker: {
+        file: URL;
+        commands: string;
+      };
+    };
+  };
+  FASM_trunk: {
+    id: string;
+    displayName: string;
+    description: string;
+    diagnosticsParser: typeof fasmDiagnostics;
+    binaries: {
+      assembler: {
+        file: URL;
+        commands: string;
+      };
+    };
+  };
+  NASM_trunk: {
+    id: string;
+    displayName: string;
+    description: string;
+    diagnosticsParser: typeof nasmDiagnostics;
+    binaries: {
+      assembler: {
+        file: URL;
+        commands: string;
+      };
+      linker: {
+        file: URL;
+        commands: string;
+      };
+    };
+  };
+};
+type AssemblerId = keyof typeof assemblers;
+declare const DEFAULT_ASSEMBLER_ID: AssemblerId;
+declare function nasmDiagnostics(str: string): DiagnosticLine[];
+declare function gnuDiagnostics(str: string): DiagnosticLine[];
+declare function fasmDiagnostics(str: string): DiagnosticLine[];
+//#endregion
+//#region src/callbacks.d.ts
+type MaybePromise<T> = T | PromiseLike<T>;
+declare function observeCallbackResult(result: MaybePromise<void>): void;
+//#endregion
+//#region src/types.d.ts
+declare const X86_REGISTER_NAMES: readonly ["rax", "rbx", "rcx", "rdx", "rsp", "rbp", "rsi", "rdi", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "rip"];
+type X86RegisterName = (typeof X86_REGISTER_NAMES)[number];
+declare enum BlinkState {
+  NotReady = "NOT_READY",
+  Ready = "READY",
+  Assembling = "ASSEMBLING",
+  Linking = "LINKING",
+  ProgramLoaded = "PROGRAM_LOADED",
+  ProgramRunning = "PROGRAM_RUNNING",
+  ProgramPaused = "PROGRAM_PAUSED",
+  ProgramReadlinePause = "PROGRAM_READLINE_PAUSE",
+  ProgramStopped = "PROGRAM_STOPPED"
+}
+type StopReasonKind = 'exit' | 'signal' | 'input' | 'limit' | 'breakpoint' | 'load-fail';
+type StopReason = {
+  loadFail: boolean;
+  exitCode: number;
+  details: string;
+  kind?: StopReasonKind;
+  address?: bigint;
+  lineNumber?: number;
+  executedInstructions?: bigint;
+};
+type X86CompilationDiagnostic = {
+  line: number;
+  error: string;
+};
+type X86CompileResult = {
+  ok: true;
+  report: string;
+} | {
+  ok: false;
+  errors: X86CompilationDiagnostic[];
+  report: string;
+};
+type X86EmulatorEventMap = {
+  stateChange: {
+    state: BlinkState;
+    oldState: BlinkState;
+  };
+  stdout: number;
+  stderr: number;
+  signal: {
+    signal: number;
+    code: number;
+  };
+  inputRequest: {
+    maxBytes: bigint;
+  };
+};
+type X86EmulatorEventName = keyof X86EmulatorEventMap;
+type X86EmulatorEventHandler<T extends X86EmulatorEventName> = (event: X86EmulatorEventMap[T]) => MaybePromise<void>;
+//#endregion
+//#region src/wasm-types.d.ts
+type EmscriptenFS = {
+  init(stdin: () => number | null, stdout: (charCode: number) => void, stderr: (charCode: number) => void): void;
+  writeFile(path: string, data: string | Uint8Array): void;
+  open(path: string, flags: string): unknown;
+  write(stream: unknown, data: Uint8Array, offset: number, length: number, position: number): void;
+  close(stream: unknown): void;
+  chmod(path: string, mode: number): void;
+  readFile(path: string, options?: {
+    encoding?: 'binary' | 'utf8';
+  }): Uint8Array | string;
+};
+type BlinkenlibModuleOptions = {
+  noInitialRun?: boolean;
+  preRun?: (module: BlinkenlibModule) => void;
+  instantiateWasm?: (imports: WebAssembly.Imports, receiveInstance: (instance: WebAssembly.Instance, module?: WebAssembly.Module) => void) => void;
+};
+type RegisterSnapshot = {
+  registers: Record<X86RegisterName, bigint>;
+  rip: bigint;
+  rsp: bigint;
+  pc: bigint;
+  flags: number;
+};
+type MemoryReadResult = {
+  ok: true;
+  bytes: number[];
+} | {
+  ok: false;
+  error: string;
+  readBytes: number;
+};
+type MemoryWriteResult = {
+  ok: true;
+  writtenBytes: number;
+} | {
+  ok: false;
+  error: string;
+  writtenBytes: number;
+};
+type NativeRunStopKind = 'none' | 'breakpoint' | 'limit';
+type NativeRunStop = {
+  kind: NativeRunStopKind;
+  address: bigint;
+  executedInstructions: bigint;
+};
+type NativeRunControls = {
+  breakpoints: bigint[];
+};
+type NativeControlFlowKind = 'none' | 'call' | 'return';
+type NativeMemoryWrite = {
+  address: bigint;
+  size: number;
+  old: number[];
+  truncated: boolean;
+};
+type NativeStepInfo = {
+  valid: false;
+  memoryWrites: NativeMemoryWrite[];
+} | {
+  valid: true;
+  pcBefore: bigint;
+  pcAfter: bigint;
+  spBefore: bigint;
+  spAfter: bigint;
+  flagsBefore: number;
+  flagsAfter: number;
+  controlFlow: NativeControlFlowKind;
+  truncatedMemoryWrites: boolean;
+  memoryWrites: NativeMemoryWrite[];
+};
+type NativeSymbol = {
+  address: bigint;
+  name: string;
+};
+type NativeInstruction = {
+  address: bigint;
+  size: number;
+  code: string;
+};
+type DisassemblySnapshot = {
+  lines: string[];
+  currentLine: number;
+};
+type BlinkenlibModule = {
+  FS: EmscriptenFS;
+  callMain(args: string[]): void;
+  addFunction(fn: (...args: never[]) => void, signature: string): number;
+  _blinkenlib_run_fast(): void;
+  _blinkenlib_run(): void;
+  _blinkenlib_start(): void;
+  _blinkenlib_starti(): void;
+  _blinkenlib_stepi(): void;
+  _blinkenlib_continue(): void;
+  _blinkenlib_preempt_resume(): void;
+  _blinkenlib_faketty_resume(): void;
+  blinkenlibGetRegister(register: X86RegisterName): bigint;
+  blinkenlibSetRegister(register: X86RegisterName, value: bigint): boolean;
+  blinkenlibSetFlags(flags: number): void;
+  blinkenlibSetStepRecording(enabled: boolean): void;
+  blinkenlibGetRegisterSnapshot(): RegisterSnapshot;
+  blinkenlibReadMemoryBytes(address: bigint, length: number): MemoryReadResult;
+  blinkenlibWriteMemoryBytes(address: bigint, bytes: Uint8Array | number[]): MemoryWriteResult;
+  blinkenlibGetDisassembly(): DisassemblySnapshot;
+  blinkenlibSetEmulationArgs(progname: string, argc: string, argv: string): void;
+  blinkenlibGetInputMaxBytes(): bigint;
+  blinkenlibSetRunControls(limit: bigint, breakpointAddresses: string[]): void;
+  blinkenlibGetRunControls(): NativeRunControls;
+  blinkenlibGetRunStop(): NativeRunStop;
+  blinkenlibGetLastStepInfo(): NativeStepInfo;
+  blinkenlibGetInstructionAt(address: bigint): NativeInstruction | null;
+  blinkenlibResolveSymbol(address: bigint): NativeSymbol | null;
+};
+//#endregion
+//#region src/blink-runtime.d.ts
+type BlinkRuntimeCallbacks = {
+  stdin?: () => number | null;
+  stdout?: (charCode: number) => MaybePromise<void>;
+  stderr?: (charCode: number) => MaybePromise<void>;
+  signal?: (signal: number, code: number) => MaybePromise<void>;
+  stateChange?: (state: BlinkState, oldState: BlinkState) => MaybePromise<void>;
+  inputRequest?: (event: {
+    maxBytes: bigint;
+  }) => MaybePromise<void>;
+};
+type BlinkRuntimeOptions = {
+  mode?: AssemblerMode | AssemblerId;
+  callbacks?: BlinkRuntimeCallbacks;
+  scheduler?: (callback: () => void) => void;
+};
+type BlinkRunOptions = {
+  limit?: number;
+  breakpointAddresses?: bigint[];
+};
+declare class BlinkRuntime {
+  readonly module: BlinkenlibModule;
+  mode: AssemblerMode;
+  state: BlinkState;
+  stopReason: StopReason | null;
+  assemblerLogs: string;
+  assemblerErrors: Array<{
+    line: number;
+    error: string;
+  }>;
+  private readonly callbacks;
+  private readonly scheduler;
+  private readonly stateWaiters;
+  private readonly stdinBytes;
+  private sourceMap;
+  private readonly defaultArgc;
+  private readonly defaultArgv;
+  private constructor();
+  static create(options?: BlinkRuntimeOptions): Promise<BlinkRuntime>;
+  setMode(mode: AssemblerMode | AssemblerId): Promise<void>;
+  compileAssembly(code: string): Promise<X86CompileResult>;
+  loadElf(data: ArrayBuffer | Uint8Array): void;
+  starti(): void;
+  run(): void;
+  step(): void;
+  continue(): void;
+  runUntilBlocked(options?: BlinkRunOptions): Promise<BlinkState>;
+  provideInput(line: string): void;
+  readMemoryBytes(address: bigint, length: bigint): Uint8Array;
+  writeMemoryBytes(address: bigint, data: Uint8Array): void;
+  getDisassemblyLines(): string[];
+  getDisassemblyCurrentLine(): number;
+  getRegisterSnapshot(): RegisterSnapshot;
+  getRegister(register: keyof RegisterSnapshot['registers']): bigint;
+  setRegister(register: keyof RegisterSnapshot['registers'], value: bigint): void;
+  setFlags(flags: bigint | number): void;
+  setStepRecording(enabled: boolean): void;
+  getPc(): bigint;
+  getSp(): bigint;
+  getFlags(): bigint;
+  getInputMaxBytes(): bigint;
+  getInstructionAt(address: bigint): NativeInstruction | null;
+  getLastStepInfo(): NativeStepInfo;
+  resolveSymbol(address: bigint): NativeSymbol | null;
+  getSourceLineForAddress(address: bigint): number | null;
+  getAddressesForSourceLine(lineIndex: number): bigint[];
+  pauseForBreakpoint(address: bigint, lineNumber: number | undefined): void;
+  pauseForLimit(address: bigint, executedInstructions: bigint): void;
+  resumeAfterStateMutation(): void;
+  private startProgram;
+  private writeExecutable;
+  private writeExecutableSync;
+  private setEmulationArgs;
+  private configureRunControls;
+  private collectAssemblerLog;
+  private handleSignal;
+  private handleExit;
+  private handleAssemblerExit;
+  private handleLinkerExit;
+  private setState;
+  private waitForState;
+  private resolveStateWaiters;
+  private assertReadyForCompile;
+  private getDisassemblySnapshot;
+  private tryReadSourceMap;
+}
+//#endregion
+//#region src/interface.d.ts
+type StatusRegister = {
+  name: string;
+  value: number;
+  prev: number;
+};
+type MonacoError = {
+  lineIndex: number;
+  column: number;
+  line: {
+    line: string;
+    line_index: number;
+  };
+  message: string;
+  formatted: string;
+};
+type StackFrame = {
+  name: string;
+  address: bigint;
+  destination: bigint;
+  sp: bigint;
+  line: number;
+  color: string;
+};
+type RegisterHex = [hi: string, lo: string];
+declare enum RegisterSize {
+  Byte = 1,
+  Word = 2,
+  Long = 4,
+  Double = 8
+}
+type ExecutionStep = {
+  mutations: MutationOperation[];
+  pc: number;
+  old_ccr: {
+    bits: number;
+  };
+  new_ccr: {
+    bits: number;
+  };
+  line: number;
+};
+type MutationOperation = {
+  type: 'WriteRegister';
+  value: {
+    register: string;
+    old: bigint;
+    size: RegisterSize;
+  };
+} | {
+  type: 'WriteMemory';
+  value: {
+    address: bigint;
+    old: bigint;
+    size: RegisterSize;
+  };
+} | {
+  type: 'WriteMemoryBytes';
+  value: {
+    address: bigint;
+    old: number[];
+  };
+} | {
+  type: 'PopCallStack';
+  value: {
+    to: bigint;
+    from: bigint;
+  };
+} | {
+  type: 'PushCallStack';
+  value: {
+    to: bigint;
+    from: bigint;
+  };
+} | {
+  type: 'Other';
+  value: string;
+};
+type EmulatorDecoration = {
+  type: 'below-line';
+  note?: string;
+  belowLine: number;
+  md: string;
+};
+type CompilationError = {
+  type: 'raw';
+  message: string;
+};
+declare enum EmulatorStatus {
+  Terminated = 0,
+  Running = 1,
+  WaitingForInput = 2,
+  NotReady = 3
+}
+type Instruction = {
+  address: bigint;
+  lineNumber: number;
+  code: string;
+};
+type EmulatorConfig<R extends string> = {
+  systemSize: RegisterSize;
+  registerNames: R[];
+  endianness?: 'little' | 'big';
+  hiddenRegisters?: R[];
+};
+declare abstract class BaseEmulator<T, R extends string, CompileResult = {
+  ok: true;
+} | {
+  ok: false;
+  errors: CompilationError[];
+  report: string;
+}> {
+  protected _registerNames: R[];
+  protected _systemSize: RegisterSize;
+  protected _endianness: 'little' | 'big';
+  constructor(options: EmulatorConfig<R>);
+  getSystemSize(): RegisterSize;
+  getEndianness(): 'little' | 'big';
+  getRegisterNames(): R[];
+  abstract initialize(undoSize: number): void;
+  abstract getCompiledCode(): {
+    decorations: EmulatorDecoration[];
+    code: string;
+  };
+  abstract dispose(): void;
+  abstract stringifyError(error: unknown): string;
+  abstract compile(code: string): Promise<CompileResult>;
+  abstract checkCode(code: string): Promise<MonacoError[]>;
+  abstract undo(): void;
+  abstract canUndo(): boolean;
+  abstract step(): Promise<{
+    terminated: boolean;
+  }>;
+  abstract getStatus(): EmulatorStatus;
+  abstract writeMemoryBytes(address: bigint, data: Uint8Array): void;
+  abstract readMemoryBytes(address: bigint, length: bigint): Uint8Array;
+  abstract getNextInstruction(): Instruction | null;
+  abstract getUndoHistory(max: number): ExecutionStep[];
+  abstract getPc(): bigint;
+  abstract getSp(): bigint;
+  abstract getFlags(): {
+    name: string;
+    value: number;
+    prev?: number;
+  }[];
+  abstract getCallStack(): StackFrame[];
+  abstract getInstructionAt(address: bigint): Instruction | null;
+  abstract getRegisterValues(): bigint[];
+  abstract getRegisterValuesRecord(): Record<R, bigint>;
+  abstract getRegisterValue(register: R, size?: RegisterSize): bigint;
+  abstract setRegisterValue(register: R, value: bigint, size?: RegisterSize): void;
+  abstract hasTerminated(): boolean;
+  abstract run(limit?: number, breakpoints?: number[]): Promise<EmulatorStatus>;
+}
+//#endregion
+//#region src/x86-emulator.d.ts
+type X86EmulatorOptions = Omit<BlinkRuntimeOptions, 'callbacks' | 'mode'> & {
+  mode?: AssemblerMode | AssemblerId;
+  callbacks?: BlinkRuntimeCallbacks;
+};
+declare class X86Emulator extends BaseEmulator<BlinkRuntime, X86RegisterName, X86CompileResult> {
+  readonly runtime: BlinkRuntime;
+  private readonly eventHandlers;
+  private lastCompileResult;
+  private lastSourceCode;
+  private history;
+  private callStack;
+  private constructor();
+  static create(options?: X86EmulatorOptions): Promise<X86Emulator>;
+  get module(): BlinkenlibModule;
+  get state(): BlinkState;
+  get stopReason(): StopReason | null;
+  on<T extends X86EmulatorEventName>(eventName: T, handler: X86EmulatorEventHandler<T>): () => void;
+  setMode(mode: AssemblerMode | AssemblerId): Promise<void>;
+  compile(code: string): Promise<X86CompileResult>;
+  loadElf(data: ArrayBuffer | Uint8Array): void;
+  runUntilBlocked(): Promise<EmulatorStatus>;
+  provideInput(line: string): void;
+  initialize(undoSize: number): void;
+  getCompiledCode(): {
+    decorations: EmulatorDecoration[];
+    code: string;
+  };
+  dispose(): void;
+  stringifyError(error: unknown): string;
+  checkCode(code: string): Promise<MonacoError[]>;
+  undo(): void;
+  canUndo(): boolean;
+  step(): Promise<{
+    terminated: boolean;
+  }>;
+  getStatus(): EmulatorStatus;
+  writeMemoryBytes(address: bigint, data: Uint8Array): void;
+  readMemoryBytes(address: bigint, length: bigint): Uint8Array;
+  getNextInstruction(): Instruction | null;
+  getUndoHistory(max: number): ExecutionStep[];
+  getPc(): bigint;
+  getSp(): bigint;
+  getFlags(): {
+    name: string;
+    value: number;
+    prev?: number;
+  }[];
+  getCallStack(): StackFrame[];
+  getInstructionAt(address: bigint): Instruction | null;
+  getRegisterValues(): bigint[];
+  getRegisterValuesRecord(): Record<X86RegisterName, bigint>;
+  getRegisterValue(register: X86RegisterName, size?: RegisterSize): bigint;
+  setRegisterValue(register: X86RegisterName, value: bigint, size?: RegisterSize): void;
+  hasTerminated(): boolean;
+  run(limit?: number, breakpoints?: number[]): Promise<EmulatorStatus>;
+  private validateRunLimit;
+  private resolveBreakpointAddresses;
+  private runWithBreakpoints;
+  private runWithHistory;
+  private isTracingEnabled;
+  private clearExecutionTrace;
+  private prepareOneInstructionRun;
+  private captureStep;
+  private recordStep;
+  private recordMemoryMutations;
+  private recordControlFlowMutation;
+  private emit;
+}
+declare function createX86Emulator(options?: X86EmulatorOptions): Promise<X86Emulator>;
+//#endregion
+export { AssemblerId, AssemblerMode, BaseEmulator, Binary, BlinkRunOptions, BlinkRuntime, BlinkRuntimeCallbacks, BlinkRuntimeOptions, BlinkState, BlinkenlibModule, BlinkenlibModuleOptions, CompilationError, DEFAULT_ASSEMBLER_ID, DiagnosticLine, DiagnosticsParser, DisassemblySnapshot, EmscriptenFS, EmulatorConfig, EmulatorDecoration, EmulatorStatus, ExecutionStep, Instruction, MaybePromise, MemoryReadResult, MemoryWriteResult, MonacoError, MutationOperation, NativeControlFlowKind, NativeInstruction, NativeMemoryWrite, NativeRunControls, NativeRunStop, NativeRunStopKind, NativeStepInfo, NativeSymbol, RegisterHex, RegisterSize, RegisterSnapshot, ResourceSource, StackFrame, StatusRegister, StopReason, StopReasonKind, X86CompilationDiagnostic, X86CompileResult, X86Emulator, X86EmulatorEventHandler, X86EmulatorEventMap, X86EmulatorEventName, X86EmulatorOptions, X86RegisterName, X86_REGISTER_NAMES, assemblers, createX86Emulator, defaultResourceUrl, fasmDiagnostics, gnuDiagnostics, isNodeRuntime, nasmDiagnostics, observeCallbackResult, readResourceBytes, toResourceUrl };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/resources.ts","../src/assemblers.ts","../src/callbacks.ts","../src/types.ts","../src/wasm-types.ts","../src/blink-runtime.ts","../src/interface.ts","../src/x86-emulator.ts"],"mappings":";KAAY,cAAA,YAA0B,GAAA,GAAM,WAAA,GAAc,UAAA;AAAA,iBAE1C,aAAA,CAAA;AAAA,iBAQA,aAAA,CAAc,MAAA,WAAiB,GAAA,GAAM,GAAA;AAAA,iBAS/B,iBAAA,CAAkB,MAAA,EAAQ,cAAA,GAAiB,OAAA,CAAQ,UAAA;AAAA,iBAiCzD,kBAAA,CAAmB,YAAA,UAAsB,OAAA,WAAkB,GAAA;;;UClD1D,MAAA;EACb,IAAA,EAAM,cAAA;EACN,QAAA;AAAA;AAAA,UAGa,cAAA;EACb,IAAA;EACA,KAAA;AAAA;AAAA,KAGQ,iBAAA,IAAqB,aAAA,aAA0B,cAAA;AAAA,UAE1C,aAAA;EACb,EAAA;EACA,WAAA;EACA,WAAA;EACA,iBAAA,GAAoB,iBAAA;EACpB,QAAA;IACI,SAAA,EAAW,MAAA;IACX,MAAA,GAAS,MAAA;EAAA;AAAA;AAAA,cAOJ,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+CD,WAAA,gBAA2B,UAAA;AAAA,cAE1B,oBAAA,EAAsB,WAAA;AAAA,iBAEnB,eAAA,CAAgB,GAAA,WAAc,cAAA;AAAA,iBAgB9B,cAAA,CAAe,GAAA,WAAc,cAAA;AAAA,iBAgB7B,eAAA,CAAgB,GAAA,WAAc,cAAA;;;KC/GlC,YAAA,MAAkB,CAAA,GAAI,WAAA,CAAY,CAAA;AAAA,iBAE9B,qBAAA,CAAsB,MAAA,EAAQ,YAAA;;;cCAjC,kBAAA;AAAA,KAoBD,eAAA,WAA0B,kBAAA;AAAA,aAE1B,UAAA;EACR,QAAA;EACA,KAAA;EACA,UAAA;EACA,OAAA;EACA,aAAA;EACA,cAAA;EACA,aAAA;EACA,oBAAA;EACA,cAAA;AAAA;AAAA,KAGQ,cAAA;AAAA,KAEA,UAAA;EACR,QAAA;EACA,QAAA;EACA,OAAA;EACA,IAAA,GAAO,cAAA;EACP,OAAA;EACA,UAAA;EACA,oBAAA;AAAA;AAAA,KAGQ,wBAAA;EACR,IAAA;EACA,KAAA;AAAA;AAAA,KAGQ,gBAAA;EACJ,EAAA;EAAU,MAAA;AAAA;EACV,EAAA;EAAW,MAAA,EAAQ,wBAAA;EAA4B,MAAA;AAAA;AAAA,KAE3C,mBAAA;EACR,WAAA;IAAe,KAAA,EAAO,UAAA;IAAY,QAAA,EAAU,UAAA;EAAA;EAC5C,MAAA;EACA,MAAA;EACA,MAAA;IAAU,MAAA;IAAgB,IAAA;EAAA;EAC1B,YAAA;IAAgB,QAAA;EAAA;AAAA;AAAA,KAGR,oBAAA,SAA6B,mBAAA;AAAA,KAE7B,uBAAA,WAAkC,oBAAA,KAC1C,KAAA,EAAO,mBAAA,CAAoB,CAAA,MAC1B,YAAA;;;KCnEO,YAAA;EACR,IAAA,CAAK,KAAA,uBAA4B,MAAA,GAAS,QAAA,mBAA2B,MAAA,GAAS,QAAA;EAC9E,SAAA,CAAU,IAAA,UAAc,IAAA,WAAe,UAAA;EACvC,IAAA,CAAK,IAAA,UAAc,KAAA;EACnB,KAAA,CAAM,MAAA,WAAiB,IAAA,EAAM,UAAA,EAAY,MAAA,UAAgB,MAAA,UAAgB,QAAA;EACzE,KAAA,CAAM,MAAA;EACN,KAAA,CAAM,IAAA,UAAc,IAAA;EACpB,QAAA,CAAS,IAAA,UAAc,OAAA;IAAY,QAAA;EAAA,IAAiC,UAAA;AAAA;AAAA,KAG5D,uBAAA;EACR,YAAA;EACA,MAAA,IAAU,MAAA,EAAQ,gBAAA;EAClB,eAAA,IACI,OAAA,EAAS,WAAA,CAAY,OAAA,EACrB,eAAA,GAAkB,QAAA,EAAU,WAAA,CAAY,QAAA,EAAU,MAAA,GAAS,WAAA,CAAY,MAAA;AAAA;AAAA,KAInE,gBAAA;EACR,SAAA,EAAW,MAAA,CAAO,eAAA;EAClB,GAAA;EACA,GAAA;EACA,EAAA;EACA,KAAA;AAAA;AAAA,KAGQ,gBAAA;EACJ,EAAA;EAAU,KAAA;AAAA;EACV,EAAA;EAAW,KAAA;EAAe,SAAA;AAAA;AAAA,KAEtB,iBAAA;EACJ,EAAA;EAAU,YAAA;AAAA;EACV,EAAA;EAAW,KAAA;EAAe,YAAA;AAAA;AAAA,KAEtB,iBAAA;AAAA,KAEA,aAAA;EACR,IAAA,EAAM,iBAAA;EACN,OAAA;EACA,oBAAA;AAAA;AAAA,KAGQ,iBAAA;EACR,WAAA;AAAA;AAAA,KAGQ,qBAAA;AAAA,KAEA,iBAAA;EACR,OAAA;EACA,IAAA;EACA,GAAA;EACA,SAAA;AAAA;AAAA,KAGQ,cAAA;EAEF,KAAA;EACA,YAAA,EAAc,iBAAA;AAAA;EAGd,KAAA;EACA,QAAA;EACA,OAAA;EACA,QAAA;EACA,OAAA;EACA,WAAA;EACA,UAAA;EACA,WAAA,EAAa,qBAAA;EACb,qBAAA;EACA,YAAA,EAAc,iBAAA;AAAA;AAAA,KAGZ,YAAA;EACR,OAAA;EACA,IAAA;AAAA;AAAA,KAGQ,iBAAA;EACR,OAAA;EACA,IAAA;EACA,IAAA;AAAA;AAAA,KAGQ,mBAAA;EACR,KAAA;EACA,WAAA;AAAA;AAAA,KAGQ,gBAAA;EACR,EAAA,EAAI,YAAA;EACJ,QAAA,CAAS,IAAA;EACT,WAAA,CAAY,EAAA,MAAQ,IAAA,oBAAwB,SAAA;EAC5C,oBAAA;EACA,eAAA;EACA,iBAAA;EACA,kBAAA;EACA,iBAAA;EACA,oBAAA;EACA,0BAAA;EACA,0BAAA;EACA,qBAAA,CAAsB,QAAA,EAAU,eAAA;EAChC,qBAAA,CAAsB,QAAA,EAAU,eAAA,EAAiB,KAAA;EACjD,kBAAA,CAAmB,KAAA;EACnB,0BAAA,CAA2B,OAAA;EAC3B,6BAAA,IAAiC,gBAAA;EACjC,yBAAA,CAA0B,OAAA,UAAiB,MAAA,WAAiB,gBAAA;EAC5D,0BAAA,CAA2B,OAAA,UAAiB,KAAA,EAAO,UAAA,cAAwB,iBAAA;EAC3E,wBAAA,IAA4B,mBAAA;EAC5B,0BAAA,CAA2B,QAAA,UAAkB,IAAA,UAAc,IAAA;EAC3D,0BAAA;EACA,wBAAA,CAAyB,KAAA,UAAe,mBAAA;EACxC,wBAAA,IAA4B,iBAAA;EAC5B,oBAAA,IAAwB,aAAA;EACxB,yBAAA,IAA6B,cAAA;EAC7B,0BAAA,CAA2B,OAAA,WAAkB,iBAAA;EAC7C,uBAAA,CAAwB,OAAA,WAAkB,YAAA;AAAA;;;KCvElC,qBAAA;EACR,KAAA;EACA,MAAA,IAAU,QAAA,aAAqB,YAAA;EAC/B,MAAA,IAAU,QAAA,aAAqB,YAAA;EAC/B,MAAA,IAAU,MAAA,UAAgB,IAAA,aAAiB,YAAA;EAC3C,WAAA,IAAe,KAAA,EAAO,UAAA,EAAY,QAAA,EAAU,UAAA,KAAe,YAAA;EAC3D,YAAA,IAAgB,KAAA;IAAS,QAAA;EAAA,MAAuB,YAAA;AAAA;AAAA,KAGxC,mBAAA;EACR,IAAA,GAAO,aAAA,GAAgB,WAAA;EACvB,SAAA,GAAY,qBAAA;EACZ,SAAA,IAAa,QAAA;AAAA;AAAA,KAGL,eAAA;EACR,KAAA;EACA,mBAAA;AAAA;AAAA,cAQS,YAAA;EAAA,SACA,MAAA,EAAQ,gBAAA;EAEjB,IAAA,EAAM,aAAA;EACN,KAAA,EAAK,UAAA;EACL,UAAA,EAAY,UAAA;EACZ,aAAA;EACA,eAAA,EAAiB,KAAA;IAAQ,IAAA;IAAc,KAAA;EAAA;EAAA,iBAEtB,SAAA;EAAA,iBACA,SAAA;EAAA,iBACA,YAAA;EAAA,iBACA,UAAA;EAAA,QACT,SAAA;EAAA,iBAES,WAAA;EAAA,iBACA,WAAA;EAAA,QAEV,WAAA,CAAA;EAAA,OAYM,MAAA,CAAO,OAAA,GAAS,mBAAA,GAA2B,OAAA,CAAQ,YAAA;EA8C1D,OAAA,CAAQ,IAAA,EAAM,aAAA,GAAgB,WAAA,GAAc,OAAA;EAY5C,eAAA,CAAgB,IAAA,WAAe,OAAA,CAAQ,gBAAA;EAoB7C,OAAA,CAAQ,IAAA,EAAM,WAAA,GAAc,UAAA;EAQ5B,MAAA,CAAA;EAIA,GAAA,CAAA;EAIA,IAAA,CAAA;EAQA,QAAA,CAAA;EAQM,eAAA,CAAgB,OAAA,GAAS,eAAA,GAAuB,OAAA,CAAQ,UAAA;EAe9D,YAAA,CAAa,IAAA;EAQb,eAAA,CAAgB,OAAA,UAAiB,MAAA,WAAiB,UAAA;EAQlD,gBAAA,CAAiB,OAAA,UAAiB,IAAA,EAAM,UAAA;EAKxC,mBAAA,CAAA;EAIA,yBAAA,CAAA;EAIA,mBAAA,CAAA,GAAuB,gBAAA;EAIvB,WAAA,CAAY,QAAA,QAAgB,gBAAA;EAI5B,WAAA,CAAY,QAAA,QAAgB,gBAAA,eAA+B,KAAA;EAM3D,QAAA,CAAS,KAAA;EAIT,gBAAA,CAAiB,OAAA;EAIjB,KAAA,CAAA;EAIA,KAAA,CAAA;EAIA,QAAA,CAAA;EAIA,gBAAA,CAAA;EAIA,gBAAA,CAAiB,OAAA,WAAkB,iBAAA;EAInC,eAAA,CAAA,GAAmB,cAAA;EAInB,aAAA,CAAc,OAAA,WAAkB,YAAA;EAIhC,uBAAA,CAAwB,OAAA;EAIxB,yBAAA,CAA0B,SAAA;EAI1B,kBAAA,CAAmB,OAAA,UAAiB,UAAA;EAYpC,aAAA,CAAc,OAAA,UAAiB,oBAAA;EAa/B,wBAAA,CAAA;EAAA,QAWQ,YAAA;EAAA,QAYM,eAAA;EAAA,QAIN,mBAAA;EAAA,QAOA,gBAAA;EAAA,QAIA,oBAAA;EAAA,QAQA,mBAAA;EAAA,QAMA,YAAA;EAAA,QAsDA,UAAA;EAAA,QAmBA,mBAAA;EAAA,QAoBA,gBAAA;EAAA,QASA,QAAA;EAAA,QAQA,YAAA;EAAA,QAOA,mBAAA;EAAA,QAUA,qBAAA;EAAA,QAUA,sBAAA;EAAA,QAIA,gBAAA;AAAA;;;KCrhBA,cAAA;EACR,IAAA;EACA,KAAA;EACA,IAAA;AAAA;AAAA,KAEQ,WAAA;EACR,SAAA;EACA,MAAA;EACA,IAAA;IACI,IAAA;IACA,UAAA;EAAA;EAEJ,OAAA;EACA,SAAA;AAAA;AAAA,KAGQ,UAAA;EACR,IAAA;EACA,OAAA;EACA,WAAA;EACA,EAAA;EACA,IAAA;EACA,KAAA;AAAA;AAAA,KAGQ,WAAA,IAAe,EAAA,UAAY,EAAA;AAAA,aAE3B,YAAA;EACR,IAAA;EACA,IAAA;EACA,IAAA;EACA,MAAA;AAAA;AAAA,KAGQ,aAAA;EACR,SAAA,EAAW,iBAAA;EACX,EAAA;EACA,OAAA;IACI,IAAA;EAAA;EAEJ,OAAA;IACI,IAAA;EAAA;EAEJ,IAAA;AAAA;AAAA,KAGQ,iBAAA;EAEF,IAAA;EACA,KAAA;IACI,QAAA;IACA,GAAA;IACA,IAAA,EAAM,YAAA;EAAA;AAAA;EAIV,IAAA;EACA,KAAA;IACI,OAAA;IACA,GAAA;IACA,IAAA,EAAM,YAAA;EAAA;AAAA;EAIV,IAAA;EACA,KAAA;IACI,OAAA;IACA,GAAA;EAAA;AAAA;EAIJ,IAAA;EACA,KAAA;IACI,EAAA;IACA,IAAA;EAAA;AAAA;EAIJ,IAAA;EACA,KAAA;IACI,EAAA;IACA,IAAA;EAAA;AAAA;EAIJ,IAAA;EACA,KAAA;AAAA;AAAA,KAIE,kBAAA;EACR,IAAA;EACA,IAAA;EACA,SAAA;EACA,EAAA;AAAA;AAAA,KAIQ,gBAAA;EACR,IAAA;EACA,OAAA;AAAA;AAAA,aAGQ,cAAA;EACR,UAAA;EACA,OAAA;EACA,eAAA;EACA,QAAA;AAAA;AAAA,KAGQ,WAAA;EACR,OAAA;EACA,UAAA;EACA,IAAA;AAAA;AAAA,KAGQ,cAAA;EACR,UAAA,EAAY,YAAA;EACZ,aAAA,EAAe,CAAA;EACf,UAAA;EACA,eAAA,GAAkB,CAAA;AAAA;AAAA,uBAGA,YAAA;EAGA,EAAA;AAAA;EAAe,EAAA;EAAW,MAAA,EAAQ,gBAAA;EAAoB,MAAA;AAAA;EAAA,UAG9D,cAAA,EAAgB,CAAA;EAAA,UAChB,WAAA,EAAa,YAAA;EAAA,UACb,WAAA;cAEE,OAAA,EAAS,cAAA,CAAe,CAAA;EAMpC,aAAA,CAAA,GAAiB,YAAA;EAIjB,aAAA,CAAA;EAMA,gBAAA,CAAA,GAAoB,CAAA;EAAA,SAIX,UAAA,CAAW,QAAA;EAAA,SAEX,eAAA,CAAA;IAAqB,WAAA,EAAa,kBAAA;IAAsB,IAAA;EAAA;EAAA,SAExD,OAAA,CAAA;EAAA,SAEA,cAAA,CAAe,KAAA;EAAA,SAEf,OAAA,CAAQ,IAAA,WAAe,OAAA,CAAQ,aAAA;EAAA,SAE/B,SAAA,CAAU,IAAA,WAAe,OAAA,CAAQ,WAAA;EAAA,SAEjC,IAAA,CAAA;EAAA,SAEA,OAAA,CAAA;EAAA,SAEA,IAAA,CAAA,GAAQ,OAAA;IAAU,UAAA;EAAA;EAAA,SAElB,SAAA,CAAA,GAAa,cAAA;EAAA,SAEb,gBAAA,CAAiB,OAAA,UAAiB,IAAA,EAAM,UAAA;EAAA,SAExC,eAAA,CAAgB,OAAA,UAAiB,MAAA,WAAiB,UAAA;EAAA,SAElD,kBAAA,CAAA,GAAsB,WAAA;EAAA,SAEtB,cAAA,CAAe,GAAA,WAAc,aAAA;EAAA,SAE7B,KAAA,CAAA;EAAA,SAEA,KAAA,CAAA;EAAA,SAEA,QAAA,CAAA;IAAa,IAAA;IAAc,KAAA;IAAe,IAAA;EAAA;EAAA,SAE1C,YAAA,CAAA,GAAgB,UAAA;EAAA,SAEhB,gBAAA,CAAiB,OAAA,WAAkB,WAAA;EAAA,SAEnC,iBAAA,CAAA;EAAA,SAEA,uBAAA,CAAA,GAA2B,MAAA,CAAO,CAAA;EAAA,SAElC,gBAAA,CAAiB,QAAA,EAAU,CAAA,EAAG,IAAA,GAAO,YAAA;EAAA,SAErC,gBAAA,CAAiB,QAAA,EAAU,CAAA,EAAG,KAAA,UAAe,IAAA,GAAO,YAAA;EAAA,SAEpD,aAAA,CAAA;EAAA,SAEA,GAAA,CAAI,KAAA,WAAgB,WAAA,cAAyB,OAAA,CAAQ,cAAA;AAAA;;;KC5JtD,kBAAA,GAAqB,IAAA,CAAK,mBAAA;EAClC,IAAA,GAAO,aAAA,GAAgB,WAAA;EACvB,SAAA,GAAY,qBAAA;AAAA;AAAA,cAGH,WAAA,SAAoB,YAAA,CAAa,YAAA,EAAc,eAAA,EAAiB,gBAAA;EAAA,SAChE,OAAA,EAAS,YAAA;EAAA,iBAED,aAAA;EAAA,QAUT,iBAAA;EAAA,QACA,cAAA;EAAA,QACA,OAAA;EAAA,QACA,SAAA;EAAA,QAED,WAAA,CAAA;EAAA,OASM,MAAA,CAAO,OAAA,GAAS,kBAAA,GAA0B,OAAA,CAAQ,WAAA;EAAA,IAqC3D,MAAA,CAAA,GAAU,gBAAA;EAAA,IAIV,KAAA,CAAA,GAAS,UAAA;EAAA,IAIT,UAAA,CAAA,GAAc,UAAA;EAIlB,EAAA,WAAa,oBAAA,CAAA,CACT,SAAA,EAAW,CAAA,EACX,OAAA,EAAS,uBAAA,CAAwB,CAAA;EAM/B,OAAA,CAAQ,IAAA,EAAM,aAAA,GAAgB,WAAA,GAAc,OAAA;EAK5C,OAAA,CAAQ,IAAA,WAAe,OAAA,CAAQ,gBAAA;EAOrC,OAAA,CAAQ,IAAA,EAAM,WAAA,GAAc,UAAA;EAKtB,eAAA,CAAA,GAAmB,OAAA,CAAQ,cAAA;EAMjC,YAAA,CAAa,IAAA;EAIb,UAAA,CAAW,QAAA;EAOX,eAAA,CAAA;IAAqB,WAAA,EAAa,kBAAA;IAAsB,IAAA;EAAA;EAIxD,OAAA,CAAA;EAUA,cAAA,CAAe,KAAA;EAKT,SAAA,CAAU,IAAA,WAAe,OAAA,CAAQ,WAAA;EAgBvC,IAAA,CAAA;EAoBA,OAAA,CAAA;EAKM,IAAA,CAAA,GAAQ,OAAA;IAAU,UAAA;EAAA;EAUxB,SAAA,CAAA,GAAa,cAAA;EAOb,gBAAA,CAAiB,OAAA,UAAiB,IAAA,EAAM,UAAA;EAIxC,eAAA,CAAgB,OAAA,UAAiB,MAAA,WAAiB,UAAA;EAIlD,kBAAA,CAAA,GAAsB,WAAA;EAItB,cAAA,CAAe,GAAA,WAAc,aAAA;EAM7B,KAAA,CAAA;EAIA,KAAA,CAAA;EAIA,QAAA,CAAA;IAAc,IAAA;IAAc,KAAA;IAAe,IAAA;EAAA;EAW3C,YAAA,CAAA,GAAgB,UAAA;EAIhB,gBAAA,CAAiB,OAAA,WAAkB,WAAA;EAUnC,iBAAA,CAAA;EAIA,uBAAA,CAAA,GAA2B,MAAA,CAAO,eAAA;EAMlC,gBAAA,CAAiB,QAAA,EAAU,eAAA,EAAiB,IAAA,GAAM,YAAA;EAIlD,gBAAA,CAAiB,QAAA,EAAU,eAAA,EAAiB,KAAA,UAAe,IAAA,GAAM,YAAA;EAOjE,aAAA,CAAA;EAIM,GAAA,CAAI,KAAA,WAAgB,WAAA,cAA6B,OAAA,CAAQ,cAAA;EAAA,QASvD,gBAAA;EAAA,QAOA,0BAAA;EAAA,QAaM,kBAAA;EAAA,QA0BA,cAAA;EAAA,QA0BN,gBAAA;EAAA,QAIA,mBAAA;EAAA,QAKA,wBAAA;EAAA,QAUA,WAAA;EAAA,QAaA,UAAA;EAAA,QAkDA,qBAAA;EAAA,QAyBA,yBAAA;EAAA,QA4BA,IAAA;AAAA;AAAA,iBAKU,iBAAA,CAAkB,OAAA,GAAS,kBAAA,GAA0B,OAAA,CAAQ,WAAA"}