From 4f7df9ea79400e4f776acf3e38c2328f460fe92e Mon Sep 17 00:00:00 2001 From: Coder-soft Date: Sat, 7 Mar 2026 15:24:15 +0500 Subject: [PATCH 1/8] feat: add history command to track and display past copyright checks - Add history storage with save/load/clear functionality - Add new 'history' CLI command with -c/--clear and -l/--limit options - Integrate history saving into single and batch processing flows - Add licensingUrl extraction to AI summary with new schema field - Display Spotify link and licensing URL in verdict output - Improve MusicBrainz API error handling and response parsing - Enhance AI client rate limit detection with additional error types --- desktop-app/electron.vite.config.ts | 37 + desktop-app/out/main/index.js | 10316 ++++++++++++++++ desktop-app/out/preload/index.js | 25 + desktop-app/package-lock.json | 8142 ++++++++++++ desktop-app/package.json | 78 + desktop-app/postcss.config.js | 6 + desktop-app/public/icon.png | Bin 0 -> 12541 bytes desktop-app/src/main/index.ts | 153 + desktop-app/src/preload/index.ts | 25 + desktop-app/src/preload/types.d.ts | 23 + desktop-app/src/renderer/index.html | 12 + desktop-app/src/renderer/src/App.tsx | 100 + .../src/renderer/src/components/CheckView.tsx | 264 + .../src/renderer/src/components/HomePage.tsx | 51 + .../src/renderer/src/components/Sidebar.tsx | 66 + .../src/renderer/src/components/TitleBar.tsx | 35 + desktop-app/src/renderer/src/index.css | 37 + desktop-app/src/renderer/src/main.tsx | 10 + .../src/renderer/src/types-window.d.ts | 27 + desktop-app/src/renderer/src/types.ts | 62 + desktop-app/tailwind.config.js | 17 + desktop-app/tsconfig.json | 24 + desktop-app/tsconfig.node.json | 19 + icon.png | Bin 0 -> 25973 bytes package-lock.json | 1227 +- package.json | 3 +- src/agents/summary-agent.ts | 2 + src/index.ts | 85 +- src/services/musicbrainz.ts | 40 +- src/types/index.ts | 1 + src/utils/ai-client.ts | 53 +- src/utils/history.ts | 68 + tsconfig.json | 3 +- 33 files changed, 20955 insertions(+), 56 deletions(-) create mode 100644 desktop-app/electron.vite.config.ts create mode 100644 desktop-app/out/main/index.js create mode 100644 desktop-app/out/preload/index.js create mode 100644 desktop-app/package-lock.json create mode 100644 desktop-app/package.json create mode 100644 desktop-app/postcss.config.js create mode 100644 desktop-app/public/icon.png create mode 100644 desktop-app/src/main/index.ts create mode 100644 desktop-app/src/preload/index.ts create mode 100644 desktop-app/src/preload/types.d.ts create mode 100644 desktop-app/src/renderer/index.html create mode 100644 desktop-app/src/renderer/src/App.tsx create mode 100644 desktop-app/src/renderer/src/components/CheckView.tsx create mode 100644 desktop-app/src/renderer/src/components/HomePage.tsx create mode 100644 desktop-app/src/renderer/src/components/Sidebar.tsx create mode 100644 desktop-app/src/renderer/src/components/TitleBar.tsx create mode 100644 desktop-app/src/renderer/src/index.css create mode 100644 desktop-app/src/renderer/src/main.tsx create mode 100644 desktop-app/src/renderer/src/types-window.d.ts create mode 100644 desktop-app/src/renderer/src/types.ts create mode 100644 desktop-app/tailwind.config.js create mode 100644 desktop-app/tsconfig.json create mode 100644 desktop-app/tsconfig.node.json create mode 100644 icon.png create mode 100644 src/utils/history.ts diff --git a/desktop-app/electron.vite.config.ts b/desktop-app/electron.vite.config.ts new file mode 100644 index 0000000..eab3d61 --- /dev/null +++ b/desktop-app/electron.vite.config.ts @@ -0,0 +1,37 @@ +import { defineConfig } from 'electron-vite' +import { resolve } from 'path' +import react from '@vitejs/plugin-react' + +export default defineConfig({ + main: { + build: { + rollupOptions: { + input: { + index: resolve(__dirname, 'src/main/index.ts') + } + } + } + }, + preload: { + build: { + rollupOptions: { + input: { + index: resolve(__dirname, 'src/preload/index.ts') + } + } + } + }, + renderer: { + root: 'src/renderer', + build: { + rollupOptions: { + input: { + index: resolve(__dirname, 'src/renderer/index.html') + } + }, + outDir: '../../out/renderer' + }, + plugins: [react()], + publicDir: resolve(__dirname, 'public') + } +}) diff --git a/desktop-app/out/main/index.js b/desktop-app/out/main/index.js new file mode 100644 index 0000000..a2cbdc7 --- /dev/null +++ b/desktop-app/out/main/index.js @@ -0,0 +1,10316 @@ +"use strict"; +const electron = require("electron"); +const path$1 = require("path"); +const url = require("url"); +const process$1 = require("node:process"); +const path = require("node:path"); +const node_util = require("node:util"); +const fs = require("node:fs"); +const crypto = require("node:crypto"); +const assert = require("node:assert"); +const os = require("node:os"); +require("node:events"); +require("node:stream"); +const fs$1 = require("fs"); +const isObject = (value) => { + const type2 = typeof value; + return value !== null && (type2 === "object" || type2 === "function"); +}; +const disallowedKeys = /* @__PURE__ */ new Set([ + "__proto__", + "prototype", + "constructor" +]); +const digits = new Set("0123456789"); +function getPathSegments(path2) { + const parts = []; + let currentSegment = ""; + let currentPart = "start"; + let isIgnoring = false; + for (const character of path2) { + switch (character) { + case "\\": { + if (currentPart === "index") { + throw new Error("Invalid character in an index"); + } + if (currentPart === "indexEnd") { + throw new Error("Invalid character after an index"); + } + if (isIgnoring) { + currentSegment += character; + } + currentPart = "property"; + isIgnoring = !isIgnoring; + break; + } + case ".": { + if (currentPart === "index") { + throw new Error("Invalid character in an index"); + } + if (currentPart === "indexEnd") { + currentPart = "property"; + break; + } + if (isIgnoring) { + isIgnoring = false; + currentSegment += character; + break; + } + if (disallowedKeys.has(currentSegment)) { + return []; + } + parts.push(currentSegment); + currentSegment = ""; + currentPart = "property"; + break; + } + case "[": { + if (currentPart === "index") { + throw new Error("Invalid character in an index"); + } + if (currentPart === "indexEnd") { + currentPart = "index"; + break; + } + if (isIgnoring) { + isIgnoring = false; + currentSegment += character; + break; + } + if (currentPart === "property") { + if (disallowedKeys.has(currentSegment)) { + return []; + } + parts.push(currentSegment); + currentSegment = ""; + } + currentPart = "index"; + break; + } + case "]": { + if (currentPart === "index") { + parts.push(Number.parseInt(currentSegment, 10)); + currentSegment = ""; + currentPart = "indexEnd"; + break; + } + if (currentPart === "indexEnd") { + throw new Error("Invalid character after an index"); + } + } + default: { + if (currentPart === "index" && !digits.has(character)) { + throw new Error("Invalid character in an index"); + } + if (currentPart === "indexEnd") { + throw new Error("Invalid character after an index"); + } + if (currentPart === "start") { + currentPart = "property"; + } + if (isIgnoring) { + isIgnoring = false; + currentSegment += "\\"; + } + currentSegment += character; + } + } + } + if (isIgnoring) { + currentSegment += "\\"; + } + switch (currentPart) { + case "property": { + if (disallowedKeys.has(currentSegment)) { + return []; + } + parts.push(currentSegment); + break; + } + case "index": { + throw new Error("Index was not closed"); + } + case "start": { + parts.push(""); + break; + } + } + return parts; +} +function isStringIndex(object, key) { + if (typeof key !== "number" && Array.isArray(object)) { + const index = Number.parseInt(key, 10); + return Number.isInteger(index) && object[index] === object[key]; + } + return false; +} +function assertNotStringIndex(object, key) { + if (isStringIndex(object, key)) { + throw new Error("Cannot use string index"); + } +} +function getProperty(object, path2, value) { + if (!isObject(object) || typeof path2 !== "string") { + return value === void 0 ? object : value; + } + const pathArray = getPathSegments(path2); + if (pathArray.length === 0) { + return value; + } + for (let index = 0; index < pathArray.length; index++) { + const key = pathArray[index]; + if (isStringIndex(object, key)) { + object = index === pathArray.length - 1 ? void 0 : null; + } else { + object = object[key]; + } + if (object === void 0 || object === null) { + if (index !== pathArray.length - 1) { + return value; + } + break; + } + } + return object === void 0 ? value : object; +} +function setProperty(object, path2, value) { + if (!isObject(object) || typeof path2 !== "string") { + return object; + } + const root = object; + const pathArray = getPathSegments(path2); + for (let index = 0; index < pathArray.length; index++) { + const key = pathArray[index]; + assertNotStringIndex(object, key); + if (index === pathArray.length - 1) { + object[key] = value; + } else if (!isObject(object[key])) { + object[key] = typeof pathArray[index + 1] === "number" ? [] : {}; + } + object = object[key]; + } + return root; +} +function deleteProperty(object, path2) { + if (!isObject(object) || typeof path2 !== "string") { + return false; + } + const pathArray = getPathSegments(path2); + for (let index = 0; index < pathArray.length; index++) { + const key = pathArray[index]; + assertNotStringIndex(object, key); + if (index === pathArray.length - 1) { + delete object[key]; + return true; + } + object = object[key]; + if (!isObject(object)) { + return false; + } + } +} +function hasProperty(object, path2) { + if (!isObject(object) || typeof path2 !== "string") { + return false; + } + const pathArray = getPathSegments(path2); + if (pathArray.length === 0) { + return false; + } + for (const key of pathArray) { + if (!isObject(object) || !(key in object) || isStringIndex(object, key)) { + return false; + } + object = object[key]; + } + return true; +} +const homedir = os.homedir(); +const tmpdir = os.tmpdir(); +const { env } = process$1; +const macos = (name) => { + const library = path.join(homedir, "Library"); + return { + data: path.join(library, "Application Support", name), + config: path.join(library, "Preferences", name), + cache: path.join(library, "Caches", name), + log: path.join(library, "Logs", name), + temp: path.join(tmpdir, name) + }; +}; +const windows = (name) => { + const appData = env.APPDATA || path.join(homedir, "AppData", "Roaming"); + const localAppData = env.LOCALAPPDATA || path.join(homedir, "AppData", "Local"); + return { + // Data/config/cache/log are invented by me as Windows isn't opinionated about this + data: path.join(localAppData, name, "Data"), + config: path.join(appData, name, "Config"), + cache: path.join(localAppData, name, "Cache"), + log: path.join(localAppData, name, "Log"), + temp: path.join(tmpdir, name) + }; +}; +const linux = (name) => { + const username = path.basename(homedir); + return { + data: path.join(env.XDG_DATA_HOME || path.join(homedir, ".local", "share"), name), + config: path.join(env.XDG_CONFIG_HOME || path.join(homedir, ".config"), name), + cache: path.join(env.XDG_CACHE_HOME || path.join(homedir, ".cache"), name), + // https://wiki.debian.org/XDGBaseDirectorySpecification#state + log: path.join(env.XDG_STATE_HOME || path.join(homedir, ".local", "state"), name), + temp: path.join(tmpdir, username, name) + }; +}; +function envPaths(name, { suffix = "nodejs" } = {}) { + if (typeof name !== "string") { + throw new TypeError(`Expected a string, got ${typeof name}`); + } + if (suffix) { + name += `-${suffix}`; + } + if (process$1.platform === "darwin") { + return macos(name); + } + if (process$1.platform === "win32") { + return windows(name); + } + return linux(name); +} +const attemptifyAsync = (fn, options) => { + const { onError } = options; + return function attemptified(...args) { + return fn.apply(void 0, args).catch(onError); + }; +}; +const attemptifySync = (fn, options) => { + const { onError } = options; + return function attemptified(...args) { + try { + return fn.apply(void 0, args); + } catch (error2) { + return onError(error2); + } + }; +}; +const RETRY_INTERVAL = 250; +const retryifyAsync = (fn, options) => { + const { isRetriable } = options; + return function retryified(options2) { + const { timeout } = options2; + const interval = options2.interval ?? RETRY_INTERVAL; + const timestamp = Date.now() + timeout; + return function attempt(...args) { + return fn.apply(void 0, args).catch((error2) => { + if (!isRetriable(error2)) + throw error2; + if (Date.now() >= timestamp) + throw error2; + const delay = Math.round(interval * Math.random()); + if (delay > 0) { + const delayPromise = new Promise((resolve2) => setTimeout(resolve2, delay)); + return delayPromise.then(() => attempt.apply(void 0, args)); + } else { + return attempt.apply(void 0, args); + } + }); + }; + }; +}; +const retryifySync = (fn, options) => { + const { isRetriable } = options; + return function retryified(options2) { + const { timeout } = options2; + const timestamp = Date.now() + timeout; + return function attempt(...args) { + while (true) { + try { + return fn.apply(void 0, args); + } catch (error2) { + if (!isRetriable(error2)) + throw error2; + if (Date.now() >= timestamp) + throw error2; + continue; + } + } + }; + }; +}; +const Handlers = { + /* API */ + isChangeErrorOk: (error2) => { + if (!Handlers.isNodeError(error2)) + return false; + const { code: code2 } = error2; + if (code2 === "ENOSYS") + return true; + if (!IS_USER_ROOT && (code2 === "EINVAL" || code2 === "EPERM")) + return true; + return false; + }, + isNodeError: (error2) => { + return error2 instanceof Error; + }, + isRetriableError: (error2) => { + if (!Handlers.isNodeError(error2)) + return false; + const { code: code2 } = error2; + if (code2 === "EMFILE" || code2 === "ENFILE" || code2 === "EAGAIN" || code2 === "EBUSY" || code2 === "EACCESS" || code2 === "EACCES" || code2 === "EACCS" || code2 === "EPERM") + return true; + return false; + }, + onChangeError: (error2) => { + if (!Handlers.isNodeError(error2)) + throw error2; + if (Handlers.isChangeErrorOk(error2)) + return; + throw error2; + } +}; +const ATTEMPTIFY_CHANGE_ERROR_OPTIONS = { + onError: Handlers.onChangeError +}; +const ATTEMPTIFY_NOOP_OPTIONS = { + onError: () => void 0 +}; +const IS_USER_ROOT = process$1.getuid ? !process$1.getuid() : false; +const RETRYIFY_OPTIONS = { + isRetriable: Handlers.isRetriableError +}; +const FS = { + attempt: { + /* ASYNC */ + chmod: attemptifyAsync(node_util.promisify(fs.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS), + chown: attemptifyAsync(node_util.promisify(fs.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS), + close: attemptifyAsync(node_util.promisify(fs.close), ATTEMPTIFY_NOOP_OPTIONS), + fsync: attemptifyAsync(node_util.promisify(fs.fsync), ATTEMPTIFY_NOOP_OPTIONS), + mkdir: attemptifyAsync(node_util.promisify(fs.mkdir), ATTEMPTIFY_NOOP_OPTIONS), + realpath: attemptifyAsync(node_util.promisify(fs.realpath), ATTEMPTIFY_NOOP_OPTIONS), + stat: attemptifyAsync(node_util.promisify(fs.stat), ATTEMPTIFY_NOOP_OPTIONS), + unlink: attemptifyAsync(node_util.promisify(fs.unlink), ATTEMPTIFY_NOOP_OPTIONS), + /* SYNC */ + chmodSync: attemptifySync(fs.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS), + chownSync: attemptifySync(fs.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS), + closeSync: attemptifySync(fs.closeSync, ATTEMPTIFY_NOOP_OPTIONS), + existsSync: attemptifySync(fs.existsSync, ATTEMPTIFY_NOOP_OPTIONS), + fsyncSync: attemptifySync(fs.fsync, ATTEMPTIFY_NOOP_OPTIONS), + mkdirSync: attemptifySync(fs.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS), + realpathSync: attemptifySync(fs.realpathSync, ATTEMPTIFY_NOOP_OPTIONS), + statSync: attemptifySync(fs.statSync, ATTEMPTIFY_NOOP_OPTIONS), + unlinkSync: attemptifySync(fs.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS) + }, + retry: { + /* ASYNC */ + close: retryifyAsync(node_util.promisify(fs.close), RETRYIFY_OPTIONS), + fsync: retryifyAsync(node_util.promisify(fs.fsync), RETRYIFY_OPTIONS), + open: retryifyAsync(node_util.promisify(fs.open), RETRYIFY_OPTIONS), + readFile: retryifyAsync(node_util.promisify(fs.readFile), RETRYIFY_OPTIONS), + rename: retryifyAsync(node_util.promisify(fs.rename), RETRYIFY_OPTIONS), + stat: retryifyAsync(node_util.promisify(fs.stat), RETRYIFY_OPTIONS), + write: retryifyAsync(node_util.promisify(fs.write), RETRYIFY_OPTIONS), + writeFile: retryifyAsync(node_util.promisify(fs.writeFile), RETRYIFY_OPTIONS), + /* SYNC */ + closeSync: retryifySync(fs.closeSync, RETRYIFY_OPTIONS), + fsyncSync: retryifySync(fs.fsyncSync, RETRYIFY_OPTIONS), + openSync: retryifySync(fs.openSync, RETRYIFY_OPTIONS), + readFileSync: retryifySync(fs.readFileSync, RETRYIFY_OPTIONS), + renameSync: retryifySync(fs.renameSync, RETRYIFY_OPTIONS), + statSync: retryifySync(fs.statSync, RETRYIFY_OPTIONS), + writeSync: retryifySync(fs.writeSync, RETRYIFY_OPTIONS), + writeFileSync: retryifySync(fs.writeFileSync, RETRYIFY_OPTIONS) + } +}; +const DEFAULT_ENCODING = "utf8"; +const DEFAULT_FILE_MODE = 438; +const DEFAULT_FOLDER_MODE = 511; +const DEFAULT_WRITE_OPTIONS = {}; +const DEFAULT_USER_UID = process$1.geteuid ? process$1.geteuid() : -1; +const DEFAULT_USER_GID = process$1.getegid ? process$1.getegid() : -1; +const DEFAULT_TIMEOUT_SYNC = 1e3; +const IS_POSIX = !!process$1.getuid; +process$1.getuid ? !process$1.getuid() : false; +const LIMIT_BASENAME_LENGTH = 128; +const isException = (value) => { + return value instanceof Error && "code" in value; +}; +const isString = (value) => { + return typeof value === "string"; +}; +const isUndefined = (value) => { + return value === void 0; +}; +const IS_LINUX = process$1.platform === "linux"; +const IS_WINDOWS = process$1.platform === "win32"; +const Signals = ["SIGHUP", "SIGINT", "SIGTERM"]; +if (!IS_WINDOWS) { + Signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT"); +} +if (IS_LINUX) { + Signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT"); +} +class Interceptor { + /* CONSTRUCTOR */ + constructor() { + this.callbacks = /* @__PURE__ */ new Set(); + this.exited = false; + this.exit = (signal) => { + if (this.exited) + return; + this.exited = true; + for (const callback of this.callbacks) { + callback(); + } + if (signal) { + if (IS_WINDOWS && (signal !== "SIGINT" && signal !== "SIGTERM" && signal !== "SIGKILL")) { + process$1.kill(process$1.pid, "SIGTERM"); + } else { + process$1.kill(process$1.pid, signal); + } + } + }; + this.hook = () => { + process$1.once("exit", () => this.exit()); + for (const signal of Signals) { + try { + process$1.once(signal, () => this.exit(signal)); + } catch { + } + } + }; + this.register = (callback) => { + this.callbacks.add(callback); + return () => { + this.callbacks.delete(callback); + }; + }; + this.hook(); + } +} +const Interceptor$1 = new Interceptor(); +const whenExit = Interceptor$1.register; +const Temp = { + /* VARIABLES */ + store: {}, + // filePath => purge + /* API */ + create: (filePath) => { + const randomness = `000000${Math.floor(Math.random() * 16777215).toString(16)}`.slice(-6); + const timestamp = Date.now().toString().slice(-10); + const prefix = "tmp-"; + const suffix = `.${prefix}${timestamp}${randomness}`; + const tempPath = `${filePath}${suffix}`; + return tempPath; + }, + get: (filePath, creator, purge = true) => { + const tempPath = Temp.truncate(creator(filePath)); + if (tempPath in Temp.store) + return Temp.get(filePath, creator, purge); + Temp.store[tempPath] = purge; + const disposer = () => delete Temp.store[tempPath]; + return [tempPath, disposer]; + }, + purge: (filePath) => { + if (!Temp.store[filePath]) + return; + delete Temp.store[filePath]; + FS.attempt.unlink(filePath); + }, + purgeSync: (filePath) => { + if (!Temp.store[filePath]) + return; + delete Temp.store[filePath]; + FS.attempt.unlinkSync(filePath); + }, + purgeSyncAll: () => { + for (const filePath in Temp.store) { + Temp.purgeSync(filePath); + } + }, + truncate: (filePath) => { + const basename = path.basename(filePath); + if (basename.length <= LIMIT_BASENAME_LENGTH) + return filePath; + const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename); + if (!truncable) + return filePath; + const truncationLength = basename.length - LIMIT_BASENAME_LENGTH; + return `${filePath.slice(0, -basename.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`; + } +}; +whenExit(Temp.purgeSyncAll); +function writeFileSync(filePath, data, options = DEFAULT_WRITE_OPTIONS) { + if (isString(options)) + return writeFileSync(filePath, data, { encoding: options }); + const timeout = options.timeout ?? DEFAULT_TIMEOUT_SYNC; + const retryOptions = { timeout }; + let tempDisposer = null; + let tempPath = null; + let fd = null; + try { + const filePathReal = FS.attempt.realpathSync(filePath); + const filePathExists = !!filePathReal; + filePath = filePathReal || filePath; + [tempPath, tempDisposer] = Temp.get(filePath, options.tmpCreate || Temp.create, !(options.tmpPurge === false)); + const useStatChown = IS_POSIX && isUndefined(options.chown); + const useStatMode = isUndefined(options.mode); + if (filePathExists && (useStatChown || useStatMode)) { + const stats = FS.attempt.statSync(filePath); + if (stats) { + options = { ...options }; + if (useStatChown) { + options.chown = { uid: stats.uid, gid: stats.gid }; + } + if (useStatMode) { + options.mode = stats.mode; + } + } + } + if (!filePathExists) { + const parentPath = path.dirname(filePath); + FS.attempt.mkdirSync(parentPath, { + mode: DEFAULT_FOLDER_MODE, + recursive: true + }); + } + fd = FS.retry.openSync(retryOptions)(tempPath, "w", options.mode || DEFAULT_FILE_MODE); + if (options.tmpCreated) { + options.tmpCreated(tempPath); + } + if (isString(data)) { + FS.retry.writeSync(retryOptions)(fd, data, 0, options.encoding || DEFAULT_ENCODING); + } else if (!isUndefined(data)) { + FS.retry.writeSync(retryOptions)(fd, data, 0, data.length, 0); + } + if (options.fsync !== false) { + if (options.fsyncWait !== false) { + FS.retry.fsyncSync(retryOptions)(fd); + } else { + FS.attempt.fsync(fd); + } + } + FS.retry.closeSync(retryOptions)(fd); + fd = null; + if (options.chown && (options.chown.uid !== DEFAULT_USER_UID || options.chown.gid !== DEFAULT_USER_GID)) { + FS.attempt.chownSync(tempPath, options.chown.uid, options.chown.gid); + } + if (options.mode && options.mode !== DEFAULT_FILE_MODE) { + FS.attempt.chmodSync(tempPath, options.mode); + } + try { + FS.retry.renameSync(retryOptions)(tempPath, filePath); + } catch (error2) { + if (!isException(error2)) + throw error2; + if (error2.code !== "ENAMETOOLONG") + throw error2; + FS.retry.renameSync(retryOptions)(tempPath, Temp.truncate(filePath)); + } + tempDisposer(); + tempPath = null; + } finally { + if (fd) + FS.attempt.closeSync(fd); + if (tempPath) + Temp.purge(tempPath); + } +} +function getDefaultExportFromCjs(x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x; +} +var _2020 = { exports: {} }; +var core$3 = {}; +var validate = {}; +var boolSchema = {}; +var errors = {}; +var codegen = {}; +var code$1 = {}; +(function(exports$1) { + Object.defineProperty(exports$1, "__esModule", { value: true }); + exports$1.regexpCode = exports$1.getEsmExportName = exports$1.getProperty = exports$1.safeStringify = exports$1.stringify = exports$1.strConcat = exports$1.addCodeArg = exports$1.str = exports$1._ = exports$1.nil = exports$1._Code = exports$1.Name = exports$1.IDENTIFIER = exports$1._CodeOrName = void 0; + class _CodeOrName { + } + exports$1._CodeOrName = _CodeOrName; + exports$1.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i; + class Name extends _CodeOrName { + constructor(s) { + super(); + if (!exports$1.IDENTIFIER.test(s)) + throw new Error("CodeGen: name must be a valid identifier"); + this.str = s; + } + toString() { + return this.str; + } + emptyStr() { + return false; + } + get names() { + return { [this.str]: 1 }; + } + } + exports$1.Name = Name; + class _Code extends _CodeOrName { + constructor(code2) { + super(); + this._items = typeof code2 === "string" ? [code2] : code2; + } + toString() { + return this.str; + } + emptyStr() { + if (this._items.length > 1) + return false; + const item = this._items[0]; + return item === "" || item === '""'; + } + get str() { + var _a; + return (_a = this._str) !== null && _a !== void 0 ? _a : this._str = this._items.reduce((s, c) => `${s}${c}`, ""); + } + get names() { + var _a; + return (_a = this._names) !== null && _a !== void 0 ? _a : this._names = this._items.reduce((names2, c) => { + if (c instanceof Name) + names2[c.str] = (names2[c.str] || 0) + 1; + return names2; + }, {}); + } + } + exports$1._Code = _Code; + exports$1.nil = new _Code(""); + function _(strs, ...args) { + const code2 = [strs[0]]; + let i = 0; + while (i < args.length) { + addCodeArg(code2, args[i]); + code2.push(strs[++i]); + } + return new _Code(code2); + } + exports$1._ = _; + const plus = new _Code("+"); + function str(strs, ...args) { + const expr = [safeStringify(strs[0])]; + let i = 0; + while (i < args.length) { + expr.push(plus); + addCodeArg(expr, args[i]); + expr.push(plus, safeStringify(strs[++i])); + } + optimize(expr); + return new _Code(expr); + } + exports$1.str = str; + function addCodeArg(code2, arg) { + if (arg instanceof _Code) + code2.push(...arg._items); + else if (arg instanceof Name) + code2.push(arg); + else + code2.push(interpolate(arg)); + } + exports$1.addCodeArg = addCodeArg; + function optimize(expr) { + let i = 1; + while (i < expr.length - 1) { + if (expr[i] === plus) { + const res = mergeExprItems(expr[i - 1], expr[i + 1]); + if (res !== void 0) { + expr.splice(i - 1, 3, res); + continue; + } + expr[i++] = "+"; + } + i++; + } + } + function mergeExprItems(a, b) { + if (b === '""') + return a; + if (a === '""') + return b; + if (typeof a == "string") { + if (b instanceof Name || a[a.length - 1] !== '"') + return; + if (typeof b != "string") + return `${a.slice(0, -1)}${b}"`; + if (b[0] === '"') + return a.slice(0, -1) + b.slice(1); + return; + } + if (typeof b == "string" && b[0] === '"' && !(a instanceof Name)) + return `"${a}${b.slice(1)}`; + return; + } + function strConcat(c1, c2) { + return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`; + } + exports$1.strConcat = strConcat; + function interpolate(x) { + return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x); + } + function stringify(x) { + return new _Code(safeStringify(x)); + } + exports$1.stringify = stringify; + function safeStringify(x) { + return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029"); + } + exports$1.safeStringify = safeStringify; + function getProperty2(key) { + return typeof key == "string" && exports$1.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`; + } + exports$1.getProperty = getProperty2; + function getEsmExportName(key) { + if (typeof key == "string" && exports$1.IDENTIFIER.test(key)) { + return new _Code(`${key}`); + } + throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`); + } + exports$1.getEsmExportName = getEsmExportName; + function regexpCode(rx) { + return new _Code(rx.toString()); + } + exports$1.regexpCode = regexpCode; +})(code$1); +var scope = {}; +(function(exports$1) { + Object.defineProperty(exports$1, "__esModule", { value: true }); + exports$1.ValueScope = exports$1.ValueScopeName = exports$1.Scope = exports$1.varKinds = exports$1.UsedValueState = void 0; + const code_12 = code$1; + class ValueError extends Error { + constructor(name) { + super(`CodeGen: "code" for ${name} not defined`); + this.value = name.value; + } + } + var UsedValueState; + (function(UsedValueState2) { + UsedValueState2[UsedValueState2["Started"] = 0] = "Started"; + UsedValueState2[UsedValueState2["Completed"] = 1] = "Completed"; + })(UsedValueState || (exports$1.UsedValueState = UsedValueState = {})); + exports$1.varKinds = { + const: new code_12.Name("const"), + let: new code_12.Name("let"), + var: new code_12.Name("var") + }; + class Scope { + constructor({ prefixes, parent } = {}) { + this._names = {}; + this._prefixes = prefixes; + this._parent = parent; + } + toName(nameOrPrefix) { + return nameOrPrefix instanceof code_12.Name ? nameOrPrefix : this.name(nameOrPrefix); + } + name(prefix) { + return new code_12.Name(this._newName(prefix)); + } + _newName(prefix) { + const ng = this._names[prefix] || this._nameGroup(prefix); + return `${prefix}${ng.index++}`; + } + _nameGroup(prefix) { + var _a, _b; + if (((_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a._prefixes) === null || _b === void 0 ? void 0 : _b.has(prefix)) || this._prefixes && !this._prefixes.has(prefix)) { + throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`); + } + return this._names[prefix] = { prefix, index: 0 }; + } + } + exports$1.Scope = Scope; + class ValueScopeName extends code_12.Name { + constructor(prefix, nameStr) { + super(nameStr); + this.prefix = prefix; + } + setValue(value, { property, itemIndex }) { + this.value = value; + this.scopePath = (0, code_12._)`.${new code_12.Name(property)}[${itemIndex}]`; + } + } + exports$1.ValueScopeName = ValueScopeName; + const line = (0, code_12._)`\n`; + class ValueScope extends Scope { + constructor(opts) { + super(opts); + this._values = {}; + this._scope = opts.scope; + this.opts = { ...opts, _n: opts.lines ? line : code_12.nil }; + } + get() { + return this._scope; + } + name(prefix) { + return new ValueScopeName(prefix, this._newName(prefix)); + } + value(nameOrPrefix, value) { + var _a; + if (value.ref === void 0) + throw new Error("CodeGen: ref must be passed in value"); + const name = this.toName(nameOrPrefix); + const { prefix } = name; + const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref; + let vs = this._values[prefix]; + if (vs) { + const _name = vs.get(valueKey); + if (_name) + return _name; + } else { + vs = this._values[prefix] = /* @__PURE__ */ new Map(); + } + vs.set(valueKey, name); + const s = this._scope[prefix] || (this._scope[prefix] = []); + const itemIndex = s.length; + s[itemIndex] = value.ref; + name.setValue(value, { property: prefix, itemIndex }); + return name; + } + getValue(prefix, keyOrRef) { + const vs = this._values[prefix]; + if (!vs) + return; + return vs.get(keyOrRef); + } + scopeRefs(scopeName, values = this._values) { + return this._reduceValues(values, (name) => { + if (name.scopePath === void 0) + throw new Error(`CodeGen: name "${name}" has no value`); + return (0, code_12._)`${scopeName}${name.scopePath}`; + }); + } + scopeCode(values = this._values, usedValues, getCode) { + return this._reduceValues(values, (name) => { + if (name.value === void 0) + throw new Error(`CodeGen: name "${name}" has no value`); + return name.value.code; + }, usedValues, getCode); + } + _reduceValues(values, valueCode, usedValues = {}, getCode) { + let code2 = code_12.nil; + for (const prefix in values) { + const vs = values[prefix]; + if (!vs) + continue; + const nameSet = usedValues[prefix] = usedValues[prefix] || /* @__PURE__ */ new Map(); + vs.forEach((name) => { + if (nameSet.has(name)) + return; + nameSet.set(name, UsedValueState.Started); + let c = valueCode(name); + if (c) { + const def2 = this.opts.es5 ? exports$1.varKinds.var : exports$1.varKinds.const; + code2 = (0, code_12._)`${code2}${def2} ${name} = ${c};${this.opts._n}`; + } else if (c = getCode === null || getCode === void 0 ? void 0 : getCode(name)) { + code2 = (0, code_12._)`${code2}${c}${this.opts._n}`; + } else { + throw new ValueError(name); + } + nameSet.set(name, UsedValueState.Completed); + }); + } + return code2; + } + } + exports$1.ValueScope = ValueScope; +})(scope); +(function(exports$1) { + Object.defineProperty(exports$1, "__esModule", { value: true }); + exports$1.or = exports$1.and = exports$1.not = exports$1.CodeGen = exports$1.operators = exports$1.varKinds = exports$1.ValueScopeName = exports$1.ValueScope = exports$1.Scope = exports$1.Name = exports$1.regexpCode = exports$1.stringify = exports$1.getProperty = exports$1.nil = exports$1.strConcat = exports$1.str = exports$1._ = void 0; + const code_12 = code$1; + const scope_1 = scope; + var code_2 = code$1; + Object.defineProperty(exports$1, "_", { enumerable: true, get: function() { + return code_2._; + } }); + Object.defineProperty(exports$1, "str", { enumerable: true, get: function() { + return code_2.str; + } }); + Object.defineProperty(exports$1, "strConcat", { enumerable: true, get: function() { + return code_2.strConcat; + } }); + Object.defineProperty(exports$1, "nil", { enumerable: true, get: function() { + return code_2.nil; + } }); + Object.defineProperty(exports$1, "getProperty", { enumerable: true, get: function() { + return code_2.getProperty; + } }); + Object.defineProperty(exports$1, "stringify", { enumerable: true, get: function() { + return code_2.stringify; + } }); + Object.defineProperty(exports$1, "regexpCode", { enumerable: true, get: function() { + return code_2.regexpCode; + } }); + Object.defineProperty(exports$1, "Name", { enumerable: true, get: function() { + return code_2.Name; + } }); + var scope_2 = scope; + Object.defineProperty(exports$1, "Scope", { enumerable: true, get: function() { + return scope_2.Scope; + } }); + Object.defineProperty(exports$1, "ValueScope", { enumerable: true, get: function() { + return scope_2.ValueScope; + } }); + Object.defineProperty(exports$1, "ValueScopeName", { enumerable: true, get: function() { + return scope_2.ValueScopeName; + } }); + Object.defineProperty(exports$1, "varKinds", { enumerable: true, get: function() { + return scope_2.varKinds; + } }); + exports$1.operators = { + GT: new code_12._Code(">"), + GTE: new code_12._Code(">="), + LT: new code_12._Code("<"), + LTE: new code_12._Code("<="), + EQ: new code_12._Code("==="), + NEQ: new code_12._Code("!=="), + NOT: new code_12._Code("!"), + OR: new code_12._Code("||"), + AND: new code_12._Code("&&"), + ADD: new code_12._Code("+") + }; + class Node { + optimizeNodes() { + return this; + } + optimizeNames(_names, _constants) { + return this; + } + } + class Def extends Node { + constructor(varKind, name, rhs) { + super(); + this.varKind = varKind; + this.name = name; + this.rhs = rhs; + } + render({ es5, _n }) { + const varKind = es5 ? scope_1.varKinds.var : this.varKind; + const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`; + return `${varKind} ${this.name}${rhs};` + _n; + } + optimizeNames(names2, constants2) { + if (!names2[this.name.str]) + return; + if (this.rhs) + this.rhs = optimizeExpr(this.rhs, names2, constants2); + return this; + } + get names() { + return this.rhs instanceof code_12._CodeOrName ? this.rhs.names : {}; + } + } + class Assign extends Node { + constructor(lhs, rhs, sideEffects) { + super(); + this.lhs = lhs; + this.rhs = rhs; + this.sideEffects = sideEffects; + } + render({ _n }) { + return `${this.lhs} = ${this.rhs};` + _n; + } + optimizeNames(names2, constants2) { + if (this.lhs instanceof code_12.Name && !names2[this.lhs.str] && !this.sideEffects) + return; + this.rhs = optimizeExpr(this.rhs, names2, constants2); + return this; + } + get names() { + const names2 = this.lhs instanceof code_12.Name ? {} : { ...this.lhs.names }; + return addExprNames(names2, this.rhs); + } + } + class AssignOp extends Assign { + constructor(lhs, op, rhs, sideEffects) { + super(lhs, rhs, sideEffects); + this.op = op; + } + render({ _n }) { + return `${this.lhs} ${this.op}= ${this.rhs};` + _n; + } + } + class Label extends Node { + constructor(label) { + super(); + this.label = label; + this.names = {}; + } + render({ _n }) { + return `${this.label}:` + _n; + } + } + class Break extends Node { + constructor(label) { + super(); + this.label = label; + this.names = {}; + } + render({ _n }) { + const label = this.label ? ` ${this.label}` : ""; + return `break${label};` + _n; + } + } + class Throw extends Node { + constructor(error2) { + super(); + this.error = error2; + } + render({ _n }) { + return `throw ${this.error};` + _n; + } + get names() { + return this.error.names; + } + } + class AnyCode extends Node { + constructor(code2) { + super(); + this.code = code2; + } + render({ _n }) { + return `${this.code};` + _n; + } + optimizeNodes() { + return `${this.code}` ? this : void 0; + } + optimizeNames(names2, constants2) { + this.code = optimizeExpr(this.code, names2, constants2); + return this; + } + get names() { + return this.code instanceof code_12._CodeOrName ? this.code.names : {}; + } + } + class ParentNode extends Node { + constructor(nodes = []) { + super(); + this.nodes = nodes; + } + render(opts) { + return this.nodes.reduce((code2, n) => code2 + n.render(opts), ""); + } + optimizeNodes() { + const { nodes } = this; + let i = nodes.length; + while (i--) { + const n = nodes[i].optimizeNodes(); + if (Array.isArray(n)) + nodes.splice(i, 1, ...n); + else if (n) + nodes[i] = n; + else + nodes.splice(i, 1); + } + return nodes.length > 0 ? this : void 0; + } + optimizeNames(names2, constants2) { + const { nodes } = this; + let i = nodes.length; + while (i--) { + const n = nodes[i]; + if (n.optimizeNames(names2, constants2)) + continue; + subtractNames(names2, n.names); + nodes.splice(i, 1); + } + return nodes.length > 0 ? this : void 0; + } + get names() { + return this.nodes.reduce((names2, n) => addNames(names2, n.names), {}); + } + } + class BlockNode extends ParentNode { + render(opts) { + return "{" + opts._n + super.render(opts) + "}" + opts._n; + } + } + class Root extends ParentNode { + } + class Else extends BlockNode { + } + Else.kind = "else"; + class If extends BlockNode { + constructor(condition, nodes) { + super(nodes); + this.condition = condition; + } + render(opts) { + let code2 = `if(${this.condition})` + super.render(opts); + if (this.else) + code2 += "else " + this.else.render(opts); + return code2; + } + optimizeNodes() { + super.optimizeNodes(); + const cond = this.condition; + if (cond === true) + return this.nodes; + let e = this.else; + if (e) { + const ns = e.optimizeNodes(); + e = this.else = Array.isArray(ns) ? new Else(ns) : ns; + } + if (e) { + if (cond === false) + return e instanceof If ? e : e.nodes; + if (this.nodes.length) + return this; + return new If(not2(cond), e instanceof If ? [e] : e.nodes); + } + if (cond === false || !this.nodes.length) + return void 0; + return this; + } + optimizeNames(names2, constants2) { + var _a; + this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names2, constants2); + if (!(super.optimizeNames(names2, constants2) || this.else)) + return; + this.condition = optimizeExpr(this.condition, names2, constants2); + return this; + } + get names() { + const names2 = super.names; + addExprNames(names2, this.condition); + if (this.else) + addNames(names2, this.else.names); + return names2; + } + } + If.kind = "if"; + class For extends BlockNode { + } + For.kind = "for"; + class ForLoop extends For { + constructor(iteration) { + super(); + this.iteration = iteration; + } + render(opts) { + return `for(${this.iteration})` + super.render(opts); + } + optimizeNames(names2, constants2) { + if (!super.optimizeNames(names2, constants2)) + return; + this.iteration = optimizeExpr(this.iteration, names2, constants2); + return this; + } + get names() { + return addNames(super.names, this.iteration.names); + } + } + class ForRange extends For { + constructor(varKind, name, from, to) { + super(); + this.varKind = varKind; + this.name = name; + this.from = from; + this.to = to; + } + render(opts) { + const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind; + const { name, from, to } = this; + return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts); + } + get names() { + const names2 = addExprNames(super.names, this.from); + return addExprNames(names2, this.to); + } + } + class ForIter extends For { + constructor(loop, varKind, name, iterable) { + super(); + this.loop = loop; + this.varKind = varKind; + this.name = name; + this.iterable = iterable; + } + render(opts) { + return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts); + } + optimizeNames(names2, constants2) { + if (!super.optimizeNames(names2, constants2)) + return; + this.iterable = optimizeExpr(this.iterable, names2, constants2); + return this; + } + get names() { + return addNames(super.names, this.iterable.names); + } + } + class Func extends BlockNode { + constructor(name, args, async) { + super(); + this.name = name; + this.args = args; + this.async = async; + } + render(opts) { + const _async = this.async ? "async " : ""; + return `${_async}function ${this.name}(${this.args})` + super.render(opts); + } + } + Func.kind = "func"; + class Return extends ParentNode { + render(opts) { + return "return " + super.render(opts); + } + } + Return.kind = "return"; + class Try extends BlockNode { + render(opts) { + let code2 = "try" + super.render(opts); + if (this.catch) + code2 += this.catch.render(opts); + if (this.finally) + code2 += this.finally.render(opts); + return code2; + } + optimizeNodes() { + var _a, _b; + super.optimizeNodes(); + (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNodes(); + (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes(); + return this; + } + optimizeNames(names2, constants2) { + var _a, _b; + super.optimizeNames(names2, constants2); + (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names2, constants2); + (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names2, constants2); + return this; + } + get names() { + const names2 = super.names; + if (this.catch) + addNames(names2, this.catch.names); + if (this.finally) + addNames(names2, this.finally.names); + return names2; + } + } + class Catch extends BlockNode { + constructor(error2) { + super(); + this.error = error2; + } + render(opts) { + return `catch(${this.error})` + super.render(opts); + } + } + Catch.kind = "catch"; + class Finally extends BlockNode { + render(opts) { + return "finally" + super.render(opts); + } + } + Finally.kind = "finally"; + class CodeGen { + constructor(extScope, opts = {}) { + this._values = {}; + this._blockStarts = []; + this._constants = {}; + this.opts = { ...opts, _n: opts.lines ? "\n" : "" }; + this._extScope = extScope; + this._scope = new scope_1.Scope({ parent: extScope }); + this._nodes = [new Root()]; + } + toString() { + return this._root.render(this.opts); + } + // returns unique name in the internal scope + name(prefix) { + return this._scope.name(prefix); + } + // reserves unique name in the external scope + scopeName(prefix) { + return this._extScope.name(prefix); + } + // reserves unique name in the external scope and assigns value to it + scopeValue(prefixOrName, value) { + const name = this._extScope.value(prefixOrName, value); + const vs = this._values[name.prefix] || (this._values[name.prefix] = /* @__PURE__ */ new Set()); + vs.add(name); + return name; + } + getScopeValue(prefix, keyOrRef) { + return this._extScope.getValue(prefix, keyOrRef); + } + // return code that assigns values in the external scope to the names that are used internally + // (same names that were returned by gen.scopeName or gen.scopeValue) + scopeRefs(scopeName) { + return this._extScope.scopeRefs(scopeName, this._values); + } + scopeCode() { + return this._extScope.scopeCode(this._values); + } + _def(varKind, nameOrPrefix, rhs, constant) { + const name = this._scope.toName(nameOrPrefix); + if (rhs !== void 0 && constant) + this._constants[name.str] = rhs; + this._leafNode(new Def(varKind, name, rhs)); + return name; + } + // `const` declaration (`var` in es5 mode) + const(nameOrPrefix, rhs, _constant) { + return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant); + } + // `let` declaration with optional assignment (`var` in es5 mode) + let(nameOrPrefix, rhs, _constant) { + return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant); + } + // `var` declaration with optional assignment + var(nameOrPrefix, rhs, _constant) { + return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant); + } + // assignment code + assign(lhs, rhs, sideEffects) { + return this._leafNode(new Assign(lhs, rhs, sideEffects)); + } + // `+=` code + add(lhs, rhs) { + return this._leafNode(new AssignOp(lhs, exports$1.operators.ADD, rhs)); + } + // appends passed SafeExpr to code or executes Block + code(c) { + if (typeof c == "function") + c(); + else if (c !== code_12.nil) + this._leafNode(new AnyCode(c)); + return this; + } + // returns code for object literal for the passed argument list of key-value pairs + object(...keyValues) { + const code2 = ["{"]; + for (const [key, value] of keyValues) { + if (code2.length > 1) + code2.push(","); + code2.push(key); + if (key !== value || this.opts.es5) { + code2.push(":"); + (0, code_12.addCodeArg)(code2, value); + } + } + code2.push("}"); + return new code_12._Code(code2); + } + // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed) + if(condition, thenBody, elseBody) { + this._blockNode(new If(condition)); + if (thenBody && elseBody) { + this.code(thenBody).else().code(elseBody).endIf(); + } else if (thenBody) { + this.code(thenBody).endIf(); + } else if (elseBody) { + throw new Error('CodeGen: "else" body without "then" body'); + } + return this; + } + // `else if` clause - invalid without `if` or after `else` clauses + elseIf(condition) { + return this._elseNode(new If(condition)); + } + // `else` clause - only valid after `if` or `else if` clauses + else() { + return this._elseNode(new Else()); + } + // end `if` statement (needed if gen.if was used only with condition) + endIf() { + return this._endBlockNode(If, Else); + } + _for(node, forBody) { + this._blockNode(node); + if (forBody) + this.code(forBody).endFor(); + return this; + } + // a generic `for` clause (or statement if `forBody` is passed) + for(iteration, forBody) { + return this._for(new ForLoop(iteration), forBody); + } + // `for` statement for a range of values + forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) { + const name = this._scope.toName(nameOrPrefix); + return this._for(new ForRange(varKind, name, from, to), () => forBody(name)); + } + // `for-of` statement (in es5 mode replace with a normal for loop) + forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) { + const name = this._scope.toName(nameOrPrefix); + if (this.opts.es5) { + const arr = iterable instanceof code_12.Name ? iterable : this.var("_arr", iterable); + return this.forRange("_i", 0, (0, code_12._)`${arr}.length`, (i) => { + this.var(name, (0, code_12._)`${arr}[${i}]`); + forBody(name); + }); + } + return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name)); + } + // `for-in` statement. + // With option `ownProperties` replaced with a `for-of` loop for object keys + forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) { + if (this.opts.ownProperties) { + return this.forOf(nameOrPrefix, (0, code_12._)`Object.keys(${obj})`, forBody); + } + const name = this._scope.toName(nameOrPrefix); + return this._for(new ForIter("in", varKind, name, obj), () => forBody(name)); + } + // end `for` loop + endFor() { + return this._endBlockNode(For); + } + // `label` statement + label(label) { + return this._leafNode(new Label(label)); + } + // `break` statement + break(label) { + return this._leafNode(new Break(label)); + } + // `return` statement + return(value) { + const node = new Return(); + this._blockNode(node); + this.code(value); + if (node.nodes.length !== 1) + throw new Error('CodeGen: "return" should have one node'); + return this._endBlockNode(Return); + } + // `try` statement + try(tryBody, catchCode, finallyCode) { + if (!catchCode && !finallyCode) + throw new Error('CodeGen: "try" without "catch" and "finally"'); + const node = new Try(); + this._blockNode(node); + this.code(tryBody); + if (catchCode) { + const error2 = this.name("e"); + this._currNode = node.catch = new Catch(error2); + catchCode(error2); + } + if (finallyCode) { + this._currNode = node.finally = new Finally(); + this.code(finallyCode); + } + return this._endBlockNode(Catch, Finally); + } + // `throw` statement + throw(error2) { + return this._leafNode(new Throw(error2)); + } + // start self-balancing block + block(body, nodeCount) { + this._blockStarts.push(this._nodes.length); + if (body) + this.code(body).endBlock(nodeCount); + return this; + } + // end the current self-balancing block + endBlock(nodeCount) { + const len = this._blockStarts.pop(); + if (len === void 0) + throw new Error("CodeGen: not in self-balancing block"); + const toClose = this._nodes.length - len; + if (toClose < 0 || nodeCount !== void 0 && toClose !== nodeCount) { + throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`); + } + this._nodes.length = len; + return this; + } + // `function` heading (or definition if funcBody is passed) + func(name, args = code_12.nil, async, funcBody) { + this._blockNode(new Func(name, args, async)); + if (funcBody) + this.code(funcBody).endFunc(); + return this; + } + // end function definition + endFunc() { + return this._endBlockNode(Func); + } + optimize(n = 1) { + while (n-- > 0) { + this._root.optimizeNodes(); + this._root.optimizeNames(this._root.names, this._constants); + } + } + _leafNode(node) { + this._currNode.nodes.push(node); + return this; + } + _blockNode(node) { + this._currNode.nodes.push(node); + this._nodes.push(node); + } + _endBlockNode(N1, N2) { + const n = this._currNode; + if (n instanceof N1 || N2 && n instanceof N2) { + this._nodes.pop(); + return this; + } + throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`); + } + _elseNode(node) { + const n = this._currNode; + if (!(n instanceof If)) { + throw new Error('CodeGen: "else" without "if"'); + } + this._currNode = n.else = node; + return this; + } + get _root() { + return this._nodes[0]; + } + get _currNode() { + const ns = this._nodes; + return ns[ns.length - 1]; + } + set _currNode(node) { + const ns = this._nodes; + ns[ns.length - 1] = node; + } + } + exports$1.CodeGen = CodeGen; + function addNames(names2, from) { + for (const n in from) + names2[n] = (names2[n] || 0) + (from[n] || 0); + return names2; + } + function addExprNames(names2, from) { + return from instanceof code_12._CodeOrName ? addNames(names2, from.names) : names2; + } + function optimizeExpr(expr, names2, constants2) { + if (expr instanceof code_12.Name) + return replaceName(expr); + if (!canOptimize(expr)) + return expr; + return new code_12._Code(expr._items.reduce((items2, c) => { + if (c instanceof code_12.Name) + c = replaceName(c); + if (c instanceof code_12._Code) + items2.push(...c._items); + else + items2.push(c); + return items2; + }, [])); + function replaceName(n) { + const c = constants2[n.str]; + if (c === void 0 || names2[n.str] !== 1) + return n; + delete names2[n.str]; + return c; + } + function canOptimize(e) { + return e instanceof code_12._Code && e._items.some((c) => c instanceof code_12.Name && names2[c.str] === 1 && constants2[c.str] !== void 0); + } + } + function subtractNames(names2, from) { + for (const n in from) + names2[n] = (names2[n] || 0) - (from[n] || 0); + } + function not2(x) { + return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_12._)`!${par(x)}`; + } + exports$1.not = not2; + const andCode = mappend(exports$1.operators.AND); + function and(...args) { + return args.reduce(andCode); + } + exports$1.and = and; + const orCode = mappend(exports$1.operators.OR); + function or(...args) { + return args.reduce(orCode); + } + exports$1.or = or; + function mappend(op) { + return (x, y) => x === code_12.nil ? y : y === code_12.nil ? x : (0, code_12._)`${par(x)} ${op} ${par(y)}`; + } + function par(x) { + return x instanceof code_12.Name ? x : (0, code_12._)`(${x})`; + } +})(codegen); +var util = {}; +Object.defineProperty(util, "__esModule", { value: true }); +util.checkStrictMode = util.getErrorPath = util.Type = util.useFunc = util.setEvaluated = util.evaluatedPropsToName = util.mergeEvaluated = util.eachItem = util.unescapeJsonPointer = util.escapeJsonPointer = util.escapeFragment = util.unescapeFragment = util.schemaRefOrVal = util.schemaHasRulesButRef = util.schemaHasRules = util.checkUnknownRules = util.alwaysValidSchema = util.toHash = void 0; +const codegen_1$z = codegen; +const code_1$a = code$1; +function toHash(arr) { + const hash = {}; + for (const item of arr) + hash[item] = true; + return hash; +} +util.toHash = toHash; +function alwaysValidSchema(it, schema) { + if (typeof schema == "boolean") + return schema; + if (Object.keys(schema).length === 0) + return true; + checkUnknownRules(it, schema); + return !schemaHasRules(schema, it.self.RULES.all); +} +util.alwaysValidSchema = alwaysValidSchema; +function checkUnknownRules(it, schema = it.schema) { + const { opts, self } = it; + if (!opts.strictSchema) + return; + if (typeof schema === "boolean") + return; + const rules2 = self.RULES.keywords; + for (const key in schema) { + if (!rules2[key]) + checkStrictMode(it, `unknown keyword: "${key}"`); + } +} +util.checkUnknownRules = checkUnknownRules; +function schemaHasRules(schema, rules2) { + if (typeof schema == "boolean") + return !schema; + for (const key in schema) + if (rules2[key]) + return true; + return false; +} +util.schemaHasRules = schemaHasRules; +function schemaHasRulesButRef(schema, RULES) { + if (typeof schema == "boolean") + return !schema; + for (const key in schema) + if (key !== "$ref" && RULES.all[key]) + return true; + return false; +} +util.schemaHasRulesButRef = schemaHasRulesButRef; +function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword2, $data) { + if (!$data) { + if (typeof schema == "number" || typeof schema == "boolean") + return schema; + if (typeof schema == "string") + return (0, codegen_1$z._)`${schema}`; + } + return (0, codegen_1$z._)`${topSchemaRef}${schemaPath}${(0, codegen_1$z.getProperty)(keyword2)}`; +} +util.schemaRefOrVal = schemaRefOrVal; +function unescapeFragment(str) { + return unescapeJsonPointer(decodeURIComponent(str)); +} +util.unescapeFragment = unescapeFragment; +function escapeFragment(str) { + return encodeURIComponent(escapeJsonPointer(str)); +} +util.escapeFragment = escapeFragment; +function escapeJsonPointer(str) { + if (typeof str == "number") + return `${str}`; + return str.replace(/~/g, "~0").replace(/\//g, "~1"); +} +util.escapeJsonPointer = escapeJsonPointer; +function unescapeJsonPointer(str) { + return str.replace(/~1/g, "/").replace(/~0/g, "~"); +} +util.unescapeJsonPointer = unescapeJsonPointer; +function eachItem(xs, f) { + if (Array.isArray(xs)) { + for (const x of xs) + f(x); + } else { + f(xs); + } +} +util.eachItem = eachItem; +function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues, resultToName }) { + return (gen, from, to, toName) => { + const res = to === void 0 ? from : to instanceof codegen_1$z.Name ? (from instanceof codegen_1$z.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1$z.Name ? (mergeToName(gen, to, from), from) : mergeValues(from, to); + return toName === codegen_1$z.Name && !(res instanceof codegen_1$z.Name) ? resultToName(gen, res) : res; + }; +} +util.mergeEvaluated = { + props: makeMergeEvaluated({ + mergeNames: (gen, from, to) => gen.if((0, codegen_1$z._)`${to} !== true && ${from} !== undefined`, () => { + gen.if((0, codegen_1$z._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1$z._)`${to} || {}`).code((0, codegen_1$z._)`Object.assign(${to}, ${from})`)); + }), + mergeToName: (gen, from, to) => gen.if((0, codegen_1$z._)`${to} !== true`, () => { + if (from === true) { + gen.assign(to, true); + } else { + gen.assign(to, (0, codegen_1$z._)`${to} || {}`); + setEvaluated(gen, to, from); + } + }), + mergeValues: (from, to) => from === true ? true : { ...from, ...to }, + resultToName: evaluatedPropsToName + }), + items: makeMergeEvaluated({ + mergeNames: (gen, from, to) => gen.if((0, codegen_1$z._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1$z._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)), + mergeToName: (gen, from, to) => gen.if((0, codegen_1$z._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1$z._)`${to} > ${from} ? ${to} : ${from}`)), + mergeValues: (from, to) => from === true ? true : Math.max(from, to), + resultToName: (gen, items2) => gen.var("items", items2) + }) +}; +function evaluatedPropsToName(gen, ps) { + if (ps === true) + return gen.var("props", true); + const props = gen.var("props", (0, codegen_1$z._)`{}`); + if (ps !== void 0) + setEvaluated(gen, props, ps); + return props; +} +util.evaluatedPropsToName = evaluatedPropsToName; +function setEvaluated(gen, props, ps) { + Object.keys(ps).forEach((p) => gen.assign((0, codegen_1$z._)`${props}${(0, codegen_1$z.getProperty)(p)}`, true)); +} +util.setEvaluated = setEvaluated; +const snippets = {}; +function useFunc(gen, f) { + return gen.scopeValue("func", { + ref: f, + code: snippets[f.code] || (snippets[f.code] = new code_1$a._Code(f.code)) + }); +} +util.useFunc = useFunc; +var Type; +(function(Type2) { + Type2[Type2["Num"] = 0] = "Num"; + Type2[Type2["Str"] = 1] = "Str"; +})(Type || (util.Type = Type = {})); +function getErrorPath(dataProp, dataPropType, jsPropertySyntax) { + if (dataProp instanceof codegen_1$z.Name) { + const isNumber = dataPropType === Type.Num; + return jsPropertySyntax ? isNumber ? (0, codegen_1$z._)`"[" + ${dataProp} + "]"` : (0, codegen_1$z._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1$z._)`"/" + ${dataProp}` : (0, codegen_1$z._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`; + } + return jsPropertySyntax ? (0, codegen_1$z.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp); +} +util.getErrorPath = getErrorPath; +function checkStrictMode(it, msg, mode = it.opts.strictSchema) { + if (!mode) + return; + msg = `strict mode: ${msg}`; + if (mode === true) + throw new Error(msg); + it.self.logger.warn(msg); +} +util.checkStrictMode = checkStrictMode; +var names$1 = {}; +Object.defineProperty(names$1, "__esModule", { value: true }); +const codegen_1$y = codegen; +const names = { + // validation function arguments + data: new codegen_1$y.Name("data"), + // data passed to validation function + // args passed from referencing schema + valCxt: new codegen_1$y.Name("valCxt"), + // validation/data context - should not be used directly, it is destructured to the names below + instancePath: new codegen_1$y.Name("instancePath"), + parentData: new codegen_1$y.Name("parentData"), + parentDataProperty: new codegen_1$y.Name("parentDataProperty"), + rootData: new codegen_1$y.Name("rootData"), + // root data - same as the data passed to the first/top validation function + dynamicAnchors: new codegen_1$y.Name("dynamicAnchors"), + // used to support recursiveRef and dynamicRef + // function scoped variables + vErrors: new codegen_1$y.Name("vErrors"), + // null or array of validation errors + errors: new codegen_1$y.Name("errors"), + // counter of validation errors + this: new codegen_1$y.Name("this"), + // "globals" + self: new codegen_1$y.Name("self"), + scope: new codegen_1$y.Name("scope"), + // JTD serialize/parse name for JSON string and position + json: new codegen_1$y.Name("json"), + jsonPos: new codegen_1$y.Name("jsonPos"), + jsonLen: new codegen_1$y.Name("jsonLen"), + jsonPart: new codegen_1$y.Name("jsonPart") +}; +names$1.default = names; +(function(exports$1) { + Object.defineProperty(exports$1, "__esModule", { value: true }); + exports$1.extendErrors = exports$1.resetErrorsCount = exports$1.reportExtraError = exports$1.reportError = exports$1.keyword$DataError = exports$1.keywordError = void 0; + const codegen_12 = codegen; + const util_12 = util; + const names_12 = names$1; + exports$1.keywordError = { + message: ({ keyword: keyword2 }) => (0, codegen_12.str)`must pass "${keyword2}" keyword validation` + }; + exports$1.keyword$DataError = { + message: ({ keyword: keyword2, schemaType }) => schemaType ? (0, codegen_12.str)`"${keyword2}" keyword must be ${schemaType} ($data)` : (0, codegen_12.str)`"${keyword2}" keyword is invalid ($data)` + }; + function reportError(cxt, error2 = exports$1.keywordError, errorPaths, overrideAllErrors) { + const { it } = cxt; + const { gen, compositeRule, allErrors } = it; + const errObj = errorObjectCode(cxt, error2, errorPaths); + if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : compositeRule || allErrors) { + addError(gen, errObj); + } else { + returnErrors(it, (0, codegen_12._)`[${errObj}]`); + } + } + exports$1.reportError = reportError; + function reportExtraError(cxt, error2 = exports$1.keywordError, errorPaths) { + const { it } = cxt; + const { gen, compositeRule, allErrors } = it; + const errObj = errorObjectCode(cxt, error2, errorPaths); + addError(gen, errObj); + if (!(compositeRule || allErrors)) { + returnErrors(it, names_12.default.vErrors); + } + } + exports$1.reportExtraError = reportExtraError; + function resetErrorsCount(gen, errsCount) { + gen.assign(names_12.default.errors, errsCount); + gen.if((0, codegen_12._)`${names_12.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_12._)`${names_12.default.vErrors}.length`, errsCount), () => gen.assign(names_12.default.vErrors, null))); + } + exports$1.resetErrorsCount = resetErrorsCount; + function extendErrors({ gen, keyword: keyword2, schemaValue, data, errsCount, it }) { + if (errsCount === void 0) + throw new Error("ajv implementation error"); + const err = gen.name("err"); + gen.forRange("i", errsCount, names_12.default.errors, (i) => { + gen.const(err, (0, codegen_12._)`${names_12.default.vErrors}[${i}]`); + gen.if((0, codegen_12._)`${err}.instancePath === undefined`, () => gen.assign((0, codegen_12._)`${err}.instancePath`, (0, codegen_12.strConcat)(names_12.default.instancePath, it.errorPath))); + gen.assign((0, codegen_12._)`${err}.schemaPath`, (0, codegen_12.str)`${it.errSchemaPath}/${keyword2}`); + if (it.opts.verbose) { + gen.assign((0, codegen_12._)`${err}.schema`, schemaValue); + gen.assign((0, codegen_12._)`${err}.data`, data); + } + }); + } + exports$1.extendErrors = extendErrors; + function addError(gen, errObj) { + const err = gen.const("err", errObj); + gen.if((0, codegen_12._)`${names_12.default.vErrors} === null`, () => gen.assign(names_12.default.vErrors, (0, codegen_12._)`[${err}]`), (0, codegen_12._)`${names_12.default.vErrors}.push(${err})`); + gen.code((0, codegen_12._)`${names_12.default.errors}++`); + } + function returnErrors(it, errs) { + const { gen, validateName, schemaEnv } = it; + if (schemaEnv.$async) { + gen.throw((0, codegen_12._)`new ${it.ValidationError}(${errs})`); + } else { + gen.assign((0, codegen_12._)`${validateName}.errors`, errs); + gen.return(false); + } + } + const E = { + keyword: new codegen_12.Name("keyword"), + schemaPath: new codegen_12.Name("schemaPath"), + // also used in JTD errors + params: new codegen_12.Name("params"), + propertyName: new codegen_12.Name("propertyName"), + message: new codegen_12.Name("message"), + schema: new codegen_12.Name("schema"), + parentSchema: new codegen_12.Name("parentSchema") + }; + function errorObjectCode(cxt, error2, errorPaths) { + const { createErrors } = cxt.it; + if (createErrors === false) + return (0, codegen_12._)`{}`; + return errorObject(cxt, error2, errorPaths); + } + function errorObject(cxt, error2, errorPaths = {}) { + const { gen, it } = cxt; + const keyValues = [ + errorInstancePath(it, errorPaths), + errorSchemaPath(cxt, errorPaths) + ]; + extraErrorProps(cxt, error2, keyValues); + return gen.object(...keyValues); + } + function errorInstancePath({ errorPath }, { instancePath }) { + const instPath = instancePath ? (0, codegen_12.str)`${errorPath}${(0, util_12.getErrorPath)(instancePath, util_12.Type.Str)}` : errorPath; + return [names_12.default.instancePath, (0, codegen_12.strConcat)(names_12.default.instancePath, instPath)]; + } + function errorSchemaPath({ keyword: keyword2, it: { errSchemaPath } }, { schemaPath, parentSchema }) { + let schPath = parentSchema ? errSchemaPath : (0, codegen_12.str)`${errSchemaPath}/${keyword2}`; + if (schemaPath) { + schPath = (0, codegen_12.str)`${schPath}${(0, util_12.getErrorPath)(schemaPath, util_12.Type.Str)}`; + } + return [E.schemaPath, schPath]; + } + function extraErrorProps(cxt, { params, message }, keyValues) { + const { keyword: keyword2, data, schemaValue, it } = cxt; + const { opts, propertyName, topSchemaRef, schemaPath } = it; + keyValues.push([E.keyword, keyword2], [E.params, typeof params == "function" ? params(cxt) : params || (0, codegen_12._)`{}`]); + if (opts.messages) { + keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]); + } + if (opts.verbose) { + keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_12._)`${topSchemaRef}${schemaPath}`], [names_12.default.data, data]); + } + if (propertyName) + keyValues.push([E.propertyName, propertyName]); + } +})(errors); +Object.defineProperty(boolSchema, "__esModule", { value: true }); +boolSchema.boolOrEmptySchema = boolSchema.topBoolOrEmptySchema = void 0; +const errors_1$3 = errors; +const codegen_1$x = codegen; +const names_1$9 = names$1; +const boolError = { + message: "boolean schema is false" +}; +function topBoolOrEmptySchema(it) { + const { gen, schema, validateName } = it; + if (schema === false) { + falseSchemaError(it, false); + } else if (typeof schema == "object" && schema.$async === true) { + gen.return(names_1$9.default.data); + } else { + gen.assign((0, codegen_1$x._)`${validateName}.errors`, null); + gen.return(true); + } +} +boolSchema.topBoolOrEmptySchema = topBoolOrEmptySchema; +function boolOrEmptySchema(it, valid2) { + const { gen, schema } = it; + if (schema === false) { + gen.var(valid2, false); + falseSchemaError(it); + } else { + gen.var(valid2, true); + } +} +boolSchema.boolOrEmptySchema = boolOrEmptySchema; +function falseSchemaError(it, overrideAllErrors) { + const { gen, data } = it; + const cxt = { + gen, + keyword: "false schema", + data, + schema: false, + schemaCode: false, + schemaValue: false, + params: {}, + it + }; + (0, errors_1$3.reportError)(cxt, boolError, void 0, overrideAllErrors); +} +var dataType = {}; +var rules = {}; +Object.defineProperty(rules, "__esModule", { value: true }); +rules.getRules = rules.isJSONType = void 0; +const _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"]; +const jsonTypes = new Set(_jsonTypes); +function isJSONType(x) { + return typeof x == "string" && jsonTypes.has(x); +} +rules.isJSONType = isJSONType; +function getRules() { + const groups = { + number: { type: "number", rules: [] }, + string: { type: "string", rules: [] }, + array: { type: "array", rules: [] }, + object: { type: "object", rules: [] } + }; + return { + types: { ...groups, integer: true, boolean: true, null: true }, + rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object], + post: { rules: [] }, + all: {}, + keywords: {} + }; +} +rules.getRules = getRules; +var applicability = {}; +Object.defineProperty(applicability, "__esModule", { value: true }); +applicability.shouldUseRule = applicability.shouldUseGroup = applicability.schemaHasRulesForType = void 0; +function schemaHasRulesForType({ schema, self }, type2) { + const group = self.RULES.types[type2]; + return group && group !== true && shouldUseGroup(schema, group); +} +applicability.schemaHasRulesForType = schemaHasRulesForType; +function shouldUseGroup(schema, group) { + return group.rules.some((rule) => shouldUseRule(schema, rule)); +} +applicability.shouldUseGroup = shouldUseGroup; +function shouldUseRule(schema, rule) { + var _a; + return schema[rule.keyword] !== void 0 || ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== void 0)); +} +applicability.shouldUseRule = shouldUseRule; +Object.defineProperty(dataType, "__esModule", { value: true }); +dataType.reportTypeError = dataType.checkDataTypes = dataType.checkDataType = dataType.coerceAndCheckDataType = dataType.getJSONTypes = dataType.getSchemaTypes = dataType.DataType = void 0; +const rules_1 = rules; +const applicability_1$1 = applicability; +const errors_1$2 = errors; +const codegen_1$w = codegen; +const util_1$v = util; +var DataType; +(function(DataType2) { + DataType2[DataType2["Correct"] = 0] = "Correct"; + DataType2[DataType2["Wrong"] = 1] = "Wrong"; +})(DataType || (dataType.DataType = DataType = {})); +function getSchemaTypes(schema) { + const types2 = getJSONTypes(schema.type); + const hasNull = types2.includes("null"); + if (hasNull) { + if (schema.nullable === false) + throw new Error("type: null contradicts nullable: false"); + } else { + if (!types2.length && schema.nullable !== void 0) { + throw new Error('"nullable" cannot be used without "type"'); + } + if (schema.nullable === true) + types2.push("null"); + } + return types2; +} +dataType.getSchemaTypes = getSchemaTypes; +function getJSONTypes(ts) { + const types2 = Array.isArray(ts) ? ts : ts ? [ts] : []; + if (types2.every(rules_1.isJSONType)) + return types2; + throw new Error("type must be JSONType or JSONType[]: " + types2.join(",")); +} +dataType.getJSONTypes = getJSONTypes; +function coerceAndCheckDataType(it, types2) { + const { gen, data, opts } = it; + const coerceTo = coerceToTypes(types2, opts.coerceTypes); + const checkTypes = types2.length > 0 && !(coerceTo.length === 0 && types2.length === 1 && (0, applicability_1$1.schemaHasRulesForType)(it, types2[0])); + if (checkTypes) { + const wrongType = checkDataTypes(types2, data, opts.strictNumbers, DataType.Wrong); + gen.if(wrongType, () => { + if (coerceTo.length) + coerceData(it, types2, coerceTo); + else + reportTypeError(it); + }); + } + return checkTypes; +} +dataType.coerceAndCheckDataType = coerceAndCheckDataType; +const COERCIBLE = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]); +function coerceToTypes(types2, coerceTypes) { + return coerceTypes ? types2.filter((t2) => COERCIBLE.has(t2) || coerceTypes === "array" && t2 === "array") : []; +} +function coerceData(it, types2, coerceTo) { + const { gen, data, opts } = it; + const dataType2 = gen.let("dataType", (0, codegen_1$w._)`typeof ${data}`); + const coerced = gen.let("coerced", (0, codegen_1$w._)`undefined`); + if (opts.coerceTypes === "array") { + gen.if((0, codegen_1$w._)`${dataType2} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1$w._)`${data}[0]`).assign(dataType2, (0, codegen_1$w._)`typeof ${data}`).if(checkDataTypes(types2, data, opts.strictNumbers), () => gen.assign(coerced, data))); + } + gen.if((0, codegen_1$w._)`${coerced} !== undefined`); + for (const t2 of coerceTo) { + if (COERCIBLE.has(t2) || t2 === "array" && opts.coerceTypes === "array") { + coerceSpecificType(t2); + } + } + gen.else(); + reportTypeError(it); + gen.endIf(); + gen.if((0, codegen_1$w._)`${coerced} !== undefined`, () => { + gen.assign(data, coerced); + assignParentData(it, coerced); + }); + function coerceSpecificType(t2) { + switch (t2) { + case "string": + gen.elseIf((0, codegen_1$w._)`${dataType2} == "number" || ${dataType2} == "boolean"`).assign(coerced, (0, codegen_1$w._)`"" + ${data}`).elseIf((0, codegen_1$w._)`${data} === null`).assign(coerced, (0, codegen_1$w._)`""`); + return; + case "number": + gen.elseIf((0, codegen_1$w._)`${dataType2} == "boolean" || ${data} === null + || (${dataType2} == "string" && ${data} && ${data} == +${data})`).assign(coerced, (0, codegen_1$w._)`+${data}`); + return; + case "integer": + gen.elseIf((0, codegen_1$w._)`${dataType2} === "boolean" || ${data} === null + || (${dataType2} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`).assign(coerced, (0, codegen_1$w._)`+${data}`); + return; + case "boolean": + gen.elseIf((0, codegen_1$w._)`${data} === "false" || ${data} === 0 || ${data} === null`).assign(coerced, false).elseIf((0, codegen_1$w._)`${data} === "true" || ${data} === 1`).assign(coerced, true); + return; + case "null": + gen.elseIf((0, codegen_1$w._)`${data} === "" || ${data} === 0 || ${data} === false`); + gen.assign(coerced, null); + return; + case "array": + gen.elseIf((0, codegen_1$w._)`${dataType2} === "string" || ${dataType2} === "number" + || ${dataType2} === "boolean" || ${data} === null`).assign(coerced, (0, codegen_1$w._)`[${data}]`); + } + } +} +function assignParentData({ gen, parentData, parentDataProperty }, expr) { + gen.if((0, codegen_1$w._)`${parentData} !== undefined`, () => gen.assign((0, codegen_1$w._)`${parentData}[${parentDataProperty}]`, expr)); +} +function checkDataType(dataType2, data, strictNums, correct = DataType.Correct) { + const EQ = correct === DataType.Correct ? codegen_1$w.operators.EQ : codegen_1$w.operators.NEQ; + let cond; + switch (dataType2) { + case "null": + return (0, codegen_1$w._)`${data} ${EQ} null`; + case "array": + cond = (0, codegen_1$w._)`Array.isArray(${data})`; + break; + case "object": + cond = (0, codegen_1$w._)`${data} && typeof ${data} == "object" && !Array.isArray(${data})`; + break; + case "integer": + cond = numCond((0, codegen_1$w._)`!(${data} % 1) && !isNaN(${data})`); + break; + case "number": + cond = numCond(); + break; + default: + return (0, codegen_1$w._)`typeof ${data} ${EQ} ${dataType2}`; + } + return correct === DataType.Correct ? cond : (0, codegen_1$w.not)(cond); + function numCond(_cond = codegen_1$w.nil) { + return (0, codegen_1$w.and)((0, codegen_1$w._)`typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_1$w._)`isFinite(${data})` : codegen_1$w.nil); + } +} +dataType.checkDataType = checkDataType; +function checkDataTypes(dataTypes, data, strictNums, correct) { + if (dataTypes.length === 1) { + return checkDataType(dataTypes[0], data, strictNums, correct); + } + let cond; + const types2 = (0, util_1$v.toHash)(dataTypes); + if (types2.array && types2.object) { + const notObj = (0, codegen_1$w._)`typeof ${data} != "object"`; + cond = types2.null ? notObj : (0, codegen_1$w._)`!${data} || ${notObj}`; + delete types2.null; + delete types2.array; + delete types2.object; + } else { + cond = codegen_1$w.nil; + } + if (types2.number) + delete types2.integer; + for (const t2 in types2) + cond = (0, codegen_1$w.and)(cond, checkDataType(t2, data, strictNums, correct)); + return cond; +} +dataType.checkDataTypes = checkDataTypes; +const typeError = { + message: ({ schema }) => `must be ${schema}`, + params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1$w._)`{type: ${schema}}` : (0, codegen_1$w._)`{type: ${schemaValue}}` +}; +function reportTypeError(it) { + const cxt = getTypeErrorContext(it); + (0, errors_1$2.reportError)(cxt, typeError); +} +dataType.reportTypeError = reportTypeError; +function getTypeErrorContext(it) { + const { gen, data, schema } = it; + const schemaCode = (0, util_1$v.schemaRefOrVal)(it, schema, "type"); + return { + gen, + keyword: "type", + data, + schema: schema.type, + schemaCode, + schemaValue: schemaCode, + parentSchema: schema, + params: {}, + it + }; +} +var defaults = {}; +Object.defineProperty(defaults, "__esModule", { value: true }); +defaults.assignDefaults = void 0; +const codegen_1$v = codegen; +const util_1$u = util; +function assignDefaults(it, ty) { + const { properties: properties2, items: items2 } = it.schema; + if (ty === "object" && properties2) { + for (const key in properties2) { + assignDefault(it, key, properties2[key].default); + } + } else if (ty === "array" && Array.isArray(items2)) { + items2.forEach((sch, i) => assignDefault(it, i, sch.default)); + } +} +defaults.assignDefaults = assignDefaults; +function assignDefault(it, prop, defaultValue) { + const { gen, compositeRule, data, opts } = it; + if (defaultValue === void 0) + return; + const childData = (0, codegen_1$v._)`${data}${(0, codegen_1$v.getProperty)(prop)}`; + if (compositeRule) { + (0, util_1$u.checkStrictMode)(it, `default is ignored for: ${childData}`); + return; + } + let condition = (0, codegen_1$v._)`${childData} === undefined`; + if (opts.useDefaults === "empty") { + condition = (0, codegen_1$v._)`${condition} || ${childData} === null || ${childData} === ""`; + } + gen.if(condition, (0, codegen_1$v._)`${childData} = ${(0, codegen_1$v.stringify)(defaultValue)}`); +} +var keyword = {}; +var code = {}; +Object.defineProperty(code, "__esModule", { value: true }); +code.validateUnion = code.validateArray = code.usePattern = code.callValidateCode = code.schemaProperties = code.allSchemaProperties = code.noPropertyInData = code.propertyInData = code.isOwnProperty = code.hasPropFunc = code.reportMissingProp = code.checkMissingProp = code.checkReportMissingProp = void 0; +const codegen_1$u = codegen; +const util_1$t = util; +const names_1$8 = names$1; +const util_2$1 = util; +function checkReportMissingProp(cxt, prop) { + const { gen, data, it } = cxt; + gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => { + cxt.setParams({ missingProperty: (0, codegen_1$u._)`${prop}` }, true); + cxt.error(); + }); +} +code.checkReportMissingProp = checkReportMissingProp; +function checkMissingProp({ gen, data, it: { opts } }, properties2, missing) { + return (0, codegen_1$u.or)(...properties2.map((prop) => (0, codegen_1$u.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1$u._)`${missing} = ${prop}`))); +} +code.checkMissingProp = checkMissingProp; +function reportMissingProp(cxt, missing) { + cxt.setParams({ missingProperty: missing }, true); + cxt.error(); +} +code.reportMissingProp = reportMissingProp; +function hasPropFunc(gen) { + return gen.scopeValue("func", { + // eslint-disable-next-line @typescript-eslint/unbound-method + ref: Object.prototype.hasOwnProperty, + code: (0, codegen_1$u._)`Object.prototype.hasOwnProperty` + }); +} +code.hasPropFunc = hasPropFunc; +function isOwnProperty(gen, data, property) { + return (0, codegen_1$u._)`${hasPropFunc(gen)}.call(${data}, ${property})`; +} +code.isOwnProperty = isOwnProperty; +function propertyInData(gen, data, property, ownProperties) { + const cond = (0, codegen_1$u._)`${data}${(0, codegen_1$u.getProperty)(property)} !== undefined`; + return ownProperties ? (0, codegen_1$u._)`${cond} && ${isOwnProperty(gen, data, property)}` : cond; +} +code.propertyInData = propertyInData; +function noPropertyInData(gen, data, property, ownProperties) { + const cond = (0, codegen_1$u._)`${data}${(0, codegen_1$u.getProperty)(property)} === undefined`; + return ownProperties ? (0, codegen_1$u.or)(cond, (0, codegen_1$u.not)(isOwnProperty(gen, data, property))) : cond; +} +code.noPropertyInData = noPropertyInData; +function allSchemaProperties(schemaMap) { + return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : []; +} +code.allSchemaProperties = allSchemaProperties; +function schemaProperties(it, schemaMap) { + return allSchemaProperties(schemaMap).filter((p) => !(0, util_1$t.alwaysValidSchema)(it, schemaMap[p])); +} +code.schemaProperties = schemaProperties; +function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) { + const dataAndSchema = passSchema ? (0, codegen_1$u._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data; + const valCxt = [ + [names_1$8.default.instancePath, (0, codegen_1$u.strConcat)(names_1$8.default.instancePath, errorPath)], + [names_1$8.default.parentData, it.parentData], + [names_1$8.default.parentDataProperty, it.parentDataProperty], + [names_1$8.default.rootData, names_1$8.default.rootData] + ]; + if (it.opts.dynamicRef) + valCxt.push([names_1$8.default.dynamicAnchors, names_1$8.default.dynamicAnchors]); + const args = (0, codegen_1$u._)`${dataAndSchema}, ${gen.object(...valCxt)}`; + return context !== codegen_1$u.nil ? (0, codegen_1$u._)`${func}.call(${context}, ${args})` : (0, codegen_1$u._)`${func}(${args})`; +} +code.callValidateCode = callValidateCode; +const newRegExp = (0, codegen_1$u._)`new RegExp`; +function usePattern({ gen, it: { opts } }, pattern2) { + const u = opts.unicodeRegExp ? "u" : ""; + const { regExp } = opts.code; + const rx = regExp(pattern2, u); + return gen.scopeValue("pattern", { + key: rx.toString(), + ref: rx, + code: (0, codegen_1$u._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2$1.useFunc)(gen, regExp)}(${pattern2}, ${u})` + }); +} +code.usePattern = usePattern; +function validateArray(cxt) { + const { gen, data, keyword: keyword2, it } = cxt; + const valid2 = gen.name("valid"); + if (it.allErrors) { + const validArr = gen.let("valid", true); + validateItems(() => gen.assign(validArr, false)); + return validArr; + } + gen.var(valid2, true); + validateItems(() => gen.break()); + return valid2; + function validateItems(notValid) { + const len = gen.const("len", (0, codegen_1$u._)`${data}.length`); + gen.forRange("i", 0, len, (i) => { + cxt.subschema({ + keyword: keyword2, + dataProp: i, + dataPropType: util_1$t.Type.Num + }, valid2); + gen.if((0, codegen_1$u.not)(valid2), notValid); + }); + } +} +code.validateArray = validateArray; +function validateUnion(cxt) { + const { gen, schema, keyword: keyword2, it } = cxt; + if (!Array.isArray(schema)) + throw new Error("ajv implementation error"); + const alwaysValid = schema.some((sch) => (0, util_1$t.alwaysValidSchema)(it, sch)); + if (alwaysValid && !it.opts.unevaluated) + return; + const valid2 = gen.let("valid", false); + const schValid = gen.name("_valid"); + gen.block(() => schema.forEach((_sch, i) => { + const schCxt = cxt.subschema({ + keyword: keyword2, + schemaProp: i, + compositeRule: true + }, schValid); + gen.assign(valid2, (0, codegen_1$u._)`${valid2} || ${schValid}`); + const merged = cxt.mergeValidEvaluated(schCxt, schValid); + if (!merged) + gen.if((0, codegen_1$u.not)(valid2)); + })); + cxt.result(valid2, () => cxt.reset(), () => cxt.error(true)); +} +code.validateUnion = validateUnion; +Object.defineProperty(keyword, "__esModule", { value: true }); +keyword.validateKeywordUsage = keyword.validSchemaType = keyword.funcKeywordCode = keyword.macroKeywordCode = void 0; +const codegen_1$t = codegen; +const names_1$7 = names$1; +const code_1$9 = code; +const errors_1$1 = errors; +function macroKeywordCode(cxt, def2) { + const { gen, keyword: keyword2, schema, parentSchema, it } = cxt; + const macroSchema = def2.macro.call(it.self, schema, parentSchema, it); + const schemaRef = useKeyword(gen, keyword2, macroSchema); + if (it.opts.validateSchema !== false) + it.self.validateSchema(macroSchema, true); + const valid2 = gen.name("valid"); + cxt.subschema({ + schema: macroSchema, + schemaPath: codegen_1$t.nil, + errSchemaPath: `${it.errSchemaPath}/${keyword2}`, + topSchemaRef: schemaRef, + compositeRule: true + }, valid2); + cxt.pass(valid2, () => cxt.error(true)); +} +keyword.macroKeywordCode = macroKeywordCode; +function funcKeywordCode(cxt, def2) { + var _a; + const { gen, keyword: keyword2, schema, parentSchema, $data, it } = cxt; + checkAsyncKeyword(it, def2); + const validate2 = !$data && def2.compile ? def2.compile.call(it.self, schema, parentSchema, it) : def2.validate; + const validateRef = useKeyword(gen, keyword2, validate2); + const valid2 = gen.let("valid"); + cxt.block$data(valid2, validateKeyword); + cxt.ok((_a = def2.valid) !== null && _a !== void 0 ? _a : valid2); + function validateKeyword() { + if (def2.errors === false) { + assignValid(); + if (def2.modifying) + modifyData(cxt); + reportErrs(() => cxt.error()); + } else { + const ruleErrs = def2.async ? validateAsync() : validateSync(); + if (def2.modifying) + modifyData(cxt); + reportErrs(() => addErrs(cxt, ruleErrs)); + } + } + function validateAsync() { + const ruleErrs = gen.let("ruleErrs", null); + gen.try(() => assignValid((0, codegen_1$t._)`await `), (e) => gen.assign(valid2, false).if((0, codegen_1$t._)`${e} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1$t._)`${e}.errors`), () => gen.throw(e))); + return ruleErrs; + } + function validateSync() { + const validateErrs = (0, codegen_1$t._)`${validateRef}.errors`; + gen.assign(validateErrs, null); + assignValid(codegen_1$t.nil); + return validateErrs; + } + function assignValid(_await = def2.async ? (0, codegen_1$t._)`await ` : codegen_1$t.nil) { + const passCxt = it.opts.passContext ? names_1$7.default.this : names_1$7.default.self; + const passSchema = !("compile" in def2 && !$data || def2.schema === false); + gen.assign(valid2, (0, codegen_1$t._)`${_await}${(0, code_1$9.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def2.modifying); + } + function reportErrs(errors2) { + var _a2; + gen.if((0, codegen_1$t.not)((_a2 = def2.valid) !== null && _a2 !== void 0 ? _a2 : valid2), errors2); + } +} +keyword.funcKeywordCode = funcKeywordCode; +function modifyData(cxt) { + const { gen, data, it } = cxt; + gen.if(it.parentData, () => gen.assign(data, (0, codegen_1$t._)`${it.parentData}[${it.parentDataProperty}]`)); +} +function addErrs(cxt, errs) { + const { gen } = cxt; + gen.if((0, codegen_1$t._)`Array.isArray(${errs})`, () => { + gen.assign(names_1$7.default.vErrors, (0, codegen_1$t._)`${names_1$7.default.vErrors} === null ? ${errs} : ${names_1$7.default.vErrors}.concat(${errs})`).assign(names_1$7.default.errors, (0, codegen_1$t._)`${names_1$7.default.vErrors}.length`); + (0, errors_1$1.extendErrors)(cxt); + }, () => cxt.error()); +} +function checkAsyncKeyword({ schemaEnv }, def2) { + if (def2.async && !schemaEnv.$async) + throw new Error("async keyword in sync schema"); +} +function useKeyword(gen, keyword2, result) { + if (result === void 0) + throw new Error(`keyword "${keyword2}" failed to compile`); + return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_1$t.stringify)(result) }); +} +function validSchemaType(schema, schemaType, allowUndefined = false) { + return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st || allowUndefined && typeof schema == "undefined"); +} +keyword.validSchemaType = validSchemaType; +function validateKeywordUsage({ schema, opts, self, errSchemaPath }, def2, keyword2) { + if (Array.isArray(def2.keyword) ? !def2.keyword.includes(keyword2) : def2.keyword !== keyword2) { + throw new Error("ajv implementation error"); + } + const deps = def2.dependencies; + if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) { + throw new Error(`parent schema must have dependencies of ${keyword2}: ${deps.join(",")}`); + } + if (def2.validateSchema) { + const valid2 = def2.validateSchema(schema[keyword2]); + if (!valid2) { + const msg = `keyword "${keyword2}" value is invalid at path "${errSchemaPath}": ` + self.errorsText(def2.validateSchema.errors); + if (opts.validateSchema === "log") + self.logger.error(msg); + else + throw new Error(msg); + } + } +} +keyword.validateKeywordUsage = validateKeywordUsage; +var subschema = {}; +Object.defineProperty(subschema, "__esModule", { value: true }); +subschema.extendSubschemaMode = subschema.extendSubschemaData = subschema.getSubschema = void 0; +const codegen_1$s = codegen; +const util_1$s = util; +function getSubschema(it, { keyword: keyword2, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) { + if (keyword2 !== void 0 && schema !== void 0) { + throw new Error('both "keyword" and "schema" passed, only one allowed'); + } + if (keyword2 !== void 0) { + const sch = it.schema[keyword2]; + return schemaProp === void 0 ? { + schema: sch, + schemaPath: (0, codegen_1$s._)`${it.schemaPath}${(0, codegen_1$s.getProperty)(keyword2)}`, + errSchemaPath: `${it.errSchemaPath}/${keyword2}` + } : { + schema: sch[schemaProp], + schemaPath: (0, codegen_1$s._)`${it.schemaPath}${(0, codegen_1$s.getProperty)(keyword2)}${(0, codegen_1$s.getProperty)(schemaProp)}`, + errSchemaPath: `${it.errSchemaPath}/${keyword2}/${(0, util_1$s.escapeFragment)(schemaProp)}` + }; + } + if (schema !== void 0) { + if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) { + throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"'); + } + return { + schema, + schemaPath, + topSchemaRef, + errSchemaPath + }; + } + throw new Error('either "keyword" or "schema" must be passed'); +} +subschema.getSubschema = getSubschema; +function extendSubschemaData(subschema2, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) { + if (data !== void 0 && dataProp !== void 0) { + throw new Error('both "data" and "dataProp" passed, only one allowed'); + } + const { gen } = it; + if (dataProp !== void 0) { + const { errorPath, dataPathArr, opts } = it; + const nextData = gen.let("data", (0, codegen_1$s._)`${it.data}${(0, codegen_1$s.getProperty)(dataProp)}`, true); + dataContextProps(nextData); + subschema2.errorPath = (0, codegen_1$s.str)`${errorPath}${(0, util_1$s.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`; + subschema2.parentDataProperty = (0, codegen_1$s._)`${dataProp}`; + subschema2.dataPathArr = [...dataPathArr, subschema2.parentDataProperty]; + } + if (data !== void 0) { + const nextData = data instanceof codegen_1$s.Name ? data : gen.let("data", data, true); + dataContextProps(nextData); + if (propertyName !== void 0) + subschema2.propertyName = propertyName; + } + if (dataTypes) + subschema2.dataTypes = dataTypes; + function dataContextProps(_nextData) { + subschema2.data = _nextData; + subschema2.dataLevel = it.dataLevel + 1; + subschema2.dataTypes = []; + it.definedProperties = /* @__PURE__ */ new Set(); + subschema2.parentData = it.data; + subschema2.dataNames = [...it.dataNames, _nextData]; + } +} +subschema.extendSubschemaData = extendSubschemaData; +function extendSubschemaMode(subschema2, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) { + if (compositeRule !== void 0) + subschema2.compositeRule = compositeRule; + if (createErrors !== void 0) + subschema2.createErrors = createErrors; + if (allErrors !== void 0) + subschema2.allErrors = allErrors; + subschema2.jtdDiscriminator = jtdDiscriminator; + subschema2.jtdMetadata = jtdMetadata; +} +subschema.extendSubschemaMode = extendSubschemaMode; +var resolve$2 = {}; +var fastDeepEqual = function equal(a, b) { + if (a === b) return true; + if (a && b && typeof a == "object" && typeof b == "object") { + if (a.constructor !== b.constructor) return false; + var length, i, keys; + if (Array.isArray(a)) { + length = a.length; + if (length != b.length) return false; + for (i = length; i-- !== 0; ) + if (!equal(a[i], b[i])) return false; + return true; + } + if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags; + if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf(); + if (a.toString !== Object.prototype.toString) return a.toString() === b.toString(); + keys = Object.keys(a); + length = keys.length; + if (length !== Object.keys(b).length) return false; + for (i = length; i-- !== 0; ) + if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false; + for (i = length; i-- !== 0; ) { + var key = keys[i]; + if (!equal(a[key], b[key])) return false; + } + return true; + } + return a !== a && b !== b; +}; +var jsonSchemaTraverse = { exports: {} }; +var traverse$1 = jsonSchemaTraverse.exports = function(schema, opts, cb) { + if (typeof opts == "function") { + cb = opts; + opts = {}; + } + cb = opts.cb || cb; + var pre = typeof cb == "function" ? cb : cb.pre || function() { + }; + var post = cb.post || function() { + }; + _traverse(opts, pre, post, schema, "", schema); +}; +traverse$1.keywords = { + additionalItems: true, + items: true, + contains: true, + additionalProperties: true, + propertyNames: true, + not: true, + if: true, + then: true, + else: true +}; +traverse$1.arrayKeywords = { + items: true, + allOf: true, + anyOf: true, + oneOf: true +}; +traverse$1.propsKeywords = { + $defs: true, + definitions: true, + properties: true, + patternProperties: true, + dependencies: true +}; +traverse$1.skipKeywords = { + default: true, + enum: true, + const: true, + required: true, + maximum: true, + minimum: true, + exclusiveMaximum: true, + exclusiveMinimum: true, + multipleOf: true, + maxLength: true, + minLength: true, + pattern: true, + format: true, + maxItems: true, + minItems: true, + uniqueItems: true, + maxProperties: true, + minProperties: true +}; +function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) { + if (schema && typeof schema == "object" && !Array.isArray(schema)) { + pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex); + for (var key in schema) { + var sch = schema[key]; + if (Array.isArray(sch)) { + if (key in traverse$1.arrayKeywords) { + for (var i = 0; i < sch.length; i++) + _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i); + } + } else if (key in traverse$1.propsKeywords) { + if (sch && typeof sch == "object") { + for (var prop in sch) + _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop); + } + } else if (key in traverse$1.keywords || opts.allKeys && !(key in traverse$1.skipKeywords)) { + _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema); + } + } + post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex); + } +} +function escapeJsonPtr(str) { + return str.replace(/~/g, "~0").replace(/\//g, "~1"); +} +var jsonSchemaTraverseExports = jsonSchemaTraverse.exports; +Object.defineProperty(resolve$2, "__esModule", { value: true }); +resolve$2.getSchemaRefs = resolve$2.resolveUrl = resolve$2.normalizeId = resolve$2._getFullPath = resolve$2.getFullPath = resolve$2.inlineRef = void 0; +const util_1$r = util; +const equal$3 = fastDeepEqual; +const traverse = jsonSchemaTraverseExports; +const SIMPLE_INLINED = /* @__PURE__ */ new Set([ + "type", + "format", + "pattern", + "maxLength", + "minLength", + "maxProperties", + "minProperties", + "maxItems", + "minItems", + "maximum", + "minimum", + "uniqueItems", + "multipleOf", + "required", + "enum", + "const" +]); +function inlineRef(schema, limit2 = true) { + if (typeof schema == "boolean") + return true; + if (limit2 === true) + return !hasRef(schema); + if (!limit2) + return false; + return countKeys(schema) <= limit2; +} +resolve$2.inlineRef = inlineRef; +const REF_KEYWORDS = /* @__PURE__ */ new Set([ + "$ref", + "$recursiveRef", + "$recursiveAnchor", + "$dynamicRef", + "$dynamicAnchor" +]); +function hasRef(schema) { + for (const key in schema) { + if (REF_KEYWORDS.has(key)) + return true; + const sch = schema[key]; + if (Array.isArray(sch) && sch.some(hasRef)) + return true; + if (typeof sch == "object" && hasRef(sch)) + return true; + } + return false; +} +function countKeys(schema) { + let count = 0; + for (const key in schema) { + if (key === "$ref") + return Infinity; + count++; + if (SIMPLE_INLINED.has(key)) + continue; + if (typeof schema[key] == "object") { + (0, util_1$r.eachItem)(schema[key], (sch) => count += countKeys(sch)); + } + if (count === Infinity) + return Infinity; + } + return count; +} +function getFullPath(resolver, id2 = "", normalize2) { + if (normalize2 !== false) + id2 = normalizeId(id2); + const p = resolver.parse(id2); + return _getFullPath(resolver, p); +} +resolve$2.getFullPath = getFullPath; +function _getFullPath(resolver, p) { + const serialized = resolver.serialize(p); + return serialized.split("#")[0] + "#"; +} +resolve$2._getFullPath = _getFullPath; +const TRAILING_SLASH_HASH = /#\/?$/; +function normalizeId(id2) { + return id2 ? id2.replace(TRAILING_SLASH_HASH, "") : ""; +} +resolve$2.normalizeId = normalizeId; +function resolveUrl(resolver, baseId, id2) { + id2 = normalizeId(id2); + return resolver.resolve(baseId, id2); +} +resolve$2.resolveUrl = resolveUrl; +const ANCHOR = /^[a-z_][-a-z0-9._]*$/i; +function getSchemaRefs(schema, baseId) { + if (typeof schema == "boolean") + return {}; + const { schemaId, uriResolver } = this.opts; + const schId = normalizeId(schema[schemaId] || baseId); + const baseIds = { "": schId }; + const pathPrefix = getFullPath(uriResolver, schId, false); + const localRefs = {}; + const schemaRefs = /* @__PURE__ */ new Set(); + traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => { + if (parentJsonPtr === void 0) + return; + const fullPath = pathPrefix + jsonPtr; + let innerBaseId = baseIds[parentJsonPtr]; + if (typeof sch[schemaId] == "string") + innerBaseId = addRef.call(this, sch[schemaId]); + addAnchor.call(this, sch.$anchor); + addAnchor.call(this, sch.$dynamicAnchor); + baseIds[jsonPtr] = innerBaseId; + function addRef(ref2) { + const _resolve = this.opts.uriResolver.resolve; + ref2 = normalizeId(innerBaseId ? _resolve(innerBaseId, ref2) : ref2); + if (schemaRefs.has(ref2)) + throw ambiguos(ref2); + schemaRefs.add(ref2); + let schOrRef = this.refs[ref2]; + if (typeof schOrRef == "string") + schOrRef = this.refs[schOrRef]; + if (typeof schOrRef == "object") { + checkAmbiguosRef(sch, schOrRef.schema, ref2); + } else if (ref2 !== normalizeId(fullPath)) { + if (ref2[0] === "#") { + checkAmbiguosRef(sch, localRefs[ref2], ref2); + localRefs[ref2] = sch; + } else { + this.refs[ref2] = fullPath; + } + } + return ref2; + } + function addAnchor(anchor) { + if (typeof anchor == "string") { + if (!ANCHOR.test(anchor)) + throw new Error(`invalid anchor "${anchor}"`); + addRef.call(this, `#${anchor}`); + } + } + }); + return localRefs; + function checkAmbiguosRef(sch1, sch2, ref2) { + if (sch2 !== void 0 && !equal$3(sch1, sch2)) + throw ambiguos(ref2); + } + function ambiguos(ref2) { + return new Error(`reference "${ref2}" resolves to more than one schema`); + } +} +resolve$2.getSchemaRefs = getSchemaRefs; +Object.defineProperty(validate, "__esModule", { value: true }); +validate.getData = validate.KeywordCxt = validate.validateFunctionCode = void 0; +const boolSchema_1 = boolSchema; +const dataType_1$1 = dataType; +const applicability_1 = applicability; +const dataType_2 = dataType; +const defaults_1 = defaults; +const keyword_1 = keyword; +const subschema_1 = subschema; +const codegen_1$r = codegen; +const names_1$6 = names$1; +const resolve_1$2 = resolve$2; +const util_1$q = util; +const errors_1 = errors; +function validateFunctionCode(it) { + if (isSchemaObj(it)) { + checkKeywords(it); + if (schemaCxtHasRules(it)) { + topSchemaObjCode(it); + return; + } + } + validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it)); +} +validate.validateFunctionCode = validateFunctionCode; +function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) { + if (opts.code.es5) { + gen.func(validateName, (0, codegen_1$r._)`${names_1$6.default.data}, ${names_1$6.default.valCxt}`, schemaEnv.$async, () => { + gen.code((0, codegen_1$r._)`"use strict"; ${funcSourceUrl(schema, opts)}`); + destructureValCxtES5(gen, opts); + gen.code(body); + }); + } else { + gen.func(validateName, (0, codegen_1$r._)`${names_1$6.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body)); + } +} +function destructureValCxt(opts) { + return (0, codegen_1$r._)`{${names_1$6.default.instancePath}="", ${names_1$6.default.parentData}, ${names_1$6.default.parentDataProperty}, ${names_1$6.default.rootData}=${names_1$6.default.data}${opts.dynamicRef ? (0, codegen_1$r._)`, ${names_1$6.default.dynamicAnchors}={}` : codegen_1$r.nil}}={}`; +} +function destructureValCxtES5(gen, opts) { + gen.if(names_1$6.default.valCxt, () => { + gen.var(names_1$6.default.instancePath, (0, codegen_1$r._)`${names_1$6.default.valCxt}.${names_1$6.default.instancePath}`); + gen.var(names_1$6.default.parentData, (0, codegen_1$r._)`${names_1$6.default.valCxt}.${names_1$6.default.parentData}`); + gen.var(names_1$6.default.parentDataProperty, (0, codegen_1$r._)`${names_1$6.default.valCxt}.${names_1$6.default.parentDataProperty}`); + gen.var(names_1$6.default.rootData, (0, codegen_1$r._)`${names_1$6.default.valCxt}.${names_1$6.default.rootData}`); + if (opts.dynamicRef) + gen.var(names_1$6.default.dynamicAnchors, (0, codegen_1$r._)`${names_1$6.default.valCxt}.${names_1$6.default.dynamicAnchors}`); + }, () => { + gen.var(names_1$6.default.instancePath, (0, codegen_1$r._)`""`); + gen.var(names_1$6.default.parentData, (0, codegen_1$r._)`undefined`); + gen.var(names_1$6.default.parentDataProperty, (0, codegen_1$r._)`undefined`); + gen.var(names_1$6.default.rootData, names_1$6.default.data); + if (opts.dynamicRef) + gen.var(names_1$6.default.dynamicAnchors, (0, codegen_1$r._)`{}`); + }); +} +function topSchemaObjCode(it) { + const { schema, opts, gen } = it; + validateFunction(it, () => { + if (opts.$comment && schema.$comment) + commentKeyword(it); + checkNoDefault(it); + gen.let(names_1$6.default.vErrors, null); + gen.let(names_1$6.default.errors, 0); + if (opts.unevaluated) + resetEvaluated(it); + typeAndKeywords(it); + returnResults(it); + }); + return; +} +function resetEvaluated(it) { + const { gen, validateName } = it; + it.evaluated = gen.const("evaluated", (0, codegen_1$r._)`${validateName}.evaluated`); + gen.if((0, codegen_1$r._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1$r._)`${it.evaluated}.props`, (0, codegen_1$r._)`undefined`)); + gen.if((0, codegen_1$r._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1$r._)`${it.evaluated}.items`, (0, codegen_1$r._)`undefined`)); +} +function funcSourceUrl(schema, opts) { + const schId = typeof schema == "object" && schema[opts.schemaId]; + return schId && (opts.code.source || opts.code.process) ? (0, codegen_1$r._)`/*# sourceURL=${schId} */` : codegen_1$r.nil; +} +function subschemaCode(it, valid2) { + if (isSchemaObj(it)) { + checkKeywords(it); + if (schemaCxtHasRules(it)) { + subSchemaObjCode(it, valid2); + return; + } + } + (0, boolSchema_1.boolOrEmptySchema)(it, valid2); +} +function schemaCxtHasRules({ schema, self }) { + if (typeof schema == "boolean") + return !schema; + for (const key in schema) + if (self.RULES.all[key]) + return true; + return false; +} +function isSchemaObj(it) { + return typeof it.schema != "boolean"; +} +function subSchemaObjCode(it, valid2) { + const { schema, gen, opts } = it; + if (opts.$comment && schema.$comment) + commentKeyword(it); + updateContext(it); + checkAsyncSchema(it); + const errsCount = gen.const("_errs", names_1$6.default.errors); + typeAndKeywords(it, errsCount); + gen.var(valid2, (0, codegen_1$r._)`${errsCount} === ${names_1$6.default.errors}`); +} +function checkKeywords(it) { + (0, util_1$q.checkUnknownRules)(it); + checkRefsAndKeywords(it); +} +function typeAndKeywords(it, errsCount) { + if (it.opts.jtd) + return schemaKeywords(it, [], false, errsCount); + const types2 = (0, dataType_1$1.getSchemaTypes)(it.schema); + const checkedTypes = (0, dataType_1$1.coerceAndCheckDataType)(it, types2); + schemaKeywords(it, types2, !checkedTypes, errsCount); +} +function checkRefsAndKeywords(it) { + const { schema, errSchemaPath, opts, self } = it; + if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1$q.schemaHasRulesButRef)(schema, self.RULES)) { + self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`); + } +} +function checkNoDefault(it) { + const { schema, opts } = it; + if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema) { + (0, util_1$q.checkStrictMode)(it, "default is ignored in the schema root"); + } +} +function updateContext(it) { + const schId = it.schema[it.opts.schemaId]; + if (schId) + it.baseId = (0, resolve_1$2.resolveUrl)(it.opts.uriResolver, it.baseId, schId); +} +function checkAsyncSchema(it) { + if (it.schema.$async && !it.schemaEnv.$async) + throw new Error("async schema in sync schema"); +} +function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) { + const msg = schema.$comment; + if (opts.$comment === true) { + gen.code((0, codegen_1$r._)`${names_1$6.default.self}.logger.log(${msg})`); + } else if (typeof opts.$comment == "function") { + const schemaPath = (0, codegen_1$r.str)`${errSchemaPath}/$comment`; + const rootName = gen.scopeValue("root", { ref: schemaEnv.root }); + gen.code((0, codegen_1$r._)`${names_1$6.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`); + } +} +function returnResults(it) { + const { gen, schemaEnv, validateName, ValidationError: ValidationError2, opts } = it; + if (schemaEnv.$async) { + gen.if((0, codegen_1$r._)`${names_1$6.default.errors} === 0`, () => gen.return(names_1$6.default.data), () => gen.throw((0, codegen_1$r._)`new ${ValidationError2}(${names_1$6.default.vErrors})`)); + } else { + gen.assign((0, codegen_1$r._)`${validateName}.errors`, names_1$6.default.vErrors); + if (opts.unevaluated) + assignEvaluated(it); + gen.return((0, codegen_1$r._)`${names_1$6.default.errors} === 0`); + } +} +function assignEvaluated({ gen, evaluated, props, items: items2 }) { + if (props instanceof codegen_1$r.Name) + gen.assign((0, codegen_1$r._)`${evaluated}.props`, props); + if (items2 instanceof codegen_1$r.Name) + gen.assign((0, codegen_1$r._)`${evaluated}.items`, items2); +} +function schemaKeywords(it, types2, typeErrors, errsCount) { + const { gen, schema, data, allErrors, opts, self } = it; + const { RULES } = self; + if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1$q.schemaHasRulesButRef)(schema, RULES))) { + gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition)); + return; + } + if (!opts.jtd) + checkStrictTypes(it, types2); + gen.block(() => { + for (const group of RULES.rules) + groupKeywords(group); + groupKeywords(RULES.post); + }); + function groupKeywords(group) { + if (!(0, applicability_1.shouldUseGroup)(schema, group)) + return; + if (group.type) { + gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers)); + iterateKeywords(it, group); + if (types2.length === 1 && types2[0] === group.type && typeErrors) { + gen.else(); + (0, dataType_2.reportTypeError)(it); + } + gen.endIf(); + } else { + iterateKeywords(it, group); + } + if (!allErrors) + gen.if((0, codegen_1$r._)`${names_1$6.default.errors} === ${errsCount || 0}`); + } +} +function iterateKeywords(it, group) { + const { gen, schema, opts: { useDefaults } } = it; + if (useDefaults) + (0, defaults_1.assignDefaults)(it, group.type); + gen.block(() => { + for (const rule of group.rules) { + if ((0, applicability_1.shouldUseRule)(schema, rule)) { + keywordCode(it, rule.keyword, rule.definition, group.type); + } + } + }); +} +function checkStrictTypes(it, types2) { + if (it.schemaEnv.meta || !it.opts.strictTypes) + return; + checkContextTypes(it, types2); + if (!it.opts.allowUnionTypes) + checkMultipleTypes(it, types2); + checkKeywordTypes(it, it.dataTypes); +} +function checkContextTypes(it, types2) { + if (!types2.length) + return; + if (!it.dataTypes.length) { + it.dataTypes = types2; + return; + } + types2.forEach((t2) => { + if (!includesType(it.dataTypes, t2)) { + strictTypesError(it, `type "${t2}" not allowed by context "${it.dataTypes.join(",")}"`); + } + }); + narrowSchemaTypes(it, types2); +} +function checkMultipleTypes(it, ts) { + if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) { + strictTypesError(it, "use allowUnionTypes to allow union type keyword"); + } +} +function checkKeywordTypes(it, ts) { + const rules2 = it.self.RULES.all; + for (const keyword2 in rules2) { + const rule = rules2[keyword2]; + if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) { + const { type: type2 } = rule.definition; + if (type2.length && !type2.some((t2) => hasApplicableType(ts, t2))) { + strictTypesError(it, `missing type "${type2.join(",")}" for keyword "${keyword2}"`); + } + } + } +} +function hasApplicableType(schTs, kwdT) { + return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer"); +} +function includesType(ts, t2) { + return ts.includes(t2) || t2 === "integer" && ts.includes("number"); +} +function narrowSchemaTypes(it, withTypes) { + const ts = []; + for (const t2 of it.dataTypes) { + if (includesType(withTypes, t2)) + ts.push(t2); + else if (withTypes.includes("integer") && t2 === "number") + ts.push("integer"); + } + it.dataTypes = ts; +} +function strictTypesError(it, msg) { + const schemaPath = it.schemaEnv.baseId + it.errSchemaPath; + msg += ` at "${schemaPath}" (strictTypes)`; + (0, util_1$q.checkStrictMode)(it, msg, it.opts.strictTypes); +} +class KeywordCxt { + constructor(it, def2, keyword2) { + (0, keyword_1.validateKeywordUsage)(it, def2, keyword2); + this.gen = it.gen; + this.allErrors = it.allErrors; + this.keyword = keyword2; + this.data = it.data; + this.schema = it.schema[keyword2]; + this.$data = def2.$data && it.opts.$data && this.schema && this.schema.$data; + this.schemaValue = (0, util_1$q.schemaRefOrVal)(it, this.schema, keyword2, this.$data); + this.schemaType = def2.schemaType; + this.parentSchema = it.schema; + this.params = {}; + this.it = it; + this.def = def2; + if (this.$data) { + this.schemaCode = it.gen.const("vSchema", getData(this.$data, it)); + } else { + this.schemaCode = this.schemaValue; + if (!(0, keyword_1.validSchemaType)(this.schema, def2.schemaType, def2.allowUndefined)) { + throw new Error(`${keyword2} value must be ${JSON.stringify(def2.schemaType)}`); + } + } + if ("code" in def2 ? def2.trackErrors : def2.errors !== false) { + this.errsCount = it.gen.const("_errs", names_1$6.default.errors); + } + } + result(condition, successAction, failAction) { + this.failResult((0, codegen_1$r.not)(condition), successAction, failAction); + } + failResult(condition, successAction, failAction) { + this.gen.if(condition); + if (failAction) + failAction(); + else + this.error(); + if (successAction) { + this.gen.else(); + successAction(); + if (this.allErrors) + this.gen.endIf(); + } else { + if (this.allErrors) + this.gen.endIf(); + else + this.gen.else(); + } + } + pass(condition, failAction) { + this.failResult((0, codegen_1$r.not)(condition), void 0, failAction); + } + fail(condition) { + if (condition === void 0) { + this.error(); + if (!this.allErrors) + this.gen.if(false); + return; + } + this.gen.if(condition); + this.error(); + if (this.allErrors) + this.gen.endIf(); + else + this.gen.else(); + } + fail$data(condition) { + if (!this.$data) + return this.fail(condition); + const { schemaCode } = this; + this.fail((0, codegen_1$r._)`${schemaCode} !== undefined && (${(0, codegen_1$r.or)(this.invalid$data(), condition)})`); + } + error(append, errorParams, errorPaths) { + if (errorParams) { + this.setParams(errorParams); + this._error(append, errorPaths); + this.setParams({}); + return; + } + this._error(append, errorPaths); + } + _error(append, errorPaths) { + (append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths); + } + $dataError() { + (0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError); + } + reset() { + if (this.errsCount === void 0) + throw new Error('add "trackErrors" to keyword definition'); + (0, errors_1.resetErrorsCount)(this.gen, this.errsCount); + } + ok(cond) { + if (!this.allErrors) + this.gen.if(cond); + } + setParams(obj, assign) { + if (assign) + Object.assign(this.params, obj); + else + this.params = obj; + } + block$data(valid2, codeBlock, $dataValid = codegen_1$r.nil) { + this.gen.block(() => { + this.check$data(valid2, $dataValid); + codeBlock(); + }); + } + check$data(valid2 = codegen_1$r.nil, $dataValid = codegen_1$r.nil) { + if (!this.$data) + return; + const { gen, schemaCode, schemaType, def: def2 } = this; + gen.if((0, codegen_1$r.or)((0, codegen_1$r._)`${schemaCode} === undefined`, $dataValid)); + if (valid2 !== codegen_1$r.nil) + gen.assign(valid2, true); + if (schemaType.length || def2.validateSchema) { + gen.elseIf(this.invalid$data()); + this.$dataError(); + if (valid2 !== codegen_1$r.nil) + gen.assign(valid2, false); + } + gen.else(); + } + invalid$data() { + const { gen, schemaCode, schemaType, def: def2, it } = this; + return (0, codegen_1$r.or)(wrong$DataType(), invalid$DataSchema()); + function wrong$DataType() { + if (schemaType.length) { + if (!(schemaCode instanceof codegen_1$r.Name)) + throw new Error("ajv implementation error"); + const st = Array.isArray(schemaType) ? schemaType : [schemaType]; + return (0, codegen_1$r._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`; + } + return codegen_1$r.nil; + } + function invalid$DataSchema() { + if (def2.validateSchema) { + const validateSchemaRef = gen.scopeValue("validate$data", { ref: def2.validateSchema }); + return (0, codegen_1$r._)`!${validateSchemaRef}(${schemaCode})`; + } + return codegen_1$r.nil; + } + } + subschema(appl, valid2) { + const subschema2 = (0, subschema_1.getSubschema)(this.it, appl); + (0, subschema_1.extendSubschemaData)(subschema2, this.it, appl); + (0, subschema_1.extendSubschemaMode)(subschema2, appl); + const nextContext = { ...this.it, ...subschema2, items: void 0, props: void 0 }; + subschemaCode(nextContext, valid2); + return nextContext; + } + mergeEvaluated(schemaCxt, toName) { + const { it, gen } = this; + if (!it.opts.unevaluated) + return; + if (it.props !== true && schemaCxt.props !== void 0) { + it.props = util_1$q.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName); + } + if (it.items !== true && schemaCxt.items !== void 0) { + it.items = util_1$q.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName); + } + } + mergeValidEvaluated(schemaCxt, valid2) { + const { it, gen } = this; + if (it.opts.unevaluated && (it.props !== true || it.items !== true)) { + gen.if(valid2, () => this.mergeEvaluated(schemaCxt, codegen_1$r.Name)); + return true; + } + } +} +validate.KeywordCxt = KeywordCxt; +function keywordCode(it, keyword2, def2, ruleType) { + const cxt = new KeywordCxt(it, def2, keyword2); + if ("code" in def2) { + def2.code(cxt, ruleType); + } else if (cxt.$data && def2.validate) { + (0, keyword_1.funcKeywordCode)(cxt, def2); + } else if ("macro" in def2) { + (0, keyword_1.macroKeywordCode)(cxt, def2); + } else if (def2.compile || def2.validate) { + (0, keyword_1.funcKeywordCode)(cxt, def2); + } +} +const JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/; +const RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/; +function getData($data, { dataLevel, dataNames, dataPathArr }) { + let jsonPointer; + let data; + if ($data === "") + return names_1$6.default.rootData; + if ($data[0] === "/") { + if (!JSON_POINTER.test($data)) + throw new Error(`Invalid JSON-pointer: ${$data}`); + jsonPointer = $data; + data = names_1$6.default.rootData; + } else { + const matches = RELATIVE_JSON_POINTER.exec($data); + if (!matches) + throw new Error(`Invalid JSON-pointer: ${$data}`); + const up = +matches[1]; + jsonPointer = matches[2]; + if (jsonPointer === "#") { + if (up >= dataLevel) + throw new Error(errorMsg("property/index", up)); + return dataPathArr[dataLevel - up]; + } + if (up > dataLevel) + throw new Error(errorMsg("data", up)); + data = dataNames[dataLevel - up]; + if (!jsonPointer) + return data; + } + let expr = data; + const segments = jsonPointer.split("/"); + for (const segment of segments) { + if (segment) { + data = (0, codegen_1$r._)`${data}${(0, codegen_1$r.getProperty)((0, util_1$q.unescapeJsonPointer)(segment))}`; + expr = (0, codegen_1$r._)`${expr} && ${data}`; + } + } + return expr; + function errorMsg(pointerType, up) { + return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`; + } +} +validate.getData = getData; +var validation_error = {}; +Object.defineProperty(validation_error, "__esModule", { value: true }); +class ValidationError extends Error { + constructor(errors2) { + super("validation failed"); + this.errors = errors2; + this.ajv = this.validation = true; + } +} +validation_error.default = ValidationError; +var ref_error = {}; +Object.defineProperty(ref_error, "__esModule", { value: true }); +const resolve_1$1 = resolve$2; +class MissingRefError extends Error { + constructor(resolver, baseId, ref2, msg) { + super(msg || `can't resolve reference ${ref2} from id ${baseId}`); + this.missingRef = (0, resolve_1$1.resolveUrl)(resolver, baseId, ref2); + this.missingSchema = (0, resolve_1$1.normalizeId)((0, resolve_1$1.getFullPath)(resolver, this.missingRef)); + } +} +ref_error.default = MissingRefError; +var compile = {}; +Object.defineProperty(compile, "__esModule", { value: true }); +compile.resolveSchema = compile.getCompilingSchema = compile.resolveRef = compile.compileSchema = compile.SchemaEnv = void 0; +const codegen_1$q = codegen; +const validation_error_1 = validation_error; +const names_1$5 = names$1; +const resolve_1 = resolve$2; +const util_1$p = util; +const validate_1$1 = validate; +class SchemaEnv { + constructor(env2) { + var _a; + this.refs = {}; + this.dynamicAnchors = {}; + let schema; + if (typeof env2.schema == "object") + schema = env2.schema; + this.schema = env2.schema; + this.schemaId = env2.schemaId; + this.root = env2.root || this; + this.baseId = (_a = env2.baseId) !== null && _a !== void 0 ? _a : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env2.schemaId || "$id"]); + this.schemaPath = env2.schemaPath; + this.localRefs = env2.localRefs; + this.meta = env2.meta; + this.$async = schema === null || schema === void 0 ? void 0 : schema.$async; + this.refs = {}; + } +} +compile.SchemaEnv = SchemaEnv; +function compileSchema(sch) { + const _sch = getCompilingSchema.call(this, sch); + if (_sch) + return _sch; + const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId); + const { es5, lines } = this.opts.code; + const { ownProperties } = this.opts; + const gen = new codegen_1$q.CodeGen(this.scope, { es5, lines, ownProperties }); + let _ValidationError; + if (sch.$async) { + _ValidationError = gen.scopeValue("Error", { + ref: validation_error_1.default, + code: (0, codegen_1$q._)`require("ajv/dist/runtime/validation_error").default` + }); + } + const validateName = gen.scopeName("validate"); + sch.validateName = validateName; + const schemaCxt = { + gen, + allErrors: this.opts.allErrors, + data: names_1$5.default.data, + parentData: names_1$5.default.parentData, + parentDataProperty: names_1$5.default.parentDataProperty, + dataNames: [names_1$5.default.data], + dataPathArr: [codegen_1$q.nil], + // TODO can its length be used as dataLevel if nil is removed? + dataLevel: 0, + dataTypes: [], + definedProperties: /* @__PURE__ */ new Set(), + topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true ? { ref: sch.schema, code: (0, codegen_1$q.stringify)(sch.schema) } : { ref: sch.schema }), + validateName, + ValidationError: _ValidationError, + schema: sch.schema, + schemaEnv: sch, + rootId, + baseId: sch.baseId || rootId, + schemaPath: codegen_1$q.nil, + errSchemaPath: sch.schemaPath || (this.opts.jtd ? "" : "#"), + errorPath: (0, codegen_1$q._)`""`, + opts: this.opts, + self: this + }; + let sourceCode; + try { + this._compilations.add(sch); + (0, validate_1$1.validateFunctionCode)(schemaCxt); + gen.optimize(this.opts.code.optimize); + const validateCode = gen.toString(); + sourceCode = `${gen.scopeRefs(names_1$5.default.scope)}return ${validateCode}`; + if (this.opts.code.process) + sourceCode = this.opts.code.process(sourceCode, sch); + const makeValidate = new Function(`${names_1$5.default.self}`, `${names_1$5.default.scope}`, sourceCode); + const validate2 = makeValidate(this, this.scope.get()); + this.scope.value(validateName, { ref: validate2 }); + validate2.errors = null; + validate2.schema = sch.schema; + validate2.schemaEnv = sch; + if (sch.$async) + validate2.$async = true; + if (this.opts.code.source === true) { + validate2.source = { validateName, validateCode, scopeValues: gen._values }; + } + if (this.opts.unevaluated) { + const { props, items: items2 } = schemaCxt; + validate2.evaluated = { + props: props instanceof codegen_1$q.Name ? void 0 : props, + items: items2 instanceof codegen_1$q.Name ? void 0 : items2, + dynamicProps: props instanceof codegen_1$q.Name, + dynamicItems: items2 instanceof codegen_1$q.Name + }; + if (validate2.source) + validate2.source.evaluated = (0, codegen_1$q.stringify)(validate2.evaluated); + } + sch.validate = validate2; + return sch; + } catch (e) { + delete sch.validate; + delete sch.validateName; + if (sourceCode) + this.logger.error("Error compiling schema, function code:", sourceCode); + throw e; + } finally { + this._compilations.delete(sch); + } +} +compile.compileSchema = compileSchema; +function resolveRef(root, baseId, ref2) { + var _a; + ref2 = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref2); + const schOrFunc = root.refs[ref2]; + if (schOrFunc) + return schOrFunc; + let _sch = resolve$1.call(this, root, ref2); + if (_sch === void 0) { + const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref2]; + const { schemaId } = this.opts; + if (schema) + _sch = new SchemaEnv({ schema, schemaId, root, baseId }); + } + if (_sch === void 0) + return; + return root.refs[ref2] = inlineOrCompile.call(this, _sch); +} +compile.resolveRef = resolveRef; +function inlineOrCompile(sch) { + if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs)) + return sch.schema; + return sch.validate ? sch : compileSchema.call(this, sch); +} +function getCompilingSchema(schEnv) { + for (const sch of this._compilations) { + if (sameSchemaEnv(sch, schEnv)) + return sch; + } +} +compile.getCompilingSchema = getCompilingSchema; +function sameSchemaEnv(s1, s2) { + return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId; +} +function resolve$1(root, ref2) { + let sch; + while (typeof (sch = this.refs[ref2]) == "string") + ref2 = sch; + return sch || this.schemas[ref2] || resolveSchema.call(this, root, ref2); +} +function resolveSchema(root, ref2) { + const p = this.opts.uriResolver.parse(ref2); + const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p); + let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, void 0); + if (Object.keys(root.schema).length > 0 && refPath === baseId) { + return getJsonPointer.call(this, p, root); + } + const id2 = (0, resolve_1.normalizeId)(refPath); + const schOrRef = this.refs[id2] || this.schemas[id2]; + if (typeof schOrRef == "string") { + const sch = resolveSchema.call(this, root, schOrRef); + if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object") + return; + return getJsonPointer.call(this, p, sch); + } + if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object") + return; + if (!schOrRef.validate) + compileSchema.call(this, schOrRef); + if (id2 === (0, resolve_1.normalizeId)(ref2)) { + const { schema } = schOrRef; + const { schemaId } = this.opts; + const schId = schema[schemaId]; + if (schId) + baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId); + return new SchemaEnv({ schema, schemaId, root, baseId }); + } + return getJsonPointer.call(this, p, schOrRef); +} +compile.resolveSchema = resolveSchema; +const PREVENT_SCOPE_CHANGE = /* @__PURE__ */ new Set([ + "properties", + "patternProperties", + "enum", + "dependencies", + "definitions" +]); +function getJsonPointer(parsedRef, { baseId, schema, root }) { + var _a; + if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !== "/") + return; + for (const part of parsedRef.fragment.slice(1).split("/")) { + if (typeof schema === "boolean") + return; + const partSchema = schema[(0, util_1$p.unescapeFragment)(part)]; + if (partSchema === void 0) + return; + schema = partSchema; + const schId = typeof schema === "object" && schema[this.opts.schemaId]; + if (!PREVENT_SCOPE_CHANGE.has(part) && schId) { + baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId); + } + } + let env2; + if (typeof schema != "boolean" && schema.$ref && !(0, util_1$p.schemaHasRulesButRef)(schema, this.RULES)) { + const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref); + env2 = resolveSchema.call(this, root, $ref); + } + const { schemaId } = this.opts; + env2 = env2 || new SchemaEnv({ schema, schemaId, root, baseId }); + if (env2.schema !== env2.root.schema) + return env2; + return void 0; +} +const $id$9 = "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#"; +const description = "Meta-schema for $data reference (JSON AnySchema extension proposal)"; +const type$9 = "object"; +const required$1 = [ + "$data" +]; +const properties$a = { + $data: { + type: "string", + anyOf: [ + { + format: "relative-json-pointer" + }, + { + format: "json-pointer" + } + ] + } +}; +const additionalProperties$1 = false; +const require$$9 = { + $id: $id$9, + description, + type: type$9, + required: required$1, + properties: properties$a, + additionalProperties: additionalProperties$1 +}; +var uri$1 = {}; +var fastUri$1 = { exports: {} }; +const isUUID$1 = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu); +const isIPv4$1 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u); +function stringArrayToHexStripped(input) { + let acc = ""; + let code2 = 0; + let i = 0; + for (i = 0; i < input.length; i++) { + code2 = input[i].charCodeAt(0); + if (code2 === 48) { + continue; + } + if (!(code2 >= 48 && code2 <= 57 || code2 >= 65 && code2 <= 70 || code2 >= 97 && code2 <= 102)) { + return ""; + } + acc += input[i]; + break; + } + for (i += 1; i < input.length; i++) { + code2 = input[i].charCodeAt(0); + if (!(code2 >= 48 && code2 <= 57 || code2 >= 65 && code2 <= 70 || code2 >= 97 && code2 <= 102)) { + return ""; + } + acc += input[i]; + } + return acc; +} +const nonSimpleDomain$1 = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u); +function consumeIsZone(buffer) { + buffer.length = 0; + return true; +} +function consumeHextets(buffer, address, output) { + if (buffer.length) { + const hex = stringArrayToHexStripped(buffer); + if (hex !== "") { + address.push(hex); + } else { + output.error = true; + return false; + } + buffer.length = 0; + } + return true; +} +function getIPV6(input) { + let tokenCount = 0; + const output = { error: false, address: "", zone: "" }; + const address = []; + const buffer = []; + let endipv6Encountered = false; + let endIpv6 = false; + let consume = consumeHextets; + for (let i = 0; i < input.length; i++) { + const cursor = input[i]; + if (cursor === "[" || cursor === "]") { + continue; + } + if (cursor === ":") { + if (endipv6Encountered === true) { + endIpv6 = true; + } + if (!consume(buffer, address, output)) { + break; + } + if (++tokenCount > 7) { + output.error = true; + break; + } + if (i > 0 && input[i - 1] === ":") { + endipv6Encountered = true; + } + address.push(":"); + continue; + } else if (cursor === "%") { + if (!consume(buffer, address, output)) { + break; + } + consume = consumeIsZone; + } else { + buffer.push(cursor); + continue; + } + } + if (buffer.length) { + if (consume === consumeIsZone) { + output.zone = buffer.join(""); + } else if (endIpv6) { + address.push(buffer.join("")); + } else { + address.push(stringArrayToHexStripped(buffer)); + } + } + output.address = address.join(""); + return output; +} +function normalizeIPv6$1(host) { + if (findToken(host, ":") < 2) { + return { host, isIPV6: false }; + } + const ipv6 = getIPV6(host); + if (!ipv6.error) { + let newHost = ipv6.address; + let escapedHost = ipv6.address; + if (ipv6.zone) { + newHost += "%" + ipv6.zone; + escapedHost += "%25" + ipv6.zone; + } + return { host: newHost, isIPV6: true, escapedHost }; + } else { + return { host, isIPV6: false }; + } +} +function findToken(str, token) { + let ind = 0; + for (let i = 0; i < str.length; i++) { + if (str[i] === token) ind++; + } + return ind; +} +function removeDotSegments$1(path2) { + let input = path2; + const output = []; + let nextSlash = -1; + let len = 0; + while (len = input.length) { + if (len === 1) { + if (input === ".") { + break; + } else if (input === "/") { + output.push("/"); + break; + } else { + output.push(input); + break; + } + } else if (len === 2) { + if (input[0] === ".") { + if (input[1] === ".") { + break; + } else if (input[1] === "/") { + input = input.slice(2); + continue; + } + } else if (input[0] === "/") { + if (input[1] === "." || input[1] === "/") { + output.push("/"); + break; + } + } + } else if (len === 3) { + if (input === "/..") { + if (output.length !== 0) { + output.pop(); + } + output.push("/"); + break; + } + } + if (input[0] === ".") { + if (input[1] === ".") { + if (input[2] === "/") { + input = input.slice(3); + continue; + } + } else if (input[1] === "/") { + input = input.slice(2); + continue; + } + } else if (input[0] === "/") { + if (input[1] === ".") { + if (input[2] === "/") { + input = input.slice(2); + continue; + } else if (input[2] === ".") { + if (input[3] === "/") { + input = input.slice(3); + if (output.length !== 0) { + output.pop(); + } + continue; + } + } + } + } + if ((nextSlash = input.indexOf("/", 1)) === -1) { + output.push(input); + break; + } else { + output.push(input.slice(0, nextSlash)); + input = input.slice(nextSlash); + } + } + return output.join(""); +} +function normalizeComponentEncoding$1(component, esc) { + const func = esc !== true ? escape : unescape; + if (component.scheme !== void 0) { + component.scheme = func(component.scheme); + } + if (component.userinfo !== void 0) { + component.userinfo = func(component.userinfo); + } + if (component.host !== void 0) { + component.host = func(component.host); + } + if (component.path !== void 0) { + component.path = func(component.path); + } + if (component.query !== void 0) { + component.query = func(component.query); + } + if (component.fragment !== void 0) { + component.fragment = func(component.fragment); + } + return component; +} +function recomposeAuthority$1(component) { + const uriTokens = []; + if (component.userinfo !== void 0) { + uriTokens.push(component.userinfo); + uriTokens.push("@"); + } + if (component.host !== void 0) { + let host = unescape(component.host); + if (!isIPv4$1(host)) { + const ipV6res = normalizeIPv6$1(host); + if (ipV6res.isIPV6 === true) { + host = `[${ipV6res.escapedHost}]`; + } else { + host = component.host; + } + } + uriTokens.push(host); + } + if (typeof component.port === "number" || typeof component.port === "string") { + uriTokens.push(":"); + uriTokens.push(String(component.port)); + } + return uriTokens.length ? uriTokens.join("") : void 0; +} +var utils = { + nonSimpleDomain: nonSimpleDomain$1, + recomposeAuthority: recomposeAuthority$1, + normalizeComponentEncoding: normalizeComponentEncoding$1, + removeDotSegments: removeDotSegments$1, + isIPv4: isIPv4$1, + isUUID: isUUID$1, + normalizeIPv6: normalizeIPv6$1 +}; +const { isUUID } = utils; +const URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu; +function wsIsSecure(wsComponent) { + if (wsComponent.secure === true) { + return true; + } else if (wsComponent.secure === false) { + return false; + } else if (wsComponent.scheme) { + return wsComponent.scheme.length === 3 && (wsComponent.scheme[0] === "w" || wsComponent.scheme[0] === "W") && (wsComponent.scheme[1] === "s" || wsComponent.scheme[1] === "S") && (wsComponent.scheme[2] === "s" || wsComponent.scheme[2] === "S"); + } else { + return false; + } +} +function httpParse(component) { + if (!component.host) { + component.error = component.error || "HTTP URIs must have a host."; + } + return component; +} +function httpSerialize(component) { + const secure = String(component.scheme).toLowerCase() === "https"; + if (component.port === (secure ? 443 : 80) || component.port === "") { + component.port = void 0; + } + if (!component.path) { + component.path = "/"; + } + return component; +} +function wsParse(wsComponent) { + wsComponent.secure = wsIsSecure(wsComponent); + wsComponent.resourceName = (wsComponent.path || "/") + (wsComponent.query ? "?" + wsComponent.query : ""); + wsComponent.path = void 0; + wsComponent.query = void 0; + return wsComponent; +} +function wsSerialize(wsComponent) { + if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === "") { + wsComponent.port = void 0; + } + if (typeof wsComponent.secure === "boolean") { + wsComponent.scheme = wsComponent.secure ? "wss" : "ws"; + wsComponent.secure = void 0; + } + if (wsComponent.resourceName) { + const [path2, query] = wsComponent.resourceName.split("?"); + wsComponent.path = path2 && path2 !== "/" ? path2 : void 0; + wsComponent.query = query; + wsComponent.resourceName = void 0; + } + wsComponent.fragment = void 0; + return wsComponent; +} +function urnParse(urnComponent, options) { + if (!urnComponent.path) { + urnComponent.error = "URN can not be parsed"; + return urnComponent; + } + const matches = urnComponent.path.match(URN_REG); + if (matches) { + const scheme = options.scheme || urnComponent.scheme || "urn"; + urnComponent.nid = matches[1].toLowerCase(); + urnComponent.nss = matches[2]; + const urnScheme = `${scheme}:${options.nid || urnComponent.nid}`; + const schemeHandler = getSchemeHandler$1(urnScheme); + urnComponent.path = void 0; + if (schemeHandler) { + urnComponent = schemeHandler.parse(urnComponent, options); + } + } else { + urnComponent.error = urnComponent.error || "URN can not be parsed."; + } + return urnComponent; +} +function urnSerialize(urnComponent, options) { + if (urnComponent.nid === void 0) { + throw new Error("URN without nid cannot be serialized"); + } + const scheme = options.scheme || urnComponent.scheme || "urn"; + const nid = urnComponent.nid.toLowerCase(); + const urnScheme = `${scheme}:${options.nid || nid}`; + const schemeHandler = getSchemeHandler$1(urnScheme); + if (schemeHandler) { + urnComponent = schemeHandler.serialize(urnComponent, options); + } + const uriComponent = urnComponent; + const nss = urnComponent.nss; + uriComponent.path = `${nid || options.nid}:${nss}`; + options.skipEscape = true; + return uriComponent; +} +function urnuuidParse(urnComponent, options) { + const uuidComponent = urnComponent; + uuidComponent.uuid = uuidComponent.nss; + uuidComponent.nss = void 0; + if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) { + uuidComponent.error = uuidComponent.error || "UUID is not valid."; + } + return uuidComponent; +} +function urnuuidSerialize(uuidComponent) { + const urnComponent = uuidComponent; + urnComponent.nss = (uuidComponent.uuid || "").toLowerCase(); + return urnComponent; +} +const http = ( + /** @type {SchemeHandler} */ + { + scheme: "http", + domainHost: true, + parse: httpParse, + serialize: httpSerialize + } +); +const https = ( + /** @type {SchemeHandler} */ + { + scheme: "https", + domainHost: http.domainHost, + parse: httpParse, + serialize: httpSerialize + } +); +const ws = ( + /** @type {SchemeHandler} */ + { + scheme: "ws", + domainHost: true, + parse: wsParse, + serialize: wsSerialize + } +); +const wss = ( + /** @type {SchemeHandler} */ + { + scheme: "wss", + domainHost: ws.domainHost, + parse: ws.parse, + serialize: ws.serialize + } +); +const urn = ( + /** @type {SchemeHandler} */ + { + scheme: "urn", + parse: urnParse, + serialize: urnSerialize, + skipNormalize: true + } +); +const urnuuid = ( + /** @type {SchemeHandler} */ + { + scheme: "urn:uuid", + parse: urnuuidParse, + serialize: urnuuidSerialize, + skipNormalize: true + } +); +const SCHEMES$1 = ( + /** @type {Record} */ + { + http, + https, + ws, + wss, + urn, + "urn:uuid": urnuuid + } +); +Object.setPrototypeOf(SCHEMES$1, null); +function getSchemeHandler$1(scheme) { + return scheme && (SCHEMES$1[ + /** @type {SchemeName} */ + scheme + ] || SCHEMES$1[ + /** @type {SchemeName} */ + scheme.toLowerCase() + ]) || void 0; +} +var schemes = { + SCHEMES: SCHEMES$1, + getSchemeHandler: getSchemeHandler$1 +}; +const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = utils; +const { SCHEMES, getSchemeHandler } = schemes; +function normalize(uri2, options) { + if (typeof uri2 === "string") { + uri2 = /** @type {T} */ + serialize(parse$7(uri2, options), options); + } else if (typeof uri2 === "object") { + uri2 = /** @type {T} */ + parse$7(serialize(uri2, options), options); + } + return uri2; +} +function resolve(baseURI, relativeURI, options) { + const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" }; + const resolved = resolveComponent(parse$7(baseURI, schemelessOptions), parse$7(relativeURI, schemelessOptions), schemelessOptions, true); + schemelessOptions.skipEscape = true; + return serialize(resolved, schemelessOptions); +} +function resolveComponent(base, relative, options, skipNormalization) { + const target = {}; + if (!skipNormalization) { + base = parse$7(serialize(base, options), options); + relative = parse$7(serialize(relative, options), options); + } + options = options || {}; + if (!options.tolerant && relative.scheme) { + target.scheme = relative.scheme; + target.userinfo = relative.userinfo; + target.host = relative.host; + target.port = relative.port; + target.path = removeDotSegments(relative.path || ""); + target.query = relative.query; + } else { + if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) { + target.userinfo = relative.userinfo; + target.host = relative.host; + target.port = relative.port; + target.path = removeDotSegments(relative.path || ""); + target.query = relative.query; + } else { + if (!relative.path) { + target.path = base.path; + if (relative.query !== void 0) { + target.query = relative.query; + } else { + target.query = base.query; + } + } else { + if (relative.path[0] === "/") { + target.path = removeDotSegments(relative.path); + } else { + if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) { + target.path = "/" + relative.path; + } else if (!base.path) { + target.path = relative.path; + } else { + target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path; + } + target.path = removeDotSegments(target.path); + } + target.query = relative.query; + } + target.userinfo = base.userinfo; + target.host = base.host; + target.port = base.port; + } + target.scheme = base.scheme; + } + target.fragment = relative.fragment; + return target; +} +function equal$2(uriA, uriB, options) { + if (typeof uriA === "string") { + uriA = unescape(uriA); + uriA = serialize(normalizeComponentEncoding(parse$7(uriA, options), true), { ...options, skipEscape: true }); + } else if (typeof uriA === "object") { + uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true }); + } + if (typeof uriB === "string") { + uriB = unescape(uriB); + uriB = serialize(normalizeComponentEncoding(parse$7(uriB, options), true), { ...options, skipEscape: true }); + } else if (typeof uriB === "object") { + uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true }); + } + return uriA.toLowerCase() === uriB.toLowerCase(); +} +function serialize(cmpts, opts) { + const component = { + host: cmpts.host, + scheme: cmpts.scheme, + userinfo: cmpts.userinfo, + port: cmpts.port, + path: cmpts.path, + query: cmpts.query, + nid: cmpts.nid, + nss: cmpts.nss, + uuid: cmpts.uuid, + fragment: cmpts.fragment, + reference: cmpts.reference, + resourceName: cmpts.resourceName, + secure: cmpts.secure, + error: "" + }; + const options = Object.assign({}, opts); + const uriTokens = []; + const schemeHandler = getSchemeHandler(options.scheme || component.scheme); + if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options); + if (component.path !== void 0) { + if (!options.skipEscape) { + component.path = escape(component.path); + if (component.scheme !== void 0) { + component.path = component.path.split("%3A").join(":"); + } + } else { + component.path = unescape(component.path); + } + } + if (options.reference !== "suffix" && component.scheme) { + uriTokens.push(component.scheme, ":"); + } + const authority = recomposeAuthority(component); + if (authority !== void 0) { + if (options.reference !== "suffix") { + uriTokens.push("//"); + } + uriTokens.push(authority); + if (component.path && component.path[0] !== "/") { + uriTokens.push("/"); + } + } + if (component.path !== void 0) { + let s = component.path; + if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) { + s = removeDotSegments(s); + } + if (authority === void 0 && s[0] === "/" && s[1] === "/") { + s = "/%2F" + s.slice(2); + } + uriTokens.push(s); + } + if (component.query !== void 0) { + uriTokens.push("?", component.query); + } + if (component.fragment !== void 0) { + uriTokens.push("#", component.fragment); + } + return uriTokens.join(""); +} +const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u; +function parse$7(uri2, opts) { + const options = Object.assign({}, opts); + const parsed = { + scheme: void 0, + userinfo: void 0, + host: "", + port: void 0, + path: "", + query: void 0, + fragment: void 0 + }; + let isIP = false; + if (options.reference === "suffix") { + if (options.scheme) { + uri2 = options.scheme + ":" + uri2; + } else { + uri2 = "//" + uri2; + } + } + const matches = uri2.match(URI_PARSE); + if (matches) { + parsed.scheme = matches[1]; + parsed.userinfo = matches[3]; + parsed.host = matches[4]; + parsed.port = parseInt(matches[5], 10); + parsed.path = matches[6] || ""; + parsed.query = matches[7]; + parsed.fragment = matches[8]; + if (isNaN(parsed.port)) { + parsed.port = matches[5]; + } + if (parsed.host) { + const ipv4result = isIPv4(parsed.host); + if (ipv4result === false) { + const ipv6result = normalizeIPv6(parsed.host); + parsed.host = ipv6result.host.toLowerCase(); + isIP = ipv6result.isIPV6; + } else { + isIP = true; + } + } + if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) { + parsed.reference = "same-document"; + } else if (parsed.scheme === void 0) { + parsed.reference = "relative"; + } else if (parsed.fragment === void 0) { + parsed.reference = "absolute"; + } else { + parsed.reference = "uri"; + } + if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) { + parsed.error = parsed.error || "URI is not a " + options.reference + " reference."; + } + const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme); + if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) { + if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) { + try { + parsed.host = URL.domainToASCII(parsed.host.toLowerCase()); + } catch (e) { + parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e; + } + } + } + if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) { + if (uri2.indexOf("%") !== -1) { + if (parsed.scheme !== void 0) { + parsed.scheme = unescape(parsed.scheme); + } + if (parsed.host !== void 0) { + parsed.host = unescape(parsed.host); + } + } + if (parsed.path) { + parsed.path = escape(unescape(parsed.path)); + } + if (parsed.fragment) { + parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment)); + } + } + if (schemeHandler && schemeHandler.parse) { + schemeHandler.parse(parsed, options); + } + } else { + parsed.error = parsed.error || "URI can not be parsed."; + } + return parsed; +} +const fastUri = { + SCHEMES, + normalize, + resolve, + resolveComponent, + equal: equal$2, + serialize, + parse: parse$7 +}; +fastUri$1.exports = fastUri; +fastUri$1.exports.default = fastUri; +fastUri$1.exports.fastUri = fastUri; +var fastUriExports = fastUri$1.exports; +Object.defineProperty(uri$1, "__esModule", { value: true }); +const uri = fastUriExports; +uri.code = 'require("ajv/dist/runtime/uri").default'; +uri$1.default = uri; +(function(exports$1) { + Object.defineProperty(exports$1, "__esModule", { value: true }); + exports$1.CodeGen = exports$1.Name = exports$1.nil = exports$1.stringify = exports$1.str = exports$1._ = exports$1.KeywordCxt = void 0; + var validate_12 = validate; + Object.defineProperty(exports$1, "KeywordCxt", { enumerable: true, get: function() { + return validate_12.KeywordCxt; + } }); + var codegen_12 = codegen; + Object.defineProperty(exports$1, "_", { enumerable: true, get: function() { + return codegen_12._; + } }); + Object.defineProperty(exports$1, "str", { enumerable: true, get: function() { + return codegen_12.str; + } }); + Object.defineProperty(exports$1, "stringify", { enumerable: true, get: function() { + return codegen_12.stringify; + } }); + Object.defineProperty(exports$1, "nil", { enumerable: true, get: function() { + return codegen_12.nil; + } }); + Object.defineProperty(exports$1, "Name", { enumerable: true, get: function() { + return codegen_12.Name; + } }); + Object.defineProperty(exports$1, "CodeGen", { enumerable: true, get: function() { + return codegen_12.CodeGen; + } }); + const validation_error_12 = validation_error; + const ref_error_12 = ref_error; + const rules_12 = rules; + const compile_12 = compile; + const codegen_2 = codegen; + const resolve_12 = resolve$2; + const dataType_12 = dataType; + const util_12 = util; + const $dataRefSchema = require$$9; + const uri_1 = uri$1; + const defaultRegExp = (str, flags) => new RegExp(str, flags); + defaultRegExp.code = "new RegExp"; + const META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"]; + const EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([ + "validate", + "serialize", + "parse", + "wrapper", + "root", + "schema", + "keyword", + "pattern", + "formats", + "validate$data", + "func", + "obj", + "Error" + ]); + const removedOptions = { + errorDataPath: "", + format: "`validateFormats: false` can be used instead.", + nullable: '"nullable" keyword is supported by default.', + jsonPointers: "Deprecated jsPropertySyntax can be used instead.", + extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.", + missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.", + processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`", + sourceCode: "Use option `code: {source: true}`", + strictDefaults: "It is default now, see option `strict`.", + strictKeywords: "It is default now, see option `strict`.", + uniqueItems: '"uniqueItems" keyword is always validated.', + unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).", + cache: "Map is used as cache, schema object as key.", + serialize: "Map is used as cache, schema object as key.", + ajvErrors: "It is default now." + }; + const deprecatedOptions = { + ignoreKeywordsWithRef: "", + jsPropertySyntax: "", + unicode: '"minLength"/"maxLength" account for unicode characters by default.' + }; + const MAX_EXPRESSION = 200; + function requiredOptions(o) { + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0; + const s = o.strict; + const _optz = (_a = o.code) === null || _a === void 0 ? void 0 : _a.optimize; + const optimize = _optz === true || _optz === void 0 ? 1 : _optz || 0; + const regExp = (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp; + const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default; + return { + strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0 ? _f : true, + strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0 ? _h : true, + strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0 ? _k : "log", + strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0 ? _m : "log", + strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0 ? _p : false, + code: o.code ? { ...o.code, optimize, regExp } : { optimize, regExp }, + loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION, + loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION, + meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true, + messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true, + inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true, + schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : "$id", + addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true, + validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true, + validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true, + unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true, + int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true, + uriResolver + }; + } + class Ajv { + constructor(opts = {}) { + this.schemas = {}; + this.refs = {}; + this.formats = {}; + this._compilations = /* @__PURE__ */ new Set(); + this._loading = {}; + this._cache = /* @__PURE__ */ new Map(); + opts = this.opts = { ...opts, ...requiredOptions(opts) }; + const { es5, lines } = this.opts.code; + this.scope = new codegen_2.ValueScope({ scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines }); + this.logger = getLogger(opts.logger); + const formatOpt = opts.validateFormats; + opts.validateFormats = false; + this.RULES = (0, rules_12.getRules)(); + checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED"); + checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn"); + this._metaOpts = getMetaSchemaOptions.call(this); + if (opts.formats) + addInitialFormats.call(this); + this._addVocabularies(); + this._addDefaultMetaSchema(); + if (opts.keywords) + addInitialKeywords.call(this, opts.keywords); + if (typeof opts.meta == "object") + this.addMetaSchema(opts.meta); + addInitialSchemas.call(this); + opts.validateFormats = formatOpt; + } + _addVocabularies() { + this.addKeyword("$async"); + } + _addDefaultMetaSchema() { + const { $data, meta, schemaId } = this.opts; + let _dataRefSchema = $dataRefSchema; + if (schemaId === "id") { + _dataRefSchema = { ...$dataRefSchema }; + _dataRefSchema.id = _dataRefSchema.$id; + delete _dataRefSchema.$id; + } + if (meta && $data) + this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false); + } + defaultMeta() { + const { meta, schemaId } = this.opts; + return this.opts.defaultMeta = typeof meta == "object" ? meta[schemaId] || meta : void 0; + } + validate(schemaKeyRef, data) { + let v; + if (typeof schemaKeyRef == "string") { + v = this.getSchema(schemaKeyRef); + if (!v) + throw new Error(`no schema with key or ref "${schemaKeyRef}"`); + } else { + v = this.compile(schemaKeyRef); + } + const valid2 = v(data); + if (!("$async" in v)) + this.errors = v.errors; + return valid2; + } + compile(schema, _meta) { + const sch = this._addSchema(schema, _meta); + return sch.validate || this._compileSchemaEnv(sch); + } + compileAsync(schema, meta) { + if (typeof this.opts.loadSchema != "function") { + throw new Error("options.loadSchema should be a function"); + } + const { loadSchema } = this.opts; + return runCompileAsync.call(this, schema, meta); + async function runCompileAsync(_schema, _meta) { + await loadMetaSchema.call(this, _schema.$schema); + const sch = this._addSchema(_schema, _meta); + return sch.validate || _compileAsync.call(this, sch); + } + async function loadMetaSchema($ref) { + if ($ref && !this.getSchema($ref)) { + await runCompileAsync.call(this, { $ref }, true); + } + } + async function _compileAsync(sch) { + try { + return this._compileSchemaEnv(sch); + } catch (e) { + if (!(e instanceof ref_error_12.default)) + throw e; + checkLoaded.call(this, e); + await loadMissingSchema.call(this, e.missingSchema); + return _compileAsync.call(this, sch); + } + } + function checkLoaded({ missingSchema: ref2, missingRef }) { + if (this.refs[ref2]) { + throw new Error(`AnySchema ${ref2} is loaded but ${missingRef} cannot be resolved`); + } + } + async function loadMissingSchema(ref2) { + const _schema = await _loadSchema.call(this, ref2); + if (!this.refs[ref2]) + await loadMetaSchema.call(this, _schema.$schema); + if (!this.refs[ref2]) + this.addSchema(_schema, ref2, meta); + } + async function _loadSchema(ref2) { + const p = this._loading[ref2]; + if (p) + return p; + try { + return await (this._loading[ref2] = loadSchema(ref2)); + } finally { + delete this._loading[ref2]; + } + } + } + // Adds schema to the instance + addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) { + if (Array.isArray(schema)) { + for (const sch of schema) + this.addSchema(sch, void 0, _meta, _validateSchema); + return this; + } + let id2; + if (typeof schema === "object") { + const { schemaId } = this.opts; + id2 = schema[schemaId]; + if (id2 !== void 0 && typeof id2 != "string") { + throw new Error(`schema ${schemaId} must be string`); + } + } + key = (0, resolve_12.normalizeId)(key || id2); + this._checkUnique(key); + this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true); + return this; + } + // Add schema that will be used to validate other schemas + // options in META_IGNORE_OPTIONS are alway set to false + addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) { + this.addSchema(schema, key, true, _validateSchema); + return this; + } + // Validate schema against its meta-schema + validateSchema(schema, throwOrLogError) { + if (typeof schema == "boolean") + return true; + let $schema2; + $schema2 = schema.$schema; + if ($schema2 !== void 0 && typeof $schema2 != "string") { + throw new Error("$schema must be a string"); + } + $schema2 = $schema2 || this.opts.defaultMeta || this.defaultMeta(); + if (!$schema2) { + this.logger.warn("meta-schema not available"); + this.errors = null; + return true; + } + const valid2 = this.validate($schema2, schema); + if (!valid2 && throwOrLogError) { + const message = "schema is invalid: " + this.errorsText(); + if (this.opts.validateSchema === "log") + this.logger.error(message); + else + throw new Error(message); + } + return valid2; + } + // Get compiled schema by `key` or `ref`. + // (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id) + getSchema(keyRef) { + let sch; + while (typeof (sch = getSchEnv.call(this, keyRef)) == "string") + keyRef = sch; + if (sch === void 0) { + const { schemaId } = this.opts; + const root = new compile_12.SchemaEnv({ schema: {}, schemaId }); + sch = compile_12.resolveSchema.call(this, root, keyRef); + if (!sch) + return; + this.refs[keyRef] = sch; + } + return sch.validate || this._compileSchemaEnv(sch); + } + // Remove cached schema(s). + // If no parameter is passed all schemas but meta-schemas are removed. + // If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed. + // Even if schema is referenced by other schemas it still can be removed as other schemas have local references. + removeSchema(schemaKeyRef) { + if (schemaKeyRef instanceof RegExp) { + this._removeAllSchemas(this.schemas, schemaKeyRef); + this._removeAllSchemas(this.refs, schemaKeyRef); + return this; + } + switch (typeof schemaKeyRef) { + case "undefined": + this._removeAllSchemas(this.schemas); + this._removeAllSchemas(this.refs); + this._cache.clear(); + return this; + case "string": { + const sch = getSchEnv.call(this, schemaKeyRef); + if (typeof sch == "object") + this._cache.delete(sch.schema); + delete this.schemas[schemaKeyRef]; + delete this.refs[schemaKeyRef]; + return this; + } + case "object": { + const cacheKey = schemaKeyRef; + this._cache.delete(cacheKey); + let id2 = schemaKeyRef[this.opts.schemaId]; + if (id2) { + id2 = (0, resolve_12.normalizeId)(id2); + delete this.schemas[id2]; + delete this.refs[id2]; + } + return this; + } + default: + throw new Error("ajv.removeSchema: invalid parameter"); + } + } + // add "vocabulary" - a collection of keywords + addVocabulary(definitions2) { + for (const def2 of definitions2) + this.addKeyword(def2); + return this; + } + addKeyword(kwdOrDef, def2) { + let keyword2; + if (typeof kwdOrDef == "string") { + keyword2 = kwdOrDef; + if (typeof def2 == "object") { + this.logger.warn("these parameters are deprecated, see docs for addKeyword"); + def2.keyword = keyword2; + } + } else if (typeof kwdOrDef == "object" && def2 === void 0) { + def2 = kwdOrDef; + keyword2 = def2.keyword; + if (Array.isArray(keyword2) && !keyword2.length) { + throw new Error("addKeywords: keyword must be string or non-empty array"); + } + } else { + throw new Error("invalid addKeywords parameters"); + } + checkKeyword.call(this, keyword2, def2); + if (!def2) { + (0, util_12.eachItem)(keyword2, (kwd) => addRule.call(this, kwd)); + return this; + } + keywordMetaschema.call(this, def2); + const definition = { + ...def2, + type: (0, dataType_12.getJSONTypes)(def2.type), + schemaType: (0, dataType_12.getJSONTypes)(def2.schemaType) + }; + (0, util_12.eachItem)(keyword2, definition.type.length === 0 ? (k) => addRule.call(this, k, definition) : (k) => definition.type.forEach((t2) => addRule.call(this, k, definition, t2))); + return this; + } + getKeyword(keyword2) { + const rule = this.RULES.all[keyword2]; + return typeof rule == "object" ? rule.definition : !!rule; + } + // Remove keyword + removeKeyword(keyword2) { + const { RULES } = this; + delete RULES.keywords[keyword2]; + delete RULES.all[keyword2]; + for (const group of RULES.rules) { + const i = group.rules.findIndex((rule) => rule.keyword === keyword2); + if (i >= 0) + group.rules.splice(i, 1); + } + return this; + } + // Add format + addFormat(name, format2) { + if (typeof format2 == "string") + format2 = new RegExp(format2); + this.formats[name] = format2; + return this; + } + errorsText(errors2 = this.errors, { separator = ", ", dataVar = "data" } = {}) { + if (!errors2 || errors2.length === 0) + return "No errors"; + return errors2.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg); + } + $dataMetaSchema(metaSchema2, keywordsJsonPointers) { + const rules2 = this.RULES.all; + metaSchema2 = JSON.parse(JSON.stringify(metaSchema2)); + for (const jsonPointer of keywordsJsonPointers) { + const segments = jsonPointer.split("/").slice(1); + let keywords = metaSchema2; + for (const seg of segments) + keywords = keywords[seg]; + for (const key in rules2) { + const rule = rules2[key]; + if (typeof rule != "object") + continue; + const { $data } = rule.definition; + const schema = keywords[key]; + if ($data && schema) + keywords[key] = schemaOrData(schema); + } + } + return metaSchema2; + } + _removeAllSchemas(schemas, regex) { + for (const keyRef in schemas) { + const sch = schemas[keyRef]; + if (!regex || regex.test(keyRef)) { + if (typeof sch == "string") { + delete schemas[keyRef]; + } else if (sch && !sch.meta) { + this._cache.delete(sch.schema); + delete schemas[keyRef]; + } + } + } + } + _addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) { + let id2; + const { schemaId } = this.opts; + if (typeof schema == "object") { + id2 = schema[schemaId]; + } else { + if (this.opts.jtd) + throw new Error("schema must be object"); + else if (typeof schema != "boolean") + throw new Error("schema must be object or boolean"); + } + let sch = this._cache.get(schema); + if (sch !== void 0) + return sch; + baseId = (0, resolve_12.normalizeId)(id2 || baseId); + const localRefs = resolve_12.getSchemaRefs.call(this, schema, baseId); + sch = new compile_12.SchemaEnv({ schema, schemaId, meta, baseId, localRefs }); + this._cache.set(sch.schema, sch); + if (addSchema && !baseId.startsWith("#")) { + if (baseId) + this._checkUnique(baseId); + this.refs[baseId] = sch; + } + if (validateSchema) + this.validateSchema(schema, true); + return sch; + } + _checkUnique(id2) { + if (this.schemas[id2] || this.refs[id2]) { + throw new Error(`schema with key or id "${id2}" already exists`); + } + } + _compileSchemaEnv(sch) { + if (sch.meta) + this._compileMetaSchema(sch); + else + compile_12.compileSchema.call(this, sch); + if (!sch.validate) + throw new Error("ajv implementation error"); + return sch.validate; + } + _compileMetaSchema(sch) { + const currentOpts = this.opts; + this.opts = this._metaOpts; + try { + compile_12.compileSchema.call(this, sch); + } finally { + this.opts = currentOpts; + } + } + } + Ajv.ValidationError = validation_error_12.default; + Ajv.MissingRefError = ref_error_12.default; + exports$1.default = Ajv; + function checkOptions(checkOpts, options, msg, log = "error") { + for (const key in checkOpts) { + const opt = key; + if (opt in options) + this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`); + } + } + function getSchEnv(keyRef) { + keyRef = (0, resolve_12.normalizeId)(keyRef); + return this.schemas[keyRef] || this.refs[keyRef]; + } + function addInitialSchemas() { + const optsSchemas = this.opts.schemas; + if (!optsSchemas) + return; + if (Array.isArray(optsSchemas)) + this.addSchema(optsSchemas); + else + for (const key in optsSchemas) + this.addSchema(optsSchemas[key], key); + } + function addInitialFormats() { + for (const name in this.opts.formats) { + const format2 = this.opts.formats[name]; + if (format2) + this.addFormat(name, format2); + } + } + function addInitialKeywords(defs) { + if (Array.isArray(defs)) { + this.addVocabulary(defs); + return; + } + this.logger.warn("keywords option as map is deprecated, pass array"); + for (const keyword2 in defs) { + const def2 = defs[keyword2]; + if (!def2.keyword) + def2.keyword = keyword2; + this.addKeyword(def2); + } + } + function getMetaSchemaOptions() { + const metaOpts = { ...this.opts }; + for (const opt of META_IGNORE_OPTIONS) + delete metaOpts[opt]; + return metaOpts; + } + const noLogs = { log() { + }, warn() { + }, error() { + } }; + function getLogger(logger) { + if (logger === false) + return noLogs; + if (logger === void 0) + return console; + if (logger.log && logger.warn && logger.error) + return logger; + throw new Error("logger must implement log, warn and error methods"); + } + const KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i; + function checkKeyword(keyword2, def2) { + const { RULES } = this; + (0, util_12.eachItem)(keyword2, (kwd) => { + if (RULES.keywords[kwd]) + throw new Error(`Keyword ${kwd} is already defined`); + if (!KEYWORD_NAME.test(kwd)) + throw new Error(`Keyword ${kwd} has invalid name`); + }); + if (!def2) + return; + if (def2.$data && !("code" in def2 || "validate" in def2)) { + throw new Error('$data keyword must have "code" or "validate" function'); + } + } + function addRule(keyword2, definition, dataType2) { + var _a; + const post = definition === null || definition === void 0 ? void 0 : definition.post; + if (dataType2 && post) + throw new Error('keyword with "post" flag cannot have "type"'); + const { RULES } = this; + let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t2 }) => t2 === dataType2); + if (!ruleGroup) { + ruleGroup = { type: dataType2, rules: [] }; + RULES.rules.push(ruleGroup); + } + RULES.keywords[keyword2] = true; + if (!definition) + return; + const rule = { + keyword: keyword2, + definition: { + ...definition, + type: (0, dataType_12.getJSONTypes)(definition.type), + schemaType: (0, dataType_12.getJSONTypes)(definition.schemaType) + } + }; + if (definition.before) + addBeforeRule.call(this, ruleGroup, rule, definition.before); + else + ruleGroup.rules.push(rule); + RULES.all[keyword2] = rule; + (_a = definition.implements) === null || _a === void 0 ? void 0 : _a.forEach((kwd) => this.addKeyword(kwd)); + } + function addBeforeRule(ruleGroup, rule, before) { + const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before); + if (i >= 0) { + ruleGroup.rules.splice(i, 0, rule); + } else { + ruleGroup.rules.push(rule); + this.logger.warn(`rule ${before} is not defined`); + } + } + function keywordMetaschema(def2) { + let { metaSchema: metaSchema2 } = def2; + if (metaSchema2 === void 0) + return; + if (def2.$data && this.opts.$data) + metaSchema2 = schemaOrData(metaSchema2); + def2.validateSchema = this.compile(metaSchema2, true); + } + const $dataRef = { + $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#" + }; + function schemaOrData(schema) { + return { anyOf: [schema, $dataRef] }; + } +})(core$3); +var draft2020 = {}; +var core$2 = {}; +var id = {}; +Object.defineProperty(id, "__esModule", { value: true }); +const def$B = { + keyword: "id", + code() { + throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID'); + } +}; +id.default = def$B; +var ref = {}; +Object.defineProperty(ref, "__esModule", { value: true }); +ref.callRef = ref.getValidate = void 0; +const ref_error_1$1 = ref_error; +const code_1$8 = code; +const codegen_1$p = codegen; +const names_1$4 = names$1; +const compile_1$2 = compile; +const util_1$o = util; +const def$A = { + keyword: "$ref", + schemaType: "string", + code(cxt) { + const { gen, schema: $ref, it } = cxt; + const { baseId, schemaEnv: env2, validateName, opts, self } = it; + const { root } = env2; + if (($ref === "#" || $ref === "#/") && baseId === root.baseId) + return callRootRef(); + const schOrEnv = compile_1$2.resolveRef.call(self, root, baseId, $ref); + if (schOrEnv === void 0) + throw new ref_error_1$1.default(it.opts.uriResolver, baseId, $ref); + if (schOrEnv instanceof compile_1$2.SchemaEnv) + return callValidate(schOrEnv); + return inlineRefSchema(schOrEnv); + function callRootRef() { + if (env2 === root) + return callRef(cxt, validateName, env2, env2.$async); + const rootName = gen.scopeValue("root", { ref: root }); + return callRef(cxt, (0, codegen_1$p._)`${rootName}.validate`, root, root.$async); + } + function callValidate(sch) { + const v = getValidate(cxt, sch); + callRef(cxt, v, sch, sch.$async); + } + function inlineRefSchema(sch) { + const schName = gen.scopeValue("schema", opts.code.source === true ? { ref: sch, code: (0, codegen_1$p.stringify)(sch) } : { ref: sch }); + const valid2 = gen.name("valid"); + const schCxt = cxt.subschema({ + schema: sch, + dataTypes: [], + schemaPath: codegen_1$p.nil, + topSchemaRef: schName, + errSchemaPath: $ref + }, valid2); + cxt.mergeEvaluated(schCxt); + cxt.ok(valid2); + } + } +}; +function getValidate(cxt, sch) { + const { gen } = cxt; + return sch.validate ? gen.scopeValue("validate", { ref: sch.validate }) : (0, codegen_1$p._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`; +} +ref.getValidate = getValidate; +function callRef(cxt, v, sch, $async) { + const { gen, it } = cxt; + const { allErrors, schemaEnv: env2, opts } = it; + const passCxt = opts.passContext ? names_1$4.default.this : codegen_1$p.nil; + if ($async) + callAsyncRef(); + else + callSyncRef(); + function callAsyncRef() { + if (!env2.$async) + throw new Error("async schema referenced by sync schema"); + const valid2 = gen.let("valid"); + gen.try(() => { + gen.code((0, codegen_1$p._)`await ${(0, code_1$8.callValidateCode)(cxt, v, passCxt)}`); + addEvaluatedFrom(v); + if (!allErrors) + gen.assign(valid2, true); + }, (e) => { + gen.if((0, codegen_1$p._)`!(${e} instanceof ${it.ValidationError})`, () => gen.throw(e)); + addErrorsFrom(e); + if (!allErrors) + gen.assign(valid2, false); + }); + cxt.ok(valid2); + } + function callSyncRef() { + cxt.result((0, code_1$8.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v)); + } + function addErrorsFrom(source) { + const errs = (0, codegen_1$p._)`${source}.errors`; + gen.assign(names_1$4.default.vErrors, (0, codegen_1$p._)`${names_1$4.default.vErrors} === null ? ${errs} : ${names_1$4.default.vErrors}.concat(${errs})`); + gen.assign(names_1$4.default.errors, (0, codegen_1$p._)`${names_1$4.default.vErrors}.length`); + } + function addEvaluatedFrom(source) { + var _a; + if (!it.opts.unevaluated) + return; + const schEvaluated = (_a = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a === void 0 ? void 0 : _a.evaluated; + if (it.props !== true) { + if (schEvaluated && !schEvaluated.dynamicProps) { + if (schEvaluated.props !== void 0) { + it.props = util_1$o.mergeEvaluated.props(gen, schEvaluated.props, it.props); + } + } else { + const props = gen.var("props", (0, codegen_1$p._)`${source}.evaluated.props`); + it.props = util_1$o.mergeEvaluated.props(gen, props, it.props, codegen_1$p.Name); + } + } + if (it.items !== true) { + if (schEvaluated && !schEvaluated.dynamicItems) { + if (schEvaluated.items !== void 0) { + it.items = util_1$o.mergeEvaluated.items(gen, schEvaluated.items, it.items); + } + } else { + const items2 = gen.var("items", (0, codegen_1$p._)`${source}.evaluated.items`); + it.items = util_1$o.mergeEvaluated.items(gen, items2, it.items, codegen_1$p.Name); + } + } + } +} +ref.callRef = callRef; +ref.default = def$A; +Object.defineProperty(core$2, "__esModule", { value: true }); +const id_1 = id; +const ref_1$2 = ref; +const core$1 = [ + "$schema", + "$id", + "$defs", + "$vocabulary", + { keyword: "$comment" }, + "definitions", + id_1.default, + ref_1$2.default +]; +core$2.default = core$1; +var validation$2 = {}; +var limitNumber = {}; +Object.defineProperty(limitNumber, "__esModule", { value: true }); +const codegen_1$o = codegen; +const ops = codegen_1$o.operators; +const KWDs = { + maximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT }, + minimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT }, + exclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE }, + exclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE } +}; +const error$k = { + message: ({ keyword: keyword2, schemaCode }) => (0, codegen_1$o.str)`must be ${KWDs[keyword2].okStr} ${schemaCode}`, + params: ({ keyword: keyword2, schemaCode }) => (0, codegen_1$o._)`{comparison: ${KWDs[keyword2].okStr}, limit: ${schemaCode}}` +}; +const def$z = { + keyword: Object.keys(KWDs), + type: "number", + schemaType: "number", + $data: true, + error: error$k, + code(cxt) { + const { keyword: keyword2, data, schemaCode } = cxt; + cxt.fail$data((0, codegen_1$o._)`${data} ${KWDs[keyword2].fail} ${schemaCode} || isNaN(${data})`); + } +}; +limitNumber.default = def$z; +var multipleOf = {}; +Object.defineProperty(multipleOf, "__esModule", { value: true }); +const codegen_1$n = codegen; +const error$j = { + message: ({ schemaCode }) => (0, codegen_1$n.str)`must be multiple of ${schemaCode}`, + params: ({ schemaCode }) => (0, codegen_1$n._)`{multipleOf: ${schemaCode}}` +}; +const def$y = { + keyword: "multipleOf", + type: "number", + schemaType: "number", + $data: true, + error: error$j, + code(cxt) { + const { gen, data, schemaCode, it } = cxt; + const prec = it.opts.multipleOfPrecision; + const res = gen.let("res"); + const invalid = prec ? (0, codegen_1$n._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1$n._)`${res} !== parseInt(${res})`; + cxt.fail$data((0, codegen_1$n._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`); + } +}; +multipleOf.default = def$y; +var limitLength = {}; +var ucs2length$1 = {}; +Object.defineProperty(ucs2length$1, "__esModule", { value: true }); +function ucs2length(str) { + const len = str.length; + let length = 0; + let pos = 0; + let value; + while (pos < len) { + length++; + value = str.charCodeAt(pos++); + if (value >= 55296 && value <= 56319 && pos < len) { + value = str.charCodeAt(pos); + if ((value & 64512) === 56320) + pos++; + } + } + return length; +} +ucs2length$1.default = ucs2length; +ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default'; +Object.defineProperty(limitLength, "__esModule", { value: true }); +const codegen_1$m = codegen; +const util_1$n = util; +const ucs2length_1 = ucs2length$1; +const error$i = { + message({ keyword: keyword2, schemaCode }) { + const comp = keyword2 === "maxLength" ? "more" : "fewer"; + return (0, codegen_1$m.str)`must NOT have ${comp} than ${schemaCode} characters`; + }, + params: ({ schemaCode }) => (0, codegen_1$m._)`{limit: ${schemaCode}}` +}; +const def$x = { + keyword: ["maxLength", "minLength"], + type: "string", + schemaType: "number", + $data: true, + error: error$i, + code(cxt) { + const { keyword: keyword2, data, schemaCode, it } = cxt; + const op = keyword2 === "maxLength" ? codegen_1$m.operators.GT : codegen_1$m.operators.LT; + const len = it.opts.unicode === false ? (0, codegen_1$m._)`${data}.length` : (0, codegen_1$m._)`${(0, util_1$n.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`; + cxt.fail$data((0, codegen_1$m._)`${len} ${op} ${schemaCode}`); + } +}; +limitLength.default = def$x; +var pattern = {}; +Object.defineProperty(pattern, "__esModule", { value: true }); +const code_1$7 = code; +const util_1$m = util; +const codegen_1$l = codegen; +const error$h = { + message: ({ schemaCode }) => (0, codegen_1$l.str)`must match pattern "${schemaCode}"`, + params: ({ schemaCode }) => (0, codegen_1$l._)`{pattern: ${schemaCode}}` +}; +const def$w = { + keyword: "pattern", + type: "string", + schemaType: "string", + $data: true, + error: error$h, + code(cxt) { + const { gen, data, $data, schema, schemaCode, it } = cxt; + const u = it.opts.unicodeRegExp ? "u" : ""; + if ($data) { + const { regExp } = it.opts.code; + const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1$l._)`new RegExp` : (0, util_1$m.useFunc)(gen, regExp); + const valid2 = gen.let("valid"); + gen.try(() => gen.assign(valid2, (0, codegen_1$l._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid2, false)); + cxt.fail$data((0, codegen_1$l._)`!${valid2}`); + } else { + const regExp = (0, code_1$7.usePattern)(cxt, schema); + cxt.fail$data((0, codegen_1$l._)`!${regExp}.test(${data})`); + } + } +}; +pattern.default = def$w; +var limitProperties = {}; +Object.defineProperty(limitProperties, "__esModule", { value: true }); +const codegen_1$k = codegen; +const error$g = { + message({ keyword: keyword2, schemaCode }) { + const comp = keyword2 === "maxProperties" ? "more" : "fewer"; + return (0, codegen_1$k.str)`must NOT have ${comp} than ${schemaCode} properties`; + }, + params: ({ schemaCode }) => (0, codegen_1$k._)`{limit: ${schemaCode}}` +}; +const def$v = { + keyword: ["maxProperties", "minProperties"], + type: "object", + schemaType: "number", + $data: true, + error: error$g, + code(cxt) { + const { keyword: keyword2, data, schemaCode } = cxt; + const op = keyword2 === "maxProperties" ? codegen_1$k.operators.GT : codegen_1$k.operators.LT; + cxt.fail$data((0, codegen_1$k._)`Object.keys(${data}).length ${op} ${schemaCode}`); + } +}; +limitProperties.default = def$v; +var required = {}; +Object.defineProperty(required, "__esModule", { value: true }); +const code_1$6 = code; +const codegen_1$j = codegen; +const util_1$l = util; +const error$f = { + message: ({ params: { missingProperty } }) => (0, codegen_1$j.str)`must have required property '${missingProperty}'`, + params: ({ params: { missingProperty } }) => (0, codegen_1$j._)`{missingProperty: ${missingProperty}}` +}; +const def$u = { + keyword: "required", + type: "object", + schemaType: "array", + $data: true, + error: error$f, + code(cxt) { + const { gen, schema, schemaCode, data, $data, it } = cxt; + const { opts } = it; + if (!$data && schema.length === 0) + return; + const useLoop = schema.length >= opts.loopRequired; + if (it.allErrors) + allErrorsMode(); + else + exitOnErrorMode(); + if (opts.strictRequired) { + const props = cxt.parentSchema.properties; + const { definedProperties } = cxt.it; + for (const requiredKey of schema) { + if ((props === null || props === void 0 ? void 0 : props[requiredKey]) === void 0 && !definedProperties.has(requiredKey)) { + const schemaPath = it.schemaEnv.baseId + it.errSchemaPath; + const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`; + (0, util_1$l.checkStrictMode)(it, msg, it.opts.strictRequired); + } + } + } + function allErrorsMode() { + if (useLoop || $data) { + cxt.block$data(codegen_1$j.nil, loopAllRequired); + } else { + for (const prop of schema) { + (0, code_1$6.checkReportMissingProp)(cxt, prop); + } + } + } + function exitOnErrorMode() { + const missing = gen.let("missing"); + if (useLoop || $data) { + const valid2 = gen.let("valid", true); + cxt.block$data(valid2, () => loopUntilMissing(missing, valid2)); + cxt.ok(valid2); + } else { + gen.if((0, code_1$6.checkMissingProp)(cxt, schema, missing)); + (0, code_1$6.reportMissingProp)(cxt, missing); + gen.else(); + } + } + function loopAllRequired() { + gen.forOf("prop", schemaCode, (prop) => { + cxt.setParams({ missingProperty: prop }); + gen.if((0, code_1$6.noPropertyInData)(gen, data, prop, opts.ownProperties), () => cxt.error()); + }); + } + function loopUntilMissing(missing, valid2) { + cxt.setParams({ missingProperty: missing }); + gen.forOf(missing, schemaCode, () => { + gen.assign(valid2, (0, code_1$6.propertyInData)(gen, data, missing, opts.ownProperties)); + gen.if((0, codegen_1$j.not)(valid2), () => { + cxt.error(); + gen.break(); + }); + }, codegen_1$j.nil); + } + } +}; +required.default = def$u; +var limitItems = {}; +Object.defineProperty(limitItems, "__esModule", { value: true }); +const codegen_1$i = codegen; +const error$e = { + message({ keyword: keyword2, schemaCode }) { + const comp = keyword2 === "maxItems" ? "more" : "fewer"; + return (0, codegen_1$i.str)`must NOT have ${comp} than ${schemaCode} items`; + }, + params: ({ schemaCode }) => (0, codegen_1$i._)`{limit: ${schemaCode}}` +}; +const def$t = { + keyword: ["maxItems", "minItems"], + type: "array", + schemaType: "number", + $data: true, + error: error$e, + code(cxt) { + const { keyword: keyword2, data, schemaCode } = cxt; + const op = keyword2 === "maxItems" ? codegen_1$i.operators.GT : codegen_1$i.operators.LT; + cxt.fail$data((0, codegen_1$i._)`${data}.length ${op} ${schemaCode}`); + } +}; +limitItems.default = def$t; +var uniqueItems = {}; +var equal$1 = {}; +Object.defineProperty(equal$1, "__esModule", { value: true }); +const equal2 = fastDeepEqual; +equal2.code = 'require("ajv/dist/runtime/equal").default'; +equal$1.default = equal2; +Object.defineProperty(uniqueItems, "__esModule", { value: true }); +const dataType_1 = dataType; +const codegen_1$h = codegen; +const util_1$k = util; +const equal_1$2 = equal$1; +const error$d = { + message: ({ params: { i, j } }) => (0, codegen_1$h.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`, + params: ({ params: { i, j } }) => (0, codegen_1$h._)`{i: ${i}, j: ${j}}` +}; +const def$s = { + keyword: "uniqueItems", + type: "array", + schemaType: "boolean", + $data: true, + error: error$d, + code(cxt) { + const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt; + if (!$data && !schema) + return; + const valid2 = gen.let("valid"); + const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : []; + cxt.block$data(valid2, validateUniqueItems, (0, codegen_1$h._)`${schemaCode} === false`); + cxt.ok(valid2); + function validateUniqueItems() { + const i = gen.let("i", (0, codegen_1$h._)`${data}.length`); + const j = gen.let("j"); + cxt.setParams({ i, j }); + gen.assign(valid2, true); + gen.if((0, codegen_1$h._)`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j)); + } + function canOptimize() { + return itemTypes.length > 0 && !itemTypes.some((t2) => t2 === "object" || t2 === "array"); + } + function loopN(i, j) { + const item = gen.name("item"); + const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong); + const indices = gen.const("indices", (0, codegen_1$h._)`{}`); + gen.for((0, codegen_1$h._)`;${i}--;`, () => { + gen.let(item, (0, codegen_1$h._)`${data}[${i}]`); + gen.if(wrongType, (0, codegen_1$h._)`continue`); + if (itemTypes.length > 1) + gen.if((0, codegen_1$h._)`typeof ${item} == "string"`, (0, codegen_1$h._)`${item} += "_"`); + gen.if((0, codegen_1$h._)`typeof ${indices}[${item}] == "number"`, () => { + gen.assign(j, (0, codegen_1$h._)`${indices}[${item}]`); + cxt.error(); + gen.assign(valid2, false).break(); + }).code((0, codegen_1$h._)`${indices}[${item}] = ${i}`); + }); + } + function loopN2(i, j) { + const eql = (0, util_1$k.useFunc)(gen, equal_1$2.default); + const outer = gen.name("outer"); + gen.label(outer).for((0, codegen_1$h._)`;${i}--;`, () => gen.for((0, codegen_1$h._)`${j} = ${i}; ${j}--;`, () => gen.if((0, codegen_1$h._)`${eql}(${data}[${i}], ${data}[${j}])`, () => { + cxt.error(); + gen.assign(valid2, false).break(outer); + }))); + } + } +}; +uniqueItems.default = def$s; +var _const = {}; +Object.defineProperty(_const, "__esModule", { value: true }); +const codegen_1$g = codegen; +const util_1$j = util; +const equal_1$1 = equal$1; +const error$c = { + message: "must be equal to constant", + params: ({ schemaCode }) => (0, codegen_1$g._)`{allowedValue: ${schemaCode}}` +}; +const def$r = { + keyword: "const", + $data: true, + error: error$c, + code(cxt) { + const { gen, data, $data, schemaCode, schema } = cxt; + if ($data || schema && typeof schema == "object") { + cxt.fail$data((0, codegen_1$g._)`!${(0, util_1$j.useFunc)(gen, equal_1$1.default)}(${data}, ${schemaCode})`); + } else { + cxt.fail((0, codegen_1$g._)`${schema} !== ${data}`); + } + } +}; +_const.default = def$r; +var _enum = {}; +Object.defineProperty(_enum, "__esModule", { value: true }); +const codegen_1$f = codegen; +const util_1$i = util; +const equal_1 = equal$1; +const error$b = { + message: "must be equal to one of the allowed values", + params: ({ schemaCode }) => (0, codegen_1$f._)`{allowedValues: ${schemaCode}}` +}; +const def$q = { + keyword: "enum", + schemaType: "array", + $data: true, + error: error$b, + code(cxt) { + const { gen, data, $data, schema, schemaCode, it } = cxt; + if (!$data && schema.length === 0) + throw new Error("enum must have non-empty array"); + const useLoop = schema.length >= it.opts.loopEnum; + let eql; + const getEql = () => eql !== null && eql !== void 0 ? eql : eql = (0, util_1$i.useFunc)(gen, equal_1.default); + let valid2; + if (useLoop || $data) { + valid2 = gen.let("valid"); + cxt.block$data(valid2, loopEnum); + } else { + if (!Array.isArray(schema)) + throw new Error("ajv implementation error"); + const vSchema = gen.const("vSchema", schemaCode); + valid2 = (0, codegen_1$f.or)(...schema.map((_x, i) => equalCode(vSchema, i))); + } + cxt.pass(valid2); + function loopEnum() { + gen.assign(valid2, false); + gen.forOf("v", schemaCode, (v) => gen.if((0, codegen_1$f._)`${getEql()}(${data}, ${v})`, () => gen.assign(valid2, true).break())); + } + function equalCode(vSchema, i) { + const sch = schema[i]; + return typeof sch === "object" && sch !== null ? (0, codegen_1$f._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1$f._)`${data} === ${sch}`; + } + } +}; +_enum.default = def$q; +Object.defineProperty(validation$2, "__esModule", { value: true }); +const limitNumber_1 = limitNumber; +const multipleOf_1 = multipleOf; +const limitLength_1 = limitLength; +const pattern_1 = pattern; +const limitProperties_1 = limitProperties; +const required_1 = required; +const limitItems_1 = limitItems; +const uniqueItems_1 = uniqueItems; +const const_1 = _const; +const enum_1 = _enum; +const validation$1 = [ + // number + limitNumber_1.default, + multipleOf_1.default, + // string + limitLength_1.default, + pattern_1.default, + // object + limitProperties_1.default, + required_1.default, + // array + limitItems_1.default, + uniqueItems_1.default, + // any + { keyword: "type", schemaType: ["string", "array"] }, + { keyword: "nullable", schemaType: "boolean" }, + const_1.default, + enum_1.default +]; +validation$2.default = validation$1; +var applicator$1 = {}; +var additionalItems = {}; +Object.defineProperty(additionalItems, "__esModule", { value: true }); +additionalItems.validateAdditionalItems = void 0; +const codegen_1$e = codegen; +const util_1$h = util; +const error$a = { + message: ({ params: { len } }) => (0, codegen_1$e.str)`must NOT have more than ${len} items`, + params: ({ params: { len } }) => (0, codegen_1$e._)`{limit: ${len}}` +}; +const def$p = { + keyword: "additionalItems", + type: "array", + schemaType: ["boolean", "object"], + before: "uniqueItems", + error: error$a, + code(cxt) { + const { parentSchema, it } = cxt; + const { items: items2 } = parentSchema; + if (!Array.isArray(items2)) { + (0, util_1$h.checkStrictMode)(it, '"additionalItems" is ignored when "items" is not an array of schemas'); + return; + } + validateAdditionalItems(cxt, items2); + } +}; +function validateAdditionalItems(cxt, items2) { + const { gen, schema, data, keyword: keyword2, it } = cxt; + it.items = true; + const len = gen.const("len", (0, codegen_1$e._)`${data}.length`); + if (schema === false) { + cxt.setParams({ len: items2.length }); + cxt.pass((0, codegen_1$e._)`${len} <= ${items2.length}`); + } else if (typeof schema == "object" && !(0, util_1$h.alwaysValidSchema)(it, schema)) { + const valid2 = gen.var("valid", (0, codegen_1$e._)`${len} <= ${items2.length}`); + gen.if((0, codegen_1$e.not)(valid2), () => validateItems(valid2)); + cxt.ok(valid2); + } + function validateItems(valid2) { + gen.forRange("i", items2.length, len, (i) => { + cxt.subschema({ keyword: keyword2, dataProp: i, dataPropType: util_1$h.Type.Num }, valid2); + if (!it.allErrors) + gen.if((0, codegen_1$e.not)(valid2), () => gen.break()); + }); + } +} +additionalItems.validateAdditionalItems = validateAdditionalItems; +additionalItems.default = def$p; +var prefixItems = {}; +var items = {}; +Object.defineProperty(items, "__esModule", { value: true }); +items.validateTuple = void 0; +const codegen_1$d = codegen; +const util_1$g = util; +const code_1$5 = code; +const def$o = { + keyword: "items", + type: "array", + schemaType: ["object", "array", "boolean"], + before: "uniqueItems", + code(cxt) { + const { schema, it } = cxt; + if (Array.isArray(schema)) + return validateTuple(cxt, "additionalItems", schema); + it.items = true; + if ((0, util_1$g.alwaysValidSchema)(it, schema)) + return; + cxt.ok((0, code_1$5.validateArray)(cxt)); + } +}; +function validateTuple(cxt, extraItems, schArr = cxt.schema) { + const { gen, parentSchema, data, keyword: keyword2, it } = cxt; + checkStrictTuple(parentSchema); + if (it.opts.unevaluated && schArr.length && it.items !== true) { + it.items = util_1$g.mergeEvaluated.items(gen, schArr.length, it.items); + } + const valid2 = gen.name("valid"); + const len = gen.const("len", (0, codegen_1$d._)`${data}.length`); + schArr.forEach((sch, i) => { + if ((0, util_1$g.alwaysValidSchema)(it, sch)) + return; + gen.if((0, codegen_1$d._)`${len} > ${i}`, () => cxt.subschema({ + keyword: keyword2, + schemaProp: i, + dataProp: i + }, valid2)); + cxt.ok(valid2); + }); + function checkStrictTuple(sch) { + const { opts, errSchemaPath } = it; + const l = schArr.length; + const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false); + if (opts.strictTuples && !fullTuple) { + const msg = `"${keyword2}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`; + (0, util_1$g.checkStrictMode)(it, msg, opts.strictTuples); + } + } +} +items.validateTuple = validateTuple; +items.default = def$o; +Object.defineProperty(prefixItems, "__esModule", { value: true }); +const items_1$1 = items; +const def$n = { + keyword: "prefixItems", + type: "array", + schemaType: ["array"], + before: "uniqueItems", + code: (cxt) => (0, items_1$1.validateTuple)(cxt, "items") +}; +prefixItems.default = def$n; +var items2020 = {}; +Object.defineProperty(items2020, "__esModule", { value: true }); +const codegen_1$c = codegen; +const util_1$f = util; +const code_1$4 = code; +const additionalItems_1$1 = additionalItems; +const error$9 = { + message: ({ params: { len } }) => (0, codegen_1$c.str)`must NOT have more than ${len} items`, + params: ({ params: { len } }) => (0, codegen_1$c._)`{limit: ${len}}` +}; +const def$m = { + keyword: "items", + type: "array", + schemaType: ["object", "boolean"], + before: "uniqueItems", + error: error$9, + code(cxt) { + const { schema, parentSchema, it } = cxt; + const { prefixItems: prefixItems2 } = parentSchema; + it.items = true; + if ((0, util_1$f.alwaysValidSchema)(it, schema)) + return; + if (prefixItems2) + (0, additionalItems_1$1.validateAdditionalItems)(cxt, prefixItems2); + else + cxt.ok((0, code_1$4.validateArray)(cxt)); + } +}; +items2020.default = def$m; +var contains = {}; +Object.defineProperty(contains, "__esModule", { value: true }); +const codegen_1$b = codegen; +const util_1$e = util; +const error$8 = { + message: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1$b.str)`must contain at least ${min} valid item(s)` : (0, codegen_1$b.str)`must contain at least ${min} and no more than ${max} valid item(s)`, + params: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1$b._)`{minContains: ${min}}` : (0, codegen_1$b._)`{minContains: ${min}, maxContains: ${max}}` +}; +const def$l = { + keyword: "contains", + type: "array", + schemaType: ["object", "boolean"], + before: "uniqueItems", + trackErrors: true, + error: error$8, + code(cxt) { + const { gen, schema, parentSchema, data, it } = cxt; + let min; + let max; + const { minContains, maxContains } = parentSchema; + if (it.opts.next) { + min = minContains === void 0 ? 1 : minContains; + max = maxContains; + } else { + min = 1; + } + const len = gen.const("len", (0, codegen_1$b._)`${data}.length`); + cxt.setParams({ min, max }); + if (max === void 0 && min === 0) { + (0, util_1$e.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`); + return; + } + if (max !== void 0 && min > max) { + (0, util_1$e.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`); + cxt.fail(); + return; + } + if ((0, util_1$e.alwaysValidSchema)(it, schema)) { + let cond = (0, codegen_1$b._)`${len} >= ${min}`; + if (max !== void 0) + cond = (0, codegen_1$b._)`${cond} && ${len} <= ${max}`; + cxt.pass(cond); + return; + } + it.items = true; + const valid2 = gen.name("valid"); + if (max === void 0 && min === 1) { + validateItems(valid2, () => gen.if(valid2, () => gen.break())); + } else if (min === 0) { + gen.let(valid2, true); + if (max !== void 0) + gen.if((0, codegen_1$b._)`${data}.length > 0`, validateItemsWithCount); + } else { + gen.let(valid2, false); + validateItemsWithCount(); + } + cxt.result(valid2, () => cxt.reset()); + function validateItemsWithCount() { + const schValid = gen.name("_valid"); + const count = gen.let("count", 0); + validateItems(schValid, () => gen.if(schValid, () => checkLimits(count))); + } + function validateItems(_valid, block) { + gen.forRange("i", 0, len, (i) => { + cxt.subschema({ + keyword: "contains", + dataProp: i, + dataPropType: util_1$e.Type.Num, + compositeRule: true + }, _valid); + block(); + }); + } + function checkLimits(count) { + gen.code((0, codegen_1$b._)`${count}++`); + if (max === void 0) { + gen.if((0, codegen_1$b._)`${count} >= ${min}`, () => gen.assign(valid2, true).break()); + } else { + gen.if((0, codegen_1$b._)`${count} > ${max}`, () => gen.assign(valid2, false).break()); + if (min === 1) + gen.assign(valid2, true); + else + gen.if((0, codegen_1$b._)`${count} >= ${min}`, () => gen.assign(valid2, true)); + } + } + } +}; +contains.default = def$l; +var dependencies = {}; +(function(exports$1) { + Object.defineProperty(exports$1, "__esModule", { value: true }); + exports$1.validateSchemaDeps = exports$1.validatePropertyDeps = exports$1.error = void 0; + const codegen_12 = codegen; + const util_12 = util; + const code_12 = code; + exports$1.error = { + message: ({ params: { property, depsCount, deps } }) => { + const property_ies = depsCount === 1 ? "property" : "properties"; + return (0, codegen_12.str)`must have ${property_ies} ${deps} when property ${property} is present`; + }, + params: ({ params: { property, depsCount, deps, missingProperty } }) => (0, codegen_12._)`{property: ${property}, + missingProperty: ${missingProperty}, + depsCount: ${depsCount}, + deps: ${deps}}` + // TODO change to reference + }; + const def2 = { + keyword: "dependencies", + type: "object", + schemaType: "object", + error: exports$1.error, + code(cxt) { + const [propDeps, schDeps] = splitDependencies(cxt); + validatePropertyDeps(cxt, propDeps); + validateSchemaDeps(cxt, schDeps); + } + }; + function splitDependencies({ schema }) { + const propertyDeps = {}; + const schemaDeps = {}; + for (const key in schema) { + if (key === "__proto__") + continue; + const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps; + deps[key] = schema[key]; + } + return [propertyDeps, schemaDeps]; + } + function validatePropertyDeps(cxt, propertyDeps = cxt.schema) { + const { gen, data, it } = cxt; + if (Object.keys(propertyDeps).length === 0) + return; + const missing = gen.let("missing"); + for (const prop in propertyDeps) { + const deps = propertyDeps[prop]; + if (deps.length === 0) + continue; + const hasProperty2 = (0, code_12.propertyInData)(gen, data, prop, it.opts.ownProperties); + cxt.setParams({ + property: prop, + depsCount: deps.length, + deps: deps.join(", ") + }); + if (it.allErrors) { + gen.if(hasProperty2, () => { + for (const depProp of deps) { + (0, code_12.checkReportMissingProp)(cxt, depProp); + } + }); + } else { + gen.if((0, codegen_12._)`${hasProperty2} && (${(0, code_12.checkMissingProp)(cxt, deps, missing)})`); + (0, code_12.reportMissingProp)(cxt, missing); + gen.else(); + } + } + } + exports$1.validatePropertyDeps = validatePropertyDeps; + function validateSchemaDeps(cxt, schemaDeps = cxt.schema) { + const { gen, data, keyword: keyword2, it } = cxt; + const valid2 = gen.name("valid"); + for (const prop in schemaDeps) { + if ((0, util_12.alwaysValidSchema)(it, schemaDeps[prop])) + continue; + gen.if( + (0, code_12.propertyInData)(gen, data, prop, it.opts.ownProperties), + () => { + const schCxt = cxt.subschema({ keyword: keyword2, schemaProp: prop }, valid2); + cxt.mergeValidEvaluated(schCxt, valid2); + }, + () => gen.var(valid2, true) + // TODO var + ); + cxt.ok(valid2); + } + } + exports$1.validateSchemaDeps = validateSchemaDeps; + exports$1.default = def2; +})(dependencies); +var propertyNames = {}; +Object.defineProperty(propertyNames, "__esModule", { value: true }); +const codegen_1$a = codegen; +const util_1$d = util; +const error$7 = { + message: "property name must be valid", + params: ({ params }) => (0, codegen_1$a._)`{propertyName: ${params.propertyName}}` +}; +const def$k = { + keyword: "propertyNames", + type: "object", + schemaType: ["object", "boolean"], + error: error$7, + code(cxt) { + const { gen, schema, data, it } = cxt; + if ((0, util_1$d.alwaysValidSchema)(it, schema)) + return; + const valid2 = gen.name("valid"); + gen.forIn("key", data, (key) => { + cxt.setParams({ propertyName: key }); + cxt.subschema({ + keyword: "propertyNames", + data: key, + dataTypes: ["string"], + propertyName: key, + compositeRule: true + }, valid2); + gen.if((0, codegen_1$a.not)(valid2), () => { + cxt.error(true); + if (!it.allErrors) + gen.break(); + }); + }); + cxt.ok(valid2); + } +}; +propertyNames.default = def$k; +var additionalProperties = {}; +Object.defineProperty(additionalProperties, "__esModule", { value: true }); +const code_1$3 = code; +const codegen_1$9 = codegen; +const names_1$3 = names$1; +const util_1$c = util; +const error$6 = { + message: "must NOT have additional properties", + params: ({ params }) => (0, codegen_1$9._)`{additionalProperty: ${params.additionalProperty}}` +}; +const def$j = { + keyword: "additionalProperties", + type: ["object"], + schemaType: ["boolean", "object"], + allowUndefined: true, + trackErrors: true, + error: error$6, + code(cxt) { + const { gen, schema, parentSchema, data, errsCount, it } = cxt; + if (!errsCount) + throw new Error("ajv implementation error"); + const { allErrors, opts } = it; + it.props = true; + if (opts.removeAdditional !== "all" && (0, util_1$c.alwaysValidSchema)(it, schema)) + return; + const props = (0, code_1$3.allSchemaProperties)(parentSchema.properties); + const patProps = (0, code_1$3.allSchemaProperties)(parentSchema.patternProperties); + checkAdditionalProperties(); + cxt.ok((0, codegen_1$9._)`${errsCount} === ${names_1$3.default.errors}`); + function checkAdditionalProperties() { + gen.forIn("key", data, (key) => { + if (!props.length && !patProps.length) + additionalPropertyCode(key); + else + gen.if(isAdditional(key), () => additionalPropertyCode(key)); + }); + } + function isAdditional(key) { + let definedProp; + if (props.length > 8) { + const propsSchema = (0, util_1$c.schemaRefOrVal)(it, parentSchema.properties, "properties"); + definedProp = (0, code_1$3.isOwnProperty)(gen, propsSchema, key); + } else if (props.length) { + definedProp = (0, codegen_1$9.or)(...props.map((p) => (0, codegen_1$9._)`${key} === ${p}`)); + } else { + definedProp = codegen_1$9.nil; + } + if (patProps.length) { + definedProp = (0, codegen_1$9.or)(definedProp, ...patProps.map((p) => (0, codegen_1$9._)`${(0, code_1$3.usePattern)(cxt, p)}.test(${key})`)); + } + return (0, codegen_1$9.not)(definedProp); + } + function deleteAdditional(key) { + gen.code((0, codegen_1$9._)`delete ${data}[${key}]`); + } + function additionalPropertyCode(key) { + if (opts.removeAdditional === "all" || opts.removeAdditional && schema === false) { + deleteAdditional(key); + return; + } + if (schema === false) { + cxt.setParams({ additionalProperty: key }); + cxt.error(); + if (!allErrors) + gen.break(); + return; + } + if (typeof schema == "object" && !(0, util_1$c.alwaysValidSchema)(it, schema)) { + const valid2 = gen.name("valid"); + if (opts.removeAdditional === "failing") { + applyAdditionalSchema(key, valid2, false); + gen.if((0, codegen_1$9.not)(valid2), () => { + cxt.reset(); + deleteAdditional(key); + }); + } else { + applyAdditionalSchema(key, valid2); + if (!allErrors) + gen.if((0, codegen_1$9.not)(valid2), () => gen.break()); + } + } + } + function applyAdditionalSchema(key, valid2, errors2) { + const subschema2 = { + keyword: "additionalProperties", + dataProp: key, + dataPropType: util_1$c.Type.Str + }; + if (errors2 === false) { + Object.assign(subschema2, { + compositeRule: true, + createErrors: false, + allErrors: false + }); + } + cxt.subschema(subschema2, valid2); + } + } +}; +additionalProperties.default = def$j; +var properties$9 = {}; +Object.defineProperty(properties$9, "__esModule", { value: true }); +const validate_1 = validate; +const code_1$2 = code; +const util_1$b = util; +const additionalProperties_1$1 = additionalProperties; +const def$i = { + keyword: "properties", + type: "object", + schemaType: "object", + code(cxt) { + const { gen, schema, parentSchema, data, it } = cxt; + if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === void 0) { + additionalProperties_1$1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1$1.default, "additionalProperties")); + } + const allProps = (0, code_1$2.allSchemaProperties)(schema); + for (const prop of allProps) { + it.definedProperties.add(prop); + } + if (it.opts.unevaluated && allProps.length && it.props !== true) { + it.props = util_1$b.mergeEvaluated.props(gen, (0, util_1$b.toHash)(allProps), it.props); + } + const properties2 = allProps.filter((p) => !(0, util_1$b.alwaysValidSchema)(it, schema[p])); + if (properties2.length === 0) + return; + const valid2 = gen.name("valid"); + for (const prop of properties2) { + if (hasDefault(prop)) { + applyPropertySchema(prop); + } else { + gen.if((0, code_1$2.propertyInData)(gen, data, prop, it.opts.ownProperties)); + applyPropertySchema(prop); + if (!it.allErrors) + gen.else().var(valid2, true); + gen.endIf(); + } + cxt.it.definedProperties.add(prop); + cxt.ok(valid2); + } + function hasDefault(prop) { + return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== void 0; + } + function applyPropertySchema(prop) { + cxt.subschema({ + keyword: "properties", + schemaProp: prop, + dataProp: prop + }, valid2); + } + } +}; +properties$9.default = def$i; +var patternProperties = {}; +Object.defineProperty(patternProperties, "__esModule", { value: true }); +const code_1$1 = code; +const codegen_1$8 = codegen; +const util_1$a = util; +const util_2 = util; +const def$h = { + keyword: "patternProperties", + type: "object", + schemaType: "object", + code(cxt) { + const { gen, schema, data, parentSchema, it } = cxt; + const { opts } = it; + const patterns = (0, code_1$1.allSchemaProperties)(schema); + const alwaysValidPatterns = patterns.filter((p) => (0, util_1$a.alwaysValidSchema)(it, schema[p])); + if (patterns.length === 0 || alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated || it.props === true)) { + return; + } + const checkProperties = opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties; + const valid2 = gen.name("valid"); + if (it.props !== true && !(it.props instanceof codegen_1$8.Name)) { + it.props = (0, util_2.evaluatedPropsToName)(gen, it.props); + } + const { props } = it; + validatePatternProperties(); + function validatePatternProperties() { + for (const pat of patterns) { + if (checkProperties) + checkMatchingProperties(pat); + if (it.allErrors) { + validateProperties(pat); + } else { + gen.var(valid2, true); + validateProperties(pat); + gen.if(valid2); + } + } + } + function checkMatchingProperties(pat) { + for (const prop in checkProperties) { + if (new RegExp(pat).test(prop)) { + (0, util_1$a.checkStrictMode)(it, `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`); + } + } + } + function validateProperties(pat) { + gen.forIn("key", data, (key) => { + gen.if((0, codegen_1$8._)`${(0, code_1$1.usePattern)(cxt, pat)}.test(${key})`, () => { + const alwaysValid = alwaysValidPatterns.includes(pat); + if (!alwaysValid) { + cxt.subschema({ + keyword: "patternProperties", + schemaProp: pat, + dataProp: key, + dataPropType: util_2.Type.Str + }, valid2); + } + if (it.opts.unevaluated && props !== true) { + gen.assign((0, codegen_1$8._)`${props}[${key}]`, true); + } else if (!alwaysValid && !it.allErrors) { + gen.if((0, codegen_1$8.not)(valid2), () => gen.break()); + } + }); + }); + } + } +}; +patternProperties.default = def$h; +var not = {}; +Object.defineProperty(not, "__esModule", { value: true }); +const util_1$9 = util; +const def$g = { + keyword: "not", + schemaType: ["object", "boolean"], + trackErrors: true, + code(cxt) { + const { gen, schema, it } = cxt; + if ((0, util_1$9.alwaysValidSchema)(it, schema)) { + cxt.fail(); + return; + } + const valid2 = gen.name("valid"); + cxt.subschema({ + keyword: "not", + compositeRule: true, + createErrors: false, + allErrors: false + }, valid2); + cxt.failResult(valid2, () => cxt.reset(), () => cxt.error()); + }, + error: { message: "must NOT be valid" } +}; +not.default = def$g; +var anyOf = {}; +Object.defineProperty(anyOf, "__esModule", { value: true }); +const code_1 = code; +const def$f = { + keyword: "anyOf", + schemaType: "array", + trackErrors: true, + code: code_1.validateUnion, + error: { message: "must match a schema in anyOf" } +}; +anyOf.default = def$f; +var oneOf = {}; +Object.defineProperty(oneOf, "__esModule", { value: true }); +const codegen_1$7 = codegen; +const util_1$8 = util; +const error$5 = { + message: "must match exactly one schema in oneOf", + params: ({ params }) => (0, codegen_1$7._)`{passingSchemas: ${params.passing}}` +}; +const def$e = { + keyword: "oneOf", + schemaType: "array", + trackErrors: true, + error: error$5, + code(cxt) { + const { gen, schema, parentSchema, it } = cxt; + if (!Array.isArray(schema)) + throw new Error("ajv implementation error"); + if (it.opts.discriminator && parentSchema.discriminator) + return; + const schArr = schema; + const valid2 = gen.let("valid", false); + const passing = gen.let("passing", null); + const schValid = gen.name("_valid"); + cxt.setParams({ passing }); + gen.block(validateOneOf); + cxt.result(valid2, () => cxt.reset(), () => cxt.error(true)); + function validateOneOf() { + schArr.forEach((sch, i) => { + let schCxt; + if ((0, util_1$8.alwaysValidSchema)(it, sch)) { + gen.var(schValid, true); + } else { + schCxt = cxt.subschema({ + keyword: "oneOf", + schemaProp: i, + compositeRule: true + }, schValid); + } + if (i > 0) { + gen.if((0, codegen_1$7._)`${schValid} && ${valid2}`).assign(valid2, false).assign(passing, (0, codegen_1$7._)`[${passing}, ${i}]`).else(); + } + gen.if(schValid, () => { + gen.assign(valid2, true); + gen.assign(passing, i); + if (schCxt) + cxt.mergeEvaluated(schCxt, codegen_1$7.Name); + }); + }); + } + } +}; +oneOf.default = def$e; +var allOf$1 = {}; +Object.defineProperty(allOf$1, "__esModule", { value: true }); +const util_1$7 = util; +const def$d = { + keyword: "allOf", + schemaType: "array", + code(cxt) { + const { gen, schema, it } = cxt; + if (!Array.isArray(schema)) + throw new Error("ajv implementation error"); + const valid2 = gen.name("valid"); + schema.forEach((sch, i) => { + if ((0, util_1$7.alwaysValidSchema)(it, sch)) + return; + const schCxt = cxt.subschema({ keyword: "allOf", schemaProp: i }, valid2); + cxt.ok(valid2); + cxt.mergeEvaluated(schCxt); + }); + } +}; +allOf$1.default = def$d; +var _if = {}; +Object.defineProperty(_if, "__esModule", { value: true }); +const codegen_1$6 = codegen; +const util_1$6 = util; +const error$4 = { + message: ({ params }) => (0, codegen_1$6.str)`must match "${params.ifClause}" schema`, + params: ({ params }) => (0, codegen_1$6._)`{failingKeyword: ${params.ifClause}}` +}; +const def$c = { + keyword: "if", + schemaType: ["object", "boolean"], + trackErrors: true, + error: error$4, + code(cxt) { + const { gen, parentSchema, it } = cxt; + if (parentSchema.then === void 0 && parentSchema.else === void 0) { + (0, util_1$6.checkStrictMode)(it, '"if" without "then" and "else" is ignored'); + } + const hasThen = hasSchema(it, "then"); + const hasElse = hasSchema(it, "else"); + if (!hasThen && !hasElse) + return; + const valid2 = gen.let("valid", true); + const schValid = gen.name("_valid"); + validateIf(); + cxt.reset(); + if (hasThen && hasElse) { + const ifClause = gen.let("ifClause"); + cxt.setParams({ ifClause }); + gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause)); + } else if (hasThen) { + gen.if(schValid, validateClause("then")); + } else { + gen.if((0, codegen_1$6.not)(schValid), validateClause("else")); + } + cxt.pass(valid2, () => cxt.error(true)); + function validateIf() { + const schCxt = cxt.subschema({ + keyword: "if", + compositeRule: true, + createErrors: false, + allErrors: false + }, schValid); + cxt.mergeEvaluated(schCxt); + } + function validateClause(keyword2, ifClause) { + return () => { + const schCxt = cxt.subschema({ keyword: keyword2 }, schValid); + gen.assign(valid2, schValid); + cxt.mergeValidEvaluated(schCxt, valid2); + if (ifClause) + gen.assign(ifClause, (0, codegen_1$6._)`${keyword2}`); + else + cxt.setParams({ ifClause: keyword2 }); + }; + } + } +}; +function hasSchema(it, keyword2) { + const schema = it.schema[keyword2]; + return schema !== void 0 && !(0, util_1$6.alwaysValidSchema)(it, schema); +} +_if.default = def$c; +var thenElse = {}; +Object.defineProperty(thenElse, "__esModule", { value: true }); +const util_1$5 = util; +const def$b = { + keyword: ["then", "else"], + schemaType: ["object", "boolean"], + code({ keyword: keyword2, parentSchema, it }) { + if (parentSchema.if === void 0) + (0, util_1$5.checkStrictMode)(it, `"${keyword2}" without "if" is ignored`); + } +}; +thenElse.default = def$b; +Object.defineProperty(applicator$1, "__esModule", { value: true }); +const additionalItems_1 = additionalItems; +const prefixItems_1 = prefixItems; +const items_1 = items; +const items2020_1 = items2020; +const contains_1 = contains; +const dependencies_1$2 = dependencies; +const propertyNames_1 = propertyNames; +const additionalProperties_1 = additionalProperties; +const properties_1 = properties$9; +const patternProperties_1 = patternProperties; +const not_1 = not; +const anyOf_1 = anyOf; +const oneOf_1 = oneOf; +const allOf_1 = allOf$1; +const if_1 = _if; +const thenElse_1 = thenElse; +function getApplicator(draft20202 = false) { + const applicator2 = [ + // any + not_1.default, + anyOf_1.default, + oneOf_1.default, + allOf_1.default, + if_1.default, + thenElse_1.default, + // object + propertyNames_1.default, + additionalProperties_1.default, + dependencies_1$2.default, + properties_1.default, + patternProperties_1.default + ]; + if (draft20202) + applicator2.push(prefixItems_1.default, items2020_1.default); + else + applicator2.push(additionalItems_1.default, items_1.default); + applicator2.push(contains_1.default); + return applicator2; +} +applicator$1.default = getApplicator; +var dynamic$1 = {}; +var dynamicAnchor$1 = {}; +Object.defineProperty(dynamicAnchor$1, "__esModule", { value: true }); +dynamicAnchor$1.dynamicAnchor = void 0; +const codegen_1$5 = codegen; +const names_1$2 = names$1; +const compile_1$1 = compile; +const ref_1$1 = ref; +const def$a = { + keyword: "$dynamicAnchor", + schemaType: "string", + code: (cxt) => dynamicAnchor(cxt, cxt.schema) +}; +function dynamicAnchor(cxt, anchor) { + const { gen, it } = cxt; + it.schemaEnv.root.dynamicAnchors[anchor] = true; + const v = (0, codegen_1$5._)`${names_1$2.default.dynamicAnchors}${(0, codegen_1$5.getProperty)(anchor)}`; + const validate2 = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt); + gen.if((0, codegen_1$5._)`!${v}`, () => gen.assign(v, validate2)); +} +dynamicAnchor$1.dynamicAnchor = dynamicAnchor; +function _getValidate(cxt) { + const { schemaEnv, schema, self } = cxt.it; + const { root, baseId, localRefs, meta } = schemaEnv.root; + const { schemaId } = self.opts; + const sch = new compile_1$1.SchemaEnv({ schema, schemaId, root, baseId, localRefs, meta }); + compile_1$1.compileSchema.call(self, sch); + return (0, ref_1$1.getValidate)(cxt, sch); +} +dynamicAnchor$1.default = def$a; +var dynamicRef$1 = {}; +Object.defineProperty(dynamicRef$1, "__esModule", { value: true }); +dynamicRef$1.dynamicRef = void 0; +const codegen_1$4 = codegen; +const names_1$1 = names$1; +const ref_1 = ref; +const def$9 = { + keyword: "$dynamicRef", + schemaType: "string", + code: (cxt) => dynamicRef(cxt, cxt.schema) +}; +function dynamicRef(cxt, ref2) { + const { gen, keyword: keyword2, it } = cxt; + if (ref2[0] !== "#") + throw new Error(`"${keyword2}" only supports hash fragment reference`); + const anchor = ref2.slice(1); + if (it.allErrors) { + _dynamicRef(); + } else { + const valid2 = gen.let("valid", false); + _dynamicRef(valid2); + cxt.ok(valid2); + } + function _dynamicRef(valid2) { + if (it.schemaEnv.root.dynamicAnchors[anchor]) { + const v = gen.let("_v", (0, codegen_1$4._)`${names_1$1.default.dynamicAnchors}${(0, codegen_1$4.getProperty)(anchor)}`); + gen.if(v, _callRef(v, valid2), _callRef(it.validateName, valid2)); + } else { + _callRef(it.validateName, valid2)(); + } + } + function _callRef(validate2, valid2) { + return valid2 ? () => gen.block(() => { + (0, ref_1.callRef)(cxt, validate2); + gen.let(valid2, true); + }) : () => (0, ref_1.callRef)(cxt, validate2); + } +} +dynamicRef$1.dynamicRef = dynamicRef; +dynamicRef$1.default = def$9; +var recursiveAnchor = {}; +Object.defineProperty(recursiveAnchor, "__esModule", { value: true }); +const dynamicAnchor_1$1 = dynamicAnchor$1; +const util_1$4 = util; +const def$8 = { + keyword: "$recursiveAnchor", + schemaType: "boolean", + code(cxt) { + if (cxt.schema) + (0, dynamicAnchor_1$1.dynamicAnchor)(cxt, ""); + else + (0, util_1$4.checkStrictMode)(cxt.it, "$recursiveAnchor: false is ignored"); + } +}; +recursiveAnchor.default = def$8; +var recursiveRef = {}; +Object.defineProperty(recursiveRef, "__esModule", { value: true }); +const dynamicRef_1$1 = dynamicRef$1; +const def$7 = { + keyword: "$recursiveRef", + schemaType: "string", + code: (cxt) => (0, dynamicRef_1$1.dynamicRef)(cxt, cxt.schema) +}; +recursiveRef.default = def$7; +Object.defineProperty(dynamic$1, "__esModule", { value: true }); +const dynamicAnchor_1 = dynamicAnchor$1; +const dynamicRef_1 = dynamicRef$1; +const recursiveAnchor_1 = recursiveAnchor; +const recursiveRef_1 = recursiveRef; +const dynamic = [dynamicAnchor_1.default, dynamicRef_1.default, recursiveAnchor_1.default, recursiveRef_1.default]; +dynamic$1.default = dynamic; +var next$1 = {}; +var dependentRequired = {}; +Object.defineProperty(dependentRequired, "__esModule", { value: true }); +const dependencies_1$1 = dependencies; +const def$6 = { + keyword: "dependentRequired", + type: "object", + schemaType: "object", + error: dependencies_1$1.error, + code: (cxt) => (0, dependencies_1$1.validatePropertyDeps)(cxt) +}; +dependentRequired.default = def$6; +var dependentSchemas = {}; +Object.defineProperty(dependentSchemas, "__esModule", { value: true }); +const dependencies_1 = dependencies; +const def$5 = { + keyword: "dependentSchemas", + type: "object", + schemaType: "object", + code: (cxt) => (0, dependencies_1.validateSchemaDeps)(cxt) +}; +dependentSchemas.default = def$5; +var limitContains = {}; +Object.defineProperty(limitContains, "__esModule", { value: true }); +const util_1$3 = util; +const def$4 = { + keyword: ["maxContains", "minContains"], + type: "array", + schemaType: "number", + code({ keyword: keyword2, parentSchema, it }) { + if (parentSchema.contains === void 0) { + (0, util_1$3.checkStrictMode)(it, `"${keyword2}" without "contains" is ignored`); + } + } +}; +limitContains.default = def$4; +Object.defineProperty(next$1, "__esModule", { value: true }); +const dependentRequired_1 = dependentRequired; +const dependentSchemas_1 = dependentSchemas; +const limitContains_1 = limitContains; +const next = [dependentRequired_1.default, dependentSchemas_1.default, limitContains_1.default]; +next$1.default = next; +var unevaluated$2 = {}; +var unevaluatedProperties = {}; +Object.defineProperty(unevaluatedProperties, "__esModule", { value: true }); +const codegen_1$3 = codegen; +const util_1$2 = util; +const names_1 = names$1; +const error$3 = { + message: "must NOT have unevaluated properties", + params: ({ params }) => (0, codegen_1$3._)`{unevaluatedProperty: ${params.unevaluatedProperty}}` +}; +const def$3 = { + keyword: "unevaluatedProperties", + type: "object", + schemaType: ["boolean", "object"], + trackErrors: true, + error: error$3, + code(cxt) { + const { gen, schema, data, errsCount, it } = cxt; + if (!errsCount) + throw new Error("ajv implementation error"); + const { allErrors, props } = it; + if (props instanceof codegen_1$3.Name) { + gen.if((0, codegen_1$3._)`${props} !== true`, () => gen.forIn("key", data, (key) => gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key)))); + } else if (props !== true) { + gen.forIn("key", data, (key) => props === void 0 ? unevaluatedPropCode(key) : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key))); + } + it.props = true; + cxt.ok((0, codegen_1$3._)`${errsCount} === ${names_1.default.errors}`); + function unevaluatedPropCode(key) { + if (schema === false) { + cxt.setParams({ unevaluatedProperty: key }); + cxt.error(); + if (!allErrors) + gen.break(); + return; + } + if (!(0, util_1$2.alwaysValidSchema)(it, schema)) { + const valid2 = gen.name("valid"); + cxt.subschema({ + keyword: "unevaluatedProperties", + dataProp: key, + dataPropType: util_1$2.Type.Str + }, valid2); + if (!allErrors) + gen.if((0, codegen_1$3.not)(valid2), () => gen.break()); + } + } + function unevaluatedDynamic(evaluatedProps, key) { + return (0, codegen_1$3._)`!${evaluatedProps} || !${evaluatedProps}[${key}]`; + } + function unevaluatedStatic(evaluatedProps, key) { + const ps = []; + for (const p in evaluatedProps) { + if (evaluatedProps[p] === true) + ps.push((0, codegen_1$3._)`${key} !== ${p}`); + } + return (0, codegen_1$3.and)(...ps); + } + } +}; +unevaluatedProperties.default = def$3; +var unevaluatedItems = {}; +Object.defineProperty(unevaluatedItems, "__esModule", { value: true }); +const codegen_1$2 = codegen; +const util_1$1 = util; +const error$2 = { + message: ({ params: { len } }) => (0, codegen_1$2.str)`must NOT have more than ${len} items`, + params: ({ params: { len } }) => (0, codegen_1$2._)`{limit: ${len}}` +}; +const def$2 = { + keyword: "unevaluatedItems", + type: "array", + schemaType: ["boolean", "object"], + error: error$2, + code(cxt) { + const { gen, schema, data, it } = cxt; + const items2 = it.items || 0; + if (items2 === true) + return; + const len = gen.const("len", (0, codegen_1$2._)`${data}.length`); + if (schema === false) { + cxt.setParams({ len: items2 }); + cxt.fail((0, codegen_1$2._)`${len} > ${items2}`); + } else if (typeof schema == "object" && !(0, util_1$1.alwaysValidSchema)(it, schema)) { + const valid2 = gen.var("valid", (0, codegen_1$2._)`${len} <= ${items2}`); + gen.if((0, codegen_1$2.not)(valid2), () => validateItems(valid2, items2)); + cxt.ok(valid2); + } + it.items = true; + function validateItems(valid2, from) { + gen.forRange("i", from, len, (i) => { + cxt.subschema({ keyword: "unevaluatedItems", dataProp: i, dataPropType: util_1$1.Type.Num }, valid2); + if (!it.allErrors) + gen.if((0, codegen_1$2.not)(valid2), () => gen.break()); + }); + } + } +}; +unevaluatedItems.default = def$2; +Object.defineProperty(unevaluated$2, "__esModule", { value: true }); +const unevaluatedProperties_1 = unevaluatedProperties; +const unevaluatedItems_1 = unevaluatedItems; +const unevaluated$1 = [unevaluatedProperties_1.default, unevaluatedItems_1.default]; +unevaluated$2.default = unevaluated$1; +var format$3 = {}; +var format$2 = {}; +Object.defineProperty(format$2, "__esModule", { value: true }); +const codegen_1$1 = codegen; +const error$1 = { + message: ({ schemaCode }) => (0, codegen_1$1.str)`must match format "${schemaCode}"`, + params: ({ schemaCode }) => (0, codegen_1$1._)`{format: ${schemaCode}}` +}; +const def$1 = { + keyword: "format", + type: ["number", "string"], + schemaType: "string", + $data: true, + error: error$1, + code(cxt, ruleType) { + const { gen, data, $data, schema, schemaCode, it } = cxt; + const { opts, errSchemaPath, schemaEnv, self } = it; + if (!opts.validateFormats) + return; + if ($data) + validate$DataFormat(); + else + validateFormat(); + function validate$DataFormat() { + const fmts = gen.scopeValue("formats", { + ref: self.formats, + code: opts.code.formats + }); + const fDef = gen.const("fDef", (0, codegen_1$1._)`${fmts}[${schemaCode}]`); + const fType = gen.let("fType"); + const format2 = gen.let("format"); + gen.if((0, codegen_1$1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1$1._)`${fDef}.type || "string"`).assign(format2, (0, codegen_1$1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1$1._)`"string"`).assign(format2, fDef)); + cxt.fail$data((0, codegen_1$1.or)(unknownFmt(), invalidFmt())); + function unknownFmt() { + if (opts.strictSchema === false) + return codegen_1$1.nil; + return (0, codegen_1$1._)`${schemaCode} && !${format2}`; + } + function invalidFmt() { + const callFormat = schemaEnv.$async ? (0, codegen_1$1._)`(${fDef}.async ? await ${format2}(${data}) : ${format2}(${data}))` : (0, codegen_1$1._)`${format2}(${data})`; + const validData = (0, codegen_1$1._)`(typeof ${format2} == "function" ? ${callFormat} : ${format2}.test(${data}))`; + return (0, codegen_1$1._)`${format2} && ${format2} !== true && ${fType} === ${ruleType} && !${validData}`; + } + } + function validateFormat() { + const formatDef = self.formats[schema]; + if (!formatDef) { + unknownFormat(); + return; + } + if (formatDef === true) + return; + const [fmtType, format2, fmtRef] = getFormat(formatDef); + if (fmtType === ruleType) + cxt.pass(validCondition()); + function unknownFormat() { + if (opts.strictSchema === false) { + self.logger.warn(unknownMsg()); + return; + } + throw new Error(unknownMsg()); + function unknownMsg() { + return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`; + } + } + function getFormat(fmtDef) { + const code2 = fmtDef instanceof RegExp ? (0, codegen_1$1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1$1._)`${opts.code.formats}${(0, codegen_1$1.getProperty)(schema)}` : void 0; + const fmt = gen.scopeValue("formats", { key: schema, ref: fmtDef, code: code2 }); + if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) { + return [fmtDef.type || "string", fmtDef.validate, (0, codegen_1$1._)`${fmt}.validate`]; + } + return ["string", fmtDef, fmt]; + } + function validCondition() { + if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) { + if (!schemaEnv.$async) + throw new Error("async format in sync schema"); + return (0, codegen_1$1._)`await ${fmtRef}(${data})`; + } + return typeof format2 == "function" ? (0, codegen_1$1._)`${fmtRef}(${data})` : (0, codegen_1$1._)`${fmtRef}.test(${data})`; + } + } + } +}; +format$2.default = def$1; +Object.defineProperty(format$3, "__esModule", { value: true }); +const format_1$2 = format$2; +const format$1 = [format_1$2.default]; +format$3.default = format$1; +var metadata$1 = {}; +Object.defineProperty(metadata$1, "__esModule", { value: true }); +metadata$1.contentVocabulary = metadata$1.metadataVocabulary = void 0; +metadata$1.metadataVocabulary = [ + "title", + "description", + "default", + "deprecated", + "readOnly", + "writeOnly", + "examples" +]; +metadata$1.contentVocabulary = [ + "contentMediaType", + "contentEncoding", + "contentSchema" +]; +Object.defineProperty(draft2020, "__esModule", { value: true }); +const core_1$1 = core$2; +const validation_1$1 = validation$2; +const applicator_1$1 = applicator$1; +const dynamic_1 = dynamic$1; +const next_1 = next$1; +const unevaluated_1 = unevaluated$2; +const format_1$1 = format$3; +const metadata_1$1 = metadata$1; +const draft2020Vocabularies = [ + dynamic_1.default, + core_1$1.default, + validation_1$1.default, + (0, applicator_1$1.default)(true), + format_1$1.default, + metadata_1$1.metadataVocabulary, + metadata_1$1.contentVocabulary, + next_1.default, + unevaluated_1.default +]; +draft2020.default = draft2020Vocabularies; +var discriminator = {}; +var types = {}; +Object.defineProperty(types, "__esModule", { value: true }); +types.DiscrError = void 0; +var DiscrError; +(function(DiscrError2) { + DiscrError2["Tag"] = "tag"; + DiscrError2["Mapping"] = "mapping"; +})(DiscrError || (types.DiscrError = DiscrError = {})); +Object.defineProperty(discriminator, "__esModule", { value: true }); +const codegen_1 = codegen; +const types_1 = types; +const compile_1 = compile; +const ref_error_1 = ref_error; +const util_1 = util; +const error = { + message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag ? `tag "${tagName}" must be string` : `value of tag "${tagName}" must be in oneOf`, + params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}` +}; +const def = { + keyword: "discriminator", + type: "object", + schemaType: "object", + error, + code(cxt) { + const { gen, data, schema, parentSchema, it } = cxt; + const { oneOf: oneOf2 } = parentSchema; + if (!it.opts.discriminator) { + throw new Error("discriminator: requires discriminator option"); + } + const tagName = schema.propertyName; + if (typeof tagName != "string") + throw new Error("discriminator: requires propertyName"); + if (schema.mapping) + throw new Error("discriminator: mapping is not supported"); + if (!oneOf2) + throw new Error("discriminator: requires oneOf keyword"); + const valid2 = gen.let("valid", false); + const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`); + gen.if((0, codegen_1._)`typeof ${tag} == "string"`, () => validateMapping(), () => cxt.error(false, { discrError: types_1.DiscrError.Tag, tag, tagName })); + cxt.ok(valid2); + function validateMapping() { + const mapping = getMapping(); + gen.if(false); + for (const tagValue in mapping) { + gen.elseIf((0, codegen_1._)`${tag} === ${tagValue}`); + gen.assign(valid2, applyTagSchema(mapping[tagValue])); + } + gen.else(); + cxt.error(false, { discrError: types_1.DiscrError.Mapping, tag, tagName }); + gen.endIf(); + } + function applyTagSchema(schemaProp) { + const _valid = gen.name("valid"); + const schCxt = cxt.subschema({ keyword: "oneOf", schemaProp }, _valid); + cxt.mergeEvaluated(schCxt, codegen_1.Name); + return _valid; + } + function getMapping() { + var _a; + const oneOfMapping = {}; + const topRequired = hasRequired(parentSchema); + let tagRequired = true; + for (let i = 0; i < oneOf2.length; i++) { + let sch = oneOf2[i]; + if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) { + const ref2 = sch.$ref; + sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref2); + if (sch instanceof compile_1.SchemaEnv) + sch = sch.schema; + if (sch === void 0) + throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref2); + } + const propSch = (_a = sch === null || sch === void 0 ? void 0 : sch.properties) === null || _a === void 0 ? void 0 : _a[tagName]; + if (typeof propSch != "object") { + throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`); + } + tagRequired = tagRequired && (topRequired || hasRequired(sch)); + addMappings(propSch, i); + } + if (!tagRequired) + throw new Error(`discriminator: "${tagName}" must be required`); + return oneOfMapping; + function hasRequired({ required: required2 }) { + return Array.isArray(required2) && required2.includes(tagName); + } + function addMappings(sch, i) { + if (sch.const) { + addMapping(sch.const, i); + } else if (sch.enum) { + for (const tagValue of sch.enum) { + addMapping(tagValue, i); + } + } else { + throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`); + } + } + function addMapping(tagValue, i) { + if (typeof tagValue != "string" || tagValue in oneOfMapping) { + throw new Error(`discriminator: "${tagName}" values must be unique strings`); + } + oneOfMapping[tagValue] = i; + } + } + } +}; +discriminator.default = def; +var jsonSchema202012 = {}; +const $schema$8 = "https://json-schema.org/draft/2020-12/schema"; +const $id$8 = "https://json-schema.org/draft/2020-12/schema"; +const $vocabulary$7 = { + "https://json-schema.org/draft/2020-12/vocab/core": true, + "https://json-schema.org/draft/2020-12/vocab/applicator": true, + "https://json-schema.org/draft/2020-12/vocab/unevaluated": true, + "https://json-schema.org/draft/2020-12/vocab/validation": true, + "https://json-schema.org/draft/2020-12/vocab/meta-data": true, + "https://json-schema.org/draft/2020-12/vocab/format-annotation": true, + "https://json-schema.org/draft/2020-12/vocab/content": true +}; +const $dynamicAnchor$7 = "meta"; +const title$8 = "Core and Validation specifications meta-schema"; +const allOf = [ + { + $ref: "meta/core" + }, + { + $ref: "meta/applicator" + }, + { + $ref: "meta/unevaluated" + }, + { + $ref: "meta/validation" + }, + { + $ref: "meta/meta-data" + }, + { + $ref: "meta/format-annotation" + }, + { + $ref: "meta/content" + } +]; +const type$8 = [ + "object", + "boolean" +]; +const $comment = "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use."; +const properties$8 = { + definitions: { + $comment: '"definitions" has been replaced by "$defs".', + type: "object", + additionalProperties: { + $dynamicRef: "#meta" + }, + deprecated: true, + "default": {} + }, + dependencies: { + $comment: '"dependencies" has been split and replaced by "dependentSchemas" and "dependentRequired" in order to serve their differing semantics.', + type: "object", + additionalProperties: { + anyOf: [ + { + $dynamicRef: "#meta" + }, + { + $ref: "meta/validation#/$defs/stringArray" + } + ] + }, + deprecated: true, + "default": {} + }, + $recursiveAnchor: { + $comment: '"$recursiveAnchor" has been replaced by "$dynamicAnchor".', + $ref: "meta/core#/$defs/anchorString", + deprecated: true + }, + $recursiveRef: { + $comment: '"$recursiveRef" has been replaced by "$dynamicRef".', + $ref: "meta/core#/$defs/uriReferenceString", + deprecated: true + } +}; +const require$$0 = { + $schema: $schema$8, + $id: $id$8, + $vocabulary: $vocabulary$7, + $dynamicAnchor: $dynamicAnchor$7, + title: title$8, + allOf, + type: type$8, + $comment, + properties: properties$8 +}; +const $schema$7 = "https://json-schema.org/draft/2020-12/schema"; +const $id$7 = "https://json-schema.org/draft/2020-12/meta/applicator"; +const $vocabulary$6 = { + "https://json-schema.org/draft/2020-12/vocab/applicator": true +}; +const $dynamicAnchor$6 = "meta"; +const title$7 = "Applicator vocabulary meta-schema"; +const type$7 = [ + "object", + "boolean" +]; +const properties$7 = { + prefixItems: { + $ref: "#/$defs/schemaArray" + }, + items: { + $dynamicRef: "#meta" + }, + contains: { + $dynamicRef: "#meta" + }, + additionalProperties: { + $dynamicRef: "#meta" + }, + properties: { + type: "object", + additionalProperties: { + $dynamicRef: "#meta" + }, + "default": {} + }, + patternProperties: { + type: "object", + additionalProperties: { + $dynamicRef: "#meta" + }, + propertyNames: { + format: "regex" + }, + "default": {} + }, + dependentSchemas: { + type: "object", + additionalProperties: { + $dynamicRef: "#meta" + }, + "default": {} + }, + propertyNames: { + $dynamicRef: "#meta" + }, + "if": { + $dynamicRef: "#meta" + }, + then: { + $dynamicRef: "#meta" + }, + "else": { + $dynamicRef: "#meta" + }, + allOf: { + $ref: "#/$defs/schemaArray" + }, + anyOf: { + $ref: "#/$defs/schemaArray" + }, + oneOf: { + $ref: "#/$defs/schemaArray" + }, + not: { + $dynamicRef: "#meta" + } +}; +const $defs$2 = { + schemaArray: { + type: "array", + minItems: 1, + items: { + $dynamicRef: "#meta" + } + } +}; +const require$$1 = { + $schema: $schema$7, + $id: $id$7, + $vocabulary: $vocabulary$6, + $dynamicAnchor: $dynamicAnchor$6, + title: title$7, + type: type$7, + properties: properties$7, + $defs: $defs$2 +}; +const $schema$6 = "https://json-schema.org/draft/2020-12/schema"; +const $id$6 = "https://json-schema.org/draft/2020-12/meta/unevaluated"; +const $vocabulary$5 = { + "https://json-schema.org/draft/2020-12/vocab/unevaluated": true +}; +const $dynamicAnchor$5 = "meta"; +const title$6 = "Unevaluated applicator vocabulary meta-schema"; +const type$6 = [ + "object", + "boolean" +]; +const properties$6 = { + unevaluatedItems: { + $dynamicRef: "#meta" + }, + unevaluatedProperties: { + $dynamicRef: "#meta" + } +}; +const require$$2 = { + $schema: $schema$6, + $id: $id$6, + $vocabulary: $vocabulary$5, + $dynamicAnchor: $dynamicAnchor$5, + title: title$6, + type: type$6, + properties: properties$6 +}; +const $schema$5 = "https://json-schema.org/draft/2020-12/schema"; +const $id$5 = "https://json-schema.org/draft/2020-12/meta/content"; +const $vocabulary$4 = { + "https://json-schema.org/draft/2020-12/vocab/content": true +}; +const $dynamicAnchor$4 = "meta"; +const title$5 = "Content vocabulary meta-schema"; +const type$5 = [ + "object", + "boolean" +]; +const properties$5 = { + contentEncoding: { + type: "string" + }, + contentMediaType: { + type: "string" + }, + contentSchema: { + $dynamicRef: "#meta" + } +}; +const require$$3$1 = { + $schema: $schema$5, + $id: $id$5, + $vocabulary: $vocabulary$4, + $dynamicAnchor: $dynamicAnchor$4, + title: title$5, + type: type$5, + properties: properties$5 +}; +const $schema$4 = "https://json-schema.org/draft/2020-12/schema"; +const $id$4 = "https://json-schema.org/draft/2020-12/meta/core"; +const $vocabulary$3 = { + "https://json-schema.org/draft/2020-12/vocab/core": true +}; +const $dynamicAnchor$3 = "meta"; +const title$4 = "Core vocabulary meta-schema"; +const type$4 = [ + "object", + "boolean" +]; +const properties$4 = { + $id: { + $ref: "#/$defs/uriReferenceString", + $comment: "Non-empty fragments not allowed.", + pattern: "^[^#]*#?$" + }, + $schema: { + $ref: "#/$defs/uriString" + }, + $ref: { + $ref: "#/$defs/uriReferenceString" + }, + $anchor: { + $ref: "#/$defs/anchorString" + }, + $dynamicRef: { + $ref: "#/$defs/uriReferenceString" + }, + $dynamicAnchor: { + $ref: "#/$defs/anchorString" + }, + $vocabulary: { + type: "object", + propertyNames: { + $ref: "#/$defs/uriString" + }, + additionalProperties: { + type: "boolean" + } + }, + $comment: { + type: "string" + }, + $defs: { + type: "object", + additionalProperties: { + $dynamicRef: "#meta" + } + } +}; +const $defs$1 = { + anchorString: { + type: "string", + pattern: "^[A-Za-z_][-A-Za-z0-9._]*$" + }, + uriString: { + type: "string", + format: "uri" + }, + uriReferenceString: { + type: "string", + format: "uri-reference" + } +}; +const require$$4 = { + $schema: $schema$4, + $id: $id$4, + $vocabulary: $vocabulary$3, + $dynamicAnchor: $dynamicAnchor$3, + title: title$4, + type: type$4, + properties: properties$4, + $defs: $defs$1 +}; +const $schema$3 = "https://json-schema.org/draft/2020-12/schema"; +const $id$3 = "https://json-schema.org/draft/2020-12/meta/format-annotation"; +const $vocabulary$2 = { + "https://json-schema.org/draft/2020-12/vocab/format-annotation": true +}; +const $dynamicAnchor$2 = "meta"; +const title$3 = "Format vocabulary meta-schema for annotation results"; +const type$3 = [ + "object", + "boolean" +]; +const properties$3 = { + format: { + type: "string" + } +}; +const require$$5 = { + $schema: $schema$3, + $id: $id$3, + $vocabulary: $vocabulary$2, + $dynamicAnchor: $dynamicAnchor$2, + title: title$3, + type: type$3, + properties: properties$3 +}; +const $schema$2 = "https://json-schema.org/draft/2020-12/schema"; +const $id$2 = "https://json-schema.org/draft/2020-12/meta/meta-data"; +const $vocabulary$1 = { + "https://json-schema.org/draft/2020-12/vocab/meta-data": true +}; +const $dynamicAnchor$1 = "meta"; +const title$2 = "Meta-data vocabulary meta-schema"; +const type$2 = [ + "object", + "boolean" +]; +const properties$2 = { + title: { + type: "string" + }, + description: { + type: "string" + }, + "default": true, + deprecated: { + type: "boolean", + "default": false + }, + readOnly: { + type: "boolean", + "default": false + }, + writeOnly: { + type: "boolean", + "default": false + }, + examples: { + type: "array", + items: true + } +}; +const require$$6 = { + $schema: $schema$2, + $id: $id$2, + $vocabulary: $vocabulary$1, + $dynamicAnchor: $dynamicAnchor$1, + title: title$2, + type: type$2, + properties: properties$2 +}; +const $schema$1 = "https://json-schema.org/draft/2020-12/schema"; +const $id$1 = "https://json-schema.org/draft/2020-12/meta/validation"; +const $vocabulary = { + "https://json-schema.org/draft/2020-12/vocab/validation": true +}; +const $dynamicAnchor = "meta"; +const title$1 = "Validation vocabulary meta-schema"; +const type$1 = [ + "object", + "boolean" +]; +const properties$1 = { + type: { + anyOf: [ + { + $ref: "#/$defs/simpleTypes" + }, + { + type: "array", + items: { + $ref: "#/$defs/simpleTypes" + }, + minItems: 1, + uniqueItems: true + } + ] + }, + "const": true, + "enum": { + type: "array", + items: true + }, + multipleOf: { + type: "number", + exclusiveMinimum: 0 + }, + maximum: { + type: "number" + }, + exclusiveMaximum: { + type: "number" + }, + minimum: { + type: "number" + }, + exclusiveMinimum: { + type: "number" + }, + maxLength: { + $ref: "#/$defs/nonNegativeInteger" + }, + minLength: { + $ref: "#/$defs/nonNegativeIntegerDefault0" + }, + pattern: { + type: "string", + format: "regex" + }, + maxItems: { + $ref: "#/$defs/nonNegativeInteger" + }, + minItems: { + $ref: "#/$defs/nonNegativeIntegerDefault0" + }, + uniqueItems: { + type: "boolean", + "default": false + }, + maxContains: { + $ref: "#/$defs/nonNegativeInteger" + }, + minContains: { + $ref: "#/$defs/nonNegativeInteger", + "default": 1 + }, + maxProperties: { + $ref: "#/$defs/nonNegativeInteger" + }, + minProperties: { + $ref: "#/$defs/nonNegativeIntegerDefault0" + }, + required: { + $ref: "#/$defs/stringArray" + }, + dependentRequired: { + type: "object", + additionalProperties: { + $ref: "#/$defs/stringArray" + } + } +}; +const $defs = { + nonNegativeInteger: { + type: "integer", + minimum: 0 + }, + nonNegativeIntegerDefault0: { + $ref: "#/$defs/nonNegativeInteger", + "default": 0 + }, + simpleTypes: { + "enum": [ + "array", + "boolean", + "integer", + "null", + "number", + "object", + "string" + ] + }, + stringArray: { + type: "array", + items: { + type: "string" + }, + uniqueItems: true, + "default": [] + } +}; +const require$$7 = { + $schema: $schema$1, + $id: $id$1, + $vocabulary, + $dynamicAnchor, + title: title$1, + type: type$1, + properties: properties$1, + $defs +}; +Object.defineProperty(jsonSchema202012, "__esModule", { value: true }); +const metaSchema = require$$0; +const applicator = require$$1; +const unevaluated = require$$2; +const content = require$$3$1; +const core = require$$4; +const format = require$$5; +const metadata = require$$6; +const validation = require$$7; +const META_SUPPORT_DATA = ["/properties"]; +function addMetaSchema2020($data) { + [ + metaSchema, + applicator, + unevaluated, + content, + core, + with$data(this, format), + metadata, + with$data(this, validation) + ].forEach((sch) => this.addMetaSchema(sch, void 0, false)); + return this; + function with$data(ajv2, sch) { + return $data ? ajv2.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch; + } +} +jsonSchema202012.default = addMetaSchema2020; +(function(module, exports$1) { + Object.defineProperty(exports$1, "__esModule", { value: true }); + exports$1.MissingRefError = exports$1.ValidationError = exports$1.CodeGen = exports$1.Name = exports$1.nil = exports$1.stringify = exports$1.str = exports$1._ = exports$1.KeywordCxt = exports$1.Ajv2020 = void 0; + const core_12 = core$3; + const draft2020_1 = draft2020; + const discriminator_1 = discriminator; + const json_schema_2020_12_1 = jsonSchema202012; + const META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema"; + class Ajv2020 extends core_12.default { + constructor(opts = {}) { + super({ + ...opts, + dynamicRef: true, + next: true, + unevaluated: true + }); + } + _addVocabularies() { + super._addVocabularies(); + draft2020_1.default.forEach((v) => this.addVocabulary(v)); + if (this.opts.discriminator) + this.addKeyword(discriminator_1.default); + } + _addDefaultMetaSchema() { + super._addDefaultMetaSchema(); + const { $data, meta } = this.opts; + if (!meta) + return; + json_schema_2020_12_1.default.call(this, $data); + this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID; + } + defaultMeta() { + return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0); + } + } + exports$1.Ajv2020 = Ajv2020; + module.exports = exports$1 = Ajv2020; + module.exports.Ajv2020 = Ajv2020; + Object.defineProperty(exports$1, "__esModule", { value: true }); + exports$1.default = Ajv2020; + var validate_12 = validate; + Object.defineProperty(exports$1, "KeywordCxt", { enumerable: true, get: function() { + return validate_12.KeywordCxt; + } }); + var codegen_12 = codegen; + Object.defineProperty(exports$1, "_", { enumerable: true, get: function() { + return codegen_12._; + } }); + Object.defineProperty(exports$1, "str", { enumerable: true, get: function() { + return codegen_12.str; + } }); + Object.defineProperty(exports$1, "stringify", { enumerable: true, get: function() { + return codegen_12.stringify; + } }); + Object.defineProperty(exports$1, "nil", { enumerable: true, get: function() { + return codegen_12.nil; + } }); + Object.defineProperty(exports$1, "Name", { enumerable: true, get: function() { + return codegen_12.Name; + } }); + Object.defineProperty(exports$1, "CodeGen", { enumerable: true, get: function() { + return codegen_12.CodeGen; + } }); + var validation_error_12 = validation_error; + Object.defineProperty(exports$1, "ValidationError", { enumerable: true, get: function() { + return validation_error_12.default; + } }); + var ref_error_12 = ref_error; + Object.defineProperty(exports$1, "MissingRefError", { enumerable: true, get: function() { + return ref_error_12.default; + } }); +})(_2020, _2020.exports); +var _2020Exports = _2020.exports; +var dist = { exports: {} }; +var formats = {}; +(function(exports$1) { + Object.defineProperty(exports$1, "__esModule", { value: true }); + exports$1.formatNames = exports$1.fastFormats = exports$1.fullFormats = void 0; + function fmtDef(validate2, compare2) { + return { validate: validate2, compare: compare2 }; + } + exports$1.fullFormats = { + // date: http://tools.ietf.org/html/rfc3339#section-5.6 + date: fmtDef(date, compareDate), + // date-time: http://tools.ietf.org/html/rfc3339#section-5.6 + time: fmtDef(getTime(true), compareTime), + "date-time": fmtDef(getDateTime(true), compareDateTime), + "iso-time": fmtDef(getTime(), compareIsoTime), + "iso-date-time": fmtDef(getDateTime(), compareIsoDateTime), + // duration: https://tools.ietf.org/html/rfc3339#appendix-A + duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/, + uri: uri2, + "uri-reference": /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i, + // uri-template: https://tools.ietf.org/html/rfc6570 + "uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i, + // For the source: https://gist.github.com/dperini/729294 + // For test cases: https://mathiasbynens.be/demo/url-regex + url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu, + email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i, + hostname: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i, + // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html + ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/, + ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i, + regex, + // uuid: http://tools.ietf.org/html/rfc4122 + uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i, + // JSON-pointer: https://tools.ietf.org/html/rfc6901 + // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A + "json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/, + "json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i, + // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00 + "relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/, + // the following formats are used by the openapi specification: https://spec.openapis.org/oas/v3.0.0#data-types + // byte: https://github.com/miguelmota/is-base64 + byte, + // signed 32 bit integer + int32: { type: "number", validate: validateInt32 }, + // signed 64 bit integer + int64: { type: "number", validate: validateInt64 }, + // C-type float + float: { type: "number", validate: validateNumber }, + // C-type double + double: { type: "number", validate: validateNumber }, + // hint to the UI to hide input strings + password: true, + // unchecked string payload + binary: true + }; + exports$1.fastFormats = { + ...exports$1.fullFormats, + date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate), + time: fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareTime), + "date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareDateTime), + "iso-time": fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoTime), + "iso-date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoDateTime), + // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js + uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i, + "uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i, + // email (sources from jsen validator): + // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363 + // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'wilful violation') + email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i + }; + exports$1.formatNames = Object.keys(exports$1.fullFormats); + function isLeapYear(year) { + return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); + } + const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/; + const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + function date(str) { + const matches = DATE.exec(str); + if (!matches) + return false; + const year = +matches[1]; + const month = +matches[2]; + const day = +matches[3]; + return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]); + } + function compareDate(d1, d2) { + if (!(d1 && d2)) + return void 0; + if (d1 > d2) + return 1; + if (d1 < d2) + return -1; + return 0; + } + const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i; + function getTime(strictTimeZone) { + return function time(str) { + const matches = TIME.exec(str); + if (!matches) + return false; + const hr = +matches[1]; + const min = +matches[2]; + const sec = +matches[3]; + const tz = matches[4]; + const tzSign = matches[5] === "-" ? -1 : 1; + const tzH = +(matches[6] || 0); + const tzM = +(matches[7] || 0); + if (tzH > 23 || tzM > 59 || strictTimeZone && !tz) + return false; + if (hr <= 23 && min <= 59 && sec < 60) + return true; + const utcMin = min - tzM * tzSign; + const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0); + return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61; + }; + } + function compareTime(s1, s2) { + if (!(s1 && s2)) + return void 0; + const t1 = (/* @__PURE__ */ new Date("2020-01-01T" + s1)).valueOf(); + const t2 = (/* @__PURE__ */ new Date("2020-01-01T" + s2)).valueOf(); + if (!(t1 && t2)) + return void 0; + return t1 - t2; + } + function compareIsoTime(t1, t2) { + if (!(t1 && t2)) + return void 0; + const a1 = TIME.exec(t1); + const a2 = TIME.exec(t2); + if (!(a1 && a2)) + return void 0; + t1 = a1[1] + a1[2] + a1[3]; + t2 = a2[1] + a2[2] + a2[3]; + if (t1 > t2) + return 1; + if (t1 < t2) + return -1; + return 0; + } + const DATE_TIME_SEPARATOR = /t|\s/i; + function getDateTime(strictTimeZone) { + const time = getTime(strictTimeZone); + return function date_time(str) { + const dateTime = str.split(DATE_TIME_SEPARATOR); + return dateTime.length === 2 && date(dateTime[0]) && time(dateTime[1]); + }; + } + function compareDateTime(dt1, dt2) { + if (!(dt1 && dt2)) + return void 0; + const d1 = new Date(dt1).valueOf(); + const d2 = new Date(dt2).valueOf(); + if (!(d1 && d2)) + return void 0; + return d1 - d2; + } + function compareIsoDateTime(dt1, dt2) { + if (!(dt1 && dt2)) + return void 0; + const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR); + const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR); + const res = compareDate(d1, d2); + if (res === void 0) + return void 0; + return res || compareTime(t1, t2); + } + const NOT_URI_FRAGMENT = /\/|:/; + const URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i; + function uri2(str) { + return NOT_URI_FRAGMENT.test(str) && URI.test(str); + } + const BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm; + function byte(str) { + BYTE.lastIndex = 0; + return BYTE.test(str); + } + const MIN_INT32 = -2147483648; + const MAX_INT32 = 2 ** 31 - 1; + function validateInt32(value) { + return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32; + } + function validateInt64(value) { + return Number.isInteger(value); + } + function validateNumber() { + return true; + } + const Z_ANCHOR = /[^\\]\\Z/; + function regex(str) { + if (Z_ANCHOR.test(str)) + return false; + try { + new RegExp(str); + return true; + } catch (e) { + return false; + } + } +})(formats); +var limit = {}; +var ajv = { exports: {} }; +var draft7 = {}; +Object.defineProperty(draft7, "__esModule", { value: true }); +const core_1 = core$2; +const validation_1 = validation$2; +const applicator_1 = applicator$1; +const format_1 = format$3; +const metadata_1 = metadata$1; +const draft7Vocabularies = [ + core_1.default, + validation_1.default, + (0, applicator_1.default)(), + format_1.default, + metadata_1.metadataVocabulary, + metadata_1.contentVocabulary +]; +draft7.default = draft7Vocabularies; +const $schema = "http://json-schema.org/draft-07/schema#"; +const $id = "http://json-schema.org/draft-07/schema#"; +const title = "Core schema meta-schema"; +const definitions = { + schemaArray: { + type: "array", + minItems: 1, + items: { + $ref: "#" + } + }, + nonNegativeInteger: { + type: "integer", + minimum: 0 + }, + nonNegativeIntegerDefault0: { + allOf: [ + { + $ref: "#/definitions/nonNegativeInteger" + }, + { + "default": 0 + } + ] + }, + simpleTypes: { + "enum": [ + "array", + "boolean", + "integer", + "null", + "number", + "object", + "string" + ] + }, + stringArray: { + type: "array", + items: { + type: "string" + }, + uniqueItems: true, + "default": [] + } +}; +const type = [ + "object", + "boolean" +]; +const properties = { + $id: { + type: "string", + format: "uri-reference" + }, + $schema: { + type: "string", + format: "uri" + }, + $ref: { + type: "string", + format: "uri-reference" + }, + $comment: { + type: "string" + }, + title: { + type: "string" + }, + description: { + type: "string" + }, + "default": true, + readOnly: { + type: "boolean", + "default": false + }, + examples: { + type: "array", + items: true + }, + multipleOf: { + type: "number", + exclusiveMinimum: 0 + }, + maximum: { + type: "number" + }, + exclusiveMaximum: { + type: "number" + }, + minimum: { + type: "number" + }, + exclusiveMinimum: { + type: "number" + }, + maxLength: { + $ref: "#/definitions/nonNegativeInteger" + }, + minLength: { + $ref: "#/definitions/nonNegativeIntegerDefault0" + }, + pattern: { + type: "string", + format: "regex" + }, + additionalItems: { + $ref: "#" + }, + items: { + anyOf: [ + { + $ref: "#" + }, + { + $ref: "#/definitions/schemaArray" + } + ], + "default": true + }, + maxItems: { + $ref: "#/definitions/nonNegativeInteger" + }, + minItems: { + $ref: "#/definitions/nonNegativeIntegerDefault0" + }, + uniqueItems: { + type: "boolean", + "default": false + }, + contains: { + $ref: "#" + }, + maxProperties: { + $ref: "#/definitions/nonNegativeInteger" + }, + minProperties: { + $ref: "#/definitions/nonNegativeIntegerDefault0" + }, + required: { + $ref: "#/definitions/stringArray" + }, + additionalProperties: { + $ref: "#" + }, + definitions: { + type: "object", + additionalProperties: { + $ref: "#" + }, + "default": {} + }, + properties: { + type: "object", + additionalProperties: { + $ref: "#" + }, + "default": {} + }, + patternProperties: { + type: "object", + additionalProperties: { + $ref: "#" + }, + propertyNames: { + format: "regex" + }, + "default": {} + }, + dependencies: { + type: "object", + additionalProperties: { + anyOf: [ + { + $ref: "#" + }, + { + $ref: "#/definitions/stringArray" + } + ] + } + }, + propertyNames: { + $ref: "#" + }, + "const": true, + "enum": { + type: "array", + items: true, + minItems: 1, + uniqueItems: true + }, + type: { + anyOf: [ + { + $ref: "#/definitions/simpleTypes" + }, + { + type: "array", + items: { + $ref: "#/definitions/simpleTypes" + }, + minItems: 1, + uniqueItems: true + } + ] + }, + format: { + type: "string" + }, + contentMediaType: { + type: "string" + }, + contentEncoding: { + type: "string" + }, + "if": { + $ref: "#" + }, + then: { + $ref: "#" + }, + "else": { + $ref: "#" + }, + allOf: { + $ref: "#/definitions/schemaArray" + }, + anyOf: { + $ref: "#/definitions/schemaArray" + }, + oneOf: { + $ref: "#/definitions/schemaArray" + }, + not: { + $ref: "#" + } +}; +const require$$3 = { + $schema, + $id, + title, + definitions, + type, + properties, + "default": true +}; +(function(module, exports$1) { + Object.defineProperty(exports$1, "__esModule", { value: true }); + exports$1.MissingRefError = exports$1.ValidationError = exports$1.CodeGen = exports$1.Name = exports$1.nil = exports$1.stringify = exports$1.str = exports$1._ = exports$1.KeywordCxt = exports$1.Ajv = void 0; + const core_12 = core$3; + const draft7_1 = draft7; + const discriminator_1 = discriminator; + const draft7MetaSchema = require$$3; + const META_SUPPORT_DATA2 = ["/properties"]; + const META_SCHEMA_ID = "http://json-schema.org/draft-07/schema"; + class Ajv extends core_12.default { + _addVocabularies() { + super._addVocabularies(); + draft7_1.default.forEach((v) => this.addVocabulary(v)); + if (this.opts.discriminator) + this.addKeyword(discriminator_1.default); + } + _addDefaultMetaSchema() { + super._addDefaultMetaSchema(); + if (!this.opts.meta) + return; + const metaSchema2 = this.opts.$data ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA2) : draft7MetaSchema; + this.addMetaSchema(metaSchema2, META_SCHEMA_ID, false); + this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID; + } + defaultMeta() { + return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0); + } + } + exports$1.Ajv = Ajv; + module.exports = exports$1 = Ajv; + module.exports.Ajv = Ajv; + Object.defineProperty(exports$1, "__esModule", { value: true }); + exports$1.default = Ajv; + var validate_12 = validate; + Object.defineProperty(exports$1, "KeywordCxt", { enumerable: true, get: function() { + return validate_12.KeywordCxt; + } }); + var codegen_12 = codegen; + Object.defineProperty(exports$1, "_", { enumerable: true, get: function() { + return codegen_12._; + } }); + Object.defineProperty(exports$1, "str", { enumerable: true, get: function() { + return codegen_12.str; + } }); + Object.defineProperty(exports$1, "stringify", { enumerable: true, get: function() { + return codegen_12.stringify; + } }); + Object.defineProperty(exports$1, "nil", { enumerable: true, get: function() { + return codegen_12.nil; + } }); + Object.defineProperty(exports$1, "Name", { enumerable: true, get: function() { + return codegen_12.Name; + } }); + Object.defineProperty(exports$1, "CodeGen", { enumerable: true, get: function() { + return codegen_12.CodeGen; + } }); + var validation_error_12 = validation_error; + Object.defineProperty(exports$1, "ValidationError", { enumerable: true, get: function() { + return validation_error_12.default; + } }); + var ref_error_12 = ref_error; + Object.defineProperty(exports$1, "MissingRefError", { enumerable: true, get: function() { + return ref_error_12.default; + } }); +})(ajv, ajv.exports); +var ajvExports = ajv.exports; +(function(exports$1) { + Object.defineProperty(exports$1, "__esModule", { value: true }); + exports$1.formatLimitDefinition = void 0; + const ajv_1 = ajvExports; + const codegen_12 = codegen; + const ops2 = codegen_12.operators; + const KWDs2 = { + formatMaximum: { okStr: "<=", ok: ops2.LTE, fail: ops2.GT }, + formatMinimum: { okStr: ">=", ok: ops2.GTE, fail: ops2.LT }, + formatExclusiveMaximum: { okStr: "<", ok: ops2.LT, fail: ops2.GTE }, + formatExclusiveMinimum: { okStr: ">", ok: ops2.GT, fail: ops2.LTE } + }; + const error2 = { + message: ({ keyword: keyword2, schemaCode }) => (0, codegen_12.str)`should be ${KWDs2[keyword2].okStr} ${schemaCode}`, + params: ({ keyword: keyword2, schemaCode }) => (0, codegen_12._)`{comparison: ${KWDs2[keyword2].okStr}, limit: ${schemaCode}}` + }; + exports$1.formatLimitDefinition = { + keyword: Object.keys(KWDs2), + type: "string", + schemaType: "string", + $data: true, + error: error2, + code(cxt) { + const { gen, data, schemaCode, keyword: keyword2, it } = cxt; + const { opts, self } = it; + if (!opts.validateFormats) + return; + const fCxt = new ajv_1.KeywordCxt(it, self.RULES.all.format.definition, "format"); + if (fCxt.$data) + validate$DataFormat(); + else + validateFormat(); + function validate$DataFormat() { + const fmts = gen.scopeValue("formats", { + ref: self.formats, + code: opts.code.formats + }); + const fmt = gen.const("fmt", (0, codegen_12._)`${fmts}[${fCxt.schemaCode}]`); + cxt.fail$data((0, codegen_12.or)((0, codegen_12._)`typeof ${fmt} != "object"`, (0, codegen_12._)`${fmt} instanceof RegExp`, (0, codegen_12._)`typeof ${fmt}.compare != "function"`, compareCode(fmt))); + } + function validateFormat() { + const format2 = fCxt.schema; + const fmtDef = self.formats[format2]; + if (!fmtDef || fmtDef === true) + return; + if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") { + throw new Error(`"${keyword2}": format "${format2}" does not define "compare" function`); + } + const fmt = gen.scopeValue("formats", { + key: format2, + ref: fmtDef, + code: opts.code.formats ? (0, codegen_12._)`${opts.code.formats}${(0, codegen_12.getProperty)(format2)}` : void 0 + }); + cxt.fail$data(compareCode(fmt)); + } + function compareCode(fmt) { + return (0, codegen_12._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs2[keyword2].fail} 0`; + } + }, + dependencies: ["format"] + }; + const formatLimitPlugin = (ajv2) => { + ajv2.addKeyword(exports$1.formatLimitDefinition); + return ajv2; + }; + exports$1.default = formatLimitPlugin; +})(limit); +(function(module, exports$1) { + Object.defineProperty(exports$1, "__esModule", { value: true }); + const formats_1 = formats; + const limit_1 = limit; + const codegen_12 = codegen; + const fullName = new codegen_12.Name("fullFormats"); + const fastName = new codegen_12.Name("fastFormats"); + const formatsPlugin = (ajv2, opts = { keywords: true }) => { + if (Array.isArray(opts)) { + addFormats(ajv2, opts, formats_1.fullFormats, fullName); + return ajv2; + } + const [formats2, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName]; + const list = opts.formats || formats_1.formatNames; + addFormats(ajv2, list, formats2, exportName); + if (opts.keywords) + (0, limit_1.default)(ajv2); + return ajv2; + }; + formatsPlugin.get = (name, mode = "full") => { + const formats2 = mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats; + const f = formats2[name]; + if (!f) + throw new Error(`Unknown format "${name}"`); + return f; + }; + function addFormats(ajv2, list, fs2, exportName) { + var _a; + var _b; + (_a = (_b = ajv2.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_12._)`require("ajv-formats/dist/formats").${exportName}`; + for (const f of list) + ajv2.addFormat(f, fs2[f]); + } + module.exports = exports$1 = formatsPlugin; + Object.defineProperty(exports$1, "__esModule", { value: true }); + exports$1.default = formatsPlugin; +})(dist, dist.exports); +var distExports = dist.exports; +const ajvFormatsModule = /* @__PURE__ */ getDefaultExportFromCjs(distExports); +const copyProperty = (to, from, property, ignoreNonConfigurable) => { + if (property === "length" || property === "prototype") { + return; + } + if (property === "arguments" || property === "caller") { + return; + } + const toDescriptor = Object.getOwnPropertyDescriptor(to, property); + const fromDescriptor = Object.getOwnPropertyDescriptor(from, property); + if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) { + return; + } + Object.defineProperty(to, property, fromDescriptor); +}; +const canCopyProperty = function(toDescriptor, fromDescriptor) { + return toDescriptor === void 0 || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value); +}; +const changePrototype = (to, from) => { + const fromPrototype = Object.getPrototypeOf(from); + if (fromPrototype === Object.getPrototypeOf(to)) { + return; + } + Object.setPrototypeOf(to, fromPrototype); +}; +const wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/ +${fromBody}`; +const toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "toString"); +const toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name"); +const changeToString = (to, from, name) => { + const withName = name === "" ? "" : `with ${name.trim()}() `; + const newToString = wrappedToString.bind(null, withName, from.toString()); + Object.defineProperty(newToString, "name", toStringName); + const { writable, enumerable, configurable } = toStringDescriptor; + Object.defineProperty(to, "toString", { value: newToString, writable, enumerable, configurable }); +}; +function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) { + const { name } = to; + for (const property of Reflect.ownKeys(from)) { + copyProperty(to, from, property, ignoreNonConfigurable); + } + changePrototype(to, from); + changeToString(to, from, name); + return to; +} +const debounceFunction = (inputFunction, options = {}) => { + if (typeof inputFunction !== "function") { + throw new TypeError(`Expected the first argument to be a function, got \`${typeof inputFunction}\``); + } + const { + wait = 0, + maxWait = Number.POSITIVE_INFINITY, + before = false, + after = true + } = options; + if (wait < 0 || maxWait < 0) { + throw new RangeError("`wait` and `maxWait` must not be negative."); + } + if (!before && !after) { + throw new Error("Both `before` and `after` are false, function wouldn't be called."); + } + let timeout; + let maxTimeout; + let result; + const debouncedFunction = function(...arguments_) { + const context = this; + const later = () => { + timeout = void 0; + if (maxTimeout) { + clearTimeout(maxTimeout); + maxTimeout = void 0; + } + if (after) { + result = inputFunction.apply(context, arguments_); + } + }; + const maxLater = () => { + maxTimeout = void 0; + if (timeout) { + clearTimeout(timeout); + timeout = void 0; + } + if (after) { + result = inputFunction.apply(context, arguments_); + } + }; + const shouldCallNow = before && !timeout; + clearTimeout(timeout); + timeout = setTimeout(later, wait); + if (maxWait > 0 && maxWait !== Number.POSITIVE_INFINITY && !maxTimeout) { + maxTimeout = setTimeout(maxLater, maxWait); + } + if (shouldCallNow) { + result = inputFunction.apply(context, arguments_); + } + return result; + }; + mimicFunction(debouncedFunction, inputFunction); + debouncedFunction.cancel = () => { + if (timeout) { + clearTimeout(timeout); + timeout = void 0; + } + if (maxTimeout) { + clearTimeout(maxTimeout); + maxTimeout = void 0; + } + }; + return debouncedFunction; +}; +var re$2 = { exports: {} }; +const SEMVER_SPEC_VERSION = "2.0.0"; +const MAX_LENGTH$1 = 256; +const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */ +9007199254740991; +const MAX_SAFE_COMPONENT_LENGTH = 16; +const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH$1 - 6; +const RELEASE_TYPES = [ + "major", + "premajor", + "minor", + "preminor", + "patch", + "prepatch", + "prerelease" +]; +var constants$1 = { + MAX_LENGTH: MAX_LENGTH$1, + MAX_SAFE_COMPONENT_LENGTH, + MAX_SAFE_BUILD_LENGTH, + MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1, + RELEASE_TYPES, + SEMVER_SPEC_VERSION, + FLAG_INCLUDE_PRERELEASE: 1, + FLAG_LOOSE: 2 +}; +const debug$1 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => { +}; +var debug_1 = debug$1; +(function(module, exports$1) { + const { + MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH2, + MAX_SAFE_BUILD_LENGTH: MAX_SAFE_BUILD_LENGTH2, + MAX_LENGTH: MAX_LENGTH2 + } = constants$1; + const debug2 = debug_1; + exports$1 = module.exports = {}; + const re2 = exports$1.re = []; + const safeRe = exports$1.safeRe = []; + const src = exports$1.src = []; + const safeSrc = exports$1.safeSrc = []; + const t2 = exports$1.t = {}; + let R = 0; + const LETTERDASHNUMBER = "[a-zA-Z0-9-]"; + const safeRegexReplacements = [ + ["\\s", 1], + ["\\d", MAX_LENGTH2], + [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH2] + ]; + const makeSafeRegex = (value) => { + for (const [token, max] of safeRegexReplacements) { + value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`); + } + return value; + }; + const createToken = (name, value, isGlobal) => { + const safe = makeSafeRegex(value); + const index = R++; + debug2(name, index, value); + t2[name] = index; + src[index] = value; + safeSrc[index] = safe; + re2[index] = new RegExp(value, isGlobal ? "g" : void 0); + safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0); + }; + createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*"); + createToken("NUMERICIDENTIFIERLOOSE", "\\d+"); + createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`); + createToken("MAINVERSION", `(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})`); + createToken("MAINVERSIONLOOSE", `(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})`); + createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NONNUMERICIDENTIFIER]}|${src[t2.NUMERICIDENTIFIER]})`); + createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NONNUMERICIDENTIFIER]}|${src[t2.NUMERICIDENTIFIERLOOSE]})`); + createToken("PRERELEASE", `(?:-(${src[t2.PRERELEASEIDENTIFIER]}(?:\\.${src[t2.PRERELEASEIDENTIFIER]})*))`); + createToken("PRERELEASELOOSE", `(?:-?(${src[t2.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t2.PRERELEASEIDENTIFIERLOOSE]})*))`); + createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`); + createToken("BUILD", `(?:\\+(${src[t2.BUILDIDENTIFIER]}(?:\\.${src[t2.BUILDIDENTIFIER]})*))`); + createToken("FULLPLAIN", `v?${src[t2.MAINVERSION]}${src[t2.PRERELEASE]}?${src[t2.BUILD]}?`); + createToken("FULL", `^${src[t2.FULLPLAIN]}$`); + createToken("LOOSEPLAIN", `[v=\\s]*${src[t2.MAINVERSIONLOOSE]}${src[t2.PRERELEASELOOSE]}?${src[t2.BUILD]}?`); + createToken("LOOSE", `^${src[t2.LOOSEPLAIN]}$`); + createToken("GTLT", "((?:<|>)?=?)"); + createToken("XRANGEIDENTIFIERLOOSE", `${src[t2.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`); + createToken("XRANGEIDENTIFIER", `${src[t2.NUMERICIDENTIFIER]}|x|X|\\*`); + createToken("XRANGEPLAIN", `[v=\\s]*(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:${src[t2.PRERELEASE]})?${src[t2.BUILD]}?)?)?`); + createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:${src[t2.PRERELEASELOOSE]})?${src[t2.BUILD]}?)?)?`); + createToken("XRANGE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAIN]}$`); + createToken("XRANGELOOSE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAINLOOSE]}$`); + createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH2}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?`); + createToken("COERCE", `${src[t2.COERCEPLAIN]}(?:$|[^\\d])`); + createToken("COERCEFULL", src[t2.COERCEPLAIN] + `(?:${src[t2.PRERELEASE]})?(?:${src[t2.BUILD]})?(?:$|[^\\d])`); + createToken("COERCERTL", src[t2.COERCE], true); + createToken("COERCERTLFULL", src[t2.COERCEFULL], true); + createToken("LONETILDE", "(?:~>?)"); + createToken("TILDETRIM", `(\\s*)${src[t2.LONETILDE]}\\s+`, true); + exports$1.tildeTrimReplace = "$1~"; + createToken("TILDE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAIN]}$`); + createToken("TILDELOOSE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAINLOOSE]}$`); + createToken("LONECARET", "(?:\\^)"); + createToken("CARETTRIM", `(\\s*)${src[t2.LONECARET]}\\s+`, true); + exports$1.caretTrimReplace = "$1^"; + createToken("CARET", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAIN]}$`); + createToken("CARETLOOSE", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAINLOOSE]}$`); + createToken("COMPARATORLOOSE", `^${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]})$|^$`); + createToken("COMPARATOR", `^${src[t2.GTLT]}\\s*(${src[t2.FULLPLAIN]})$|^$`); + createToken("COMPARATORTRIM", `(\\s*)${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]}|${src[t2.XRANGEPLAIN]})`, true); + exports$1.comparatorTrimReplace = "$1$2$3"; + createToken("HYPHENRANGE", `^\\s*(${src[t2.XRANGEPLAIN]})\\s+-\\s+(${src[t2.XRANGEPLAIN]})\\s*$`); + createToken("HYPHENRANGELOOSE", `^\\s*(${src[t2.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t2.XRANGEPLAINLOOSE]})\\s*$`); + createToken("STAR", "(<|>)?=?\\s*\\*"); + createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"); + createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$"); +})(re$2, re$2.exports); +var reExports = re$2.exports; +const looseOption = Object.freeze({ loose: true }); +const emptyOpts = Object.freeze({}); +const parseOptions$1 = (options) => { + if (!options) { + return emptyOpts; + } + if (typeof options !== "object") { + return looseOption; + } + return options; +}; +var parseOptions_1 = parseOptions$1; +const numeric = /^[0-9]+$/; +const compareIdentifiers$1 = (a, b) => { + if (typeof a === "number" && typeof b === "number") { + return a === b ? 0 : a < b ? -1 : 1; + } + const anum = numeric.test(a); + const bnum = numeric.test(b); + if (anum && bnum) { + a = +a; + b = +b; + } + return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1; +}; +const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a); +var identifiers$1 = { + compareIdentifiers: compareIdentifiers$1, + rcompareIdentifiers +}; +const debug = debug_1; +const { MAX_LENGTH, MAX_SAFE_INTEGER } = constants$1; +const { safeRe: re$1, t: t$1 } = reExports; +const parseOptions = parseOptions_1; +const { compareIdentifiers } = identifiers$1; +let SemVer$d = class SemVer { + constructor(version, options) { + options = parseOptions(options); + if (version instanceof SemVer) { + if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) { + return version; + } else { + version = version.version; + } + } else if (typeof version !== "string") { + throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`); + } + if (version.length > MAX_LENGTH) { + throw new TypeError( + `version is longer than ${MAX_LENGTH} characters` + ); + } + debug("SemVer", version, options); + this.options = options; + this.loose = !!options.loose; + this.includePrerelease = !!options.includePrerelease; + const m = version.trim().match(options.loose ? re$1[t$1.LOOSE] : re$1[t$1.FULL]); + if (!m) { + throw new TypeError(`Invalid Version: ${version}`); + } + this.raw = version; + this.major = +m[1]; + this.minor = +m[2]; + this.patch = +m[3]; + if (this.major > MAX_SAFE_INTEGER || this.major < 0) { + throw new TypeError("Invalid major version"); + } + if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { + throw new TypeError("Invalid minor version"); + } + if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { + throw new TypeError("Invalid patch version"); + } + if (!m[4]) { + this.prerelease = []; + } else { + this.prerelease = m[4].split(".").map((id2) => { + if (/^[0-9]+$/.test(id2)) { + const num = +id2; + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num; + } + } + return id2; + }); + } + this.build = m[5] ? m[5].split(".") : []; + this.format(); + } + format() { + this.version = `${this.major}.${this.minor}.${this.patch}`; + if (this.prerelease.length) { + this.version += `-${this.prerelease.join(".")}`; + } + return this.version; + } + toString() { + return this.version; + } + compare(other) { + debug("SemVer.compare", this.version, this.options, other); + if (!(other instanceof SemVer)) { + if (typeof other === "string" && other === this.version) { + return 0; + } + other = new SemVer(other, this.options); + } + if (other.version === this.version) { + return 0; + } + return this.compareMain(other) || this.comparePre(other); + } + compareMain(other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options); + } + if (this.major < other.major) { + return -1; + } + if (this.major > other.major) { + return 1; + } + if (this.minor < other.minor) { + return -1; + } + if (this.minor > other.minor) { + return 1; + } + if (this.patch < other.patch) { + return -1; + } + if (this.patch > other.patch) { + return 1; + } + return 0; + } + comparePre(other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options); + } + if (this.prerelease.length && !other.prerelease.length) { + return -1; + } else if (!this.prerelease.length && other.prerelease.length) { + return 1; + } else if (!this.prerelease.length && !other.prerelease.length) { + return 0; + } + let i = 0; + do { + const a = this.prerelease[i]; + const b = other.prerelease[i]; + debug("prerelease compare", i, a, b); + if (a === void 0 && b === void 0) { + return 0; + } else if (b === void 0) { + return 1; + } else if (a === void 0) { + return -1; + } else if (a === b) { + continue; + } else { + return compareIdentifiers(a, b); + } + } while (++i); + } + compareBuild(other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options); + } + let i = 0; + do { + const a = this.build[i]; + const b = other.build[i]; + debug("build compare", i, a, b); + if (a === void 0 && b === void 0) { + return 0; + } else if (b === void 0) { + return 1; + } else if (a === void 0) { + return -1; + } else if (a === b) { + continue; + } else { + return compareIdentifiers(a, b); + } + } while (++i); + } + // preminor will bump the version up to the next minor release, and immediately + // down to pre-release. premajor and prepatch work the same way. + inc(release, identifier, identifierBase) { + if (release.startsWith("pre")) { + if (!identifier && identifierBase === false) { + throw new Error("invalid increment argument: identifier is empty"); + } + if (identifier) { + const match = `-${identifier}`.match(this.options.loose ? re$1[t$1.PRERELEASELOOSE] : re$1[t$1.PRERELEASE]); + if (!match || match[1] !== identifier) { + throw new Error(`invalid identifier: ${identifier}`); + } + } + } + switch (release) { + case "premajor": + this.prerelease.length = 0; + this.patch = 0; + this.minor = 0; + this.major++; + this.inc("pre", identifier, identifierBase); + break; + case "preminor": + this.prerelease.length = 0; + this.patch = 0; + this.minor++; + this.inc("pre", identifier, identifierBase); + break; + case "prepatch": + this.prerelease.length = 0; + this.inc("patch", identifier, identifierBase); + this.inc("pre", identifier, identifierBase); + break; + case "prerelease": + if (this.prerelease.length === 0) { + this.inc("patch", identifier, identifierBase); + } + this.inc("pre", identifier, identifierBase); + break; + case "release": + if (this.prerelease.length === 0) { + throw new Error(`version ${this.raw} is not a prerelease`); + } + this.prerelease.length = 0; + break; + case "major": + if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) { + this.major++; + } + this.minor = 0; + this.patch = 0; + this.prerelease = []; + break; + case "minor": + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++; + } + this.patch = 0; + this.prerelease = []; + break; + case "patch": + if (this.prerelease.length === 0) { + this.patch++; + } + this.prerelease = []; + break; + case "pre": { + const base = Number(identifierBase) ? 1 : 0; + if (this.prerelease.length === 0) { + this.prerelease = [base]; + } else { + let i = this.prerelease.length; + while (--i >= 0) { + if (typeof this.prerelease[i] === "number") { + this.prerelease[i]++; + i = -2; + } + } + if (i === -1) { + if (identifier === this.prerelease.join(".") && identifierBase === false) { + throw new Error("invalid increment argument: identifier already exists"); + } + this.prerelease.push(base); + } + } + if (identifier) { + let prerelease2 = [identifier, base]; + if (identifierBase === false) { + prerelease2 = [identifier]; + } + if (compareIdentifiers(this.prerelease[0], identifier) === 0) { + if (isNaN(this.prerelease[1])) { + this.prerelease = prerelease2; + } + } else { + this.prerelease = prerelease2; + } + } + break; + } + default: + throw new Error(`invalid increment argument: ${release}`); + } + this.raw = this.format(); + if (this.build.length) { + this.raw += `+${this.build.join(".")}`; + } + return this; + } +}; +var semver$2 = SemVer$d; +const SemVer$c = semver$2; +const parse$6 = (version, options, throwErrors = false) => { + if (version instanceof SemVer$c) { + return version; + } + try { + return new SemVer$c(version, options); + } catch (er) { + if (!throwErrors) { + return null; + } + throw er; + } +}; +var parse_1 = parse$6; +const parse$5 = parse_1; +const valid$2 = (version, options) => { + const v = parse$5(version, options); + return v ? v.version : null; +}; +var valid_1 = valid$2; +const parse$4 = parse_1; +const clean$1 = (version, options) => { + const s = parse$4(version.trim().replace(/^[=v]+/, ""), options); + return s ? s.version : null; +}; +var clean_1 = clean$1; +const SemVer$b = semver$2; +const inc$1 = (version, release, options, identifier, identifierBase) => { + if (typeof options === "string") { + identifierBase = identifier; + identifier = options; + options = void 0; + } + try { + return new SemVer$b( + version instanceof SemVer$b ? version.version : version, + options + ).inc(release, identifier, identifierBase).version; + } catch (er) { + return null; + } +}; +var inc_1 = inc$1; +const parse$3 = parse_1; +const diff$1 = (version1, version2) => { + const v1 = parse$3(version1, null, true); + const v2 = parse$3(version2, null, true); + const comparison = v1.compare(v2); + if (comparison === 0) { + return null; + } + const v1Higher = comparison > 0; + const highVersion = v1Higher ? v1 : v2; + const lowVersion = v1Higher ? v2 : v1; + const highHasPre = !!highVersion.prerelease.length; + const lowHasPre = !!lowVersion.prerelease.length; + if (lowHasPre && !highHasPre) { + if (!lowVersion.patch && !lowVersion.minor) { + return "major"; + } + if (lowVersion.compareMain(highVersion) === 0) { + if (lowVersion.minor && !lowVersion.patch) { + return "minor"; + } + return "patch"; + } + } + const prefix = highHasPre ? "pre" : ""; + if (v1.major !== v2.major) { + return prefix + "major"; + } + if (v1.minor !== v2.minor) { + return prefix + "minor"; + } + if (v1.patch !== v2.patch) { + return prefix + "patch"; + } + return "prerelease"; +}; +var diff_1 = diff$1; +const SemVer$a = semver$2; +const major$1 = (a, loose) => new SemVer$a(a, loose).major; +var major_1 = major$1; +const SemVer$9 = semver$2; +const minor$1 = (a, loose) => new SemVer$9(a, loose).minor; +var minor_1 = minor$1; +const SemVer$8 = semver$2; +const patch$1 = (a, loose) => new SemVer$8(a, loose).patch; +var patch_1 = patch$1; +const parse$2 = parse_1; +const prerelease$1 = (version, options) => { + const parsed = parse$2(version, options); + return parsed && parsed.prerelease.length ? parsed.prerelease : null; +}; +var prerelease_1 = prerelease$1; +const SemVer$7 = semver$2; +const compare$b = (a, b, loose) => new SemVer$7(a, loose).compare(new SemVer$7(b, loose)); +var compare_1 = compare$b; +const compare$a = compare_1; +const rcompare$1 = (a, b, loose) => compare$a(b, a, loose); +var rcompare_1 = rcompare$1; +const compare$9 = compare_1; +const compareLoose$1 = (a, b) => compare$9(a, b, true); +var compareLoose_1 = compareLoose$1; +const SemVer$6 = semver$2; +const compareBuild$3 = (a, b, loose) => { + const versionA = new SemVer$6(a, loose); + const versionB = new SemVer$6(b, loose); + return versionA.compare(versionB) || versionA.compareBuild(versionB); +}; +var compareBuild_1 = compareBuild$3; +const compareBuild$2 = compareBuild_1; +const sort$1 = (list, loose) => list.sort((a, b) => compareBuild$2(a, b, loose)); +var sort_1 = sort$1; +const compareBuild$1 = compareBuild_1; +const rsort$1 = (list, loose) => list.sort((a, b) => compareBuild$1(b, a, loose)); +var rsort_1 = rsort$1; +const compare$8 = compare_1; +const gt$4 = (a, b, loose) => compare$8(a, b, loose) > 0; +var gt_1 = gt$4; +const compare$7 = compare_1; +const lt$3 = (a, b, loose) => compare$7(a, b, loose) < 0; +var lt_1 = lt$3; +const compare$6 = compare_1; +const eq$2 = (a, b, loose) => compare$6(a, b, loose) === 0; +var eq_1 = eq$2; +const compare$5 = compare_1; +const neq$2 = (a, b, loose) => compare$5(a, b, loose) !== 0; +var neq_1 = neq$2; +const compare$4 = compare_1; +const gte$3 = (a, b, loose) => compare$4(a, b, loose) >= 0; +var gte_1 = gte$3; +const compare$3 = compare_1; +const lte$3 = (a, b, loose) => compare$3(a, b, loose) <= 0; +var lte_1 = lte$3; +const eq$1 = eq_1; +const neq$1 = neq_1; +const gt$3 = gt_1; +const gte$2 = gte_1; +const lt$2 = lt_1; +const lte$2 = lte_1; +const cmp$1 = (a, op, b, loose) => { + switch (op) { + case "===": + if (typeof a === "object") { + a = a.version; + } + if (typeof b === "object") { + b = b.version; + } + return a === b; + case "!==": + if (typeof a === "object") { + a = a.version; + } + if (typeof b === "object") { + b = b.version; + } + return a !== b; + case "": + case "=": + case "==": + return eq$1(a, b, loose); + case "!=": + return neq$1(a, b, loose); + case ">": + return gt$3(a, b, loose); + case ">=": + return gte$2(a, b, loose); + case "<": + return lt$2(a, b, loose); + case "<=": + return lte$2(a, b, loose); + default: + throw new TypeError(`Invalid operator: ${op}`); + } +}; +var cmp_1 = cmp$1; +const SemVer$5 = semver$2; +const parse$1 = parse_1; +const { safeRe: re, t } = reExports; +const coerce$1 = (version, options) => { + if (version instanceof SemVer$5) { + return version; + } + if (typeof version === "number") { + version = String(version); + } + if (typeof version !== "string") { + return null; + } + options = options || {}; + let match = null; + if (!options.rtl) { + match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]); + } else { + const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL]; + let next2; + while ((next2 = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) { + if (!match || next2.index + next2[0].length !== match.index + match[0].length) { + match = next2; + } + coerceRtlRegex.lastIndex = next2.index + next2[1].length + next2[2].length; + } + coerceRtlRegex.lastIndex = -1; + } + if (match === null) { + return null; + } + const major2 = match[2]; + const minor2 = match[3] || "0"; + const patch2 = match[4] || "0"; + const prerelease2 = options.includePrerelease && match[5] ? `-${match[5]}` : ""; + const build = options.includePrerelease && match[6] ? `+${match[6]}` : ""; + return parse$1(`${major2}.${minor2}.${patch2}${prerelease2}${build}`, options); +}; +var coerce_1 = coerce$1; +class LRUCache { + constructor() { + this.max = 1e3; + this.map = /* @__PURE__ */ new Map(); + } + get(key) { + const value = this.map.get(key); + if (value === void 0) { + return void 0; + } else { + this.map.delete(key); + this.map.set(key, value); + return value; + } + } + delete(key) { + return this.map.delete(key); + } + set(key, value) { + const deleted = this.delete(key); + if (!deleted && value !== void 0) { + if (this.map.size >= this.max) { + const firstKey = this.map.keys().next().value; + this.delete(firstKey); + } + this.map.set(key, value); + } + return this; + } +} +var lrucache = LRUCache; +var range; +var hasRequiredRange; +function requireRange() { + if (hasRequiredRange) return range; + hasRequiredRange = 1; + const SPACE_CHARACTERS = /\s+/g; + class Range2 { + constructor(range2, options) { + options = parseOptions2(options); + if (range2 instanceof Range2) { + if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) { + return range2; + } else { + return new Range2(range2.raw, options); + } + } + if (range2 instanceof Comparator2) { + this.raw = range2.value; + this.set = [[range2]]; + this.formatted = void 0; + return this; + } + this.options = options; + this.loose = !!options.loose; + this.includePrerelease = !!options.includePrerelease; + this.raw = range2.trim().replace(SPACE_CHARACTERS, " "); + this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length); + if (!this.set.length) { + throw new TypeError(`Invalid SemVer Range: ${this.raw}`); + } + if (this.set.length > 1) { + const first = this.set[0]; + this.set = this.set.filter((c) => !isNullSet(c[0])); + if (this.set.length === 0) { + this.set = [first]; + } else if (this.set.length > 1) { + for (const c of this.set) { + if (c.length === 1 && isAny(c[0])) { + this.set = [c]; + break; + } + } + } + } + this.formatted = void 0; + } + get range() { + if (this.formatted === void 0) { + this.formatted = ""; + for (let i = 0; i < this.set.length; i++) { + if (i > 0) { + this.formatted += "||"; + } + const comps = this.set[i]; + for (let k = 0; k < comps.length; k++) { + if (k > 0) { + this.formatted += " "; + } + this.formatted += comps[k].toString().trim(); + } + } + } + return this.formatted; + } + format() { + return this.range; + } + toString() { + return this.range; + } + parseRange(range2) { + const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE); + const memoKey = memoOpts + ":" + range2; + const cached = cache.get(memoKey); + if (cached) { + return cached; + } + const loose = this.options.loose; + const hr = loose ? re2[t2.HYPHENRANGELOOSE] : re2[t2.HYPHENRANGE]; + range2 = range2.replace(hr, hyphenReplace(this.options.includePrerelease)); + debug2("hyphen replace", range2); + range2 = range2.replace(re2[t2.COMPARATORTRIM], comparatorTrimReplace); + debug2("comparator trim", range2); + range2 = range2.replace(re2[t2.TILDETRIM], tildeTrimReplace); + debug2("tilde trim", range2); + range2 = range2.replace(re2[t2.CARETTRIM], caretTrimReplace); + debug2("caret trim", range2); + let rangeList = range2.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options)); + if (loose) { + rangeList = rangeList.filter((comp) => { + debug2("loose invalid filter", comp, this.options); + return !!comp.match(re2[t2.COMPARATORLOOSE]); + }); + } + debug2("range list", rangeList); + const rangeMap = /* @__PURE__ */ new Map(); + const comparators = rangeList.map((comp) => new Comparator2(comp, this.options)); + for (const comp of comparators) { + if (isNullSet(comp)) { + return [comp]; + } + rangeMap.set(comp.value, comp); + } + if (rangeMap.size > 1 && rangeMap.has("")) { + rangeMap.delete(""); + } + const result = [...rangeMap.values()]; + cache.set(memoKey, result); + return result; + } + intersects(range2, options) { + if (!(range2 instanceof Range2)) { + throw new TypeError("a Range is required"); + } + return this.set.some((thisComparators) => { + return isSatisfiable(thisComparators, options) && range2.set.some((rangeComparators) => { + return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => { + return rangeComparators.every((rangeComparator) => { + return thisComparator.intersects(rangeComparator, options); + }); + }); + }); + }); + } + // if ANY of the sets match ALL of its comparators, then pass + test(version) { + if (!version) { + return false; + } + if (typeof version === "string") { + try { + version = new SemVer3(version, this.options); + } catch (er) { + return false; + } + } + for (let i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version, this.options)) { + return true; + } + } + return false; + } + } + range = Range2; + const LRU = lrucache; + const cache = new LRU(); + const parseOptions2 = parseOptions_1; + const Comparator2 = requireComparator(); + const debug2 = debug_1; + const SemVer3 = semver$2; + const { + safeRe: re2, + t: t2, + comparatorTrimReplace, + tildeTrimReplace, + caretTrimReplace + } = reExports; + const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = constants$1; + const isNullSet = (c) => c.value === "<0.0.0-0"; + const isAny = (c) => c.value === ""; + const isSatisfiable = (comparators, options) => { + let result = true; + const remainingComparators = comparators.slice(); + let testComparator = remainingComparators.pop(); + while (result && remainingComparators.length) { + result = remainingComparators.every((otherComparator) => { + return testComparator.intersects(otherComparator, options); + }); + testComparator = remainingComparators.pop(); + } + return result; + }; + const parseComparator = (comp, options) => { + comp = comp.replace(re2[t2.BUILD], ""); + debug2("comp", comp, options); + comp = replaceCarets(comp, options); + debug2("caret", comp); + comp = replaceTildes(comp, options); + debug2("tildes", comp); + comp = replaceXRanges(comp, options); + debug2("xrange", comp); + comp = replaceStars(comp, options); + debug2("stars", comp); + return comp; + }; + const isX = (id2) => !id2 || id2.toLowerCase() === "x" || id2 === "*"; + const replaceTildes = (comp, options) => { + return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" "); + }; + const replaceTilde = (comp, options) => { + const r = options.loose ? re2[t2.TILDELOOSE] : re2[t2.TILDE]; + return comp.replace(r, (_, M, m, p, pr) => { + debug2("tilde", comp, _, M, m, p, pr); + let ret; + if (isX(M)) { + ret = ""; + } else if (isX(m)) { + ret = `>=${M}.0.0 <${+M + 1}.0.0-0`; + } else if (isX(p)) { + ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`; + } else if (pr) { + debug2("replaceTilde pr", pr); + ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`; + } else { + ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`; + } + debug2("tilde return", ret); + return ret; + }); + }; + const replaceCarets = (comp, options) => { + return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" "); + }; + const replaceCaret = (comp, options) => { + debug2("caret", comp, options); + const r = options.loose ? re2[t2.CARETLOOSE] : re2[t2.CARET]; + const z = options.includePrerelease ? "-0" : ""; + return comp.replace(r, (_, M, m, p, pr) => { + debug2("caret", comp, _, M, m, p, pr); + let ret; + if (isX(M)) { + ret = ""; + } else if (isX(m)) { + ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`; + } else if (isX(p)) { + if (M === "0") { + ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`; + } else { + ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`; + } + } else if (pr) { + debug2("replaceCaret pr", pr); + if (M === "0") { + if (m === "0") { + ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`; + } else { + ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`; + } + } else { + ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`; + } + } else { + debug2("no pr"); + if (M === "0") { + if (m === "0") { + ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`; + } else { + ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`; + } + } else { + ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`; + } + } + debug2("caret return", ret); + return ret; + }); + }; + const replaceXRanges = (comp, options) => { + debug2("replaceXRanges", comp, options); + return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" "); + }; + const replaceXRange = (comp, options) => { + comp = comp.trim(); + const r = options.loose ? re2[t2.XRANGELOOSE] : re2[t2.XRANGE]; + return comp.replace(r, (ret, gtlt, M, m, p, pr) => { + debug2("xRange", comp, ret, gtlt, M, m, p, pr); + const xM = isX(M); + const xm = xM || isX(m); + const xp = xm || isX(p); + const anyX = xp; + if (gtlt === "=" && anyX) { + gtlt = ""; + } + pr = options.includePrerelease ? "-0" : ""; + if (xM) { + if (gtlt === ">" || gtlt === "<") { + ret = "<0.0.0-0"; + } else { + ret = "*"; + } + } else if (gtlt && anyX) { + if (xm) { + m = 0; + } + p = 0; + if (gtlt === ">") { + gtlt = ">="; + if (xm) { + M = +M + 1; + m = 0; + p = 0; + } else { + m = +m + 1; + p = 0; + } + } else if (gtlt === "<=") { + gtlt = "<"; + if (xm) { + M = +M + 1; + } else { + m = +m + 1; + } + } + if (gtlt === "<") { + pr = "-0"; + } + ret = `${gtlt + M}.${m}.${p}${pr}`; + } else if (xm) { + ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`; + } else if (xp) { + ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`; + } + debug2("xRange return", ret); + return ret; + }); + }; + const replaceStars = (comp, options) => { + debug2("replaceStars", comp, options); + return comp.trim().replace(re2[t2.STAR], ""); + }; + const replaceGTE0 = (comp, options) => { + debug2("replaceGTE0", comp, options); + return comp.trim().replace(re2[options.includePrerelease ? t2.GTE0PRE : t2.GTE0], ""); + }; + const hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => { + if (isX(fM)) { + from = ""; + } else if (isX(fm)) { + from = `>=${fM}.0.0${incPr ? "-0" : ""}`; + } else if (isX(fp)) { + from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`; + } else if (fpr) { + from = `>=${from}`; + } else { + from = `>=${from}${incPr ? "-0" : ""}`; + } + if (isX(tM)) { + to = ""; + } else if (isX(tm)) { + to = `<${+tM + 1}.0.0-0`; + } else if (isX(tp)) { + to = `<${tM}.${+tm + 1}.0-0`; + } else if (tpr) { + to = `<=${tM}.${tm}.${tp}-${tpr}`; + } else if (incPr) { + to = `<${tM}.${tm}.${+tp + 1}-0`; + } else { + to = `<=${to}`; + } + return `${from} ${to}`.trim(); + }; + const testSet = (set, version, options) => { + for (let i = 0; i < set.length; i++) { + if (!set[i].test(version)) { + return false; + } + } + if (version.prerelease.length && !options.includePrerelease) { + for (let i = 0; i < set.length; i++) { + debug2(set[i].semver); + if (set[i].semver === Comparator2.ANY) { + continue; + } + if (set[i].semver.prerelease.length > 0) { + const allowed = set[i].semver; + if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) { + return true; + } + } + } + return false; + } + return true; + }; + return range; +} +var comparator; +var hasRequiredComparator; +function requireComparator() { + if (hasRequiredComparator) return comparator; + hasRequiredComparator = 1; + const ANY2 = Symbol("SemVer ANY"); + class Comparator2 { + static get ANY() { + return ANY2; + } + constructor(comp, options) { + options = parseOptions2(options); + if (comp instanceof Comparator2) { + if (comp.loose === !!options.loose) { + return comp; + } else { + comp = comp.value; + } + } + comp = comp.trim().split(/\s+/).join(" "); + debug2("comparator", comp, options); + this.options = options; + this.loose = !!options.loose; + this.parse(comp); + if (this.semver === ANY2) { + this.value = ""; + } else { + this.value = this.operator + this.semver.version; + } + debug2("comp", this); + } + parse(comp) { + const r = this.options.loose ? re2[t2.COMPARATORLOOSE] : re2[t2.COMPARATOR]; + const m = comp.match(r); + if (!m) { + throw new TypeError(`Invalid comparator: ${comp}`); + } + this.operator = m[1] !== void 0 ? m[1] : ""; + if (this.operator === "=") { + this.operator = ""; + } + if (!m[2]) { + this.semver = ANY2; + } else { + this.semver = new SemVer3(m[2], this.options.loose); + } + } + toString() { + return this.value; + } + test(version) { + debug2("Comparator.test", version, this.options.loose); + if (this.semver === ANY2 || version === ANY2) { + return true; + } + if (typeof version === "string") { + try { + version = new SemVer3(version, this.options); + } catch (er) { + return false; + } + } + return cmp2(version, this.operator, this.semver, this.options); + } + intersects(comp, options) { + if (!(comp instanceof Comparator2)) { + throw new TypeError("a Comparator is required"); + } + if (this.operator === "") { + if (this.value === "") { + return true; + } + return new Range2(comp.value, options).test(this.value); + } else if (comp.operator === "") { + if (comp.value === "") { + return true; + } + return new Range2(this.value, options).test(comp.semver); + } + options = parseOptions2(options); + if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) { + return false; + } + if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) { + return false; + } + if (this.operator.startsWith(">") && comp.operator.startsWith(">")) { + return true; + } + if (this.operator.startsWith("<") && comp.operator.startsWith("<")) { + return true; + } + if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) { + return true; + } + if (cmp2(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) { + return true; + } + if (cmp2(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) { + return true; + } + return false; + } + } + comparator = Comparator2; + const parseOptions2 = parseOptions_1; + const { safeRe: re2, t: t2 } = reExports; + const cmp2 = cmp_1; + const debug2 = debug_1; + const SemVer3 = semver$2; + const Range2 = requireRange(); + return comparator; +} +const Range$9 = requireRange(); +const satisfies$4 = (version, range2, options) => { + try { + range2 = new Range$9(range2, options); + } catch (er) { + return false; + } + return range2.test(version); +}; +var satisfies_1 = satisfies$4; +const Range$8 = requireRange(); +const toComparators$1 = (range2, options) => new Range$8(range2, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" ")); +var toComparators_1 = toComparators$1; +const SemVer$4 = semver$2; +const Range$7 = requireRange(); +const maxSatisfying$1 = (versions, range2, options) => { + let max = null; + let maxSV = null; + let rangeObj = null; + try { + rangeObj = new Range$7(range2, options); + } catch (er) { + return null; + } + versions.forEach((v) => { + if (rangeObj.test(v)) { + if (!max || maxSV.compare(v) === -1) { + max = v; + maxSV = new SemVer$4(max, options); + } + } + }); + return max; +}; +var maxSatisfying_1 = maxSatisfying$1; +const SemVer$3 = semver$2; +const Range$6 = requireRange(); +const minSatisfying$1 = (versions, range2, options) => { + let min = null; + let minSV = null; + let rangeObj = null; + try { + rangeObj = new Range$6(range2, options); + } catch (er) { + return null; + } + versions.forEach((v) => { + if (rangeObj.test(v)) { + if (!min || minSV.compare(v) === 1) { + min = v; + minSV = new SemVer$3(min, options); + } + } + }); + return min; +}; +var minSatisfying_1 = minSatisfying$1; +const SemVer$2 = semver$2; +const Range$5 = requireRange(); +const gt$2 = gt_1; +const minVersion$1 = (range2, loose) => { + range2 = new Range$5(range2, loose); + let minver = new SemVer$2("0.0.0"); + if (range2.test(minver)) { + return minver; + } + minver = new SemVer$2("0.0.0-0"); + if (range2.test(minver)) { + return minver; + } + minver = null; + for (let i = 0; i < range2.set.length; ++i) { + const comparators = range2.set[i]; + let setMin = null; + comparators.forEach((comparator2) => { + const compver = new SemVer$2(comparator2.semver.version); + switch (comparator2.operator) { + case ">": + if (compver.prerelease.length === 0) { + compver.patch++; + } else { + compver.prerelease.push(0); + } + compver.raw = compver.format(); + case "": + case ">=": + if (!setMin || gt$2(compver, setMin)) { + setMin = compver; + } + break; + case "<": + case "<=": + break; + default: + throw new Error(`Unexpected operation: ${comparator2.operator}`); + } + }); + if (setMin && (!minver || gt$2(minver, setMin))) { + minver = setMin; + } + } + if (minver && range2.test(minver)) { + return minver; + } + return null; +}; +var minVersion_1 = minVersion$1; +const Range$4 = requireRange(); +const validRange$1 = (range2, options) => { + try { + return new Range$4(range2, options).range || "*"; + } catch (er) { + return null; + } +}; +var valid$1 = validRange$1; +const SemVer$1 = semver$2; +const Comparator$2 = requireComparator(); +const { ANY: ANY$1 } = Comparator$2; +const Range$3 = requireRange(); +const satisfies$3 = satisfies_1; +const gt$1 = gt_1; +const lt$1 = lt_1; +const lte$1 = lte_1; +const gte$1 = gte_1; +const outside$3 = (version, range2, hilo, options) => { + version = new SemVer$1(version, options); + range2 = new Range$3(range2, options); + let gtfn, ltefn, ltfn, comp, ecomp; + switch (hilo) { + case ">": + gtfn = gt$1; + ltefn = lte$1; + ltfn = lt$1; + comp = ">"; + ecomp = ">="; + break; + case "<": + gtfn = lt$1; + ltefn = gte$1; + ltfn = gt$1; + comp = "<"; + ecomp = "<="; + break; + default: + throw new TypeError('Must provide a hilo val of "<" or ">"'); + } + if (satisfies$3(version, range2, options)) { + return false; + } + for (let i = 0; i < range2.set.length; ++i) { + const comparators = range2.set[i]; + let high = null; + let low = null; + comparators.forEach((comparator2) => { + if (comparator2.semver === ANY$1) { + comparator2 = new Comparator$2(">=0.0.0"); + } + high = high || comparator2; + low = low || comparator2; + if (gtfn(comparator2.semver, high.semver, options)) { + high = comparator2; + } else if (ltfn(comparator2.semver, low.semver, options)) { + low = comparator2; + } + }); + if (high.operator === comp || high.operator === ecomp) { + return false; + } + if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) { + return false; + } else if (low.operator === ecomp && ltfn(version, low.semver)) { + return false; + } + } + return true; +}; +var outside_1 = outside$3; +const outside$2 = outside_1; +const gtr$1 = (version, range2, options) => outside$2(version, range2, ">", options); +var gtr_1 = gtr$1; +const outside$1 = outside_1; +const ltr$1 = (version, range2, options) => outside$1(version, range2, "<", options); +var ltr_1 = ltr$1; +const Range$2 = requireRange(); +const intersects$1 = (r1, r2, options) => { + r1 = new Range$2(r1, options); + r2 = new Range$2(r2, options); + return r1.intersects(r2, options); +}; +var intersects_1 = intersects$1; +const satisfies$2 = satisfies_1; +const compare$2 = compare_1; +var simplify = (versions, range2, options) => { + const set = []; + let first = null; + let prev = null; + const v = versions.sort((a, b) => compare$2(a, b, options)); + for (const version of v) { + const included = satisfies$2(version, range2, options); + if (included) { + prev = version; + if (!first) { + first = version; + } + } else { + if (prev) { + set.push([first, prev]); + } + prev = null; + first = null; + } + } + if (first) { + set.push([first, null]); + } + const ranges = []; + for (const [min, max] of set) { + if (min === max) { + ranges.push(min); + } else if (!max && min === v[0]) { + ranges.push("*"); + } else if (!max) { + ranges.push(`>=${min}`); + } else if (min === v[0]) { + ranges.push(`<=${max}`); + } else { + ranges.push(`${min} - ${max}`); + } + } + const simplified = ranges.join(" || "); + const original = typeof range2.raw === "string" ? range2.raw : String(range2); + return simplified.length < original.length ? simplified : range2; +}; +const Range$1 = requireRange(); +const Comparator$1 = requireComparator(); +const { ANY } = Comparator$1; +const satisfies$1 = satisfies_1; +const compare$1 = compare_1; +const subset$1 = (sub, dom, options = {}) => { + if (sub === dom) { + return true; + } + sub = new Range$1(sub, options); + dom = new Range$1(dom, options); + let sawNonNull = false; + OUTER: for (const simpleSub of sub.set) { + for (const simpleDom of dom.set) { + const isSub = simpleSubset(simpleSub, simpleDom, options); + sawNonNull = sawNonNull || isSub !== null; + if (isSub) { + continue OUTER; + } + } + if (sawNonNull) { + return false; + } + } + return true; +}; +const minimumVersionWithPreRelease = [new Comparator$1(">=0.0.0-0")]; +const minimumVersion = [new Comparator$1(">=0.0.0")]; +const simpleSubset = (sub, dom, options) => { + if (sub === dom) { + return true; + } + if (sub.length === 1 && sub[0].semver === ANY) { + if (dom.length === 1 && dom[0].semver === ANY) { + return true; + } else if (options.includePrerelease) { + sub = minimumVersionWithPreRelease; + } else { + sub = minimumVersion; + } + } + if (dom.length === 1 && dom[0].semver === ANY) { + if (options.includePrerelease) { + return true; + } else { + dom = minimumVersion; + } + } + const eqSet = /* @__PURE__ */ new Set(); + let gt2, lt2; + for (const c of sub) { + if (c.operator === ">" || c.operator === ">=") { + gt2 = higherGT(gt2, c, options); + } else if (c.operator === "<" || c.operator === "<=") { + lt2 = lowerLT(lt2, c, options); + } else { + eqSet.add(c.semver); + } + } + if (eqSet.size > 1) { + return null; + } + let gtltComp; + if (gt2 && lt2) { + gtltComp = compare$1(gt2.semver, lt2.semver, options); + if (gtltComp > 0) { + return null; + } else if (gtltComp === 0 && (gt2.operator !== ">=" || lt2.operator !== "<=")) { + return null; + } + } + for (const eq2 of eqSet) { + if (gt2 && !satisfies$1(eq2, String(gt2), options)) { + return null; + } + if (lt2 && !satisfies$1(eq2, String(lt2), options)) { + return null; + } + for (const c of dom) { + if (!satisfies$1(eq2, String(c), options)) { + return false; + } + } + return true; + } + let higher, lower; + let hasDomLT, hasDomGT; + let needDomLTPre = lt2 && !options.includePrerelease && lt2.semver.prerelease.length ? lt2.semver : false; + let needDomGTPre = gt2 && !options.includePrerelease && gt2.semver.prerelease.length ? gt2.semver : false; + if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt2.operator === "<" && needDomLTPre.prerelease[0] === 0) { + needDomLTPre = false; + } + for (const c of dom) { + hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">="; + hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<="; + if (gt2) { + if (needDomGTPre) { + if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) { + needDomGTPre = false; + } + } + if (c.operator === ">" || c.operator === ">=") { + higher = higherGT(gt2, c, options); + if (higher === c && higher !== gt2) { + return false; + } + } else if (gt2.operator === ">=" && !satisfies$1(gt2.semver, String(c), options)) { + return false; + } + } + if (lt2) { + if (needDomLTPre) { + if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) { + needDomLTPre = false; + } + } + if (c.operator === "<" || c.operator === "<=") { + lower = lowerLT(lt2, c, options); + if (lower === c && lower !== lt2) { + return false; + } + } else if (lt2.operator === "<=" && !satisfies$1(lt2.semver, String(c), options)) { + return false; + } + } + if (!c.operator && (lt2 || gt2) && gtltComp !== 0) { + return false; + } + } + if (gt2 && hasDomLT && !lt2 && gtltComp !== 0) { + return false; + } + if (lt2 && hasDomGT && !gt2 && gtltComp !== 0) { + return false; + } + if (needDomGTPre || needDomLTPre) { + return false; + } + return true; +}; +const higherGT = (a, b, options) => { + if (!a) { + return b; + } + const comp = compare$1(a.semver, b.semver, options); + return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a; +}; +const lowerLT = (a, b, options) => { + if (!a) { + return b; + } + const comp = compare$1(a.semver, b.semver, options); + return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a; +}; +var subset_1 = subset$1; +const internalRe = reExports; +const constants = constants$1; +const SemVer2 = semver$2; +const identifiers = identifiers$1; +const parse = parse_1; +const valid = valid_1; +const clean = clean_1; +const inc = inc_1; +const diff = diff_1; +const major = major_1; +const minor = minor_1; +const patch = patch_1; +const prerelease = prerelease_1; +const compare = compare_1; +const rcompare = rcompare_1; +const compareLoose = compareLoose_1; +const compareBuild = compareBuild_1; +const sort = sort_1; +const rsort = rsort_1; +const gt = gt_1; +const lt = lt_1; +const eq = eq_1; +const neq = neq_1; +const gte = gte_1; +const lte = lte_1; +const cmp = cmp_1; +const coerce = coerce_1; +const Comparator = requireComparator(); +const Range = requireRange(); +const satisfies = satisfies_1; +const toComparators = toComparators_1; +const maxSatisfying = maxSatisfying_1; +const minSatisfying = minSatisfying_1; +const minVersion = minVersion_1; +const validRange = valid$1; +const outside = outside_1; +const gtr = gtr_1; +const ltr = ltr_1; +const intersects = intersects_1; +const simplifyRange = simplify; +const subset = subset_1; +var semver = { + parse, + valid, + clean, + inc, + diff, + major, + minor, + patch, + prerelease, + compare, + rcompare, + compareLoose, + compareBuild, + sort, + rsort, + gt, + lt, + eq, + neq, + gte, + lte, + cmp, + coerce, + Comparator, + Range, + satisfies, + toComparators, + maxSatisfying, + minSatisfying, + minVersion, + validRange, + outside, + gtr, + ltr, + intersects, + simplifyRange, + subset, + SemVer: SemVer2, + re: internalRe.re, + src: internalRe.src, + tokens: internalRe.t, + SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION, + RELEASE_TYPES: constants.RELEASE_TYPES, + compareIdentifiers: identifiers.compareIdentifiers, + rcompareIdentifiers: identifiers.rcompareIdentifiers +}; +const semver$1 = /* @__PURE__ */ getDefaultExportFromCjs(semver); +const objectToString = Object.prototype.toString; +const uint8ArrayStringified = "[object Uint8Array]"; +const arrayBufferStringified = "[object ArrayBuffer]"; +function isType(value, typeConstructor, typeStringified) { + if (!value) { + return false; + } + if (value.constructor === typeConstructor) { + return true; + } + return objectToString.call(value) === typeStringified; +} +function isUint8Array(value) { + return isType(value, Uint8Array, uint8ArrayStringified); +} +function isArrayBuffer(value) { + return isType(value, ArrayBuffer, arrayBufferStringified); +} +function isUint8ArrayOrArrayBuffer(value) { + return isUint8Array(value) || isArrayBuffer(value); +} +function assertUint8Array(value) { + if (!isUint8Array(value)) { + throw new TypeError(`Expected \`Uint8Array\`, got \`${typeof value}\``); + } +} +function assertUint8ArrayOrArrayBuffer(value) { + if (!isUint8ArrayOrArrayBuffer(value)) { + throw new TypeError(`Expected \`Uint8Array\` or \`ArrayBuffer\`, got \`${typeof value}\``); + } +} +function concatUint8Arrays(arrays, totalLength) { + if (arrays.length === 0) { + return new Uint8Array(0); + } + totalLength ??= arrays.reduce((accumulator, currentValue) => accumulator + currentValue.length, 0); + const returnValue = new Uint8Array(totalLength); + let offset = 0; + for (const array of arrays) { + assertUint8Array(array); + returnValue.set(array, offset); + offset += array.length; + } + return returnValue; +} +const cachedDecoders = { + utf8: new globalThis.TextDecoder("utf8") +}; +function uint8ArrayToString(array, encoding = "utf8") { + assertUint8ArrayOrArrayBuffer(array); + cachedDecoders[encoding] ??= new globalThis.TextDecoder(encoding); + return cachedDecoders[encoding].decode(array); +} +function assertString(value) { + if (typeof value !== "string") { + throw new TypeError(`Expected \`string\`, got \`${typeof value}\``); + } +} +const cachedEncoder = new globalThis.TextEncoder(); +function stringToUint8Array(string) { + assertString(string); + return cachedEncoder.encode(string); +} +Array.from({ length: 256 }, (_, index) => index.toString(16).padStart(2, "0")); +const ajvFormats = ajvFormatsModule.default; +const encryptionAlgorithm = "aes-256-cbc"; +const createPlainObject = () => /* @__PURE__ */ Object.create(null); +const isExist = (data) => data !== void 0 && data !== null; +const checkValueType = (key, value) => { + const nonJsonTypes = /* @__PURE__ */ new Set([ + "undefined", + "symbol", + "function" + ]); + const type2 = typeof value; + if (nonJsonTypes.has(type2)) { + throw new TypeError(`Setting a value of type \`${type2}\` for key \`${key}\` is not allowed as it's not supported by JSON`); + } +}; +const INTERNAL_KEY = "__internal__"; +const MIGRATION_KEY = `${INTERNAL_KEY}.migrations.version`; +class Conf { + path; + events; + #validator; + #encryptionKey; + #options; + #defaultValues = {}; + constructor(partialOptions = {}) { + const options = { + configName: "config", + fileExtension: "json", + projectSuffix: "nodejs", + clearInvalidConfig: false, + accessPropertiesByDotNotation: true, + configFileMode: 438, + ...partialOptions + }; + if (!options.cwd) { + if (!options.projectName) { + throw new Error("Please specify the `projectName` option."); + } + options.cwd = envPaths(options.projectName, { suffix: options.projectSuffix }).config; + } + this.#options = options; + if (options.schema ?? options.ajvOptions ?? options.rootSchema) { + if (options.schema && typeof options.schema !== "object") { + throw new TypeError("The `schema` option must be an object."); + } + const ajv2 = new _2020Exports.Ajv2020({ + allErrors: true, + useDefaults: true, + ...options.ajvOptions + }); + ajvFormats(ajv2); + const schema = { + ...options.rootSchema, + type: "object", + properties: options.schema + }; + this.#validator = ajv2.compile(schema); + for (const [key, value] of Object.entries(options.schema ?? {})) { + if (value?.default) { + this.#defaultValues[key] = value.default; + } + } + } + if (options.defaults) { + this.#defaultValues = { + ...this.#defaultValues, + ...options.defaults + }; + } + if (options.serialize) { + this._serialize = options.serialize; + } + if (options.deserialize) { + this._deserialize = options.deserialize; + } + this.events = new EventTarget(); + this.#encryptionKey = options.encryptionKey; + const fileExtension = options.fileExtension ? `.${options.fileExtension}` : ""; + this.path = path.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`); + const fileStore = this.store; + const store2 = Object.assign(createPlainObject(), options.defaults, fileStore); + if (options.migrations) { + if (!options.projectVersion) { + throw new Error("Please specify the `projectVersion` option."); + } + this._migrate(options.migrations, options.projectVersion, options.beforeEachMigration); + } + this._validate(store2); + try { + assert.deepEqual(fileStore, store2); + } catch { + this.store = store2; + } + if (options.watch) { + this._watch(); + } + } + get(key, defaultValue) { + if (this.#options.accessPropertiesByDotNotation) { + return this._get(key, defaultValue); + } + const { store: store2 } = this; + return key in store2 ? store2[key] : defaultValue; + } + set(key, value) { + if (typeof key !== "string" && typeof key !== "object") { + throw new TypeError(`Expected \`key\` to be of type \`string\` or \`object\`, got ${typeof key}`); + } + if (typeof key !== "object" && value === void 0) { + throw new TypeError("Use `delete()` to clear values"); + } + if (this._containsReservedKey(key)) { + throw new TypeError(`Please don't use the ${INTERNAL_KEY} key, as it's used to manage this module internal operations.`); + } + const { store: store2 } = this; + const set = (key2, value2) => { + checkValueType(key2, value2); + if (this.#options.accessPropertiesByDotNotation) { + setProperty(store2, key2, value2); + } else { + store2[key2] = value2; + } + }; + if (typeof key === "object") { + const object = key; + for (const [key2, value2] of Object.entries(object)) { + set(key2, value2); + } + } else { + set(key, value); + } + this.store = store2; + } + has(key) { + if (this.#options.accessPropertiesByDotNotation) { + return hasProperty(this.store, key); + } + return key in this.store; + } + /** + Reset items to their default values, as defined by the `defaults` or `schema` option. + + @see `clear()` to reset all items. + + @param keys - The keys of the items to reset. + */ + reset(...keys) { + for (const key of keys) { + if (isExist(this.#defaultValues[key])) { + this.set(key, this.#defaultValues[key]); + } + } + } + delete(key) { + const { store: store2 } = this; + if (this.#options.accessPropertiesByDotNotation) { + deleteProperty(store2, key); + } else { + delete store2[key]; + } + this.store = store2; + } + /** + Delete all items. + + This resets known items to their default values, if defined by the `defaults` or `schema` option. + */ + clear() { + this.store = createPlainObject(); + for (const key of Object.keys(this.#defaultValues)) { + this.reset(key); + } + } + onDidChange(key, callback) { + if (typeof key !== "string") { + throw new TypeError(`Expected \`key\` to be of type \`string\`, got ${typeof key}`); + } + if (typeof callback !== "function") { + throw new TypeError(`Expected \`callback\` to be of type \`function\`, got ${typeof callback}`); + } + return this._handleChange(() => this.get(key), callback); + } + /** + Watches the whole config object, calling `callback` on any changes. + + @param callback - A callback function that is called on any changes. When a `key` is first set `oldValue` will be `undefined`, and when a key is deleted `newValue` will be `undefined`. + @returns A function, that when called, will unsubscribe. + */ + onDidAnyChange(callback) { + if (typeof callback !== "function") { + throw new TypeError(`Expected \`callback\` to be of type \`function\`, got ${typeof callback}`); + } + return this._handleChange(() => this.store, callback); + } + get size() { + return Object.keys(this.store).length; + } + /** + Get all the config as an object or replace the current config with an object. + + @example + ``` + console.log(config.store); + //=> {name: 'John', age: 30} + ``` + + @example + ``` + config.store = { + hello: 'world' + }; + ``` + */ + get store() { + try { + const data = fs.readFileSync(this.path, this.#encryptionKey ? null : "utf8"); + const dataString = this._encryptData(data); + const deserializedData = this._deserialize(dataString); + this._validate(deserializedData); + return Object.assign(createPlainObject(), deserializedData); + } catch (error2) { + if (error2?.code === "ENOENT") { + this._ensureDirectory(); + return createPlainObject(); + } + if (this.#options.clearInvalidConfig && error2.name === "SyntaxError") { + return createPlainObject(); + } + throw error2; + } + } + set store(value) { + this._ensureDirectory(); + this._validate(value); + this._write(value); + this.events.dispatchEvent(new Event("change")); + } + *[Symbol.iterator]() { + for (const [key, value] of Object.entries(this.store)) { + yield [key, value]; + } + } + _encryptData(data) { + if (!this.#encryptionKey) { + return typeof data === "string" ? data : uint8ArrayToString(data); + } + try { + const initializationVector = data.slice(0, 16); + const password = crypto.pbkdf2Sync(this.#encryptionKey, initializationVector.toString(), 1e4, 32, "sha512"); + const decipher = crypto.createDecipheriv(encryptionAlgorithm, password, initializationVector); + const slice = data.slice(17); + const dataUpdate = typeof slice === "string" ? stringToUint8Array(slice) : slice; + return uint8ArrayToString(concatUint8Arrays([decipher.update(dataUpdate), decipher.final()])); + } catch { + } + return data.toString(); + } + _handleChange(getter, callback) { + let currentValue = getter(); + const onChange = () => { + const oldValue = currentValue; + const newValue = getter(); + if (node_util.isDeepStrictEqual(newValue, oldValue)) { + return; + } + currentValue = newValue; + callback.call(this, newValue, oldValue); + }; + this.events.addEventListener("change", onChange); + return () => { + this.events.removeEventListener("change", onChange); + }; + } + _deserialize = (value) => JSON.parse(value); + _serialize = (value) => JSON.stringify(value, void 0, " "); + _validate(data) { + if (!this.#validator) { + return; + } + const valid2 = this.#validator(data); + if (valid2 || !this.#validator.errors) { + return; + } + const errors2 = this.#validator.errors.map(({ instancePath, message = "" }) => `\`${instancePath.slice(1)}\` ${message}`); + throw new Error("Config schema violation: " + errors2.join("; ")); + } + _ensureDirectory() { + fs.mkdirSync(path.dirname(this.path), { recursive: true }); + } + _write(value) { + let data = this._serialize(value); + if (this.#encryptionKey) { + const initializationVector = crypto.randomBytes(16); + const password = crypto.pbkdf2Sync(this.#encryptionKey, initializationVector.toString(), 1e4, 32, "sha512"); + const cipher = crypto.createCipheriv(encryptionAlgorithm, password, initializationVector); + data = concatUint8Arrays([initializationVector, stringToUint8Array(":"), cipher.update(stringToUint8Array(data)), cipher.final()]); + } + if (process$1.env.SNAP) { + fs.writeFileSync(this.path, data, { mode: this.#options.configFileMode }); + } else { + try { + writeFileSync(this.path, data, { mode: this.#options.configFileMode }); + } catch (error2) { + if (error2?.code === "EXDEV") { + fs.writeFileSync(this.path, data, { mode: this.#options.configFileMode }); + return; + } + throw error2; + } + } + } + _watch() { + this._ensureDirectory(); + if (!fs.existsSync(this.path)) { + this._write(createPlainObject()); + } + if (process$1.platform === "win32") { + fs.watch(this.path, { persistent: false }, debounceFunction(() => { + this.events.dispatchEvent(new Event("change")); + }, { wait: 100 })); + } else { + fs.watchFile(this.path, { persistent: false }, debounceFunction(() => { + this.events.dispatchEvent(new Event("change")); + }, { wait: 5e3 })); + } + } + _migrate(migrations, versionToMigrate, beforeEachMigration) { + let previousMigratedVersion = this._get(MIGRATION_KEY, "0.0.0"); + const newerVersions = Object.keys(migrations).filter((candidateVersion) => this._shouldPerformMigration(candidateVersion, previousMigratedVersion, versionToMigrate)); + let storeBackup = { ...this.store }; + for (const version of newerVersions) { + try { + if (beforeEachMigration) { + beforeEachMigration(this, { + fromVersion: previousMigratedVersion, + toVersion: version, + finalVersion: versionToMigrate, + versions: newerVersions + }); + } + const migration = migrations[version]; + migration?.(this); + this._set(MIGRATION_KEY, version); + previousMigratedVersion = version; + storeBackup = { ...this.store }; + } catch (error2) { + this.store = storeBackup; + throw new Error(`Something went wrong during the migration! Changes applied to the store until this failed migration will be restored. ${error2}`); + } + } + if (this._isVersionInRangeFormat(previousMigratedVersion) || !semver$1.eq(previousMigratedVersion, versionToMigrate)) { + this._set(MIGRATION_KEY, versionToMigrate); + } + } + _containsReservedKey(key) { + if (typeof key === "object") { + const firstKey = Object.keys(key)[0]; + if (firstKey === INTERNAL_KEY) { + return true; + } + } + if (typeof key !== "string") { + return false; + } + if (this.#options.accessPropertiesByDotNotation) { + if (key.startsWith(`${INTERNAL_KEY}.`)) { + return true; + } + return false; + } + return false; + } + _isVersionInRangeFormat(version) { + return semver$1.clean(version) === null; + } + _shouldPerformMigration(candidateVersion, previousMigratedVersion, versionToMigrate) { + if (this._isVersionInRangeFormat(candidateVersion)) { + if (previousMigratedVersion !== "0.0.0" && semver$1.satisfies(previousMigratedVersion, candidateVersion)) { + return false; + } + return semver$1.satisfies(versionToMigrate, candidateVersion); + } + if (semver$1.lte(candidateVersion, previousMigratedVersion)) { + return false; + } + if (semver$1.gt(candidateVersion, versionToMigrate)) { + return false; + } + return true; + } + _get(key, defaultValue) { + return getProperty(this.store, key, defaultValue); + } + _set(key, value) { + const { store: store2 } = this; + setProperty(store2, key, value); + this.store = store2; + } +} +const { app, ipcMain, shell } = electron; +let isInitialized = false; +const initDataListener = () => { + if (!ipcMain || !app) { + throw new Error("Electron Store: You need to call `.initRenderer()` from the main process."); + } + const appData = { + defaultCwd: app.getPath("userData"), + appVersion: app.getVersion() + }; + if (isInitialized) { + return appData; + } + ipcMain.on("electron-store-get-data", (event) => { + event.returnValue = appData; + }); + isInitialized = true; + return appData; +}; +class ElectronStore extends Conf { + constructor(options) { + let defaultCwd; + let appVersion; + if (process$1.type === "renderer") { + const appData = electron.ipcRenderer.sendSync("electron-store-get-data"); + if (!appData) { + throw new Error("Electron Store: You need to call `.initRenderer()` from the main process."); + } + ({ defaultCwd, appVersion } = appData); + } else if (ipcMain && app) { + ({ defaultCwd, appVersion } = initDataListener()); + } + options = { + name: "config", + ...options + }; + options.projectVersion ||= appVersion; + if (options.cwd) { + options.cwd = path.isAbsolute(options.cwd) ? options.cwd : path.join(defaultCwd, options.cwd); + } else { + options.cwd = defaultCwd; + } + options.configName = options.name; + delete options.name; + super(options); + } + static initRenderer() { + initDataListener(); + } + async openInEditor() { + const error2 = await shell.openPath(this.path); + if (error2) { + throw new Error(error2); + } + } +} +const __dirname$1 = path$1.dirname(url.fileURLToPath(require("url").pathToFileURL(__filename).href)); +const OSMIUM_ICON = "data:image/png;base64,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"; +function getIcon() { + const paths = [ + path$1.join(__dirname$1, "../../public/icon.png"), + path$1.join(__dirname$1, "../../../public/icon.png"), + path$1.join(process.resourcesPath, "public/icon.png") + ]; + for (const iconPath of paths) { + if (fs$1.existsSync(iconPath)) { + try { + const img = electron.nativeImage.createFromPath(iconPath); + if (!img.isEmpty()) { + return img; + } + } catch { + continue; + } + } + } + return electron.nativeImage.createFromDataURL(OSMIUM_ICON); +} +const store = new ElectronStore({ + defaults: { checks: [] } +}); +let mainWindow = null; +async function createWindow() { + const icon = getIcon(); + mainWindow = new electron.BrowserWindow({ + width: 1200, + height: 800, + minWidth: 800, + minHeight: 600, + frame: false, + backgroundColor: "#0a0a0a", + icon, + show: false, + webPreferences: { + preload: path$1.join(__dirname$1, "../preload/index.js"), + nodeIntegration: false, + contextIsolation: true + } + }); + mainWindow.once("ready-to-show", () => { + mainWindow?.show(); + }); + mainWindow.webContents.setWindowOpenHandler(({ url: url2 }) => { + electron.shell.openExternal(url2); + return { action: "deny" }; + }); + if (!electron.app.isPackaged) { + mainWindow.loadURL("http://localhost:5173"); + mainWindow.webContents.openDevTools(); + } else { + mainWindow.loadFile(path$1.join(__dirname$1, "../renderer/index.html")); + } +} +electron.app.whenReady().then(createWindow); +electron.app.on("window-all-closed", () => { + if (process.platform !== "darwin") electron.app.quit(); +}); +electron.app.on("activate", () => { + if (electron.BrowserWindow.getAllWindows().length === 0) createWindow(); +}); +electron.ipcMain.handle("window:minimize", () => mainWindow?.minimize()); +electron.ipcMain.handle("window:maximize", () => { + if (mainWindow?.isMaximized()) mainWindow.unmaximize(); + else mainWindow?.maximize(); +}); +electron.ipcMain.handle("window:close", () => mainWindow?.close()); +electron.ipcMain.handle("shell:open-external", async (_event, url2) => { + await electron.shell.openExternal(url2); +}); +electron.ipcMain.handle("store:get-checks", () => store.get("checks")); +electron.ipcMain.handle("store:clear-checks", () => store.set("checks", [])); +electron.ipcMain.handle("store:get-path", () => store.path); +electron.ipcMain.handle("check:run", async (_event, trackInput) => { + try { + const osmiumPath = path$1.join(__dirname$1, "../../.."); + const runnerUrl = url.pathToFileURL(path$1.join(osmiumPath, "dist/pipeline/runner.js")).href; + const configUrl = url.pathToFileURL(path$1.join(osmiumPath, "dist/config/index.js")).href; + const { PipelineRunner } = await import(runnerUrl); + const { getConfig } = await import(configUrl); + const config = getConfig(); + const pipeline = new PipelineRunner(config); + const sendProgress = (event) => { + mainWindow?.webContents.send("check:progress", event); + }; + pipeline.on("progress", sendProgress); + const verdict = await pipeline.run(trackInput, { verbose: false }); + const checks = store.get("checks") || []; + store.set("checks", [verdict, ...checks].slice(0, 50)); + return { success: true, verdict }; + } catch (error2) { + return { + success: false, + error: error2 instanceof Error ? error2.message : String(error2) + }; + } +}); diff --git a/desktop-app/out/preload/index.js b/desktop-app/out/preload/index.js new file mode 100644 index 0000000..519be17 --- /dev/null +++ b/desktop-app/out/preload/index.js @@ -0,0 +1,25 @@ +"use strict"; +const electron = require("electron"); +electron.contextBridge.exposeInMainWorld("osmium", { + window: { + minimize: () => electron.ipcRenderer.invoke("window:minimize"), + maximize: () => electron.ipcRenderer.invoke("window:maximize"), + close: () => electron.ipcRenderer.invoke("window:close") + }, + shell: { + openExternal: (url) => electron.ipcRenderer.invoke("shell:open-external", url) + }, + store: { + getChecks: () => electron.ipcRenderer.invoke("store:get-checks"), + clearChecks: () => electron.ipcRenderer.invoke("store:clear-checks"), + getPath: () => electron.ipcRenderer.invoke("store:get-path") + }, + check: { + run: (trackInput) => electron.ipcRenderer.invoke("check:run", trackInput), + onProgress: (callback) => { + const handler = (_, event) => callback(event); + electron.ipcRenderer.on("check:progress", handler); + return () => electron.ipcRenderer.removeListener("check:progress", handler); + } + } +}); diff --git a/desktop-app/package-lock.json b/desktop-app/package-lock.json new file mode 100644 index 0000000..bb496c3 --- /dev/null +++ b/desktop-app/package-lock.json @@ -0,0 +1,8142 @@ +{ + "name": "osmium-desktop", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "osmium-desktop", + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "electron-store": "^10.0.0" + }, + "devDependencies": { + "@types/node": "^22.13.0", + "@types/react": "^19.0.0", + "@types/react-dom": "^19.0.0", + "@vitejs/plugin-react": "^4.3.4", + "autoprefixer": "^10.4.20", + "electron": "^34.0.0", + "electron-builder": "^25.1.8", + "electron-vite": "^2.3.0", + "postcss": "^8.4.49", + "react": "^19.0.0", + "react-dom": "^19.0.0", + "tailwindcss": "^3.4.17", + "typescript": "^5.7.0", + "vite": "^5.4.0" + } + }, + "node_modules/@alloc/quick-lru": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz", + "integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz", + "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.28.5", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz", + "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", + "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-compilation-targets": "^7.28.6", + "@babel/helper-module-transforms": "^7.28.6", + "@babel/helpers": "^7.28.6", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/traverse": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/remapping": "^2.3.5", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/generator": { + "version": "7.29.1", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz", + "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz", + "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.28.6", + "@babel/helper-validator-option": "^7.27.1", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-globals": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz", + "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz", + "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz", + "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.28.6", + "@babel/helper-validator-identifier": "^7.28.5", + "@babel/traverse": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz", + "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", + "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz", + "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.6.tgz", + "integrity": "sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz", + "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.0" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-transform-arrow-functions": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.27.1.tgz", + "integrity": "sha512-8Z4TGic6xW70FKThA5HYEKKyBpOOsucTOD1DjU3fZxDg+K3zBJcXMFnt/4yQiZnf5+MiOMSXQ9PaEK/Ilh1DeA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-self": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz", + "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-source": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz", + "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/template": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz", + "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.28.6", + "@babel/parser": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", + "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-globals": "^7.28.0", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/types": "^7.29.0", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", + "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.28.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@develar/schema-utils": { + "version": "2.6.5", + "resolved": "https://registry.npmjs.org/@develar/schema-utils/-/schema-utils-2.6.5.tgz", + "integrity": "sha512-0cp4PsWQ/9avqTVMCtZ+GirikIA36ikvjtHweU4/j8yLtgObI0+JUPhYFScgwlteveGB1rt3Cm8UhN04XayDig==", + "dev": true, + "license": "MIT", + "dependencies": { + "ajv": "^6.12.0", + "ajv-keywords": "^3.4.1" + }, + "engines": { + "node": ">= 8.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/@develar/schema-utils/node_modules/ajv": { + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz", + "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/@develar/schema-utils/node_modules/ajv-keywords": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz", + "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "ajv": "^6.9.1" + } + }, + "node_modules/@develar/schema-utils/node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@electron/asar": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/@electron/asar/-/asar-3.4.1.tgz", + "integrity": "sha512-i4/rNPRS84t0vSRa2HorerGRXWyF4vThfHesw0dmcWHp+cspK743UanA0suA5Q5y8kzY2y6YKrvbIUn69BCAiA==", + "dev": true, + "license": "MIT", + "dependencies": { + "commander": "^5.0.0", + "glob": "^7.1.6", + "minimatch": "^3.0.4" + }, + "bin": { + "asar": "bin/asar.js" + }, + "engines": { + "node": ">=10.12.0" + } + }, + "node_modules/@electron/asar/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/@electron/asar/node_modules/brace-expansion": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", + "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/@electron/asar/node_modules/commander": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz", + "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/@electron/asar/node_modules/minimatch": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz", + "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/@electron/get": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/@electron/get/-/get-2.0.3.tgz", + "integrity": "sha512-Qkzpg2s9GnVV2I2BjRksUi43U5e6+zaQMcjoJy0C+C5oxaKl+fmckGDQFtRpZpZV0NQekuZZ+tGz7EA9TVnQtQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.1.1", + "env-paths": "^2.2.0", + "fs-extra": "^8.1.0", + "got": "^11.8.5", + "progress": "^2.0.3", + "semver": "^6.2.0", + "sumchecker": "^3.0.1" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "global-agent": "^3.0.0" + } + }, + "node_modules/@electron/notarize": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@electron/notarize/-/notarize-2.5.0.tgz", + "integrity": "sha512-jNT8nwH1f9X5GEITXaQ8IF/KdskvIkOFfB2CvwumsveVidzpSc+mvhhTMdAGSYF3O+Nq49lJ7y+ssODRXu06+A==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.1.1", + "fs-extra": "^9.0.1", + "promise-retry": "^2.0.1" + }, + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/@electron/notarize/node_modules/fs-extra": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@electron/notarize/node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/@electron/notarize/node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/@electron/osx-sign": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@electron/osx-sign/-/osx-sign-1.3.1.tgz", + "integrity": "sha512-BAfviURMHpmb1Yb50YbCxnOY0wfwaLXH5KJ4+80zS0gUkzDX3ec23naTlEqKsN+PwYn+a1cCzM7BJ4Wcd3sGzw==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "compare-version": "^0.1.2", + "debug": "^4.3.4", + "fs-extra": "^10.0.0", + "isbinaryfile": "^4.0.8", + "minimist": "^1.2.6", + "plist": "^3.0.5" + }, + "bin": { + "electron-osx-flat": "bin/electron-osx-flat.js", + "electron-osx-sign": "bin/electron-osx-sign.js" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/@electron/osx-sign/node_modules/fs-extra": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz", + "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@electron/osx-sign/node_modules/isbinaryfile": { + "version": "4.0.10", + "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-4.0.10.tgz", + "integrity": "sha512-iHrqe5shvBUcFbmZq9zOQHBoeOhZJu6RQGrDpBgenUm/Am+F3JM2MgQj+rK3Z601fzrL5gLZWtAPH2OBaSVcyw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/gjtorikian/" + } + }, + "node_modules/@electron/osx-sign/node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/@electron/osx-sign/node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/@electron/rebuild": { + "version": "3.6.1", + "resolved": "https://registry.npmjs.org/@electron/rebuild/-/rebuild-3.6.1.tgz", + "integrity": "sha512-f6596ZHpEq/YskUd8emYvOUne89ij8mQgjYFA5ru25QwbrRO+t1SImofdDv7kKOuWCmVOuU5tvfkbgGxIl3E/w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@malept/cross-spawn-promise": "^2.0.0", + "chalk": "^4.0.0", + "debug": "^4.1.1", + "detect-libc": "^2.0.1", + "fs-extra": "^10.0.0", + "got": "^11.7.0", + "node-abi": "^3.45.0", + "node-api-version": "^0.2.0", + "node-gyp": "^9.0.0", + "ora": "^5.1.0", + "read-binary-file-arch": "^1.0.6", + "semver": "^7.3.5", + "tar": "^6.0.5", + "yargs": "^17.0.1" + }, + "bin": { + "electron-rebuild": "lib/cli.js" + }, + "engines": { + "node": ">=12.13.0" + } + }, + "node_modules/@electron/rebuild/node_modules/fs-extra": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz", + "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@electron/rebuild/node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/@electron/rebuild/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@electron/rebuild/node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/@electron/universal": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@electron/universal/-/universal-2.0.1.tgz", + "integrity": "sha512-fKpv9kg4SPmt+hY7SVBnIYULE9QJl8L3sCfcBsnqbJwwBwAeTLokJ9TRt9y7bK0JAzIW2y78TVVjvnQEms/yyA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@electron/asar": "^3.2.7", + "@malept/cross-spawn-promise": "^2.0.0", + "debug": "^4.3.1", + "dir-compare": "^4.2.0", + "fs-extra": "^11.1.1", + "minimatch": "^9.0.3", + "plist": "^3.1.0" + }, + "engines": { + "node": ">=16.4" + } + }, + "node_modules/@electron/universal/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/@electron/universal/node_modules/brace-expansion": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz", + "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/@electron/universal/node_modules/fs-extra": { + "version": "11.3.4", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz", + "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=14.14" + } + }, + "node_modules/@electron/universal/node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/@electron/universal/node_modules/minimatch": { + "version": "9.0.9", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz", + "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.2" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/@electron/universal/node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz", + "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz", + "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz", + "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz", + "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz", + "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz", + "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz", + "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz", + "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz", + "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz", + "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz", + "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz", + "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz", + "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz", + "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz", + "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz", + "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz", + "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz", + "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz", + "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz", + "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz", + "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz", + "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz", + "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@gar/promisify": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/@gar/promisify/-/promisify-1.1.3.tgz", + "integrity": "sha512-k2Ty1JcVojjJFwrg/ThKi2ujJ7XNLYaFGNB/bWT9wGR+oSMJHMa5w+CUq6p/pVrKeNNgA7pCqEcjSnHVoqJQFw==", + "dev": true, + "license": "MIT" + }, + "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/@isaacs/cliui/node_modules/ansi-regex": { + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz", + "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/@isaacs/cliui/node_modules/ansi-styles": { + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz", + "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@isaacs/cliui/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/@isaacs/cliui/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/@isaacs/cliui/node_modules/strip-ansi": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz", + "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.2.2" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/@isaacs/cliui/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/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "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.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@malept/cross-spawn-promise": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@malept/cross-spawn-promise/-/cross-spawn-promise-2.0.0.tgz", + "integrity": "sha512-1DpKU0Z5ThltBwjNySMC14g0CkbyhCaz9FkhxqNsZI6uAPJXFS8cMXlBKo26FJ8ZuW6S9GCMcR9IO5k2X5/9Fg==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/malept" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/subscription/pkg/npm-.malept-cross-spawn-promise?utm_medium=referral&utm_source=npm_fund" + } + ], + "license": "Apache-2.0", + "dependencies": { + "cross-spawn": "^7.0.1" + }, + "engines": { + "node": ">= 12.13.0" + } + }, + "node_modules/@malept/flatpak-bundler": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/@malept/flatpak-bundler/-/flatpak-bundler-0.4.0.tgz", + "integrity": "sha512-9QOtNffcOF/c1seMCDnjckb3R9WHcG34tky+FHpNKKCW0wc/scYLwMtO+ptyGUfMW0/b/n4qRiALlaFHc9Oj7Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.1.1", + "fs-extra": "^9.0.0", + "lodash": "^4.17.15", + "tmp-promise": "^3.0.2" + }, + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/@malept/flatpak-bundler/node_modules/fs-extra": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@malept/flatpak-bundler/node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/@malept/flatpak-bundler/node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@npmcli/fs": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-2.1.2.tgz", + "integrity": "sha512-yOJKRvohFOaLqipNtwYB9WugyZKhC/DZC4VYPmpaCzDBrA8YpK3qHZ8/HGscMnE4GqbkLNuVcCnxkeQEdGt6LQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "@gar/promisify": "^1.1.3", + "semver": "^7.3.5" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/@npmcli/fs/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@npmcli/move-file": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@npmcli/move-file/-/move-file-2.0.1.tgz", + "integrity": "sha512-mJd2Z5TjYWq/ttPLLGqArdtnC74J6bOzg4rMDnN+p1xTacZ2yPRCk2y0oSWQtygLR9YVQXgOcONrwtnk3JupxQ==", + "deprecated": "This functionality has been moved to @npmcli/fs", + "dev": true, + "license": "MIT", + "dependencies": { + "mkdirp": "^1.0.4", + "rimraf": "^3.0.2" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "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/@rolldown/pluginutils": { + "version": "1.0.0-beta.27", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz", + "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.59.0.tgz", + "integrity": "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.59.0.tgz", + "integrity": "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.59.0.tgz", + "integrity": "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.59.0.tgz", + "integrity": "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.59.0.tgz", + "integrity": "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.59.0.tgz", + "integrity": "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.59.0.tgz", + "integrity": "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.59.0.tgz", + "integrity": "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.59.0.tgz", + "integrity": "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.59.0.tgz", + "integrity": "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.59.0.tgz", + "integrity": "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.59.0.tgz", + "integrity": "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.59.0.tgz", + "integrity": "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.59.0.tgz", + "integrity": "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.59.0.tgz", + "integrity": "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.59.0.tgz", + "integrity": "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.59.0.tgz", + "integrity": "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.59.0.tgz", + "integrity": "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.59.0.tgz", + "integrity": "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.59.0.tgz", + "integrity": "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.59.0.tgz", + "integrity": "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.59.0.tgz", + "integrity": "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.59.0.tgz", + "integrity": "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.59.0.tgz", + "integrity": "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.59.0.tgz", + "integrity": "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@sindresorhus/is": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz", + "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/is?sponsor=1" + } + }, + "node_modules/@szmarczak/http-timer": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-4.0.6.tgz", + "integrity": "sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==", + "dev": true, + "license": "MIT", + "dependencies": { + "defer-to-connect": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@tootallnate/once": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@tootallnate/once/-/once-2.0.0.tgz", + "integrity": "sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10" + } + }, + "node_modules/@types/babel__core": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz", + "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.27.0", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz", + "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.4", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz", + "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz", + "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.2" + } + }, + "node_modules/@types/cacheable-request": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz", + "integrity": "sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/http-cache-semantics": "*", + "@types/keyv": "^3.1.4", + "@types/node": "*", + "@types/responselike": "^1.0.0" + } + }, + "node_modules/@types/debug": { + "version": "4.1.12", + "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz", + "integrity": "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/ms": "*" + } + }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/fs-extra": { + "version": "9.0.13", + "resolved": "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-9.0.13.tgz", + "integrity": "sha512-nEnwB++1u5lVDM2UI4c1+5R+FYaKfaAzS4OococimjVm3nQw3TuzH5UNsocrcTBbhnerblyHj4A49qXbIiZdpA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/http-cache-semantics": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz", + "integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/keyv": { + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/@types/keyv/-/keyv-3.1.4.tgz", + "integrity": "sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/ms": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz", + "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "22.19.15", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.15.tgz", + "integrity": "sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.0" + } + }, + "node_modules/@types/plist": { + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/@types/plist/-/plist-3.0.5.tgz", + "integrity": "sha512-E6OCaRmAe4WDmWNsL/9RMqdkkzDCY1etutkflWk4c+AcjDU07Pcz1fQwTX0TQz+Pxqn9i4L1TU3UFpjnrcDgxA==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@types/node": "*", + "xmlbuilder": ">=11.0.1" + } + }, + "node_modules/@types/react": { + "version": "19.2.14", + "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz", + "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==", + "dev": true, + "license": "MIT", + "dependencies": { + "csstype": "^3.2.2" + } + }, + "node_modules/@types/react-dom": { + "version": "19.2.3", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz", + "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^19.2.0" + } + }, + "node_modules/@types/responselike": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@types/responselike/-/responselike-1.0.3.tgz", + "integrity": "sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/verror": { + "version": "1.10.11", + "resolved": "https://registry.npmjs.org/@types/verror/-/verror-1.10.11.tgz", + "integrity": "sha512-RlDm9K7+o5stv0Co8i8ZRGxDbrTxhJtgjqjFyVh/tXQyl/rYtTKlnTvZ88oSTeYREWurwx20Js4kTuKCsFkUtg==", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/@types/yauzl": { + "version": "2.10.3", + "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz", + "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@vitejs/plugin-react": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz", + "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.28.0", + "@babel/plugin-transform-react-jsx-self": "^7.27.1", + "@babel/plugin-transform-react-jsx-source": "^7.27.1", + "@rolldown/pluginutils": "1.0.0-beta.27", + "@types/babel__core": "^7.20.5", + "react-refresh": "^0.17.0" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "peerDependencies": { + "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + } + }, + "node_modules/@xmldom/xmldom": { + "version": "0.8.11", + "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.8.11.tgz", + "integrity": "sha512-cQzWCtO6C8TQiYl1ruKNn2U6Ao4o4WBBcbL61yJl84x+j5sOWWFU9X7DpND8XZG3daDppSsigMdfAIl2upQBRw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/7zip-bin": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/7zip-bin/-/7zip-bin-5.2.0.tgz", + "integrity": "sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A==", + "dev": true, + "license": "MIT" + }, + "node_modules/abbrev": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", + "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==", + "dev": true, + "license": "ISC" + }, + "node_modules/agent-base": { + "version": "7.1.4", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz", + "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14" + } + }, + "node_modules/agentkeepalive": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.6.0.tgz", + "integrity": "sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "humanize-ms": "^1.2.1" + }, + "engines": { + "node": ">= 8.0.0" + } + }, + "node_modules/aggregate-error": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz", + "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==", + "dev": true, + "license": "MIT", + "dependencies": { + "clean-stack": "^2.0.0", + "indent-string": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/ajv": { + "version": "8.18.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz", + "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3", + "fast-uri": "^3.0.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ajv-formats": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz", + "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==", + "license": "MIT", + "dependencies": { + "ajv": "^8.0.0" + }, + "peerDependencies": { + "ajv": "^8.0.0" + }, + "peerDependenciesMeta": { + "ajv": { + "optional": true + } + } + }, + "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/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/any-promise": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz", + "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==", + "dev": true, + "license": "MIT" + }, + "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/app-builder-bin": { + "version": "5.0.0-alpha.10", + "resolved": "https://registry.npmjs.org/app-builder-bin/-/app-builder-bin-5.0.0-alpha.10.tgz", + "integrity": "sha512-Ev4jj3D7Bo+O0GPD2NMvJl+PGiBAfS7pUGawntBNpCbxtpncfUixqFj9z9Jme7V7s3LBGqsWZZP54fxBX3JKJw==", + "dev": true, + "license": "MIT" + }, + "node_modules/app-builder-lib": { + "version": "25.1.8", + "resolved": "https://registry.npmjs.org/app-builder-lib/-/app-builder-lib-25.1.8.tgz", + "integrity": "sha512-pCqe7dfsQFBABC1jeKZXQWhGcCPF3rPCXDdfqVKjIeWBcXzyC1iOWZdfFhGl+S9MyE/k//DFmC6FzuGAUudNDg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@develar/schema-utils": "~2.6.5", + "@electron/notarize": "2.5.0", + "@electron/osx-sign": "1.3.1", + "@electron/rebuild": "3.6.1", + "@electron/universal": "2.0.1", + "@malept/flatpak-bundler": "^0.4.0", + "@types/fs-extra": "9.0.13", + "async-exit-hook": "^2.0.1", + "bluebird-lst": "^1.0.9", + "builder-util": "25.1.7", + "builder-util-runtime": "9.2.10", + "chromium-pickle-js": "^0.2.0", + "config-file-ts": "0.2.8-rc1", + "debug": "^4.3.4", + "dotenv": "^16.4.5", + "dotenv-expand": "^11.0.6", + "ejs": "^3.1.8", + "electron-publish": "25.1.7", + "form-data": "^4.0.0", + "fs-extra": "^10.1.0", + "hosted-git-info": "^4.1.0", + "is-ci": "^3.0.0", + "isbinaryfile": "^5.0.0", + "js-yaml": "^4.1.0", + "json5": "^2.2.3", + "lazy-val": "^1.0.5", + "minimatch": "^10.0.0", + "resedit": "^1.7.0", + "sanitize-filename": "^1.6.3", + "semver": "^7.3.8", + "tar": "^6.1.12", + "temp-file": "^3.4.0" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "dmg-builder": "25.1.8", + "electron-builder-squirrel-windows": "25.1.8" + } + }, + "node_modules/app-builder-lib/node_modules/fs-extra": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz", + "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/app-builder-lib/node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/app-builder-lib/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/app-builder-lib/node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/aproba": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/aproba/-/aproba-2.1.0.tgz", + "integrity": "sha512-tLIEcj5GuR2RSTnxNKdkK0dJ/GrC7P38sUkiDmDuHfsHmbagTFAxDVIBltoklXEVIQ/f14IL8IMJ5pn9Hez1Ew==", + "dev": true, + "license": "ISC" + }, + "node_modules/archiver": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/archiver/-/archiver-5.3.2.tgz", + "integrity": "sha512-+25nxyyznAXF7Nef3y0EbBeqmGZgeN/BxHX29Rs39djAfaFalmQ89SE6CWyDCHzGL0yt/ycBtNOmGTW0FyGWNw==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "archiver-utils": "^2.1.0", + "async": "^3.2.4", + "buffer-crc32": "^0.2.1", + "readable-stream": "^3.6.0", + "readdir-glob": "^1.1.2", + "tar-stream": "^2.2.0", + "zip-stream": "^4.1.0" + }, + "engines": { + "node": ">= 10" + } + }, + "node_modules/archiver-utils": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/archiver-utils/-/archiver-utils-2.1.0.tgz", + "integrity": "sha512-bEL/yUb/fNNiNTuUz979Z0Yg5L+LzLxGJz8x79lYmR54fmTIb6ob/hNQgkQnIUDWIFjZVQwl9Xs356I6BAMHfw==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "glob": "^7.1.4", + "graceful-fs": "^4.2.0", + "lazystream": "^1.0.0", + "lodash.defaults": "^4.2.0", + "lodash.difference": "^4.5.0", + "lodash.flatten": "^4.4.0", + "lodash.isplainobject": "^4.0.6", + "lodash.union": "^4.6.0", + "normalize-path": "^3.0.0", + "readable-stream": "^2.0.0" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/archiver-utils/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", + "peer": true, + "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/archiver-utils/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", + "peer": true + }, + "node_modules/archiver-utils/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", + "peer": true, + "dependencies": { + "safe-buffer": "~5.1.0" + } + }, + "node_modules/are-we-there-yet": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-3.0.1.tgz", + "integrity": "sha512-QZW4EDmGwlYur0Yyf/b2uGucHQMa8aFUP7eu9ddR73vvhFyt4V0Vl3QHPcTNJ8l6qYOBdxgXdnBXQrHilfRQBg==", + "deprecated": "This package is no longer supported.", + "dev": true, + "license": "ISC", + "dependencies": { + "delegates": "^1.0.0", + "readable-stream": "^3.6.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/arg": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz", + "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==", + "dev": true, + "license": "MIT" + }, + "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/assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==", + "dev": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/astral-regex": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz", + "integrity": "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==", + "dev": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/async": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz", + "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==", + "dev": true, + "license": "MIT" + }, + "node_modules/async-exit-hook": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/async-exit-hook/-/async-exit-hook-2.0.1.tgz", + "integrity": "sha512-NW2cX8m1Q7KPA7a5M2ULQeZ2wR5qI5PAbw5L0UOMxdioVk9PMZ0h1TmyZEkPYrCvYjDlFICusOu1dlEKAAeXBw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/at-least-node": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz", + "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/atomically": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/atomically/-/atomically-2.1.1.tgz", + "integrity": "sha512-P4w9o2dqARji6P7MHprklbfiArZAWvo07yW7qs3pdljb3BWr12FIB7W+p0zJiuiVsUpRO0iZn1kFFcpPegg0tQ==", + "license": "MIT", + "dependencies": { + "stubborn-fs": "^2.0.0", + "when-exit": "^2.1.4" + } + }, + "node_modules/autoprefixer": { + "version": "10.4.27", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.27.tgz", + "integrity": "sha512-NP9APE+tO+LuJGn7/9+cohklunJsXWiaWEfV3si4Gi/XHDwVNgkwr1J3RQYFIvPy76GmJ9/bW8vyoU1LcxwKHA==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/autoprefixer" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "browserslist": "^4.28.1", + "caniuse-lite": "^1.0.30001774", + "fraction.js": "^5.3.4", + "picocolors": "^1.1.1", + "postcss-value-parser": "^4.2.0" + }, + "bin": { + "autoprefixer": "bin/autoprefixer" + }, + "engines": { + "node": "^10 || ^12 || >=14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "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/baseline-browser-mapping": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.0.tgz", + "integrity": "sha512-lIyg0szRfYbiy67j9KN8IyeD7q7hcmqnJ1ddWmNt19ItGpNN64mnllmxUNFIOdOm6by97jlL6wfpTTJrmnjWAA==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "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": "4.1.0", + "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz", + "integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "buffer": "^5.5.0", + "inherits": "^2.0.4", + "readable-stream": "^3.4.0" + } + }, + "node_modules/bluebird": { + "version": "3.7.2", + "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz", + "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==", + "dev": true, + "license": "MIT" + }, + "node_modules/bluebird-lst": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/bluebird-lst/-/bluebird-lst-1.0.9.tgz", + "integrity": "sha512-7B1Rtx82hjnSD4PGLAjVWeYH3tHAcVUmChh85a3lltKQm6FresXh9ErQo6oAv6CqxttczC3/kEg8SY5NluPuUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "bluebird": "^3.5.5" + } + }, + "node_modules/boolean": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/boolean/-/boolean-3.2.0.tgz", + "integrity": "sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==", + "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/brace-expansion": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", + "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + } + }, + "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/browserslist": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz", + "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "baseline-browser-mapping": "^2.9.0", + "caniuse-lite": "^1.0.30001759", + "electron-to-chromium": "^1.5.263", + "node-releases": "^2.0.27", + "update-browserslist-db": "^1.2.0" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/buffer": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz", + "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==", + "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.1.13" + } + }, + "node_modules/buffer-crc32": { + "version": "0.2.13", + "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz", + "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/builder-util": { + "version": "25.1.7", + "resolved": "https://registry.npmjs.org/builder-util/-/builder-util-25.1.7.tgz", + "integrity": "sha512-7jPjzBwEGRbwNcep0gGNpLXG9P94VA3CPAZQCzxkFXiV2GMQKlziMbY//rXPI7WKfhsvGgFXjTcXdBEwgXw9ww==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/debug": "^4.1.6", + "7zip-bin": "~5.2.0", + "app-builder-bin": "5.0.0-alpha.10", + "bluebird-lst": "^1.0.9", + "builder-util-runtime": "9.2.10", + "chalk": "^4.1.2", + "cross-spawn": "^7.0.3", + "debug": "^4.3.4", + "fs-extra": "^10.1.0", + "http-proxy-agent": "^7.0.0", + "https-proxy-agent": "^7.0.0", + "is-ci": "^3.0.0", + "js-yaml": "^4.1.0", + "source-map-support": "^0.5.19", + "stat-mode": "^1.0.0", + "temp-file": "^3.4.0" + } + }, + "node_modules/builder-util-runtime": { + "version": "9.2.10", + "resolved": "https://registry.npmjs.org/builder-util-runtime/-/builder-util-runtime-9.2.10.tgz", + "integrity": "sha512-6p/gfG1RJSQeIbz8TK5aPNkoztgY1q5TgmGFMAXcY8itsGW6Y2ld1ALsZ5UJn8rog7hKF3zHx5iQbNQ8uLcRlw==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.3.4", + "sax": "^1.2.4" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/builder-util/node_modules/fs-extra": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz", + "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/builder-util/node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/builder-util/node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/cac": { + "version": "6.7.14", + "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz", + "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/cacache": { + "version": "16.1.3", + "resolved": "https://registry.npmjs.org/cacache/-/cacache-16.1.3.tgz", + "integrity": "sha512-/+Emcj9DAXxX4cwlLmRI9c166RuL3w30zp4R7Joiv2cQTtTtA+jeuCAjH3ZlGnYS3tKENSrKhAzVVP9GVyzeYQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "@npmcli/fs": "^2.1.0", + "@npmcli/move-file": "^2.0.0", + "chownr": "^2.0.0", + "fs-minipass": "^2.1.0", + "glob": "^8.0.1", + "infer-owner": "^1.0.4", + "lru-cache": "^7.7.1", + "minipass": "^3.1.6", + "minipass-collect": "^1.0.2", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "mkdirp": "^1.0.4", + "p-map": "^4.0.0", + "promise-inflight": "^1.0.1", + "rimraf": "^3.0.2", + "ssri": "^9.0.0", + "tar": "^6.1.11", + "unique-filename": "^2.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/cacache/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/cacache/node_modules/brace-expansion": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz", + "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/cacache/node_modules/glob": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz", + "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==", + "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me", + "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/cacache/node_modules/lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/cacache/node_modules/minimatch": { + "version": "5.1.9", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz", + "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/cacheable-lookup": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-5.0.4.tgz", + "integrity": "sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.6.0" + } + }, + "node_modules/cacheable-request": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-7.0.4.tgz", + "integrity": "sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==", + "dev": true, + "license": "MIT", + "dependencies": { + "clone-response": "^1.0.2", + "get-stream": "^5.1.0", + "http-cache-semantics": "^4.0.0", + "keyv": "^4.0.0", + "lowercase-keys": "^2.0.0", + "normalize-url": "^6.0.1", + "responselike": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/camelcase-css": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz", + "integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001777", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001777.tgz", + "integrity": "sha512-tmN+fJxroPndC74efCdp12j+0rk0RHwV5Jwa1zWaFVyw2ZxAuPeG8ZgWC3Wz7uSjT3qMRQ5XHZ4COgQmsCMJAQ==", + "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/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/chokidar/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/chownr": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", + "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/chromium-pickle-js": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/chromium-pickle-js/-/chromium-pickle-js-0.2.0.tgz", + "integrity": "sha512-1R5Fho+jBq0DDydt+/vHWj5KJNJCKdARKOCwZUen84I5BreWoLqRLANH1U87eJy1tiASPtMnGqJJq0ZsLoRPOw==", + "dev": true, + "license": "MIT" + }, + "node_modules/ci-info": { + "version": "3.9.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz", + "integrity": "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/sibiraj-s" + } + ], + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/clean-stack": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz", + "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/cli-cursor": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz", + "integrity": "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==", + "dev": true, + "license": "MIT", + "dependencies": { + "restore-cursor": "^3.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "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/cli-truncate": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-2.1.0.tgz", + "integrity": "sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "slice-ansi": "^3.0.0", + "string-width": "^4.2.0" + }, + "engines": { + "node": ">=8" + }, + "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/clone": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz", + "integrity": "sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8" + } + }, + "node_modules/clone-response": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.3.tgz", + "integrity": "sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==", + "dev": true, + "license": "MIT", + "dependencies": { + "mimic-response": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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/color-support": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz", + "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==", + "dev": true, + "license": "ISC", + "bin": { + "color-support": "bin.js" + } + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "dev": true, + "license": "MIT", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/commander": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz", + "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/compare-version": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/compare-version/-/compare-version-0.1.2.tgz", + "integrity": "sha512-pJDh5/4wrEnXX/VWRZvruAGHkzKdr46z11OlTPN+VrATlWWhSKewNCJ1futCO5C7eJB3nPMFZA1LeYtcFboZ2A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/compress-commons": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/compress-commons/-/compress-commons-4.1.2.tgz", + "integrity": "sha512-D3uMHtGc/fcO1Gt1/L7i1e33VOvD4A9hfQLP+6ewd+BvG/gQ84Yh4oftEhAdjSMgBgwGL+jsppT7JYNpo6MHHg==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "buffer-crc32": "^0.2.13", + "crc32-stream": "^4.0.2", + "normalize-path": "^3.0.0", + "readable-stream": "^3.6.0" + }, + "engines": { + "node": ">= 10" + } + }, + "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/conf": { + "version": "14.0.0", + "resolved": "https://registry.npmjs.org/conf/-/conf-14.0.0.tgz", + "integrity": "sha512-L6BuueHTRuJHQvQVc6YXYZRtN5vJUtOdCTLn0tRYYV5azfbAFcPghB5zEE40mVrV6w7slMTqUfkDomutIK14fw==", + "license": "MIT", + "dependencies": { + "ajv": "^8.17.1", + "ajv-formats": "^3.0.1", + "atomically": "^2.0.3", + "debounce-fn": "^6.0.0", + "dot-prop": "^9.0.0", + "env-paths": "^3.0.0", + "json-schema-typed": "^8.0.1", + "semver": "^7.7.2", + "uint8array-extras": "^1.4.0" + }, + "engines": { + "node": ">=20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/conf/node_modules/env-paths": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-3.0.0.tgz", + "integrity": "sha512-dtJUTepzMW3Lm/NPxRf3wP4642UWhjL2sQxc+ym2YMj1m/H2zDNQOlezafzkHwn6sMstjHTwG6iQQsctDW/b1A==", + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/conf/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/config-file-ts": { + "version": "0.2.8-rc1", + "resolved": "https://registry.npmjs.org/config-file-ts/-/config-file-ts-0.2.8-rc1.tgz", + "integrity": "sha512-GtNECbVI82bT4RiDIzBSVuTKoSHufnU7Ce7/42bkWZJZFLjmDF2WBpVsvRkhKCfKBnTBb3qZrBwPpFBU/Myvhg==", + "dev": true, + "license": "MIT", + "dependencies": { + "glob": "^10.3.12", + "typescript": "^5.4.3" + } + }, + "node_modules/config-file-ts/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/config-file-ts/node_modules/brace-expansion": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz", + "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/config-file-ts/node_modules/glob": { + "version": "10.5.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.5.0.tgz", + "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==", + "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me", + "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/config-file-ts/node_modules/minimatch": { + "version": "9.0.9", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz", + "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.2" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/config-file-ts/node_modules/minipass": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", + "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/console-control-strings": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", + "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==", + "dev": true, + "license": "ISC" + }, + "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-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/crc": { + "version": "3.8.0", + "resolved": "https://registry.npmjs.org/crc/-/crc-3.8.0.tgz", + "integrity": "sha512-iX3mfgcTMIq3ZKLIsVFAbv7+Mc10kxabAGQb8HvjA1o3T1PIYprbakQ65d3I+2HGHt6nSKkM9PYjgoJO2KcFBQ==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "buffer": "^5.1.0" + } + }, + "node_modules/crc-32": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz", + "integrity": "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==", + "dev": true, + "license": "Apache-2.0", + "peer": true, + "bin": { + "crc32": "bin/crc32.njs" + }, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/crc32-stream": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/crc32-stream/-/crc32-stream-4.0.3.tgz", + "integrity": "sha512-NT7w2JVU7DFroFdYkeq8cywxrgjPHWkdX1wjpRQXPX5Asews3tA+Ght6lddQO5Mkumffp3X7GEqku3epj2toIw==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "crc-32": "^1.2.0", + "readable-stream": "^3.4.0" + }, + "engines": { + "node": ">= 10" + } + }, + "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/cssesc": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", + "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", + "dev": true, + "license": "MIT", + "bin": { + "cssesc": "bin/cssesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/debounce-fn": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/debounce-fn/-/debounce-fn-6.0.0.tgz", + "integrity": "sha512-rBMW+F2TXryBwB54Q0d8drNEI+TfoS9JpNTAoVpukbWEhjXQq4rySFYLaqXMFXwdv61Zb2OHtj5bviSoimqxRQ==", + "license": "MIT", + "dependencies": { + "mimic-function": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decompress-response": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz", + "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "mimic-response": "^3.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/decompress-response/node_modules/mimic-response": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz", + "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/defaults": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/defaults/-/defaults-1.0.4.tgz", + "integrity": "sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "clone": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/defer-to-connect": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz", + "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/define-data-property": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz", + "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "gopd": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/define-properties": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz", + "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "define-data-property": "^1.0.1", + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/delegates": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", + "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/detect-libc": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", + "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=8" + } + }, + "node_modules/detect-node": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz", + "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/didyoumean": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz", + "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/dir-compare": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/dir-compare/-/dir-compare-4.2.0.tgz", + "integrity": "sha512-2xMCmOoMrdQIPHdsTawECdNPwlVFB9zGcz3kuhmBO6U3oU+UQjsue0i8ayLKpgBcm+hcXPMVSGUN9d+pvJ6+VQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "minimatch": "^3.0.5", + "p-limit": "^3.1.0 " + } + }, + "node_modules/dir-compare/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/dir-compare/node_modules/brace-expansion": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", + "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/dir-compare/node_modules/minimatch": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz", + "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/dlv": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz", + "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==", + "dev": true, + "license": "MIT" + }, + "node_modules/dmg-builder": { + "version": "25.1.8", + "resolved": "https://registry.npmjs.org/dmg-builder/-/dmg-builder-25.1.8.tgz", + "integrity": "sha512-NoXo6Liy2heSklTI5OIZbCgXC1RzrDQsZkeEwXhdOro3FT1VBOvbubvscdPnjVuQ4AMwwv61oaH96AbiYg9EnQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "app-builder-lib": "25.1.8", + "builder-util": "25.1.7", + "builder-util-runtime": "9.2.10", + "fs-extra": "^10.1.0", + "iconv-lite": "^0.6.2", + "js-yaml": "^4.1.0" + }, + "optionalDependencies": { + "dmg-license": "^1.0.11" + } + }, + "node_modules/dmg-builder/node_modules/fs-extra": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz", + "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/dmg-builder/node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/dmg-builder/node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/dmg-license": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/dmg-license/-/dmg-license-1.0.11.tgz", + "integrity": "sha512-ZdzmqwKmECOWJpqefloC5OJy1+WZBBse5+MR88z9g9Zn4VY+WYUkAyojmhzJckH5YbbZGcYIuGAkY5/Ys5OM2Q==", + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "dependencies": { + "@types/plist": "^3.0.1", + "@types/verror": "^1.10.3", + "ajv": "^6.10.0", + "crc": "^3.8.0", + "iconv-corefoundation": "^1.1.7", + "plist": "^3.0.4", + "smart-buffer": "^4.0.2", + "verror": "^1.10.0" + }, + "bin": { + "dmg-license": "bin/dmg-license.js" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/dmg-license/node_modules/ajv": { + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz", + "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/dmg-license/node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/dot-prop": { + "version": "9.0.0", + "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-9.0.0.tgz", + "integrity": "sha512-1gxPBJpI/pcjQhKgIU91II6Wkay+dLcN3M6rf2uwP8hRur3HtQXjVrdAK3sjC0piaEuxzMwjXChcETiJl47lAQ==", + "license": "MIT", + "dependencies": { + "type-fest": "^4.18.2" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/dotenv": { + "version": "16.6.1", + "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz", + "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://dotenvx.com" + } + }, + "node_modules/dotenv-expand": { + "version": "11.0.7", + "resolved": "https://registry.npmjs.org/dotenv-expand/-/dotenv-expand-11.0.7.tgz", + "integrity": "sha512-zIHwmZPRshsCdpMDyVsqGmgyP0yT8GAgXUnkdAoJisxvf33k7yO6OuoKmcTGuXPWSsm8Oh88nZicRLA9Y0rUeA==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "dotenv": "^16.4.5" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://dotenvx.com" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "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/ejs": { + "version": "3.1.10", + "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz", + "integrity": "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "jake": "^10.8.5" + }, + "bin": { + "ejs": "bin/cli.js" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/electron": { + "version": "34.5.8", + "resolved": "https://registry.npmjs.org/electron/-/electron-34.5.8.tgz", + "integrity": "sha512-vxLD65mabTzYmEVa9KceMHM0+zO+vqgrhcyNVlmTd0IGV5J7XZ8v/qElm0o4YQ4wPeq7olZkUjZkBQQEdr23/g==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "@electron/get": "^2.0.0", + "@types/node": "^20.9.0", + "extract-zip": "^2.0.1" + }, + "bin": { + "electron": "cli.js" + }, + "engines": { + "node": ">= 12.20.55" + } + }, + "node_modules/electron-builder": { + "version": "25.1.8", + "resolved": "https://registry.npmjs.org/electron-builder/-/electron-builder-25.1.8.tgz", + "integrity": "sha512-poRgAtUHHOnlzZnc9PK4nzG53xh74wj2Jy7jkTrqZ0MWPoHGh1M2+C//hGeYdA+4K8w4yiVCNYoLXF7ySj2Wig==", + "dev": true, + "license": "MIT", + "dependencies": { + "app-builder-lib": "25.1.8", + "builder-util": "25.1.7", + "builder-util-runtime": "9.2.10", + "chalk": "^4.1.2", + "dmg-builder": "25.1.8", + "fs-extra": "^10.1.0", + "is-ci": "^3.0.0", + "lazy-val": "^1.0.5", + "simple-update-notifier": "2.0.0", + "yargs": "^17.6.2" + }, + "bin": { + "electron-builder": "cli.js", + "install-app-deps": "install-app-deps.js" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/electron-builder-squirrel-windows": { + "version": "25.1.8", + "resolved": "https://registry.npmjs.org/electron-builder-squirrel-windows/-/electron-builder-squirrel-windows-25.1.8.tgz", + "integrity": "sha512-2ntkJ+9+0GFP6nAISiMabKt6eqBB0kX1QqHNWFWAXgi0VULKGisM46luRFpIBiU3u/TDmhZMM8tzvo2Abn3ayg==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "app-builder-lib": "25.1.8", + "archiver": "^5.3.1", + "builder-util": "25.1.7", + "fs-extra": "^10.1.0" + } + }, + "node_modules/electron-builder-squirrel-windows/node_modules/fs-extra": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz", + "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/electron-builder-squirrel-windows/node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/electron-builder-squirrel-windows/node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "peer": true, + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/electron-builder/node_modules/fs-extra": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz", + "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/electron-builder/node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/electron-builder/node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/electron-publish": { + "version": "25.1.7", + "resolved": "https://registry.npmjs.org/electron-publish/-/electron-publish-25.1.7.tgz", + "integrity": "sha512-+jbTkR9m39eDBMP4gfbqglDd6UvBC7RLh5Y0MhFSsc6UkGHj9Vj9TWobxevHYMMqmoujL11ZLjfPpMX+Pt6YEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/fs-extra": "^9.0.11", + "builder-util": "25.1.7", + "builder-util-runtime": "9.2.10", + "chalk": "^4.1.2", + "fs-extra": "^10.1.0", + "lazy-val": "^1.0.5", + "mime": "^2.5.2" + } + }, + "node_modules/electron-publish/node_modules/fs-extra": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz", + "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/electron-publish/node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/electron-publish/node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/electron-store": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/electron-store/-/electron-store-10.1.0.tgz", + "integrity": "sha512-oL8bRy7pVCLpwhmXy05Rh/L6O93+k9t6dqSw0+MckIc3OmCTZm6Mp04Q4f/J0rtu84Ky6ywkR8ivtGOmrq+16w==", + "license": "MIT", + "dependencies": { + "conf": "^14.0.0", + "type-fest": "^4.41.0" + }, + "engines": { + "node": ">=20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.5.307", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.307.tgz", + "integrity": "sha512-5z3uFKBWjiNR44nFcYdkcXjKMbg5KXNdciu7mhTPo9tB7NbqSNP2sSnGR+fqknZSCwKkBN+oxiiajWs4dT6ORg==", + "dev": true, + "license": "ISC" + }, + "node_modules/electron-vite": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/electron-vite/-/electron-vite-2.3.0.tgz", + "integrity": "sha512-lsN2FymgJlp4k6MrcsphGqZQ9fKRdJKasoaiwIrAewN1tapYI/KINLdfEL7n10LuF0pPSNf/IqjzZbB5VINctg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.24.7", + "@babel/plugin-transform-arrow-functions": "^7.24.7", + "cac": "^6.7.14", + "esbuild": "^0.21.5", + "magic-string": "^0.30.10", + "picocolors": "^1.0.1" + }, + "bin": { + "electron-vite": "bin/electron-vite.js" + }, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "peerDependencies": { + "@swc/core": "^1.0.0", + "vite": "^4.0.0 || ^5.0.0" + }, + "peerDependenciesMeta": { + "@swc/core": { + "optional": true + } + } + }, + "node_modules/electron/node_modules/@types/node": { + "version": "20.19.37", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz", + "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.0" + } + }, + "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/encoding": { + "version": "0.1.13", + "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.13.tgz", + "integrity": "sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "iconv-lite": "^0.6.2" + } + }, + "node_modules/end-of-stream": { + "version": "1.4.5", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz", + "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==", + "dev": true, + "license": "MIT", + "dependencies": { + "once": "^1.4.0" + } + }, + "node_modules/env-paths": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz", + "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/err-code": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/err-code/-/err-code-2.0.3.tgz", + "integrity": "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==", + "dev": true, + "license": "MIT" + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-object-atoms": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", + "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", + "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es6-error": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz", + "integrity": "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/esbuild": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz", + "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.21.5", + "@esbuild/android-arm": "0.21.5", + "@esbuild/android-arm64": "0.21.5", + "@esbuild/android-x64": "0.21.5", + "@esbuild/darwin-arm64": "0.21.5", + "@esbuild/darwin-x64": "0.21.5", + "@esbuild/freebsd-arm64": "0.21.5", + "@esbuild/freebsd-x64": "0.21.5", + "@esbuild/linux-arm": "0.21.5", + "@esbuild/linux-arm64": "0.21.5", + "@esbuild/linux-ia32": "0.21.5", + "@esbuild/linux-loong64": "0.21.5", + "@esbuild/linux-mips64el": "0.21.5", + "@esbuild/linux-ppc64": "0.21.5", + "@esbuild/linux-riscv64": "0.21.5", + "@esbuild/linux-s390x": "0.21.5", + "@esbuild/linux-x64": "0.21.5", + "@esbuild/netbsd-x64": "0.21.5", + "@esbuild/openbsd-x64": "0.21.5", + "@esbuild/sunos-x64": "0.21.5", + "@esbuild/win32-arm64": "0.21.5", + "@esbuild/win32-ia32": "0.21.5", + "@esbuild/win32-x64": "0.21.5" + } + }, + "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", + "optional": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/exponential-backoff": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/exponential-backoff/-/exponential-backoff-3.1.3.tgz", + "integrity": "sha512-ZgEeZXj30q+I0EN+CbSSpIyPaJ5HVQD18Z1m+u1FXbAeT94mr1zw50q4q6jiiC447Nl/YTcIYSAftiGqetwXCA==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/extract-zip": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz", + "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "debug": "^4.1.1", + "get-stream": "^5.1.0", + "yauzl": "^2.10.0" + }, + "bin": { + "extract-zip": "cli.js" + }, + "engines": { + "node": ">= 10.17.0" + }, + "optionalDependencies": { + "@types/yauzl": "^2.9.1" + } + }, + "node_modules/extsprintf": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.4.1.tgz", + "integrity": "sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA==", + "dev": true, + "engines": [ + "node >=0.6.0" + ], + "license": "MIT", + "optional": true + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "license": "MIT" + }, + "node_modules/fast-glob": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz", + "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.8" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fast-glob/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/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-uri": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz", + "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fastify" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/fastify" + } + ], + "license": "BSD-3-Clause" + }, + "node_modules/fastq": { + "version": "1.20.1", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz", + "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==", + "dev": true, + "license": "ISC", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/fd-slicer": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz", + "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==", + "dev": true, + "license": "MIT", + "dependencies": { + "pend": "~1.2.0" + } + }, + "node_modules/filelist": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.6.tgz", + "integrity": "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "minimatch": "^5.0.1" + } + }, + "node_modules/filelist/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/filelist/node_modules/brace-expansion": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz", + "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/filelist/node_modules/minimatch": { + "version": "5.1.9", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz", + "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "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/foreground-child": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz", + "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==", + "dev": true, + "license": "ISC", + "dependencies": { + "cross-spawn": "^7.0.6", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/foreground-child/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/form-data": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz", + "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==", + "dev": true, + "license": "MIT", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "es-set-tostringtag": "^2.1.0", + "hasown": "^2.0.2", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fraction.js": { + "version": "5.3.4", + "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz", + "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "*" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/rawify" + } + }, + "node_modules/fs-constants": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz", + "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/fs-extra": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz", + "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^4.0.0", + "universalify": "^0.1.0" + }, + "engines": { + "node": ">=6 <7 || >=8" + } + }, + "node_modules/fs-minipass": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz", + "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==", + "dev": true, + "license": "ISC", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "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/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gauge": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/gauge/-/gauge-4.0.4.tgz", + "integrity": "sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg==", + "deprecated": "This package is no longer supported.", + "dev": true, + "license": "ISC", + "dependencies": { + "aproba": "^1.0.3 || ^2.0.0", + "color-support": "^1.1.3", + "console-control-strings": "^1.1.0", + "has-unicode": "^2.0.1", + "signal-exit": "^3.0.7", + "string-width": "^4.2.3", + "strip-ansi": "^6.0.1", + "wide-align": "^1.1.5" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.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/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "dev": true, + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/get-stream": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", + "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", + "dev": true, + "license": "MIT", + "dependencies": { + "pump": "^3.0.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me", + "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/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/glob/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/glob/node_modules/brace-expansion": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", + "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/glob/node_modules/minimatch": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz", + "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/global-agent": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/global-agent/-/global-agent-3.0.0.tgz", + "integrity": "sha512-PT6XReJ+D07JvGoxQMkT6qji/jVNfX/h364XHZOWeRzy64sSFr+xJ5OX7LI3b4MPQzdL4H8Y8M0xzPpsVMwA8Q==", + "dev": true, + "license": "BSD-3-Clause", + "optional": true, + "dependencies": { + "boolean": "^3.0.1", + "es6-error": "^4.1.1", + "matcher": "^3.0.0", + "roarr": "^2.15.3", + "semver": "^7.3.2", + "serialize-error": "^7.0.1" + }, + "engines": { + "node": ">=10.0" + } + }, + "node_modules/global-agent/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "optional": true, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/globalthis": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz", + "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "define-properties": "^1.2.1", + "gopd": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/got": { + "version": "11.8.6", + "resolved": "https://registry.npmjs.org/got/-/got-11.8.6.tgz", + "integrity": "sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@sindresorhus/is": "^4.0.0", + "@szmarczak/http-timer": "^4.0.5", + "@types/cacheable-request": "^6.0.1", + "@types/responselike": "^1.0.0", + "cacheable-lookup": "^5.0.3", + "cacheable-request": "^7.0.2", + "decompress-response": "^6.0.0", + "http2-wrapper": "^1.0.0-beta.5.2", + "lowercase-keys": "^2.0.0", + "p-cancelable": "^2.0.0", + "responselike": "^2.0.0" + }, + "engines": { + "node": ">=10.19.0" + }, + "funding": { + "url": "https://github.com/sindresorhus/got?sponsor=1" + } + }, + "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/has-property-descriptors": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", + "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "es-define-property": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-unicode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", + "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hosted-git-info": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", + "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", + "dev": true, + "license": "ISC", + "dependencies": { + "lru-cache": "^6.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/hosted-git-info/node_modules/lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/hosted-git-info/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true, + "license": "ISC" + }, + "node_modules/http-cache-semantics": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz", + "integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==", + "dev": true, + "license": "BSD-2-Clause" + }, + "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/http2-wrapper": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-1.0.3.tgz", + "integrity": "sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "quick-lru": "^5.1.1", + "resolve-alpn": "^1.0.0" + }, + "engines": { + "node": ">=10.19.0" + } + }, + "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/humanize-ms": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz", + "integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.0.0" + } + }, + "node_modules/iconv-corefoundation": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/iconv-corefoundation/-/iconv-corefoundation-1.1.7.tgz", + "integrity": "sha512-T10qvkw0zz4wnm560lOEg0PovVqUXuOFhhHAkixw8/sycy7TJt7v/RrkEKEQnAw2viPSJu6iAkErxnzR0g8PpQ==", + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "dependencies": { + "cli-truncate": "^2.1.0", + "node-addon-api": "^1.6.3" + }, + "engines": { + "node": "^8.11.2 || >=10" + } + }, + "node_modules/iconv-lite": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "dev": true, + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "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/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/indent-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", + "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/infer-owner": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/infer-owner/-/infer-owner-1.0.4.tgz", + "integrity": "sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==", + "dev": true, + "license": "ISC" + }, + "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/ip-address": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.1.0.tgz", + "integrity": "sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 12" + } + }, + "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-ci": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/is-ci/-/is-ci-3.0.1.tgz", + "integrity": "sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ci-info": "^3.2.0" + }, + "bin": { + "is-ci": "bin.js" + } + }, + "node_modules/is-core-module": { + "version": "2.16.1", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz", + "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", + "dev": true, + "license": "MIT", + "dependencies": { + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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": "1.0.0", + "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-1.0.0.tgz", + "integrity": "sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-lambda": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-lambda/-/is-lambda-1.0.1.tgz", + "integrity": "sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==", + "dev": true, + "license": "MIT" + }, + "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-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", + "peer": true + }, + "node_modules/isbinaryfile": { + "version": "5.0.7", + "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-5.0.7.tgz", + "integrity": "sha512-gnWD14Jh3FzS3CPhF0AxNOJ8CxqeblPTADzI38r0wt8ZyQl5edpy75myt08EG2oKvpyiqSqsx+Wkz9vtkbTqYQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 18.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/gjtorikian/" + } + }, + "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/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/jake": { + "version": "10.9.4", + "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.4.tgz", + "integrity": "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "async": "^3.2.6", + "filelist": "^1.0.4", + "picocolors": "^1.1.1" + }, + "bin": { + "jake": "bin/cli.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/jiti": { + "version": "1.21.7", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz", + "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==", + "dev": true, + "license": "MIT", + "bin": { + "jiti": "bin/jiti.js" + } + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz", + "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "license": "MIT" + }, + "node_modules/json-schema-typed": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/json-schema-typed/-/json-schema-typed-8.0.2.tgz", + "integrity": "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==", + "license": "BSD-2-Clause" + }, + "node_modules/json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==", + "dev": true, + "license": "ISC", + "optional": true + }, + "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/jsonfile": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz", + "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==", + "dev": true, + "license": "MIT", + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/lazy-val": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/lazy-val/-/lazy-val-1.0.5.tgz", + "integrity": "sha512-0/BnGCCfyUMkBpeDgWihanIAF9JmZhHBgUhEqzvf+adhNGLoP6TaiI5oF8oyb3I45P+PcnrqihSf01M0l0G5+Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/lazystream": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/lazystream/-/lazystream-1.0.1.tgz", + "integrity": "sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "readable-stream": "^2.0.5" + }, + "engines": { + "node": ">= 0.6.3" + } + }, + "node_modules/lazystream/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", + "peer": true, + "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/lazystream/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", + "peer": true + }, + "node_modules/lazystream/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", + "peer": true, + "dependencies": { + "safe-buffer": "~5.1.0" + } + }, + "node_modules/lilconfig": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz", + "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/antonk52" + } + }, + "node_modules/lines-and-columns": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "dev": true, + "license": "MIT" + }, + "node_modules/lodash": { + "version": "4.17.23", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz", + "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==", + "dev": true, + "license": "MIT" + }, + "node_modules/lodash.defaults": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz", + "integrity": "sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/lodash.difference": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.difference/-/lodash.difference-4.5.0.tgz", + "integrity": "sha512-dS2j+W26TQ7taQBGN8Lbbq04ssV3emRw4NY58WErlTO29pIqS0HmoT5aJ9+TUQ1N3G+JOZSji4eugsWwGp9yPA==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/lodash.flatten": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/lodash.flatten/-/lodash.flatten-4.4.0.tgz", + "integrity": "sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/lodash.isplainobject": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz", + "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/lodash.union": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.union/-/lodash.union-4.6.0.tgz", + "integrity": "sha512-c4pB2CdGrGdjMKYLA+XiRDO7Y0PRQbm/Gzg8qMj+QH+pFVAoTp5sBpO0odL3FjoPCGjK96p6qsP+yQoiLoOBcw==", + "dev": true, + "license": "MIT", + "peer": true + }, + "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/lowercase-keys": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz", + "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/make-fetch-happen": { + "version": "10.2.1", + "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-10.2.1.tgz", + "integrity": "sha512-NgOPbRiaQM10DYXvN3/hhGVI2M5MtITFryzBGxHM5p4wnFxsVCbxkrBrDsk+EZ5OB4jEOT7AjDxtdF+KVEFT7w==", + "dev": true, + "license": "ISC", + "dependencies": { + "agentkeepalive": "^4.2.1", + "cacache": "^16.1.0", + "http-cache-semantics": "^4.1.0", + "http-proxy-agent": "^5.0.0", + "https-proxy-agent": "^5.0.0", + "is-lambda": "^1.0.1", + "lru-cache": "^7.7.1", + "minipass": "^3.1.6", + "minipass-collect": "^1.0.2", + "minipass-fetch": "^2.0.3", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "negotiator": "^0.6.3", + "promise-retry": "^2.0.1", + "socks-proxy-agent": "^7.0.0", + "ssri": "^9.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/make-fetch-happen/node_modules/agent-base": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "4" + }, + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/make-fetch-happen/node_modules/http-proxy-agent": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-5.0.0.tgz", + "integrity": "sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@tootallnate/once": "2", + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/make-fetch-happen/node_modules/https-proxy-agent": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", + "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", + "dev": true, + "license": "MIT", + "dependencies": { + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/make-fetch-happen/node_modules/lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/matcher": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/matcher/-/matcher-3.0.0.tgz", + "integrity": "sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "escape-string-regexp": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/micromatch": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", + "dev": true, + "license": "MIT", + "dependencies": { + "braces": "^3.0.3", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/mime": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-2.6.0.tgz", + "integrity": "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==", + "dev": true, + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "dev": true, + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "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/mimic-function": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/mimic-function/-/mimic-function-5.0.1.tgz", + "integrity": "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==", + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mimic-response": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz", + "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/minimatch": { + "version": "10.2.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", + "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-collect": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-1.0.2.tgz", + "integrity": "sha512-6T6lH0H8OG9kITm/Jm6tdooIbogG9e0tLgpY6mphXSm/A9u8Nq1ryBG+Qspiub9LjWlBPsPS3tWQ/Botq4FdxA==", + "dev": true, + "license": "ISC", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/minipass-fetch": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-2.1.2.tgz", + "integrity": "sha512-LT49Zi2/WMROHYoqGgdlQIZh8mLPZmOrN2NdJjMXxYe4nkN6FUyuPuOAOedNJDrx0IRGg9+4guZewtp8hE6TxA==", + "dev": true, + "license": "MIT", + "dependencies": { + "minipass": "^3.1.6", + "minipass-sized": "^1.0.3", + "minizlib": "^2.1.2" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + }, + "optionalDependencies": { + "encoding": "^0.1.13" + } + }, + "node_modules/minipass-flush": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/minipass-flush/-/minipass-flush-1.0.5.tgz", + "integrity": "sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==", + "dev": true, + "license": "ISC", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/minipass-pipeline": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz", + "integrity": "sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==", + "dev": true, + "license": "ISC", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-sized": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/minipass-sized/-/minipass-sized-1.0.3.tgz", + "integrity": "sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g==", + "dev": true, + "license": "ISC", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true, + "license": "ISC" + }, + "node_modules/minizlib": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz", + "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==", + "dev": true, + "license": "MIT", + "dependencies": { + "minipass": "^3.0.0", + "yallist": "^4.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/minizlib/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true, + "license": "ISC" + }, + "node_modules/mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "dev": true, + "license": "MIT", + "bin": { + "mkdirp": "bin/cmd.js" + }, + "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/mz": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz", + "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "any-promise": "^1.0.0", + "object-assign": "^4.0.1", + "thenify-all": "^1.0.0" + } + }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/negotiator": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.4.tgz", + "integrity": "sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/node-abi": { + "version": "3.87.0", + "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.87.0.tgz", + "integrity": "sha512-+CGM1L1CgmtheLcBuleyYOn7NWPVu0s0EJH2C4puxgEZb9h8QpR9G2dBfZJOAUhi7VQxuBPMd0hiISWcTyiYyQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "^7.3.5" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/node-abi/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/node-addon-api": { + "version": "1.7.2", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-1.7.2.tgz", + "integrity": "sha512-ibPK3iA+vaY1eEjESkQkM0BbCqFOaZMiXRTtdB0u7b4djtY6JnsjvPdUHVMg6xQt3B8fpTTWHI9A+ADjM9frzg==", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/node-api-version": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/node-api-version/-/node-api-version-0.2.1.tgz", + "integrity": "sha512-2xP/IGGMmmSQpI1+O/k72jF/ykvZ89JeuKX3TLJAYPDVLUalrshrLHkeVcCCZqG/eEa635cr8IBYzgnDvM2O8Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "^7.3.5" + } + }, + "node_modules/node-api-version/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/node-gyp": { + "version": "9.4.1", + "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-9.4.1.tgz", + "integrity": "sha512-OQkWKbjQKbGkMf/xqI1jjy3oCTgMKJac58G2+bjZb3fza6gW2YrCSdMQYaoTb70crvE//Gngr4f0AgVHmqHvBQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "env-paths": "^2.2.0", + "exponential-backoff": "^3.1.1", + "glob": "^7.1.4", + "graceful-fs": "^4.2.6", + "make-fetch-happen": "^10.0.3", + "nopt": "^6.0.0", + "npmlog": "^6.0.0", + "rimraf": "^3.0.2", + "semver": "^7.3.5", + "tar": "^6.1.2", + "which": "^2.0.2" + }, + "bin": { + "node-gyp": "bin/node-gyp.js" + }, + "engines": { + "node": "^12.13 || ^14.13 || >=16" + } + }, + "node_modules/node-gyp/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/node-releases": { + "version": "2.0.36", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.36.tgz", + "integrity": "sha512-TdC8FSgHz8Mwtw9g5L4gR/Sh9XhSP/0DEkQxfEFXOpiul5IiHgHan2VhYYb6agDSfp4KuvltmGApc8HMgUrIkA==", + "dev": true, + "license": "MIT" + }, + "node_modules/nopt": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-6.0.0.tgz", + "integrity": "sha512-ZwLpbTgdhuZUnZzjd7nb1ZV+4DoiC6/sfiVKok72ym/4Tlf+DFdlHYmT2JPmcNNWV6Pi3SDf1kT+A4r9RTuT9g==", + "dev": true, + "license": "ISC", + "dependencies": { + "abbrev": "^1.0.0" + }, + "bin": { + "nopt": "bin/nopt.js" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "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/normalize-url": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz", + "integrity": "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npmlog": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-6.0.2.tgz", + "integrity": "sha512-/vBvz5Jfr9dT/aFWd0FIRf+T/Q2WBsLENygUaFUqstqsycmZAP/t5BvFJTK0viFmSUxiUKTUplWy5vt+rvKIxg==", + "deprecated": "This package is no longer supported.", + "dev": true, + "license": "ISC", + "dependencies": { + "are-we-there-yet": "^3.0.0", + "console-control-strings": "^1.1.0", + "gauge": "^4.0.3", + "set-blocking": "^2.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-hash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz", + "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "dev": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">= 0.4" + } + }, + "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": "5.4.1", + "resolved": "https://registry.npmjs.org/ora/-/ora-5.4.1.tgz", + "integrity": "sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "bl": "^4.1.0", + "chalk": "^4.1.0", + "cli-cursor": "^3.1.0", + "cli-spinners": "^2.5.0", + "is-interactive": "^1.0.0", + "is-unicode-supported": "^0.1.0", + "log-symbols": "^4.1.0", + "strip-ansi": "^6.0.0", + "wcwidth": "^1.0.1" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-cancelable": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-2.1.1.tgz", + "integrity": "sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "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-map": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz", + "integrity": "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "aggregate-error": "^3.0.0" + }, + "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/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-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true, + "license": "MIT" + }, + "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/path-scurry/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/path-scurry/node_modules/minipass": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", + "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/pe-library": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/pe-library/-/pe-library-0.4.1.tgz", + "integrity": "sha512-eRWB5LBz7PpDu4PUlwT0PhnQfTQJlDDdPa35urV4Osrm0t0AqQFGn+UIkU3klZvwJ8KPO3VbBFsXquA6p6kqZw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12", + "npm": ">=6" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/jet2jet" + } + }, + "node_modules/pend": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz", + "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==", + "dev": true, + "license": "MIT" + }, + "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": "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/pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/pirates": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz", + "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/plist": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/plist/-/plist-3.1.0.tgz", + "integrity": "sha512-uysumyrvkUX0rX/dEVqt8gC3sTBzd4zoWfLeS29nb53imdaXVvLINYXTI2GNqzaMuvacNx4uJQ8+b3zXR0pkgQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@xmldom/xmldom": "^0.8.8", + "base64-js": "^1.5.1", + "xmlbuilder": "^15.1.1" + }, + "engines": { + "node": ">=10.4.0" + } + }, + "node_modules/postcss": { + "version": "8.5.8", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz", + "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/postcss-import": { + "version": "15.1.0", + "resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz", + "integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.0.0", + "read-cache": "^1.0.0", + "resolve": "^1.1.7" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "postcss": "^8.0.0" + } + }, + "node_modules/postcss-js": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.1.0.tgz", + "integrity": "sha512-oIAOTqgIo7q2EOwbhb8UalYePMvYoIeRY2YKntdpFQXNosSu3vLrniGgmH9OKs/qAkfoj5oB3le/7mINW1LCfw==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "camelcase-css": "^2.0.1" + }, + "engines": { + "node": "^12 || ^14 || >= 16" + }, + "peerDependencies": { + "postcss": "^8.4.21" + } + }, + "node_modules/postcss-load-config": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz", + "integrity": "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "lilconfig": "^3.1.1" + }, + "engines": { + "node": ">= 18" + }, + "peerDependencies": { + "jiti": ">=1.21.0", + "postcss": ">=8.0.9", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "jiti": { + "optional": true + }, + "postcss": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/postcss-nested": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz", + "integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.1.1" + }, + "engines": { + "node": ">=12.0" + }, + "peerDependencies": { + "postcss": "^8.2.14" + } + }, + "node_modules/postcss-selector-parser": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-value-parser": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz", + "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==", + "dev": true, + "license": "MIT" + }, + "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", + "peer": true + }, + "node_modules/progress": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz", + "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/promise-inflight": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/promise-inflight/-/promise-inflight-1.0.1.tgz", + "integrity": "sha512-6zWPyEOFaQBJYcGMHBKTKJ3u6TBsnMFOIZSa6ce1e/ZrrsOlnHRHbabMjLiBYKp+n44X9eUI6VUPaukCXHuG4g==", + "dev": true, + "license": "ISC" + }, + "node_modules/promise-retry": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/promise-retry/-/promise-retry-2.0.1.tgz", + "integrity": "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "err-code": "^2.0.2", + "retry": "^0.12.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/pump": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.4.tgz", + "integrity": "sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "end-of-stream": "^1.1.0", + "once": "^1.3.1" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "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/quick-lru": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz", + "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/react": { + "version": "19.2.4", + "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz", + "integrity": "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "19.2.4", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.4.tgz", + "integrity": "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "scheduler": "^0.27.0" + }, + "peerDependencies": { + "react": "^19.2.4" + } + }, + "node_modules/react-refresh": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz", + "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/read-binary-file-arch": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/read-binary-file-arch/-/read-binary-file-arch-1.0.6.tgz", + "integrity": "sha512-BNg9EN3DD3GsDXX7Aa8O4p92sryjkmzYYgmgTAc6CA4uGLEDzFfxOxugu21akOxpcXHiEgsYkC6nPsQvLLLmEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.3.4" + }, + "bin": { + "read-binary-file-arch": "cli.js" + } + }, + "node_modules/read-cache": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz", + "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "pify": "^2.3.0" + } + }, + "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/readdir-glob": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/readdir-glob/-/readdir-glob-1.1.3.tgz", + "integrity": "sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==", + "dev": true, + "license": "Apache-2.0", + "peer": true, + "dependencies": { + "minimatch": "^5.1.0" + } + }, + "node_modules/readdir-glob/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", + "peer": true + }, + "node_modules/readdir-glob/node_modules/brace-expansion": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz", + "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/readdir-glob/node_modules/minimatch": { + "version": "5.1.9", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz", + "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==", + "dev": true, + "license": "ISC", + "peer": true, + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "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/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/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resedit": { + "version": "1.7.2", + "resolved": "https://registry.npmjs.org/resedit/-/resedit-1.7.2.tgz", + "integrity": "sha512-vHjcY2MlAITJhC0eRD/Vv8Vlgmu9Sd3LX9zZvtGzU5ZImdTN3+d6e/4mnTyV8vEbyf1sgNIrWxhWlrys52OkEA==", + "dev": true, + "license": "MIT", + "dependencies": { + "pe-library": "^0.4.1" + }, + "engines": { + "node": ">=12", + "npm": ">=6" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/jet2jet" + } + }, + "node_modules/resolve": { + "version": "1.22.11", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz", + "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-core-module": "^2.16.1", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/resolve-alpn": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz", + "integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==", + "dev": true, + "license": "MIT" + }, + "node_modules/responselike": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/responselike/-/responselike-2.0.1.tgz", + "integrity": "sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==", + "dev": true, + "license": "MIT", + "dependencies": { + "lowercase-keys": "^2.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/restore-cursor": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz", + "integrity": "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "onetime": "^5.1.0", + "signal-exit": "^3.0.2" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/retry": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz", + "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/reusify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz", + "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", + "dev": true, + "license": "MIT", + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "deprecated": "Rimraf versions prior to v4 are no longer supported", + "dev": true, + "license": "ISC", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/roarr": { + "version": "2.15.4", + "resolved": "https://registry.npmjs.org/roarr/-/roarr-2.15.4.tgz", + "integrity": "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A==", + "dev": true, + "license": "BSD-3-Clause", + "optional": true, + "dependencies": { + "boolean": "^3.0.1", + "detect-node": "^2.0.4", + "globalthis": "^1.0.1", + "json-stringify-safe": "^5.0.1", + "semver-compare": "^1.0.0", + "sprintf-js": "^1.1.2" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/rollup": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.59.0.tgz", + "integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.59.0", + "@rollup/rollup-android-arm64": "4.59.0", + "@rollup/rollup-darwin-arm64": "4.59.0", + "@rollup/rollup-darwin-x64": "4.59.0", + "@rollup/rollup-freebsd-arm64": "4.59.0", + "@rollup/rollup-freebsd-x64": "4.59.0", + "@rollup/rollup-linux-arm-gnueabihf": "4.59.0", + "@rollup/rollup-linux-arm-musleabihf": "4.59.0", + "@rollup/rollup-linux-arm64-gnu": "4.59.0", + "@rollup/rollup-linux-arm64-musl": "4.59.0", + "@rollup/rollup-linux-loong64-gnu": "4.59.0", + "@rollup/rollup-linux-loong64-musl": "4.59.0", + "@rollup/rollup-linux-ppc64-gnu": "4.59.0", + "@rollup/rollup-linux-ppc64-musl": "4.59.0", + "@rollup/rollup-linux-riscv64-gnu": "4.59.0", + "@rollup/rollup-linux-riscv64-musl": "4.59.0", + "@rollup/rollup-linux-s390x-gnu": "4.59.0", + "@rollup/rollup-linux-x64-gnu": "4.59.0", + "@rollup/rollup-linux-x64-musl": "4.59.0", + "@rollup/rollup-openbsd-x64": "4.59.0", + "@rollup/rollup-openharmony-arm64": "4.59.0", + "@rollup/rollup-win32-arm64-msvc": "4.59.0", + "@rollup/rollup-win32-ia32-msvc": "4.59.0", + "@rollup/rollup-win32-x64-gnu": "4.59.0", + "@rollup/rollup-win32-x64-msvc": "4.59.0", + "fsevents": "~2.3.2" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "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": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "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/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "dev": true, + "license": "MIT" + }, + "node_modules/sanitize-filename": { + "version": "1.6.3", + "resolved": "https://registry.npmjs.org/sanitize-filename/-/sanitize-filename-1.6.3.tgz", + "integrity": "sha512-y/52Mcy7aw3gRm7IrcGDFx/bCk4AhRh2eI9luHOQM86nZsqwiRkkq2GekHXBBD+SmPidc8i2PqtYZl+pWJ8Oeg==", + "dev": true, + "license": "WTFPL OR ISC", + "dependencies": { + "truncate-utf8-bytes": "^1.0.0" + } + }, + "node_modules/sax": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.5.0.tgz", + "integrity": "sha512-21IYA3Q5cQf089Z6tgaUTr7lDAyzoTPx5HRtbhsME8Udispad8dC/+sziTNugOEx54ilvatQ9YCzl4KQLPcRHA==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=11.0.0" + } + }, + "node_modules/scheduler": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz", + "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/semver-compare": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/semver-compare/-/semver-compare-1.0.0.tgz", + "integrity": "sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow==", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/serialize-error": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/serialize-error/-/serialize-error-7.0.1.tgz", + "integrity": "sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "type-fest": "^0.13.1" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/serialize-error/node_modules/type-fest": { + "version": "0.13.1", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.13.1.tgz", + "integrity": "sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "optional": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==", + "dev": true, + "license": "ISC" + }, + "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": "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/simple-update-notifier": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz", + "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "^7.5.3" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/simple-update-notifier/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/slice-ansi": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-3.0.0.tgz", + "integrity": "sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "ansi-styles": "^4.0.0", + "astral-regex": "^2.0.0", + "is-fullwidth-code-point": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/smart-buffer": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz", + "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6.0.0", + "npm": ">= 3.0.0" + } + }, + "node_modules/socks": { + "version": "2.8.7", + "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.7.tgz", + "integrity": "sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ip-address": "^10.0.1", + "smart-buffer": "^4.2.0" + }, + "engines": { + "node": ">= 10.0.0", + "npm": ">= 3.0.0" + } + }, + "node_modules/socks-proxy-agent": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-7.0.0.tgz", + "integrity": "sha512-Fgl0YPZ902wEsAyiQ+idGd1A7rSFx/ayC1CQVMw5P+EQx2V0SgpGtf6OKFhVjPflPUl9YMmEOnmfjCdMUsygww==", + "dev": true, + "license": "MIT", + "dependencies": { + "agent-base": "^6.0.2", + "debug": "^4.3.3", + "socks": "^2.6.2" + }, + "engines": { + "node": ">= 10" + } + }, + "node_modules/socks-proxy-agent/node_modules/agent-base": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "4" + }, + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "dev": true, + "license": "MIT", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/sprintf-js": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz", + "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==", + "dev": true, + "license": "BSD-3-Clause", + "optional": true + }, + "node_modules/ssri": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/ssri/-/ssri-9.0.1.tgz", + "integrity": "sha512-o57Wcn66jMQvfHG1FlYbWeZWW/dHZhJXjpIcTfXldXEk5nz5lStPo3mK0OJQfGR3RbZUlbISexbljkJzuEj/8Q==", + "dev": true, + "license": "ISC", + "dependencies": { + "minipass": "^3.1.1" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/stat-mode": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/stat-mode/-/stat-mode-1.0.0.tgz", + "integrity": "sha512-jH9EhtKIjuXZ2cWxmXS8ZP80XyC3iasQxMDV8jzhNJpfDb7VbQLVW4Wvsxz9QZvzV+G4YoSfBUVKDOyxLzi/sg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "dev": true, + "license": "MIT", + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "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/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/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": { + "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/stubborn-fs": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/stubborn-fs/-/stubborn-fs-2.0.0.tgz", + "integrity": "sha512-Y0AvSwDw8y+nlSNFXMm2g6L51rBGdAQT20J3YSOqxC53Lo3bjWRtr2BKcfYoAf352WYpsZSTURrA0tqhfgudPA==", + "license": "MIT", + "dependencies": { + "stubborn-utils": "^1.0.1" + } + }, + "node_modules/stubborn-utils": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/stubborn-utils/-/stubborn-utils-1.0.2.tgz", + "integrity": "sha512-zOh9jPYI+xrNOyisSelgym4tolKTJCQd5GBhK0+0xJvcYDcwlOoxF/rnFKQ2KRZknXSG9jWAp66fwP6AxN9STg==", + "license": "MIT" + }, + "node_modules/sucrase": { + "version": "3.35.1", + "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.1.tgz", + "integrity": "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.2", + "commander": "^4.0.0", + "lines-and-columns": "^1.1.6", + "mz": "^2.7.0", + "pirates": "^4.0.1", + "tinyglobby": "^0.2.11", + "ts-interface-checker": "^0.1.9" + }, + "bin": { + "sucrase": "bin/sucrase", + "sucrase-node": "bin/sucrase-node" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/sumchecker": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/sumchecker/-/sumchecker-3.0.1.tgz", + "integrity": "sha512-MvjXzkz/BOfyVDkG0oFOtBxHX2u3gKbMHIF/dXblZsgD3BWOFLmHovIpZY7BykJdAjcqRCBi1WYBNdEC9yI7vg==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "debug": "^4.1.0" + }, + "engines": { + "node": ">= 8.0" + } + }, + "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/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/tailwindcss": { + "version": "3.4.19", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.19.tgz", + "integrity": "sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@alloc/quick-lru": "^5.2.0", + "arg": "^5.0.2", + "chokidar": "^3.6.0", + "didyoumean": "^1.2.2", + "dlv": "^1.1.3", + "fast-glob": "^3.3.2", + "glob-parent": "^6.0.2", + "is-glob": "^4.0.3", + "jiti": "^1.21.7", + "lilconfig": "^3.1.3", + "micromatch": "^4.0.8", + "normalize-path": "^3.0.0", + "object-hash": "^3.0.0", + "picocolors": "^1.1.1", + "postcss": "^8.4.47", + "postcss-import": "^15.1.0", + "postcss-js": "^4.0.1", + "postcss-load-config": "^4.0.2 || ^5.0 || ^6.0", + "postcss-nested": "^6.2.0", + "postcss-selector-parser": "^6.1.2", + "resolve": "^1.22.8", + "sucrase": "^3.35.0" + }, + "bin": { + "tailwind": "lib/cli.js", + "tailwindcss": "lib/cli.js" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tar": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz", + "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==", + "deprecated": "Old versions of tar are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me", + "dev": true, + "license": "ISC", + "dependencies": { + "chownr": "^2.0.0", + "fs-minipass": "^2.0.0", + "minipass": "^5.0.0", + "minizlib": "^2.1.1", + "mkdirp": "^1.0.3", + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/tar-stream": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz", + "integrity": "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "bl": "^4.0.3", + "end-of-stream": "^1.4.1", + "fs-constants": "^1.0.0", + "inherits": "^2.0.3", + "readable-stream": "^3.1.1" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/tar/node_modules/minipass": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz", + "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=8" + } + }, + "node_modules/tar/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true, + "license": "ISC" + }, + "node_modules/temp-file": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/temp-file/-/temp-file-3.4.0.tgz", + "integrity": "sha512-C5tjlC/HCtVUOi3KWVokd4vHVViOmGjtLwIh4MuzPo/nMYTV/p1urt3RnMz2IWXDdKEGJH3k5+KPxtqRsUYGtg==", + "dev": true, + "license": "MIT", + "dependencies": { + "async-exit-hook": "^2.0.1", + "fs-extra": "^10.0.0" + } + }, + "node_modules/temp-file/node_modules/fs-extra": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz", + "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/temp-file/node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/temp-file/node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/thenify": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz", + "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==", + "dev": true, + "license": "MIT", + "dependencies": { + "any-promise": "^1.0.0" + } + }, + "node_modules/thenify-all": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz", + "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==", + "dev": true, + "license": "MIT", + "dependencies": { + "thenify": ">= 3.1.0 < 4" + }, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/tinyglobby": { + "version": "0.2.15", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", + "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.3" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/tinyglobby/node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/tinyglobby/node_modules/picomatch": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", + "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/tmp": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.5.tgz", + "integrity": "sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.14" + } + }, + "node_modules/tmp-promise": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/tmp-promise/-/tmp-promise-3.0.3.tgz", + "integrity": "sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "tmp": "^0.2.0" + } + }, + "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/truncate-utf8-bytes": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/truncate-utf8-bytes/-/truncate-utf8-bytes-1.0.2.tgz", + "integrity": "sha512-95Pu1QXQvruGEhv62XCMO3Mm90GscOCClvrIUwCM0PYOXK3kaF3l3sIHxx71ThJfcbM2O5Au6SO3AWCSEfW4mQ==", + "dev": true, + "license": "WTFPL", + "dependencies": { + "utf8-byte-length": "^1.0.1" + } + }, + "node_modules/ts-interface-checker": { + "version": "0.1.13", + "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz", + "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/type-fest": { + "version": "4.41.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz", + "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==", + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/uint8array-extras": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/uint8array-extras/-/uint8array-extras-1.5.0.tgz", + "integrity": "sha512-rvKSBiC5zqCCiDZ9kAOszZcDvdAHwwIKJG33Ykj43OKcWsnmcBRL09YTU4nOeHZ8Y2a7l1MgTd08SBe9A8Qj6A==", + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/undici-types": { + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/unique-filename": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-2.0.1.tgz", + "integrity": "sha512-ODWHtkkdx3IAR+veKxFV+VBkUMcN+FaqzUUd7IZzt+0zhDZFPFxhlqwPF3YQvMHx1TD0tdgYl+kuPnJ8E6ql7A==", + "dev": true, + "license": "ISC", + "dependencies": { + "unique-slug": "^3.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/unique-slug": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-3.0.0.tgz", + "integrity": "sha512-8EyMynh679x/0gqE9fT9oilG+qEt+ibFyqjuVTsZn1+CMxH+XLlpvr2UZx4nVcCwTpx81nICr2JQFkM+HPLq4w==", + "dev": true, + "license": "ISC", + "dependencies": { + "imurmurhash": "^0.1.4" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + } + }, + "node_modules/universalify": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz", + "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", + "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/utf8-byte-length": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/utf8-byte-length/-/utf8-byte-length-1.0.5.tgz", + "integrity": "sha512-Xn0w3MtiQ6zoz2vFyUVruaCL53O/DwUvkEeOvj+uulMm0BkUGYWmBYVyElqZaSLhY6ZD0ulfU3aBra2aVT4xfA==", + "dev": true, + "license": "(WTFPL OR MIT)" + }, + "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/verror": { + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.1.tgz", + "integrity": "sha512-veufcmxri4e3XSrT0xwfUR7kguIkaxBeosDg00yDWhk49wdwkSUrvvsm7nc75e1PUyvIeZj6nS8VQRYz2/S4Xg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "assert-plus": "^1.0.0", + "core-util-is": "1.0.2", + "extsprintf": "^1.2.0" + }, + "engines": { + "node": ">=0.6.0" + } + }, + "node_modules/vite": { + "version": "5.4.21", + "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz", + "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.21.3", + "postcss": "^8.4.43", + "rollup": "^4.20.0" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || >=20.0.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.4.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + } + } + }, + "node_modules/wcwidth": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz", + "integrity": "sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==", + "dev": true, + "license": "MIT", + "dependencies": { + "defaults": "^1.0.3" + } + }, + "node_modules/when-exit": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/when-exit/-/when-exit-2.1.5.tgz", + "integrity": "sha512-VGkKJ564kzt6Ms1dbgPP/yuIoQCrsFAnRbptpC5wOEsDaNsbCB2bnfnaA8i/vRs5tjUSEOtIuvl9/MyVsvQZCg==", + "license": "MIT" + }, + "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/wide-align": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz", + "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==", + "dev": true, + "license": "ISC", + "dependencies": { + "string-width": "^1.0.2 || 2 || 3 || 4" + } + }, + "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/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/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/xmlbuilder": { + "version": "15.1.1", + "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz", + "integrity": "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.0" + } + }, + "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/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" + }, + "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/yauzl": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz", + "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "buffer-crc32": "~0.2.3", + "fd-slicer": "~1.1.0" + } + }, + "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/zip-stream": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/zip-stream/-/zip-stream-4.1.1.tgz", + "integrity": "sha512-9qv4rlDiopXg4E69k+vMHjNN63YFMe9sZMrdlvKnCjlCRWeCBswPPMPUfx+ipsAWq1LXHe70RcbaHdJJpS6hyQ==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "archiver-utils": "^3.0.4", + "compress-commons": "^4.1.2", + "readable-stream": "^3.6.0" + }, + "engines": { + "node": ">= 10" + } + }, + "node_modules/zip-stream/node_modules/archiver-utils": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/archiver-utils/-/archiver-utils-3.0.4.tgz", + "integrity": "sha512-KVgf4XQVrTjhyWmx6cte4RxonPLR9onExufI1jhvw/MQ4BB6IsZD5gT8Lq+u/+pRkWna/6JoHpiQioaqFP5Rzw==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "glob": "^7.2.3", + "graceful-fs": "^4.2.0", + "lazystream": "^1.0.0", + "lodash.defaults": "^4.2.0", + "lodash.difference": "^4.5.0", + "lodash.flatten": "^4.4.0", + "lodash.isplainobject": "^4.0.6", + "lodash.union": "^4.6.0", + "normalize-path": "^3.0.0", + "readable-stream": "^3.6.0" + }, + "engines": { + "node": ">= 10" + } + } + } +} diff --git a/desktop-app/package.json b/desktop-app/package.json new file mode 100644 index 0000000..63b77b0 --- /dev/null +++ b/desktop-app/package.json @@ -0,0 +1,78 @@ +{ + "name": "osmium-desktop", + "version": "1.0.0", + "description": "Osmium Desktop - AI-powered music copyright checker", + "main": "./out/main/index.js", + "author": "Osmium", + "license": "MIT", + "appId": "com.osmium.desktop", + "scripts": { + "dev": "electron-vite dev", + "build": "electron-vite build", + "package": "electron-builder", + "make": "npm run build && npm run package", + "preview": "electron-vite preview", + "start": "electron-vite preview", + "typecheck": "tsc --noEmit" + }, + "build": { + "appId": "com.osmium.desktop", + "productName": "Osmium", + "directories": { + "output": "dist" + }, + "files": [ + "out/**/*", + "public/**/*" + ], + "extraResources": [ + { + "from": "public", + "to": "public" + } + ], + "win": { + "icon": "public/icon.png", + "target": [ + "nsis", + "portable" + ] + }, + "mac": { + "icon": "public/icon.png", + "target": [ + "dmg" + ] + }, + "linux": { + "icon": "public/icon.png", + "target": [ + "AppImage", + "deb" + ] + }, + "nsis": { + "oneClick": false, + "allowToChangeInstallationDirectory": true + } + }, + "dependencies": { + "electron-store": "^10.0.0" + }, + "devDependencies": { + "@types/node": "^22.13.0", + "@types/react": "^19.0.0", + "@types/react-dom": "^19.0.0", + "@vitejs/plugin-react": "^4.3.4", + "autoprefixer": "^10.4.20", + "electron": "^34.0.0", + "electron-builder": "^25.1.8", + "electron-vite": "^2.3.0", + "postcss": "^8.4.49", + "react": "^19.0.0", + "react-dom": "^19.0.0", + "tailwindcss": "^3.4.17", + "typescript": "^5.7.0", + "vite": "^5.4.0" + } +} diff --git a/desktop-app/postcss.config.js b/desktop-app/postcss.config.js new file mode 100644 index 0000000..2b75bd8 --- /dev/null +++ b/desktop-app/postcss.config.js @@ -0,0 +1,6 @@ +export default { + plugins: { + tailwindcss: {}, + autoprefixer: {} + } +} diff --git a/desktop-app/public/icon.png b/desktop-app/public/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..e93696fbfae3b12886f86a6196451ea7ad0c6fdb GIT binary patch literal 12541 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 Lf_90fef0kW(lNYI literal 0 HcmV?d00001 diff --git a/desktop-app/src/main/index.ts b/desktop-app/src/main/index.ts new file mode 100644 index 0000000..9218e75 --- /dev/null +++ b/desktop-app/src/main/index.ts @@ -0,0 +1,153 @@ +import { app, BrowserWindow, ipcMain, shell, nativeImage } from 'electron' +import { join, dirname } from 'path' +import { fileURLToPath, pathToFileURL } from 'url' +import Store from 'electron-store' +import { existsSync } from 'fs' + +const __dirname = dirname(fileURLToPath(import.meta.url)) + +const OSMIUM_ICON = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAACXBIWXMAAAsTAAALEwEAmpwYAAAGRmlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4gPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNS42LWMxNDUgNzkuMTYzNDk5LCAyMDE4LzA4LzEzLTE2OjQwOjIyICAgICAgICAiPiA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPiA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIi8+IDwvcmRmOlJERj4gPC94OnhtcG1ldGE+IDw/eHBhY2tldCBlbmQ9InIiPz4JxfPsAAAEbElEQVR4nO3dW5LiMAyF4T6B/f8v3Cw7K6tAqGBmY1Zm/v9nZjOq0jq8WrQEAKB+XT9fX0BAAB6uLwCwAAHYvQBgBQSwewXAClx4mgBwEof/TcD4+vp6+QKAEQj8fkl4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4d3T2Pf7R9ggLoAIBWEPz/QMzQDwCQ1rTn/QH4DfMPAKTofP4NwG+YfwAghUnPAb4Hwm8AOIPT/wHAN7h+HwDfwOk/APAu3r8A4AOu+AsA7+H9CwDu4/0LAH7C+x8A8BPu/wDAn7j/AwB/4/4PAPyF+z8A8Bc+fADAT8x/BwD+gvu/AOAvHP8CAPyE8z8A8CNu/wDAj7j/AwA/4f4PAPyE+38AwE+4/wMAf+P/DwD8hPt/AMBP+P8DAP8B3t0+4E5ZiLsAAAAASUVORK5CYII=' + +function getIcon(): nativeImage { + const paths = [ + join(__dirname, '../../public/icon.png'), + join(__dirname, '../../../public/icon.png'), + join(process.resourcesPath, 'public/icon.png') + ] + + for (const iconPath of paths) { + if (existsSync(iconPath)) { + try { + const img = nativeImage.createFromPath(iconPath) + if (!img.isEmpty()) { + return img + } + } catch { + continue + } + } + } + + return nativeImage.createFromDataURL(OSMIUM_ICON) +} + +interface PipelineEvent { + step: number + name: string + status: string + message?: string + data?: unknown + error?: string +} + +interface CopyrightVerdict { + track: { name: string; artists: string[]; isrc: string; spotifyId: string; releaseDate: string; duration: number } + masterRights: { holder: string; label: string; confirmed: boolean; sources: string[] } + compositionRights: { writers: Array<{ name: string; role: string; source: string }>; publishers: string[]; proRegistrations: Array<{ pro: string; workId?: string; status: string }> } + samples: { detected: boolean; details: unknown[]; riskLevel: string } + copyrightType: string + riskLevel: string + confidence: number + licensingPath: string + discrepancies: string[] + dataSources: string[] + aiSummary?: { isCopyrighted: string; requiresLicense: string; licensingUrl?: string; explanation: string; actionableSteps: string[] } + generatedAt: string +} + +const store = new Store<{ checks: CopyrightVerdict[] }>({ + defaults: { checks: [] } +}) + +let mainWindow: BrowserWindow | null = null + +async function createWindow() { + const icon = getIcon() + + mainWindow = new BrowserWindow({ + width: 1200, + height: 800, + minWidth: 800, + minHeight: 600, + frame: false, + backgroundColor: '#0a0a0a', + icon: icon, + show: false, + webPreferences: { + preload: join(__dirname, '../preload/index.js'), + nodeIntegration: false, + contextIsolation: true + } + }) + + mainWindow.once('ready-to-show', () => { + mainWindow?.show() + }) + + mainWindow.webContents.setWindowOpenHandler(({ url }) => { + shell.openExternal(url) + return { action: 'deny' } + }) + + if (!app.isPackaged) { + mainWindow.loadURL('http://localhost:5173') + mainWindow.webContents.openDevTools() + } else { + mainWindow.loadFile(join(__dirname, '../renderer/index.html')) + } +} + +app.whenReady().then(createWindow) + +app.on('window-all-closed', () => { + if (process.platform !== 'darwin') app.quit() +}) + +app.on('activate', () => { + if (BrowserWindow.getAllWindows().length === 0) createWindow() +}) + +ipcMain.handle('window:minimize', () => mainWindow?.minimize()) +ipcMain.handle('window:maximize', () => { + if (mainWindow?.isMaximized()) mainWindow.unmaximize() + else mainWindow?.maximize() +}) +ipcMain.handle('window:close', () => mainWindow?.close()) + +ipcMain.handle('shell:open-external', async (_event, url: string) => { + await shell.openExternal(url) +}) + +ipcMain.handle('store:get-checks', () => store.get('checks')) +ipcMain.handle('store:clear-checks', () => store.set('checks', [])) +ipcMain.handle('store:get-path', () => store.path) + +ipcMain.handle('check:run', async (_event, trackInput: string) => { + try { + const osmiumPath = join(__dirname, '../../..') + const runnerUrl = pathToFileURL(join(osmiumPath, 'dist/pipeline/runner.js')).href + const configUrl = pathToFileURL(join(osmiumPath, 'dist/config/index.js')).href + + const { PipelineRunner } = await import(runnerUrl) + const { getConfig } = await import(configUrl) + + const config = getConfig() + const pipeline = new PipelineRunner(config) + + const sendProgress = (event: PipelineEvent) => { + mainWindow?.webContents.send('check:progress', event) + } + + pipeline.on('progress', sendProgress) + + const verdict = await pipeline.run(trackInput, { verbose: false }) + const checks = store.get('checks') || [] + store.set('checks', [verdict, ...checks].slice(0, 50)) + return { success: true, verdict } + } catch (error) { + return { + success: false, + error: error instanceof Error ? error.message : String(error) + } + } +}) diff --git a/desktop-app/src/preload/index.ts b/desktop-app/src/preload/index.ts new file mode 100644 index 0000000..57e1262 --- /dev/null +++ b/desktop-app/src/preload/index.ts @@ -0,0 +1,25 @@ +import { contextBridge, ipcRenderer } from 'electron' + +contextBridge.exposeInMainWorld('osmium', { + window: { + minimize: () => ipcRenderer.invoke('window:minimize'), + maximize: () => ipcRenderer.invoke('window:maximize'), + close: () => ipcRenderer.invoke('window:close') + }, + shell: { + openExternal: (url: string) => ipcRenderer.invoke('shell:open-external', url) + }, + store: { + getChecks: () => ipcRenderer.invoke('store:get-checks'), + clearChecks: () => ipcRenderer.invoke('store:clear-checks'), + getPath: () => ipcRenderer.invoke('store:get-path') + }, + check: { + run: (trackInput: string) => ipcRenderer.invoke('check:run', trackInput), + onProgress: (callback: (event: unknown) => void) => { + const handler = (_: unknown, event: unknown) => callback(event) + ipcRenderer.on('check:progress', handler) + return () => ipcRenderer.removeListener('check:progress', handler) + } + } +}) diff --git a/desktop-app/src/preload/types.d.ts b/desktop-app/src/preload/types.d.ts new file mode 100644 index 0000000..cb4ed37 --- /dev/null +++ b/desktop-app/src/preload/types.d.ts @@ -0,0 +1,23 @@ +import type { PipelineEvent, CopyrightVerdict } from '../types' + +declare global { + interface Window { + osmium: { + window: { + minimize: () => Promise + maximize: () => Promise + close: () => Promise + } + store: { + getChecks: () => Promise + clearChecks: () => Promise + } + check: { + run: (trackInput: string) => Promise<{ success: boolean; verdict?: CopyrightVerdict; error?: string }> + onProgress: (callback: (event: PipelineEvent) => void) => () => void + } + } + } +} + +export {} diff --git a/desktop-app/src/renderer/index.html b/desktop-app/src/renderer/index.html new file mode 100644 index 0000000..1b3f674 --- /dev/null +++ b/desktop-app/src/renderer/index.html @@ -0,0 +1,12 @@ + + + + + + Osmium + + +
+ + + diff --git a/desktop-app/src/renderer/src/App.tsx b/desktop-app/src/renderer/src/App.tsx new file mode 100644 index 0000000..d7f9d20 --- /dev/null +++ b/desktop-app/src/renderer/src/App.tsx @@ -0,0 +1,100 @@ +import { useState, useEffect } from 'react' +import TitleBar from './components/TitleBar' +import Sidebar from './components/Sidebar' +import HomePage from './components/HomePage' +import CheckView from './components/CheckView' +import type { PipelineEvent, CheckSession } from './types' + +export default function App() { + const [view, setView] = useState<'home' | 'check'>('home') + const [sessions, setSessions] = useState([]) + const [activeSession, setActiveSession] = useState(null) + const [isChecking, setIsChecking] = useState(false) + + useEffect(() => { + window.osmium.store.getChecks().then((checks) => { + const existing: CheckSession[] = checks.map((v, i) => ({ + id: `history-${i}`, + status: 'completed', + verdict: v + })) + setSessions(existing) + }) + }, []) + + const startCheck = async (input: string) => { + const session: CheckSession = { + id: `check-${Date.now()}`, + status: 'running', + input, + progress: [], + startedAt: new Date().toISOString() + } + + setSessions(prev => [session, ...prev]) + setActiveSession(session) + setView('check') + setIsChecking(true) + + const unsubscribe = window.osmium.check.onProgress((event: PipelineEvent) => { + setSessions(prev => prev.map(s => + s.id === session.id + ? { ...s, progress: [...(s.progress || []), event] } + : s + )) + setActiveSession(prev => prev ? { ...prev, progress: [...(prev.progress || []), event] } : prev) + }) + + const result = await window.osmium.check.run(input) + + unsubscribe() + setIsChecking(false) + + if (result.success && result.verdict) { + setSessions(prev => prev.map(s => + s.id === session.id + ? { ...s, status: 'completed', verdict: result.verdict } + : s + )) + setActiveSession(prev => prev ? { ...prev, status: 'completed', verdict: result.verdict } : prev) + } else { + setSessions(prev => prev.map(s => + s.id === session.id + ? { ...s, status: 'failed', error: result.error } + : s + )) + setActiveSession(prev => prev ? { ...prev, status: 'failed', error: result.error } : prev) + } + } + + const selectSession = (session: CheckSession) => { + setActiveSession(session) + setView('check') + } + + const goHome = () => { + setView('home') + setActiveSession(null) + } + + return ( +
+ +
+ +
+ {view === 'home' ? ( + + ) : ( + setView('home')} /> + )} +
+
+
+ ) +} diff --git a/desktop-app/src/renderer/src/components/CheckView.tsx b/desktop-app/src/renderer/src/components/CheckView.tsx new file mode 100644 index 0000000..6ecd486 --- /dev/null +++ b/desktop-app/src/renderer/src/components/CheckView.tsx @@ -0,0 +1,264 @@ +import type { CheckSession, PipelineEvent } from '../types' + +interface Props { + session: CheckSession | null + onNewCheck: () => void +} + +export default function CheckView({ session, onNewCheck }: Props) { + if (!session) { + return ( +
+ No session selected +
+ ) + } + + return ( +
+ {session.status === 'running' && ( + + )} + + {session.status === 'failed' && ( +
+
Check Failed
+
{session.error}
+ +
+ )} + + {session.status === 'completed' && session.verdict && ( + + )} +
+ ) +} + +function ProgressView({ progress }: { progress: PipelineEvent[] }) { + const steps = [ + { name: 'track-resolution', label: 'Track Resolution' }, + { name: 'credits-parsing', label: 'Credits Parsing' }, + { name: 'registry-lookup', label: 'Registry Lookup' }, + { name: 'musicbrainz-lookup', label: 'MusicBrainz' }, + { name: 'fingerprint-check', label: 'Fingerprint' }, + { name: 'sample-detection', label: 'Sample Detection' }, + { name: 'ai-synthesis', label: 'AI Synthesis' }, + { name: 'risk-assessment', label: 'Risk Assessment' }, + { name: 'ai-summary', label: 'AI Summary' } + ] + + const getStepStatus = (stepName: string) => { + const events = progress.filter(e => e.name === stepName) + if (events.length === 0) return 'pending' + const lastEvent = events[events.length - 1] + return lastEvent.status + } + + const getStepMessage = (stepName: string) => { + const events = progress.filter(e => e.name === stepName) + if (events.length === 0) return null + const lastEvent = events[events.length - 1] + return lastEvent.message + } + + return ( +
+

Running Check...

+
+ {steps.map((step, i) => { + const status = getStepStatus(step.name) + const message = getStepMessage(step.name) + + return ( +
+
+ {i + 1} +
+
+
{step.label}
+ {message &&
{message}
} +
+ +
+ ) + })} +
+
+ ) +} + +function StatusIcon({ status }: { status: string }) { + switch (status) { + case 'completed': + return ✓ + case 'failed': + return ✗ + case 'skipped': + return − + case 'in_progress': + return ● + default: + return ○ + } +} + +function VerdictView({ verdict }: { verdict: NonNullable }) { + const spotifyUrl = `https://open.spotify.com/track/${verdict.track.spotifyId}` + + return ( +
+
+
+

{verdict.track.name}

+

{verdict.track.artists.join(', ')}

+
+
+ + {verdict.confidence}% +
+
+ + + +
+ + + + w.name).join(', ') || 'Unknown'} /> +
+ + {verdict.compositionRights.proRegistrations.length > 0 && ( +
+

PRO Registrations

+
+ {verdict.compositionRights.proRegistrations.map((r, i) => ( +
+ {r.pro} + {r.workId && #{r.workId}} +
+ ))} +
+
+ )} + + {verdict.samples.detected && ( +
+

Samples Detected

+

Risk Level: {verdict.samples.riskLevel}

+
+ )} + + {verdict.discrepancies.length > 0 && ( +
+

Discrepancies

+
    + {verdict.discrepancies.map((d, i) =>
  • • {d}
    • )} +
+
+ )} + + {verdict.aiSummary && ( +
+
+ +
+

{verdict.aiSummary.explanation}

+ + {verdict.aiSummary.licensingUrl && ( +
+

Licensing URL

+ +
+ )} + + {verdict.aiSummary.actionableSteps.length > 0 && ( + <> +

Actionable Steps

+
    + {verdict.aiSummary.actionableSteps.map((step, i) => ( +
  • → {step}
    • + ))} +
+ + )} + + {verdict.aiSummary.webSearchSources.length > 0 && ( +
+

Web Sources

+
+ {verdict.aiSummary.webSearchSources.map((src, i) => ( +
+ {src.title} + +
+ ))} +
+
+ )} +
+ )} + +
+ Sources: {verdict.dataSources.join(' • ')} +
+
+ ) +} + +function InfoCard({ label, value, sub }: { label: string; value: string; sub?: string }) { + return ( +
+
{label}
+
{value}
+ {sub &&
{sub}
} +
+ ) +} + +function RiskBadge({ level }: { level: string }) { + const styles: Record = { + low: 'bg-green-500/20 text-green-400', + medium: 'bg-yellow-500/20 text-yellow-400', + high: 'bg-red-500/20 text-red-400', + critical: 'bg-red-500 text-white' + } + return ( + + {level.toUpperCase()} + + ) +} + +function LicenseBadge({ requires }: { requires: string }) { + if (requires === 'no') { + return NO LICENSE REQUIRED + } + if (requires === 'depends') { + return LICENSE MAY BE REQUIRED + } + return LICENSE REQUIRED +} diff --git a/desktop-app/src/renderer/src/components/HomePage.tsx b/desktop-app/src/renderer/src/components/HomePage.tsx new file mode 100644 index 0000000..24cafee --- /dev/null +++ b/desktop-app/src/renderer/src/components/HomePage.tsx @@ -0,0 +1,51 @@ +import { useState } from 'react' + +interface Props { + onStartCheck: (input: string) => void + isChecking: boolean +} + +export default function HomePage({ onStartCheck, isChecking }: Props) { + const [input, setInput] = useState('') + + const handleSubmit = (e: React.FormEvent) => { + e.preventDefault() + if (input.trim() && !isChecking) { + onStartCheck(input.trim()) + } + } + + return ( +
+
+

◆ OSMIUM

+

AI-powered music copyright checker

+
+ +
+
+ setInput(e.target.value)} + placeholder="Paste Spotify track URL or ID..." + disabled={isChecking} + className="w-full bg-bg-tertiary border border-white/10 rounded px-4 py-3 text-white placeholder-white/30 focus:outline-none focus:border-osmium/50 transition-colors disabled:opacity-50" + /> + +
+
+ +
+

Supports: Spotify track URLs, URIs, and IDs

+

Example: https://open.spotify.com/track/...

+
+
+ ) +} diff --git a/desktop-app/src/renderer/src/components/Sidebar.tsx b/desktop-app/src/renderer/src/components/Sidebar.tsx new file mode 100644 index 0000000..9da5800 --- /dev/null +++ b/desktop-app/src/renderer/src/components/Sidebar.tsx @@ -0,0 +1,66 @@ +import type { CheckSession } from '../types' + +interface Props { + sessions: CheckSession[] + activeId?: string + onSelect: (session: CheckSession) => void + onHome: () => void +} + +export default function Sidebar({ sessions, activeId, onSelect, onHome }: Props) { + return ( + + ) +} + +function RiskBadge({ level }: { level: string }) { + const colors: Record = { + low: 'text-green-400', + medium: 'text-yellow-400', + high: 'text-red-400', + critical: 'text-red-500 bg-red-500/20 px-1 rounded' + } + return {level.toUpperCase()} +} diff --git a/desktop-app/src/renderer/src/components/TitleBar.tsx b/desktop-app/src/renderer/src/components/TitleBar.tsx new file mode 100644 index 0000000..a7ce7e3 --- /dev/null +++ b/desktop-app/src/renderer/src/components/TitleBar.tsx @@ -0,0 +1,35 @@ +export default function TitleBar() { + return ( +
+
+ ◆ OSMIUM +
+
+ + + +
+
+ ) +} diff --git a/desktop-app/src/renderer/src/index.css b/desktop-app/src/renderer/src/index.css new file mode 100644 index 0000000..f75c389 --- /dev/null +++ b/desktop-app/src/renderer/src/index.css @@ -0,0 +1,37 @@ +@tailwind base; +@tailwind components; +@tailwind utilities; + +:root { + --osmium: #e8ff47; +} + +* { + margin: 0; + padding: 0; + box-sizing: border-box; +} + +html, body, #root { + height: 100%; + background: #0a0a0a; + color: #fff; + font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; +} + +::-webkit-scrollbar { + width: 6px; +} + +::-webkit-scrollbar-track { + background: #1a1a1a; +} + +::-webkit-scrollbar-thumb { + background: #333; + border-radius: 3px; +} + +::-webkit-scrollbar-thumb:hover { + background: #444; +} diff --git a/desktop-app/src/renderer/src/main.tsx b/desktop-app/src/renderer/src/main.tsx new file mode 100644 index 0000000..4a1b150 --- /dev/null +++ b/desktop-app/src/renderer/src/main.tsx @@ -0,0 +1,10 @@ +import React from 'react' +import ReactDOM from 'react-dom/client' +import App from './App' +import './index.css' + +ReactDOM.createRoot(document.getElementById('root')!).render( + + + +) diff --git a/desktop-app/src/renderer/src/types-window.d.ts b/desktop-app/src/renderer/src/types-window.d.ts new file mode 100644 index 0000000..0a093f9 --- /dev/null +++ b/desktop-app/src/renderer/src/types-window.d.ts @@ -0,0 +1,27 @@ +import type { PipelineEvent, CopyrightVerdict } from './types' + +declare global { + interface Window { + osmium: { + window: { + minimize: () => Promise + maximize: () => Promise + close: () => Promise + } + shell: { + openExternal: (url: string) => Promise + } + store: { + getChecks: () => Promise + clearChecks: () => Promise + getPath: () => Promise + } + check: { + run: (trackInput: string) => Promise<{ success: boolean; verdict?: CopyrightVerdict; error?: string }> + onProgress: (callback: (event: PipelineEvent) => void) => () => void + } + } + } +} + +export {} diff --git a/desktop-app/src/renderer/src/types.ts b/desktop-app/src/renderer/src/types.ts new file mode 100644 index 0000000..c3a78bd --- /dev/null +++ b/desktop-app/src/renderer/src/types.ts @@ -0,0 +1,62 @@ +export interface PipelineEvent { + step: number + name: string + status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'skipped' + message?: string + data?: unknown + error?: string +} + +export interface CopyrightVerdict { + track: { + name: string + artists: string[] + isrc: string + spotifyId: string + releaseDate: string + duration: number + } + masterRights: { + holder: string + label: string + confirmed: boolean + sources: string[] + } + compositionRights: { + writers: Array<{ name: string; role: string; source: string }> + publishers: string[] + proRegistrations: Array<{ pro: string; workId?: string; status: string }> + } + samples: { + detected: boolean + details: unknown[] + riskLevel: string + } + copyrightType: string + riskLevel: 'low' | 'medium' | 'high' | 'critical' + confidence: number + licensingPath: string + discrepancies: string[] + dataSources: string[] + aiSummary?: { + isCopyrighted: string + requiresLicense: string + masterRightsHolder: string + labelType: string + licensingUrl?: string + explanation: string + actionableSteps: string[] + webSearchSources: Array<{ title: string; url: string }> + } + generatedAt: string +} + +export interface CheckSession { + id: string + status: 'running' | 'completed' | 'failed' + input?: string + progress?: PipelineEvent[] + verdict?: CopyrightVerdict + error?: string + startedAt?: string +} diff --git a/desktop-app/tailwind.config.js b/desktop-app/tailwind.config.js new file mode 100644 index 0000000..9ecabd1 --- /dev/null +++ b/desktop-app/tailwind.config.js @@ -0,0 +1,17 @@ +/** @type {import('tailwindcss').Config} */ +export default { + content: ['./src/**/*.{js,ts,jsx,tsx}', './index.html'], + theme: { + extend: { + colors: { + osmium: '#e8ff47', + bg: { + primary: '#0a0a0a', + secondary: '#111111', + tertiary: '#1a1a1a' + } + } + } + }, + plugins: [] +} diff --git a/desktop-app/tsconfig.json b/desktop-app/tsconfig.json new file mode 100644 index 0000000..c09bd5d --- /dev/null +++ b/desktop-app/tsconfig.json @@ -0,0 +1,24 @@ +{ + "compilerOptions": { + "target": "ES2022", + "lib": ["ES2022", "DOM", "DOM.Iterable"], + "module": "ESNext", + "skipLibCheck": true, + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "resolveJsonModule": true, + "isolatedModules": true, + "noEmit": true, + "jsx": "react-jsx", + "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noFallthroughCasesInSwitch": true, + "baseUrl": ".", + "paths": { + "@/*": ["src/renderer/src/*"] + } + }, + "include": ["src/renderer/src/**/*.ts", "src/renderer/src/**/*.tsx"], + "references": [{ "path": "./tsconfig.node.json" }] +} diff --git a/desktop-app/tsconfig.node.json b/desktop-app/tsconfig.node.json new file mode 100644 index 0000000..c6c2346 --- /dev/null +++ b/desktop-app/tsconfig.node.json @@ -0,0 +1,19 @@ +{ + "compilerOptions": { + "composite": true, + "target": "ES2022", + "lib": ["ES2022"], + "module": "ESNext", + "skipLibCheck": true, + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "resolveJsonModule": true, + "isolatedModules": true, + "noEmit": true, + "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noFallthroughCasesInSwitch": true + }, + "include": ["src/main/**/*.ts", "src/preload/**/*.ts", "electron.vite.config.ts"] +} diff --git a/icon.png b/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..64ecf94c59493f7d1cfb899c5620d21add2980dc GIT binary patch literal 25973 zcmeFYS6GwXwm+ zLi+>+q(f*@ReF~YdO0uOT6?X%&pP}6oU3znF7Pp#WB%sobIdVkUf#c_MNfBy4gdgp z9c>Lb08nh5{?VKTzv&p7dIbQ~%+5v+eIM%UDcO0rL2T?jY#ks0Zl2&c04S>lc-q)K zaq#7}b#QWaSK(hLH1P8}+pF-K%Iiz(d#XD;cGgCDJ3K($GqOWHvAb!{uL`A84p0IC z+#Gyucmv#A-F=h-RQUhKRRaHi`n424@82Z8PgM9H>fh&8_waV$m50bfr1_zAyvpA8 zj!JNiyZ@XFep2Co?Ca~PBqinV?+@{pgLrs5Ny*&2c~eSSR!UY@5~Psy33T_h36OO6 z5jchT2Zn}&kDa%(r?0bzJMSr`jjadLSB0M+9OwNn&fGlz1@7+iPw7EDNCnt#|I3tr4gbePhXCh)%kV#zIUV^Aa$jf1|AqW?22qr>F40?EAY22z}1x0y&Y_P9W=l{ z6@FQ1Sp`XHIZ0_nBN;iR>vBrcH^imom87NrMXm2)@9Y@(|3ob>qa-W;f2Rih!`{Z% z=Kl@-zcj9NO8pP6K;Qg7v-Iyt>K?8h-XM3N6moxa`|lwgb@lt+9*)kg;Fu3wOO01Y zQ(ZykrhJPy10+;v) z4(?9>F>-1pSLCUi8@oG$c9s2`!M`Ux{P!3rq_niu ze_P4yKgUi(hgbP;hf>mZ_VM-b4*dJ8f5g)R2d{s8`o~9C=f4Aqm-laXQnIl-vy{}o(iHgNUy07a9rPe?Fpc%Z znooeK@|iQ}3jg5(03aHNjB9|Y8M3yjy4Y+{J->40ieUbo>)&s?IN$&N%;o;`f=eNL z0voNrRRnV6AG6VYNDieZvlFjeKX=FQOyAWvnvz1rB-#7?J+tGanyH|kpOZd+U1=9J ztFvJ$t$B8dZa;(6N1b;>&FPos`SX<+UWp|$>i#fv?Mup^Z+1iZVQbb;%6`h|zSiq%i2ga>TLvS!iYl#krl{c>GyST*UI zchGfoEOt4XBuyQpNIC1z%zb4JY9{p2UTls@5c@_uZ5L&j8WOM}%PYP#!+1Q?6OXaf zbWGyEBA%oDpiy!u-^f5)?^R}OT=wJb6Ax?h%$F*7-5}!|gNQ#v=e8w9F&BQ5dZoW> zJqikswv<;50|eGTVDin^p*Iw!S4#6+{HKFi@Z7|dO9yeTzlQ9Ytqk5v(s2#<);?Su zU5B>rFqvVB@y{ky7BHl@SdS1Yrw!U(c@uC$qV?1^^8o;e!08`F09Mrx0C)i%jXOpG z?^ZJW-wB!q7EPs%jv5c?YKyMW2;Szu{89c9C+CGaoT=B{GaM3j-m;G_q`EY z@!KOiy|Wg=bbg6W{@A#8Ma3b-=@*#IRG697M0o{Q!+lN`78mm$Oz9Zs;Xf0moWjZw zNO;E5eS@&Pd&X4ZOlmZI|NlS#-{>Ic-gutly&8kAcd`qiOltWKw!K`u;YO`>OXCmN zJSEXj)*r~_G2m6hW0&6d(sCHC8O}qmHp-*ZOd7AFpR7HQW90O0py3<5oy{WqZ2V() zpdgx>`dzP%;cchAv;$(Nz`0>LHErYj3*oOXt3H@_HEyJQzs6XAyNX_tnBZyrN+Dl{ zygeZhZgl3wy*3)JDy8`npor45;oht7GsQYbp>)+t=(IrBEP@sdj)^WK_To=>AE_1ZTJ26af z6;>ra^=^Z~(J?kpYIGCYRXOu*Cz~&;QC@e_Ibvt!D}oLU?lK6&HS-+ zd}(DUUF*r5lYH93wD(Gm(Z?W}B& zh8d($IoBvMy;mboUp$5xejp4S{*F%zyyvM!%SZJTY%7q&2X$gZ+XF6vOdhLt5#y)k%rF@Tm>iN|EbK1 zep=;rs@z;6QyFo!SFOG^gjSk3Ne0THtK77=n|W46!dW9Og1r0^ zS?WB~$U_wn9VV$-td!RnIRB}NGGMGU&EfWK?Kjis;$zdk2$LFsjVldpN`kru7Z&$^ z?5(D5#`_C4J`v%-vB1w?&SrsAxi7aJ7E{!o{e-#{bCq0T? zEuiPBul29@==d#u6R1paKJ!_{m#Or*KYtQ_4Fbt^RP(_nR0oaq+Uq3ureTG zN?f^X5vZmed`i~_(me-)85$F?)@r2el<^~x4_Yau$E-jW!mup;yP_t|pBHK(IR@kT z-8U{bvIFnrcB2T_hIUpgfgls&%3o9~7x?Tz2i4};jZ^x4AHV=3Dhu_jO<2md?cbd`QIrLdLyKbM{Iu!W z33lt5gKr14s@B&?$Qe^$1(ZOGZRs*!GcC9__4tSG8)qAh>2_OuQ4JzZH7{1;E4E0u z7kiq(0jLw1*)+azZP11qbC;0cjwmdtA3f>xJ2-K8AD_Kz4R{Xbr`3hAyW>%Cbzd{UhsD|E)*-k&SUzCX>k%yP|A zwvW!oqJUd6IfSaDzv#(xa1D+k0MSYOM!+>xkB!Kk6Nly}!X zEwwDp_!L+l=8*zcP`)Cxme??FtLqsTuoKt&d^qwrUTOpJ2>Zd z=qJAuO7v%nt78p?$#32`c)?)%Sl3PIkWeMdIBr^U47DdYKkeuRr9QLl5Gdps&w-^i z>+r9}z?$MheU6T7Oz0oq`nSFalnG(9-4j~k&$kxY-Q^V8XBN*?3g(R{5yir_V`Jce z^~-2p@CZ7n?`Pn_9;qm?Yq{UPN)W@HyCmv8b>Y!eei~QW!8D8PV=xw!tDTWMEPZ=} z0l>Iw8HJS8+Wo96zgOX!)GMr6k77OM?{A zFyN}}LVcU8e(`K%_pCBvu98N@zDTLL_R#eCBL>4pthkG#f86)**XKbCo^`hz4Pijv z1kSN}Xwt&GN-{Jt#|9k)OuYUMrZ{GN)@rZBYMU4E5qFt;hXyCHfs-f|i>_x~nC1sK z&rPs%g@~#&N-7x>x(y;YNPdVXBs0- ziJj5P*O+BD?=RS|)Oca{ZUM)ky+@+D=D$=zoL=O&&iY+ExI14z`(EWo#Pm_Ufirfp z;e(^qnsHq0#RxSKyRJ7KT~p7$PHov)OlCJ=lb!W-d%pe3Z43UoF@jJy+WXEG>tJoU$Ir*-Ut7og`OM$Hkfx!5cIk3VQthg|LoX1;UdTImaTvq&6sy$45npGQ^m>WtU`jsOD*EX3FE8<*#>svIIB@Dc;3OI@^80kP zXDzdHXVCssZJiNCk-aSH^*Rf=3zj@CS<-Fe$Vtwxc9_^UWsQx>*2&6M$4jIss%d{Q zq$~qyo*A=*y#rvT$n>7~`90=(wVn>;baSJH?Vo-=zRiq(97f=f^6~dRek_ zu8$X;pWx0gDA1h8*Xj?y8!O^7*wIrRb~_k&vBs<%?yy)=6_QS*4?H&@y3KiL>CSy-x(w*{ODY`LBl)8I zqEzZ6x?F|@w%mQ)S*ln4igHC&-iRw%zmPztk08|l^xOFt#uBBdH_F@X*Q{U;Y7umF z8LuxycXX-uzN}A!&aSFewOMLQiTkQZUfc}nPB#dk4TftEd_*M>vD!ZbJrbt%)&GQG z_Lb2j;e?tXi6mN%E26%#%n}eqMruzPv>SBxocwrEafjSEmNY*{nwxOAse}=P&`xYO zi7P?-YL1xxG}trW4v?;8V-APPYeM4kRh*laO{-5TS`IJI z_mD83MnCxI%-g zFwi5CLHqOpMQ1ifVo@?8O*$>ilGsnZWo17|2|xQ;e&XSn7m#*kqa|m-?7SBR(ZMZW zEH##xk_TcYD%9X79zYieCX)O;oOp>Yh;&n~}qPcsNA3S!ce7 z3>!o>tqP~Y`2Al_D6F_g_X-83hi6(ba6F6r@_O9+4z3DVNz9+*;>pgJ!ws6ufYOuxd)qkttDsNM*@C9!?2)AoTbwKB`CX3eDX%`(8b3+ERDz?~#56Ya|LT-R%6S1@WlqE1jss9DCWbbQ# z91Evs`%=(zKdA59kxQE$MaD^xOzlAr(##@iJa6c@zhe>f<`9v&mL&XMjlx_8-SiJO zd7sk|l?P!eoV;rG9)abIZrr{@#1A{0EAGQ2ef6zQ|VZSlF z!Hj$K&~Kdy?$4a0dv`?OVP8&Bz`e5qOxb()fnmyk+aOHjkC2a~&8F4(@U1)Km6{dT zG{GB>7x7F8mIdEM{0F3%twCO-#&S_qT`@ciP=c#=feGx&?d*gfVEPF@qZGIIQgcb< zTM{K1mI&e8?XbS&YAtTrv<3~s6GJ|_KLBkvj-{z1WUlQr=G0Sj;Z(nZ02J!k3FfB& ztY~VWHOakT;eHTxU(M9sB7hM@Qb7@mZE%Jv-r3uX#hu2v0X46K$X|!w~DvIdV zv<#geR9}09xfD2s4V6HD2DjReZ;WXFmJ^6WD{m{QrE$>GZSC=6n6CZv@Y+II%Na^8R0x-L~EYGGaY2)vT3+? zT;vbL?uDu`m$Bs^s0HQ>!Mjtb8+>w8ArVuE`N1awuXl~d3;K^q+UpzQA>>$EZ@xYhD8~)-9$2Ml z*cq$s)4aHMwj112M3hvYq8|4trHb#LevwcWq0R{vMT>(D%W#SW_9xDM2OahTcwD+s{g~6xer>={SW-esQLK3= z*CXt^faVg)Je4m%Ol{{SQC+x$-e~C@Rkgil*E^d6U2UHCz3q))EN7m7#E90{9E%e6 z;p_2x#Q1S(vwkErM?(!`8#Nwn8SSo=#|>MGpXP(G$L`+&wn4M{fCf43NL&a9lhgwW z%QKJc63?FhK5jK!{8-yJQ(uw3iQQRWYoA(HY+~z)LvH3Gys8VmQ`6jqG_5Ix8$=_f z&heHK6)CG9Yj!EOfR09&-K#TYX6X*4YRv1s31=5>mz;rBZ?T6?j;~8p)o2|x3qBs} zd6Tx35;04TQt?Y%^D#?b{3iGEOToH2YHG8CI;WnZF%Pu#z$tH0@N-6LYNvST8@29l zcI3o#Vq5fHHj)-KyS)ev@U42$l%BF>N?E@4hx=S!V_8Od>5d7g4@nQ+dc$uis5Q_P zejr`4Kv)<^MX7^kU3IX>-w zA4g3p-=C|r)+Px_R7#cAl}8OML&H8t?DzKLRpLKPxQB=tm?!`6{rNyxV@Vt9KPDwa zrUiH`4CNkxdvm0U5=z+)awJelm*QTqVqf$wIP zF2@jb1B4xO(59TkWjwbwq9lL;?SwCkE`CQ&M!2eA(M~dK5XgOW8JSUUqS6~ zC1V!08wjt7$G$rya2!?R!BEbzBDEiy$pefgv1nM=3H7wpz5pr3|7n5)w~49M&YRt% zSiu=_|MX_^)>;$J1qe!{MWW5smOIdA}`#!T+5;h94|NU1GbYh1?^tt|0KRfSY zs+1(T0kldwxRF<#LuN1;i25>Tv|t@6rwf5&rrS6>@9U}OqU%3(B4i$q{v=R$>L3~5#6c@}c#!S=}p$W5uWj^@u0J(HxHo!WnbTwDANNY~X`Q>s<#x|YqQ4Hu? zcL9%7y*WJ=78)@y_&$^hlT@iUlmK-xpDB)2@3fG}RmsQRE+QS6*=PCEoF};le~lAkxc|V^3H?_u7S4k8<-gm5|v(p?S&5|!X$sn0OQfh zC5X?IiGE+8cH#9vhb5{%@We?rPn2wm&dh|jGfo8Ot74m_T~Q1}V9M6RmAH6H*yHL# z&C2>$Apbu$iqQY&tB`Iep z@k8qz)DUI9f^QbGS@yRWh@4C?N`sKMtgxCig%j6koU2ecDqZoq?$3R3`|J0FeTsa5 z@Ec&fIuF?&hXPU$4X!Gs9^|nnc)k84Tev!_4}n0i1T+~K^2Uz57< zQx?7)zre7n3m=}%IEKwH$|~wuo+K<`MWz-HFmL-qw9-N{(@QUgspc>|SOX7>V6JA@ z6ZWYj%rM!4J*O9-+q(lBG61{1EZtSpNaMLsB#Vt?x2KPmSo|Z)zCiPDi#9$wy>O$V zV%UNGD1xhofXtNR?FFuU}cTLud~0n21+Y+TLgXrmSpZY?e+Em za94c-rm5drQ>wTQ1R}x10-qd+D`HuK0s{_FljgXStjU~uxhc(j%{8QUKm#u;kxA_5mmf3z; z1FdCY*Z3U{tKkk`YIFPTpg3;`h*k!4f`&P**t6IcRX9{deSfw5f|H~HcB;ow)ZZS? zc_U7&cA?0?H+eq&l43s%V|oWVguT)tru6y!SB=emo%gULB#trdscr~68U}8GHDJP= z&_o%0J5QH!12i%>#k4FCBQ-W8-7&5@7+`(ZiuR_0#+YRB!Idiq8-u;Wnx*33oIMG2=JER$0MQCLz;W8S=YbyXnp z{v5Pv30|XNA?q=$>aM7@j1oICyb`MDR*X+LYlcg&{LP7t-1^)$qP^b{dHh0D-vJ&* zdAjZU%z;HO!6~o(vRXEa0I0%`6rEH7dat+R$JOeaJv)@IGc(qVy2h+HxG=HB&bavU z=*z}O44Z}@1~0d~6haPYKP$H?Uti4jA7cu>ileHLdDTiWQuVcJ3sz)`5c&f=W>4>jwnwY!5@H38 zX?SH*=URCd-OaxI8PsVvD8I=`2=D2U+q)c-)++wUn)1-{_4c@|Ct5SQfl?&K{y#_FnZy7vkMNC0_ECi78H9hwUM>RA-xdTmWqdYF{-$M3G zz$(lw<&29iNfU#Ie05Ki9gAig%oAy6i$me*F+{%EldC9rLrEKVY#$h!%OKAp*#e|U z-+=-+<4x!*hY48&7eSu~=b3DEMC^$)FbozttDuVMlNl0ZK!*U(+i(&qSk-$MC`_oYzTKBks3Ddj z=Ad3dhNY!2t;PKf0`x|fHRMX6=^bPEu-E}zflJ3xoKkEcHP5q5Vgq|MmHip8+x!F8 z75QF(lu#>v^KB%yCp{*%6VVq~^3!i%)J$h3S2FzGCf%xop;`|2e()u(T>ru47~%`k zQXWw4r`hG2t~Xb|x**8mCAuY(S4RxKj6MSHtxTD;8qayB>9h53RRzBZE}vX=s3zKJ zE<1!Xq+lUQsS-7kJnaXEdNr#z3yhXP9g$B(Q&dsXy~|1$^4eKSK8%4Ym503y5#$R^ zlig`L`Bq}KCEgRXI1yl(>6a8UG`pJD^Ode2dV7;$IC8SA#0vlJ-bLKOc7^MadqXgGO})=& zv3^k|XYK9a0Nnb?>O;V^I6oD^(msAtW+W&;^8)Hv&UihHgU*!yueg#i$d!z-4}K)S zeKDV`N;g?Ww~jC#y!JJ1sU7ZtKPbPEy3a3_jdfInWw2KA6CiSr4F}GDsaTSWemdV+ zzAT78^`PeqG{Gi9jYr_exio{@^QHp~im&VNUV~!NME9%D7)P`#Wc?RMAU-U!{C;IW zu%xAZrr?`6!iP0}!@xGCP!1fSzNm#$tHfIK5$dQPEKDM;=Cy$!uwk4Ea^1i-P9bZ5 zf5A@e;C30sG&2xcByuSUk1pg$?`-NxA2yxKh1d55UPMV{b4Ta>_Svh&2h!BP(yse7 zqaXR{OdYKk6dohC#N=vvaisO(D_GqaH^Vv4+5EJdAn%0SmCV?E_3RjmRjRHGU=FzY zuH&^R@`10r1k_emO2KG7J;9{vYEL`X6289Xq?)t#RZx7f^g1FQ3ZLRlEV;P+JX>pF zan=(@$o-Cl6;%X^qB~3nS2{IHovc&qc*&7!JYMcMdX-@m>_UygcG>aps`hrUaDHF- zCA}n~;{KaXx3Op;Iji5 z8Shb$xis|`05LNzGsx85wp<&vkqy7UAkayFF0BlJQa!q+GLb92);9}ZyqNasO=nl) z%P#EoqbtaR3jxm3^;Jig;ry=o63co>NN3&gGi8dZ5iUY~o!9CUB#+3b0k zHnV^4{e#^$Wra%8@*nJE4``I%$7XYy2JuN@%fH?N8K0x5$(X;kr33e}&hHfSq?s3XhU~OjeZTsW5HYz7K{`BSz~vPa za=7iT^PZ)`peU!GKZ)Bv2o{gqSIdq8RI5FP#o0DY(VFK|A0w0)Etm`hV10q3+1s|y z7{oZ$=hmDQznK>Nj7O!?de)ERWYX+qH}BgjdxGblsY0Ej3BDxlqxZd$?|8MA7>F1L?L}yy;(L`2so|j5P^mmU=K$Y`#?T=>_owrN0!$0e?w6PZtuk z_g5X^n29dz46lE){3`?>J2vR2@%a0DJqxwt8$p4o=@!WkEM<2_BMe}OL-|ZZv;cCf zZi?XTt1}^Zd2Az4`xY}Y9$z?B5xZ|)kUy%=(w?cxfYVr_dI1eToSsC`qE#t3zL7Pa z|D{R$7~YfEcP&NGmKC=3C#V7L(30iW#F}^Dj^jy~o-uWlhM!we)nMkFk~)hJbZ$*V zMP0{8&OYHIR~6=uz5ync<5qAT_Ef)UUqI~(+7EkxS`!K0sJc>|=SyUThx0Mc!C~#k zhY(J0PMhM_Jx`pkJy6B5|9P>#=U?|a)Q$sN*!p%z|Hzk&;Q7`$C{lZ(N(wrwm%uOpQ`aN z*N62K(TdixH+n38IC~)yDfu87MRZqs$(a$Ep;(nC9I@r9E0N0nvYU{?>IPAK4QJ#s z*|A|BwOQRFC0qG{I=8_z>yz~sda_tE@-SWA>jl)Xqof6mr3SgUmBrz%v)Z(xTYS?8 zJ1c3x26!3*VtFLPBS-Y%nDF~XTiog!P_~Y{<8Ymzqf%L^O<(eSx{*o_w~uwl*=Uv@ zA7hC69~jv1;s(0IVF7oqc`#Q9k{?;UdP}s{!wvJ$)y)N;WFo+8{tMG)wiJAH28H;N z?^clcH(GnYBKJ4vyRcU@?YZ&nGFx+;SSO!zLgcm5$h=XSqQ1W=~(jN*M1 zFd?qX*qm1x^XxZ6dn6hAsq;XdSR_Y-+d1n|2481bn3K_|>-1sb7c?C$k|uO4w))mP z(;#R&_Wjf&rm(&iiABQ+5#vD}_3GzJ5Zy9l!D`bcqWh%it zbn@R7a*6RPN-jI2GI1wRALh>az7Uy^7H#wtc+hHi#6McbIxda7N>>*VyzWF$pxC{R zPSuOpt{A;hTU6?x2gmdeu^&7-v^A_-*QhR??^<016)C5r_@Izjw#1NxLhW7_RXsm> zH>%AwVOlWTzvULL5C*Tr!rT^*3>fQ{t(CSyu4Da4UqAR}RP-Cbz_a$gM(KS0`?K1! z#M#M6`#0-HuJeDP_m$r}&OHC?3QlnG!Z<1-Q6x8Ab^PblpOA`Kk->a1S)!Fl>by12 z)K8;-DfX2<)b|&=hL;hN8$AS z3OiiBWd6%6?QA}O^7s6xZY;crG{?6kAj{*9%RA|RmL!;IrPvrFYtp-U$e>j0u7Lb^W6)9VxQ=Bn}M&Usl*ST;clzF4lOu*cr4qpxkaQEg7I9Q*n*^ zt#WJsvmw}hM6=agw^z|ae9?SY5Gw}dS6E9NfXU=QG*{r^?ws-d^aR*N0xQ;^XCPib z`lcZN4tNhz^^>Inc2pRC_O!FQa?#igy{n$hn6f@u=Oc%%1GssN3|WKx4CC=0iIX1V zk?EJ?ybyNF)vvRN(eF$#5r5p8)+SVjvS5hv{;cZ-koIw5zw~PTIMm}UtCUu%6l?GS zjGdz1*Y~~W+WbTDq)=U(2KX+PY=b=N8Pv|TTxzuAcvhu5vEgvrQfl`2+RU{o4%s^% zDIZDKpC_aCOHeohzt5Ow?c(`o%fU*Ik_+@#@Y7gwFP}eRrR9U~&aLJxWdI1}Xsicc zw3JtHz{Obi(YxIS{*ye7#sIgQQR808b>th>ido|*hd!csp^OGOMf8;6bshRcqu1ZMfRH+*JLO z`Ab;OH}HUPuapV(v`X($zFl|l(!r$tydf&8>Q!~h|iM~ z2U~JZoWfG#o3S=K*N@jjB{v!JvFJ$3YDdj3==<9OIlQc>tle$IErUB+bBqx9l#ss{ zWd;QKybk$to^C7Jyv~|%J3+WpXMPwv zKPcoh#o2b-;$9Ua-$bHg-nc)BywmdB7<_M&=<*iqCha`+n5rNdiCUh2kw7pp`H^)} z?x$r0(YCbcC29E6c>;;968Z7MBXBD8IBoD5r>ndm~zwZ^Fv+!RFNP#b1p_b2p1}|qWTn-u12RpYUN*Z-PecwsH{Q3N^MODG;e{zZWJ3`pg{c4TI_xRhSI z$5%9r=+}9LtXUQt9q;A>(}KV-|XJi(=`N@npQ+u-2@~96Zk%AbK#JD zvZfKUmV3JIC+*~}z=s89FUw71;9-?~!2@mRoY~6XNFa%2W1t0M0d-0 z+L(1gOSM&B^01;bgO|IxEGQ&^YE|H*xH8$`4J9g$kSVeYWgj2QfrN-LCF>n+is?uW zN26c}<`2tPPE(Vue}+2d0}_WAXug>+5=~QYo-^6JV52BXLG%KOtW3)Cv>qqZ++SeZ z0Q+^ym*`CI{0!Y^{2XwEoORvn9Bap~ zh)aPfM1tF*S~=pgyAp<5_Ktgd=~~d+3FK%-eT;Cs=^seHlz3v*%rXAr@vQx7hSvpf zr+MuW^HP-+WnYhMecLMb;)w1>{z|KiWWa#a-7BvYHJ2A7khpo$mct2ENZ(O1!?jBC zhm@Qd>%5WVCEZ}0|IjZT6-iITuYG)vkQW*zs8d^4mQX(({ynJ-}xME|LA%wx0+YkeyMRA0S)Jby+#W;NMVSY}2< z+k5e)TS#5NGd*Lsn}jaGvJjFtf9^73*kjbT{zwxpI+bW=o{;6|GX{xROuoLC`Qu=1 z=c;hT@Fz@W4m@Y}@TUFZ75A)zJVGeF{(j(tfsi46xt@Vnq}1v>t%FLbv(S$~Kl}SF z(@(C!MXihdHrGhA4NSQ`2Hx!GvfOx;6Y~#V@wNeP73AmlZ~3`WdD5cQ0sF{|^W~Tz z8;z%&{qoVRv8ed`cQAtvrKHrT#rVW7HTjM^-HKI)cNaD*Lqv~_A4wC{m+G)L;8jQ8 zQ`ZeLa>shBrdG4Azh1+;PhOfJKrjRAR!-4}4sq$<3;}!ZU%Yjy@dS!@a!D&@QRQ(Z zjsb74%g=$!U#D1k`t{C4`N;D^RP(!z0c=KzrzYHBbF2p3yKvlG#JV{BgA zf^bgTF)v;vh)bXOToW<}$2UAx@>@a_ypBuwL(eUw!5;6!+>?tOV)3cxEA`V2Sylbm z_JHlz-NjHfMNG-dG0Wk}S3FI^$j0?2Z$B4g5gk(fc~;?=X7^Vk*vDgk@67(lWm{(a zqT>yPrw4S1G^bb|_bM^2FVV_(V{HSS#?J{Fr0Q;4Ub2z1>)7COaA_u2t>0j5%wv;I z>M$BI7XKB^FDR^*32_64_;wGy<6&U-(P2y0ES3@(J?6-PE*avT50D}e#Ih$2Ig^Ep z0!W>OBA?|-tucdi-JUo43-v5Jdi=vL*0|k=Pj-?5SK_{1|2l6YcE|hJsMN{eMLL&r z#5&CbmZFA`);+pvri|3_DiH`G}tS(%*Aj{8W3#+YoN>=DnQkj4eMTJ}c1KuO7U4tk}Xg zgK^R?e~=M6g3RP`mGUmv9i|P5e3I2Md#2q(Pbdg#@t)JJXM+pj(g-S{`Zh(@?VVCp zFG|aHGcWYx&F0vwlz!Ref3S@!OjPZ`w1@Qz>5GzAzQ% z&}iv@@YacHmj>T6@gwM#zjNeIm35M#biHU=#T(|~0q=N&nOZft0a-`@6>{_9K!xUK zqWTMW$ODt5*>dIA>g$ctFcnE(o*M8anSR2r{sSCr0@+ooKV8&8?40i=fBrh*f39u) zX}QVOF@h*5^dWWpyqn&3uta}E>$9KAr5B=>-KYMjfv=}xqxjh;NkcJD=WiH8I!sq8 z$))g~woy_rez-Tt#2?}uIX7R$yYp9hNZkeOnniszF=*)?Or>r{+;3RAcC|;CR8A!9 z-d%*$jCH3Hy3@ymzs{Zv2SEy3nqVt*+E(QV~>*YURr|*{Ub%zz7 zC1I93Z%q$!Ca8oBR^6i)YYM!+C~&$w88~J|8_q%EqInnwMD7M?HnWS}UkQxM!<^Sv z5!m!SNFxf>Kt+U^ZtXdCXL03_Fc32)r?A~3TyxcMj zYlA7b&o8eQL|0tFIcctysJOL`!>ee=GP90ujLuKsu z@OQ};C2sE{|8!+eMnF6V%@!}|;H?$n!RK(@rYa@*?xSb!>t=J_6dz1j*)LskRa}(h zt*fpth`pJM9Vi`Rsq7nLs~*NL*AaUU@1=RS5hu@)hQ504e9WBL89u&{lG(Mw4DY#X zs!1DPF}oIjobv7P6&2UTC0mmPZ3}1T2?yL;L0{(>LX0qOtl3S;AQMy5KjiQx^4dhX zD&Nc$U(xtVUiQx7hrhA5_w3FM$Sqr0eigp}q5nY19mE~lz zV3rg_q;A%z37+F#_oovr+^*A;kSTy^&-+p7ay*@K@Uux;mn(LAScIXYSZ8r@{Lov$ z1>^X2es-BOpVq~#zEJOt`JOY2*m_qJ!%e;t8eY3U_ilXo1php~reR~{>qFUhS}{;k zSC;F#-YZy#ve8U-_JLAh$E?+Lj}i;PbPKBk=@+_)CjxJYq%>HwgKkJ{b3DqgOKT~x z4(3u7Jvwh7CADhz>~P)!+aDb64ja&%9H=y#J+6xB`@NI@C5*Y{(3I<)<>4@!pR?fQ zZh=-{cg}6h`s{RFy{u_vCwyyVLEO(8M}=>UhN}l>8}0-oooF=boQLxm7nquuYqvK9)O7J)V&8IUrW8yvHk7yT7VF zcPr5?t0TU4WqRgU!?IIYMAA=XmkUuI(e3W8U@+j=x#BIqa&`pB25UuAklyfkgejmI#Ro#hsXMgj zi7ZVN1H68}_tWHs`Y6xhV0)Tah?`s;&o?PKFQs;lOEx7Q3KBsw-VMSVNAxgx2wdx$YKdJ&&ix06hk^m>Z-(S)$R{_sg9M7GzsjiTngry z%|yoXZ>^QWR&ptjX47-9{+yrWzZeSBdo%xH0~(Nzy%$v(bL7-JJ-LNk8ize5j;{kJ z7alz~oO|2z)_}vXw_Envh}$xPFG#np>|IC>QQvK(a-nBeccN0b;nlHiPmzN~!XyI9 zKiv0`wB`+UQCuFgp4kla2|37RoeJsms#|{k@E+RfYMSMK%|^ccjTk2RpUYM5S;mb{ z@1>LW79K*yDwU;NpE0r#1j)WAHn{bHR95b6p5{HA)+dz!+gAwPss_cCv|%Bss-;j7 z-wjSb%$6&Uo|Jc{vLK|`Q?#!-*@m`pfB^={`20ygpl5@d%jN5EX!()EZ3I{mNrJzb z@}^A~XIbr?kKNyYE^GmKpV7zNdSbXFJB!WKr)3NJw172PEiPxJP2XD1b6Xs*UY4kt zqJQ{nJXh#&LKOOZhazCprX7pXTIe5pr8qa11ke7y z+>&X}{kl|N$f5Fq2rhCw;G2l`HFaDoHfn@~9e?6iGlujCvmV)h!oAsj>;X$?mOAk; zkAJWq#xQaGT^R6WM5i_-z;?(VRX=um^02uyn|h2^(l-hL42!vD4n?m*$~C-hZOS>n z^rION%tEXQMZpc`qv6)#nmEoUNqYdpa>bH!J`+J~YMy+3%2ITzW;+Qrf5N}NJy3IV zuu5aaKXqtw0_eV}T;s~O>G&=Frz$@&s(7+=l@@?dc~LPyD{C9* zNW@#cg2%+vvTM#{8qhu{pOX6_J{#{Wq7@Ur`g{W#m|O1ZvCk319w0JFJ>4k~-*GI7 za{89ocjL-GaJ_VY(g9kIvbFr18)iAnLdq?f^|Seqb@Dm4(Hmxv2axt$!=<+ht`-;U zjB+Niug7QOp<<)N%RQfBo~Is?ubnuR)*nD+%@^dx)ZBo=s=?Uj&)tsgUZtAn0rtXt|O6U;XpDDra1~Zzf0nR^P z;xAf_#y(cjURrd}&48~{t*J{{8}58KPX1<6eL z0VXS1HeXj;YoOu$}N)0XL%VZkzFgbSmH2749THecf5PIZCh^4VM}EJ)`vgyI&qxl(ZSqI zsfWpEmRDrfA#`Jw$32K95wA-jVs?H%6v9=Urn6G?c;e=nVjbf&3XcR7zAIE0VR{t{ zbvFvi95twKnfr)Y4a`y3Wm2#8hBz!299n zdKdb1Q4vhxyyoLTiS;iYR3m;y-h1>R%bh85D_PswzhR2AmfccpO;t zSfza~H*#8tBS^Df80WNkVeCDT9`wWA9B$LcM{NGut5z?2LkgE2oN=hBGhdEA&1`bo zZAI?NxMpp|O~Vuw-k$qnO%e0yLrB%g(MRN;S|u!`JS7s&$TwNLa{nnN!C#@(>2rOM z`SBhN^eOx2EmMk>8%i~YbML?DI4>QG@tD;I*!_O!3vmugeAu{cwiP^BU_1PQ44)rt zHCfu0-76efPX7@b#Cq>2hg*u7(HS@X#!PK?)wFblJcC_xGW?JjOVR`gZ$YIQ{soC+ zCa$tTO@jY?`*s9?&rG&Zws8izzm4@SI9T?f_;AI>Tk-gmVVxYJy36i^<0p46{EDhg zX^v*hYGn>sm_Fg{!4f8GuAC@Rq-lv@rcBHtqmu4~m9}O|O^%FQn5GjwEXC>VP^|`+ zNKotbq2iB<6NFz`b|eUQXeQ&YQ}R}1;nMdFzW1n7&*rRIN5I#s+Uz>7`MY6v*{L7Y zpbTD=)kdGNG;-{~APsd{M|@`B&BI1Z%eRXQhq`0G3C`Fe9^^~Jt06b|@X!&qURXAg zSmtaVCQ3$MvDxycsSnQKfNa_h`yJ>6dr}sw?akI-{bfz@E~H`R)h#=6BrABeKx=L3 zdiCtIE%o(Rm2p8b^uanF*p~*N8vCTfN$d$-ALDV&s5Cp4;1lZpQpl zmlh-4TdJC;FHQ;tQM~il^KR+cpXA_I%N~9`Wc!;JV5hiI=4$cMOA~f!(^Y*Vx7|At zrJah>nHb9R+-FIO%o1R{7%20SuoPL&QkMCKzZlhjQ*)PS7cai{W`YNPdVf)Vi8CDt zzS5{SS{eL-+#KtqQVh|th<8Vg3L-5sBZ)z7f@)W=+|MT0rGIs{F|gP^G_p!+vx5cq zUL^eH`f{#uAV$Bax>zcMZ}R?vJhozFgl1X|FnH5v)%Ung{5u(GxF01-w)#*-tiUIt z0>3sxY2pY&hZd68Hh1O5?RYDUj=ADoewG1{8wxeHINy(gO01|i&XNiW!0rw7R8(K4 zfB9NG-sIagq*xZb%2o5nsKl$O_d+s^+oO{o`pYwjt z8U*n>Qg{J4E+743WpFfC-FCd=UM&TiJA!Q4%I@Ug$1;R;RV05s*Rh$j%fQz=WFl{V zh<)3~TAjmVD|vl#+SYAo`AYy|^A#%;+;fz1*_3XK=Z8jt+NN;Vb3A|&VWcK^5=Jj) zD-GqrC3PF9ur3qaI#@lcx2(UNZJqx$H(4-Qzh{i>4Qu_;_*1txjQ-7nOTpO(;&SZJ zCKa*w**a&sQfhV387$BCr2sQ=vpU-nR;0;tpCkHmWnOn#!VKSLVh0s5^z#L?QBNZ3 z?3?Y3+dD9YOoBG)+SFY-{89zk?=}g-eTlRJ_Sp4m?Y!`L#-4JOkvwtsl}75VDI^9?cZL3NA-YRwSw zJ{d^!dmEO14QDy$C#|kQq{rjeK;5mX zdfi0wGW9NWsA=6MDjpzi*KBeHqk0MJqL-;CxSKF#68Ow%1JN`_JeVs+i$anL_kZ-V zvc9Dg7CW;a_ti}vO*b-WsAEELi>H_%qpZ`KY^75>Vp-Gpax%I^(~pQ<44`k@AzLg z08Ufmxpp9}k7#JH*8k~jp;zNpMd$6pa@_v0P8HQ$E=4Du*^1P8@R{Z= zP~R99#*RDT{$3ivMHsUpjQ>qWG}Ni_BS@lroOVwNBsVdiGW_y;yybGQ557K7b=LKk z{PgT_f2}be8dSKy)jN3mK_>nrV|cV{J&z2fisp6wT&i~4SfDa?x&4|E;p=K_f0>${ zZCKp2-p?#;<HkSeQvM!h{VMnY@lC=H1eAV>z(j!xUr zl?sK$wdE+$=W;39*&>6%vxTn9=V`jR*3%-(m2Z57oT@;D(~Yv}?+o@Vxc8$`N2wr$ zW{q@Jb_6i!&*Wdhs$Jp($Gxp9Y%MZkn}yx5Ieusvt)SS^L10dM59&P_$^#d4APL%s zZ|dzi5M#p&y5V=6&4>lai%T5gP|O1g((XKVu4gM!me)+!(50za%=J3I>QwrS#JvpqB=KDXN4wCA#U|b zx7r556t+8=x5-O0g50#AMDO)CuS03nWf<@36>BJCcQkY|Kp8rkFD=A zw*#C115Gw~JR@7SUhKJg^JR)6u=z_0 zU&gE2s~CP8LbIDAkT-Bdl?@`PbInn5+wB$$B>zfi+xwGe_Q}&{lx~(y2h#(WkMYOsq-{^EzINR?wS&KdC|Kb^K@T0ab?8bRI)FzO= z+2#HGB+nToi;{0%`OyYN$80Y5bye!sK8o%fayrh-R$f==Whp;>XUR5WRxG`#91*n! z`}G}|=gIjy8D9Z>jT`uO{EGI`ONw=pF%tD2#jW4lmi*nF_ru%6u1d3VHrd5^L*J{N z-HtyEE%mH`DtBHmM+N_XI>`C8#7jEUVu$tYvYE|INiF$L@$a~uE&RT{=s!||Z*f4^ z8}z@-^4?2KQUzGo zv&)IHu_|8jX0FiD+(S^N-7VvoH|7!M33@7NI{oXc>sXYJ&3 zxzIhfp7&TFGP6A?8@o3d<(^&*fUl-NzkmEAh8BHnIm9xRQrX4Wgaa&aQH`DhrEJ6VSBlAcFw)@RYXa$?;NCIql8x_XVDQ*AChF<64jjIYnqdRQ~gxsDib zlbRFRhXG*kJqVaPfGxv*wCn?_2>mpj?qWc>S0u*Eve&rl5zg?ZuTICyJr6fEXWON) zCaq~nD0u%5{t#C9g>9IERCrL&V+kie3L4_^h$hVitYZd|y% zSdeeo)7l84P6mqbL%K!uR4Tw#01oGwX-hQ>_ZhODGkJt)&{Y{RD0T>pOwds&Ts!au z)GD@*O#UF=Nu}+n!GZ^X%o;l%^%?+PI#V9#$c~GJlqbv73yRR`fp75F*YP(AYZvOz zj3A}3pI>O-^Xf}H+Ag8a-qV7$+5?$gKxW9r6Vov1DUSkMa~M$>5+IhcogEfk=$$A< zXY1Y*%c?{qt_9rlw%D0ilYKcl*}V+Y#p;KSYh_jDxN100_SUt`v?QUV`zB;ws+A8n z4`*+=e;XQq5~3&N>@`_h%c*`H`JO1bmd6#*uDpG_ z_ZgSn61tTM=U!a0RK_n1cLe3}0Q|F~1|uRX85b_?So4eJAls9~+g9$sU%y}$FO|Mm zNVQAdo8JkF(!W|{>{~&tJ!R?wm>H|FY^@uF{R%zH29<9n{3pZSawv6rc{a>QM_xuX zAeMyX0L(E796NN-@%OT;n2l^C@&JusO&+xgd6{`CL`2ehDT{pQs+dcD57x18mrJBm zfU)2n*z1FtQ5}E8l&>J{%8Z)um_TE)iRezMv{JjTUxBmawfhy_KO64(c1cHm0UfU& zC7xyn+ol-U{#vPUEp3d(gf)cW=Ht5r2c(-y3n`|HKkxfpMWgEeb(8SmF3=_P5OiUQ zG1ylJvKUaL5RPIzb)ye;Vb|#aX}fBQ>xdn8Awx zuwnHw*fSf3n!aETiZvaD0L>(U4K81Ka-ILg5|0{!b|e?IqHTkMUdq>8#FVxOf{uLtQbA8mP*y z)Zu&_LKche1UmpVIPLS903KdWiOEbnK+v&m0=%(zj0J@&T4~OT%!{&ZIq>mMv2SM8 zxtJo`r;G$|EYU&A0bs)Hlp(;eLX81Kz~-1BIYp+F$KVCWQ9JxjFYS}LfDelslD`dH zwIaU0QO>fi?%$*({#?cGT|O*hV+VvNC-cD`K#l8ySOPiu?_*2WK4mr!vV|1~3;a%d zYll}g$^|!>DbV2vXc-T*bfX-+>=ZUB!WC;7?6Ol{np<*_#D>VNQq`-$HoZ$yM{R%f z1A_v%)My|61rAUTI$}>S7T})%o0dTp(8I>shqthmBFwpXzjda)rgnD?BC_3}pE{Zp z;-6ySXL5Vdb_Y4dFxL;nMv^MkwF7`Zm;!&Wqk4D&^=070g2aw~s0DWIU?E|2=Sb$% zR%UFz#-=H;Nuu?lbO+xJu*V&D00j}^AT0QRCwzteQYlP;r5w}-7}8q&;scx6&+T*U zA;n1;r^taEYMdt&Xkhq-Y-ld4UJ7>AdT<0OGg7i3C8iY0JeMc7cfWFK)k%CyO!j-g z7sr#u!${kEs09V;8-9sYe0vW54ZyP|KpxHyvsXhc6vQyKX6(QT*0u~-t%4(T&zeb+ z$WB;Dfw?a!U13gS%UZERj!#D}BJOE_2d8Or>M;OYT7t`v0p(#%9ApR0t;zleKUAGb z6J|5-mL;_7J|Vr*LOov}?)gIIG*#h1$L1=x=s&E$v}j;jd;g+i$YtIqtGV$AFE_lN zcu=$+jQalCD5je^CaS{;QoEtGG|N({t4#(FUL$Z}GSCF2Kp@Mj#^0G7B56$6Wqkh< za-rw;Z2pT2k6rYU1aBG_ z{MxyOGgmJ8Lc7vRW4W`4RtEKb;FwR+!NGr0NxpELU;o3*Uq{%?S6Fu*mXhWPNeW-(H!$db1n#VxM?@#}c#8l-H+S@}wp|0x0mQQzeT32?a~%qoAbLw(oAsk&qy2 zM94kNype%dH>l#!2E+>JX*I)YrjV?=HrLQgme4Zrwpor!oqzjkMuEPU0CAg#ALoW+ zkyk=$I0k(T%PK8GkJBD8#aBf-Al?ea&tg`jniz5YAQq>8=Ux1FU7WzW#6r8usA992 zh}(p8kC8r6Y~M#Bhn|hK;jqO-)VoUGnx-2svM#3v=Uj#pR+DeORc7 z7LdzzCe}-c%@+Jfcy+vW%4of&`je?desi(RhJg#vKq1Jm8Y1(Ai!1?0hA)WUe@VfV zUFMZ^Z4!z!iqJZKq}%CX|CrVBm3cI_MTYU?WWW)?da_w4y3>im-zO|*Rl>yr?FK-F zft(UDhnH>C${TXp?0~oFy$Pa14PY5SQs15FF(dzIAGSQvv^GpG59m_ z9gI}uE(l!CgGeDcv#PcrmufVN(M~}b_KDuK( zb?!!%*0ifRcY0l!^k#1r!0Ca^(u{7JL%lS58IZu#1|aWq;Pjx@F^k3(#efl&E3l7-2pT{3TAC zxtpttG^t+78Qx=jSSyh}*Mp0yvhAl@%rE^)70x_9T20=LJcp-;3sIPWo`W4SbS2-t z-Z%?iPop!j`tspHKZy}j;jK5RCQ!}O$IY~>vWi7?$hY|%+t_B&bKe9``xmU+EQ}~W z5OurAc7D%)Y|&%?ZxjY?5u~*?@k&5Gl2AqO@~+l&*2*N^lC=Qab^tr4I=_US~`N zQO}PwT-G_&6pPQu47i-u+`c|Fa64&q8(~LFe48ORK+Y&X2VVdX^f=A3X%JIfRL`z) zmU^tT<(MCb?LWsSpWl>lDgPz1QqKD}wqH4T9c{tu@Llqsq_17XWcZ9O&i4f*OQ< ze{kjJ9z%l4A9Oadd(Xe^&PYEg%r+vn6|>QMTKeQ7i{N`>gNa5G!dNCcNv7497k&by z@zzxKCva`flZ;Kyxr0YD6mbGom_VB_B{c;PfU7pty^L;da@v-xSHU}> z7{c;>hKt+GES?KRg9~tHV)+OYnd$|@+<^2tP1CH1E-Nn*+^x)1J5*f3SHNK|R+%8G z2WTL$qcIWi$O7`Waiun*02D~osFE|Da%oynW5lT4dT98o{=vBKeMG~b&tGHi&8$O# z`Jhvzx$bFo1cjImMD%fL7^#Rk4foJOF4Ms_ELAmT@TP3Bkr)p2Jqv7XJf{C+Dch2f`_q{#^`fIm4jIRsVXnAyZp9E9>4WnCcnPO z<&h+?KJGDT=HA1RXf_z&AMEy+u6f9$G=?P`_6LT$w1moKTFQ+LX#Kjs&!tOdRg#vB zWLEo+u#y%uB|1Xap+hrg9#N&qX?&*Z_vxx!+#Lu97I5Ja-R75BXTSt|4vd@dz1ewQ z1PX-hlEfxRzSxWVXEoN}shUq520>pkSZ5A0=<_Z_gNozmd)=erOhGTUN6N-@_jCmI z1$E_yWmnPb;1xb8gLOPKmTbxZe@SWBPiY8KV7f6IF>?JdznSbo!i|!s71n-g{GH)I z#IsTEb=m?H$zISh)QGq;lwve}bAD~)i#069&rsEAb~;As7Ci%iK^GZP6lX;NegLXJ zee)*PXP3LWpn>a)L*b;8rPR?$;86`8?zEO26ADw7g-M+Aw?k<+56b(VLX{NwuCyOG zTr;Hq4Q@I`gOq_FoD3Akh&o$3W>3?8sgQ=4WXv)hWIx0QcbfW_qqM}^!kmhzFT5LF zZFIhzMRNz8b_lpEMnz*ctV-)-{&OOj&wh4{Gc-s`ocC|8tjR#e{1!MtoTB4<=N&>B z${P45w_r(OBX}i`fsR!(;62T@REFECkYw1<{R7hz)2GxwaRcka{PyFS${<_DId68H zuR&Yf*M%^qs=6&N;o$MdERzlAoHe2;bS2Sv)QF+A5d%?II5-w9qN6HeZWbYXcmZXm zvQiaJ-698gWhpvdR3>!N($3XGGw2@TRir~t?OpXlZ#rT#oq$2^X^=pKnm$dHS_0pt zXK3ci`Ep#;ieJrUcsvrWcjzC$V%ZUO84he*yos4 zGZy}gZ@A_Poszkw+%esOmKG^OUjh3&;o+S1P1Ob4tYWUc(YQo2Xd8WfcbJr};Q zDmswuIL2AkwRiq)dU*KTjLd<`q2`y?I<{_J=Lwx_*vm0qipKM30xDXVT~o+p;!u-m z8<*2sp{1bEH zSA1p(q`Zk2B1K+PCo#Y|K$J<}3R_(A?1-lkF#I#({QLDb2Q;X((|yFHIYXn=q zeeHQiaQrb19qhiwI%wlf)sJotA%}I@T>Os;I(56=s==G?p$`>r4SGd61zj{2d15Yq zL~gUAd24`OT@0+Z6V2{^`D7$B&KY9aR!l)B3`8={^@AqlG1Y)9HpD3q8$ur_)l~|@ zjnc5E=7x2BhXzoK;bbd0l2lvxzq5h2|6W*6p}h(yrOWys6$;+muKRL8ZkY`ij=l#7 zKDy(6gW9v%1eybAYEW?7D$Rb(HILMAV)&-I_61;=B*EEM&jV0!LiaH8&XT;)`vJ-f zdgqXUv6>1v`KiUc2G7W|?AElxB5%Woyw#)DOFU=D$?yLru_0(FQ|y=12" + }, + "optionalDependencies": { + "global-agent": "^3.0.0" + } + }, "node_modules/@esbuild/aix-ppc64": { "version": "0.27.3", "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz", @@ -479,6 +503,32 @@ "zod": "^3.25.0 || ^4.0.0" } }, + "node_modules/@sindresorhus/is": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz", + "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/is?sponsor=1" + } + }, + "node_modules/@szmarczak/http-timer": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-4.0.6.tgz", + "integrity": "sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==", + "dev": true, + "license": "MIT", + "dependencies": { + "defer-to-connect": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/@tavily/core": { "version": "0.7.2", "resolved": "https://registry.npmjs.org/@tavily/core/-/core-0.7.2.tgz", @@ -490,6 +540,36 @@ "js-tiktoken": "^1.0.14" } }, + "node_modules/@types/cacheable-request": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz", + "integrity": "sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/http-cache-semantics": "*", + "@types/keyv": "^3.1.4", + "@types/node": "*", + "@types/responselike": "^1.0.0" + } + }, + "node_modules/@types/http-cache-semantics": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz", + "integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/keyv": { + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/@types/keyv/-/keyv-3.1.4.tgz", + "integrity": "sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, "node_modules/@types/node": { "version": "22.19.13", "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.13.tgz", @@ -500,6 +580,27 @@ "undici-types": "~6.21.0" } }, + "node_modules/@types/responselike": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@types/responselike/-/responselike-1.0.3.tgz", + "integrity": "sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/yauzl": { + "version": "2.10.3", + "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz", + "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@types/node": "*" + } + }, "node_modules/agent-base": { "version": "7.1.4", "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz", @@ -521,6 +622,22 @@ "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/asynckit": { "version": "0.4.0", "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", @@ -564,6 +681,54 @@ "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==", "license": "ISC" }, + "node_modules/boolean": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/boolean/-/boolean-3.2.0.tgz", + "integrity": "sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==", + "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/buffer-crc32": { + "version": "0.2.13", + "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz", + "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/cacheable-lookup": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-5.0.4.tgz", + "integrity": "sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.6.0" + } + }, + "node_modules/cacheable-request": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-7.0.4.tgz", + "integrity": "sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==", + "dev": true, + "license": "MIT", + "dependencies": { + "clone-response": "^1.0.2", + "get-stream": "^5.1.0", + "http-cache-semantics": "^4.0.0", + "keyv": "^4.0.0", + "lowercase-keys": "^2.0.0", + "normalize-url": "^6.0.1", + "responselike": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, "node_modules/call-bind-apply-helpers": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", @@ -658,6 +823,99 @@ "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/clone-response": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.3.tgz", + "integrity": "sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==", + "dev": true, + "license": "MIT", + "dependencies": { + "mimic-response": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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/combined-stream": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", @@ -679,6 +937,61 @@ "node": ">=18" } }, + "node_modules/concurrently": { + "version": "9.2.1", + "resolved": "https://registry.npmjs.org/concurrently/-/concurrently-9.2.1.tgz", + "integrity": "sha512-fsfrO0MxV64Znoy8/l1vVIjjHa29SZyyqPgQBwhiDcaW8wJc2W3XWVOGx4M3oJBnv/zdUZIIp1gDeS98GzP8Ng==", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "4.1.2", + "rxjs": "7.8.2", + "shell-quote": "1.8.3", + "supports-color": "8.1.1", + "tree-kill": "1.2.2", + "yargs": "17.7.2" + }, + "bin": { + "conc": "dist/bin/concurrently.js", + "concurrently": "dist/bin/concurrently.js" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/open-cli-tools/concurrently?sponsor=1" + } + }, + "node_modules/concurrently/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/concurrently/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/css-select": { "version": "5.2.2", "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.2.2.tgz", @@ -724,6 +1037,83 @@ } } }, + "node_modules/decompress-response": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz", + "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "mimic-response": "^3.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/decompress-response/node_modules/mimic-response": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz", + "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/defer-to-connect": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz", + "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/define-data-property": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz", + "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "gopd": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/define-properties": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz", + "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "define-data-property": "^1.0.1", + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/delayed-stream": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", @@ -733,6 +1123,14 @@ "node": ">=0.4.0" } }, + "node_modules/detect-node": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz", + "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==", + "dev": true, + "license": "MIT", + "optional": true + }, "node_modules/dom-serializer": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", @@ -814,6 +1212,42 @@ "node": ">= 0.4" } }, + "node_modules/electron": { + "version": "40.8.0", + "resolved": "https://registry.npmjs.org/electron/-/electron-40.8.0.tgz", + "integrity": "sha512-WoPq0Nr9Yx3g7T6VnJXdwa/rr2+VRyH3a+K+ezfMKBlf6WjxE/LmhMQabKbb6yjm9RbZhJBRcYyoLph421O2mQ==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "@electron/get": "^2.0.0", + "@types/node": "^24.9.0", + "extract-zip": "^2.0.1" + }, + "bin": { + "electron": "cli.js" + }, + "engines": { + "node": ">= 12.20.55" + } + }, + "node_modules/electron/node_modules/@types/node": { + "version": "24.12.0", + "resolved": "https://registry.npmjs.org/@types/node/-/node-24.12.0.tgz", + "integrity": "sha512-GYDxsZi3ChgmckRT9HPU0WEhKLP08ev/Yfcq2AstjrDASOYCSXeyjDsHg4v5t4jOj7cyDX3vmprafKlWIG9MXQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~7.16.0" + } + }, + "node_modules/electron/node_modules/undici-types": { + "version": "7.16.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz", + "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==", + "dev": true, + "license": "MIT" + }, "node_modules/emoji-regex": { "version": "10.6.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.6.0.tgz", @@ -833,6 +1267,16 @@ "url": "https://github.com/fb55/encoding-sniffer?sponsor=1" } }, + "node_modules/end-of-stream": { + "version": "1.4.5", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz", + "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==", + "dev": true, + "license": "MIT", + "dependencies": { + "once": "^1.4.0" + } + }, "node_modules/entities": { "version": "4.5.0", "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", @@ -845,6 +1289,16 @@ "url": "https://github.com/fb55/entities?sponsor=1" } }, + "node_modules/env-paths": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz", + "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, "node_modules/es-define-property": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", @@ -890,6 +1344,14 @@ "node": ">= 0.4" } }, + "node_modules/es6-error": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz", + "integrity": "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==", + "dev": true, + "license": "MIT", + "optional": true + }, "node_modules/esbuild": { "version": "0.27.3", "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz", @@ -932,21 +1394,76 @@ "@esbuild/win32-x64": "0.27.3" } }, - "node_modules/follow-redirects": { - "version": "1.15.11", - "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz", - "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==", - "funding": [ - { - "type": "individual", - "url": "https://github.com/sponsors/RubenVerborgh" - } - ], + "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": ">=4.0" - }, - "peerDependenciesMeta": { + "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", + "optional": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/extract-zip": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz", + "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "debug": "^4.1.1", + "get-stream": "^5.1.0", + "yauzl": "^2.10.0" + }, + "bin": { + "extract-zip": "cli.js" + }, + "engines": { + "node": ">= 10.17.0" + }, + "optionalDependencies": { + "@types/yauzl": "^2.9.1" + } + }, + "node_modules/fd-slicer": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz", + "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==", + "dev": true, + "license": "MIT", + "dependencies": { + "pend": "~1.2.0" + } + }, + "node_modules/follow-redirects": { + "version": "1.15.11", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz", + "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "license": "MIT", + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { "debug": { "optional": true } @@ -968,6 +1485,21 @@ "node": ">= 6" } }, + "node_modules/fs-extra": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz", + "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^4.0.0", + "universalify": "^0.1.0" + }, + "engines": { + "node": ">=6 <7 || >=8" + } + }, "node_modules/fsevents": { "version": "2.3.3", "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", @@ -992,6 +1524,16 @@ "url": "https://github.com/sponsors/ljharb" } }, + "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/get-east-asian-width": { "version": "1.5.0", "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.5.0.tgz", @@ -1041,6 +1583,22 @@ "node": ">= 0.4" } }, + "node_modules/get-stream": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", + "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", + "dev": true, + "license": "MIT", + "dependencies": { + "pump": "^3.0.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/get-tsconfig": { "version": "4.13.6", "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.6.tgz", @@ -1054,6 +1612,57 @@ "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" } }, + "node_modules/global-agent": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/global-agent/-/global-agent-3.0.0.tgz", + "integrity": "sha512-PT6XReJ+D07JvGoxQMkT6qji/jVNfX/h364XHZOWeRzy64sSFr+xJ5OX7LI3b4MPQzdL4H8Y8M0xzPpsVMwA8Q==", + "dev": true, + "license": "BSD-3-Clause", + "optional": true, + "dependencies": { + "boolean": "^3.0.1", + "es6-error": "^4.1.1", + "matcher": "^3.0.0", + "roarr": "^2.15.3", + "semver": "^7.3.2", + "serialize-error": "^7.0.1" + }, + "engines": { + "node": ">=10.0" + } + }, + "node_modules/global-agent/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "optional": true, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/globalthis": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz", + "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "define-properties": "^1.2.1", + "gopd": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/gopd": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", @@ -1066,6 +1675,63 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/got": { + "version": "11.8.6", + "resolved": "https://registry.npmjs.org/got/-/got-11.8.6.tgz", + "integrity": "sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@sindresorhus/is": "^4.0.0", + "@szmarczak/http-timer": "^4.0.5", + "@types/cacheable-request": "^6.0.1", + "@types/responselike": "^1.0.0", + "cacheable-lookup": "^5.0.3", + "cacheable-request": "^7.0.2", + "decompress-response": "^6.0.0", + "http2-wrapper": "^1.0.0-beta.5.2", + "lowercase-keys": "^2.0.0", + "p-cancelable": "^2.0.0", + "responselike": "^2.0.0" + }, + "engines": { + "node": ">=10.19.0" + }, + "funding": { + "url": "https://github.com/sindresorhus/got?sponsor=1" + } + }, + "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/has-property-descriptors": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", + "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "es-define-property": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/has-symbols": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", @@ -1136,6 +1802,27 @@ "url": "https://github.com/fb55/entities?sponsor=1" } }, + "node_modules/http-cache-semantics": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz", + "integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==", + "dev": true, + "license": "BSD-2-Clause" + }, + "node_modules/http2-wrapper": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-1.0.3.tgz", + "integrity": "sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "quick-lru": "^5.1.1", + "resolve-alpn": "^1.0.0" + }, + "engines": { + "node": ">=10.19.0" + } + }, "node_modules/https-proxy-agent": { "version": "7.0.6", "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz", @@ -1161,6 +1848,16 @@ "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-interactive": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-2.0.0.tgz", @@ -1194,6 +1891,41 @@ "base64-js": "^1.5.1" } }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==", + "dev": true, + "license": "ISC", + "optional": true + }, + "node_modules/jsonfile": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz", + "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==", + "dev": true, + "license": "MIT", + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, "node_modules/log-symbols": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-6.0.0.tgz", @@ -1222,6 +1954,30 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/lowercase-keys": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz", + "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/matcher": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/matcher/-/matcher-3.0.0.tgz", + "integrity": "sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "escape-string-regexp": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/math-intrinsics": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", @@ -1264,12 +2020,35 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/mimic-response": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz", + "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, "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==", "license": "MIT" }, + "node_modules/normalize-url": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz", + "integrity": "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/nth-check": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz", @@ -1282,6 +2061,27 @@ "url": "https://github.com/fb55/nth-check?sponsor=1" } }, + "node_modules/object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "dev": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">= 0.4" + } + }, + "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": "7.0.0", "resolved": "https://registry.npmjs.org/onetime/-/onetime-7.0.0.tgz", @@ -1341,6 +2141,16 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/p-cancelable": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-2.1.1.tgz", + "integrity": "sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, "node_modules/parse5": { "version": "7.3.0", "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz", @@ -1390,12 +2200,70 @@ "url": "https://github.com/fb55/entities?sponsor=1" } }, + "node_modules/pend": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz", + "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==", + "dev": true, + "license": "MIT" + }, + "node_modules/progress": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz", + "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, "node_modules/proxy-from-env": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==", "license": "MIT" }, + "node_modules/pump": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.4.tgz", + "integrity": "sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "end-of-stream": "^1.1.0", + "once": "^1.3.1" + } + }, + "node_modules/quick-lru": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz", + "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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/resolve-alpn": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz", + "integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==", + "dev": true, + "license": "MIT" + }, "node_modules/resolve-pkg-maps": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", @@ -1406,6 +2274,19 @@ "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" } }, + "node_modules/responselike": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/responselike/-/responselike-2.0.1.tgz", + "integrity": "sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==", + "dev": true, + "license": "MIT", + "dependencies": { + "lowercase-keys": "^2.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/restore-cursor": { "version": "5.1.0", "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-5.1.0.tgz", @@ -1422,12 +2303,89 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/roarr": { + "version": "2.15.4", + "resolved": "https://registry.npmjs.org/roarr/-/roarr-2.15.4.tgz", + "integrity": "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A==", + "dev": true, + "license": "BSD-3-Clause", + "optional": true, + "dependencies": { + "boolean": "^3.0.1", + "detect-node": "^2.0.4", + "globalthis": "^1.0.1", + "json-stringify-safe": "^5.0.1", + "semver-compare": "^1.0.0", + "sprintf-js": "^1.1.2" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/rxjs": { + "version": "7.8.2", + "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz", + "integrity": "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "tslib": "^2.1.0" + } + }, "node_modules/safer-buffer": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", "license": "MIT" }, + "node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/semver-compare": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/semver-compare/-/semver-compare-1.0.0.tgz", + "integrity": "sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow==", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/serialize-error": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/serialize-error/-/serialize-error-7.0.1.tgz", + "integrity": "sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "type-fest": "^0.13.1" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/shell-quote": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.3.tgz", + "integrity": "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/signal-exit": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", @@ -1440,6 +2398,14 @@ "url": "https://github.com/sponsors/isaacs" } }, + "node_modules/sprintf-js": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz", + "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==", + "dev": true, + "license": "BSD-3-Clause", + "optional": true + }, "node_modules/stdin-discarder": { "version": "0.2.2", "resolved": "https://registry.npmjs.org/stdin-discarder/-/stdin-discarder-0.2.2.tgz", @@ -1484,6 +2450,52 @@ "url": "https://github.com/chalk/strip-ansi?sponsor=1" } }, + "node_modules/sumchecker": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/sumchecker/-/sumchecker-3.0.1.tgz", + "integrity": "sha512-MvjXzkz/BOfyVDkG0oFOtBxHX2u3gKbMHIF/dXblZsgD3BWOFLmHovIpZY7BykJdAjcqRCBi1WYBNdEC9yI7vg==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "debug": "^4.1.0" + }, + "engines": { + "node": ">= 8.0" + } + }, + "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/tree-kill": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/tree-kill/-/tree-kill-1.2.2.tgz", + "integrity": "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==", + "dev": true, + "license": "MIT", + "bin": { + "tree-kill": "cli.js" + } + }, + "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/tsx": { "version": "4.21.0", "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz", @@ -1504,6 +2516,20 @@ "fsevents": "~2.3.3" } }, + "node_modules/type-fest": { + "version": "0.13.1", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.13.1.tgz", + "integrity": "sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "optional": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/typescript": { "version": "5.9.3", "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", @@ -1534,6 +2560,16 @@ "dev": true, "license": "MIT" }, + "node_modules/universalify": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz", + "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4.0.0" + } + }, "node_modules/whatwg-encoding": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz", @@ -1556,6 +2592,171 @@ "node": ">=18" } }, + "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/wrap-ansi/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/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/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/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/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/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/yauzl": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz", + "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "buffer-crc32": "~0.2.3", + "fd-slicer": "~1.1.0" + } + }, "node_modules/zod": { "version": "4.3.6", "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz", diff --git a/package.json b/package.json index 71d7eed..bfe0dc7 100644 --- a/package.json +++ b/package.json @@ -11,7 +11,8 @@ "dev": "tsx src/index.ts", "build": "tsc", "start": "node dist/index.js", - "typecheck": "tsc --noEmit" + "typecheck": "tsc --noEmit", + "test": "npm run build && node --input-type=module -e \"import { existsSync, readdirSync } from 'node:fs'; import { join } from 'node:path'; import { spawnSync } from 'node:child_process'; const dir = 'dist/tests'; if (!existsSync(dir)) { process.exit(0); } const files = readdirSync(dir).filter((name) => name.endsWith('.test.js')).map((name) => join(dir, name)); if (files.length === 0) { process.exit(0); } const result = spawnSync('node', ['--test', ...files], { stdio: 'inherit' }); process.exit(result.status ?? 1);\"" }, "keywords": [ "music", diff --git a/src/agents/summary-agent.ts b/src/agents/summary-agent.ts index ae4a504..52431b2 100644 --- a/src/agents/summary-agent.ts +++ b/src/agents/summary-agent.ts @@ -18,6 +18,7 @@ You must respond with ONLY valid JSON matching this exact schema: "labelType": "major" | "indie" | "self-released" | "unknown", "labelInfo": "string (brief sentence about the label or their general licensing ethos based on search results)", "licensingVerdict": "string (a clear 1-2 sentence final verdict on if they can use it)", + "licensingUrl": "string or null (if you found a direct URL to the label's licensing page, sync licensing portal, or music licensing platform. Extract from web search results. Must be a valid URL starting with https://)", "explanation": "string (a detailed paragraph explaining the rights situation, referencing the master and composition rights)", "actionableSteps": ["string", "string"] (2-3 concrete next steps to legally use the track) } @@ -26,6 +27,7 @@ Important Guidelines: - If the track is public domain, 'requiresLicense' is likely 'no'. - If the track is owned by a major label (UMG, Sony, Warner etc.), 'requiresLicense' is 'yes'. - If the search results indicate the label offers "sync licenses" or "creator safe" music, note that. +- IMPORTANT: Extract the licensingUrl from web search results if available. Look for URLs containing words like "license", "sync", "music", "creators", "licensing" from the label's official domain. - Keep the explanation professional and legally sound, but easy to understand for a content creator.`; const userMessage = `Analyze the copyright data and web search results to produce a final AI summary. diff --git a/src/index.ts b/src/index.ts index d1100a6..5a9e817 100644 --- a/src/index.ts +++ b/src/index.ts @@ -10,6 +10,7 @@ import { getPlaylistTracksViaNoCodeAPI } from "./services/nocode-spotify.js"; import { PipelineRunner } from "./pipeline/runner.js"; import { Logger } from "./utils/logger.js"; import { parsePlaylistInput } from "./utils/validation.js"; +import { loadHistory, saveToHistory, clearHistory, getStorePathForDisplay } from "./utils/history.js"; import type { PipelineEvent, CopyrightVerdict } from "./types/index.js"; const VERSION = "1.0.0"; @@ -21,7 +22,7 @@ program .description( chalk.hex("#e8ff47")("◆ Osmium") + chalk.gray( - " — AI-powered music copyright checker" + " — The Best tool for Checking Spotify Track Copyrights (and Playlists!)" ) ) .version(VERSION); @@ -93,6 +94,9 @@ program // Display verdict displayVerdict(verdict, logger); + // Save to history + await saveToHistory(verdict); + // Write to file if requested if (options.output) { await writeFile( @@ -188,6 +192,7 @@ program const verdict = await pipeline.run(t.id, { verbose: options.verbose ?? false }); verdicts.push(verdict); + await saveToHistory(verdict); spinner.stop(); const risk = colorRiskBadge(verdict.riskLevel); @@ -262,12 +267,19 @@ function displayVerdict(verdict: CopyrightVerdict, logger: Logger): void { logger.header("Copyright Verdict"); console.log(); + const spotifyUrl = `https://open.spotify.com/track/${verdict.track.spotifyId}`; + const rows: Array<[string, string, string]> = [ [ "Track", `${verdict.track.name} — ${verdict.track.artists.join(", ")}`, "", ], + [ + "Spotify", + chalk.cyan.underline(spotifyUrl), + "", + ], [ "ISRC", verdict.track.isrc || "N/A", @@ -364,6 +376,13 @@ function displayVerdict(verdict: CopyrightVerdict, logger: Logger): void { console.log(` ${bannerText}`); console.log(); console.log(` ${chalk.white(summary.explanation)}`); + + if (summary.licensingUrl) { + console.log(); + console.log(chalk.gray(" Licensing URL:")); + console.log(` ${chalk.cyan.underline(summary.licensingUrl)}`); + } + console.log(); console.log(chalk.gray(" Actionable Steps:")); for (const step of summary.actionableSteps) { @@ -372,9 +391,10 @@ function displayVerdict(verdict: CopyrightVerdict, logger: Logger): void { if (summary.webSearchSources.length > 0) { console.log(); - console.log(chalk.gray(" Web Sources Investigated:")); + console.log(chalk.gray(" Web Sources:")); for (const src of summary.webSearchSources) { - console.log(` ${chalk.dim("•")} ${chalk.cyan(src.title)}`); + console.log(` ${chalk.dim("•")} ${chalk.white(src.title)}`); + console.log(` ${chalk.cyan.underline(src.url)}`); } } } @@ -429,4 +449,63 @@ function colorConfidence(confidence: number): string { return chalk.red(`[LOW]`); } +program + .command("history") + .description("View past copyright checks (synced with desktop app)") + .option("-c, --clear", "Clear all history", false) + .option("-l, --limit ", "Limit number of entries to show", "20") + .action(async (options: { clear?: boolean; limit?: string }) => { + if (options.clear) { + await clearHistory(); + console.log(); + console.log(chalk.green(" ✓ History cleared")); + console.log(); + return; + } + + const limit = options.limit ? parseInt(options.limit, 10) : 20; + const history = await loadHistory(); + + console.log(); + console.log( + chalk.bold(chalk.hex("#e8ff47")(" ◆ OSMIUM")) + + chalk.gray(" · Check History") + ); + console.log(chalk.dim(" ─".repeat(25))); + console.log(); + + if (history.length === 0) { + console.log(chalk.dim(" No checks in history")); + console.log(); + console.log(chalk.dim(` Store: ${getStorePathForDisplay()}`)); + console.log(); + return; + } + + console.log(chalk.dim(` ${history.length} check(s) in history`)); + console.log(); + + const display = history.slice(0, limit); + + for (let i = 0; i < display.length; i++) { + const v = display[i]; + const num = chalk.dim(`${(i + 1).toString().padStart(3)}`); + const risk = colorRiskBadge(v.riskLevel); + const conf = chalk.dim(`${v.confidence}%`.padStart(4)); + const track = chalk.white(v.track.name); + const artists = chalk.gray(`— ${v.track.artists.join(", ")}`); + + console.log(` ${num} ${risk} ${conf} ${track} ${artists}`); + } + + if (history.length > limit) { + console.log(); + console.log(chalk.dim(` ... and ${history.length - limit} more`)); + } + + console.log(); + console.log(chalk.dim(` Store: ${getStorePathForDisplay()}`)); + console.log(); + }); + program.parse(); diff --git a/src/services/musicbrainz.ts b/src/services/musicbrainz.ts index 396a6bb..51feed3 100644 --- a/src/services/musicbrainz.ts +++ b/src/services/musicbrainz.ts @@ -2,16 +2,17 @@ import { rateLimitedFetch } from "../utils/http.js"; import type { MusicBrainzResult, MusicBrainzRecording } from "../types/index.js"; const MB_API_BASE = "https://musicbrainz.org/ws/2"; -const MB_USER_AGENT = "OsmiumCLI/1.0 (music-copyright-checker)"; +const MB_USER_AGENT = "OsmiumCLI/1.0 (https://github.com/anomalyco/opencode)"; + +interface MBSearchResponse { + created: string; + count: number; + offset: number; + recordings: MusicBrainzRecording[]; +} -/** - * Look up recordings by ISRC from MusicBrainz. - * Returns canonical recording info including labels and artist credits. - * - * MusicBrainz requires a descriptive User-Agent and limits to 1 req/sec. - */ export async function lookupByISRC(isrc: string): Promise { - const url = `${MB_API_BASE}/isrc/${isrc}?inc=releases+labels+artist-credits&fmt=json`; + const url = `${MB_API_BASE}/recording?query=isrc:${encodeURIComponent(isrc)}&inc=releases+labels+artists&fmt=json&limit=5`; const response = await rateLimitedFetch( url, @@ -21,45 +22,43 @@ export async function lookupByISRC(isrc: string): Promise { Accept: "application/json", }, }, - 1100 // 1.1 sec between requests + 1100 ); if (!response.ok) { if (response.status === 404) { return { recordings: [], isrc, label: undefined, mbid: undefined }; } + const body = await response.text().catch(() => ""); throw new Error( - `MusicBrainz ISRC lookup failed (${response.status}): ${isrc}` + `MusicBrainz ISRC lookup failed (${response.status}): ${isrc}. Response: ${body.slice(0, 200)}` ); } - const data = (await response.json()) as { recordings?: MusicBrainzRecording[] }; + const data = (await response.json()) as MBSearchResponse; const recordings = data.recordings ?? []; const primaryRecording = recordings[0]; - // Extract label from the first release's label-info let label: string | undefined; let mbid: string | undefined; if (primaryRecording) { mbid = primaryRecording.id; - const release = primaryRecording.releases?.[0]; - if (release?.labelInfo) { - label = release.labelInfo[0]?.label?.name; + const release = primaryRecording.releases?.[0] as unknown as Record; + const labelInfo = (release?.labelInfo ?? release?.["label-info"]) as Array<{ label?: { name: string } }> | undefined; + if (labelInfo?.[0]?.label?.name) { + label = labelInfo[0].label.name; } } return { recordings, isrc, label, mbid }; } -/** - * Look up a recording by MBID with additional relationships. - */ export async function getRecording( mbid: string ): Promise { - const url = `${MB_API_BASE}/recording/${mbid}?inc=releases+labels+artist-credits+work-rels&fmt=json`; + const url = `${MB_API_BASE}/recording/${mbid}?inc=releases+artists+isrcs+work-rels&fmt=json`; const response = await rateLimitedFetch( url, @@ -74,8 +73,9 @@ export async function getRecording( if (!response.ok) { if (response.status === 404) return null; + const body = await response.text().catch(() => ""); throw new Error( - `MusicBrainz recording lookup failed (${response.status}): ${mbid}` + `MusicBrainz recording lookup failed (${response.status}): ${mbid}. Response: ${body.slice(0, 200)}` ); } diff --git a/src/types/index.ts b/src/types/index.ts index 9cf5e8c..e52c8e7 100644 --- a/src/types/index.ts +++ b/src/types/index.ts @@ -182,6 +182,7 @@ export interface AISummary { labelType: "major" | "indie" | "self-released" | "unknown"; labelInfo: string; licensingVerdict: string; + licensingUrl?: string; explanation: string; actionableSteps: string[]; webSearchSources: WebSearchSource[]; diff --git a/src/utils/ai-client.ts b/src/utils/ai-client.ts index 81fbfb7..29a7a36 100644 --- a/src/utils/ai-client.ts +++ b/src/utils/ai-client.ts @@ -5,12 +5,21 @@ function isRateLimitError(error: unknown): boolean { if (error instanceof OpenAI.APIError) { return error.status === 429; } + if (OpenAI.APIConnectionError && error instanceof OpenAI.APIConnectionError) { + return true; + } + if (OpenAI.RateLimitError && error instanceof OpenAI.RateLimitError) { + return true; + } if (error instanceof Error) { const msg = error.message.toLowerCase(); return ( msg.includes("429") || msg.includes("rate limit") || - msg.includes("too many requests") + msg.includes("too many requests") || + msg.includes("overloaded") || + msg.includes("capacity") || + msg.includes("temporarily unavailable") ); } return false; @@ -54,26 +63,34 @@ export async function chatCompletion( } return content; } catch (error) { - if (isRateLimitError(error) && config.modal) { - console.warn("OpenRouter rate limited, falling back to Modal..."); - - const modalClient = new OpenAI({ - baseURL: config.modal.baseURL, - apiKey: config.modal.apiKey, - }); + if (isRateLimitError(error)) { + console.warn("OpenRouter rate limited:", error instanceof Error ? error.message : String(error)); + + if (config.modal) { + console.warn("Falling back to Modal..."); + try { + const modalClient = new OpenAI({ + baseURL: config.modal.baseURL, + apiKey: config.modal.apiKey, + }); - const result = await modalClient.chat.completions.create({ - model: config.modal.model, - messages, - max_tokens: options.maxTokens, - temperature: options.temperature, - }); + const result = await modalClient.chat.completions.create({ + model: config.modal.model, + messages, + max_tokens: options.maxTokens, + temperature: options.temperature, + }); - const content = result.choices?.[0]?.message?.content; - if (!content) { - throw new Error("No response content from Modal"); + const content = result.choices?.[0]?.message?.content; + if (!content) { + throw new Error("No response content from Modal"); + } + return content; + } catch (modalError) { + console.error("Modal fallback also failed:", modalError instanceof Error ? modalError.message : String(modalError)); + throw modalError; + } } - return content; } throw error; diff --git a/src/utils/history.ts b/src/utils/history.ts new file mode 100644 index 0000000..9f77e11 --- /dev/null +++ b/src/utils/history.ts @@ -0,0 +1,68 @@ +import { readFile, writeFile, mkdir } from "node:fs/promises"; +import { existsSync } from "node:fs"; +import { join } from "node:path"; +import { homedir, platform } from "node:os"; +import type { CopyrightVerdict } from "../types/index.js"; + +function getStorePath(): string { + const p = platform(); + const appName = "osmium-desktop"; + + if (p === "win32") { + const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming"); + return join(appData, appName, "config.json"); + } else if (p === "darwin") { + return join(homedir(), "Library", "Application Support", appName, "config.json"); + } else { + const configHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config"); + return join(configHome, appName, "config.json"); + } +} + +interface StoreData { + checks: CopyrightVerdict[]; +} + +export async function loadHistory(): Promise { + const storePath = getStorePath(); + + if (!existsSync(storePath)) { + return []; + } + + try { + const data = await readFile(storePath, "utf-8"); + const parsed = JSON.parse(data) as StoreData; + return parsed.checks || []; + } catch { + return []; + } +} + +export async function saveToHistory(verdict: CopyrightVerdict): Promise { + const storePath = getStorePath(); + const storeDir = join(storePath, ".."); + + if (!existsSync(storeDir)) { + await mkdir(storeDir, { recursive: true }); + } + + const existing = await loadHistory(); + const checks = [verdict, ...existing].slice(0, 50); + + const data: StoreData = { checks }; + await writeFile(storePath, JSON.stringify(data, null, 2), "utf-8"); +} + +export async function clearHistory(): Promise { + const storePath = getStorePath(); + + if (existsSync(storePath)) { + const data: StoreData = { checks: [] }; + await writeFile(storePath, JSON.stringify(data, null, 2), "utf-8"); + } +} + +export function getStorePathForDisplay(): string { + return getStorePath(); +} diff --git a/tsconfig.json b/tsconfig.json index 4b8fec8..c757d1e 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -3,6 +3,7 @@ "target": "ES2022", "module": "Node16", "moduleResolution": "Node16", + "lib": ["ES2022"], "outDir": "./dist", "rootDir": "./src", "strict": true, @@ -21,4 +22,4 @@ "node_modules", "dist" ] -} \ No newline at end of file +} From 6431b017248e6088a6a98329dca4af7401f23206 Mon Sep 17 00:00:00 2001 From: Coder-soft Date: Sat, 7 Mar 2026 20:58:00 +0500 Subject: [PATCH 2/8] feat: add Spotify search functionality and migrate from Modal to Groq - Add Spotify search feature to both desktop app and CLI with interactive track selection - Replace Modal AI provider with Groq for improved performance and cost-effectiveness - Update UI to include search mode alongside URL input in desktop application - Add IPC handlers for Spotify search between renderer and main processes - Refactor CLI check logic into shared function for reuse in search command - Update configuration types and validation to support Groq integration - Add test files for Spotify search functionality - Update project descriptions to reflect Renderdragon branding --- README.md | 2 +- desktop-app/out/main/index.js | 18 + desktop-app/out/preload/index.js | 3 + desktop-app/package.json | 2 +- desktop-app/src/main/index.ts | 45 +- desktop-app/src/preload/index.ts | 3 + .../src/renderer/src/components/HomePage.tsx | 146 +- .../src/renderer/src/types-window.d.ts | 7 +- desktop-app/src/renderer/src/types.ts | 8 + package-lock.json | 1580 ++++------------- package.json | 3 +- src/config/index.ts | 10 +- src/index.ts | 235 ++- src/services/spotify.ts | 33 + src/types/index.ts | 2 +- src/utils/ai-client.ts | 22 +- tmp/test2.ts | 39 +- tmp/test_search.ts | 16 + 18 files changed, 815 insertions(+), 1359 deletions(-) create mode 100644 tmp/test_search.ts diff --git a/README.md b/README.md index 849add1..ac641a3 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Osmium CLI 💿 -**Osmium** is an AI-powered music copyright checker. It orchestrates a sophisticated multi-agent AI pipeline to resolve track ownership by consulting Spotify, PRO registries (ASCAP, BMI, SESAC, Copyright Office), audio fingerprinting (AcoustID), metadata databases (MusicBrainz, Discogs), and sample databases. +**Osmium** is a music copyright checker By Renderdragon. It orchestrates a sophisticated multi-agent AI pipeline to resolve track ownership by consulting Spotify, PRO registries (ASCAP, BMI, SESAC, Copyright Office), audio fingerprinting (AcoustID), metadata databases (MusicBrainz, Discogs), and sample databases. Finally, it synthesizes all this data using an LLM (via OpenRouter) to provide a definitive, human-readable answer on whether a specific track requires a license and the steps to obtain it. diff --git a/desktop-app/out/main/index.js b/desktop-app/out/main/index.js index a2cbdc7..778539c 100644 --- a/desktop-app/out/main/index.js +++ b/desktop-app/out/main/index.js @@ -10314,3 +10314,21 @@ electron.ipcMain.handle("check:run", async (_event, trackInput) => { }; } }); +electron.ipcMain.handle("spotify:search", async (_event, query) => { + try { + const osmiumPath = path$1.join(__dirname$1, "../../.."); + const configUrl = url.pathToFileURL(path$1.join(osmiumPath, "dist/config/index.js")).href; + const spotifyUrl = url.pathToFileURL(path$1.join(osmiumPath, "dist/services/spotify.js")).href; + const { getConfig } = await import(configUrl); + const { getSpotifyToken, searchTracks } = await import(spotifyUrl); + const config = getConfig(); + const token = await getSpotifyToken(config.spotify.clientId, config.spotify.clientSecret); + const results = await searchTracks(query, token); + return { success: true, results }; + } catch (error2) { + return { + success: false, + error: error2 instanceof Error ? error2.message : String(error2) + }; + } +}); diff --git a/desktop-app/out/preload/index.js b/desktop-app/out/preload/index.js index 519be17..826d162 100644 --- a/desktop-app/out/preload/index.js +++ b/desktop-app/out/preload/index.js @@ -21,5 +21,8 @@ electron.contextBridge.exposeInMainWorld("osmium", { electron.ipcRenderer.on("check:progress", handler); return () => electron.ipcRenderer.removeListener("check:progress", handler); } + }, + spotify: { + search: (query) => electron.ipcRenderer.invoke("spotify:search", query) } }); diff --git a/desktop-app/package.json b/desktop-app/package.json index 63b77b0..78c198c 100644 --- a/desktop-app/package.json +++ b/desktop-app/package.json @@ -1,7 +1,7 @@ { "name": "osmium-desktop", "version": "1.0.0", - "description": "Osmium Desktop - AI-powered music copyright checker", + "description": "Osmium Desktop - music copyright checker By Renderdragon", "main": "./out/main/index.js", "author": "Osmium", "license": "MIT", diff --git a/desktop-app/src/main/index.ts b/desktop-app/src/main/index.ts index 9218e75..8524008 100644 --- a/desktop-app/src/main/index.ts +++ b/desktop-app/src/main/index.ts @@ -14,7 +14,7 @@ function getIcon(): nativeImage { join(__dirname, '../../../public/icon.png'), join(process.resourcesPath, 'public/icon.png') ] - + for (const iconPath of paths) { if (existsSync(iconPath)) { try { @@ -27,7 +27,7 @@ function getIcon(): nativeImage { } } } - + return nativeImage.createFromDataURL(OSMIUM_ICON) } @@ -63,7 +63,7 @@ let mainWindow: BrowserWindow | null = null async function createWindow() { const icon = getIcon() - + mainWindow = new BrowserWindow({ width: 1200, height: 800, @@ -127,27 +127,50 @@ ipcMain.handle('check:run', async (_event, trackInput: string) => { const osmiumPath = join(__dirname, '../../..') const runnerUrl = pathToFileURL(join(osmiumPath, 'dist/pipeline/runner.js')).href const configUrl = pathToFileURL(join(osmiumPath, 'dist/config/index.js')).href - + const { PipelineRunner } = await import(runnerUrl) const { getConfig } = await import(configUrl) - + const config = getConfig() const pipeline = new PipelineRunner(config) - + const sendProgress = (event: PipelineEvent) => { mainWindow?.webContents.send('check:progress', event) } - + pipeline.on('progress', sendProgress) - + const verdict = await pipeline.run(trackInput, { verbose: false }) const checks = store.get('checks') || [] store.set('checks', [verdict, ...checks].slice(0, 50)) return { success: true, verdict } } catch (error) { - return { - success: false, - error: error instanceof Error ? error.message : String(error) + return { + success: false, + error: error instanceof Error ? error.message : String(error) + } + } +}) + +ipcMain.handle('spotify:search', async (_event, query: string) => { + try { + const osmiumPath = join(__dirname, '../../..') + const configUrl = pathToFileURL(join(osmiumPath, 'dist/config/index.js')).href + const spotifyUrl = pathToFileURL(join(osmiumPath, 'dist/services/spotify.js')).href + + const { getConfig } = await import(configUrl) + const { getSpotifyToken, searchTracks } = await import(spotifyUrl) + + const config = getConfig() + const token = await getSpotifyToken(config.spotify.clientId, config.spotify.clientSecret) + const results = await searchTracks(query, token) + + return { success: true, results } + } catch (error) { + return { + success: false, + error: error instanceof Error ? error.message : String(error) } } }) + diff --git a/desktop-app/src/preload/index.ts b/desktop-app/src/preload/index.ts index 57e1262..8599015 100644 --- a/desktop-app/src/preload/index.ts +++ b/desktop-app/src/preload/index.ts @@ -21,5 +21,8 @@ contextBridge.exposeInMainWorld('osmium', { ipcRenderer.on('check:progress', handler) return () => ipcRenderer.removeListener('check:progress', handler) } + }, + spotify: { + search: (query: string) => ipcRenderer.invoke('spotify:search', query) } }) diff --git a/desktop-app/src/renderer/src/components/HomePage.tsx b/desktop-app/src/renderer/src/components/HomePage.tsx index 24cafee..356e8ce 100644 --- a/desktop-app/src/renderer/src/components/HomePage.tsx +++ b/desktop-app/src/renderer/src/components/HomePage.tsx @@ -1,4 +1,5 @@ import { useState } from 'react' +import type { SpotifySearchResult } from '../types' interface Props { onStartCheck: (input: string) => void @@ -6,46 +7,139 @@ interface Props { } export default function HomePage({ onStartCheck, isChecking }: Props) { + const [mode, setMode] = useState<'url' | 'search'>('url') const [input, setInput] = useState('') + const [searchQuery, setSearchQuery] = useState('') + const [isSearching, setIsSearching] = useState(false) + const [searchResults, setSearchResults] = useState([]) - const handleSubmit = (e: React.FormEvent) => { + const handleSubmitUrl = (e: React.FormEvent) => { e.preventDefault() if (input.trim() && !isChecking) { onStartCheck(input.trim()) } } + const handleSearch = async (e: React.FormEvent) => { + e.preventDefault() + if (!searchQuery.trim() || isSearching || isChecking) return + + setIsSearching(true) + try { + const response = await window.osmium.spotify.search(searchQuery.trim()) + if (response.success && response.results) { + setSearchResults(response.results) + } else { + console.error('Search failed:', response.error) + setSearchResults([]) + } + } catch (err) { + console.error(err) + setSearchResults([]) + } finally { + setIsSearching(false) + } + } + return (

◆ OSMIUM

-

AI-powered music copyright checker

+

music copyright checker By Renderdragon

- -
-
- setInput(e.target.value)} - placeholder="Paste Spotify track URL or ID..." - disabled={isChecking} - className="w-full bg-bg-tertiary border border-white/10 rounded px-4 py-3 text-white placeholder-white/30 focus:outline-none focus:border-osmium/50 transition-colors disabled:opacity-50" - /> - -
-
- -
-

Supports: Spotify track URLs, URIs, and IDs

-

Example: https://open.spotify.com/track/...

+ +
+ +
+ + {mode === 'url' ? ( +
+
+ setInput(e.target.value)} + placeholder="Paste Spotify track URL or ID..." + disabled={isChecking} + className="w-full bg-bg-tertiary border border-white/10 rounded px-4 py-3 text-white placeholder-white/30 focus:outline-none focus:border-osmium/50 transition-colors disabled:opacity-50" + /> + +
+
+

Supports: Spotify track URLs, URIs, and IDs

+

Example: https://open.spotify.com/track/...

+
+
+ ) : ( +
+
+
+ setSearchQuery(e.target.value)} + placeholder="Search by track name or artist..." + disabled={isChecking || isSearching} + className="w-full bg-bg-tertiary border border-white/10 rounded px-4 py-3 text-white placeholder-white/30 focus:outline-none focus:border-osmium/50 transition-colors disabled:opacity-50" + /> + +
+
+ +
+ {searchResults.length === 0 ? ( +
+ No results. Search for a track to begin. +
+ ) : ( +
    + {searchResults.map((track) => ( +
  • + +
    • + ))} +
+ )} +
+
+ )}
) } diff --git a/desktop-app/src/renderer/src/types-window.d.ts b/desktop-app/src/renderer/src/types-window.d.ts index 0a093f9..ac2f51e 100644 --- a/desktop-app/src/renderer/src/types-window.d.ts +++ b/desktop-app/src/renderer/src/types-window.d.ts @@ -1,4 +1,4 @@ -import type { PipelineEvent, CopyrightVerdict } from './types' +import type { PipelineEvent, CopyrightVerdict, SpotifySearchResult } from './types' declare global { interface Window { @@ -20,8 +20,11 @@ declare global { run: (trackInput: string) => Promise<{ success: boolean; verdict?: CopyrightVerdict; error?: string }> onProgress: (callback: (event: PipelineEvent) => void) => () => void } + spotify: { + search: (query: string) => Promise<{ success: boolean; results?: SpotifySearchResult[]; error?: string }> + } } } } -export {} +export { } diff --git a/desktop-app/src/renderer/src/types.ts b/desktop-app/src/renderer/src/types.ts index c3a78bd..08b9c94 100644 --- a/desktop-app/src/renderer/src/types.ts +++ b/desktop-app/src/renderer/src/types.ts @@ -60,3 +60,11 @@ export interface CheckSession { error?: string startedAt?: string } + +export interface SpotifySearchResult { + id: string + name: string + artists: string[] + album: string + duration_ms: number +} diff --git a/package-lock.json b/package-lock.json index 5510395..f0bbb1a 100644 --- a/package-lock.json +++ b/package-lock.json @@ -9,6 +9,7 @@ "version": "1.0.0", "license": "MIT", "dependencies": { + "@inquirer/prompts": "^8.3.0", "@openrouter/sdk": "^0.9.11", "@tavily/core": "^0.7.2", "chalk": "^5.4.1", @@ -23,34 +24,10 @@ }, "devDependencies": { "@types/node": "^22.13.0", - "concurrently": "^9.2.1", - "electron": "^40.8.0", "tsx": "^4.19.0", "typescript": "^5.7.0" } }, - "node_modules/@electron/get": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/@electron/get/-/get-2.0.3.tgz", - "integrity": "sha512-Qkzpg2s9GnVV2I2BjRksUi43U5e6+zaQMcjoJy0C+C5oxaKl+fmckGDQFtRpZpZV0NQekuZZ+tGz7EA9TVnQtQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "debug": "^4.1.1", - "env-paths": "^2.2.0", - "fs-extra": "^8.1.0", - "got": "^11.8.5", - "progress": "^2.0.3", - "semver": "^6.2.0", - "sumchecker": "^3.0.1" - }, - "engines": { - "node": ">=12" - }, - "optionalDependencies": { - "global-agent": "^3.0.0" - } - }, "node_modules/@esbuild/aix-ppc64": { "version": "0.27.3", "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz", @@ -493,112 +470,379 @@ "node": ">=18" } }, - "node_modules/@openrouter/sdk": { - "version": "0.9.11", - "resolved": "https://registry.npmjs.org/@openrouter/sdk/-/sdk-0.9.11.tgz", - "integrity": "sha512-BgFu6NcIJO4a9aVjr04y3kZ8pyM71j15I+bzfVAGEvxnj+KQNIkBYQGgwrG3D+aT1QpDKLki8btcQmpaxUas6A==", - "hasInstallScript": true, - "license": "Apache-2.0", + "node_modules/@inquirer/ansi": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/@inquirer/ansi/-/ansi-2.0.3.tgz", + "integrity": "sha512-g44zhR3NIKVs0zUesa4iMzExmZpLUdTLRMCStqX3GE5NT6VkPcxQGJ+uC8tDgBUC/vB1rUhUd55cOf++4NZcmw==", + "license": "MIT", + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + } + }, + "node_modules/@inquirer/checkbox": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@inquirer/checkbox/-/checkbox-5.1.0.tgz", + "integrity": "sha512-/HjF1LN0a1h4/OFsbGKHNDtWICFU/dqXCdym719HFTyJo9IG7Otr+ziGWc9S0iQuohRZllh+WprSgd5UW5Fw0g==", + "license": "MIT", "dependencies": { - "zod": "^3.25.0 || ^4.0.0" + "@inquirer/ansi": "^2.0.3", + "@inquirer/core": "^11.1.5", + "@inquirer/figures": "^2.0.3", + "@inquirer/type": "^4.0.3" + }, + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } } }, - "node_modules/@sindresorhus/is": { - "version": "4.6.0", - "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz", - "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==", - "dev": true, + "node_modules/@inquirer/confirm": { + "version": "6.0.8", + "resolved": "https://registry.npmjs.org/@inquirer/confirm/-/confirm-6.0.8.tgz", + "integrity": "sha512-Di6dgmiZ9xCSUxWUReWTqDtbhXCuG2MQm2xmgSAIruzQzBqNf49b8E07/vbCYY506kDe8BiwJbegXweG8M1klw==", "license": "MIT", + "dependencies": { + "@inquirer/core": "^11.1.5", + "@inquirer/type": "^4.0.3" + }, "engines": { - "node": ">=10" + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" }, - "funding": { - "url": "https://github.com/sindresorhus/is?sponsor=1" + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } } }, - "node_modules/@szmarczak/http-timer": { - "version": "4.0.6", - "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-4.0.6.tgz", - "integrity": "sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==", - "dev": true, + "node_modules/@inquirer/core": { + "version": "11.1.5", + "resolved": "https://registry.npmjs.org/@inquirer/core/-/core-11.1.5.tgz", + "integrity": "sha512-QQPAX+lka8GyLcZ7u7Nb1h6q72iZ/oy0blilC3IB2nSt1Qqxp7akt94Jqhi/DzARuN3Eo9QwJRvtl4tmVe4T5A==", + "license": "MIT", + "dependencies": { + "@inquirer/ansi": "^2.0.3", + "@inquirer/figures": "^2.0.3", + "@inquirer/type": "^4.0.3", + "cli-width": "^4.1.0", + "fast-wrap-ansi": "^0.2.0", + "mute-stream": "^3.0.0", + "signal-exit": "^4.1.0" + }, + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/editor": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/@inquirer/editor/-/editor-5.0.8.tgz", + "integrity": "sha512-sLcpbb9B3XqUEGrj1N66KwhDhEckzZ4nI/W6SvLXyBX8Wic3LDLENlWRvkOGpCPoserabe+MxQkpiMoI8irvyA==", "license": "MIT", "dependencies": { - "defer-to-connect": "^2.0.0" + "@inquirer/core": "^11.1.5", + "@inquirer/external-editor": "^2.0.3", + "@inquirer/type": "^4.0.3" }, "engines": { - "node": ">=10" + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } } }, - "node_modules/@tavily/core": { + "node_modules/@inquirer/expand": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/@inquirer/expand/-/expand-5.0.8.tgz", + "integrity": "sha512-QieW3F1prNw3j+hxO7/NKkG1pk3oz7pOB6+5Upwu3OIwADfPX0oZVppsqlL+Vl/uBHHDSOBY0BirLctLnXwGGg==", + "license": "MIT", + "dependencies": { + "@inquirer/core": "^11.1.5", + "@inquirer/type": "^4.0.3" + }, + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/external-editor": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/@inquirer/external-editor/-/external-editor-2.0.3.tgz", + "integrity": "sha512-LgyI7Agbda74/cL5MvA88iDpvdXI2KuMBCGRkbCl2Dg1vzHeOgs+s0SDcXV7b+WZJrv2+ERpWSM65Fpi9VfY3w==", + "license": "MIT", + "dependencies": { + "chardet": "^2.1.1", + "iconv-lite": "^0.7.2" + }, + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/external-editor/node_modules/iconv-lite": { "version": "0.7.2", - "resolved": "https://registry.npmjs.org/@tavily/core/-/core-0.7.2.tgz", - "integrity": "sha512-N9xfw9miPD1jyVKYTMWV1hQvWPNjATT9Hffr6tv7VMHzwOPOeBwfX/R25ZE2F7meTyq6xSeGxclWnLVH2xHqFA==", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz", + "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==", "license": "MIT", "dependencies": { - "axios": "^1.7.7", - "https-proxy-agent": "^7.0.6", - "js-tiktoken": "^1.0.14" + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, - "node_modules/@types/cacheable-request": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz", - "integrity": "sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==", - "dev": true, + "node_modules/@inquirer/figures": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-2.0.3.tgz", + "integrity": "sha512-y09iGt3JKoOCBQ3w4YrSJdokcD8ciSlMIWsD+auPu+OZpfxLuyz+gICAQ6GCBOmJJt4KEQGHuZSVff2jiNOy7g==", + "license": "MIT", + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + } + }, + "node_modules/@inquirer/input": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/@inquirer/input/-/input-5.0.8.tgz", + "integrity": "sha512-p0IJslw0AmedLEkOU+yrEX3Aj2RTpQq7ZOf8nc1DIhjzaxRWrrgeuE5Kyh39fVRgtcACaMXx/9WNo8+GjgBOfw==", "license": "MIT", "dependencies": { - "@types/http-cache-semantics": "*", - "@types/keyv": "^3.1.4", - "@types/node": "*", - "@types/responselike": "^1.0.0" + "@inquirer/core": "^11.1.5", + "@inquirer/type": "^4.0.3" + }, + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } } }, - "node_modules/@types/http-cache-semantics": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz", - "integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==", - "dev": true, - "license": "MIT" + "node_modules/@inquirer/number": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/@inquirer/number/-/number-4.0.8.tgz", + "integrity": "sha512-uGLiQah9A0F9UIvJBX52m0CnqtLaym0WpT9V4YZrjZ+YRDKZdwwoEPz06N6w8ChE2lrnsdyhY9sL+Y690Kh9gQ==", + "license": "MIT", + "dependencies": { + "@inquirer/core": "^11.1.5", + "@inquirer/type": "^4.0.3" + }, + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } }, - "node_modules/@types/keyv": { - "version": "3.1.4", - "resolved": "https://registry.npmjs.org/@types/keyv/-/keyv-3.1.4.tgz", - "integrity": "sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==", - "dev": true, + "node_modules/@inquirer/password": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/@inquirer/password/-/password-5.0.8.tgz", + "integrity": "sha512-zt1sF4lYLdvPqvmvHdmjOzuUUjuCQ897pdUCO8RbXMUDKXJTTyOQgtn23le+jwcb+MpHl3VAFvzIdxRAf6aPlA==", "license": "MIT", "dependencies": { - "@types/node": "*" + "@inquirer/ansi": "^2.0.3", + "@inquirer/core": "^11.1.5", + "@inquirer/type": "^4.0.3" + }, + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } } }, - "node_modules/@types/node": { - "version": "22.19.13", - "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.13.tgz", - "integrity": "sha512-akNQMv0wW5uyRpD2v2IEyRSZiR+BeGuoB6L310EgGObO44HSMNT8z1xzio28V8qOrgYaopIDNA18YgdXd+qTiw==", - "dev": true, + "node_modules/@inquirer/prompts": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/@inquirer/prompts/-/prompts-8.3.0.tgz", + "integrity": "sha512-JAj66kjdH/F1+B7LCigjARbwstt3SNUOSzMdjpsvwJmzunK88gJeXmcm95L9nw1KynvFVuY4SzXh/3Y0lvtgSg==", "license": "MIT", "dependencies": { - "undici-types": "~6.21.0" + "@inquirer/checkbox": "^5.1.0", + "@inquirer/confirm": "^6.0.8", + "@inquirer/editor": "^5.0.8", + "@inquirer/expand": "^5.0.8", + "@inquirer/input": "^5.0.8", + "@inquirer/number": "^4.0.8", + "@inquirer/password": "^5.0.8", + "@inquirer/rawlist": "^5.2.4", + "@inquirer/search": "^4.1.4", + "@inquirer/select": "^5.1.0" + }, + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } } }, - "node_modules/@types/responselike": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/@types/responselike/-/responselike-1.0.3.tgz", - "integrity": "sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==", - "dev": true, + "node_modules/@inquirer/rawlist": { + "version": "5.2.4", + "resolved": "https://registry.npmjs.org/@inquirer/rawlist/-/rawlist-5.2.4.tgz", + "integrity": "sha512-fTuJ5Cq9W286isLxwj6GGyfTjx1Zdk4qppVEPexFuA6yioCCXS4V1zfKroQqw7QdbDPN73xs2DiIAlo55+kBqg==", + "license": "MIT", + "dependencies": { + "@inquirer/core": "^11.1.5", + "@inquirer/type": "^4.0.3" + }, + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/search": { + "version": "4.1.4", + "resolved": "https://registry.npmjs.org/@inquirer/search/-/search-4.1.4.tgz", + "integrity": "sha512-9yPTxq7LPmYjrGn3DRuaPuPbmC6u3fiWcsE9ggfLcdgO/ICHYgxq7mEy1yJ39brVvgXhtOtvDVjDh9slJxE4LQ==", "license": "MIT", "dependencies": { - "@types/node": "*" + "@inquirer/core": "^11.1.5", + "@inquirer/figures": "^2.0.3", + "@inquirer/type": "^4.0.3" + }, + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } } }, - "node_modules/@types/yauzl": { - "version": "2.10.3", - "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz", - "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==", - "dev": true, + "node_modules/@inquirer/select": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@inquirer/select/-/select-5.1.0.tgz", + "integrity": "sha512-OyYbKnchS1u+zRe14LpYrN8S0wH1vD0p2yKISvSsJdH2TpI87fh4eZdWnpdbrGauCRWDph3NwxRmM4Pcm/hx1Q==", + "license": "MIT", + "dependencies": { + "@inquirer/ansi": "^2.0.3", + "@inquirer/core": "^11.1.5", + "@inquirer/figures": "^2.0.3", + "@inquirer/type": "^4.0.3" + }, + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/type": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/@inquirer/type/-/type-4.0.3.tgz", + "integrity": "sha512-cKZN7qcXOpj1h+1eTTcGDVLaBIHNMT1Rz9JqJP5MnEJ0JhgVWllx7H/tahUp5YEK1qaByH2Itb8wLG/iScD5kw==", + "license": "MIT", + "engines": { + "node": ">=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@openrouter/sdk": { + "version": "0.9.11", + "resolved": "https://registry.npmjs.org/@openrouter/sdk/-/sdk-0.9.11.tgz", + "integrity": "sha512-BgFu6NcIJO4a9aVjr04y3kZ8pyM71j15I+bzfVAGEvxnj+KQNIkBYQGgwrG3D+aT1QpDKLki8btcQmpaxUas6A==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "zod": "^3.25.0 || ^4.0.0" + } + }, + "node_modules/@tavily/core": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/@tavily/core/-/core-0.7.2.tgz", + "integrity": "sha512-N9xfw9miPD1jyVKYTMWV1hQvWPNjATT9Hffr6tv7VMHzwOPOeBwfX/R25ZE2F7meTyq6xSeGxclWnLVH2xHqFA==", + "license": "MIT", + "dependencies": { + "axios": "^1.7.7", + "https-proxy-agent": "^7.0.6", + "js-tiktoken": "^1.0.14" + } + }, + "node_modules/@types/node": { + "version": "22.19.13", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.13.tgz", + "integrity": "sha512-akNQMv0wW5uyRpD2v2IEyRSZiR+BeGuoB6L310EgGObO44HSMNT8z1xzio28V8qOrgYaopIDNA18YgdXd+qTiw==", + "devOptional": true, "license": "MIT", - "optional": true, "dependencies": { - "@types/node": "*" + "undici-types": "~6.21.0" } }, "node_modules/agent-base": { @@ -622,22 +866,6 @@ "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/asynckit": { "version": "0.4.0", "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", @@ -681,54 +909,6 @@ "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==", "license": "ISC" }, - "node_modules/boolean": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/boolean/-/boolean-3.2.0.tgz", - "integrity": "sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==", - "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.", - "dev": true, - "license": "MIT", - "optional": true - }, - "node_modules/buffer-crc32": { - "version": "0.2.13", - "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz", - "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==", - "dev": true, - "license": "MIT", - "engines": { - "node": "*" - } - }, - "node_modules/cacheable-lookup": { - "version": "5.0.4", - "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-5.0.4.tgz", - "integrity": "sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=10.6.0" - } - }, - "node_modules/cacheable-request": { - "version": "7.0.4", - "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-7.0.4.tgz", - "integrity": "sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==", - "dev": true, - "license": "MIT", - "dependencies": { - "clone-response": "^1.0.2", - "get-stream": "^5.1.0", - "http-cache-semantics": "^4.0.0", - "keyv": "^4.0.0", - "lowercase-keys": "^2.0.0", - "normalize-url": "^6.0.1", - "responselike": "^2.0.0" - }, - "engines": { - "node": ">=8" - } - }, "node_modules/call-bind-apply-helpers": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", @@ -754,8 +934,14 @@ "url": "https://github.com/chalk/chalk?sponsor=1" } }, - "node_modules/cheerio": { - "version": "1.2.0", + "node_modules/chardet": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/chardet/-/chardet-2.1.1.tgz", + "integrity": "sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==", + "license": "MIT" + }, + "node_modules/cheerio": { + "version": "1.2.0", "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.2.0.tgz", "integrity": "sha512-WDrybc/gKFpTYQutKIK6UvfcuxijIZfMfXaYm8NMsPQxSYvf+13fXUJ4rztGGbJcBQ/GF55gvrZ0Bc0bj/mqvg==", "license": "MIT", @@ -823,99 +1009,15 @@ "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, + "node_modules/cli-width": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-4.1.0.tgz", + "integrity": "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==", "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/clone-response": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.3.tgz", - "integrity": "sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==", - "dev": true, - "license": "MIT", - "dependencies": { - "mimic-response": "^1.0.0" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "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": ">= 12" } }, - "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/combined-stream": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", @@ -937,61 +1039,6 @@ "node": ">=18" } }, - "node_modules/concurrently": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/concurrently/-/concurrently-9.2.1.tgz", - "integrity": "sha512-fsfrO0MxV64Znoy8/l1vVIjjHa29SZyyqPgQBwhiDcaW8wJc2W3XWVOGx4M3oJBnv/zdUZIIp1gDeS98GzP8Ng==", - "dev": true, - "license": "MIT", - "dependencies": { - "chalk": "4.1.2", - "rxjs": "7.8.2", - "shell-quote": "1.8.3", - "supports-color": "8.1.1", - "tree-kill": "1.2.2", - "yargs": "17.7.2" - }, - "bin": { - "conc": "dist/bin/concurrently.js", - "concurrently": "dist/bin/concurrently.js" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/open-cli-tools/concurrently?sponsor=1" - } - }, - "node_modules/concurrently/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/concurrently/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/css-select": { "version": "5.2.2", "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.2.2.tgz", @@ -1037,83 +1084,6 @@ } } }, - "node_modules/decompress-response": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz", - "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "mimic-response": "^3.1.0" - }, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/decompress-response/node_modules/mimic-response": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz", - "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/defer-to-connect": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz", - "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=10" - } - }, - "node_modules/define-data-property": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz", - "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==", - "dev": true, - "license": "MIT", - "optional": true, - "dependencies": { - "es-define-property": "^1.0.0", - "es-errors": "^1.3.0", - "gopd": "^1.0.1" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/define-properties": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz", - "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==", - "dev": true, - "license": "MIT", - "optional": true, - "dependencies": { - "define-data-property": "^1.0.1", - "has-property-descriptors": "^1.0.0", - "object-keys": "^1.1.1" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, "node_modules/delayed-stream": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", @@ -1123,14 +1093,6 @@ "node": ">=0.4.0" } }, - "node_modules/detect-node": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz", - "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==", - "dev": true, - "license": "MIT", - "optional": true - }, "node_modules/dom-serializer": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", @@ -1212,42 +1174,6 @@ "node": ">= 0.4" } }, - "node_modules/electron": { - "version": "40.8.0", - "resolved": "https://registry.npmjs.org/electron/-/electron-40.8.0.tgz", - "integrity": "sha512-WoPq0Nr9Yx3g7T6VnJXdwa/rr2+VRyH3a+K+ezfMKBlf6WjxE/LmhMQabKbb6yjm9RbZhJBRcYyoLph421O2mQ==", - "dev": true, - "hasInstallScript": true, - "license": "MIT", - "dependencies": { - "@electron/get": "^2.0.0", - "@types/node": "^24.9.0", - "extract-zip": "^2.0.1" - }, - "bin": { - "electron": "cli.js" - }, - "engines": { - "node": ">= 12.20.55" - } - }, - "node_modules/electron/node_modules/@types/node": { - "version": "24.12.0", - "resolved": "https://registry.npmjs.org/@types/node/-/node-24.12.0.tgz", - "integrity": "sha512-GYDxsZi3ChgmckRT9HPU0WEhKLP08ev/Yfcq2AstjrDASOYCSXeyjDsHg4v5t4jOj7cyDX3vmprafKlWIG9MXQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "undici-types": "~7.16.0" - } - }, - "node_modules/electron/node_modules/undici-types": { - "version": "7.16.0", - "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz", - "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==", - "dev": true, - "license": "MIT" - }, "node_modules/emoji-regex": { "version": "10.6.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.6.0.tgz", @@ -1267,16 +1193,6 @@ "url": "https://github.com/fb55/encoding-sniffer?sponsor=1" } }, - "node_modules/end-of-stream": { - "version": "1.4.5", - "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz", - "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==", - "dev": true, - "license": "MIT", - "dependencies": { - "once": "^1.4.0" - } - }, "node_modules/entities": { "version": "4.5.0", "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", @@ -1289,16 +1205,6 @@ "url": "https://github.com/fb55/entities?sponsor=1" } }, - "node_modules/env-paths": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz", - "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=6" - } - }, "node_modules/es-define-property": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", @@ -1344,14 +1250,6 @@ "node": ">= 0.4" } }, - "node_modules/es6-error": { - "version": "4.1.1", - "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz", - "integrity": "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==", - "dev": true, - "license": "MIT", - "optional": true - }, "node_modules/esbuild": { "version": "0.27.3", "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz", @@ -1394,59 +1292,28 @@ "@esbuild/win32-x64": "0.27.3" } }, - "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/fast-string-truncated-width": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/fast-string-truncated-width/-/fast-string-truncated-width-3.0.3.tgz", + "integrity": "sha512-0jjjIEL6+0jag3l2XWWizO64/aZVtpiGE3t0Zgqxv0DPuxiMjvB3M24fCyhZUO4KomJQPj3LTSUnDP3GpdwC0g==", + "license": "MIT" }, - "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, + "node_modules/fast-string-width": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/fast-string-width/-/fast-string-width-3.0.2.tgz", + "integrity": "sha512-gX8LrtNEI5hq8DVUfRQMbr5lpaS4nMIWV+7XEbXk2b8kiQIizgnlr12B4dA3ZEx3308ze0O4Q1R+cHts8kyUJg==", "license": "MIT", - "optional": true, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/extract-zip": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz", - "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==", - "dev": true, - "license": "BSD-2-Clause", "dependencies": { - "debug": "^4.1.1", - "get-stream": "^5.1.0", - "yauzl": "^2.10.0" - }, - "bin": { - "extract-zip": "cli.js" - }, - "engines": { - "node": ">= 10.17.0" - }, - "optionalDependencies": { - "@types/yauzl": "^2.9.1" + "fast-string-truncated-width": "^3.0.2" } }, - "node_modules/fd-slicer": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz", - "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==", - "dev": true, + "node_modules/fast-wrap-ansi": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/fast-wrap-ansi/-/fast-wrap-ansi-0.2.0.tgz", + "integrity": "sha512-rLV8JHxTyhVmFYhBJuMujcrHqOT2cnO5Zxj37qROj23CP39GXubJRBUFF0z8KFK77Uc0SukZUf7JZhsVEQ6n8w==", "license": "MIT", "dependencies": { - "pend": "~1.2.0" + "fast-string-width": "^3.0.2" } }, "node_modules/follow-redirects": { @@ -1485,21 +1352,6 @@ "node": ">= 6" } }, - "node_modules/fs-extra": { - "version": "8.1.0", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz", - "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==", - "dev": true, - "license": "MIT", - "dependencies": { - "graceful-fs": "^4.2.0", - "jsonfile": "^4.0.0", - "universalify": "^0.1.0" - }, - "engines": { - "node": ">=6 <7 || >=8" - } - }, "node_modules/fsevents": { "version": "2.3.3", "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", @@ -1524,16 +1376,6 @@ "url": "https://github.com/sponsors/ljharb" } }, - "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/get-east-asian-width": { "version": "1.5.0", "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.5.0.tgz", @@ -1583,22 +1425,6 @@ "node": ">= 0.4" } }, - "node_modules/get-stream": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", - "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", - "dev": true, - "license": "MIT", - "dependencies": { - "pump": "^3.0.0" - }, - "engines": { - "node": ">=8" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/get-tsconfig": { "version": "4.13.6", "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.6.tgz", @@ -1612,50 +1438,11 @@ "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" } }, - "node_modules/global-agent": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/global-agent/-/global-agent-3.0.0.tgz", - "integrity": "sha512-PT6XReJ+D07JvGoxQMkT6qji/jVNfX/h364XHZOWeRzy64sSFr+xJ5OX7LI3b4MPQzdL4H8Y8M0xzPpsVMwA8Q==", - "dev": true, - "license": "BSD-3-Clause", - "optional": true, - "dependencies": { - "boolean": "^3.0.1", - "es6-error": "^4.1.1", - "matcher": "^3.0.0", - "roarr": "^2.15.3", - "semver": "^7.3.2", - "serialize-error": "^7.0.1" - }, - "engines": { - "node": ">=10.0" - } - }, - "node_modules/global-agent/node_modules/semver": { - "version": "7.7.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", - "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", - "dev": true, - "license": "ISC", - "optional": true, - "bin": { - "semver": "bin/semver.js" - }, - "engines": { - "node": ">=10" - } - }, - "node_modules/globalthis": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz", - "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==", - "dev": true, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", "license": "MIT", - "optional": true, - "dependencies": { - "define-properties": "^1.2.1", - "gopd": "^1.0.1" - }, "engines": { "node": ">= 0.4" }, @@ -1663,10 +1450,10 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/gopd": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", - "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", "license": "MIT", "engines": { "node": ">= 0.4" @@ -1675,88 +1462,19 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/got": { - "version": "11.8.6", - "resolved": "https://registry.npmjs.org/got/-/got-11.8.6.tgz", - "integrity": "sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==", - "dev": true, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", "license": "MIT", "dependencies": { - "@sindresorhus/is": "^4.0.0", - "@szmarczak/http-timer": "^4.0.5", - "@types/cacheable-request": "^6.0.1", - "@types/responselike": "^1.0.0", - "cacheable-lookup": "^5.0.3", - "cacheable-request": "^7.0.2", - "decompress-response": "^6.0.0", - "http2-wrapper": "^1.0.0-beta.5.2", - "lowercase-keys": "^2.0.0", - "p-cancelable": "^2.0.0", - "responselike": "^2.0.0" + "has-symbols": "^1.0.3" }, "engines": { - "node": ">=10.19.0" + "node": ">= 0.4" }, "funding": { - "url": "https://github.com/sindresorhus/got?sponsor=1" - } - }, - "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/has-property-descriptors": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", - "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==", - "dev": true, - "license": "MIT", - "optional": true, - "dependencies": { - "es-define-property": "^1.0.0" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/has-symbols": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", - "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", - "license": "MIT", - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/has-tostringtag": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", - "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", - "license": "MIT", - "dependencies": { - "has-symbols": "^1.0.3" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" + "url": "https://github.com/sponsors/ljharb" } }, "node_modules/hasown": { @@ -1802,27 +1520,6 @@ "url": "https://github.com/fb55/entities?sponsor=1" } }, - "node_modules/http-cache-semantics": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz", - "integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==", - "dev": true, - "license": "BSD-2-Clause" - }, - "node_modules/http2-wrapper": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-1.0.3.tgz", - "integrity": "sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==", - "dev": true, - "license": "MIT", - "dependencies": { - "quick-lru": "^5.1.1", - "resolve-alpn": "^1.0.0" - }, - "engines": { - "node": ">=10.19.0" - } - }, "node_modules/https-proxy-agent": { "version": "7.0.6", "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz", @@ -1848,16 +1545,6 @@ "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-interactive": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-2.0.0.tgz", @@ -1891,41 +1578,6 @@ "base64-js": "^1.5.1" } }, - "node_modules/json-buffer": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", - "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", - "dev": true, - "license": "MIT" - }, - "node_modules/json-stringify-safe": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", - "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==", - "dev": true, - "license": "ISC", - "optional": true - }, - "node_modules/jsonfile": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz", - "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==", - "dev": true, - "license": "MIT", - "optionalDependencies": { - "graceful-fs": "^4.1.6" - } - }, - "node_modules/keyv": { - "version": "4.5.4", - "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", - "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", - "dev": true, - "license": "MIT", - "dependencies": { - "json-buffer": "3.0.1" - } - }, "node_modules/log-symbols": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-6.0.0.tgz", @@ -1954,30 +1606,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/lowercase-keys": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz", - "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=8" - } - }, - "node_modules/matcher": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/matcher/-/matcher-3.0.0.tgz", - "integrity": "sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==", - "dev": true, - "license": "MIT", - "optional": true, - "dependencies": { - "escape-string-regexp": "^4.0.0" - }, - "engines": { - "node": ">=10" - } - }, "node_modules/math-intrinsics": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", @@ -2020,33 +1648,19 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/mimic-response": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz", - "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, "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==", "license": "MIT" }, - "node_modules/normalize-url": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz", - "integrity": "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==", - "dev": true, - "license": "MIT", + "node_modules/mute-stream": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-3.0.0.tgz", + "integrity": "sha512-dkEJPVvun4FryqBmZ5KhDo0K9iDXAwn08tMLDinNdRBNPcYEDiWYysLcc6k3mjTMlbP9KyylvRpd4wFtwrT9rw==", + "license": "ISC", "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" + "node": "^20.17.0 || >=22.9.0" } }, "node_modules/nth-check": { @@ -2061,27 +1675,6 @@ "url": "https://github.com/fb55/nth-check?sponsor=1" } }, - "node_modules/object-keys": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", - "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", - "dev": true, - "license": "MIT", - "optional": true, - "engines": { - "node": ">= 0.4" - } - }, - "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": "7.0.0", "resolved": "https://registry.npmjs.org/onetime/-/onetime-7.0.0.tgz", @@ -2141,16 +1734,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/p-cancelable": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-2.1.1.tgz", - "integrity": "sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=8" - } - }, "node_modules/parse5": { "version": "7.3.0", "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz", @@ -2200,70 +1783,12 @@ "url": "https://github.com/fb55/entities?sponsor=1" } }, - "node_modules/pend": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz", - "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==", - "dev": true, - "license": "MIT" - }, - "node_modules/progress": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz", - "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=0.4.0" - } - }, "node_modules/proxy-from-env": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==", "license": "MIT" }, - "node_modules/pump": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.4.tgz", - "integrity": "sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==", - "dev": true, - "license": "MIT", - "dependencies": { - "end-of-stream": "^1.1.0", - "once": "^1.3.1" - } - }, - "node_modules/quick-lru": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz", - "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "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/resolve-alpn": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz", - "integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==", - "dev": true, - "license": "MIT" - }, "node_modules/resolve-pkg-maps": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", @@ -2274,19 +1799,6 @@ "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" } }, - "node_modules/responselike": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/responselike/-/responselike-2.0.1.tgz", - "integrity": "sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==", - "dev": true, - "license": "MIT", - "dependencies": { - "lowercase-keys": "^2.0.0" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/restore-cursor": { "version": "5.1.0", "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-5.1.0.tgz", @@ -2303,89 +1815,12 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/roarr": { - "version": "2.15.4", - "resolved": "https://registry.npmjs.org/roarr/-/roarr-2.15.4.tgz", - "integrity": "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A==", - "dev": true, - "license": "BSD-3-Clause", - "optional": true, - "dependencies": { - "boolean": "^3.0.1", - "detect-node": "^2.0.4", - "globalthis": "^1.0.1", - "json-stringify-safe": "^5.0.1", - "semver-compare": "^1.0.0", - "sprintf-js": "^1.1.2" - }, - "engines": { - "node": ">=8.0" - } - }, - "node_modules/rxjs": { - "version": "7.8.2", - "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz", - "integrity": "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==", - "dev": true, - "license": "Apache-2.0", - "dependencies": { - "tslib": "^2.1.0" - } - }, "node_modules/safer-buffer": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", "license": "MIT" }, - "node_modules/semver": { - "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", - "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", - "dev": true, - "license": "ISC", - "bin": { - "semver": "bin/semver.js" - } - }, - "node_modules/semver-compare": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/semver-compare/-/semver-compare-1.0.0.tgz", - "integrity": "sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow==", - "dev": true, - "license": "MIT", - "optional": true - }, - "node_modules/serialize-error": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/serialize-error/-/serialize-error-7.0.1.tgz", - "integrity": "sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==", - "dev": true, - "license": "MIT", - "optional": true, - "dependencies": { - "type-fest": "^0.13.1" - }, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/shell-quote": { - "version": "1.8.3", - "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.3.tgz", - "integrity": "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, "node_modules/signal-exit": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", @@ -2398,14 +1833,6 @@ "url": "https://github.com/sponsors/isaacs" } }, - "node_modules/sprintf-js": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz", - "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==", - "dev": true, - "license": "BSD-3-Clause", - "optional": true - }, "node_modules/stdin-discarder": { "version": "0.2.2", "resolved": "https://registry.npmjs.org/stdin-discarder/-/stdin-discarder-0.2.2.tgz", @@ -2450,52 +1877,6 @@ "url": "https://github.com/chalk/strip-ansi?sponsor=1" } }, - "node_modules/sumchecker": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/sumchecker/-/sumchecker-3.0.1.tgz", - "integrity": "sha512-MvjXzkz/BOfyVDkG0oFOtBxHX2u3gKbMHIF/dXblZsgD3BWOFLmHovIpZY7BykJdAjcqRCBi1WYBNdEC9yI7vg==", - "dev": true, - "license": "Apache-2.0", - "dependencies": { - "debug": "^4.1.0" - }, - "engines": { - "node": ">= 8.0" - } - }, - "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/tree-kill": { - "version": "1.2.2", - "resolved": "https://registry.npmjs.org/tree-kill/-/tree-kill-1.2.2.tgz", - "integrity": "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==", - "dev": true, - "license": "MIT", - "bin": { - "tree-kill": "cli.js" - } - }, - "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/tsx": { "version": "4.21.0", "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz", @@ -2516,20 +1897,6 @@ "fsevents": "~2.3.3" } }, - "node_modules/type-fest": { - "version": "0.13.1", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.13.1.tgz", - "integrity": "sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==", - "dev": true, - "license": "(MIT OR CC0-1.0)", - "optional": true, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/typescript": { "version": "5.9.3", "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", @@ -2557,19 +1924,9 @@ "version": "6.21.0", "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", - "dev": true, + "devOptional": true, "license": "MIT" }, - "node_modules/universalify": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz", - "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 4.0.0" - } - }, "node_modules/whatwg-encoding": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz", @@ -2592,171 +1949,6 @@ "node": ">=18" } }, - "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/wrap-ansi/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/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/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/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/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/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/yauzl": { - "version": "2.10.0", - "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz", - "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==", - "dev": true, - "license": "MIT", - "dependencies": { - "buffer-crc32": "~0.2.3", - "fd-slicer": "~1.1.0" - } - }, "node_modules/zod": { "version": "4.3.6", "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz", diff --git a/package.json b/package.json index bfe0dc7..8b13966 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "name": "osmium-cli", "version": "1.0.0", - "description": "AI-powered music copyright checker CLI — resolves track ownership via Spotify, PRO registries, audio fingerprinting, and multi-agent reasoning", + "description": "music copyright checker By Renderdragon CLI — resolves track ownership via Spotify, PRO registries, audio fingerprinting, and multi-agent reasoning", "type": "module", "main": "dist/index.js", "bin": { @@ -23,6 +23,7 @@ ], "license": "MIT", "dependencies": { + "@inquirer/prompts": "^8.3.0", "@openrouter/sdk": "^0.9.11", "@tavily/core": "^0.7.2", "chalk": "^5.4.1", diff --git a/src/config/index.ts b/src/config/index.ts index b7a8d28..d6f8697 100644 --- a/src/config/index.ts +++ b/src/config/index.ts @@ -47,12 +47,12 @@ export function validateConfig(): AppConfig { tavily: { apiKey: process.env.TAVILY_API_KEY, }, - ...(process.env.MODAL_API_KEY + ...(process.env.GROQ_API_KEY ? { - modal: { - apiKey: process.env.MODAL_API_KEY, - model: process.env.MODAL_MODEL || "zai-org/GLM-5-FP8", - baseURL: "https://api.us-west-2.modal.direct/v1", + groq: { + apiKey: process.env.GROQ_API_KEY, + model: process.env.GROQ_MODEL || "qwen/qwen3-32b", + baseURL: "https://api.groq.com/openai/v1", }, } : {}), diff --git a/src/index.ts b/src/index.ts index 5a9e817..f44bf08 100644 --- a/src/index.ts +++ b/src/index.ts @@ -5,7 +5,7 @@ import chalk from "chalk"; import ora from "ora"; import { writeFile } from "node:fs/promises"; import { getConfig } from "./config/index.js"; -import { getSpotifyToken } from "./services/spotify.js"; +import { getSpotifyToken, searchTracks } from "./services/spotify.js"; import { getPlaylistTracksViaNoCodeAPI } from "./services/nocode-spotify.js"; import { PipelineRunner } from "./pipeline/runner.js"; import { Logger } from "./utils/logger.js"; @@ -27,93 +27,100 @@ program ) .version(VERSION); -program - .command("check") - .description("Check copyright ownership for a Spotify track") - .argument("", "Spotify track URL, URI, or ID") - .option("-o, --output ", "Write verdict JSON to file") - .option("-v, --verbose", "Enable verbose output with detailed progress", false) - .action(async (track: string, options: { output?: string; verbose?: boolean }) => { - const logger = new Logger(options.verbose); - - // Header - console.log(); - console.log( - chalk.bold(chalk.hex("#e8ff47")(" ◆ OSMIUM")) + - chalk.gray(" · Music Copyright Checker v" + VERSION) - ); - console.log(chalk.dim(" ─".repeat(25))); - console.log(); - - const spinner = ora({ - text: "Initializing pipeline...", - color: "yellow", - }).start(); +/** + * Shared check logic used by both `check` and `search` commands. + */ +async function runCheck(track: string, options: { output?: string; verbose?: boolean }) { + const logger = new Logger(options.verbose); - try { - const config = getConfig(); - const pipeline = new PipelineRunner(config); + // Header + console.log(); + console.log( + chalk.bold(chalk.hex("#e8ff47")(" ◆ OSMIUM")) + + chalk.gray(" · Music Copyright Checker v" + VERSION) + ); + console.log(chalk.dim(" ─".repeat(25))); + console.log(); - // Listen for progress events - pipeline.on("progress", (event: PipelineEvent) => { - if (event.status === "in_progress") { - spinner.text = `[${event.step}/9] ${event.message ?? event.name}`; - } else if (event.status === "completed") { - spinner.stop(); - logger.step(event.step, formatStepName(event.name), "completed"); - if (event.message) { - logger.debug(event.message); - } - spinner.start(`[${event.step + 1}/9] Processing...`); - } else if (event.status === "failed") { - spinner.stop(); - logger.step(event.step, formatStepName(event.name), "failed"); - if (event.error) { - logger.debug(`Error: ${event.error}`); - } - spinner.start(`[${event.step + 1}/9] Continuing...`); - } else if (event.status === "skipped") { - spinner.stop(); - logger.step(event.step, formatStepName(event.name), "skipped"); - if (event.message) { - logger.debug(event.message); - } - spinner.start(`[${event.step + 1}/9] Processing...`); + const spinner = ora({ + text: "Initializing pipeline...", + color: "yellow", + }).start(); + + try { + const config = getConfig(); + const pipeline = new PipelineRunner(config); + + // Listen for progress events + pipeline.on("progress", (event: PipelineEvent) => { + if (event.status === "in_progress") { + spinner.text = `[${event.step}/9] ${event.message ?? event.name}`; + } else if (event.status === "completed") { + spinner.stop(); + logger.step(event.step, formatStepName(event.name), "completed"); + if (event.message) { + logger.debug(event.message); } - }); + spinner.start(`[${event.step + 1}/9] Processing...`); + } else if (event.status === "failed") { + spinner.stop(); + logger.step(event.step, formatStepName(event.name), "failed"); + if (event.error) { + logger.debug(`Error: ${event.error}`); + } + spinner.start(`[${event.step + 1}/9] Continuing...`); + } else if (event.status === "skipped") { + spinner.stop(); + logger.step(event.step, formatStepName(event.name), "skipped"); + if (event.message) { + logger.debug(event.message); + } + spinner.start(`[${event.step + 1}/9] Processing...`); + } + }); - // Run the pipeline - const verdict = await pipeline.run(track, { - verbose: options.verbose ?? false, - outputFile: options.output, - }); + // Run the pipeline + const verdict = await pipeline.run(track, { + verbose: options.verbose ?? false, + outputFile: options.output, + }); - spinner.stop(); - console.log(); + spinner.stop(); + console.log(); - // Display verdict - displayVerdict(verdict, logger); + // Display verdict + displayVerdict(verdict, logger); - // Save to history - await saveToHistory(verdict); + // Save to history + await saveToHistory(verdict); - // Write to file if requested - if (options.output) { - await writeFile( - options.output, - JSON.stringify(verdict, null, 2), - "utf-8" - ); - console.log(); - logger.success(`Verdict written to ${chalk.bold(options.output)}`); - } - } catch (error) { - spinner.stop(); - logger.error( - error instanceof Error ? error.message : String(error) + // Write to file if requested + if (options.output) { + await writeFile( + options.output, + JSON.stringify(verdict, null, 2), + "utf-8" ); - process.exit(1); + console.log(); + logger.success(`Verdict written to ${chalk.bold(options.output)}`); } + } catch (error) { + spinner.stop(); + logger.error( + error instanceof Error ? error.message : String(error) + ); + process.exit(1); + } +} + +program + .command("check") + .description("Check copyright ownership for a Spotify track") + .argument("", "Spotify track URL, URI, or ID") + .option("-o, --output ", "Write verdict JSON to file") + .option("-v, --verbose", "Enable verbose output with detailed progress", false) + .action(async (track: string, options: { output?: string; verbose?: boolean }) => { + await runCheck(track, options); }); program @@ -268,7 +275,7 @@ function displayVerdict(verdict: CopyrightVerdict, logger: Logger): void { console.log(); const spotifyUrl = `https://open.spotify.com/track/${verdict.track.spotifyId}`; - + const rows: Array<[string, string, string]> = [ [ "Track", @@ -376,13 +383,13 @@ function displayVerdict(verdict: CopyrightVerdict, logger: Logger): void { console.log(` ${bannerText}`); console.log(); console.log(` ${chalk.white(summary.explanation)}`); - + if (summary.licensingUrl) { console.log(); console.log(chalk.gray(" Licensing URL:")); console.log(` ${chalk.cyan.underline(summary.licensingUrl)}`); } - + console.log(); console.log(chalk.gray(" Actionable Steps:")); for (const step of summary.actionableSteps) { @@ -508,4 +515,70 @@ program console.log(); }); +program + .command("search") + .description("Search for a track by name and interactively optionally check copyright") + .argument("[query]", "Search query (e.g., 'blinding lights the weeknd')") + .option("-o, --output ", "Write verdict JSON to file") + .option("-v, --verbose", "Enable verbose output with detailed progress", false) + .action(async (queryParam?: string, options?: { output?: string; verbose?: boolean }) => { + const logger = new Logger(options?.verbose); + + let query = queryParam; + if (!query) { + const inquirer = await import("@inquirer/prompts"); + query = await inquirer.input({ + message: "Enter search query:", + theme: { + prefix: chalk.hex("#e8ff47")("?"), + } + }); + } + + if (!query) { + logger.error("No search query provided."); + process.exit(1); + } + + const spinner = ora({ text: "Searching Spotify...", color: "yellow" }).start(); + + try { + const config = getConfig(); + const token = await getSpotifyToken(config.spotify.clientId, config.spotify.clientSecret); + const results = await searchTracks(query, token); + spinner.stop(); + + if (results.length === 0) { + logger.error("No tracks found matching your query."); + process.exit(1); + } + + const inquirer = await import("@inquirer/prompts"); + const selectedTrackId = await inquirer.select({ + message: "Select a track to check:", + choices: results.map((t) => ({ + name: `${t.name} — ${t.artists.join(", ")} (${t.album})`, + value: t.id, + })), + pageSize: 15, + theme: { + prefix: chalk.hex("#e8ff47")("?"), + style: { + highlight: (text: string) => chalk.hex("#e8ff47")(text), + } + } + }); + + const trackUrl = `https://open.spotify.com/track/${selectedTrackId}`; + await runCheck(trackUrl, { + output: options?.output, + verbose: options?.verbose ?? false, + }); + } catch (error) { + spinner.stop(); + logger.error(error instanceof Error ? error.message : String(error)); + process.exit(1); + } + }); + program.parse(); diff --git a/src/services/spotify.ts b/src/services/spotify.ts index f437e63..ae300fd 100644 --- a/src/services/spotify.ts +++ b/src/services/spotify.ts @@ -172,3 +172,36 @@ export async function getPlaylistTracks( tracks, }; } + +export interface SpotifySearchResult { + id: string; + name: string; + artists: string[]; + album: string; + duration_ms: number; +} + +/** + * Search for tracks on Spotify. + */ +export async function searchTracks( + query: string, + token: string, + limit: number = 20 +): Promise { + const response = await fetchJSON<{ + tracks: { + items: SpotifyTrack[]; + }; + }>(`${SPOTIFY_API_BASE}/search?q=${encodeURIComponent(query)}&type=track`, { + headers: { Authorization: `Bearer ${token}` }, + }); + + return response.tracks.items.map((track) => ({ + id: track.id, + name: track.name, + artists: track.artists.map((a) => a.name), + album: track.album.name, + duration_ms: track.duration_ms, + })); +} diff --git a/src/types/index.ts b/src/types/index.ts index e52c8e7..13ad4a5 100644 --- a/src/types/index.ts +++ b/src/types/index.ts @@ -299,7 +299,7 @@ export interface AppConfig { baseURL: string; defaultHeaders: Record; }; - modal?: { + groq?: { apiKey: string; model: string; baseURL: string; diff --git a/src/utils/ai-client.ts b/src/utils/ai-client.ts index 29a7a36..8221b76 100644 --- a/src/utils/ai-client.ts +++ b/src/utils/ai-client.ts @@ -66,16 +66,16 @@ export async function chatCompletion( if (isRateLimitError(error)) { console.warn("OpenRouter rate limited:", error instanceof Error ? error.message : String(error)); - if (config.modal) { - console.warn("Falling back to Modal..."); + if (config.groq) { + console.warn("Falling back to Groq..."); try { - const modalClient = new OpenAI({ - baseURL: config.modal.baseURL, - apiKey: config.modal.apiKey, + const groqClient = new OpenAI({ + baseURL: config.groq.baseURL, + apiKey: config.groq.apiKey, }); - const result = await modalClient.chat.completions.create({ - model: config.modal.model, + const result = await groqClient.chat.completions.create({ + model: config.groq.model, messages, max_tokens: options.maxTokens, temperature: options.temperature, @@ -83,12 +83,12 @@ export async function chatCompletion( const content = result.choices?.[0]?.message?.content; if (!content) { - throw new Error("No response content from Modal"); + throw new Error("No response content from Groq"); } return content; - } catch (modalError) { - console.error("Modal fallback also failed:", modalError instanceof Error ? modalError.message : String(modalError)); - throw modalError; + } catch (groqError) { + console.error("Groq fallback also failed:", groqError instanceof Error ? groqError.message : String(groqError)); + throw groqError; } } } diff --git a/tmp/test2.ts b/tmp/test2.ts index 59b7fe1..42e83d7 100644 --- a/tmp/test2.ts +++ b/tmp/test2.ts @@ -1,34 +1,23 @@ -import { getConfig } from "../src/config/index.js"; import { getSpotifyToken } from "../src/services/spotify.js"; import { fetchJSON } from "../src/utils/http.js"; +import { getConfig } from "../src/config/index.js"; -async function main() { - process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0"; +async function run() { + console.log("Starting..."); const config = getConfig(); const token = await getSpotifyToken(config.spotify.clientId, config.spotify.clientSecret); + console.log("Token:", token.substring(0, 5) + "..."); - const playlistId = "4bwSNOlsRr0HURnVCvX8SK"; - const SPOTIFY_API_BASE = "https://api.spotify.com/v1"; - - console.log("1. Just playlist URL NO PARAMS"); - const p1 = await fetchJSON( - `${SPOTIFY_API_BASE}/playlists/${playlistId}`, - { headers: { Authorization: `Bearer ${token}` } } - ); - console.log("keys 1:", Object.keys(p1)); - if (p1.tracks) { - console.log("p1.tracks.total:", p1.tracks.total); - console.log("p1.tracks keys:", Object.keys(p1.tracks)); - } else { - console.log("no tracks object returned at all!"); + const url = `https://api.spotify.com/v1/search?q=blinding%20lights&type=track&limit=20`; + console.log("Fetching:", url); + try { + const response = await fetchJSON(url, { + headers: { Authorization: `Bearer ${token}` } + }); + console.log("Success:", !!response); + } catch (err) { + console.error(err); } - - console.log("3. Tracks url"); - const p3 = await fetchJSON( - `${SPOTIFY_API_BASE}/playlists/${playlistId}/tracks?limit=50&offset=0`, - { headers: { Authorization: `Bearer ${token}` } } - ); - console.log("keys 3:", Object.keys(p3)); } -main().catch(console.error); +run(); diff --git a/tmp/test_search.ts b/tmp/test_search.ts new file mode 100644 index 0000000..840f666 --- /dev/null +++ b/tmp/test_search.ts @@ -0,0 +1,16 @@ +import { getSpotifyToken, searchTracks } from "../src/services/spotify.js"; +import { getConfig } from "../src/config/index.js"; + +async function run() { + const config = getConfig(); + const token = await getSpotifyToken(config.spotify.clientId, config.spotify.clientSecret); + console.log("Token acquired."); + try { + const results = await searchTracks("blinding lights", token, 20); + console.log("Results 20:", results.length); + } catch (err) { + console.error("Error with limit 20:", err); + } +} + +run(); From d28be17ad4eef0d6490a297804805ea02d7a8113 Mon Sep 17 00:00:00 2001 From: Coder-soft Date: Sat, 7 Mar 2026 21:29:06 +0500 Subject: [PATCH 3/8] feat: add GitHub Actions release workflow and desktop env embedding - Add release.yml workflow for CLI tarball + Desktop (Win/Mac/Linux) builds - Inject env vars at compile time via electron-vite define - Bundle CLI dist as extraResources for packaged desktop app - Update .gitignore for build artifacts --- .github/workflows/release.yml | 106 ++++++++++++++++++++++++++++ .gitignore | 9 ++- desktop-app/electron.vite.config.ts | 13 ++++ desktop-app/package.json | 10 ++- desktop-app/src/main/index.ts | 68 +++++++++++++++--- 5 files changed, 195 insertions(+), 11 deletions(-) create mode 100644 .github/workflows/release.yml diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..6206c49 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,106 @@ +name: Release + +on: + push: + tags: + - 'v*' + +permissions: + contents: write + +env: + NODE_VERSION: '20' + +jobs: + # ─── CLI Release ─────────────────────────────────────── + release-cli: + name: Release CLI + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-node@v4 + with: + node-version: ${{ env.NODE_VERSION }} + + - name: Install dependencies + run: npm ci + + - name: Build CLI + run: npm run build + + - name: Package tarball + run: npm pack + + - name: Create GitHub Release + uses: softprops/action-gh-release@v2 + with: + files: '*.tgz' + generate_release_notes: true + + # ─── Desktop Release ─────────────────────────────────── + release-desktop: + name: Desktop (${{ matrix.os }}) + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - os: windows-latest + build-flag: --win + - os: macos-latest + build-flag: --mac + - os: ubuntu-latest + build-flag: --linux + + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-node@v4 + with: + node-version: ${{ env.NODE_VERSION }} + + # 1. Build CLI first (desktop app bundles it via extraResources) + - name: Install CLI dependencies + run: npm ci + + - name: Build CLI + run: npm run build + + # 2. Build Desktop app + - name: Install Desktop dependencies + working-directory: desktop-app + run: npm ci + + - name: Build Desktop (electron-vite) + working-directory: desktop-app + env: + SPOTIFY_CLIENT_ID: ${{ secrets.SPOTIFY_CLIENT_ID }} + SPOTIFY_CLIENT_SECRET: ${{ secrets.SPOTIFY_CLIENT_SECRET }} + OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }} + OPENROUTER_MODEL: ${{ secrets.OPENROUTER_MODEL }} + NOCODE_SPOTIFY_CLOUD_NAME: ${{ secrets.NOCODE_SPOTIFY_CLOUD_NAME }} + NOCODE_SPOTIFY_TOKEN: ${{ secrets.NOCODE_SPOTIFY_TOKEN }} + TAVILY_API_KEY: ${{ secrets.TAVILY_API_KEY }} + ACOUSTID_API_KEY: ${{ secrets.ACOUSTID_API_KEY }} + DISCOGS_TOKEN: ${{ secrets.DISCOGS_TOKEN }} + GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }} + GROQ_MODEL: ${{ secrets.GROQ_MODEL }} + run: npm run build + + # 3. Package with electron-builder + - name: Package Desktop + working-directory: desktop-app + run: npx electron-builder ${{ matrix.build-flag }} --publish never + + # 4. Upload installers to the release + - name: Upload to GitHub Release + uses: softprops/action-gh-release@v2 + with: + files: | + desktop-app/dist/*.exe + desktop-app/dist/*.dmg + desktop-app/dist/*.AppImage + desktop-app/dist/*.deb + desktop-app/dist/*.zip + desktop-app/dist/*.tar.gz diff --git a/.gitignore b/.gitignore index 3b9b7fa..bbbf929 100644 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,11 @@ node_modules/ dist/ .env *.tgz -plans/ \ No newline at end of file +plans/ +out/ +desktop-app/node_modules/ +desktop-app/dist/ +desktop-app/out/ +desktop-app/.env +results.json +tmp/ \ No newline at end of file diff --git a/desktop-app/electron.vite.config.ts b/desktop-app/electron.vite.config.ts index eab3d61..23cded8 100644 --- a/desktop-app/electron.vite.config.ts +++ b/desktop-app/electron.vite.config.ts @@ -10,6 +10,19 @@ export default defineConfig({ index: resolve(__dirname, 'src/main/index.ts') } } + }, + define: { + '__ENV_SPOTIFY_CLIENT_ID__': JSON.stringify(process.env.SPOTIFY_CLIENT_ID || ''), + '__ENV_SPOTIFY_CLIENT_SECRET__': JSON.stringify(process.env.SPOTIFY_CLIENT_SECRET || ''), + '__ENV_OPENROUTER_API_KEY__': JSON.stringify(process.env.OPENROUTER_API_KEY || ''), + '__ENV_OPENROUTER_MODEL__': JSON.stringify(process.env.OPENROUTER_MODEL || ''), + '__ENV_NOCODE_SPOTIFY_CLOUD_NAME__': JSON.stringify(process.env.NOCODE_SPOTIFY_CLOUD_NAME || ''), + '__ENV_NOCODE_SPOTIFY_TOKEN__': JSON.stringify(process.env.NOCODE_SPOTIFY_TOKEN || ''), + '__ENV_TAVILY_API_KEY__': JSON.stringify(process.env.TAVILY_API_KEY || ''), + '__ENV_ACOUSTID_API_KEY__': JSON.stringify(process.env.ACOUSTID_API_KEY || ''), + '__ENV_DISCOGS_TOKEN__': JSON.stringify(process.env.DISCOGS_TOKEN || ''), + '__ENV_GROQ_API_KEY__': JSON.stringify(process.env.GROQ_API_KEY || ''), + '__ENV_GROQ_MODEL__': JSON.stringify(process.env.GROQ_MODEL || ''), } }, preload: { diff --git a/desktop-app/package.json b/desktop-app/package.json index 78c198c..128afb0 100644 --- a/desktop-app/package.json +++ b/desktop-app/package.json @@ -29,6 +29,14 @@ { "from": "public", "to": "public" + }, + { + "from": "../dist", + "to": "cli-dist/dist" + }, + { + "from": "../node_modules", + "to": "cli-dist/node_modules" } ], "win": { @@ -75,4 +83,4 @@ "typescript": "^5.7.0", "vite": "^5.4.0" } -} +} \ No newline at end of file diff --git a/desktop-app/src/main/index.ts b/desktop-app/src/main/index.ts index 8524008..db0e672 100644 --- a/desktop-app/src/main/index.ts +++ b/desktop-app/src/main/index.ts @@ -6,9 +6,60 @@ import { existsSync } from 'fs' const __dirname = dirname(fileURLToPath(import.meta.url)) -const OSMIUM_ICON = 'data:image/png;base64,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' +/* ────────────────────────────────────────────── + * Compile-time env injection (populated by electron-vite define) + * In dev mode these will be empty strings and dotenv handles it. + * In packaged builds these contain the real values from CI secrets. + * ────────────────────────────────────────────── */ +declare const __ENV_SPOTIFY_CLIENT_ID__: string +declare const __ENV_SPOTIFY_CLIENT_SECRET__: string +declare const __ENV_OPENROUTER_API_KEY__: string +declare const __ENV_OPENROUTER_MODEL__: string +declare const __ENV_NOCODE_SPOTIFY_CLOUD_NAME__: string +declare const __ENV_NOCODE_SPOTIFY_TOKEN__: string +declare const __ENV_TAVILY_API_KEY__: string +declare const __ENV_ACOUSTID_API_KEY__: string +declare const __ENV_DISCOGS_TOKEN__: string +declare const __ENV_GROQ_API_KEY__: string +declare const __ENV_GROQ_MODEL__: string + +function injectEnv() { + const vars: Record = { + SPOTIFY_CLIENT_ID: __ENV_SPOTIFY_CLIENT_ID__, + SPOTIFY_CLIENT_SECRET: __ENV_SPOTIFY_CLIENT_SECRET__, + OPENROUTER_API_KEY: __ENV_OPENROUTER_API_KEY__, + OPENROUTER_MODEL: __ENV_OPENROUTER_MODEL__, + NOCODE_SPOTIFY_CLOUD_NAME: __ENV_NOCODE_SPOTIFY_CLOUD_NAME__, + NOCODE_SPOTIFY_TOKEN: __ENV_NOCODE_SPOTIFY_TOKEN__, + TAVILY_API_KEY: __ENV_TAVILY_API_KEY__, + ACOUSTID_API_KEY: __ENV_ACOUSTID_API_KEY__, + DISCOGS_TOKEN: __ENV_DISCOGS_TOKEN__, + GROQ_API_KEY: __ENV_GROQ_API_KEY__, + GROQ_MODEL: __ENV_GROQ_MODEL__, + } + for (const [key, value] of Object.entries(vars)) { + if (value && !process.env[key]) { + process.env[key] = value + } + } +} + +injectEnv() -function getIcon(): nativeImage { +/* ────────────────────────────────────────────── + * Path resolution: in dev mode resolve CLI from parent dir, + * in packaged mode resolve from extraResources/cli-dist + * ────────────────────────────────────────────── */ +function getCliDistPath(): string { + if (app.isPackaged) { + return join(process.resourcesPath, 'cli-dist') + } + return join(__dirname, '../../..') +} + +const OSMIUM_ICON = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAACXBIWXMAAAsTAAALEwEAmpwYAAAGRmlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4gPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNS42LWMxNDUgNzkuMTYzNDk5LCAyMDE4LzA4LzEzLTE2OjQwOjIyICAgICAgICAiPiA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPiA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIi8+IDwvcmRmOlJERj4gPC94OnhtcG1ldGE+IDw/eHBhY2tldCBlbmQ9InIiPz4JxfPsAAAEbElEQVR4nO3dW5LiMAyF4T6B/f8v3Cw7K6tAqGBmY1Zm/v9nZjOq0jq8WrQEAKB+XT9fX0BAAB6uLwCwAAHYvQBgBQSwewXAClx4mgBwEof/TcD4+vp6+QKAEQj8fkl4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4e3t7+AKAMQjs10h4d3T2Pf7R9ggLoAIBWEPz/QMzQDwCQ1rTn/QH4DfMPAKTofP4NwG+YfwAghUnPAb4Hwm8AOIPT/wHAN7h+HwDfwOk/APAu3r8A4AOu+AsA7+H9CwDu4/0LAH7C+x8A8BPu/wDAn7j/AwB/4/4PAPyF+z8A8Bc+fADAT8x/BwD+gvu/AOAvHP8CAPyE8z8A8CNu/wDAj7j/AwA/4f4PAPyE+38AwE+4/wMAf+P/DwD8hPt/AMBP+P8DAP8B3t0+4E5ZiLsAAAAASUVORK5CYII=' + +function getIcon(): Electron.NativeImage { const paths = [ join(__dirname, '../../public/icon.png'), join(__dirname, '../../../public/icon.png'), @@ -124,9 +175,9 @@ ipcMain.handle('store:get-path', () => store.path) ipcMain.handle('check:run', async (_event, trackInput: string) => { try { - const osmiumPath = join(__dirname, '../../..') - const runnerUrl = pathToFileURL(join(osmiumPath, 'dist/pipeline/runner.js')).href - const configUrl = pathToFileURL(join(osmiumPath, 'dist/config/index.js')).href + const cliDist = getCliDistPath() + const runnerUrl = pathToFileURL(join(cliDist, 'dist/pipeline/runner.js')).href + const configUrl = pathToFileURL(join(cliDist, 'dist/config/index.js')).href const { PipelineRunner } = await import(runnerUrl) const { getConfig } = await import(configUrl) @@ -154,9 +205,9 @@ ipcMain.handle('check:run', async (_event, trackInput: string) => { ipcMain.handle('spotify:search', async (_event, query: string) => { try { - const osmiumPath = join(__dirname, '../../..') - const configUrl = pathToFileURL(join(osmiumPath, 'dist/config/index.js')).href - const spotifyUrl = pathToFileURL(join(osmiumPath, 'dist/services/spotify.js')).href + const cliDist = getCliDistPath() + const configUrl = pathToFileURL(join(cliDist, 'dist/config/index.js')).href + const spotifyUrl = pathToFileURL(join(cliDist, 'dist/services/spotify.js')).href const { getConfig } = await import(configUrl) const { getSpotifyToken, searchTracks } = await import(spotifyUrl) @@ -173,4 +224,3 @@ ipcMain.handle('spotify:search', async (_event, query: string) => { } } }) - From 7c3a17f34478c9662f77405fc4d250737dfd0bc2 Mon Sep 17 00:00:00 2001 From: Coder-soft Date: Sat, 7 Mar 2026 21:43:42 +0500 Subject: [PATCH 4/8] fix: add email to author in desktop package.json for building linux apps --- desktop-app/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/desktop-app/package.json b/desktop-app/package.json index 128afb0..369ada3 100644 --- a/desktop-app/package.json +++ b/desktop-app/package.json @@ -3,7 +3,7 @@ "version": "1.0.0", "description": "Osmium Desktop - music copyright checker By Renderdragon", "main": "./out/main/index.js", - "author": "Osmium", + "author": "Osmium ", "license": "MIT", "appId": "com.osmium.desktop", "scripts": { From d60276e20e4ae1f307f79e62e885cd774ec6b7a9 Mon Sep 17 00:00:00 2001 From: Coder-soft Date: Sat, 7 Mar 2026 22:08:59 +0500 Subject: [PATCH 5/8] fix: generate 1024x1024 icon for mac build --- desktop-app/package.json | 8 ++++---- desktop-app/public/icon_mac.png | Bin 0 -> 114102 bytes 2 files changed, 4 insertions(+), 4 deletions(-) create mode 100644 desktop-app/public/icon_mac.png diff --git a/desktop-app/package.json b/desktop-app/package.json index 369ada3..114d8a8 100644 --- a/desktop-app/package.json +++ b/desktop-app/package.json @@ -3,7 +3,7 @@ "version": "1.0.0", "description": "Osmium Desktop - music copyright checker By Renderdragon", "main": "./out/main/index.js", - "author": "Osmium ", + "author": "contact@renderdragon.org", "license": "MIT", "appId": "com.osmium.desktop", "scripts": { @@ -40,20 +40,20 @@ } ], "win": { - "icon": "public/icon.png", + "icon": "public/icon1.png", "target": [ "nsis", "portable" ] }, "mac": { - "icon": "public/icon.png", + "icon": "public/icon_mac.png", "target": [ "dmg" ] }, "linux": { - "icon": "public/icon.png", + "icon": "public/icon1.png", "target": [ "AppImage", "deb" diff --git a/desktop-app/public/icon_mac.png b/desktop-app/public/icon_mac.png new file mode 100644 index 0000000000000000000000000000000000000000..d3b662c108b2f97448c0fdbb4e248b6ed600add4 GIT binary patch literal 114102 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 CL@?c61)NJjdN%1^7<%-! zHCPhfpn!5-v=@P}0)oY$O@ZBP&3&gO^XU=x%~9kl*cu%B8%&74@Db&gN0K4 zA(qD{`^~3HY{|_nLHtX_h4`#F{X>%S9|p(+#+ty?w8@Osdz(7(1S~!OG99y77pS+Qe)jC~6anmoLNAv?$JS@f2E~M#^I?I}g`_+GMFQz6ikMub+Hk?UBzB;I+L2@??`| znV>cWq*%%mpUicB2JinqSxWD+9c4W|{e_7Sso&g>51Ta|5J{2#!zgoFzPNMueaNxSE2z%sm;Rx#oGNvr0pgwIa7ihy>! z#}hi7DrkvkNAWMzZ~%J|ndF_JEiq5r9LAWOqrilU-UaLB)U+3$(cnv|Jyg-8Gv>Y!Q48 zewTOm9&umyH|8|+K9r~MA@p`HOBLgM*|cfp9{WxLd(UwY{sCH#QyaMyl|p^x&Agdm z63n6cOt@ly55)TsBw=@rH5Mx5psAX;!H$sLI>RK5wW);?XJrV~mt!Fo+n>xJ-{f7i zInQgI!!z=6xWak3Uh{K_A&2m97&X9RXemu_8(r-;NiD>fKHbKh#vrj@8&}jgIpjNqe znK#r)Tzrgi!HgZWDiXNrhfgm}AmWFH!C@1p9vUTsa^Cp~?H}hMs0IW%mqMg{c5gdC zq6FJ_+>y_b8IeNc?nnPF>x2o@|CJ!0br6}vsk4~Cm z%3ru`a{%w+O#;l5gnd+T9sxj%g8N-`9qJe4HE_&Qd9u-XdAj4|o_6 zqKac6JtnwpeZXb=?7v_U46!;`p@2l4X<%z591M9ewn=h%)j+rv2MN)m^5s1j;4pc zV?5~a4q!`!y^%k@^=Mkhl(ROoGQ0w?s6QUJgCuTia~izf9okI_n3v>%;{StG;$a%l!%BlUlj6oOU2<%mRUN&RqfDjkZg}@Xn2?Fq5UgXi2 z{8a-wa-Tp*PdK*kc`UXYfD!^V9|7BLZx#zwz(OBxYWb(x3IP628g%1}y+e{f8yfXE z;v=8Nj(Xn~$9;;MhgUg8pFeoFE|erBVpJ#D6L=qtjiqtJc)vNDrqSrdz6Y)rqLnMi ziKzG3=`*Bd_VHAvI!fQ@P+Bmjm6q1SBAT-Y=x+@N?a!?a(DS0gjq=AsxLTYtp5iE) zv7__hSIkkMllq9+xS++>!}o0f1q{qLn&N*2%^9fiZUiWOl;_NV-Xa%ePUq|VKbeKe z=;Hp2+F~2s3c+@;`~ojipN3mu2Z7d)b8_S7>2CDV1ROC>yXT`_QT3aBAcvPYf`I7u zWPjZ%AcWh~Nido=mQ2A+hxFukj*Rc+D5Y>NY#;Qs10E3x^20TGkGg^9Jo7p=79Wc`-^_dL3r^EG?b z{If3SY0i(b>eioAkc{qO*eU!EMfqOvL^N4Aby;dX>kzi9N+cHC_JK{v3;JE@A(bTh zUQIgE#|GCktVRJqpaqV`x|1d|)+nlgM1uN>1ekkJ)kTQA1s(r|bAdFN`kxaqM>ysR z3VrZBJFaLK%WsREHgCsBo6p|{-mhOFR(QR5W?vcN@$SXS{YZHK=2zjdP0ybZG*-Og(FS)+K? zK7c8M0zE9sytwK1{sDoFv<9-4>!JKqLs-Rakdr7)kA8645J}ehEz(l)Cga>Lr|Z>! z>fQIv@N2AId$_$laZAyY0lUR5w;q2^UB!fZ7QRchOZ`V~5B?*@`?KJ~o$&InUTgZz zyWlg$`x{zymeaHrw$Y`l+83sRcaClT`n$e@o~QePHl`~PEuneTL0P*v#94S|AlOs& zj^k(bDGmpO##`tYv-V@bG&$G^9WL55_>U5@at3JO3@orIsA{1aa9ex{O0(mGMrKHb zQh}>QxV2P_BVdm(VMa_{5cwiC1_c17&$wO{u;ko8KZDKyGm6Z&WhWIL@~RZY#V&d) zx}7H8`)z?f>dIm&59kh(>&T`H!7C|~;VI#&%OMjwJMKaFjzJMpi3=uD01R8QwYH}6 zTNlz04y1IPTCyVN#o6Oq~eQns&9!>q3a^;DPKwwMhs9q1k;{!^FL5)xg@3I^X`WOnejyr;+LJYh00s z?q_T8pLCEa!%{%nH=h+34X1nnCDNS zsAn}~>-LK&>gJar20<(P;1&423(D}o35J&>T(4@hsUibQ=}L?OaFQis{OkBjG0ZF) z+p)66*u5#W6g5`=h54S~cW@Ls>nD-lTv@!S*TvdlLL@TsQ|Xm!O$B(2D@j|l;_4Q58&YlTJc z3s|QuvhOMsr9NEz`SOcB$#1#Rt^A@qizvLsTDbq~p$%@IGxi; zB#U+8l)yxd-F1F&YqIPRgQBNK6MWaXr^tz|Z;jPTj`ebsc>5M(((U zc={n+R+RC|$bkH#;R}U2^j5OnJUVL7K8kmO!5|lKF0=*5Fh=ukB3tunUy>>;UZ(!L zmz2nP*{PdBNbxrk?+P<6OQF?GzI!bUyl8*DJpuTDP<~j$pFf|idTc?bI>nz26fXYu z=N7Hr3ykvas{D$9R>`-z2`P4|{J#8_Ve$^~QQE4NR6)|J<}>04ssDOW(ZGMe3ep$@ z^T%z-J3yKn2fT7`H26+LaKjps{DinQe?EuDy-)Df%6aM4Q%zc6^2w*)D~B<{%Jd`I{pFVe)@bsEai2YQsxyutcfk6Tx%AoGgq%b&*JRZLK_IPG=G-@RrL7J zj8+9R_HvE;c2;(=Y?UR*Xd^`K^3ISnF|y}_5(WluZ+R|aYF8PlV-atK%C5FfyP~f{ zc=e5hSufYlieG96Wr)AmtKtgTr8}5^LQYQGtX1Y+3>nVQb@wwTbO+aZRlcN5Fjadj zST1d}x#|vz0{w&Qp`xban zcJ$Eb=t~QCQUUa0fLO&nxSJK;7?9|2P|#&?`uZhZD$(N#y{D%jX3;n;U3Loy;ZHlp zGv4>Q@%0L%F8e(^is*f{9*Z@EVgJdHggplmyW;(s$H(38JmOBzSO^QQ1xZ}Ce8BpG zA!Ip`DQgj=;pb?t`1r0JQ117t2;DIhW(+*eSc7tP_`RLL%&rrwKLx7K8^46^enO^1 zIzpLTTu;%cTaJLlxVL*TXMg5y_pylPI(1dIjpq4r|Jk;2$?ar=V zKtpn_Km}r`uxJ)gqS#y2-`&5qgsS zdV%O$&#p?~p=eMy@EuVgWRCb=De_qwV_PDhhtu3BLuCugQW$>!200}k?? z=;k>C3fs&;s@l-*PTI`Wyh^V%6W@G0V^QAE6*zHa1AbKg_oJDKZ`6qP7(s0-M^HDc zv=t(#Uc57P>BDBmV-Gc(7FJ(C-djJT8iUmJF3#BWmNs-lV`BjYp`@cEc%U61E8Zb2 ze7^7G`P}H4`mD_n-(<=fjb$R2%ueY-Uz@lP7yE$Q-Ey4=np2SXGEbAt9NQcAKnT=Vh8gc9i*qIS|=R+>SzRM z+Voi>W}bHy^VG@^n)ys3L`q#tsLcnyYCsJZ!mYTuVU+s=6Pbg0wmf28uXQKw1vQVF z1W%>~1=L!v0j%mf9f1?CQv(Y z;I7(M&!6Tc`u>k`Ok=wz_vyczK{Y$WS#Tsk@A%%BP5JgW7_ihup1^KK`XTuN49T?} z706`=Z;XZgO83hlr7q|c9$qaH9v(O$)A00LrF?JRf`+~hFSCO+!^_anZ=WYdAleS2 z#%q4rUq(E>cl-JZcD@f3_(5{~*f_}{+3S9(v*kx$yYo$T?d8}gpfzxo57PNU8?h6Z z3Do}KXQZa;+2or3=;(X{rMIh%kblHxHpl@IVB;_$?WbIRrE}jeivr7Pa z6@dHj;La^qNrBuCzvKy$4(|G$<@iGOLk3CtthM6$)PmlS2&D?c3J-8*@eIln1dRK~ ziLN5Fy7{6$mpL1_C}Y9a_o!5epQWF#eAMCe5JIW#Qj}qmAVDQ5z%K!S21zFx)t~x} zEG-rL(bhnU$RL3GdNqknww4LDc{Bu)2W7ib#Kh$RxD&|ojuw%GJZ*F>c|u>Bg0BLK@@ zV1wW$4MYCYnZ4gNR@n%$RRolW*OcM*I3exw&90R?2necg-ZTAs3?D_-XT9)xEVGCx71 zJF#-G6t&FGbZI>ar$fX>8G)%Q@J<2fh%UH=q}`Gzogg0mEroKLWVnE>I_6v?B--e6 zs_?e`kzRq}MdOVb`XNx=RAhw@+}Hhs`(U7B;A-G!fTI&GFC4~c#{OWle5C6B`kJNlNlZ3B?U`6fT5TDpN)v>yM5YJ0!KEP zDBN`<_T9t0ZIxJa8^;uAMJ%e9K7V)G$OeS2;$?6oUI*bH*sunG)ZR*+4(8S9e6bsk zw4TvG^p@=A1kdb4sxS&frGw8PYySr!TTXMojmT|`#V&$ENa$Pn!y+EcsOacB(*CL? zYKHKp!Lj8(rEd%&i=eb{xx1pc4>B9$nXd9In}dAx_@Dtr$YMYn2xL+76!4!FVE+Ok zeH#0L<(?f3sr{P9(@>M?mrN<{kKlTIWgtHPNy@JaV3QEemdBDbNLq%_)Ns==O8t*H zc1d~s8fbz{UrX3{I;#^cE)gb66NvL_aUB&*i6SvcLL*xuz7wvZ9(lmRLJKdoQP(l; zf_^kd(JED=Y&bt7^LQ4gj$Bx86ek;d)=btOs)xsLH!nu-N*>XQ= ztZTB&KPTqsCg2&aVTb?Gmye{X(-0?1KUYXRIqGMQf7K3>xz#5Q-K;B@`Nv!c4tI)L z{7)vd-hMO%pvlI8k&qsP9ZF}vyU$DlA=E>MQPy{dmM~89`RS(sM-wrq&`LG>tOZPJ3%-!3j5jI zsXP(!)>6H&v4$Z$tGGE;!&rE6F|b;MRVu)n?y(G#ZfWUf^u+JaU$>l} zyrHvioY<0Bey2@%@hal-{&54&#J6#)kFu|AfTNWCSs4#UZE{7GWed~mv=X{a$qcM z*t6|t&UgGQl{?Vui9s2-vXjO8ZgI&Zg>GZKBUA@WpWvU z4@gJ(uwQ(1+IL*N4F2t_<|6!vA>rqRxc(49U*1(5^E;Jz8e?$Zzy(w~4D3@kd8_1z zziASE5=`;M7%LvU|l~uoZ&o`W{jrMuY>e;&|Sh;>KgvnGx$mV0`N3B=cZX;ZlMGpt0DpThtQHn`OO|&A{%s(28N;9tT_kM&OSAicuhrC_j-d@oGAM_$Pm(qhK+1l^l-C+cvkRZdUdXRzQyxC-I!+H zY}c8fZURFUC=$iv+>Q`CLQbJ8`vE2#;EY$Fi|VHh+7Vphd&l+P#s#yOF-m5?CM)d; z@&SZ;I*AdrMtVglm6yY@tJauAzeA*n5YwL}O}BIHp~I1V@^vAVKdY)==gBxblAmn# z*nVL)0X@rf79d>>bXGB%5ZIIVrqdVStXpwIV32^NXUqnujUbm6Gm{n|D@z64KaFo#5LY(Hu;;ze(>B z!(gZ5ruX6GEy7$FMh<_1zEYH0M%QZu#M|2*V{&Gu2>*pX`Y1bEkG{28r9VkQx&MY-9-e#Aq%jR$YP}c`#P`>T{o^w0jBsT%a zCfu~5@f1g)ej69t-_7I<&UydRsXHUxU#9Wzy|?9ifAIVVoF@S&7f}ywDRE)Dw{KQp zUu8Ca7E{?Elq+WRIRPY&$zn#;s+5I$Cf2fF2ObmP04dzolte8wutAx_NdQzbn<6Vr zg;dQ-^$i`d(5d`rA1_aA@A(*H(ab&UaAn-uICb2=%~O*Tn!W-;Y)@lV+H?X-FO4Fy zMwF)tjvfl@nW(S0#|m5}pIjktPIo0(`X#PJeLf%Wo=U#wmiXCwFE1m^>5}HYqP(pW z^R~W)-u4L#Nh+-s=v7yT5#2WzlIs0h1iPi&xu;p*^O?`*VW0zr&%KKND&aA3yAb%n zQLnb^7Cn`$_jvLqzpaIuM{-^j|DyB|74POb~fvq-Uqt=zMB;EOn9>6Ybrac4JZUo!v zk{5Yt+zmP$k%KFX_V1Fr;bX(%js2wi5wwFnaPV^u$3SDIK~p!UwYpccnuqLFr-q3K zOGguJb??@4PSKWQEH|ur^1DEsZx|xB51>KTsrL9Bap<63j#~Z?fqvc@GOIXcC@0hrgT=OE@u@`Tr*nBxwc*1-8O$g0vhfH*S0eOc$ ztkT3jDsF}{vZ-&vslCr0T>6_wzyI?Vg#Ikr&SF2RBIm}gN(x4JCkwY_@rvM5?H-l% z4aFBFp{#Q`_GN0Y;LE)sCxUT1?SrRm4l{An^@Nqp(}5l6Y4;QJN*1eR+|5dZ^E6UT`zzgYjfdKLtf9i&82W!NQdDlzK{UA?;?hW!r+ zO<(ALHlXZ1M~;Mp@Nstz1PRrOgRh(pag=sjsfrGEm)gD_je1g>8yy1`*CE} zc+9uVqZvD@J_@W-Z8|R}_!cgne)q97r=4B4=y%}msBFo7%4wbJt|h=Dq0*sxeU`m^ z!hGvU>>l~cdD>QHeAqs&?5C?HN)6|}vA)@UV~zc=+YssD0rTLG8vU#H0uv~?59@ar z{VV1_3q6B^a?0-FX__h28*9V`VMUR}uP|&_xS#OB0 z4V$dV-sawu7Y601#SOPri$V(TdMMRC zeTZ2lpYw~LH?4GMG_NeSX6+_#U03w&H%@mMJh|c&w?P!H1W8=Wsl%sg2#kadYGHb) z)@v>^om2Mv5NBVe$)8Ie);UzV7_m*4r#q(BO1*@Vv$^ssg`r|xm$XE4ls#X$2&@Ho zhX9kGuO~r4IS!-kAg19G$H;shCohf|(*omNO(=4g!8AC?eOJh>crJZG=(XnKSa951 zkU9ek$_UFqkD{#9Pze$%1!Wx2B;U|BuGul(Bu)X;J+GH5#xNp6e#z)3`TA--HND}% zPowBY1RsR7(&qaFNsW285eXL>NQcqf$~P`2&eGyeCeA5U5_Z39>ve zsd?c&5zM-{yG^c-V90_wb1=1XcjqQfmD$=V0=67rmmI~CqtiM6?pBv6c!jYg-c2_? zbJ0V6%i6h0W3`+%*BPL8?Yc{f@@bcviwRq(nu+=&mzRu0JKkxcHej}J1Mr#Xzq)kr z1RpF;Vf*(V-1qnQBWKF@gGzcPFAN{%2b6Z(ns!UAcI*x?PF4VVzbv0Lm@o@D>_=dq z2X%;=wqJ7!s~`)}din|s3@6e@Mh*F6!gmUZ*I9!2EQV2&Qcv@v3y9AIBzUh;(ic)N zsY9{|jgj1w(oz>bEZ_pH%R!mO|4c*wI%1|&3ac>}i@gYZX7c%NoUe^OtHnAi3jC>H z-VY0pS2|S8k}gXt9F+Kt)pG=jsZ?E`M`5+T;03TvZTW?uN29MDkhjS1SofNt-=o>l zv#2DYArTAK2@Mv5(z`d*bsdkXmq_XUb^Vk467w2!WPhw3fjspF`00|3ci};_VIG#Cvj4zU!-*s+AIbq9Y=kevQIO(WP>+Xrvbg6A3*)Ddp0Bo1tR1!MC<$+1^ zcTDQr1t7QMQ51%d#)hzMUszKe7}C`cRx{770AwDjLQvZQ?JCetn9FJfSo@SbMH#|w zHa(`focgr~{lIZ1TMOA4aOkmrYp$WCK7h>?M}=06uu;ZcQ%k91!HiYS*=tP%qaW&P z`hV0Fw=QXF#p$w-aTZEgQNURL%_^p;g6Th)(O8Xr3`rd z2U%<%<&V!EKwwMkaFHUWP}!k|*){K8i7_#0>tRv3&6R|&N7t;O5C9ZX*Le=zpq8sY{YbYHaLKh$?$J%n(CG=T5>wpL6LXvG*B zZdTZzW6-5mgOme(JA~dq+m(-IPYB)UFXF(O9)SkaWUWGj;8 zRpQ1h*dOuTwd@Tp+<1!^N}u@v+^*k6xYmtr`R|utqg1H?u&27<#@&ujb2e;lY=2GX zW`Uo%6~r;O1`Txn?S!E=R10Ko_ZCh-*qar*7yj|=m4y4Kz%8#nfGVJd_h>$i*JWIM z(O}}&4k!?$#o~5|ax>YpzeI+=eK{2a7szj%9};r+3;dzj;B_bB?Ul#9`KAr0m3eAD z?kRQ~<+a2w_y_F?FXt)BVI8Lmr$numeHT1NZ`?-SjRE&PR~& zJj57uCSqdWWxD{ka9~$aUHKt)G-6l9o1QdhK~wCY;_NA<)F(dNU2my{%X)qW1R@`-tNnHCb!)g*i$GC-6XzG>*X&Q#Gh^Qb%cpnthYAb~ zZ+iu_6>7SzHevJ&z$e;y2YNg(eDP1?lT%?CSC7<=^v{7DvP%JY#<*}n8Xy0^|2vJX ztOYS^UQn~Ua|IwkUZK_vNK%E!(tm!Yl!k z{%9Yv3{2`UL~Pr74;KBe*d`y=fQ^6;T1KgC^XXumCJ*nNUPW}+-8)wWv7;VAKblAa&uDi16CUpN8l_Xb`<`uw*@ts~5jFw*3!RQBi6OMQFVvKWS zLDPTd<#k*bhkYB!TtL;g-~*8MtL-$!+I~M3)-P+}I9gi^d85_|;FP~`~O+?e`^gLyz)+mIC z5foE4&90LpQqXWa_6G;so_Gm=_gMXBZH!kKsTTN*0FJv_J{Huj0>GHDs$3hB~1|(*#9N*dg2_3G71M5ul z@KY@EN%0g;e0yU1)Z*{>cpwNZc(LErYS&1QnvX8k0;r({!ms*wgD}|k`qx0L;J~Y# zD-rN(Z^*i}pTgk=Zwzb&%o=t>$374tsN6swt8pI!qyo5r{sssp2s8PEfS3m{T2l=H zSWvCl86tkYwHNJ=5DF~wt?kj93Yx2k$Jvt!ESV^YFlWboS(_)k$*ka+tbtV6IvM#x z_tM)Wn)Iz z(fvRan!E&rVRGBHGoY_YT$6xiEa!$`h;_t`gui|QEqhbAQeP>&m;BW4N)r%WEusq- zFZjJ4^SyVZ(nsF)wXsV|IEm7)Qvdqz(7KZiTYf*`*h`Zwk#6)GcLV5cvy%&L_22F@ zb4uROf8RK`bufiu(brLF+A-KJEqx&SorQS@1& zKa1@t-*=jNh);j5wcxeHiG+DjW*;ZcUOP>YWzc`FkN7@hM+^uhY>4pQWF&u-89HK{ zkbPI*T+ZQW4@T)?pz(81fr^_>t30DKLa|p4AeU^{0>0!LZ-=|@!X?D}W9Aa4-PHz^ zr)=LILVl_B@b6#^4t?$=r<++}cSgY1Oe?_?9l;f7ErxOzgoD8uGdbd5)Ad?+A^7t7 zr2VAf&sb2lL#Ou7%ek2idiNnsQgkMn`E~q@N253eXvRpiY3&;|$65Ea=<8%PErU2+ zPA!|!0#4v_{3hpajp*iQhZfe*jTYT>WqsqFott!=z5no4{Rba_5l^^SdrmLX^8+x? z`qMrfk_+ZEA4m)!e@@}Y%z>KIC`d!a!M=-wa1+w=8iQf2wmk?yy#>VsDT8-t%kC@~ zcmTYyK_bG(gfO`YGin$-cB%l59l^LyF2CLY5(A$TBh*%$WQA+@s&~f8TT7bDqv~&hwmOX72Cz z{w&w$`dk;GMChED%%@$uqbd>z-HwzU%p@2s5qj=j^FQ6SLo1L~vEd05E@$5%5JS>C z>=A)#Bg4jyx~KkZtzqR)tT!q>eJ^O|NgrapHcGoqxViE3(Vxdv$`YNLh_4q*vI@r` z_+K(H)$K^sjLA||ZlbT|`f#;rdk$tHm^|2=c4pO5O-}px`x^LS;vg}{^%nYsTE_xV z?8Zx4ZHAnLnG2TRC@V-@ZMrW~qxY`i3a3n~J==TEy#vL*!W~)a?WJRk*3axbETKbk zl|-V1#F1=Nmk+rO@e{i2Peg2!HqF;qy8a#Q%=fE=gXjC~lr+6n2RJcRex-NrSHLTC z?$eVxJlu@pygePet`J2bzaI-6te$^l>f|0c&Of#PDq3Kec6JSZ^O+eujD*r9A${4mQdzwGfBPHuc6u8f0O zr%XIWPCwvdEl}!UIW*saGAAUDKhbrST|acW+J_VYs@YthQUaxSxfm$}`$hJcrVrhS zFEnE>xO#tmX^va~Lqzc0SUaTJ#f3Ntz$ysb&ROryH194n~v9?QSxK1j#{r*`b zQ42;W+Q!t9+3Q`E2PayHO5fH0i9u^A6-ziWxrB25ER9CbE+k)XJWOU7#ntG;rlHSu z>ZclziMBhsg5lB%^By2Z&HPyGC7TLAw*WaiW3M0l@tkzpZp8Qb@@rduk)EW5T@7`n z)+E1O)4O05DWS{!=ykebWYk;djGmP@LZC_?#%kmypm{i*HACcw?j-mwq-fjAX?(OO?eQSRAy{W?@)up4{E;xn_}uW6yfuixL^KrU@}^VXR(i%lsiUcHf9 zb6)Q`g1L6KuQVkwVLRb%fwPhAlRFG@tdCbP5oRB=yYPod|Y;HD0@GvCCQ5{U^x-ogJWET(eNqmN$ep~+o*+J|!I z9KHYsQGw^YuTiJMZCaTD8)-osldkorZM*eS;GT-z#^$$Brtct+y&ST3?uHtpU6RkZ z788bCiRl*t(Ru(S5r2=L+A_jFb(nQ{P@baWxDuymz?U!#ESR-ieBh%5aS{C7SRfiY zv`R3>^D&%_mYnB0@Z=Wg5;y@&M6gKk+XW8xQ$d%bf)nN0wX zkyFkHEcGem?2(YOXb?Mpi22lxd!Vouamk+HSc9#<_KB#@@qkS4Fkt(&85Hjh4ntbeT`6FgsS2dC1frn#&{J z`nA|}k+o{X;{*ARZ;m!hDP;mtxld!+RllsjaMf{ZBYOV%K=8&SugMdiZoW^j4LBP- ztgG`Cx0ELrlK#aX$BYfAyqQs*b>pnCb(s!;(4tBJR?Gqf&qNy@EM;AkIPcAZp zH!`_H#njQUxP`viFK0cP$c)_9a(c-}*0}Uq0Zlt|l}EW(3{L95dJ5UQ_9W&TyWO^b zenwLzKlq!o=cN9RvQNUb^!{j7cU^LbtH&e(LW<$s{1;eHnsHxvN^stt6^CHYwS=s` zMR5l*1y*2An(WXST+1k!Kf`mCf~pB34M7t2lH0%@?R3!ThqT+3o|+>?XX;p$*Ieek zPCCkoYkU{fxoRw%jUJ%0se@N`+Up+ueEi;nUDt&PFUK1kO}dE&G}b5Pc9xauJwOa6WX=Vh8uw<1Fm2ZaahuPxyai@CApW8aRK z5xuzyp%aUHi$vZVF)3iVlEKg_XGlB*6q~|3uFZ_5yKy%_uBN1frx+pH7MM=DgoGcx$B!py3h2*#&LXujt^v3QZoL-C9@EzE>W z+Z~2Di5cR)gNFhL1a!=d34(S#_?>iFg6Gd~ekW&eDf_P$6+G$fo*Ad*9N71^dalw^ z*e^umha)9Z+Gk<1tJ3<~TnI()B<)r$sOO~?iFEO9Pg(BV3uD$cdM33v_{c1g2hulf>CrSSu) zQlee0RKngK8gJt1Zz}Y-3U4+Q1R90+u`heGyC<+h%;IJ-cQ0g<6>rO&^{T>O(34K= zxO(vI$da=GmHqi+<5ZZNty^rRZeM_o{}!tB#B`YY`6MguN=iazrF4Yu=8WWGaJy)R z)|?&M&zk|V;;VJ|0Q6XD(jb=8YY9zpxIK zTzxtc%b-y1mUy$Rr`BUo#j!`f&%m^WC~k;zO$#Em--&U&{VUaayJt8mBwv-&{%G59gUhDCUQ?tEY;a)x@Pq4c;Ip27 z#C9mZ6}HYUh;t&BH0DWK0IjUw##>(q11Q<-6j#d3xIn{sc(d*&5<{9jDRV zL4SVO&R1)y6n}2Jn5SgYcsd!RWz?*Kwa49%7Fst}p4VLi73~uG9TBOqPA|}EpE2~i z^Jk4f+>D-fZl>8$smrJ?jEAx_h|xexch5bBzWmJ`WsXs(UVG7CX`T{F$AOP5V#_MO zykGR9Bf6&>u43?nSjQm%mTkB;-I;7`gNyLNm6faxO#4_6wWxW{_kRTx1l_wlWbr2& zGZkE-`9!q9v&Sf>D&czw_0zz~+`Y;d=1Z50PMa+Fbx;2~s2V>^ChI2phWNw(mXH7| zg)VZ)JS+|p9MG?l9*GF}SYAL55s_OUeUx}_;3jg25zNQ|Asz{oBjPyF|X zKfa2Z(GJ5^6&%4Kpn*zVhQqczSK7R$DGr0M0k&3Cw+d0=>4T>*z8Z88!6`AJ%ajBP z{G>yf_^4ynh*K^;p#;vVBy4>5MumT`jn_W2%j8hSZwgEI47C&*MjzOR8gv%~3*9;} z#K_titM-+^l=;omLt8&8C%#rijp~?6MYk+pg9-uf4>M^6>2WeSt z{rBT|J}VXOfEW0YO)v=srr(85X{WCM@9#S!Uv-jCML)kL% zJp~OV`d>b;R8+<3H`=Q5Ed-9TpG|j z7HO~(Rsu_#SLKv5znyDk3jZl*Cc@H$-DP=`;SFcq1Oxt=on1c9$Sa(W~ zMA5xF{Z=WQa&nbr;qRSx8}R!d?&;hNuiEFw40>ca^8gILD>dQ+HmS>Cadx)}puqA4 zFfF_}Ctr1L7Oz%jBj0jf6}bV?E$cEE#t^4vV$dufT` z-R=0&PKe++zCPqaa3Gt`F6<)PH|Unm*PYc)p}@{xMKY()zr8Nox$ueIQ>nLdhXE@4_yw%k=am1NO zxbccCpWa^J1Q5a2$=#O4PIQ~t#vtW)6RX?jB3l*Y#g^^M8^FH&Tng3r zR2e&Qr0>J>l`#oVLlT4v91Q1D;+*FLhd{R%*cC7Z>wTTzl?jvnNYAOB!gLrzUb7~7 zav^Ht7Nj&V44%Um039F-NX-D3J6)~5e3u~--}cTS#J}!fKCMah1zej~r*E^4L;O~n zId>a&M()RzN!aAprQaMX{{Cnk#6GiC4*L_2!JbHF@guqY;x(m;FtqyNFPz24T71e_ z4hIdgIBboNo5r7UHXlvZ_UbLE_kyrK5_8E7D6n`4vA71S2C;u#oKk%@;7>sU-FCS3R4affp zQcIfcuYABS^F9UL`?0L(`h{h0cTp}9#-aGy-AU$)LkgqDK3tt_{)RQ*+3L_RSzf|b zCEoor$*(r~CsTyAxf!Qd}6zGp1C@o);^Pzsy z^Tp51AG*~33r$QP1JQ-j!pDK$nARz5fkk;^ux54)e-@9yv9iS+iRZ8(mK%{C?A7Og zplCo3)I5~}x!R?C5M(hAf59moPNo4$J6kv23;Xt9&9BE<#Ds?*_-X+Ao!S4fE8u*H zZ|>DMuL?EO?~13+95rI?*Ba}+=2h?C{61pn{d{_JL&bpQ=IIvz{KYMQ`f7f9qZsW? z&_~q#)#(|B7?2Gb!y4ryT5T*lbGIBfjT+xVZfgN54}aY~>(KpN%DMu3tV&ZBildXm0Y^ARmt zqQYL(jM22WpEUW_BmT+t4t)7O2k4S(+VEt)pt z^s!9iq48p$$_iCjJ-sWafsD+-1is?|X8@zvgqYOwFS~#C zC6F0@@<9qg}@xyDqe(Wh@^DN@SB>?!2xG1pp zyv+?@9pFRSd1hAV1gr?)dI5kFHwFX%-XzV8$EdM)-#5Kh^Bs}awqQ)T0Q5QGoa_rq(QFhY|ksK^g{`iI{6X;Z^OX>jzr z>N#n3%Na_(gBnpZOUA&h+|w@~+$p5vV|yHS9l6>JuWBdI+chI!1iC$!tUNx<@@~g6 zagrpImls+C&0e%TRWi9$!sX(w`K>Kfifd%t&YI)^+1FlV!?>LpR59)9t8NIXaDCb$ z6+YN`<8x`SP+gpZAbCQc?6`g}xAB&*;`#SqHZDYq_q8AWR;HTdZS-WA)vTYL@pCz2 z{&=d)4Q9oJJQ+3>&ZopwSOKq7p;7uvdN7pmp!DOmv0?vpE#O(30cHJn0mR3izvUv* zqKu)q%<7CPPA?Rt4NHeL$iTpAmTx}6axJ-Y=X>K~S3_LT z&^n@ydTih)?GM#H2t}+XYUZi4Ci^{n02nn^xw5R1!lBS9V2}<&_5kWO20^@n#=d&@ zQb{M9SJIpPq&fxt?$2H>Tawnwe|(sR?z=u(Xxh zwaCP|(|R_v8au|S)loh`;T}GrZw%+DAU#YtQJO%GjE$ODz^SA2OCLiDi;}G#7;rkh z$C-{_MG<~q*bWz6LAwWg4D(07E!D%WY;mRhj#SHL+a1S|d7f^qwl)&yNX;-dkmZaC z1c*~@zcW_DDzg5G)dl3J_fun4Gd)IbL#C=c@C8z3#lzI*^Qvg+6TV(YFD?W+{84r) z92wss{vLX$9m{oN+jh|9$kDM=T-kJRP543?$chnQuBW|LJ2gM`OsYQG^`-YYfh9nR zl35vwNIFZpB*&!LShnRCryt`Am;jK12bq9DZg(j-7WTPligR%z8vCJLfg)@t;6MWm z{Vv-`cU4-zLi@dUWeLJr@kPsJjEvf#TrWn@);t4?!Y8k!?rnOfaAeA;@PQZkYRGmL z*57vRiQKcm8(iFgWEk)Bzm9+t^2~-RS9bUz6+pJ3%F8r`@PK88eQ@Zm-?@?HN4mud z0?iKleAz&uL#q=S{08IhGv;j0vbjO)Pogp-lJ)}mA{eG66`MPHAozCY0-N9>Bgi^TWW6&x7eE?2pU-paw zoDZX?_|2e{6&dt%d;MlcSZfr0vlfp*qMjJT>QB2Z7heFxMDhyu8jl-h zd;{rDVu2|r*#A9tb2#=0%AAbM+6u`<&xCzoP&d79lZwL%$bkwe~$0#fW}`E z-=YnbFeMCA(yR<^0#q;mT&P_bgXnwgH251rYxQI$0zSYbk}NmUVhxm0&e_Vt*?t9M zmvv_mC-jW|mVpIco8DBPkM&Bvf3NbEWAoHo_@KOXA=f#kdoujbR>t%IYs&B2(jCBX ziF%0!V)RDZjd6Y_jW58&&V|QJ*bKkOC%W+_pCGbd8+bD}aik^Ri3||~RHpQP|26MX z8C9tVOUn(L*+iTT*Ipp}4yL7*s|(UHP3#0+IZHpZIY3nSR-rga60Y)b7z5@Ku5d ziao1d&e@tY9QAyo)As-_zEoS7!Bt&=$$_8x$}q}G*vF)vBaeI>Nbaf(t9dL@lka_a zRd6XjzwMs=fr+;ZKHXMIw&yB(68WLsK zpZ#RxVJhingF_NB(-1vKZ0mUtUTKbk)CRq2X3C2aISD@T-;2a3j%I}a4E!r;+)tGH& zvUgnj0@bd8z8l2rp5*rG9DbC)#R~cjL)_f^G=x`pX%;;D zJRtF*I!%!8tO3ZB8RuPM5^7kDYU)H6OLy|Yr~5wA8_DsG{ntfDix^JOPIzbygAZeq5qLGNi}%(g`2u zDf``F6#aQa>q)=xU#a`o4;v@?q8e$}h?)<*h+s{#Z-;w0Iez&#pC2q#BE1IzdCB8Y z2UaLmsWl71?SFEEV^4@_z^`#)@1q5XC!jMW@zagy9%vjp0SCJ~^3Xf5NQ8g0a?`=1 zIf-spIQW9u>=r09QjWl=uooD)HG2BkyHxZ4`fDP1Wd5!#c?h^~6Z?b8#tjGL?gVX3 zn>AWp|AuB-L-tXhnf~=#m*%F>hQ*}Rb( z6*gbAQLvGFd7^3Iiq;r=)4hYv_LC|S&&|`ulF|B0w{}1|C1y6O{B%@i7QeqpiPV&> z%*Atre}j(%Jbco`21h3dNS1+SRa*qfLcsY8mXWA!of?~Qp1-Dug{Y?oc{Qm}QF*+8M?HZD$ z&Zh>5%06+>|KZ{*5y=3X4cL-2!9+B!lL{ep>rS}?-_5w?0xLF{?)&GI`zXsFhwYvYkKthpmW!{X}VXbQiNDg%d18&wNHl!pN5X`TA(OnwzoLnBMz7)8{?*kq@0hCPYfE_o|P);m#KVd^9XkdoR`3B%*GByUZA zTVyri;|WQYZI#m)nc%Y0wEM*8ZmS1uHv1@-hPm}B6xaSHB9BL`}+*EJcbQp(12LcR?H4}ij} zn?R~tE(QOQDn>F2r@!PyFVfz8Jonk&nh>gmaFlO79_5ofM;-Cdpp?L|a=feL=E21A!9bCpp7 zLr(M80@PW0Oo#=w4K0k7rbxqr^~1iPx7X89pRLo>!W6>a^89hF-F(*i8T|f61BJxI zz};`f7H?p@t-bQok6`gyfC?C+FjOaC!vw8!M%#G=2$@c*e-U4J|8bg+a3mYMGwWt4 zUI%lENoC8FCGY+T zLw&@LPtrADO$@b-{|U&_MI2uZfg4mAyBvYiBLVJq4Nq;60pE6|Nzv`P`Z*Jye*eDy z^H1DYRFW&WqSQ-acPJ6mQlgSpEzX8Sr-NG-cooahE^{xrSXd?KFPa zOdA>z&-otp=eMCufZBM;saF}VCvpW>c?o-Kl_AQNR%7b__JgE|0eWEo7bm;InLi#bVmdZ8?xT-?e_1x^f~a@^N~tl zFBKN0DSrjPRkzmMnif_HyF}{U^CxkmDUxtDIWcXoPZ(4JJlGIA*cuT5J#`^h58g>D zC!`8-`gd7JlWBg~>=)|56KA9EDdo+!E1{BKucSNP4w9k*vrQmG?~!-m=$a%tIIzG{xY-+{r(yyoEBQj&V8tb4|f82P>DMoOL@5 z#a_HJ;LtvB3t_zooBE9lt1YQVEi%c;cRs4^W7`4YNAAp4v&jR)ea6;e<<_8XU3{

@i+hl3u*AiD$*%qB+xE$vT8`EYyN@ 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 Date: Sat, 7 Mar 2026 22:14:21 +0500 Subject: [PATCH 6/8] chore(desktop): update package.json and add icon for Linux build - Change author field to object format and add homepage URL - Add maintainer field for Linux target and update icon reference - Add new icon1.png file for Linux build assets --- desktop-app/package.json | 7 ++++++- desktop-app/public/icon.png | Bin 12541 -> 7945 bytes desktop-app/public/icon1.png | Bin 0 -> 12541 bytes 3 files changed, 6 insertions(+), 1 deletion(-) create mode 100644 desktop-app/public/icon1.png diff --git a/desktop-app/package.json b/desktop-app/package.json index 114d8a8..40c70cf 100644 --- a/desktop-app/package.json +++ b/desktop-app/package.json @@ -3,7 +3,11 @@ "version": "1.0.0", "description": "Osmium Desktop - music copyright checker By Renderdragon", "main": "./out/main/index.js", - "author": "contact@renderdragon.org", + "author": { + "name": "Renderdragon", + "email": "contact@renderdragon.org" + }, + "homepage": "https://github.com/Renderdragonorg/Osmium", "license": "MIT", "appId": "com.osmium.desktop", "scripts": { @@ -54,6 +58,7 @@ }, "linux": { "icon": "public/icon1.png", + "maintainer": "contact@renderdragon.org", "target": [ "AppImage", "deb" diff --git a/desktop-app/public/icon.png b/desktop-app/public/icon.png index e93696fbfae3b12886f86a6196451ea7ad0c6fdb..61d9876f09476cd2694478436640c781d07b1c57 100644 GIT binary patch literal 7945 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 Ay8r+H literal 12541 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 Lf_90fef0kW(lNYI diff --git a/desktop-app/public/icon1.png b/desktop-app/public/icon1.png new file mode 100644 index 0000000000000000000000000000000000000000..e93696fbfae3b12886f86a6196451ea7ad0c6fdb GIT binary patch literal 12541 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 Lf_90fef0kW(lNYI literal 0 HcmV?d00001 From 66b9737b091404f75bd288c6b11b32c54d2a5b02 Mon Sep 17 00:00:00 2001 From: Coder-soft Date: Sun, 8 Mar 2026 00:02:04 +0500 Subject: [PATCH 7/8] feat: integrate Convex for secure API key management - Add Convex backend with secrets query to fetch API keys securely - Update config system to fetch secrets from Convex when available - Modify desktop app to use CONVEX_URL instead of embedding API keys - Update CI/CD workflows to use Convex for secret management - Add licensing URL validation in summary agent for HTTPS URLs - Include Convex generated files and dependencies in build process --- .github/workflows/release.yml | 12 +- .gitignore | 3 +- convex/README.md | 90 +++++ convex/_generated/api.d.ts | 49 +++ convex/_generated/api.js | 23 ++ convex/_generated/dataModel.d.ts | 58 +++ convex/_generated/server.d.ts | 143 ++++++++ convex/_generated/server.js | 93 +++++ convex/secrets.d.ts | 14 + convex/secrets.d.ts.map | 1 + convex/secrets.js | 20 ++ convex/secrets.js.map | 1 + convex/secrets.ts | 20 ++ convex/tsconfig.json | 25 ++ desktop-app/electron.vite.config.ts | 12 +- desktop-app/package.json | 4 + desktop-app/src/main/index.ts | 42 +-- package-lock.json | 528 ++++++++++++++++++++++++++++ package.json | 1 + src/agents/summary-agent.ts | 14 + src/config/index.ts | 103 +++++- src/index.ts | 8 +- src/utils/convex-client.ts | 66 ++++ 23 files changed, 1262 insertions(+), 68 deletions(-) create mode 100644 convex/README.md create mode 100644 convex/_generated/api.d.ts create mode 100644 convex/_generated/api.js create mode 100644 convex/_generated/dataModel.d.ts create mode 100644 convex/_generated/server.d.ts create mode 100644 convex/_generated/server.js create mode 100644 convex/secrets.d.ts create mode 100644 convex/secrets.d.ts.map create mode 100644 convex/secrets.js create mode 100644 convex/secrets.js.map create mode 100644 convex/secrets.ts create mode 100644 convex/tsconfig.json create mode 100644 src/utils/convex-client.ts diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 6206c49..f0f3af4 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -75,17 +75,7 @@ jobs: - name: Build Desktop (electron-vite) working-directory: desktop-app env: - SPOTIFY_CLIENT_ID: ${{ secrets.SPOTIFY_CLIENT_ID }} - SPOTIFY_CLIENT_SECRET: ${{ secrets.SPOTIFY_CLIENT_SECRET }} - OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }} - OPENROUTER_MODEL: ${{ secrets.OPENROUTER_MODEL }} - NOCODE_SPOTIFY_CLOUD_NAME: ${{ secrets.NOCODE_SPOTIFY_CLOUD_NAME }} - NOCODE_SPOTIFY_TOKEN: ${{ secrets.NOCODE_SPOTIFY_TOKEN }} - TAVILY_API_KEY: ${{ secrets.TAVILY_API_KEY }} - ACOUSTID_API_KEY: ${{ secrets.ACOUSTID_API_KEY }} - DISCOGS_TOKEN: ${{ secrets.DISCOGS_TOKEN }} - GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }} - GROQ_MODEL: ${{ secrets.GROQ_MODEL }} + CONVEX_URL: ${{ secrets.CONVEX_URL }} run: npm run build # 3. Package with electron-builder diff --git a/.gitignore b/.gitignore index bbbf929..06e0783 100644 --- a/.gitignore +++ b/.gitignore @@ -9,4 +9,5 @@ desktop-app/dist/ desktop-app/out/ desktop-app/.env results.json -tmp/ \ No newline at end of file +tmp/ +.env.local diff --git a/convex/README.md b/convex/README.md new file mode 100644 index 0000000..91a9db2 --- /dev/null +++ b/convex/README.md @@ -0,0 +1,90 @@ +# Welcome to your Convex functions directory! + +Write your Convex functions here. +See https://docs.convex.dev/functions for more. + +A query function that takes two arguments looks like: + +```ts +// convex/myFunctions.ts +import { query } from "./_generated/server"; +import { v } from "convex/values"; + +export const myQueryFunction = query({ + // Validators for arguments. + args: { + first: v.number(), + second: v.string(), + }, + + // Function implementation. + handler: async (ctx, args) => { + // Read the database as many times as you need here. + // See https://docs.convex.dev/database/reading-data. + const documents = await ctx.db.query("tablename").collect(); + + // Arguments passed from the client are properties of the args object. + console.log(args.first, args.second); + + // Write arbitrary JavaScript here: filter, aggregate, build derived data, + // remove non-public properties, or create new objects. + return documents; + }, +}); +``` + +Using this query function in a React component looks like: + +```ts +const data = useQuery(api.myFunctions.myQueryFunction, { + first: 10, + second: "hello", +}); +``` + +A mutation function looks like: + +```ts +// convex/myFunctions.ts +import { mutation } from "./_generated/server"; +import { v } from "convex/values"; + +export const myMutationFunction = mutation({ + // Validators for arguments. + args: { + first: v.string(), + second: v.string(), + }, + + // Function implementation. + handler: async (ctx, args) => { + // Insert or modify documents in the database here. + // Mutations can also read from the database like queries. + // See https://docs.convex.dev/database/writing-data. + const message = { body: args.first, author: args.second }; + const id = await ctx.db.insert("messages", message); + + // Optionally, return a value from your mutation. + return await ctx.db.get("messages", id); + }, +}); +``` + +Using this mutation function in a React component looks like: + +```ts +const mutation = useMutation(api.myFunctions.myMutationFunction); +function handleButtonPress() { + // fire and forget, the most common way to use mutations + mutation({ first: "Hello!", second: "me" }); + // OR + // use the result once the mutation has completed + mutation({ first: "Hello!", second: "me" }).then((result) => + console.log(result), + ); +} +``` + +Use the Convex CLI to push your functions to a deployment. See everything +the Convex CLI can do by running `npx convex -h` in your project root +directory. To learn more, launch the docs with `npx convex docs`. diff --git a/convex/_generated/api.d.ts b/convex/_generated/api.d.ts new file mode 100644 index 0000000..1530bda --- /dev/null +++ b/convex/_generated/api.d.ts @@ -0,0 +1,49 @@ +/* eslint-disable */ +/** + * Generated `api` utility. + * + * THIS CODE IS AUTOMATICALLY GENERATED. + * + * To regenerate, run `npx convex dev`. + * @module + */ + +import type * as secrets from "../secrets.js"; + +import type { + ApiFromModules, + FilterApi, + FunctionReference, +} from "convex/server"; + +declare const fullApi: ApiFromModules<{ + secrets: typeof secrets; +}>; + +/** + * A utility for referencing Convex functions in your app's public API. + * + * Usage: + * ```js + * const myFunctionReference = api.myModule.myFunction; + * ``` + */ +export declare const api: FilterApi< + typeof fullApi, + FunctionReference +>; + +/** + * A utility for referencing Convex functions in your app's internal API. + * + * Usage: + * ```js + * const myFunctionReference = internal.myModule.myFunction; + * ``` + */ +export declare const internal: FilterApi< + typeof fullApi, + FunctionReference +>; + +export declare const components: {}; diff --git a/convex/_generated/api.js b/convex/_generated/api.js new file mode 100644 index 0000000..44bf985 --- /dev/null +++ b/convex/_generated/api.js @@ -0,0 +1,23 @@ +/* eslint-disable */ +/** + * Generated `api` utility. + * + * THIS CODE IS AUTOMATICALLY GENERATED. + * + * To regenerate, run `npx convex dev`. + * @module + */ + +import { anyApi, componentsGeneric } from "convex/server"; + +/** + * A utility for referencing Convex functions in your app's API. + * + * Usage: + * ```js + * const myFunctionReference = api.myModule.myFunction; + * ``` + */ +export const api = anyApi; +export const internal = anyApi; +export const components = componentsGeneric(); diff --git a/convex/_generated/dataModel.d.ts b/convex/_generated/dataModel.d.ts new file mode 100644 index 0000000..a850cc1 --- /dev/null +++ b/convex/_generated/dataModel.d.ts @@ -0,0 +1,58 @@ +/* eslint-disable */ +/** + * Generated data model types. + * + * THIS CODE IS AUTOMATICALLY GENERATED. + * + * To regenerate, run `npx convex dev`. + * @module + */ + +import { AnyDataModel } from "convex/server"; +import type { GenericId } from "convex/values"; + +/** + * No `schema.ts` file found! + * + * This generated code has permissive types like `Doc = any` because + * Convex doesn't know your schema. If you'd like more type safety, see + * https://docs.convex.dev/using/schemas for instructions on how to add a + * schema file. + * + * After you change a schema, rerun codegen with `npx convex dev`. + */ + +/** + * The names of all of your Convex tables. + */ +export type TableNames = string; + +/** + * The type of a document stored in Convex. + */ +export type Doc = any; + +/** + * An identifier for a document in Convex. + * + * Convex documents are uniquely identified by their `Id`, which is accessible + * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids). + * + * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions. + * + * IDs are just strings at runtime, but this type can be used to distinguish them from other + * strings when type checking. + */ +export type Id = + GenericId; + +/** + * A type describing your Convex data model. + * + * This type includes information about what tables you have, the type of + * documents stored in those tables, and the indexes defined on them. + * + * This type is used to parameterize methods like `queryGeneric` and + * `mutationGeneric` to make them type-safe. + */ +export type DataModel = AnyDataModel; diff --git a/convex/_generated/server.d.ts b/convex/_generated/server.d.ts new file mode 100644 index 0000000..bec05e6 --- /dev/null +++ b/convex/_generated/server.d.ts @@ -0,0 +1,143 @@ +/* eslint-disable */ +/** + * Generated utilities for implementing server-side Convex query and mutation functions. + * + * THIS CODE IS AUTOMATICALLY GENERATED. + * + * To regenerate, run `npx convex dev`. + * @module + */ + +import { + ActionBuilder, + HttpActionBuilder, + MutationBuilder, + QueryBuilder, + GenericActionCtx, + GenericMutationCtx, + GenericQueryCtx, + GenericDatabaseReader, + GenericDatabaseWriter, +} from "convex/server"; +import type { DataModel } from "./dataModel.js"; + +/** + * Define a query in this Convex app's public API. + * + * This function will be allowed to read your Convex database and will be accessible from the client. + * + * @param func - The query function. It receives a {@link QueryCtx} as its first argument. + * @returns The wrapped query. Include this as an `export` to name it and make it accessible. + */ +export declare const query: QueryBuilder; + +/** + * Define a query that is only accessible from other Convex functions (but not from the client). + * + * This function will be allowed to read from your Convex database. It will not be accessible from the client. + * + * @param func - The query function. It receives a {@link QueryCtx} as its first argument. + * @returns The wrapped query. Include this as an `export` to name it and make it accessible. + */ +export declare const internalQuery: QueryBuilder; + +/** + * Define a mutation in this Convex app's public API. + * + * This function will be allowed to modify your Convex database and will be accessible from the client. + * + * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument. + * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible. + */ +export declare const mutation: MutationBuilder; + +/** + * Define a mutation that is only accessible from other Convex functions (but not from the client). + * + * This function will be allowed to modify your Convex database. It will not be accessible from the client. + * + * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument. + * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible. + */ +export declare const internalMutation: MutationBuilder; + +/** + * Define an action in this Convex app's public API. + * + * An action is a function which can execute any JavaScript code, including non-deterministic + * code and code with side-effects, like calling third-party services. + * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive. + * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}. + * + * @param func - The action. It receives an {@link ActionCtx} as its first argument. + * @returns The wrapped action. Include this as an `export` to name it and make it accessible. + */ +export declare const action: ActionBuilder; + +/** + * Define an action that is only accessible from other Convex functions (but not from the client). + * + * @param func - The function. It receives an {@link ActionCtx} as its first argument. + * @returns The wrapped function. Include this as an `export` to name it and make it accessible. + */ +export declare const internalAction: ActionBuilder; + +/** + * Define an HTTP action. + * + * The wrapped function will be used to respond to HTTP requests received + * by a Convex deployment if the requests matches the path and method where + * this action is routed. Be sure to route your httpAction in `convex/http.js`. + * + * @param func - The function. It receives an {@link ActionCtx} as its first argument + * and a Fetch API `Request` object as its second. + * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up. + */ +export declare const httpAction: HttpActionBuilder; + +/** + * A set of services for use within Convex query functions. + * + * The query context is passed as the first argument to any Convex query + * function run on the server. + * + * This differs from the {@link MutationCtx} because all of the services are + * read-only. + */ +export type QueryCtx = GenericQueryCtx; + +/** + * A set of services for use within Convex mutation functions. + * + * The mutation context is passed as the first argument to any Convex mutation + * function run on the server. + */ +export type MutationCtx = GenericMutationCtx; + +/** + * A set of services for use within Convex action functions. + * + * The action context is passed as the first argument to any Convex action + * function run on the server. + */ +export type ActionCtx = GenericActionCtx; + +/** + * An interface to read from the database within Convex query functions. + * + * The two entry points are {@link DatabaseReader.get}, which fetches a single + * document by its {@link Id}, or {@link DatabaseReader.query}, which starts + * building a query. + */ +export type DatabaseReader = GenericDatabaseReader; + +/** + * An interface to read from and write to the database within Convex mutation + * functions. + * + * Convex guarantees that all writes within a single mutation are + * executed atomically, so you never have to worry about partial writes leaving + * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control) + * for the guarantees Convex provides your functions. + */ +export type DatabaseWriter = GenericDatabaseWriter; diff --git a/convex/_generated/server.js b/convex/_generated/server.js new file mode 100644 index 0000000..bf3d25a --- /dev/null +++ b/convex/_generated/server.js @@ -0,0 +1,93 @@ +/* eslint-disable */ +/** + * Generated utilities for implementing server-side Convex query and mutation functions. + * + * THIS CODE IS AUTOMATICALLY GENERATED. + * + * To regenerate, run `npx convex dev`. + * @module + */ + +import { + actionGeneric, + httpActionGeneric, + queryGeneric, + mutationGeneric, + internalActionGeneric, + internalMutationGeneric, + internalQueryGeneric, +} from "convex/server"; + +/** + * Define a query in this Convex app's public API. + * + * This function will be allowed to read your Convex database and will be accessible from the client. + * + * @param func - The query function. It receives a {@link QueryCtx} as its first argument. + * @returns The wrapped query. Include this as an `export` to name it and make it accessible. + */ +export const query = queryGeneric; + +/** + * Define a query that is only accessible from other Convex functions (but not from the client). + * + * This function will be allowed to read from your Convex database. It will not be accessible from the client. + * + * @param func - The query function. It receives a {@link QueryCtx} as its first argument. + * @returns The wrapped query. Include this as an `export` to name it and make it accessible. + */ +export const internalQuery = internalQueryGeneric; + +/** + * Define a mutation in this Convex app's public API. + * + * This function will be allowed to modify your Convex database and will be accessible from the client. + * + * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument. + * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible. + */ +export const mutation = mutationGeneric; + +/** + * Define a mutation that is only accessible from other Convex functions (but not from the client). + * + * This function will be allowed to modify your Convex database. It will not be accessible from the client. + * + * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument. + * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible. + */ +export const internalMutation = internalMutationGeneric; + +/** + * Define an action in this Convex app's public API. + * + * An action is a function which can execute any JavaScript code, including non-deterministic + * code and code with side-effects, like calling third-party services. + * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive. + * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}. + * + * @param func - The action. It receives an {@link ActionCtx} as its first argument. + * @returns The wrapped action. Include this as an `export` to name it and make it accessible. + */ +export const action = actionGeneric; + +/** + * Define an action that is only accessible from other Convex functions (but not from the client). + * + * @param func - The function. It receives an {@link ActionCtx} as its first argument. + * @returns The wrapped function. Include this as an `export` to name it and make it accessible. + */ +export const internalAction = internalActionGeneric; + +/** + * Define an HTTP action. + * + * The wrapped function will be used to respond to HTTP requests received + * by a Convex deployment if the requests matches the path and method where + * this action is routed. Be sure to route your httpAction in `convex/http.js`. + * + * @param func - The function. It receives an {@link ActionCtx} as its first argument + * and a Fetch API `Request` object as its second. + * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up. + */ +export const httpAction = httpActionGeneric; diff --git a/convex/secrets.d.ts b/convex/secrets.d.ts new file mode 100644 index 0000000..5f0b086 --- /dev/null +++ b/convex/secrets.d.ts @@ -0,0 +1,14 @@ +export declare const getApiKeys: import("convex/server").RegisteredQuery<"public", {}, Promise<{ + spotifyClientId: string | undefined; + spotifyClientSecret: string | undefined; + openrouterApiKey: string | undefined; + openrouterModel: string; + nocodeSpotifyCloudName: string | undefined; + nocodeSpotifyToken: string | undefined; + tavilyApiKey: string | undefined; + acoustidApiKey: string | undefined; + groqApiKey: string | undefined; + groqModel: string; + discogsToken: string | undefined; +}>>; +//# sourceMappingURL=secrets.d.ts.map \ No newline at end of file diff --git a/convex/secrets.d.ts.map b/convex/secrets.d.ts.map new file mode 100644 index 0000000..62b4989 --- /dev/null +++ b/convex/secrets.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"secrets.d.ts","sourceRoot":"","sources":["secrets.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU;;;;;;;;;;;;GAiBrB,CAAC"} \ No newline at end of file diff --git a/convex/secrets.js b/convex/secrets.js new file mode 100644 index 0000000..ff1deda --- /dev/null +++ b/convex/secrets.js @@ -0,0 +1,20 @@ +import { query } from "./_generated/server.js"; +export const getApiKeys = query({ + args: {}, + handler: async () => { + return { + spotifyClientId: process.env.SPOTIFY_CLIENT_ID, + spotifyClientSecret: process.env.SPOTIFY_CLIENT_SECRET, + openrouterApiKey: process.env.OPENROUTER_API_KEY, + openrouterModel: process.env.OPENROUTER_MODEL || "z-ai/glm-4.5-air:free", + nocodeSpotifyCloudName: process.env.NOCODE_SPOTIFY_CLOUD_NAME, + nocodeSpotifyToken: process.env.NOCODE_SPOTIFY_TOKEN, + tavilyApiKey: process.env.TAVILY_API_KEY, + acoustidApiKey: process.env.ACOUSTID_API_KEY, + groqApiKey: process.env.GROQ_API_KEY, + groqModel: process.env.GROQ_MODEL || "qwen/qwen3-32b", + discogsToken: process.env.DISCOGS_TOKEN, + }; + }, +}); +//# sourceMappingURL=secrets.js.map \ No newline at end of file diff --git a/convex/secrets.js.map b/convex/secrets.js.map new file mode 100644 index 0000000..24d9b09 --- /dev/null +++ b/convex/secrets.js.map @@ -0,0 +1 @@ +{"version":3,"file":"secrets.js","sourceRoot":"","sources":["secrets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAE/C,MAAM,CAAC,MAAM,UAAU,GAAG,KAAK,CAAC;IAC5B,IAAI,EAAE,EAAE;IACR,OAAO,EAAE,KAAK,IAAI,EAAE;QAChB,OAAO;YACH,eAAe,EAAE,OAAO,CAAC,GAAG,CAAC,iBAAiB;YAC9C,mBAAmB,EAAE,OAAO,CAAC,GAAG,CAAC,qBAAqB;YACtD,gBAAgB,EAAE,OAAO,CAAC,GAAG,CAAC,kBAAkB;YAChD,eAAe,EAAE,OAAO,CAAC,GAAG,CAAC,gBAAgB,IAAI,uBAAuB;YACxE,sBAAsB,EAAE,OAAO,CAAC,GAAG,CAAC,yBAAyB;YAC7D,kBAAkB,EAAE,OAAO,CAAC,GAAG,CAAC,oBAAoB;YACpD,YAAY,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc;YACxC,cAAc,EAAE,OAAO,CAAC,GAAG,CAAC,gBAAgB;YAC5C,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,YAAY;YACpC,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,gBAAgB;YACrD,YAAY,EAAE,OAAO,CAAC,GAAG,CAAC,aAAa;SAC1C,CAAC;IACN,CAAC;CACJ,CAAC,CAAC"} \ No newline at end of file diff --git a/convex/secrets.ts b/convex/secrets.ts new file mode 100644 index 0000000..37570f8 --- /dev/null +++ b/convex/secrets.ts @@ -0,0 +1,20 @@ +import { query } from "./_generated/server.js"; + +export const getApiKeys = query({ + args: {}, + handler: async () => { + return { + spotifyClientId: process.env.SPOTIFY_CLIENT_ID, + spotifyClientSecret: process.env.SPOTIFY_CLIENT_SECRET, + openrouterApiKey: process.env.OPENROUTER_API_KEY, + openrouterModel: process.env.OPENROUTER_MODEL || "z-ai/glm-4.5-air:free", + nocodeSpotifyCloudName: process.env.NOCODE_SPOTIFY_CLOUD_NAME, + nocodeSpotifyToken: process.env.NOCODE_SPOTIFY_TOKEN, + tavilyApiKey: process.env.TAVILY_API_KEY, + acoustidApiKey: process.env.ACOUSTID_API_KEY, + groqApiKey: process.env.GROQ_API_KEY, + groqModel: process.env.GROQ_MODEL || "qwen/qwen3-32b", + discogsToken: process.env.DISCOGS_TOKEN, + }; + }, +}); diff --git a/convex/tsconfig.json b/convex/tsconfig.json new file mode 100644 index 0000000..7374127 --- /dev/null +++ b/convex/tsconfig.json @@ -0,0 +1,25 @@ +{ + /* This TypeScript project config describes the environment that + * Convex functions run in and is used to typecheck them. + * You can modify it, but some settings are required to use Convex. + */ + "compilerOptions": { + /* These settings are not required by Convex and can be modified. */ + "allowJs": true, + "strict": true, + "moduleResolution": "Bundler", + "jsx": "react-jsx", + "skipLibCheck": true, + "allowSyntheticDefaultImports": true, + + /* These compiler options are required by Convex */ + "target": "ESNext", + "lib": ["ES2021", "dom"], + "forceConsistentCasingInFileNames": true, + "module": "ESNext", + "isolatedModules": true, + "noEmit": true + }, + "include": ["./**/*"], + "exclude": ["./_generated"] +} diff --git a/desktop-app/electron.vite.config.ts b/desktop-app/electron.vite.config.ts index 23cded8..909ed41 100644 --- a/desktop-app/electron.vite.config.ts +++ b/desktop-app/electron.vite.config.ts @@ -12,17 +12,7 @@ export default defineConfig({ } }, define: { - '__ENV_SPOTIFY_CLIENT_ID__': JSON.stringify(process.env.SPOTIFY_CLIENT_ID || ''), - '__ENV_SPOTIFY_CLIENT_SECRET__': JSON.stringify(process.env.SPOTIFY_CLIENT_SECRET || ''), - '__ENV_OPENROUTER_API_KEY__': JSON.stringify(process.env.OPENROUTER_API_KEY || ''), - '__ENV_OPENROUTER_MODEL__': JSON.stringify(process.env.OPENROUTER_MODEL || ''), - '__ENV_NOCODE_SPOTIFY_CLOUD_NAME__': JSON.stringify(process.env.NOCODE_SPOTIFY_CLOUD_NAME || ''), - '__ENV_NOCODE_SPOTIFY_TOKEN__': JSON.stringify(process.env.NOCODE_SPOTIFY_TOKEN || ''), - '__ENV_TAVILY_API_KEY__': JSON.stringify(process.env.TAVILY_API_KEY || ''), - '__ENV_ACOUSTID_API_KEY__': JSON.stringify(process.env.ACOUSTID_API_KEY || ''), - '__ENV_DISCOGS_TOKEN__': JSON.stringify(process.env.DISCOGS_TOKEN || ''), - '__ENV_GROQ_API_KEY__': JSON.stringify(process.env.GROQ_API_KEY || ''), - '__ENV_GROQ_MODEL__': JSON.stringify(process.env.GROQ_MODEL || ''), + '__ENV_CONVEX_URL__': JSON.stringify(process.env.CONVEX_URL || ''), } }, preload: { diff --git a/desktop-app/package.json b/desktop-app/package.json index 40c70cf..1659535 100644 --- a/desktop-app/package.json +++ b/desktop-app/package.json @@ -41,6 +41,10 @@ { "from": "../node_modules", "to": "cli-dist/node_modules" + }, + { + "from": "../convex", + "to": "cli-dist/convex" } ], "win": { diff --git a/desktop-app/src/main/index.ts b/desktop-app/src/main/index.ts index db0e672..faaf4fb 100644 --- a/desktop-app/src/main/index.ts +++ b/desktop-app/src/main/index.ts @@ -8,39 +8,13 @@ const __dirname = dirname(fileURLToPath(import.meta.url)) /* ────────────────────────────────────────────── * Compile-time env injection (populated by electron-vite define) - * In dev mode these will be empty strings and dotenv handles it. - * In packaged builds these contain the real values from CI secrets. + * CONVEX_URL is safe to ship - API keys are fetched from Convex securely. * ────────────────────────────────────────────── */ -declare const __ENV_SPOTIFY_CLIENT_ID__: string -declare const __ENV_SPOTIFY_CLIENT_SECRET__: string -declare const __ENV_OPENROUTER_API_KEY__: string -declare const __ENV_OPENROUTER_MODEL__: string -declare const __ENV_NOCODE_SPOTIFY_CLOUD_NAME__: string -declare const __ENV_NOCODE_SPOTIFY_TOKEN__: string -declare const __ENV_TAVILY_API_KEY__: string -declare const __ENV_ACOUSTID_API_KEY__: string -declare const __ENV_DISCOGS_TOKEN__: string -declare const __ENV_GROQ_API_KEY__: string -declare const __ENV_GROQ_MODEL__: string +declare const __ENV_CONVEX_URL__: string function injectEnv() { - const vars: Record = { - SPOTIFY_CLIENT_ID: __ENV_SPOTIFY_CLIENT_ID__, - SPOTIFY_CLIENT_SECRET: __ENV_SPOTIFY_CLIENT_SECRET__, - OPENROUTER_API_KEY: __ENV_OPENROUTER_API_KEY__, - OPENROUTER_MODEL: __ENV_OPENROUTER_MODEL__, - NOCODE_SPOTIFY_CLOUD_NAME: __ENV_NOCODE_SPOTIFY_CLOUD_NAME__, - NOCODE_SPOTIFY_TOKEN: __ENV_NOCODE_SPOTIFY_TOKEN__, - TAVILY_API_KEY: __ENV_TAVILY_API_KEY__, - ACOUSTID_API_KEY: __ENV_ACOUSTID_API_KEY__, - DISCOGS_TOKEN: __ENV_DISCOGS_TOKEN__, - GROQ_API_KEY: __ENV_GROQ_API_KEY__, - GROQ_MODEL: __ENV_GROQ_MODEL__, - } - for (const [key, value] of Object.entries(vars)) { - if (value && !process.env[key]) { - process.env[key] = value - } + if (__ENV_CONVEX_URL__ && !process.env.CONVEX_URL) { + process.env.CONVEX_URL = __ENV_CONVEX_URL__ } } @@ -180,9 +154,9 @@ ipcMain.handle('check:run', async (_event, trackInput: string) => { const configUrl = pathToFileURL(join(cliDist, 'dist/config/index.js')).href const { PipelineRunner } = await import(runnerUrl) - const { getConfig } = await import(configUrl) + const { getConfigAsync } = await import(configUrl) - const config = getConfig() + const config = await getConfigAsync() const pipeline = new PipelineRunner(config) const sendProgress = (event: PipelineEvent) => { @@ -209,10 +183,10 @@ ipcMain.handle('spotify:search', async (_event, query: string) => { const configUrl = pathToFileURL(join(cliDist, 'dist/config/index.js')).href const spotifyUrl = pathToFileURL(join(cliDist, 'dist/services/spotify.js')).href - const { getConfig } = await import(configUrl) + const { getConfigAsync } = await import(configUrl) const { getSpotifyToken, searchTracks } = await import(spotifyUrl) - const config = getConfig() + const config = await getConfigAsync() const token = await getSpotifyToken(config.spotify.clientId, config.spotify.clientSecret) const results = await searchTracks(query, token) diff --git a/package-lock.json b/package-lock.json index f0bbb1a..5de6513 100644 --- a/package-lock.json +++ b/package-lock.json @@ -15,6 +15,7 @@ "chalk": "^5.4.1", "cheerio": "^1.0.0", "commander": "^13.1.0", + "convex": "^1.32.0", "dotenv": "^16.4.7", "openai": "^6.25.0", "ora": "^8.2.0" @@ -1039,6 +1040,497 @@ "node": ">=18" } }, + "node_modules/convex": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/convex/-/convex-1.32.0.tgz", + "integrity": "sha512-5FlajdLpW75pdLS+/CgGH5H6yeRuA+ru50AKJEYbJpmyILUS+7fdTvsdTaQ7ZFXMv0gE8mX4S+S3AtJ94k0mfw==", + "license": "Apache-2.0", + "dependencies": { + "esbuild": "0.27.0", + "prettier": "^3.0.0", + "ws": "8.18.0" + }, + "bin": { + "convex": "bin/main.js" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=7.0.0" + }, + "peerDependencies": { + "@auth0/auth0-react": "^2.0.1", + "@clerk/clerk-react": "^4.12.8 || ^5.0.0", + "react": "^18.0.0 || ^19.0.0-0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@auth0/auth0-react": { + "optional": true + }, + "@clerk/clerk-react": { + "optional": true + }, + "react": { + "optional": true + } + } + }, + "node_modules/convex/node_modules/@esbuild/aix-ppc64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.0.tgz", + "integrity": "sha512-KuZrd2hRjz01y5JK9mEBSD3Vj3mbCvemhT466rSuJYeE/hjuBrHfjjcjMdTm/sz7au+++sdbJZJmuBwQLuw68A==", + "cpu": [ + "ppc64" + ], + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/android-arm": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.0.tgz", + "integrity": "sha512-j67aezrPNYWJEOHUNLPj9maeJte7uSMM6gMoxfPC9hOg8N02JuQi/T7ewumf4tNvJadFkvLZMlAq73b9uwdMyQ==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/android-arm64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.0.tgz", + "integrity": "sha512-CC3vt4+1xZrs97/PKDkl0yN7w8edvU2vZvAFGD16n9F0Cvniy5qvzRXjfO1l94efczkkQE6g1x0i73Qf5uthOQ==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/android-x64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.0.tgz", + "integrity": "sha512-wurMkF1nmQajBO1+0CJmcN17U4BP6GqNSROP8t0X/Jiw2ltYGLHpEksp9MpoBqkrFR3kv2/te6Sha26k3+yZ9Q==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/darwin-arm64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.0.tgz", + "integrity": "sha512-uJOQKYCcHhg07DL7i8MzjvS2LaP7W7Pn/7uA0B5S1EnqAirJtbyw4yC5jQ5qcFjHK9l6o/MX9QisBg12kNkdHg==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/darwin-x64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.0.tgz", + "integrity": "sha512-8mG6arH3yB/4ZXiEnXof5MK72dE6zM9cDvUcPtxhUZsDjESl9JipZYW60C3JGreKCEP+p8P/72r69m4AZGJd5g==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/freebsd-arm64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.0.tgz", + "integrity": "sha512-9FHtyO988CwNMMOE3YIeci+UV+x5Zy8fI2qHNpsEtSF83YPBmE8UWmfYAQg6Ux7Gsmd4FejZqnEUZCMGaNQHQw==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/freebsd-x64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.0.tgz", + "integrity": "sha512-zCMeMXI4HS/tXvJz8vWGexpZj2YVtRAihHLk1imZj4efx1BQzN76YFeKqlDr3bUWI26wHwLWPd3rwh6pe4EV7g==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/linux-arm": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.0.tgz", + "integrity": "sha512-t76XLQDpxgmq2cNXKTVEB7O7YMb42atj2Re2Haf45HkaUpjM2J0UuJZDuaGbPbamzZ7bawyGFUkodL+zcE+jvQ==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/linux-arm64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.0.tgz", + "integrity": "sha512-AS18v0V+vZiLJyi/4LphvBE+OIX682Pu7ZYNsdUHyUKSoRwdnOsMf6FDekwoAFKej14WAkOef3zAORJgAtXnlQ==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/linux-ia32": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.0.tgz", + "integrity": "sha512-Mz1jxqm/kfgKkc/KLHC5qIujMvnnarD9ra1cEcrs7qshTUSksPihGrWHVG5+osAIQ68577Zpww7SGapmzSt4Nw==", + "cpu": [ + "ia32" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/linux-loong64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.0.tgz", + "integrity": "sha512-QbEREjdJeIreIAbdG2hLU1yXm1uu+LTdzoq1KCo4G4pFOLlvIspBm36QrQOar9LFduavoWX2msNFAAAY9j4BDg==", + "cpu": [ + "loong64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/linux-mips64el": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.0.tgz", + "integrity": "sha512-sJz3zRNe4tO2wxvDpH/HYJilb6+2YJxo/ZNbVdtFiKDufzWq4JmKAiHy9iGoLjAV7r/W32VgaHGkk35cUXlNOg==", + "cpu": [ + "mips64el" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/linux-ppc64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.0.tgz", + "integrity": "sha512-z9N10FBD0DCS2dmSABDBb5TLAyF1/ydVb+N4pi88T45efQ/w4ohr/F/QYCkxDPnkhkp6AIpIcQKQ8F0ANoA2JA==", + "cpu": [ + "ppc64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/linux-riscv64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.0.tgz", + "integrity": "sha512-pQdyAIZ0BWIC5GyvVFn5awDiO14TkT/19FTmFcPdDec94KJ1uZcmFs21Fo8auMXzD4Tt+diXu1LW1gHus9fhFQ==", + "cpu": [ + "riscv64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/linux-s390x": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.0.tgz", + "integrity": "sha512-hPlRWR4eIDDEci953RI1BLZitgi5uqcsjKMxwYfmi4LcwyWo2IcRP+lThVnKjNtk90pLS8nKdroXYOqW+QQH+w==", + "cpu": [ + "s390x" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/linux-x64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.0.tgz", + "integrity": "sha512-1hBWx4OUJE2cab++aVZ7pObD6s+DK4mPGpemtnAORBvb5l/g5xFGk0vc0PjSkrDs0XaXj9yyob3d14XqvnQ4gw==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/netbsd-arm64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.0.tgz", + "integrity": "sha512-6m0sfQfxfQfy1qRuecMkJlf1cIzTOgyaeXaiVaaki8/v+WB+U4hc6ik15ZW6TAllRlg/WuQXxWj1jx6C+dfy3w==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/netbsd-x64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.0.tgz", + "integrity": "sha512-xbbOdfn06FtcJ9d0ShxxvSn2iUsGd/lgPIO2V3VZIPDbEaIj1/3nBBe1AwuEZKXVXkMmpr6LUAgMkLD/4D2PPA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/openbsd-arm64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.0.tgz", + "integrity": "sha512-fWgqR8uNbCQ/GGv0yhzttj6sU/9Z5/Sv/VGU3F5OuXK6J6SlriONKrQ7tNlwBrJZXRYk5jUhuWvF7GYzGguBZQ==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/openbsd-x64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.0.tgz", + "integrity": "sha512-aCwlRdSNMNxkGGqQajMUza6uXzR/U0dIl1QmLjPtRbLOx3Gy3otfFu/VjATy4yQzo9yFDGTxYDo1FfAD9oRD2A==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/openharmony-arm64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.0.tgz", + "integrity": "sha512-nyvsBccxNAsNYz2jVFYwEGuRRomqZ149A39SHWk4hV0jWxKM0hjBPm3AmdxcbHiFLbBSwG6SbpIcUbXjgyECfA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/sunos-x64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.0.tgz", + "integrity": "sha512-Q1KY1iJafM+UX6CFEL+F4HRTgygmEW568YMqDA5UV97AuZSm21b7SXIrRJDwXWPzr8MGr75fUZPV67FdtMHlHA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/win32-arm64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.0.tgz", + "integrity": "sha512-W1eyGNi6d+8kOmZIwi/EDjrL9nxQIQ0MiGqe/AWc6+IaHloxHSGoeRgDRKHFISThLmsewZ5nHFvGFWdBYlgKPg==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/win32-ia32": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.0.tgz", + "integrity": "sha512-30z1aKL9h22kQhilnYkORFYt+3wp7yZsHWus+wSKAJR8JtdfI76LJ4SBdMsCopTR3z/ORqVu5L1vtnHZWVj4cQ==", + "cpu": [ + "ia32" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/@esbuild/win32-x64": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.0.tgz", + "integrity": "sha512-aIitBcjQeyOhMTImhLZmtxfdOcuNRpwlPNmlFKPcHQYPhEssw75Cl1TSXJXpMkzaua9FUetx/4OQKq7eJul5Cg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/convex/node_modules/esbuild": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.0.tgz", + "integrity": "sha512-jd0f4NHbD6cALCyGElNpGAOtWxSq46l9X/sWB0Nzd5er4Kz2YTm+Vl0qKFT9KUJvD8+fiO8AvoHhFvEatfVixA==", + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.27.0", + "@esbuild/android-arm": "0.27.0", + "@esbuild/android-arm64": "0.27.0", + "@esbuild/android-x64": "0.27.0", + "@esbuild/darwin-arm64": "0.27.0", + "@esbuild/darwin-x64": "0.27.0", + "@esbuild/freebsd-arm64": "0.27.0", + "@esbuild/freebsd-x64": "0.27.0", + "@esbuild/linux-arm": "0.27.0", + "@esbuild/linux-arm64": "0.27.0", + "@esbuild/linux-ia32": "0.27.0", + "@esbuild/linux-loong64": "0.27.0", + "@esbuild/linux-mips64el": "0.27.0", + "@esbuild/linux-ppc64": "0.27.0", + "@esbuild/linux-riscv64": "0.27.0", + "@esbuild/linux-s390x": "0.27.0", + "@esbuild/linux-x64": "0.27.0", + "@esbuild/netbsd-arm64": "0.27.0", + "@esbuild/netbsd-x64": "0.27.0", + "@esbuild/openbsd-arm64": "0.27.0", + "@esbuild/openbsd-x64": "0.27.0", + "@esbuild/openharmony-arm64": "0.27.0", + "@esbuild/sunos-x64": "0.27.0", + "@esbuild/win32-arm64": "0.27.0", + "@esbuild/win32-ia32": "0.27.0", + "@esbuild/win32-x64": "0.27.0" + } + }, "node_modules/css-select": { "version": "5.2.2", "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.2.2.tgz", @@ -1783,6 +2275,21 @@ "url": "https://github.com/fb55/entities?sponsor=1" } }, + "node_modules/prettier": { + "version": "3.8.1", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.8.1.tgz", + "integrity": "sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==", + "license": "MIT", + "bin": { + "prettier": "bin/prettier.cjs" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/prettier/prettier?sponsor=1" + } + }, "node_modules/proxy-from-env": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", @@ -1949,6 +2456,27 @@ "node": ">=18" } }, + "node_modules/ws": { + "version": "8.18.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.0.tgz", + "integrity": "sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, "node_modules/zod": { "version": "4.3.6", "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz", diff --git a/package.json b/package.json index 8b13966..b6a26be 100644 --- a/package.json +++ b/package.json @@ -29,6 +29,7 @@ "chalk": "^5.4.1", "cheerio": "^1.0.0", "commander": "^13.1.0", + "convex": "^1.32.0", "dotenv": "^16.4.7", "openai": "^6.25.0", "ora": "^8.2.0" diff --git a/src/agents/summary-agent.ts b/src/agents/summary-agent.ts index 52431b2..11aa809 100644 --- a/src/agents/summary-agent.ts +++ b/src/agents/summary-agent.ts @@ -63,8 +63,22 @@ Generate the JSON summary now.`; { model: config.openrouter.model } ); + let licensingUrl: string | null = null; + if (parsed.licensingUrl) { + try { + const trimmed = parsed.licensingUrl.trim(); + const url = new URL(trimmed); + if (url.protocol === 'https:') { + licensingUrl = trimmed; + } + } catch { + // Invalid URL, keep as null + } + } + return { ...parsed, + licensingUrl: licensingUrl ?? undefined, webSearchSources: webSearchResults, }; } catch (error) { diff --git a/src/config/index.ts b/src/config/index.ts index d6f8697..2006bf3 100644 --- a/src/config/index.ts +++ b/src/config/index.ts @@ -1,11 +1,12 @@ import dotenv from "dotenv"; import type { AppConfig } from "../types/index.js"; +import { fetchSecretsFromConvex } from "../utils/convex-client.js"; dotenv.config(); let _config: AppConfig | null = null; -export function validateConfig(): AppConfig { +function buildConfigFromEnv(): AppConfig { const missing: string[] = []; if (!process.env.SPOTIFY_CLIENT_ID) missing.push("SPOTIFY_CLIENT_ID"); @@ -31,6 +32,86 @@ export function validateConfig(): AppConfig { }, openrouter: { apiKey: process.env.OPENROUTER_API_KEY!, + model: process.env.OPENROUTER_MODEL || "z-ai/glm-4.5-air:free", + baseURL: "https://openrouter.ai/api/v1", + defaultHeaders: { + "HTTP-Referer": "https://github.com/osmium-cli/osmium", + "X-OpenRouter-Title": "Osmium CLI" + } + }, + acoustid: { + apiKey: process.env.ACOUSTID_API_KEY, + }, + discogs: { + token: process.env.DISCOGS_TOKEN, + }, + tavily: { + apiKey: process.env.TAVILY_API_KEY, + }, + ...(process.env.GROQ_API_KEY + ? { + groq: { + apiKey: process.env.GROQ_API_KEY, + model: process.env.GROQ_MODEL || "qwen/qwen3-32b", + baseURL: "https://api.groq.com/openai/v1", + }, + } + : {}), + }; +} + +function mergeConfigs(convexConfig: Partial | null, envConfig: AppConfig): AppConfig { + if (!convexConfig) return envConfig; + + return { + spotify: convexConfig.spotify || envConfig.spotify, + nocodeSpotify: convexConfig.nocodeSpotify || envConfig.nocodeSpotify, + openrouter: convexConfig.openrouter || envConfig.openrouter, + acoustid: convexConfig.acoustid || envConfig.acoustid, + discogs: convexConfig.discogs || envConfig.discogs, + tavily: convexConfig.tavily || envConfig.tavily, + groq: convexConfig.groq || envConfig.groq, + }; +} + +export async function validateConfigAsync(): Promise { + const convexConfig = await fetchSecretsFromConvex(); + + const missing: string[] = []; + + if (!convexConfig?.spotify?.clientId && !process.env.SPOTIFY_CLIENT_ID) { + missing.push("SPOTIFY_CLIENT_ID"); + } + if (!convexConfig?.spotify?.clientSecret && !process.env.SPOTIFY_CLIENT_SECRET) { + missing.push("SPOTIFY_CLIENT_SECRET"); + } + if (!convexConfig?.openrouter?.apiKey && !process.env.OPENROUTER_API_KEY) { + missing.push("OPENROUTER_API_KEY"); + } + if (!convexConfig?.nocodeSpotify?.cloudName && !process.env.NOCODE_SPOTIFY_CLOUD_NAME) { + missing.push("NOCODE_SPOTIFY_CLOUD_NAME"); + } + if (!convexConfig?.nocodeSpotify?.token && !process.env.NOCODE_SPOTIFY_TOKEN) { + missing.push("NOCODE_SPOTIFY_TOKEN"); + } + + if (missing.length > 0) { + throw new Error( + `Missing required environment variables:\n${missing.map((k) => ` • ${k}`).join("\n")}\n\nSet them in Convex or in your .env file.` + ); + } + + const envConfig: AppConfig = { + spotify: { + clientId: process.env.SPOTIFY_CLIENT_ID || "", + clientSecret: process.env.SPOTIFY_CLIENT_SECRET || "", + }, + nocodeSpotify: { + cloudName: process.env.NOCODE_SPOTIFY_CLOUD_NAME || "", + token: process.env.NOCODE_SPOTIFY_TOKEN || "", + }, + openrouter: { + apiKey: process.env.OPENROUTER_API_KEY || "", model: process.env.OPENROUTER_MODEL || "openai/gpt-4o", baseURL: "https://openrouter.ai/api/v1", defaultHeaders: { @@ -57,14 +138,22 @@ export function validateConfig(): AppConfig { } : {}), }; + + return mergeConfigs(convexConfig, envConfig); +} + +export function validateConfig(): AppConfig { + return buildConfigFromEnv(); +} + +export async function getConfigAsync(): Promise { + if (_config) return _config; + _config = await validateConfigAsync(); + return _config; } -/** - * Lazy config getter — only validates on first access so CLI --help works without .env - */ export function getConfig(): AppConfig { - if (!_config) { - _config = validateConfig(); - } + if (_config) return _config; + _config = validateConfig(); return _config; } diff --git a/src/index.ts b/src/index.ts index f44bf08..a120b09 100644 --- a/src/index.ts +++ b/src/index.ts @@ -4,7 +4,7 @@ import { Command } from "commander"; import chalk from "chalk"; import ora from "ora"; import { writeFile } from "node:fs/promises"; -import { getConfig } from "./config/index.js"; +import { getConfigAsync } from "./config/index.js"; import { getSpotifyToken, searchTracks } from "./services/spotify.js"; import { getPlaylistTracksViaNoCodeAPI } from "./services/nocode-spotify.js"; import { PipelineRunner } from "./pipeline/runner.js"; @@ -48,7 +48,7 @@ async function runCheck(track: string, options: { output?: string; verbose?: boo }).start(); try { - const config = getConfig(); + const config = await getConfigAsync(); const pipeline = new PipelineRunner(config); // Listen for progress events @@ -146,7 +146,7 @@ program const spinner = ora({ text: "Loading playlist...", color: "yellow" }).start(); try { - const config = getConfig(); + const config = await getConfigAsync(); const playlistId = parsePlaylistInput(playlistInput); const playlist = await getPlaylistTracksViaNoCodeAPI( @@ -543,7 +543,7 @@ program const spinner = ora({ text: "Searching Spotify...", color: "yellow" }).start(); try { - const config = getConfig(); + const config = await getConfigAsync(); const token = await getSpotifyToken(config.spotify.clientId, config.spotify.clientSecret); const results = await searchTracks(query, token); spinner.stop(); diff --git a/src/utils/convex-client.ts b/src/utils/convex-client.ts new file mode 100644 index 0000000..ab43b91 --- /dev/null +++ b/src/utils/convex-client.ts @@ -0,0 +1,66 @@ +import { ConvexHttpClient } from "convex/browser"; +import type { AppConfig } from "../types/index.js"; + +declare global { + var _convexClient: ConvexHttpClient | undefined; +} + +let convexClient: ConvexHttpClient | null = null; + +export function getConvexClient(): ConvexHttpClient | null { + if (convexClient) return convexClient; + + const convexUrl = process.env.CONVEX_URL; + if (!convexUrl) return null; + + convexClient = new ConvexHttpClient(convexUrl); + return convexClient; +} + +export async function fetchSecretsFromConvex(): Promise | null> { + const client = getConvexClient(); + if (!client) return null; + + try { + const { api } = await import("../../convex/_generated/api.js"); + const secrets = await client.query(api.secrets.getApiKeys); + + if (!secrets) return null; + + return { + spotify: secrets.spotifyClientId && secrets.spotifyClientSecret ? { + clientId: secrets.spotifyClientId, + clientSecret: secrets.spotifyClientSecret, + } : undefined, + nocodeSpotify: secrets.nocodeSpotifyCloudName && secrets.nocodeSpotifyToken ? { + cloudName: secrets.nocodeSpotifyCloudName, + token: secrets.nocodeSpotifyToken, + } : undefined, + openrouter: secrets.openrouterApiKey ? { + apiKey: secrets.openrouterApiKey, + model: secrets.openrouterModel || "openai/gpt-4o", + baseURL: "https://openrouter.ai/api/v1", + defaultHeaders: { + "HTTP-Referer": "https://github.com/osmium-cli/osmium", + "X-OpenRouter-Title": "Osmium CLI", + }, + } : undefined, + acoustid: secrets.acoustidApiKey ? { + apiKey: secrets.acoustidApiKey, + } : undefined, + discogs: secrets.discogsToken ? { + token: secrets.discogsToken, + } : undefined, + tavily: secrets.tavilyApiKey ? { + apiKey: secrets.tavilyApiKey, + } : undefined, + groq: secrets.groqApiKey ? { + apiKey: secrets.groqApiKey, + model: secrets.groqModel || "qwen/qwen3-32b", + baseURL: "https://api.groq.com/openai/v1", + } : undefined, + } as Partial; + } catch { + return null; + } +} From eadd6777790c14150809e07f6c8676af2ef10c1c Mon Sep 17 00:00:00 2001 From: Coder-soft Date: Sun, 8 Mar 2026 00:23:06 +0500 Subject: [PATCH 8/8] update workflow --- .github/workflows/release.yml | 31 +++++++++++++++++++++++++++++-- 1 file changed, 29 insertions(+), 2 deletions(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index f0f3af4..d6aa4be 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -1,7 +1,9 @@ -name: Release +name: CI/Release on: push: + branches: + - '**' tags: - 'v*' @@ -12,9 +14,31 @@ env: NODE_VERSION: '20' jobs: - # ─── CLI Release ─────────────────────────────────────── + # ─── CI (runs on every push) ───────────────────────────── + ci: + name: Build & Test + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-node@v4 + with: + node-version: ${{ env.NODE_VERSION }} + + - name: Install dependencies + run: npm ci + + - name: Build CLI + run: npm run build + + - name: Typecheck + run: npm run typecheck + + # ─── CLI Release (v* tags only) ────────────────────────── release-cli: name: Release CLI + needs: ci + if: startsWith(github.ref, 'refs/tags/v') runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 @@ -41,6 +65,8 @@ jobs: # ─── Desktop Release ─────────────────────────────────── release-desktop: name: Desktop (${{ matrix.os }}) + needs: ci + if: startsWith(github.ref, 'refs/tags/v') runs-on: ${{ matrix.os }} strategy: fail-fast: false @@ -94,3 +120,4 @@ jobs: desktop-app/dist/*.deb desktop-app/dist/*.zip desktop-app/dist/*.tar.gz +