From 6d4711ecc8519bf04c1d1789aafb4a43b7f498fb Mon Sep 17 00:00:00 2001 From: Luke Street Date: Mon, 16 Dec 2024 22:37:21 -0700 Subject: [PATCH] Initial commit --- .gitignore | 12 + .vscode/extensions.json | 8 + .vscode/launch.json | 17 + .vscode/settings.json | 38 + .vscode/tasks.json | 22 + .vscodeignore | 14 + README.md | 22 + biome.json | 33 + gen/diff_pb.ts | 1515 ++++++++++++++ gen/report_pb.ts | 2007 ++++++++++++++++++ media/icon.svg | 1 + package-lock.json | 3374 +++++++++++++++++++++++++++++++ package.json | 92 + rsbuild.config.ts | 77 + src/config.ts | 182 ++ src/env.d.ts | 1 + src/extension.ts | 464 +++++ tsconfig.json | 23 + webview/App.css | 48 + webview/App.tsx | 58 + webview/FunctionView.module.css | 102 + webview/FunctionView.tsx | 197 ++ webview/SymbolsView.module.css | 23 + webview/SymbolsView.tsx | 42 + webview/diff.ts | 131 ++ webview/env.d.ts | 2 + webview/index.tsx | 13 + webview/state.ts | 82 + webview/util.ts | 32 + 29 files changed, 8632 insertions(+) create mode 100644 .gitignore create mode 100644 .vscode/extensions.json create mode 100644 .vscode/launch.json create mode 100644 .vscode/settings.json create mode 100644 .vscode/tasks.json create mode 100644 .vscodeignore create mode 100644 README.md create mode 100644 biome.json create mode 100644 gen/diff_pb.ts create mode 100644 gen/report_pb.ts create mode 100644 media/icon.svg create mode 100644 package-lock.json create mode 100644 package.json create mode 100644 rsbuild.config.ts create mode 100644 src/config.ts create mode 100644 src/env.d.ts create mode 100644 src/extension.ts create mode 100644 tsconfig.json create mode 100644 webview/App.css create mode 100644 webview/App.tsx create mode 100644 webview/FunctionView.module.css create mode 100644 webview/FunctionView.tsx create mode 100644 webview/SymbolsView.module.css create mode 100644 webview/SymbolsView.tsx create mode 100644 webview/diff.ts create mode 100644 webview/env.d.ts create mode 100644 webview/index.tsx create mode 100644 webview/state.ts create mode 100644 webview/util.ts diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..19a3eef --- /dev/null +++ b/.gitignore @@ -0,0 +1,12 @@ +# Local +.DS_Store +*.local +*.log* + +# Dist +node_modules/ +dist/ + +# IDE +.vscode-test/ +*.vsix diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 0000000..2b4118e --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,8 @@ +{ + // See http://go.microsoft.com/fwlink/?LinkId=827846 + // for the documentation about the extensions.json format + "recommendations": [ + "ms-vscode.extension-test-runner", + "jacobcassidy.css-nesting-syntax-highlighting" + ] +} diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..35b0d37 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,17 @@ +// A launch configuration that compiles the extension and then opens it inside a new window +// Use IntelliSense to learn about possible attributes. +// Hover to view descriptions of existing attributes. +// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 +{ + "version": "0.2.0", + "configurations": [ + { + "name": "Run Extension", + "type": "extensionHost", + "request": "launch", + "args": ["--extensionDevelopmentPath=${workspaceFolder}"], + "outFiles": ["${workspaceFolder}/dist/**/*.js"] + // "preLaunchTask": "${defaultBuildTask}" + } + ] +} diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..2eb9890 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,38 @@ +// Place your settings in this file to overwrite default and user settings. +{ + "editor.formatOnSave": true, + "editor.codeActionsOnSave": { + "source.organizeImports.biome": "always" + }, + + // Turn off tsc task auto detection since we have the necessary tasks as npm scripts + "typescript.tsc.autoDetect": "off", + + "[css]": { + "editor.defaultFormatter": "biomejs.biome" + }, + "[scss]": { + "editor.defaultFormatter": "biomejs.biome" + }, + "[javascript]": { + "editor.defaultFormatter": "biomejs.biome" + }, + "[javascriptreact]": { + "editor.defaultFormatter": "biomejs.biome" + }, + "[typescript]": { + "editor.defaultFormatter": "biomejs.biome" + }, + "[typescriptreact]": { + "editor.defaultFormatter": "biomejs.biome" + }, + "[json]": { + "editor.defaultFormatter": "biomejs.biome" + }, + "[jsonc]": { + "editor.defaultFormatter": "biomejs.biome" + }, + "[yaml]": { + "editor.defaultFormatter": "biomejs.biome" + } +} diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 0000000..1c471d3 --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,22 @@ +// See https://go.microsoft.com/fwlink/?LinkId=733558 +// for the documentation about the tasks.json format +{ + "version": "2.0.0", + "tasks": [ + { + "type": "npm", + "script": "watch", + "group": { + "kind": "build", + "isDefault": true + }, + "isBackground": true, + "label": "npm:watch", + "presentation": { + "group": "watch", + "reveal": "never" + }, + "problemMatcher": "$tsc-watch" + } + ] +} diff --git a/.vscodeignore b/.vscodeignore new file mode 100644 index 0000000..46597d2 --- /dev/null +++ b/.vscodeignore @@ -0,0 +1,14 @@ +.vscode/** +.vscode-test/** +out/** +node_modules/** +src/** +webview/** +.gitignore +.yarnrc +rsbuild.config.ts +**/tsconfig.json +**/biome.json +**/*.map +**/*.ts +**/.vscode-test.* diff --git a/README.md b/README.md new file mode 100644 index 0000000..007aeb9 --- /dev/null +++ b/README.md @@ -0,0 +1,22 @@ +# objdiff-code + +> [!WARNING] +> This extension is in early development and is **not yet ready for use**. + +## Setup + +Open the project in Visual Studio Code. + +- Install dependencies: + + ```bash + npm install + ``` + +- Start dev server using `Ctrl+Shift+B` or by running: + + ```bash + npm run watch + ``` + +- Run the extension in debug mode using `F5`. diff --git a/biome.json b/biome.json new file mode 100644 index 0000000..7231b41 --- /dev/null +++ b/biome.json @@ -0,0 +1,33 @@ +{ + "$schema": "https://biomejs.dev/schemas/1.8.0/schema.json", + "organizeImports": { + "enabled": true + }, + "vcs": { + "enabled": true, + "clientKind": "git", + "useIgnoreFile": true + }, + "formatter": { + "indentStyle": "space" + }, + "javascript": { + "formatter": { + "quoteStyle": "single" + } + }, + "css": { + "parser": { + "cssModules": true + } + }, + "linter": { + "enabled": true, + "rules": { + "recommended": true, + "a11y": { + "all": false + } + } + } +} diff --git a/gen/diff_pb.ts b/gen/diff_pb.ts new file mode 100644 index 0000000..21014dd --- /dev/null +++ b/gen/diff_pb.ts @@ -0,0 +1,1515 @@ +/* eslint-disable */ +// @generated by protobuf-ts 2.9.4 with parameter add_pb_suffix,eslint_disable,ts_nocheck,use_proto_field_name +// @generated from protobuf file "diff.proto" (package "objdiff.diff", syntax proto3) +// tslint:disable +// @ts-nocheck +import type { BinaryWriteOptions } from "@protobuf-ts/runtime"; +import type { IBinaryWriter } from "@protobuf-ts/runtime"; +import { WireType } from "@protobuf-ts/runtime"; +import type { BinaryReadOptions } from "@protobuf-ts/runtime"; +import type { IBinaryReader } from "@protobuf-ts/runtime"; +import { UnknownFieldHandler } from "@protobuf-ts/runtime"; +import type { PartialMessage } from "@protobuf-ts/runtime"; +import { reflectionMergePartial } from "@protobuf-ts/runtime"; +import { MessageType } from "@protobuf-ts/runtime"; +/** + * A symbol + * + * @generated from protobuf message objdiff.diff.Symbol + */ +export interface Symbol { + /** + * Name of the symbol + * + * @generated from protobuf field: string name = 1; + */ + name: string; + /** + * Demangled name of the symbol + * + * @generated from protobuf field: optional string demangled_name = 2; + */ + demangled_name?: string; + /** + * Symbol address + * + * @generated from protobuf field: uint64 address = 3; + */ + address: bigint; + /** + * Symbol size + * + * @generated from protobuf field: uint64 size = 4; + */ + size: bigint; + /** + * Bitmask of SymbolFlag + * + * @generated from protobuf field: uint32 flags = 5; + */ + flags: number; +} +/** + * A single parsed instruction + * + * @generated from protobuf message objdiff.diff.Instruction + */ +export interface Instruction { + /** + * Instruction address + * + * @generated from protobuf field: uint64 address = 1; + */ + address: bigint; + /** + * Instruction size + * + * @generated from protobuf field: uint32 size = 2; + */ + size: number; + /** + * Instruction opcode + * + * @generated from protobuf field: uint32 opcode = 3; + */ + opcode: number; + /** + * Instruction mnemonic + * + * @generated from protobuf field: string mnemonic = 4; + */ + mnemonic: string; + /** + * Instruction formatted string + * + * @generated from protobuf field: string formatted = 5; + */ + formatted: string; + /** + * Original (unsimplified) instruction string + * + * @generated from protobuf field: optional string original = 6; + */ + original?: string; + /** + * Instruction arguments + * + * @generated from protobuf field: repeated objdiff.diff.Argument arguments = 7; + */ + arguments: Argument[]; + /** + * Instruction relocation + * + * @generated from protobuf field: optional objdiff.diff.Relocation relocation = 8; + */ + relocation?: Relocation; + /** + * Instruction branch destination + * + * @generated from protobuf field: optional uint64 branch_dest = 9; + */ + branch_dest?: bigint; + /** + * Instruction line number + * + * @generated from protobuf field: optional uint32 line_number = 10; + */ + line_number?: number; +} +/** + * An instruction argument + * + * @generated from protobuf message objdiff.diff.Argument + */ +export interface Argument { + /** + * @generated from protobuf oneof: value + */ + value: { + oneofKind: "plain_text"; + /** + * Plain text + * + * @generated from protobuf field: string plain_text = 1; + */ + plain_text: string; + } | { + oneofKind: "argument"; + /** + * Value + * + * @generated from protobuf field: objdiff.diff.ArgumentValue argument = 2; + */ + argument: ArgumentValue; + } | { + oneofKind: "relocation"; + /** + * Relocation + * + * @generated from protobuf field: objdiff.diff.ArgumentRelocation relocation = 3; + */ + relocation: ArgumentRelocation; + } | { + oneofKind: "branch_dest"; + /** + * Branch destination + * + * @generated from protobuf field: uint64 branch_dest = 4; + */ + branch_dest: bigint; + } | { + oneofKind: undefined; + }; +} +/** + * An instruction argument value + * + * @generated from protobuf message objdiff.diff.ArgumentValue + */ +export interface ArgumentValue { + /** + * @generated from protobuf oneof: value + */ + value: { + oneofKind: "signed"; + /** + * Signed integer + * + * @generated from protobuf field: int64 signed = 1; + */ + signed: bigint; + } | { + oneofKind: "unsigned"; + /** + * Unsigned integer + * + * @generated from protobuf field: uint64 unsigned = 2; + */ + unsigned: bigint; + } | { + oneofKind: "opaque"; + /** + * Opaque value + * + * @generated from protobuf field: string opaque = 3; + */ + opaque: string; + } | { + oneofKind: undefined; + }; +} +/** + * Marker type for relocation arguments + * + * @generated from protobuf message objdiff.diff.ArgumentRelocation + */ +export interface ArgumentRelocation { +} +/** + * @generated from protobuf message objdiff.diff.Relocation + */ +export interface Relocation { + /** + * @generated from protobuf field: uint32 type = 1; + */ + type: number; + /** + * @generated from protobuf field: string type_name = 2; + */ + type_name: string; + /** + * @generated from protobuf field: objdiff.diff.RelocationTarget target = 3; + */ + target?: RelocationTarget; +} +/** + * @generated from protobuf message objdiff.diff.RelocationTarget + */ +export interface RelocationTarget { + /** + * @generated from protobuf field: objdiff.diff.Symbol symbol = 1; + */ + symbol?: Symbol; + /** + * @generated from protobuf field: int64 addend = 2; + */ + addend: bigint; +} +/** + * @generated from protobuf message objdiff.diff.InstructionDiff + */ +export interface InstructionDiff { + /** + * @generated from protobuf field: objdiff.diff.DiffKind diff_kind = 1; + */ + diff_kind: DiffKind; + /** + * @generated from protobuf field: optional objdiff.diff.Instruction instruction = 2; + */ + instruction?: Instruction; + /** + * @generated from protobuf field: optional objdiff.diff.InstructionBranchFrom branch_from = 3; + */ + branch_from?: InstructionBranchFrom; + /** + * @generated from protobuf field: optional objdiff.diff.InstructionBranchTo branch_to = 4; + */ + branch_to?: InstructionBranchTo; + /** + * @generated from protobuf field: repeated objdiff.diff.ArgumentDiff arg_diff = 5; + */ + arg_diff: ArgumentDiff[]; +} +/** + * @generated from protobuf message objdiff.diff.ArgumentDiff + */ +export interface ArgumentDiff { + /** + * @generated from protobuf field: optional uint32 diff_index = 1; + */ + diff_index?: number; +} +/** + * @generated from protobuf message objdiff.diff.InstructionBranchFrom + */ +export interface InstructionBranchFrom { + /** + * @generated from protobuf field: repeated uint32 instruction_index = 1; + */ + instruction_index: number[]; + /** + * @generated from protobuf field: uint32 branch_index = 2; + */ + branch_index: number; +} +/** + * @generated from protobuf message objdiff.diff.InstructionBranchTo + */ +export interface InstructionBranchTo { + /** + * @generated from protobuf field: uint32 instruction_index = 1; + */ + instruction_index: number; + /** + * @generated from protobuf field: uint32 branch_index = 2; + */ + branch_index: number; +} +/** + * @generated from protobuf message objdiff.diff.FunctionDiff + */ +export interface FunctionDiff { + /** + * @generated from protobuf field: objdiff.diff.Symbol symbol = 1; + */ + symbol?: Symbol; + /** + * @generated from protobuf field: repeated objdiff.diff.InstructionDiff instructions = 2; + */ + instructions: InstructionDiff[]; + /** + * @generated from protobuf field: optional float match_percent = 3; + */ + match_percent?: number; +} +/** + * @generated from protobuf message objdiff.diff.DataDiff + */ +export interface DataDiff { + /** + * @generated from protobuf field: objdiff.diff.DiffKind kind = 1; + */ + kind: DiffKind; + /** + * @generated from protobuf field: bytes data = 2; + */ + data: Uint8Array; + /** + * May be larger than data + * + * @generated from protobuf field: uint64 size = 3; + */ + size: bigint; +} +/** + * @generated from protobuf message objdiff.diff.SectionDiff + */ +export interface SectionDiff { + /** + * @generated from protobuf field: string name = 1; + */ + name: string; + /** + * @generated from protobuf field: objdiff.diff.SectionKind kind = 2; + */ + kind: SectionKind; + /** + * @generated from protobuf field: uint64 size = 3; + */ + size: bigint; + /** + * @generated from protobuf field: uint64 address = 4; + */ + address: bigint; + /** + * @generated from protobuf field: repeated objdiff.diff.FunctionDiff functions = 5; + */ + functions: FunctionDiff[]; + /** + * @generated from protobuf field: repeated objdiff.diff.DataDiff data = 6; + */ + data: DataDiff[]; + /** + * @generated from protobuf field: optional float match_percent = 7; + */ + match_percent?: number; +} +/** + * @generated from protobuf message objdiff.diff.ObjectDiff + */ +export interface ObjectDiff { + /** + * @generated from protobuf field: repeated objdiff.diff.SectionDiff sections = 1; + */ + sections: SectionDiff[]; +} +/** + * @generated from protobuf message objdiff.diff.DiffResult + */ +export interface DiffResult { + /** + * @generated from protobuf field: optional objdiff.diff.ObjectDiff left = 1; + */ + left?: ObjectDiff; + /** + * @generated from protobuf field: optional objdiff.diff.ObjectDiff right = 2; + */ + right?: ObjectDiff; +} +/** + * Symbol visibility flags + * + * @generated from protobuf enum objdiff.diff.SymbolFlag + */ +export enum SymbolFlag { + /** + * @generated from protobuf enum value: SYMBOL_NONE = 0; + */ + SYMBOL_NONE = 0, + /** + * @generated from protobuf enum value: SYMBOL_GLOBAL = 1; + */ + SYMBOL_GLOBAL = 1, + /** + * @generated from protobuf enum value: SYMBOL_LOCAL = 2; + */ + SYMBOL_LOCAL = 2, + /** + * @generated from protobuf enum value: SYMBOL_WEAK = 3; + */ + SYMBOL_WEAK = 3, + /** + * @generated from protobuf enum value: SYMBOL_COMMON = 4; + */ + SYMBOL_COMMON = 4, + /** + * @generated from protobuf enum value: SYMBOL_HIDDEN = 5; + */ + SYMBOL_HIDDEN = 5 +} +/** + * @generated from protobuf enum objdiff.diff.DiffKind + */ +export enum DiffKind { + /** + * @generated from protobuf enum value: DIFF_NONE = 0; + */ + DIFF_NONE = 0, + /** + * @generated from protobuf enum value: DIFF_REPLACE = 1; + */ + DIFF_REPLACE = 1, + /** + * @generated from protobuf enum value: DIFF_DELETE = 2; + */ + DIFF_DELETE = 2, + /** + * @generated from protobuf enum value: DIFF_INSERT = 3; + */ + DIFF_INSERT = 3, + /** + * @generated from protobuf enum value: DIFF_OP_MISMATCH = 4; + */ + DIFF_OP_MISMATCH = 4, + /** + * @generated from protobuf enum value: DIFF_ARG_MISMATCH = 5; + */ + DIFF_ARG_MISMATCH = 5 +} +/** + * @generated from protobuf enum objdiff.diff.SectionKind + */ +export enum SectionKind { + /** + * @generated from protobuf enum value: SECTION_UNKNOWN = 0; + */ + SECTION_UNKNOWN = 0, + /** + * @generated from protobuf enum value: SECTION_TEXT = 1; + */ + SECTION_TEXT = 1, + /** + * @generated from protobuf enum value: SECTION_DATA = 2; + */ + SECTION_DATA = 2, + /** + * @generated from protobuf enum value: SECTION_BSS = 3; + */ + SECTION_BSS = 3, + /** + * @generated from protobuf enum value: SECTION_COMMON = 4; + */ + SECTION_COMMON = 4 +} +// @generated message type with reflection information, may provide speed optimized methods +class Symbol$Type extends MessageType { + constructor() { + super("objdiff.diff.Symbol", [ + { no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "demangled_name", kind: "scalar", localName: "demangled_name", opt: true, T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "address", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }, + { no: 4, name: "size", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }, + { no: 5, name: "flags", kind: "scalar", T: 13 /*ScalarType.UINT32*/ } + ]); + } + create(value?: PartialMessage): Symbol { + const message = globalThis.Object.create((this.messagePrototype!)); + message.name = ""; + message.address = 0n; + message.size = 0n; + message.flags = 0; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Symbol): Symbol { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string name */ 1: + message.name = reader.string(); + break; + case /* optional string demangled_name */ 2: + message.demangled_name = reader.string(); + break; + case /* uint64 address */ 3: + message.address = reader.uint64().toBigInt(); + break; + case /* uint64 size */ 4: + message.size = reader.uint64().toBigInt(); + break; + case /* uint32 flags */ 5: + message.flags = reader.uint32(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: Symbol, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string name = 1; */ + if (message.name !== "") + writer.tag(1, WireType.LengthDelimited).string(message.name); + /* optional string demangled_name = 2; */ + if (message.demangled_name !== undefined) + writer.tag(2, WireType.LengthDelimited).string(message.demangled_name); + /* uint64 address = 3; */ + if (message.address !== 0n) + writer.tag(3, WireType.Varint).uint64(message.address); + /* uint64 size = 4; */ + if (message.size !== 0n) + writer.tag(4, WireType.Varint).uint64(message.size); + /* uint32 flags = 5; */ + if (message.flags !== 0) + writer.tag(5, WireType.Varint).uint32(message.flags); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.Symbol + */ +export const Symbol = new Symbol$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class Instruction$Type extends MessageType { + constructor() { + super("objdiff.diff.Instruction", [ + { no: 1, name: "address", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }, + { no: 2, name: "size", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }, + { no: 3, name: "opcode", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }, + { no: 4, name: "mnemonic", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 5, name: "formatted", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 6, name: "original", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, + { no: 7, name: "arguments", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Argument }, + { no: 8, name: "relocation", kind: "message", T: () => Relocation }, + { no: 9, name: "branch_dest", kind: "scalar", localName: "branch_dest", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }, + { no: 10, name: "line_number", kind: "scalar", localName: "line_number", opt: true, T: 13 /*ScalarType.UINT32*/ } + ]); + } + create(value?: PartialMessage): Instruction { + const message = globalThis.Object.create((this.messagePrototype!)); + message.address = 0n; + message.size = 0; + message.opcode = 0; + message.mnemonic = ""; + message.formatted = ""; + message.arguments = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Instruction): Instruction { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* uint64 address */ 1: + message.address = reader.uint64().toBigInt(); + break; + case /* uint32 size */ 2: + message.size = reader.uint32(); + break; + case /* uint32 opcode */ 3: + message.opcode = reader.uint32(); + break; + case /* string mnemonic */ 4: + message.mnemonic = reader.string(); + break; + case /* string formatted */ 5: + message.formatted = reader.string(); + break; + case /* optional string original */ 6: + message.original = reader.string(); + break; + case /* repeated objdiff.diff.Argument arguments */ 7: + message.arguments.push(Argument.internalBinaryRead(reader, reader.uint32(), options)); + break; + case /* optional objdiff.diff.Relocation relocation */ 8: + message.relocation = Relocation.internalBinaryRead(reader, reader.uint32(), options, message.relocation); + break; + case /* optional uint64 branch_dest */ 9: + message.branch_dest = reader.uint64().toBigInt(); + break; + case /* optional uint32 line_number */ 10: + message.line_number = reader.uint32(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: Instruction, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* uint64 address = 1; */ + if (message.address !== 0n) + writer.tag(1, WireType.Varint).uint64(message.address); + /* uint32 size = 2; */ + if (message.size !== 0) + writer.tag(2, WireType.Varint).uint32(message.size); + /* uint32 opcode = 3; */ + if (message.opcode !== 0) + writer.tag(3, WireType.Varint).uint32(message.opcode); + /* string mnemonic = 4; */ + if (message.mnemonic !== "") + writer.tag(4, WireType.LengthDelimited).string(message.mnemonic); + /* string formatted = 5; */ + if (message.formatted !== "") + writer.tag(5, WireType.LengthDelimited).string(message.formatted); + /* optional string original = 6; */ + if (message.original !== undefined) + writer.tag(6, WireType.LengthDelimited).string(message.original); + /* repeated objdiff.diff.Argument arguments = 7; */ + for (let i = 0; i < message.arguments.length; i++) + Argument.internalBinaryWrite(message.arguments[i], writer.tag(7, WireType.LengthDelimited).fork(), options).join(); + /* optional objdiff.diff.Relocation relocation = 8; */ + if (message.relocation) + Relocation.internalBinaryWrite(message.relocation, writer.tag(8, WireType.LengthDelimited).fork(), options).join(); + /* optional uint64 branch_dest = 9; */ + if (message.branch_dest !== undefined) + writer.tag(9, WireType.Varint).uint64(message.branch_dest); + /* optional uint32 line_number = 10; */ + if (message.line_number !== undefined) + writer.tag(10, WireType.Varint).uint32(message.line_number); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.Instruction + */ +export const Instruction = new Instruction$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class Argument$Type extends MessageType { + constructor() { + super("objdiff.diff.Argument", [ + { no: 1, name: "plain_text", kind: "scalar", localName: "plain_text", oneof: "value", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "argument", kind: "message", oneof: "value", T: () => ArgumentValue }, + { no: 3, name: "relocation", kind: "message", oneof: "value", T: () => ArgumentRelocation }, + { no: 4, name: "branch_dest", kind: "scalar", localName: "branch_dest", oneof: "value", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ } + ]); + } + create(value?: PartialMessage): Argument { + const message = globalThis.Object.create((this.messagePrototype!)); + message.value = { oneofKind: undefined }; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Argument): Argument { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string plain_text */ 1: + message.value = { + oneofKind: "plain_text", + plain_text: reader.string() + }; + break; + case /* objdiff.diff.ArgumentValue argument */ 2: + message.value = { + oneofKind: "argument", + argument: ArgumentValue.internalBinaryRead(reader, reader.uint32(), options, (message.value as any).argument) + }; + break; + case /* objdiff.diff.ArgumentRelocation relocation */ 3: + message.value = { + oneofKind: "relocation", + relocation: ArgumentRelocation.internalBinaryRead(reader, reader.uint32(), options, (message.value as any).relocation) + }; + break; + case /* uint64 branch_dest */ 4: + message.value = { + oneofKind: "branch_dest", + branch_dest: reader.uint64().toBigInt() + }; + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: Argument, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string plain_text = 1; */ + if (message.value.oneofKind === "plain_text") + writer.tag(1, WireType.LengthDelimited).string(message.value.plain_text); + /* objdiff.diff.ArgumentValue argument = 2; */ + if (message.value.oneofKind === "argument") + ArgumentValue.internalBinaryWrite(message.value.argument, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + /* objdiff.diff.ArgumentRelocation relocation = 3; */ + if (message.value.oneofKind === "relocation") + ArgumentRelocation.internalBinaryWrite(message.value.relocation, writer.tag(3, WireType.LengthDelimited).fork(), options).join(); + /* uint64 branch_dest = 4; */ + if (message.value.oneofKind === "branch_dest") + writer.tag(4, WireType.Varint).uint64(message.value.branch_dest); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.Argument + */ +export const Argument = new Argument$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ArgumentValue$Type extends MessageType { + constructor() { + super("objdiff.diff.ArgumentValue", [ + { no: 1, name: "signed", kind: "scalar", oneof: "value", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }, + { no: 2, name: "unsigned", kind: "scalar", oneof: "value", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }, + { no: 3, name: "opaque", kind: "scalar", oneof: "value", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value?: PartialMessage): ArgumentValue { + const message = globalThis.Object.create((this.messagePrototype!)); + message.value = { oneofKind: undefined }; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ArgumentValue): ArgumentValue { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* int64 signed */ 1: + message.value = { + oneofKind: "signed", + signed: reader.int64().toBigInt() + }; + break; + case /* uint64 unsigned */ 2: + message.value = { + oneofKind: "unsigned", + unsigned: reader.uint64().toBigInt() + }; + break; + case /* string opaque */ 3: + message.value = { + oneofKind: "opaque", + opaque: reader.string() + }; + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: ArgumentValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* int64 signed = 1; */ + if (message.value.oneofKind === "signed") + writer.tag(1, WireType.Varint).int64(message.value.signed); + /* uint64 unsigned = 2; */ + if (message.value.oneofKind === "unsigned") + writer.tag(2, WireType.Varint).uint64(message.value.unsigned); + /* string opaque = 3; */ + if (message.value.oneofKind === "opaque") + writer.tag(3, WireType.LengthDelimited).string(message.value.opaque); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.ArgumentValue + */ +export const ArgumentValue = new ArgumentValue$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ArgumentRelocation$Type extends MessageType { + constructor() { + super("objdiff.diff.ArgumentRelocation", []); + } + create(value?: PartialMessage): ArgumentRelocation { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ArgumentRelocation): ArgumentRelocation { + return target ?? this.create(); + } + internalBinaryWrite(message: ArgumentRelocation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.ArgumentRelocation + */ +export const ArgumentRelocation = new ArgumentRelocation$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class Relocation$Type extends MessageType { + constructor() { + super("objdiff.diff.Relocation", [ + { no: 1, name: "type", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }, + { no: 2, name: "type_name", kind: "scalar", localName: "type_name", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "target", kind: "message", T: () => RelocationTarget } + ]); + } + create(value?: PartialMessage): Relocation { + const message = globalThis.Object.create((this.messagePrototype!)); + message.type = 0; + message.type_name = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Relocation): Relocation { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* uint32 type */ 1: + message.type = reader.uint32(); + break; + case /* string type_name */ 2: + message.type_name = reader.string(); + break; + case /* objdiff.diff.RelocationTarget target */ 3: + message.target = RelocationTarget.internalBinaryRead(reader, reader.uint32(), options, message.target); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: Relocation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* uint32 type = 1; */ + if (message.type !== 0) + writer.tag(1, WireType.Varint).uint32(message.type); + /* string type_name = 2; */ + if (message.type_name !== "") + writer.tag(2, WireType.LengthDelimited).string(message.type_name); + /* objdiff.diff.RelocationTarget target = 3; */ + if (message.target) + RelocationTarget.internalBinaryWrite(message.target, writer.tag(3, WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.Relocation + */ +export const Relocation = new Relocation$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class RelocationTarget$Type extends MessageType { + constructor() { + super("objdiff.diff.RelocationTarget", [ + { no: 1, name: "symbol", kind: "message", T: () => Symbol }, + { no: 2, name: "addend", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ } + ]); + } + create(value?: PartialMessage): RelocationTarget { + const message = globalThis.Object.create((this.messagePrototype!)); + message.addend = 0n; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RelocationTarget): RelocationTarget { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* objdiff.diff.Symbol symbol */ 1: + message.symbol = Symbol.internalBinaryRead(reader, reader.uint32(), options, message.symbol); + break; + case /* int64 addend */ 2: + message.addend = reader.int64().toBigInt(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: RelocationTarget, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* objdiff.diff.Symbol symbol = 1; */ + if (message.symbol) + Symbol.internalBinaryWrite(message.symbol, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* int64 addend = 2; */ + if (message.addend !== 0n) + writer.tag(2, WireType.Varint).int64(message.addend); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.RelocationTarget + */ +export const RelocationTarget = new RelocationTarget$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class InstructionDiff$Type extends MessageType { + constructor() { + super("objdiff.diff.InstructionDiff", [ + { no: 1, name: "diff_kind", kind: "enum", localName: "diff_kind", T: () => ["objdiff.diff.DiffKind", DiffKind] }, + { no: 2, name: "instruction", kind: "message", T: () => Instruction }, + { no: 3, name: "branch_from", kind: "message", localName: "branch_from", T: () => InstructionBranchFrom }, + { no: 4, name: "branch_to", kind: "message", localName: "branch_to", T: () => InstructionBranchTo }, + { no: 5, name: "arg_diff", kind: "message", localName: "arg_diff", repeat: 1 /*RepeatType.PACKED*/, T: () => ArgumentDiff } + ]); + } + create(value?: PartialMessage): InstructionDiff { + const message = globalThis.Object.create((this.messagePrototype!)); + message.diff_kind = 0; + message.arg_diff = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: InstructionDiff): InstructionDiff { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* objdiff.diff.DiffKind diff_kind */ 1: + message.diff_kind = reader.int32(); + break; + case /* optional objdiff.diff.Instruction instruction */ 2: + message.instruction = Instruction.internalBinaryRead(reader, reader.uint32(), options, message.instruction); + break; + case /* optional objdiff.diff.InstructionBranchFrom branch_from */ 3: + message.branch_from = InstructionBranchFrom.internalBinaryRead(reader, reader.uint32(), options, message.branch_from); + break; + case /* optional objdiff.diff.InstructionBranchTo branch_to */ 4: + message.branch_to = InstructionBranchTo.internalBinaryRead(reader, reader.uint32(), options, message.branch_to); + break; + case /* repeated objdiff.diff.ArgumentDiff arg_diff */ 5: + message.arg_diff.push(ArgumentDiff.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: InstructionDiff, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* objdiff.diff.DiffKind diff_kind = 1; */ + if (message.diff_kind !== 0) + writer.tag(1, WireType.Varint).int32(message.diff_kind); + /* optional objdiff.diff.Instruction instruction = 2; */ + if (message.instruction) + Instruction.internalBinaryWrite(message.instruction, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + /* optional objdiff.diff.InstructionBranchFrom branch_from = 3; */ + if (message.branch_from) + InstructionBranchFrom.internalBinaryWrite(message.branch_from, writer.tag(3, WireType.LengthDelimited).fork(), options).join(); + /* optional objdiff.diff.InstructionBranchTo branch_to = 4; */ + if (message.branch_to) + InstructionBranchTo.internalBinaryWrite(message.branch_to, writer.tag(4, WireType.LengthDelimited).fork(), options).join(); + /* repeated objdiff.diff.ArgumentDiff arg_diff = 5; */ + for (let i = 0; i < message.arg_diff.length; i++) + ArgumentDiff.internalBinaryWrite(message.arg_diff[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.InstructionDiff + */ +export const InstructionDiff = new InstructionDiff$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ArgumentDiff$Type extends MessageType { + constructor() { + super("objdiff.diff.ArgumentDiff", [ + { no: 1, name: "diff_index", kind: "scalar", localName: "diff_index", opt: true, T: 13 /*ScalarType.UINT32*/ } + ]); + } + create(value?: PartialMessage): ArgumentDiff { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ArgumentDiff): ArgumentDiff { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* optional uint32 diff_index */ 1: + message.diff_index = reader.uint32(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: ArgumentDiff, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* optional uint32 diff_index = 1; */ + if (message.diff_index !== undefined) + writer.tag(1, WireType.Varint).uint32(message.diff_index); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.ArgumentDiff + */ +export const ArgumentDiff = new ArgumentDiff$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class InstructionBranchFrom$Type extends MessageType { + constructor() { + super("objdiff.diff.InstructionBranchFrom", [ + { no: 1, name: "instruction_index", kind: "scalar", localName: "instruction_index", repeat: 1 /*RepeatType.PACKED*/, T: 13 /*ScalarType.UINT32*/ }, + { no: 2, name: "branch_index", kind: "scalar", localName: "branch_index", T: 13 /*ScalarType.UINT32*/ } + ]); + } + create(value?: PartialMessage): InstructionBranchFrom { + const message = globalThis.Object.create((this.messagePrototype!)); + message.instruction_index = []; + message.branch_index = 0; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: InstructionBranchFrom): InstructionBranchFrom { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* repeated uint32 instruction_index */ 1: + if (wireType === WireType.LengthDelimited) + for (let e = reader.int32() + reader.pos; reader.pos < e;) + message.instruction_index.push(reader.uint32()); + else + message.instruction_index.push(reader.uint32()); + break; + case /* uint32 branch_index */ 2: + message.branch_index = reader.uint32(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: InstructionBranchFrom, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* repeated uint32 instruction_index = 1; */ + if (message.instruction_index.length) { + writer.tag(1, WireType.LengthDelimited).fork(); + for (let i = 0; i < message.instruction_index.length; i++) + writer.uint32(message.instruction_index[i]); + writer.join(); + } + /* uint32 branch_index = 2; */ + if (message.branch_index !== 0) + writer.tag(2, WireType.Varint).uint32(message.branch_index); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.InstructionBranchFrom + */ +export const InstructionBranchFrom = new InstructionBranchFrom$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class InstructionBranchTo$Type extends MessageType { + constructor() { + super("objdiff.diff.InstructionBranchTo", [ + { no: 1, name: "instruction_index", kind: "scalar", localName: "instruction_index", T: 13 /*ScalarType.UINT32*/ }, + { no: 2, name: "branch_index", kind: "scalar", localName: "branch_index", T: 13 /*ScalarType.UINT32*/ } + ]); + } + create(value?: PartialMessage): InstructionBranchTo { + const message = globalThis.Object.create((this.messagePrototype!)); + message.instruction_index = 0; + message.branch_index = 0; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: InstructionBranchTo): InstructionBranchTo { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* uint32 instruction_index */ 1: + message.instruction_index = reader.uint32(); + break; + case /* uint32 branch_index */ 2: + message.branch_index = reader.uint32(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: InstructionBranchTo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* uint32 instruction_index = 1; */ + if (message.instruction_index !== 0) + writer.tag(1, WireType.Varint).uint32(message.instruction_index); + /* uint32 branch_index = 2; */ + if (message.branch_index !== 0) + writer.tag(2, WireType.Varint).uint32(message.branch_index); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.InstructionBranchTo + */ +export const InstructionBranchTo = new InstructionBranchTo$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class FunctionDiff$Type extends MessageType { + constructor() { + super("objdiff.diff.FunctionDiff", [ + { no: 1, name: "symbol", kind: "message", T: () => Symbol }, + { no: 2, name: "instructions", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => InstructionDiff }, + { no: 3, name: "match_percent", kind: "scalar", localName: "match_percent", opt: true, T: 2 /*ScalarType.FLOAT*/ } + ]); + } + create(value?: PartialMessage): FunctionDiff { + const message = globalThis.Object.create((this.messagePrototype!)); + message.instructions = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FunctionDiff): FunctionDiff { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* objdiff.diff.Symbol symbol */ 1: + message.symbol = Symbol.internalBinaryRead(reader, reader.uint32(), options, message.symbol); + break; + case /* repeated objdiff.diff.InstructionDiff instructions */ 2: + message.instructions.push(InstructionDiff.internalBinaryRead(reader, reader.uint32(), options)); + break; + case /* optional float match_percent */ 3: + message.match_percent = reader.float(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: FunctionDiff, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* objdiff.diff.Symbol symbol = 1; */ + if (message.symbol) + Symbol.internalBinaryWrite(message.symbol, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* repeated objdiff.diff.InstructionDiff instructions = 2; */ + for (let i = 0; i < message.instructions.length; i++) + InstructionDiff.internalBinaryWrite(message.instructions[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + /* optional float match_percent = 3; */ + if (message.match_percent !== undefined) + writer.tag(3, WireType.Bit32).float(message.match_percent); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.FunctionDiff + */ +export const FunctionDiff = new FunctionDiff$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class DataDiff$Type extends MessageType { + constructor() { + super("objdiff.diff.DataDiff", [ + { no: 1, name: "kind", kind: "enum", T: () => ["objdiff.diff.DiffKind", DiffKind] }, + { no: 2, name: "data", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }, + { no: 3, name: "size", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ } + ]); + } + create(value?: PartialMessage): DataDiff { + const message = globalThis.Object.create((this.messagePrototype!)); + message.kind = 0; + message.data = new Uint8Array(0); + message.size = 0n; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DataDiff): DataDiff { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* objdiff.diff.DiffKind kind */ 1: + message.kind = reader.int32(); + break; + case /* bytes data */ 2: + message.data = reader.bytes(); + break; + case /* uint64 size */ 3: + message.size = reader.uint64().toBigInt(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: DataDiff, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* objdiff.diff.DiffKind kind = 1; */ + if (message.kind !== 0) + writer.tag(1, WireType.Varint).int32(message.kind); + /* bytes data = 2; */ + if (message.data.length) + writer.tag(2, WireType.LengthDelimited).bytes(message.data); + /* uint64 size = 3; */ + if (message.size !== 0n) + writer.tag(3, WireType.Varint).uint64(message.size); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.DataDiff + */ +export const DataDiff = new DataDiff$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class SectionDiff$Type extends MessageType { + constructor() { + super("objdiff.diff.SectionDiff", [ + { no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "kind", kind: "enum", T: () => ["objdiff.diff.SectionKind", SectionKind] }, + { no: 3, name: "size", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }, + { no: 4, name: "address", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }, + { no: 5, name: "functions", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => FunctionDiff }, + { no: 6, name: "data", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => DataDiff }, + { no: 7, name: "match_percent", kind: "scalar", localName: "match_percent", opt: true, T: 2 /*ScalarType.FLOAT*/ } + ]); + } + create(value?: PartialMessage): SectionDiff { + const message = globalThis.Object.create((this.messagePrototype!)); + message.name = ""; + message.kind = 0; + message.size = 0n; + message.address = 0n; + message.functions = []; + message.data = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SectionDiff): SectionDiff { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string name */ 1: + message.name = reader.string(); + break; + case /* objdiff.diff.SectionKind kind */ 2: + message.kind = reader.int32(); + break; + case /* uint64 size */ 3: + message.size = reader.uint64().toBigInt(); + break; + case /* uint64 address */ 4: + message.address = reader.uint64().toBigInt(); + break; + case /* repeated objdiff.diff.FunctionDiff functions */ 5: + message.functions.push(FunctionDiff.internalBinaryRead(reader, reader.uint32(), options)); + break; + case /* repeated objdiff.diff.DataDiff data */ 6: + message.data.push(DataDiff.internalBinaryRead(reader, reader.uint32(), options)); + break; + case /* optional float match_percent */ 7: + message.match_percent = reader.float(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: SectionDiff, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string name = 1; */ + if (message.name !== "") + writer.tag(1, WireType.LengthDelimited).string(message.name); + /* objdiff.diff.SectionKind kind = 2; */ + if (message.kind !== 0) + writer.tag(2, WireType.Varint).int32(message.kind); + /* uint64 size = 3; */ + if (message.size !== 0n) + writer.tag(3, WireType.Varint).uint64(message.size); + /* uint64 address = 4; */ + if (message.address !== 0n) + writer.tag(4, WireType.Varint).uint64(message.address); + /* repeated objdiff.diff.FunctionDiff functions = 5; */ + for (let i = 0; i < message.functions.length; i++) + FunctionDiff.internalBinaryWrite(message.functions[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join(); + /* repeated objdiff.diff.DataDiff data = 6; */ + for (let i = 0; i < message.data.length; i++) + DataDiff.internalBinaryWrite(message.data[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join(); + /* optional float match_percent = 7; */ + if (message.match_percent !== undefined) + writer.tag(7, WireType.Bit32).float(message.match_percent); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.SectionDiff + */ +export const SectionDiff = new SectionDiff$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ObjectDiff$Type extends MessageType { + constructor() { + super("objdiff.diff.ObjectDiff", [ + { no: 1, name: "sections", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => SectionDiff } + ]); + } + create(value?: PartialMessage): ObjectDiff { + const message = globalThis.Object.create((this.messagePrototype!)); + message.sections = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ObjectDiff): ObjectDiff { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* repeated objdiff.diff.SectionDiff sections */ 1: + message.sections.push(SectionDiff.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: ObjectDiff, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* repeated objdiff.diff.SectionDiff sections = 1; */ + for (let i = 0; i < message.sections.length; i++) + SectionDiff.internalBinaryWrite(message.sections[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.ObjectDiff + */ +export const ObjectDiff = new ObjectDiff$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class DiffResult$Type extends MessageType { + constructor() { + super("objdiff.diff.DiffResult", [ + { no: 1, name: "left", kind: "message", T: () => ObjectDiff }, + { no: 2, name: "right", kind: "message", T: () => ObjectDiff } + ]); + } + create(value?: PartialMessage): DiffResult { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DiffResult): DiffResult { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* optional objdiff.diff.ObjectDiff left */ 1: + message.left = ObjectDiff.internalBinaryRead(reader, reader.uint32(), options, message.left); + break; + case /* optional objdiff.diff.ObjectDiff right */ 2: + message.right = ObjectDiff.internalBinaryRead(reader, reader.uint32(), options, message.right); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: DiffResult, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* optional objdiff.diff.ObjectDiff left = 1; */ + if (message.left) + ObjectDiff.internalBinaryWrite(message.left, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* optional objdiff.diff.ObjectDiff right = 2; */ + if (message.right) + ObjectDiff.internalBinaryWrite(message.right, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.diff.DiffResult + */ +export const DiffResult = new DiffResult$Type(); diff --git a/gen/report_pb.ts b/gen/report_pb.ts new file mode 100644 index 0000000..5416c0e --- /dev/null +++ b/gen/report_pb.ts @@ -0,0 +1,2007 @@ +/* eslint-disable */ +// @generated by protobuf-ts 2.9.4 with parameter add_pb_suffix,eslint_disable,ts_nocheck,use_proto_field_name +// @generated from protobuf file "report.proto" (package "objdiff.report", syntax proto3) +// tslint:disable +// @ts-nocheck +import type { BinaryWriteOptions } from '@protobuf-ts/runtime'; +import type { IBinaryWriter } from '@protobuf-ts/runtime'; +import { WireType } from '@protobuf-ts/runtime'; +import type { BinaryReadOptions } from '@protobuf-ts/runtime'; +import type { IBinaryReader } from '@protobuf-ts/runtime'; +import { UnknownFieldHandler } from '@protobuf-ts/runtime'; +import type { PartialMessage } from '@protobuf-ts/runtime'; +import { reflectionMergePartial } from '@protobuf-ts/runtime'; +import { MessageType } from '@protobuf-ts/runtime'; +/** + * Progress info for a report or unit + * + * @generated from protobuf message objdiff.report.Measures + */ +export interface Measures { + /** + * Overall match percent, including partially matched functions and data + * + * @generated from protobuf field: float fuzzy_match_percent = 1; + */ + fuzzy_match_percent: number; + /** + * Total size of code in bytes + * + * @generated from protobuf field: uint64 total_code = 2; + */ + total_code: bigint; + /** + * Fully matched code size in bytes + * + * @generated from protobuf field: uint64 matched_code = 3; + */ + matched_code: bigint; + /** + * Fully matched code percent + * + * @generated from protobuf field: float matched_code_percent = 4; + */ + matched_code_percent: number; + /** + * Total size of data in bytes + * + * @generated from protobuf field: uint64 total_data = 5; + */ + total_data: bigint; + /** + * Fully matched data size in bytes + * + * @generated from protobuf field: uint64 matched_data = 6; + */ + matched_data: bigint; + /** + * Fully matched data percent + * + * @generated from protobuf field: float matched_data_percent = 7; + */ + matched_data_percent: number; + /** + * Total number of functions + * + * @generated from protobuf field: uint32 total_functions = 8; + */ + total_functions: number; + /** + * Fully matched functions + * + * @generated from protobuf field: uint32 matched_functions = 9; + */ + matched_functions: number; + /** + * Fully matched functions percent + * + * @generated from protobuf field: float matched_functions_percent = 10; + */ + matched_functions_percent: number; + /** + * Completed (or "linked") code size in bytes + * + * @generated from protobuf field: uint64 complete_code = 11; + */ + complete_code: bigint; + /** + * Completed (or "linked") code percent + * + * @generated from protobuf field: float complete_code_percent = 12; + */ + complete_code_percent: number; + /** + * Completed (or "linked") data size in bytes + * + * @generated from protobuf field: uint64 complete_data = 13; + */ + complete_data: bigint; + /** + * Completed (or "linked") data percent + * + * @generated from protobuf field: float complete_data_percent = 14; + */ + complete_data_percent: number; + /** + * Total number of units + * + * @generated from protobuf field: uint32 total_units = 15; + */ + total_units: number; + /** + * Completed (or "linked") units + * + * @generated from protobuf field: uint32 complete_units = 16; + */ + complete_units: number; +} +/** + * Project progress report + * + * @generated from protobuf message objdiff.report.Report + */ +export interface Report { + /** + * Overall progress info + * + * @generated from protobuf field: objdiff.report.Measures measures = 1; + */ + measures?: Measures; + /** + * Units within this report + * + * @generated from protobuf field: repeated objdiff.report.ReportUnit units = 2; + */ + units: ReportUnit[]; + /** + * Report version + * + * @generated from protobuf field: uint32 version = 3; + */ + version: number; + /** + * Progress categories + * + * @generated from protobuf field: repeated objdiff.report.ReportCategory categories = 4; + */ + categories: ReportCategory[]; +} +/** + * @generated from protobuf message objdiff.report.ReportCategory + */ +export interface ReportCategory { + /** + * The ID of the category + * + * @generated from protobuf field: string id = 1; + */ + id: string; + /** + * The name of the category + * + * @generated from protobuf field: string name = 2; + */ + name: string; + /** + * Progress info for this category + * + * @generated from protobuf field: objdiff.report.Measures measures = 3; + */ + measures?: Measures; +} +/** + * A unit of the report (usually a translation unit) + * + * @generated from protobuf message objdiff.report.ReportUnit + */ +export interface ReportUnit { + /** + * The name of the unit + * + * @generated from protobuf field: string name = 1; + */ + name: string; + /** + * Progress info for this unit + * + * @generated from protobuf field: objdiff.report.Measures measures = 2; + */ + measures?: Measures; + /** + * Sections within this unit + * + * @generated from protobuf field: repeated objdiff.report.ReportItem sections = 3; + */ + sections: ReportItem[]; + /** + * Functions within this unit + * + * @generated from protobuf field: repeated objdiff.report.ReportItem functions = 4; + */ + functions: ReportItem[]; + /** + * Extra metadata for this unit + * + * @generated from protobuf field: optional objdiff.report.ReportUnitMetadata metadata = 5; + */ + metadata?: ReportUnitMetadata; +} +/** + * Extra metadata for a unit + * + * @generated from protobuf message objdiff.report.ReportUnitMetadata + */ +export interface ReportUnitMetadata { + /** + * Whether this unit is marked as complete (or "linked") + * + * @generated from protobuf field: optional bool complete = 1; + */ + complete?: boolean; + /** + * The name of the module this unit belongs to + * + * @generated from protobuf field: optional string module_name = 2; + */ + module_name?: string; + /** + * The ID of the module this unit belongs to + * + * @generated from protobuf field: optional uint32 module_id = 3; + */ + module_id?: number; + /** + * The path to the source file of this unit + * + * @generated from protobuf field: optional string source_path = 4; + */ + source_path?: string; + /** + * Progress categories for this unit + * + * @generated from protobuf field: repeated string progress_categories = 5; + */ + progress_categories: string[]; + /** + * Whether this unit is automatically generated (not user-provided) + * + * @generated from protobuf field: optional bool auto_generated = 6; + */ + auto_generated?: boolean; +} +/** + * A section or function within a unit + * + * @generated from protobuf message objdiff.report.ReportItem + */ +export interface ReportItem { + /** + * The name of the item + * + * @generated from protobuf field: string name = 1; + */ + name: string; + /** + * The size of the item in bytes + * + * @generated from protobuf field: uint64 size = 2; + */ + size: bigint; + /** + * The overall match percent for this item + * + * @generated from protobuf field: float fuzzy_match_percent = 3; + */ + fuzzy_match_percent: number; + /** + * Extra metadata for this item + * + * @generated from protobuf field: optional objdiff.report.ReportItemMetadata metadata = 4; + */ + metadata?: ReportItemMetadata; +} +/** + * Extra metadata for an item + * + * @generated from protobuf message objdiff.report.ReportItemMetadata + */ +export interface ReportItemMetadata { + /** + * The demangled name of the function + * + * @generated from protobuf field: optional string demangled_name = 1; + */ + demangled_name?: string; + /** + * The virtual address of the function or section + * + * @generated from protobuf field: optional uint64 virtual_address = 2; + */ + virtual_address?: bigint; +} +/** + * A pair of reports to compare and generate changes + * + * @generated from protobuf message objdiff.report.ChangesInput + */ +export interface ChangesInput { + /** + * The previous report + * + * @generated from protobuf field: objdiff.report.Report from = 1; + */ + from?: Report; + /** + * The current report + * + * @generated from protobuf field: objdiff.report.Report to = 2; + */ + to?: Report; +} +/** + * Changes between two reports + * + * @generated from protobuf message objdiff.report.Changes + */ +export interface Changes { + /** + * The progress info for the previous report + * + * @generated from protobuf field: objdiff.report.Measures from = 1; + */ + from?: Measures; + /** + * The progress info for the current report + * + * @generated from protobuf field: objdiff.report.Measures to = 2; + */ + to?: Measures; + /** + * Units that changed + * + * @generated from protobuf field: repeated objdiff.report.ChangeUnit units = 3; + */ + units: ChangeUnit[]; +} +/** + * A changed unit + * + * @generated from protobuf message objdiff.report.ChangeUnit + */ +export interface ChangeUnit { + /** + * The name of the unit + * + * @generated from protobuf field: string name = 1; + */ + name: string; + /** + * The previous progress info (omitted if new) + * + * @generated from protobuf field: optional objdiff.report.Measures from = 2; + */ + from?: Measures; + /** + * The current progress info (omitted if removed) + * + * @generated from protobuf field: optional objdiff.report.Measures to = 3; + */ + to?: Measures; + /** + * Sections that changed + * + * @generated from protobuf field: repeated objdiff.report.ChangeItem sections = 4; + */ + sections: ChangeItem[]; + /** + * Functions that changed + * + * @generated from protobuf field: repeated objdiff.report.ChangeItem functions = 5; + */ + functions: ChangeItem[]; + /** + * Extra metadata for this unit + * + * @generated from protobuf field: optional objdiff.report.ReportUnitMetadata metadata = 6; + */ + metadata?: ReportUnitMetadata; +} +/** + * A changed section or function + * + * @generated from protobuf message objdiff.report.ChangeItem + */ +export interface ChangeItem { + /** + * The name of the item + * + * @generated from protobuf field: string name = 1; + */ + name: string; + /** + * The previous progress info (omitted if new) + * + * @generated from protobuf field: optional objdiff.report.ChangeItemInfo from = 2; + */ + from?: ChangeItemInfo; + /** + * The current progress info (omitted if removed) + * + * @generated from protobuf field: optional objdiff.report.ChangeItemInfo to = 3; + */ + to?: ChangeItemInfo; + /** + * Extra metadata for this item + * + * @generated from protobuf field: optional objdiff.report.ReportItemMetadata metadata = 4; + */ + metadata?: ReportItemMetadata; +} +/** + * Progress info for a section or function + * + * @generated from protobuf message objdiff.report.ChangeItemInfo + */ +export interface ChangeItemInfo { + /** + * The overall match percent for this item + * + * @generated from protobuf field: float fuzzy_match_percent = 1; + */ + fuzzy_match_percent: number; + /** + * The size of the item in bytes + * + * @generated from protobuf field: uint64 size = 2; + */ + size: bigint; +} +// @generated message type with reflection information, may provide speed optimized methods +class Measures$Type extends MessageType { + constructor() { + super('objdiff.report.Measures', [ + { + no: 1, + name: 'fuzzy_match_percent', + kind: 'scalar', + localName: 'fuzzy_match_percent', + T: 2 /*ScalarType.FLOAT*/, + }, + { + no: 2, + name: 'total_code', + kind: 'scalar', + localName: 'total_code', + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + { + no: 3, + name: 'matched_code', + kind: 'scalar', + localName: 'matched_code', + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + { + no: 4, + name: 'matched_code_percent', + kind: 'scalar', + localName: 'matched_code_percent', + T: 2 /*ScalarType.FLOAT*/, + }, + { + no: 5, + name: 'total_data', + kind: 'scalar', + localName: 'total_data', + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + { + no: 6, + name: 'matched_data', + kind: 'scalar', + localName: 'matched_data', + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + { + no: 7, + name: 'matched_data_percent', + kind: 'scalar', + localName: 'matched_data_percent', + T: 2 /*ScalarType.FLOAT*/, + }, + { + no: 8, + name: 'total_functions', + kind: 'scalar', + localName: 'total_functions', + T: 13 /*ScalarType.UINT32*/, + }, + { + no: 9, + name: 'matched_functions', + kind: 'scalar', + localName: 'matched_functions', + T: 13 /*ScalarType.UINT32*/, + }, + { + no: 10, + name: 'matched_functions_percent', + kind: 'scalar', + localName: 'matched_functions_percent', + T: 2 /*ScalarType.FLOAT*/, + }, + { + no: 11, + name: 'complete_code', + kind: 'scalar', + localName: 'complete_code', + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + { + no: 12, + name: 'complete_code_percent', + kind: 'scalar', + localName: 'complete_code_percent', + T: 2 /*ScalarType.FLOAT*/, + }, + { + no: 13, + name: 'complete_data', + kind: 'scalar', + localName: 'complete_data', + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + { + no: 14, + name: 'complete_data_percent', + kind: 'scalar', + localName: 'complete_data_percent', + T: 2 /*ScalarType.FLOAT*/, + }, + { + no: 15, + name: 'total_units', + kind: 'scalar', + localName: 'total_units', + T: 13 /*ScalarType.UINT32*/, + }, + { + no: 16, + name: 'complete_units', + kind: 'scalar', + localName: 'complete_units', + T: 13 /*ScalarType.UINT32*/, + }, + ]); + } + create(value?: PartialMessage): Measures { + const message = globalThis.Object.create(this.messagePrototype!); + message.fuzzy_match_percent = 0; + message.total_code = 0n; + message.matched_code = 0n; + message.matched_code_percent = 0; + message.total_data = 0n; + message.matched_data = 0n; + message.matched_data_percent = 0; + message.total_functions = 0; + message.matched_functions = 0; + message.matched_functions_percent = 0; + message.complete_code = 0n; + message.complete_code_percent = 0; + message.complete_data = 0n; + message.complete_data_percent = 0; + message.total_units = 0; + message.complete_units = 0; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead( + reader: IBinaryReader, + length: number, + options: BinaryReadOptions, + target?: Measures, + ): Measures { + let message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* float fuzzy_match_percent */ 1: + message.fuzzy_match_percent = reader.float(); + break; + case /* uint64 total_code */ 2: + message.total_code = reader.uint64().toBigInt(); + break; + case /* uint64 matched_code */ 3: + message.matched_code = reader.uint64().toBigInt(); + break; + case /* float matched_code_percent */ 4: + message.matched_code_percent = reader.float(); + break; + case /* uint64 total_data */ 5: + message.total_data = reader.uint64().toBigInt(); + break; + case /* uint64 matched_data */ 6: + message.matched_data = reader.uint64().toBigInt(); + break; + case /* float matched_data_percent */ 7: + message.matched_data_percent = reader.float(); + break; + case /* uint32 total_functions */ 8: + message.total_functions = reader.uint32(); + break; + case /* uint32 matched_functions */ 9: + message.matched_functions = reader.uint32(); + break; + case /* float matched_functions_percent */ 10: + message.matched_functions_percent = reader.float(); + break; + case /* uint64 complete_code */ 11: + message.complete_code = reader.uint64().toBigInt(); + break; + case /* float complete_code_percent */ 12: + message.complete_code_percent = reader.float(); + break; + case /* uint64 complete_data */ 13: + message.complete_data = reader.uint64().toBigInt(); + break; + case /* float complete_data_percent */ 14: + message.complete_data_percent = reader.float(); + break; + case /* uint32 total_units */ 15: + message.total_units = reader.uint32(); + break; + case /* uint32 complete_units */ 16: + message.complete_units = reader.uint32(); + break; + default: + let u = options.readUnknownField; + if (u === 'throw') + throw new globalThis.Error( + `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`, + ); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)( + this.typeName, + message, + fieldNo, + wireType, + d, + ); + } + } + return message; + } + internalBinaryWrite( + message: Measures, + writer: IBinaryWriter, + options: BinaryWriteOptions, + ): IBinaryWriter { + /* float fuzzy_match_percent = 1; */ + if (message.fuzzy_match_percent !== 0) + writer.tag(1, WireType.Bit32).float(message.fuzzy_match_percent); + /* uint64 total_code = 2; */ + if (message.total_code !== 0n) + writer.tag(2, WireType.Varint).uint64(message.total_code); + /* uint64 matched_code = 3; */ + if (message.matched_code !== 0n) + writer.tag(3, WireType.Varint).uint64(message.matched_code); + /* float matched_code_percent = 4; */ + if (message.matched_code_percent !== 0) + writer.tag(4, WireType.Bit32).float(message.matched_code_percent); + /* uint64 total_data = 5; */ + if (message.total_data !== 0n) + writer.tag(5, WireType.Varint).uint64(message.total_data); + /* uint64 matched_data = 6; */ + if (message.matched_data !== 0n) + writer.tag(6, WireType.Varint).uint64(message.matched_data); + /* float matched_data_percent = 7; */ + if (message.matched_data_percent !== 0) + writer.tag(7, WireType.Bit32).float(message.matched_data_percent); + /* uint32 total_functions = 8; */ + if (message.total_functions !== 0) + writer.tag(8, WireType.Varint).uint32(message.total_functions); + /* uint32 matched_functions = 9; */ + if (message.matched_functions !== 0) + writer.tag(9, WireType.Varint).uint32(message.matched_functions); + /* float matched_functions_percent = 10; */ + if (message.matched_functions_percent !== 0) + writer.tag(10, WireType.Bit32).float(message.matched_functions_percent); + /* uint64 complete_code = 11; */ + if (message.complete_code !== 0n) + writer.tag(11, WireType.Varint).uint64(message.complete_code); + /* float complete_code_percent = 12; */ + if (message.complete_code_percent !== 0) + writer.tag(12, WireType.Bit32).float(message.complete_code_percent); + /* uint64 complete_data = 13; */ + if (message.complete_data !== 0n) + writer.tag(13, WireType.Varint).uint64(message.complete_data); + /* float complete_data_percent = 14; */ + if (message.complete_data_percent !== 0) + writer.tag(14, WireType.Bit32).float(message.complete_data_percent); + /* uint32 total_units = 15; */ + if (message.total_units !== 0) + writer.tag(15, WireType.Varint).uint32(message.total_units); + /* uint32 complete_units = 16; */ + if (message.complete_units !== 0) + writer.tag(16, WireType.Varint).uint32(message.complete_units); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)( + this.typeName, + message, + writer, + ); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.report.Measures + */ +export const Measures = new Measures$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class Report$Type extends MessageType { + constructor() { + super('objdiff.report.Report', [ + { no: 1, name: 'measures', kind: 'message', T: () => Measures }, + { + no: 2, + name: 'units', + kind: 'message', + repeat: 1 /*RepeatType.PACKED*/, + T: () => ReportUnit, + }, + { no: 3, name: 'version', kind: 'scalar', T: 13 /*ScalarType.UINT32*/ }, + { + no: 4, + name: 'categories', + kind: 'message', + repeat: 1 /*RepeatType.PACKED*/, + T: () => ReportCategory, + }, + ]); + } + create(value?: PartialMessage): Report { + const message = globalThis.Object.create(this.messagePrototype!); + message.units = []; + message.version = 0; + message.categories = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead( + reader: IBinaryReader, + length: number, + options: BinaryReadOptions, + target?: Report, + ): Report { + let message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* objdiff.report.Measures measures */ 1: + message.measures = Measures.internalBinaryRead( + reader, + reader.uint32(), + options, + message.measures, + ); + break; + case /* repeated objdiff.report.ReportUnit units */ 2: + message.units.push( + ReportUnit.internalBinaryRead(reader, reader.uint32(), options), + ); + break; + case /* uint32 version */ 3: + message.version = reader.uint32(); + break; + case /* repeated objdiff.report.ReportCategory categories */ 4: + message.categories.push( + ReportCategory.internalBinaryRead(reader, reader.uint32(), options), + ); + break; + default: + let u = options.readUnknownField; + if (u === 'throw') + throw new globalThis.Error( + `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`, + ); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)( + this.typeName, + message, + fieldNo, + wireType, + d, + ); + } + } + return message; + } + internalBinaryWrite( + message: Report, + writer: IBinaryWriter, + options: BinaryWriteOptions, + ): IBinaryWriter { + /* objdiff.report.Measures measures = 1; */ + if (message.measures) + Measures.internalBinaryWrite( + message.measures, + writer.tag(1, WireType.LengthDelimited).fork(), + options, + ).join(); + /* repeated objdiff.report.ReportUnit units = 2; */ + for (let i = 0; i < message.units.length; i++) + ReportUnit.internalBinaryWrite( + message.units[i], + writer.tag(2, WireType.LengthDelimited).fork(), + options, + ).join(); + /* uint32 version = 3; */ + if (message.version !== 0) + writer.tag(3, WireType.Varint).uint32(message.version); + /* repeated objdiff.report.ReportCategory categories = 4; */ + for (let i = 0; i < message.categories.length; i++) + ReportCategory.internalBinaryWrite( + message.categories[i], + writer.tag(4, WireType.LengthDelimited).fork(), + options, + ).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)( + this.typeName, + message, + writer, + ); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.report.Report + */ +export const Report = new Report$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ReportCategory$Type extends MessageType { + constructor() { + super('objdiff.report.ReportCategory', [ + { no: 1, name: 'id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: 'name', kind: 'scalar', T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: 'measures', kind: 'message', T: () => Measures }, + ]); + } + create(value?: PartialMessage): ReportCategory { + const message = globalThis.Object.create(this.messagePrototype!); + message.id = ''; + message.name = ''; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead( + reader: IBinaryReader, + length: number, + options: BinaryReadOptions, + target?: ReportCategory, + ): ReportCategory { + let message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string id */ 1: + message.id = reader.string(); + break; + case /* string name */ 2: + message.name = reader.string(); + break; + case /* objdiff.report.Measures measures */ 3: + message.measures = Measures.internalBinaryRead( + reader, + reader.uint32(), + options, + message.measures, + ); + break; + default: + let u = options.readUnknownField; + if (u === 'throw') + throw new globalThis.Error( + `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`, + ); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)( + this.typeName, + message, + fieldNo, + wireType, + d, + ); + } + } + return message; + } + internalBinaryWrite( + message: ReportCategory, + writer: IBinaryWriter, + options: BinaryWriteOptions, + ): IBinaryWriter { + /* string id = 1; */ + if (message.id !== '') + writer.tag(1, WireType.LengthDelimited).string(message.id); + /* string name = 2; */ + if (message.name !== '') + writer.tag(2, WireType.LengthDelimited).string(message.name); + /* objdiff.report.Measures measures = 3; */ + if (message.measures) + Measures.internalBinaryWrite( + message.measures, + writer.tag(3, WireType.LengthDelimited).fork(), + options, + ).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)( + this.typeName, + message, + writer, + ); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.report.ReportCategory + */ +export const ReportCategory = new ReportCategory$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ReportUnit$Type extends MessageType { + constructor() { + super('objdiff.report.ReportUnit', [ + { no: 1, name: 'name', kind: 'scalar', T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: 'measures', kind: 'message', T: () => Measures }, + { + no: 3, + name: 'sections', + kind: 'message', + repeat: 1 /*RepeatType.PACKED*/, + T: () => ReportItem, + }, + { + no: 4, + name: 'functions', + kind: 'message', + repeat: 1 /*RepeatType.PACKED*/, + T: () => ReportItem, + }, + { no: 5, name: 'metadata', kind: 'message', T: () => ReportUnitMetadata }, + ]); + } + create(value?: PartialMessage): ReportUnit { + const message = globalThis.Object.create(this.messagePrototype!); + message.name = ''; + message.sections = []; + message.functions = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead( + reader: IBinaryReader, + length: number, + options: BinaryReadOptions, + target?: ReportUnit, + ): ReportUnit { + let message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string name */ 1: + message.name = reader.string(); + break; + case /* objdiff.report.Measures measures */ 2: + message.measures = Measures.internalBinaryRead( + reader, + reader.uint32(), + options, + message.measures, + ); + break; + case /* repeated objdiff.report.ReportItem sections */ 3: + message.sections.push( + ReportItem.internalBinaryRead(reader, reader.uint32(), options), + ); + break; + case /* repeated objdiff.report.ReportItem functions */ 4: + message.functions.push( + ReportItem.internalBinaryRead(reader, reader.uint32(), options), + ); + break; + case /* optional objdiff.report.ReportUnitMetadata metadata */ 5: + message.metadata = ReportUnitMetadata.internalBinaryRead( + reader, + reader.uint32(), + options, + message.metadata, + ); + break; + default: + let u = options.readUnknownField; + if (u === 'throw') + throw new globalThis.Error( + `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`, + ); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)( + this.typeName, + message, + fieldNo, + wireType, + d, + ); + } + } + return message; + } + internalBinaryWrite( + message: ReportUnit, + writer: IBinaryWriter, + options: BinaryWriteOptions, + ): IBinaryWriter { + /* string name = 1; */ + if (message.name !== '') + writer.tag(1, WireType.LengthDelimited).string(message.name); + /* objdiff.report.Measures measures = 2; */ + if (message.measures) + Measures.internalBinaryWrite( + message.measures, + writer.tag(2, WireType.LengthDelimited).fork(), + options, + ).join(); + /* repeated objdiff.report.ReportItem sections = 3; */ + for (let i = 0; i < message.sections.length; i++) + ReportItem.internalBinaryWrite( + message.sections[i], + writer.tag(3, WireType.LengthDelimited).fork(), + options, + ).join(); + /* repeated objdiff.report.ReportItem functions = 4; */ + for (let i = 0; i < message.functions.length; i++) + ReportItem.internalBinaryWrite( + message.functions[i], + writer.tag(4, WireType.LengthDelimited).fork(), + options, + ).join(); + /* optional objdiff.report.ReportUnitMetadata metadata = 5; */ + if (message.metadata) + ReportUnitMetadata.internalBinaryWrite( + message.metadata, + writer.tag(5, WireType.LengthDelimited).fork(), + options, + ).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)( + this.typeName, + message, + writer, + ); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.report.ReportUnit + */ +export const ReportUnit = new ReportUnit$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ReportUnitMetadata$Type extends MessageType { + constructor() { + super('objdiff.report.ReportUnitMetadata', [ + { + no: 1, + name: 'complete', + kind: 'scalar', + opt: true, + T: 8 /*ScalarType.BOOL*/, + }, + { + no: 2, + name: 'module_name', + kind: 'scalar', + localName: 'module_name', + opt: true, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 3, + name: 'module_id', + kind: 'scalar', + localName: 'module_id', + opt: true, + T: 13 /*ScalarType.UINT32*/, + }, + { + no: 4, + name: 'source_path', + kind: 'scalar', + localName: 'source_path', + opt: true, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 5, + name: 'progress_categories', + kind: 'scalar', + localName: 'progress_categories', + repeat: 2 /*RepeatType.UNPACKED*/, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 6, + name: 'auto_generated', + kind: 'scalar', + localName: 'auto_generated', + opt: true, + T: 8 /*ScalarType.BOOL*/, + }, + ]); + } + create(value?: PartialMessage): ReportUnitMetadata { + const message = globalThis.Object.create(this.messagePrototype!); + message.progress_categories = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead( + reader: IBinaryReader, + length: number, + options: BinaryReadOptions, + target?: ReportUnitMetadata, + ): ReportUnitMetadata { + let message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* optional bool complete */ 1: + message.complete = reader.bool(); + break; + case /* optional string module_name */ 2: + message.module_name = reader.string(); + break; + case /* optional uint32 module_id */ 3: + message.module_id = reader.uint32(); + break; + case /* optional string source_path */ 4: + message.source_path = reader.string(); + break; + case /* repeated string progress_categories */ 5: + message.progress_categories.push(reader.string()); + break; + case /* optional bool auto_generated */ 6: + message.auto_generated = reader.bool(); + break; + default: + let u = options.readUnknownField; + if (u === 'throw') + throw new globalThis.Error( + `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`, + ); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)( + this.typeName, + message, + fieldNo, + wireType, + d, + ); + } + } + return message; + } + internalBinaryWrite( + message: ReportUnitMetadata, + writer: IBinaryWriter, + options: BinaryWriteOptions, + ): IBinaryWriter { + /* optional bool complete = 1; */ + if (message.complete !== undefined) + writer.tag(1, WireType.Varint).bool(message.complete); + /* optional string module_name = 2; */ + if (message.module_name !== undefined) + writer.tag(2, WireType.LengthDelimited).string(message.module_name); + /* optional uint32 module_id = 3; */ + if (message.module_id !== undefined) + writer.tag(3, WireType.Varint).uint32(message.module_id); + /* optional string source_path = 4; */ + if (message.source_path !== undefined) + writer.tag(4, WireType.LengthDelimited).string(message.source_path); + /* repeated string progress_categories = 5; */ + for (let i = 0; i < message.progress_categories.length; i++) + writer + .tag(5, WireType.LengthDelimited) + .string(message.progress_categories[i]); + /* optional bool auto_generated = 6; */ + if (message.auto_generated !== undefined) + writer.tag(6, WireType.Varint).bool(message.auto_generated); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)( + this.typeName, + message, + writer, + ); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.report.ReportUnitMetadata + */ +export const ReportUnitMetadata = new ReportUnitMetadata$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ReportItem$Type extends MessageType { + constructor() { + super('objdiff.report.ReportItem', [ + { no: 1, name: 'name', kind: 'scalar', T: 9 /*ScalarType.STRING*/ }, + { + no: 2, + name: 'size', + kind: 'scalar', + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + { + no: 3, + name: 'fuzzy_match_percent', + kind: 'scalar', + localName: 'fuzzy_match_percent', + T: 2 /*ScalarType.FLOAT*/, + }, + { no: 4, name: 'metadata', kind: 'message', T: () => ReportItemMetadata }, + ]); + } + create(value?: PartialMessage): ReportItem { + const message = globalThis.Object.create(this.messagePrototype!); + message.name = ''; + message.size = 0n; + message.fuzzy_match_percent = 0; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead( + reader: IBinaryReader, + length: number, + options: BinaryReadOptions, + target?: ReportItem, + ): ReportItem { + let message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string name */ 1: + message.name = reader.string(); + break; + case /* uint64 size */ 2: + message.size = reader.uint64().toBigInt(); + break; + case /* float fuzzy_match_percent */ 3: + message.fuzzy_match_percent = reader.float(); + break; + case /* optional objdiff.report.ReportItemMetadata metadata */ 4: + message.metadata = ReportItemMetadata.internalBinaryRead( + reader, + reader.uint32(), + options, + message.metadata, + ); + break; + default: + let u = options.readUnknownField; + if (u === 'throw') + throw new globalThis.Error( + `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`, + ); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)( + this.typeName, + message, + fieldNo, + wireType, + d, + ); + } + } + return message; + } + internalBinaryWrite( + message: ReportItem, + writer: IBinaryWriter, + options: BinaryWriteOptions, + ): IBinaryWriter { + /* string name = 1; */ + if (message.name !== '') + writer.tag(1, WireType.LengthDelimited).string(message.name); + /* uint64 size = 2; */ + if (message.size !== 0n) + writer.tag(2, WireType.Varint).uint64(message.size); + /* float fuzzy_match_percent = 3; */ + if (message.fuzzy_match_percent !== 0) + writer.tag(3, WireType.Bit32).float(message.fuzzy_match_percent); + /* optional objdiff.report.ReportItemMetadata metadata = 4; */ + if (message.metadata) + ReportItemMetadata.internalBinaryWrite( + message.metadata, + writer.tag(4, WireType.LengthDelimited).fork(), + options, + ).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)( + this.typeName, + message, + writer, + ); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.report.ReportItem + */ +export const ReportItem = new ReportItem$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ReportItemMetadata$Type extends MessageType { + constructor() { + super('objdiff.report.ReportItemMetadata', [ + { + no: 1, + name: 'demangled_name', + kind: 'scalar', + localName: 'demangled_name', + opt: true, + T: 9 /*ScalarType.STRING*/, + }, + { + no: 2, + name: 'virtual_address', + kind: 'scalar', + localName: 'virtual_address', + opt: true, + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + ]); + } + create(value?: PartialMessage): ReportItemMetadata { + const message = globalThis.Object.create(this.messagePrototype!); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead( + reader: IBinaryReader, + length: number, + options: BinaryReadOptions, + target?: ReportItemMetadata, + ): ReportItemMetadata { + let message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* optional string demangled_name */ 1: + message.demangled_name = reader.string(); + break; + case /* optional uint64 virtual_address */ 2: + message.virtual_address = reader.uint64().toBigInt(); + break; + default: + let u = options.readUnknownField; + if (u === 'throw') + throw new globalThis.Error( + `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`, + ); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)( + this.typeName, + message, + fieldNo, + wireType, + d, + ); + } + } + return message; + } + internalBinaryWrite( + message: ReportItemMetadata, + writer: IBinaryWriter, + options: BinaryWriteOptions, + ): IBinaryWriter { + /* optional string demangled_name = 1; */ + if (message.demangled_name !== undefined) + writer.tag(1, WireType.LengthDelimited).string(message.demangled_name); + /* optional uint64 virtual_address = 2; */ + if (message.virtual_address !== undefined) + writer.tag(2, WireType.Varint).uint64(message.virtual_address); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)( + this.typeName, + message, + writer, + ); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.report.ReportItemMetadata + */ +export const ReportItemMetadata = new ReportItemMetadata$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ChangesInput$Type extends MessageType { + constructor() { + super('objdiff.report.ChangesInput', [ + { no: 1, name: 'from', kind: 'message', T: () => Report }, + { no: 2, name: 'to', kind: 'message', T: () => Report }, + ]); + } + create(value?: PartialMessage): ChangesInput { + const message = globalThis.Object.create(this.messagePrototype!); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead( + reader: IBinaryReader, + length: number, + options: BinaryReadOptions, + target?: ChangesInput, + ): ChangesInput { + let message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* objdiff.report.Report from */ 1: + message.from = Report.internalBinaryRead( + reader, + reader.uint32(), + options, + message.from, + ); + break; + case /* objdiff.report.Report to */ 2: + message.to = Report.internalBinaryRead( + reader, + reader.uint32(), + options, + message.to, + ); + break; + default: + let u = options.readUnknownField; + if (u === 'throw') + throw new globalThis.Error( + `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`, + ); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)( + this.typeName, + message, + fieldNo, + wireType, + d, + ); + } + } + return message; + } + internalBinaryWrite( + message: ChangesInput, + writer: IBinaryWriter, + options: BinaryWriteOptions, + ): IBinaryWriter { + /* objdiff.report.Report from = 1; */ + if (message.from) + Report.internalBinaryWrite( + message.from, + writer.tag(1, WireType.LengthDelimited).fork(), + options, + ).join(); + /* objdiff.report.Report to = 2; */ + if (message.to) + Report.internalBinaryWrite( + message.to, + writer.tag(2, WireType.LengthDelimited).fork(), + options, + ).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)( + this.typeName, + message, + writer, + ); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.report.ChangesInput + */ +export const ChangesInput = new ChangesInput$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class Changes$Type extends MessageType { + constructor() { + super('objdiff.report.Changes', [ + { no: 1, name: 'from', kind: 'message', T: () => Measures }, + { no: 2, name: 'to', kind: 'message', T: () => Measures }, + { + no: 3, + name: 'units', + kind: 'message', + repeat: 1 /*RepeatType.PACKED*/, + T: () => ChangeUnit, + }, + ]); + } + create(value?: PartialMessage): Changes { + const message = globalThis.Object.create(this.messagePrototype!); + message.units = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead( + reader: IBinaryReader, + length: number, + options: BinaryReadOptions, + target?: Changes, + ): Changes { + let message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* objdiff.report.Measures from */ 1: + message.from = Measures.internalBinaryRead( + reader, + reader.uint32(), + options, + message.from, + ); + break; + case /* objdiff.report.Measures to */ 2: + message.to = Measures.internalBinaryRead( + reader, + reader.uint32(), + options, + message.to, + ); + break; + case /* repeated objdiff.report.ChangeUnit units */ 3: + message.units.push( + ChangeUnit.internalBinaryRead(reader, reader.uint32(), options), + ); + break; + default: + let u = options.readUnknownField; + if (u === 'throw') + throw new globalThis.Error( + `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`, + ); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)( + this.typeName, + message, + fieldNo, + wireType, + d, + ); + } + } + return message; + } + internalBinaryWrite( + message: Changes, + writer: IBinaryWriter, + options: BinaryWriteOptions, + ): IBinaryWriter { + /* objdiff.report.Measures from = 1; */ + if (message.from) + Measures.internalBinaryWrite( + message.from, + writer.tag(1, WireType.LengthDelimited).fork(), + options, + ).join(); + /* objdiff.report.Measures to = 2; */ + if (message.to) + Measures.internalBinaryWrite( + message.to, + writer.tag(2, WireType.LengthDelimited).fork(), + options, + ).join(); + /* repeated objdiff.report.ChangeUnit units = 3; */ + for (let i = 0; i < message.units.length; i++) + ChangeUnit.internalBinaryWrite( + message.units[i], + writer.tag(3, WireType.LengthDelimited).fork(), + options, + ).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)( + this.typeName, + message, + writer, + ); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.report.Changes + */ +export const Changes = new Changes$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ChangeUnit$Type extends MessageType { + constructor() { + super('objdiff.report.ChangeUnit', [ + { no: 1, name: 'name', kind: 'scalar', T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: 'from', kind: 'message', T: () => Measures }, + { no: 3, name: 'to', kind: 'message', T: () => Measures }, + { + no: 4, + name: 'sections', + kind: 'message', + repeat: 1 /*RepeatType.PACKED*/, + T: () => ChangeItem, + }, + { + no: 5, + name: 'functions', + kind: 'message', + repeat: 1 /*RepeatType.PACKED*/, + T: () => ChangeItem, + }, + { no: 6, name: 'metadata', kind: 'message', T: () => ReportUnitMetadata }, + ]); + } + create(value?: PartialMessage): ChangeUnit { + const message = globalThis.Object.create(this.messagePrototype!); + message.name = ''; + message.sections = []; + message.functions = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead( + reader: IBinaryReader, + length: number, + options: BinaryReadOptions, + target?: ChangeUnit, + ): ChangeUnit { + let message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string name */ 1: + message.name = reader.string(); + break; + case /* optional objdiff.report.Measures from */ 2: + message.from = Measures.internalBinaryRead( + reader, + reader.uint32(), + options, + message.from, + ); + break; + case /* optional objdiff.report.Measures to */ 3: + message.to = Measures.internalBinaryRead( + reader, + reader.uint32(), + options, + message.to, + ); + break; + case /* repeated objdiff.report.ChangeItem sections */ 4: + message.sections.push( + ChangeItem.internalBinaryRead(reader, reader.uint32(), options), + ); + break; + case /* repeated objdiff.report.ChangeItem functions */ 5: + message.functions.push( + ChangeItem.internalBinaryRead(reader, reader.uint32(), options), + ); + break; + case /* optional objdiff.report.ReportUnitMetadata metadata */ 6: + message.metadata = ReportUnitMetadata.internalBinaryRead( + reader, + reader.uint32(), + options, + message.metadata, + ); + break; + default: + let u = options.readUnknownField; + if (u === 'throw') + throw new globalThis.Error( + `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`, + ); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)( + this.typeName, + message, + fieldNo, + wireType, + d, + ); + } + } + return message; + } + internalBinaryWrite( + message: ChangeUnit, + writer: IBinaryWriter, + options: BinaryWriteOptions, + ): IBinaryWriter { + /* string name = 1; */ + if (message.name !== '') + writer.tag(1, WireType.LengthDelimited).string(message.name); + /* optional objdiff.report.Measures from = 2; */ + if (message.from) + Measures.internalBinaryWrite( + message.from, + writer.tag(2, WireType.LengthDelimited).fork(), + options, + ).join(); + /* optional objdiff.report.Measures to = 3; */ + if (message.to) + Measures.internalBinaryWrite( + message.to, + writer.tag(3, WireType.LengthDelimited).fork(), + options, + ).join(); + /* repeated objdiff.report.ChangeItem sections = 4; */ + for (let i = 0; i < message.sections.length; i++) + ChangeItem.internalBinaryWrite( + message.sections[i], + writer.tag(4, WireType.LengthDelimited).fork(), + options, + ).join(); + /* repeated objdiff.report.ChangeItem functions = 5; */ + for (let i = 0; i < message.functions.length; i++) + ChangeItem.internalBinaryWrite( + message.functions[i], + writer.tag(5, WireType.LengthDelimited).fork(), + options, + ).join(); + /* optional objdiff.report.ReportUnitMetadata metadata = 6; */ + if (message.metadata) + ReportUnitMetadata.internalBinaryWrite( + message.metadata, + writer.tag(6, WireType.LengthDelimited).fork(), + options, + ).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)( + this.typeName, + message, + writer, + ); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.report.ChangeUnit + */ +export const ChangeUnit = new ChangeUnit$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ChangeItem$Type extends MessageType { + constructor() { + super('objdiff.report.ChangeItem', [ + { no: 1, name: 'name', kind: 'scalar', T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: 'from', kind: 'message', T: () => ChangeItemInfo }, + { no: 3, name: 'to', kind: 'message', T: () => ChangeItemInfo }, + { no: 4, name: 'metadata', kind: 'message', T: () => ReportItemMetadata }, + ]); + } + create(value?: PartialMessage): ChangeItem { + const message = globalThis.Object.create(this.messagePrototype!); + message.name = ''; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead( + reader: IBinaryReader, + length: number, + options: BinaryReadOptions, + target?: ChangeItem, + ): ChangeItem { + let message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string name */ 1: + message.name = reader.string(); + break; + case /* optional objdiff.report.ChangeItemInfo from */ 2: + message.from = ChangeItemInfo.internalBinaryRead( + reader, + reader.uint32(), + options, + message.from, + ); + break; + case /* optional objdiff.report.ChangeItemInfo to */ 3: + message.to = ChangeItemInfo.internalBinaryRead( + reader, + reader.uint32(), + options, + message.to, + ); + break; + case /* optional objdiff.report.ReportItemMetadata metadata */ 4: + message.metadata = ReportItemMetadata.internalBinaryRead( + reader, + reader.uint32(), + options, + message.metadata, + ); + break; + default: + let u = options.readUnknownField; + if (u === 'throw') + throw new globalThis.Error( + `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`, + ); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)( + this.typeName, + message, + fieldNo, + wireType, + d, + ); + } + } + return message; + } + internalBinaryWrite( + message: ChangeItem, + writer: IBinaryWriter, + options: BinaryWriteOptions, + ): IBinaryWriter { + /* string name = 1; */ + if (message.name !== '') + writer.tag(1, WireType.LengthDelimited).string(message.name); + /* optional objdiff.report.ChangeItemInfo from = 2; */ + if (message.from) + ChangeItemInfo.internalBinaryWrite( + message.from, + writer.tag(2, WireType.LengthDelimited).fork(), + options, + ).join(); + /* optional objdiff.report.ChangeItemInfo to = 3; */ + if (message.to) + ChangeItemInfo.internalBinaryWrite( + message.to, + writer.tag(3, WireType.LengthDelimited).fork(), + options, + ).join(); + /* optional objdiff.report.ReportItemMetadata metadata = 4; */ + if (message.metadata) + ReportItemMetadata.internalBinaryWrite( + message.metadata, + writer.tag(4, WireType.LengthDelimited).fork(), + options, + ).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)( + this.typeName, + message, + writer, + ); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.report.ChangeItem + */ +export const ChangeItem = new ChangeItem$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ChangeItemInfo$Type extends MessageType { + constructor() { + super('objdiff.report.ChangeItemInfo', [ + { + no: 1, + name: 'fuzzy_match_percent', + kind: 'scalar', + localName: 'fuzzy_match_percent', + T: 2 /*ScalarType.FLOAT*/, + }, + { + no: 2, + name: 'size', + kind: 'scalar', + T: 4 /*ScalarType.UINT64*/, + L: 0 /*LongType.BIGINT*/, + }, + ]); + } + create(value?: PartialMessage): ChangeItemInfo { + const message = globalThis.Object.create(this.messagePrototype!); + message.fuzzy_match_percent = 0; + message.size = 0n; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead( + reader: IBinaryReader, + length: number, + options: BinaryReadOptions, + target?: ChangeItemInfo, + ): ChangeItemInfo { + let message = target ?? this.create(), + end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* float fuzzy_match_percent */ 1: + message.fuzzy_match_percent = reader.float(); + break; + case /* uint64 size */ 2: + message.size = reader.uint64().toBigInt(); + break; + default: + let u = options.readUnknownField; + if (u === 'throw') + throw new globalThis.Error( + `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`, + ); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)( + this.typeName, + message, + fieldNo, + wireType, + d, + ); + } + } + return message; + } + internalBinaryWrite( + message: ChangeItemInfo, + writer: IBinaryWriter, + options: BinaryWriteOptions, + ): IBinaryWriter { + /* float fuzzy_match_percent = 1; */ + if (message.fuzzy_match_percent !== 0) + writer.tag(1, WireType.Bit32).float(message.fuzzy_match_percent); + /* uint64 size = 2; */ + if (message.size !== 0n) + writer.tag(2, WireType.Varint).uint64(message.size); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)( + this.typeName, + message, + writer, + ); + return writer; + } +} +/** + * @generated MessageType for protobuf message objdiff.report.ChangeItemInfo + */ +export const ChangeItemInfo = new ChangeItemInfo$Type(); diff --git a/media/icon.svg b/media/icon.svg new file mode 100644 index 0000000..d584c1a --- /dev/null +++ b/media/icon.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..2cf3f12 --- /dev/null +++ b/package-lock.json @@ -0,0 +1,3374 @@ +{ + "name": "objdiff-code", + "version": "0.0.1", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "objdiff-code", + "version": "0.0.1", + "dependencies": { + "@protobuf-ts/runtime": "^2.9.4", + "clsx": "^2.1.1", + "memoize-one": "^6.0.0", + "picomatch": "^4.0.2", + "react": "^18.3.1", + "react-dom": "^18.3.1", + "react-virtualized-auto-sizer": "^1.0.24", + "react-window": "^1.8.10", + "zustand": "^5.0.2" + }, + "devDependencies": { + "@biomejs/biome": "^1.9.3", + "@rsbuild/core": "^1.1.8", + "@rsbuild/plugin-react": "^1.0.7", + "@rsbuild/plugin-type-check": "^1.1.0", + "@types/picomatch": "^3.0.1", + "@types/react": "^18.3.1", + "@types/react-dom": "^18.3.1", + "@types/react-window": "^1.8.8", + "@types/vscode": "^1.96.0", + "@types/vscode-webview": "^1.57.5", + "@vscode/test-cli": "^0.0.10", + "@vscode/test-electron": "^2.4.1", + "typescript": "^5.7.2" + }, + "engines": { + "vscode": "^1.96.0" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.26.2", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.26.2.tgz", + "integrity": "sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.25.9", + "js-tokens": "^4.0.0", + "picocolors": "^1.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz", + "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/runtime": { + "version": "7.26.0", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.26.0.tgz", + "integrity": "sha512-FDSOghenHTiToteC/QRlv2q3DhPZ/oOXTBoirfWNx1Cx3TMVcGWQtMMmQcSvb/JjpNeGzx8Pq/b4fKEJuWm1sw==", + "license": "MIT", + "dependencies": { + "regenerator-runtime": "^0.14.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@bcoe/v8-coverage": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz", + "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@biomejs/biome": { + "version": "1.9.4", + "resolved": "https://registry.npmjs.org/@biomejs/biome/-/biome-1.9.4.tgz", + "integrity": "sha512-1rkd7G70+o9KkTn5KLmDYXihGoTaIGO9PIIN2ZB7UJxFrWw04CZHPYiMRjYsaDvVV7hP1dYNRLxSANLaBFGpog==", + "dev": true, + "hasInstallScript": true, + "license": "MIT OR Apache-2.0", + "bin": { + "biome": "bin/biome" + }, + "engines": { + "node": ">=14.21.3" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/biome" + }, + "optionalDependencies": { + "@biomejs/cli-darwin-arm64": "1.9.4", + "@biomejs/cli-darwin-x64": "1.9.4", + "@biomejs/cli-linux-arm64": "1.9.4", + "@biomejs/cli-linux-arm64-musl": "1.9.4", + "@biomejs/cli-linux-x64": "1.9.4", + "@biomejs/cli-linux-x64-musl": "1.9.4", + "@biomejs/cli-win32-arm64": "1.9.4", + "@biomejs/cli-win32-x64": "1.9.4" + } + }, + "node_modules/@biomejs/cli-darwin-arm64": { + "version": "1.9.4", + "resolved": "https://registry.npmjs.org/@biomejs/cli-darwin-arm64/-/cli-darwin-arm64-1.9.4.tgz", + "integrity": "sha512-bFBsPWrNvkdKrNCYeAp+xo2HecOGPAy9WyNyB/jKnnedgzl4W4Hb9ZMzYNbf8dMCGmUdSavlYHiR01QaYR58cw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT OR Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=14.21.3" + } + }, + "node_modules/@biomejs/cli-darwin-x64": { + "version": "1.9.4", + "resolved": "https://registry.npmjs.org/@biomejs/cli-darwin-x64/-/cli-darwin-x64-1.9.4.tgz", + "integrity": "sha512-ngYBh/+bEedqkSevPVhLP4QfVPCpb+4BBe2p7Xs32dBgs7rh9nY2AIYUL6BgLw1JVXV8GlpKmb/hNiuIxfPfZg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT OR Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=14.21.3" + } + }, + "node_modules/@biomejs/cli-linux-arm64": { + "version": "1.9.4", + "resolved": "https://registry.npmjs.org/@biomejs/cli-linux-arm64/-/cli-linux-arm64-1.9.4.tgz", + "integrity": "sha512-fJIW0+LYujdjUgJJuwesP4EjIBl/N/TcOX3IvIHJQNsAqvV2CHIogsmA94BPG6jZATS4Hi+xv4SkBBQSt1N4/g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT OR Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=14.21.3" + } + }, + "node_modules/@biomejs/cli-linux-arm64-musl": { + "version": "1.9.4", + "resolved": "https://registry.npmjs.org/@biomejs/cli-linux-arm64-musl/-/cli-linux-arm64-musl-1.9.4.tgz", + "integrity": "sha512-v665Ct9WCRjGa8+kTr0CzApU0+XXtRgwmzIf1SeKSGAv+2scAlW6JR5PMFo6FzqqZ64Po79cKODKf3/AAmECqA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT OR Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=14.21.3" + } + }, + "node_modules/@biomejs/cli-linux-x64": { + "version": "1.9.4", + "resolved": "https://registry.npmjs.org/@biomejs/cli-linux-x64/-/cli-linux-x64-1.9.4.tgz", + "integrity": "sha512-lRCJv/Vi3Vlwmbd6K+oQ0KhLHMAysN8lXoCI7XeHlxaajk06u7G+UsFSO01NAs5iYuWKmVZjmiOzJ0OJmGsMwg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT OR Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=14.21.3" + } + }, + "node_modules/@biomejs/cli-linux-x64-musl": { + "version": "1.9.4", + "resolved": "https://registry.npmjs.org/@biomejs/cli-linux-x64-musl/-/cli-linux-x64-musl-1.9.4.tgz", + "integrity": "sha512-gEhi/jSBhZ2m6wjV530Yy8+fNqG8PAinM3oV7CyO+6c3CEh16Eizm21uHVsyVBEB6RIM8JHIl6AGYCv6Q6Q9Tg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT OR Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=14.21.3" + } + }, + "node_modules/@biomejs/cli-win32-arm64": { + "version": "1.9.4", + "resolved": "https://registry.npmjs.org/@biomejs/cli-win32-arm64/-/cli-win32-arm64-1.9.4.tgz", + "integrity": "sha512-tlbhLk+WXZmgwoIKwHIHEBZUwxml7bRJgk0X2sPyNR3S93cdRq6XulAZRQJ17FYGGzWne0fgrXBKpl7l4M87Hg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT OR Apache-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=14.21.3" + } + }, + "node_modules/@biomejs/cli-win32-x64": { + "version": "1.9.4", + "resolved": "https://registry.npmjs.org/@biomejs/cli-win32-x64/-/cli-win32-x64-1.9.4.tgz", + "integrity": "sha512-8Y5wMhVIPaWe6jw2H+KlEm4wP/f7EW3810ZLmDlrEEy5KvBsb9ECEfu/kMWD484ijfQ8+nIi0giMgu9g1UAuuA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT OR Apache-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=14.21.3" + } + }, + "node_modules/@isaacs/cliui": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", + "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", + "dev": true, + "license": "ISC", + "dependencies": { + "string-width": "^5.1.2", + "string-width-cjs": "npm:string-width@^4.2.0", + "strip-ansi": "^7.0.1", + "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", + "wrap-ansi": "^8.1.0", + "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@istanbuljs/schema": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz", + "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz", + "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.25", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", + "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@jsonjoy.com/base64": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/base64/-/base64-1.1.2.tgz", + "integrity": "sha512-q6XAnWQDIMA3+FTiOYajoYqySkO+JSat0ytXGSuRdq9uXE7o92gzuQwQM14xaCRlBLGq3v5miDGC4vkVTn54xA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" + } + }, + "node_modules/@jsonjoy.com/json-pack": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/json-pack/-/json-pack-1.1.1.tgz", + "integrity": "sha512-osjeBqMJ2lb/j/M8NCPjs1ylqWIcTRTycIhVB5pt6LgzgeRSb0YRZ7j9RfA8wIUrsr/medIuhVyonXRZWLyfdw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@jsonjoy.com/base64": "^1.1.1", + "@jsonjoy.com/util": "^1.1.2", + "hyperdyperid": "^1.2.0", + "thingies": "^1.20.0" + }, + "engines": { + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" + } + }, + "node_modules/@jsonjoy.com/util": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/util/-/util-1.5.0.tgz", + "integrity": "sha512-ojoNsrIuPI9g6o8UxhraZQSyF2ByJanAY4cTFbc8Mf2AXEF4aQRGY1dJxyJpuyav8r9FGflEt/Ff3u5Nt6YMPA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" + } + }, + "node_modules/@module-federation/runtime": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/@module-federation/runtime/-/runtime-0.5.1.tgz", + "integrity": "sha512-xgiMUWwGLWDrvZc9JibuEbXIbhXg6z2oUkemogSvQ4LKvrl/n0kbqP1Blk669mXzyWbqtSp6PpvNdwaE1aN5xQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@module-federation/sdk": "0.5.1" + } + }, + "node_modules/@module-federation/runtime-tools": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/@module-federation/runtime-tools/-/runtime-tools-0.5.1.tgz", + "integrity": "sha512-nfBedkoZ3/SWyO0hnmaxuz0R0iGPSikHZOAZ0N/dVSQaIzlffUo35B5nlC2wgWIc0JdMZfkwkjZRrnuuDIJbzg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@module-federation/runtime": "0.5.1", + "@module-federation/webpack-bundler-runtime": "0.5.1" + } + }, + "node_modules/@module-federation/sdk": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/@module-federation/sdk/-/sdk-0.5.1.tgz", + "integrity": "sha512-exvchtjNURJJkpqjQ3/opdbfeT2wPKvrbnGnyRkrwW5o3FH1LaST1tkiNviT6OXTexGaVc2DahbdniQHVtQ7pA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@module-federation/webpack-bundler-runtime": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/@module-federation/webpack-bundler-runtime/-/webpack-bundler-runtime-0.5.1.tgz", + "integrity": "sha512-mMhRFH0k2VjwHt3Jol9JkUsmI/4XlrAoBG3E0o7HoyoPYv1UFOWyqAflfANcUPgbYpvqmyLzDcO+3IT36LXnrA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@module-federation/runtime": "0.5.1", + "@module-federation/sdk": "0.5.1" + } + }, + "node_modules/@pkgjs/parseargs": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", + "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", + "dev": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">=14" + } + }, + "node_modules/@protobuf-ts/runtime": { + "version": "2.9.4", + "resolved": "https://registry.npmjs.org/@protobuf-ts/runtime/-/runtime-2.9.4.tgz", + "integrity": "sha512-vHRFWtJJB/SiogWDF0ypoKfRIZ41Kq+G9cEFj6Qm1eQaAhJ1LDFvgZ7Ja4tb3iLOQhz0PaoPnnOijF1qmEqTxg==", + "license": "(Apache-2.0 AND BSD-3-Clause)" + }, + "node_modules/@rsbuild/core": { + "version": "1.1.10", + "resolved": "https://registry.npmjs.org/@rsbuild/core/-/core-1.1.10.tgz", + "integrity": "sha512-G0aVnoMSIZ4PNcW07tKtsOSoID9M03EAnCThRmUWMj1RXDqhbGje6AFBwGun9uz63bdxYEbEp9C8wH7dGi8aYQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rspack/core": "~1.1.6", + "@rspack/lite-tapable": "~1.0.1", + "@swc/helpers": "^0.5.15", + "core-js": "~3.39.0" + }, + "bin": { + "rsbuild": "bin/rsbuild.js" + }, + "engines": { + "node": ">=16.7.0" + } + }, + "node_modules/@rsbuild/plugin-react": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@rsbuild/plugin-react/-/plugin-react-1.1.0.tgz", + "integrity": "sha512-uqdRoV2V91G1XIA14dAmxqYTlTDVf0ktpE7TgwG29oQ2j+DerF1kh29WPHK9HvGE34JTfaBrsme2Zmb6bGD0cw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rspack/plugin-react-refresh": "~1.0.0", + "react-refresh": "^0.16.0" + }, + "peerDependencies": { + "@rsbuild/core": "1.x" + } + }, + "node_modules/@rsbuild/plugin-type-check": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@rsbuild/plugin-type-check/-/plugin-type-check-1.1.0.tgz", + "integrity": "sha512-9W/TxibRe7L6i4JnsIDRJfkvypPZQqCLO/jrAp+Liv4SCo9BVmbk/Rmpj+hfo2gjyewobk0AVi4/YQ5wOP7GSQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "deepmerge": "^4.3.1", + "json5": "^2.2.3", + "reduce-configs": "^1.0.0", + "ts-checker-rspack-plugin": "^1.0.1" + }, + "peerDependencies": { + "@rsbuild/core": "1.x" + }, + "peerDependenciesMeta": { + "@rsbuild/core": { + "optional": true + } + } + }, + "node_modules/@rspack/binding": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@rspack/binding/-/binding-1.1.6.tgz", + "integrity": "sha512-vfeBEgGOYVwqj5cQjGyvdfrr/BEihAHlyIsobL98FZjTF0uig+bj2yJUH5Ib5F0BpIUKVG3Pw0IjlUBqcVpZsQ==", + "dev": true, + "license": "MIT", + "optionalDependencies": { + "@rspack/binding-darwin-arm64": "1.1.6", + "@rspack/binding-darwin-x64": "1.1.6", + "@rspack/binding-linux-arm64-gnu": "1.1.6", + "@rspack/binding-linux-arm64-musl": "1.1.6", + "@rspack/binding-linux-x64-gnu": "1.1.6", + "@rspack/binding-linux-x64-musl": "1.1.6", + "@rspack/binding-win32-arm64-msvc": "1.1.6", + "@rspack/binding-win32-ia32-msvc": "1.1.6", + "@rspack/binding-win32-x64-msvc": "1.1.6" + } + }, + "node_modules/@rspack/binding-darwin-arm64": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@rspack/binding-darwin-arm64/-/binding-darwin-arm64-1.1.6.tgz", + "integrity": "sha512-x9dxm2yyiMuL1FBwvWNNMs2/mEUJmRoSRgYb8pblR7HDaTRORrjBFCqhaYlGyAqtQaeUy7o2VAQlE0BavIiFYA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rspack/binding-darwin-x64": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@rspack/binding-darwin-x64/-/binding-darwin-x64-1.1.6.tgz", + "integrity": "sha512-o0seilveftGiDjy3VPxug20HmAgYyQbNEuagR3i93/t/PT/eWXHnik+C1jjwqcivZL1Zllqvy4tbZw393aROEQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rspack/binding-linux-arm64-gnu": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@rspack/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.1.6.tgz", + "integrity": "sha512-4atnoknJx/c3KaQElsMIxHMpPf2jcRRdWsH/SdqJIRSrkWWakMK9Yv4TFwH680I4HDTMf1XLboMVScHzW8e+Mg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rspack/binding-linux-arm64-musl": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@rspack/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.1.6.tgz", + "integrity": "sha512-7QMtwUtgFpt3/Y3/X18fSyN+kk4H8ZnZ8tDzQskVWc/j2AQYShZq56XQYqrhClzwujcCVAHauIQ2eiuJ2ASGag==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rspack/binding-linux-x64-gnu": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@rspack/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.1.6.tgz", + "integrity": "sha512-MTjDEfPn4TwHoqs5d5Fck06kmXiTHZctGIcRVfrpg0RK0r1NLEHN+oosavRZ9c9H70f34+NmcHk+/qvV4c8lWg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rspack/binding-linux-x64-musl": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@rspack/binding-linux-x64-musl/-/binding-linux-x64-musl-1.1.6.tgz", + "integrity": "sha512-LqDw7PTVr/4ZuGA0izgDQfamfr72USFHltR1Qhy2YVC3JmDmhG/pQi13LHcOLVaGH1xoeyCmEPNJpVizzDxSjg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rspack/binding-win32-arm64-msvc": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@rspack/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.1.6.tgz", + "integrity": "sha512-RHApLM93YN0WdHpS35u2cm7VCqZ8Yg3CrNRL16VJtyT9e6MBqeScoe4XIgIWKPm7edFyedYAjLX0wQOApwfjkg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rspack/binding-win32-ia32-msvc": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@rspack/binding-win32-ia32-msvc/-/binding-win32-ia32-msvc-1.1.6.tgz", + "integrity": "sha512-Y6lx4q0eJawRfMPBo/AclTJAPTZ325DSPFBQJB3TnWh9Z2X7P7pQcYc8PHDmfDuYRIdg5WRsQRvVxihSvF7v8w==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rspack/binding-win32-x64-msvc": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@rspack/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.1.6.tgz", + "integrity": "sha512-UuCsfhC/yNuU7xLASOxNXcmsXi2ZvBX14GkxvcdChw6q7IIGNYUKXo1zgR8C1PE/6qDSxmLxbRMS+71d0H3HQg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rspack/core": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/@rspack/core/-/core-1.1.6.tgz", + "integrity": "sha512-q0VLphOF5VW2FEG7Vbdq3Ke4I74FbELE/8xmKghSalFtULLZ44SoSz8lyotfMim9GXIRFhDokAaH8WICmPxG+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@module-federation/runtime-tools": "0.5.1", + "@rspack/binding": "1.1.6", + "@rspack/lite-tapable": "1.0.1", + "caniuse-lite": "^1.0.30001616" + }, + "engines": { + "node": ">=16.0.0" + }, + "peerDependencies": { + "@swc/helpers": ">=0.5.1" + }, + "peerDependenciesMeta": { + "@swc/helpers": { + "optional": true + } + } + }, + "node_modules/@rspack/lite-tapable": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@rspack/lite-tapable/-/lite-tapable-1.0.1.tgz", + "integrity": "sha512-VynGOEsVw2s8TAlLf/uESfrgfrq2+rcXB1muPJYBWbsm1Oa6r5qVQhjA5ggM6z/coYPrsVMgovl3Ff7Q7OCp1w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=16.0.0" + } + }, + "node_modules/@rspack/plugin-react-refresh": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@rspack/plugin-react-refresh/-/plugin-react-refresh-1.0.1.tgz", + "integrity": "sha512-KSBc3bsr3mrAPViv7w9MpE9KEWm6q87EyRXyHlRfJ9PpQ56NbX9KZ7AXo7jPeECb0q5sfpM2PSEf+syBiMgLSw==", + "dev": true, + "license": "MIT", + "dependencies": { + "error-stack-parser": "^2.1.4", + "html-entities": "^2.5.2" + }, + "peerDependencies": { + "react-refresh": ">=0.10.0 <1.0.0" + }, + "peerDependenciesMeta": { + "react-refresh": { + "optional": true + } + } + }, + "node_modules/@swc/helpers": { + "version": "0.5.15", + "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.15.tgz", + "integrity": "sha512-JQ5TuMi45Owi4/BIMAJBoSQoOJu12oOk/gADqlcUL9JEdHB8vyjUSsxqeNXnmXHjYKMi2WcYtezGEEhqUI/E2g==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "tslib": "^2.8.0" + } + }, + "node_modules/@types/istanbul-lib-coverage": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz", + "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/mocha": { + "version": "10.0.10", + "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-10.0.10.tgz", + "integrity": "sha512-xPyYSz1cMPnJQhl0CLMH68j3gprKZaTjG3s5Vi+fDgx+uhG9NOXwbVt52eFS8ECyXhyKcjDLCBEqBExKuiZb7Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/picomatch": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/@types/picomatch/-/picomatch-3.0.1.tgz", + "integrity": "sha512-1MRgzpzY0hOp9pW/kLRxeQhUWwil6gnrUYd3oEpeYBqp/FexhaCPv3F8LsYr47gtUU45fO2cm1dbwkSrHEo8Uw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/prop-types": { + "version": "15.7.14", + "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.14.tgz", + "integrity": "sha512-gNMvNH49DJ7OJYv+KAKn0Xp45p8PLl6zo2YnvDIbTd4J6MER2BmWN49TG7n9LvkyihINxeKW8+3bfS2yDC9dzQ==", + "devOptional": true, + "license": "MIT" + }, + "node_modules/@types/react": { + "version": "18.3.16", + "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.16.tgz", + "integrity": "sha512-oh8AMIC4Y2ciKufU8hnKgs+ufgbA/dhPTACaZPM86AbwX9QwnFtSoPWEeRUj8fge+v6kFt78BXcDhAU1SrrAsw==", + "devOptional": true, + "license": "MIT", + "dependencies": { + "@types/prop-types": "*", + "csstype": "^3.0.2" + } + }, + "node_modules/@types/react-dom": { + "version": "18.3.5", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.5.tgz", + "integrity": "sha512-P4t6saawp+b/dFrUr2cvkVsfvPguwsxtH6dNIYRllMsefqFzkZk5UIjzyDOv5g1dXIPdG4Sp1yCR4Z6RCUsG/Q==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^18.0.0" + } + }, + "node_modules/@types/react-window": { + "version": "1.8.8", + "resolved": "https://registry.npmjs.org/@types/react-window/-/react-window-1.8.8.tgz", + "integrity": "sha512-8Ls660bHR1AUA2kuRvVG9D/4XpRC6wjAaPT9dil7Ckc76eP9TKWZwwmgfq8Q1LANX3QNDnoU4Zp48A3w+zK69Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/react": "*" + } + }, + "node_modules/@types/vscode": { + "version": "1.96.0", + "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.96.0.tgz", + "integrity": "sha512-qvZbSZo+K4ZYmmDuaodMbAa67Pl6VDQzLKFka6rq+3WUTY4Kro7Bwoi0CuZLO/wema0ygcmpwow7zZfPJTs5jg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/vscode-webview": { + "version": "1.57.5", + "resolved": "https://registry.npmjs.org/@types/vscode-webview/-/vscode-webview-1.57.5.tgz", + "integrity": "sha512-iBAUYNYkz+uk1kdsq05fEcoh8gJmwT3lqqFPN7MGyjQ3HVloViMdo7ZJ8DFIP8WOK74PjOEilosqAyxV2iUFUw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@vscode/test-cli": { + "version": "0.0.10", + "resolved": "https://registry.npmjs.org/@vscode/test-cli/-/test-cli-0.0.10.tgz", + "integrity": "sha512-B0mMH4ia+MOOtwNiLi79XhA+MLmUItIC8FckEuKrVAVriIuSWjt7vv4+bF8qVFiNFe4QRfzPaIZk39FZGWEwHA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mocha": "^10.0.2", + "c8": "^9.1.0", + "chokidar": "^3.5.3", + "enhanced-resolve": "^5.15.0", + "glob": "^10.3.10", + "minimatch": "^9.0.3", + "mocha": "^10.2.0", + "supports-color": "^9.4.0", + "yargs": "^17.7.2" + }, + "bin": { + "vscode-test": "out/bin.mjs" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@vscode/test-cli/node_modules/minimatch": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", + "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/@vscode/test-electron": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/@vscode/test-electron/-/test-electron-2.4.1.tgz", + "integrity": "sha512-Gc6EdaLANdktQ1t+zozoBVRynfIsMKMc94Svu1QreOBC8y76x4tvaK32TljrLi1LI2+PK58sDVbL7ALdqf3VRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "http-proxy-agent": "^7.0.2", + "https-proxy-agent": "^7.0.5", + "jszip": "^3.10.1", + "ora": "^7.0.1", + "semver": "^7.6.2" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/agent-base": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.3.tgz", + "integrity": "sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14" + } + }, + "node_modules/ansi-colors": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz", + "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/ansi-regex": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", + "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dev": true, + "license": "ISC", + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/anymatch/node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, + "license": "Python-2.0" + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/binary-extensions": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz", + "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/bl": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/bl/-/bl-5.1.0.tgz", + "integrity": "sha512-tv1ZJHLfTDnXE6tMHv73YgSJaWR2AFuPwMntBe7XL/GBFHnT0CLnsHMogfk5+GzCDC5ZWarSCYaIGATZt9dNsQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "buffer": "^6.0.3", + "inherits": "^2.0.4", + "readable-stream": "^3.4.0" + } + }, + "node_modules/bl/node_modules/readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "dev": true, + "license": "MIT", + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/braces": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "fill-range": "^7.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browser-stdout": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz", + "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==", + "dev": true, + "license": "ISC" + }, + "node_modules/buffer": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz", + "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" + } + }, + "node_modules/c8": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/c8/-/c8-9.1.0.tgz", + "integrity": "sha512-mBWcT5iqNir1zIkzSPyI3NCR9EZCVI3WUD+AVO17MVWTSFNyUueXE82qTeampNtTr+ilN/5Ua3j24LgbCKjDVg==", + "dev": true, + "license": "ISC", + "dependencies": { + "@bcoe/v8-coverage": "^0.2.3", + "@istanbuljs/schema": "^0.1.3", + "find-up": "^5.0.0", + "foreground-child": "^3.1.1", + "istanbul-lib-coverage": "^3.2.0", + "istanbul-lib-report": "^3.0.1", + "istanbul-reports": "^3.1.6", + "test-exclude": "^6.0.0", + "v8-to-istanbul": "^9.0.0", + "yargs": "^17.7.2", + "yargs-parser": "^21.1.1" + }, + "bin": { + "c8": "bin/c8.js" + }, + "engines": { + "node": ">=14.14.0" + } + }, + "node_modules/camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001688", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001688.tgz", + "integrity": "sha512-Nmqpru91cuABu/DTCXbM2NSRHzM2uVHfPnhJ/1zEAJx/ILBRVmz3pzH4N7DZqbdG0gWClsCC05Oj0mJ/1AWMbA==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/chalk/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/chokidar": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz", + "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.2", + "glob-parent": "~5.1.2", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.6.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/cli-cursor": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-4.0.0.tgz", + "integrity": "sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg==", + "dev": true, + "license": "MIT", + "dependencies": { + "restore-cursor": "^4.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cli-spinners": { + "version": "2.9.2", + "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.9.2.tgz", + "integrity": "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cliui": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", + "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.1", + "wrap-ansi": "^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/cliui/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/cliui/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true, + "license": "MIT" + }, + "node_modules/cliui/node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/cliui/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/cliui/node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/clsx": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz", + "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true, + "license": "MIT" + }, + "node_modules/core-js": { + "version": "3.39.0", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.39.0.tgz", + "integrity": "sha512-raM0ew0/jJUqkJ0E6e8UDtl+y/7ktFivgWvqw8dNSQeNWoSDLvQ1H/RN3aPXB9tBd4/FhyR4RDPGhsNIMsAn7g==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/core-js" + } + }, + "node_modules/core-util-is": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz", + "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/csstype": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz", + "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==", + "devOptional": true, + "license": "MIT" + }, + "node_modules/debug": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz", + "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decamelize": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz", + "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/deepmerge": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz", + "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/diff": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.0.tgz", + "integrity": "sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/eastasianwidth": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", + "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==", + "dev": true, + "license": "MIT" + }, + "node_modules/emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==", + "dev": true, + "license": "MIT" + }, + "node_modules/enhanced-resolve": { + "version": "5.17.1", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.17.1.tgz", + "integrity": "sha512-LMHl3dXhTcfv8gM4kEzIUeTQ+7fpdA0l2tUf34BddXPkz2A5xJ5L/Pchd5BL6rdccM9QGvu0sWZzK1Z1t4wwyg==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.4", + "tapable": "^2.2.0" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/error-stack-parser": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/error-stack-parser/-/error-stack-parser-2.1.4.tgz", + "integrity": "sha512-Sk5V6wVazPhq5MhpO+AUxJn5x7XSXGl1R93Vn7i+zS15KDVxQijejNCrz8340/2bgLBjR9GtEG8ZVKONDjcqGQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "stackframe": "^1.3.4" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/fill-range": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "dev": true, + "license": "MIT", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", + "dev": true, + "license": "BSD-3-Clause", + "bin": { + "flat": "cli.js" + } + }, + "node_modules/foreground-child": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.0.tgz", + "integrity": "sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg==", + "dev": true, + "license": "ISC", + "dependencies": { + "cross-spawn": "^7.0.0", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true, + "license": "ISC" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true, + "license": "ISC", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/glob": { + "version": "10.4.5", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz", + "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==", + "dev": true, + "license": "ISC", + "dependencies": { + "foreground-child": "^3.1.0", + "jackspeak": "^3.1.2", + "minimatch": "^9.0.4", + "minipass": "^7.1.2", + "package-json-from-dist": "^1.0.0", + "path-scurry": "^1.11.1" + }, + "bin": { + "glob": "dist/esm/bin.mjs" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/glob/node_modules/minimatch": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", + "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/he": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", + "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", + "dev": true, + "license": "MIT", + "bin": { + "he": "bin/he" + } + }, + "node_modules/html-entities": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/html-entities/-/html-entities-2.5.2.tgz", + "integrity": "sha512-K//PSRMQk4FZ78Kyau+mZurHn3FH0Vwr+H36eE0rPbeYkRRi9YxceYPhuN60UwWorxyKHhqoAJl2OFKa4BVtaA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/mdevils" + }, + { + "type": "patreon", + "url": "https://patreon.com/mdevils" + } + ], + "license": "MIT" + }, + "node_modules/html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", + "dev": true, + "license": "MIT" + }, + "node_modules/http-proxy-agent": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz", + "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==", + "dev": true, + "license": "MIT", + "dependencies": { + "agent-base": "^7.1.0", + "debug": "^4.3.4" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/https-proxy-agent": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz", + "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==", + "dev": true, + "license": "MIT", + "dependencies": { + "agent-base": "^7.1.2", + "debug": "4" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/hyperdyperid": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/hyperdyperid/-/hyperdyperid-1.2.0.tgz", + "integrity": "sha512-Y93lCzHYgGWdrJ66yIktxiaGULYc6oGiABxhcO5AufBeOyoIdZF7bIfLaOrbM0iGIOXQQgxxRrFEnb+Y6w1n4A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.18" + } + }, + "node_modules/ieee754": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "BSD-3-Clause" + }, + "node_modules/immediate": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/immediate/-/immediate-3.0.6.tgz", + "integrity": "sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.", + "dev": true, + "license": "ISC", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dev": true, + "license": "MIT", + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-interactive": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-2.0.0.tgz", + "integrity": "sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-unicode-supported": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz", + "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/istanbul-lib-coverage": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz", + "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-report": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz", + "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "istanbul-lib-coverage": "^3.0.0", + "make-dir": "^4.0.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/istanbul-lib-report/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-reports": { + "version": "3.1.7", + "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.7.tgz", + "integrity": "sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "html-escaper": "^2.0.0", + "istanbul-lib-report": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jackspeak": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz", + "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "@isaacs/cliui": "^8.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + }, + "optionalDependencies": { + "@pkgjs/parseargs": "^0.11.0" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/jszip": { + "version": "3.10.1", + "resolved": "https://registry.npmjs.org/jszip/-/jszip-3.10.1.tgz", + "integrity": "sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==", + "dev": true, + "license": "(MIT OR GPL-3.0-or-later)", + "dependencies": { + "lie": "~3.3.0", + "pako": "~1.0.2", + "readable-stream": "~2.3.6", + "setimmediate": "^1.0.5" + } + }, + "node_modules/lie": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/lie/-/lie-3.3.0.tgz", + "integrity": "sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "immediate": "~3.0.5" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/log-symbols": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", + "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "^4.1.0", + "is-unicode-supported": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "license": "MIT", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/lru-cache": { + "version": "10.4.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz", + "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/make-dir": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz", + "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "^7.5.3" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/memfs": { + "version": "4.15.0", + "resolved": "https://registry.npmjs.org/memfs/-/memfs-4.15.0.tgz", + "integrity": "sha512-q9MmZXd2rRWHS6GU3WEm3HyiXZyyoA1DqdOhEq0lxPBmKb5S7IAOwX0RgUCwJfqjelDCySa5h8ujOy24LqsWcw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@jsonjoy.com/json-pack": "^1.0.3", + "@jsonjoy.com/util": "^1.3.0", + "tree-dump": "^1.0.1", + "tslib": "^2.0.0" + }, + "engines": { + "node": ">= 4.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + } + }, + "node_modules/memoize-one": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/memoize-one/-/memoize-one-6.0.0.tgz", + "integrity": "sha512-rkpe71W0N0c0Xz6QD0eJETuWAJGnJ9afsl1srmwPrI+yBCkge5EycXXbYRyvL29zZVUWQCY7InPRCv3GDXuZNw==", + "license": "MIT" + }, + "node_modules/mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/minipass": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz", + "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/mocha": { + "version": "10.8.2", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.8.2.tgz", + "integrity": "sha512-VZlYo/WE8t1tstuRmqgeyBgCbJc/lEdopaa+axcKzTBJ+UIdlAB9XnmvTCAH4pwR4ElNInaedhEBmZD8iCSVEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-colors": "^4.1.3", + "browser-stdout": "^1.3.1", + "chokidar": "^3.5.3", + "debug": "^4.3.5", + "diff": "^5.2.0", + "escape-string-regexp": "^4.0.0", + "find-up": "^5.0.0", + "glob": "^8.1.0", + "he": "^1.2.0", + "js-yaml": "^4.1.0", + "log-symbols": "^4.1.0", + "minimatch": "^5.1.6", + "ms": "^2.1.3", + "serialize-javascript": "^6.0.2", + "strip-json-comments": "^3.1.1", + "supports-color": "^8.1.1", + "workerpool": "^6.5.1", + "yargs": "^16.2.0", + "yargs-parser": "^20.2.9", + "yargs-unparser": "^2.0.0" + }, + "bin": { + "_mocha": "bin/_mocha", + "mocha": "bin/mocha.js" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/mocha/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/mocha/node_modules/cliui": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", + "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^7.0.0" + } + }, + "node_modules/mocha/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true, + "license": "MIT" + }, + "node_modules/mocha/node_modules/glob": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz", + "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==", + "deprecated": "Glob versions prior to v9 are no longer supported", + "dev": true, + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^5.0.1", + "once": "^1.3.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/mocha/node_modules/minimatch": { + "version": "5.1.6", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz", + "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/mocha/node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/mocha/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/mocha/node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/mocha/node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/mocha/node_modules/yargs": { + "version": "16.2.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", + "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", + "dev": true, + "license": "MIT", + "dependencies": { + "cliui": "^7.0.2", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.0", + "y18n": "^5.0.5", + "yargs-parser": "^20.2.2" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/mocha/node_modules/yargs-parser": { + "version": "20.2.9", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz", + "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dev": true, + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "mimic-fn": "^2.1.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ora": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/ora/-/ora-7.0.1.tgz", + "integrity": "sha512-0TUxTiFJWv+JnjWm4o9yvuskpEJLXTcng8MJuKd+SzAzp2o+OP3HWqNhB4OdJRt1Vsd9/mR0oyaEYlOnL7XIRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "^5.3.0", + "cli-cursor": "^4.0.0", + "cli-spinners": "^2.9.0", + "is-interactive": "^2.0.0", + "is-unicode-supported": "^1.3.0", + "log-symbols": "^5.1.0", + "stdin-discarder": "^0.1.0", + "string-width": "^6.1.0", + "strip-ansi": "^7.1.0" + }, + "engines": { + "node": ">=16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ora/node_modules/chalk": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz", + "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.17.0 || ^14.13 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/ora/node_modules/emoji-regex": { + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.4.0.tgz", + "integrity": "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==", + "dev": true, + "license": "MIT" + }, + "node_modules/ora/node_modules/is-unicode-supported": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-1.3.0.tgz", + "integrity": "sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ora/node_modules/log-symbols": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-5.1.0.tgz", + "integrity": "sha512-l0x2DvrW294C9uDCoQe1VSU4gf529FkSZ6leBl4TiqZH/e+0R7hSfHQBNut2mNygDgHwvYHfFLn6Oxb3VWj2rA==", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "^5.0.0", + "is-unicode-supported": "^1.1.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ora/node_modules/string-width": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-6.1.0.tgz", + "integrity": "sha512-k01swCJAgQmuADB0YIc+7TuatfNvTBVOoaUWJjTB9R4VJzR5vNWzf5t42ESVZFPS8xTySF7CAdV4t/aaIm3UnQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^10.2.1", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/package-json-from-dist": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz", + "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==", + "dev": true, + "license": "BlueOak-1.0.0" + }, + "node_modules/pako": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz", + "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==", + "dev": true, + "license": "(MIT AND Zlib)" + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-scurry": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz", + "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^10.2.0", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" + }, + "engines": { + "node": ">=16 || 14 >=14.18" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz", + "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/process-nextick-args": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", + "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", + "dev": true, + "license": "MIT" + }, + "node_modules/randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "safe-buffer": "^5.1.0" + } + }, + "node_modules/react": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz", + "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz", + "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0", + "scheduler": "^0.23.2" + }, + "peerDependencies": { + "react": "^18.3.1" + } + }, + "node_modules/react-refresh": { + "version": "0.16.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.16.0.tgz", + "integrity": "sha512-FPvF2XxTSikpJxcr+bHut2H4gJ17+18Uy20D5/F+SKzFap62R3cM5wH6b8WN3LyGSYeQilLEcJcR1fjBSI2S1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-virtualized-auto-sizer": { + "version": "1.0.24", + "resolved": "https://registry.npmjs.org/react-virtualized-auto-sizer/-/react-virtualized-auto-sizer-1.0.24.tgz", + "integrity": "sha512-3kCn7N9NEb3FlvJrSHWGQ4iVl+ydQObq2fHMn12i5wbtm74zHOPhz/i64OL3c1S1vi9i2GXtZqNqUJTQ+BnNfg==", + "license": "MIT", + "peerDependencies": { + "react": "^15.3.0 || ^16.0.0-alpha || ^17.0.0 || ^18.0.0", + "react-dom": "^15.3.0 || ^16.0.0-alpha || ^17.0.0 || ^18.0.0" + } + }, + "node_modules/react-window": { + "version": "1.8.10", + "resolved": "https://registry.npmjs.org/react-window/-/react-window-1.8.10.tgz", + "integrity": "sha512-Y0Cx+dnU6NLa5/EvoHukUD0BklJ8qITCtVEPY1C/nL8wwoZ0b5aEw8Ff1dOVHw7fCzMt55XfJDd8S8W8LCaUCg==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.0.0", + "memoize-one": ">=3.1.1 <6" + }, + "engines": { + "node": ">8.0.0" + }, + "peerDependencies": { + "react": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0", + "react-dom": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0" + } + }, + "node_modules/react-window/node_modules/memoize-one": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/memoize-one/-/memoize-one-5.2.1.tgz", + "integrity": "sha512-zYiwtZUcYyXKo/np96AGZAckk+FWWsUdJ3cHGGmld7+AhvcWmQyGCYUh1hc4Q/pkOhb65dQR/pqCyK0cOaHz4Q==", + "license": "MIT" + }, + "node_modules/readable-stream": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz", + "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==", + "dev": true, + "license": "MIT", + "dependencies": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, + "node_modules/readdirp/node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/reduce-configs": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/reduce-configs/-/reduce-configs-1.1.0.tgz", + "integrity": "sha512-DQxy6liNadHfrLahZR7lMdc227NYVaQZhY5FMsxLEjX8X0SCuH+ESHSLCoz2yDZFq1/CLMDOAHdsEHwOEXKtvg==", + "dev": true, + "license": "MIT" + }, + "node_modules/regenerator-runtime": { + "version": "0.14.1", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz", + "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==", + "license": "MIT" + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/restore-cursor": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-4.0.0.tgz", + "integrity": "sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg==", + "dev": true, + "license": "MIT", + "dependencies": { + "onetime": "^5.1.0", + "signal-exit": "^3.0.2" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/restore-cursor/node_modules/signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "dev": true, + "license": "MIT" + }, + "node_modules/scheduler": { + "version": "0.23.2", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz", + "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0" + } + }, + "node_modules/semver": { + "version": "7.6.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz", + "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/serialize-javascript": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz", + "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "randombytes": "^2.1.0" + } + }, + "node_modules/setimmediate": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz", + "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==", + "dev": true, + "license": "MIT" + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/stackframe": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/stackframe/-/stackframe-1.3.4.tgz", + "integrity": "sha512-oeVtt7eWQS+Na6F//S4kJ2K2VbRlS9D43mAlMyVpVWovy9o+jfgH8O9agzANzaiLjclA0oYzUXEM4PurhSUChw==", + "dev": true, + "license": "MIT" + }, + "node_modules/stdin-discarder": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/stdin-discarder/-/stdin-discarder-0.1.0.tgz", + "integrity": "sha512-xhV7w8S+bUwlPTb4bAOUQhv8/cSS5offJuX8GQGq32ONF0ZtDWKfkdomM3HMRA+LhX6um/FZ0COqlwsjD53LeQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "bl": "^5.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "dev": true, + "license": "MIT", + "dependencies": { + "safe-buffer": "~5.1.0" + } + }, + "node_modules/string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/string-width-cjs": { + "name": "string-width", + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width-cjs/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true, + "license": "MIT" + }, + "node_modules/string-width-cjs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", + "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/strip-ansi-cjs": { + "name": "strip-ansi", + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-9.4.0.tgz", + "integrity": "sha512-VL+lNrEoIXww1coLPOmiEmK/0sGigko5COxI09KzHc2VJXJsQ37UaQ+8quuxjDeA7+KnLGTWRyOXSLLR2Wb4jw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/tapable": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz", + "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/test-exclude": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz", + "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==", + "dev": true, + "license": "ISC", + "dependencies": { + "@istanbuljs/schema": "^0.1.2", + "glob": "^7.1.4", + "minimatch": "^3.0.4" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/test-exclude/node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/test-exclude/node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "deprecated": "Glob versions prior to v9 are no longer supported", + "dev": true, + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/test-exclude/node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/thingies": { + "version": "1.21.0", + "resolved": "https://registry.npmjs.org/thingies/-/thingies-1.21.0.tgz", + "integrity": "sha512-hsqsJsFMsV+aD4s3CWKk85ep/3I9XzYV/IXaSouJMYIoDlgyi11cBhsqYe9/geRfB0YIikBQg6raRaM+nIMP9g==", + "dev": true, + "license": "Unlicense", + "engines": { + "node": ">=10.18" + }, + "peerDependencies": { + "tslib": "^2" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/tree-dump": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/tree-dump/-/tree-dump-1.0.2.tgz", + "integrity": "sha512-dpev9ABuLWdEubk+cIaI9cHwRNNDjkBBLXTwI4UCUFdQ5xXKqNXoK4FEciw/vxf+NQ7Cb7sGUyeUtORvHIdRXQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" + } + }, + "node_modules/ts-checker-rspack-plugin": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/ts-checker-rspack-plugin/-/ts-checker-rspack-plugin-1.0.3.tgz", + "integrity": "sha512-K5BUrytoFju1Olu11T49vlYvDEGOguBF1CBCl4o2ARxDGPoJHHf7fBzLlK0YYkUqI5EFA5cMRUC6332M7hQBHw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.16.7", + "@rspack/lite-tapable": "^1.0.0", + "chokidar": "^3.5.3", + "memfs": "^4.14.0", + "minimatch": "^9.0.5", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=16.0.0" + }, + "peerDependencies": { + "@rspack/core": "^1.0.0", + "typescript": ">=3.8.0" + }, + "peerDependenciesMeta": { + "@rspack/core": { + "optional": true + } + } + }, + "node_modules/ts-checker-rspack-plugin/node_modules/minimatch": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", + "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "dev": true, + "license": "0BSD" + }, + "node_modules/typescript": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.2.tgz", + "integrity": "sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "dev": true, + "license": "MIT" + }, + "node_modules/v8-to-istanbul": { + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.3.0.tgz", + "integrity": "sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==", + "dev": true, + "license": "ISC", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.12", + "@types/istanbul-lib-coverage": "^2.0.1", + "convert-source-map": "^2.0.0" + }, + "engines": { + "node": ">=10.12.0" + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/workerpool": { + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.5.1.tgz", + "integrity": "sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/wrap-ansi": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", + "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^6.1.0", + "string-width": "^5.0.1", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs": { + "name": "wrap-ansi", + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true, + "license": "MIT" + }, + "node_modules/wrap-ansi-cjs/node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi/node_modules/ansi-styles": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", + "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs": { + "version": "17.7.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", + "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "cliui": "^8.0.1", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.3", + "y18n": "^5.0.5", + "yargs-parser": "^21.1.1" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/yargs-parser": { + "version": "21.1.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", + "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/yargs-unparser": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz", + "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==", + "dev": true, + "license": "MIT", + "dependencies": { + "camelcase": "^6.0.0", + "decamelize": "^4.0.0", + "flat": "^5.0.2", + "is-plain-obj": "^2.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/yargs/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true, + "license": "MIT" + }, + "node_modules/yargs/node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/yargs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zustand": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/zustand/-/zustand-5.0.2.tgz", + "integrity": "sha512-8qNdnJVJlHlrKXi50LDqqUNmUbuBjoKLrYQBnoChIbVph7vni+sY+YpvdjXG9YLd/Bxr6scMcR+rm5H3aSqPaw==", + "license": "MIT", + "engines": { + "node": ">=12.20.0" + }, + "peerDependencies": { + "@types/react": ">=18.0.0", + "immer": ">=9.0.6", + "react": ">=18.0.0", + "use-sync-external-store": ">=1.2.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "immer": { + "optional": true + }, + "react": { + "optional": true + }, + "use-sync-external-store": { + "optional": true + } + } + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..ab8630c --- /dev/null +++ b/package.json @@ -0,0 +1,92 @@ +{ + "name": "objdiff-code", + "displayName": "objdiff-code", + "description": "objdiff", + "version": "0.0.1", + "scripts": { + "build": "rsbuild build", + "watch": "rsbuild build --watch --mode development", + "check": "biome check --write", + "format": "biome format --write" + }, + "dependencies": { + "@protobuf-ts/runtime": "^2.9.4", + "clsx": "^2.1.1", + "memoize-one": "^6.0.0", + "picomatch": "^4.0.2", + "react": "^18.3.1", + "react-dom": "^18.3.1", + "react-virtualized-auto-sizer": "^1.0.24", + "react-window": "^1.8.10", + "zustand": "^5.0.2" + }, + "devDependencies": { + "@biomejs/biome": "^1.9.3", + "@rsbuild/core": "^1.1.8", + "@rsbuild/plugin-react": "^1.0.7", + "@rsbuild/plugin-type-check": "^1.1.0", + "@types/picomatch": "^3.0.1", + "@types/react": "^18.3.1", + "@types/react-dom": "^18.3.1", + "@types/react-window": "^1.8.8", + "@types/vscode": "^1.96.0", + "@types/vscode-webview": "^1.57.5", + "@vscode/test-cli": "^0.0.10", + "@vscode/test-electron": "^2.4.1", + "typescript": "^5.7.2" + }, + "main": "./dist/extension.js", + "engines": { + "vscode": "^1.96.0" + }, + "browserslist": ["chrome 128"], + "categories": ["Other"], + "activationEvents": ["*"], + "contributes": { + "commands": [ + { + "command": "objdiff.build", + "title": "objdiff: build" + } + ], + "configuration": { + "title": "objdiff", + "properties": { + "objdiff.binaryPath": { + "type": "string", + "description": "Path to the objdiff-cli binary", + "ignoreSync": true + } + } + }, + "viewsContainers": { + "panel": [ + { + "id": "objdiff", + "title": "objdiff", + "icon": "media/icon.svg" + } + ] + }, + "views": { + "objdiff": [ + { + "id": "objdiff", + "name": "objdiff", + "type": "webview" + } + ] + }, + "viewsWelcome": [ + { + "view": "objdiff", + "contents": "Loading..." + } + ], + "taskDefinitions": [ + { + "type": "objdiff" + } + ] + } +} diff --git a/rsbuild.config.ts b/rsbuild.config.ts new file mode 100644 index 0000000..593247c --- /dev/null +++ b/rsbuild.config.ts @@ -0,0 +1,77 @@ +import { defineConfig } from '@rsbuild/core'; +import { pluginReact } from '@rsbuild/plugin-react'; +import { pluginTypeCheck } from '@rsbuild/plugin-type-check'; + +export default defineConfig({ + // Disable HMR and live reload. Neither the extension nor the + // webview can communicate with the rsbuild dev server. + dev: { + hmr: false, + liveReload: false, + }, + environments: { + extension: { + source: { + entry: { + extension: './src/extension.ts', + }, + }, + output: { + target: 'node', + distPath: { + root: 'dist', + }, + externals: ['vscode'], + }, + }, + webview: { + source: { + entry: { + index: './webview/index.tsx', + }, + }, + output: { + target: 'web', + distPath: { + root: 'dist/webview', + }, + // VS Code webviews don't have easy access to resources, + // (especially if the extension is running on web) so we + // simply inline everything into the HTML. + inlineScripts: true, + inlineStyles: true, + legalComments: 'none', + }, + //