diff --git a/src/seqta/ui/themes/downloadTheme.ts b/src/seqta/ui/themes/downloadTheme.ts index 630cb624..2c277a57 100644 --- a/src/seqta/ui/themes/downloadTheme.ts +++ b/src/seqta/ui/themes/downloadTheme.ts @@ -1,7 +1,14 @@ import localforage from 'localforage'; -import type { Theme } from '@/old-interface/pages/Store'; import base64ToBlob from '@/seqta/utils/base64ToBlob'; +type Theme = { + name: string; + description: string; + coverImage: string; + marqueeImage: string; + id: string; +} + type ThemeContent = { id: string; name: string; @@ -14,6 +21,11 @@ type ThemeContent = { images: { id: string, variableName: string, data: string }[]; // data: base64 }; +function stripBase64Prefix(base64String: string): string { + const prefixRegex = /^data:image\/\w+;base64,/; + return base64String.replace(prefixRegex, ''); +} + export const StoreDownloadTheme = async (theme: { themeContent: Theme }) => { if (!theme.themeContent.id) return; @@ -24,7 +36,8 @@ export const StoreDownloadTheme = async (theme: { themeContent: Theme }) => { }; export const InstallTheme = async (themeData: ThemeContent) => { - const coverImageBlob = base64ToBlob(themeData.coverImage); + const strippedCoverImage = stripBase64Prefix(themeData.coverImage); + const coverImageBlob = base64ToBlob(strippedCoverImage); const images = themeData.images.map((image) => ({ ...image, diff --git a/vite.config.ts.timestamp-1731648335376-74d7c6bd758ba8.mjs b/vite.config.ts.timestamp-1731648335376-74d7c6bd758ba8.mjs new file mode 100644 index 00000000..bac2f90b --- /dev/null +++ b/vite.config.ts.timestamp-1731648335376-74d7c6bd758ba8.mjs @@ -0,0 +1,330 @@ +// vite.config.ts +import { defineConfig } from "file:///Users/sethburkart/Documents/Coding/betterseqta-plus/node_modules/vite/dist/node/index.js"; +import { join, resolve } from "path"; + +// lib/patchPackage.ts +import path from "node:path"; +import fs from "fs"; +import "file:///Users/sethburkart/Documents/Coding/betterseqta-plus/node_modules/vite/dist/node/index.js"; +import "file:///Users/sethburkart/Documents/Coding/betterseqta-plus/node_modules/@crxjs/vite-plugin/dist/index.mjs"; +var manifestPath = path.resolve("dist/chrome/manifest.json"); +function updateManifestPlugin() { + return { + name: "update-manifest-plugin", + enforce: "post", + closeBundle() { + forceDisableUseDynamicUrl(); + }, + configureServer(server) { + server.httpServer?.once("listening", () => { + const updated = forceDisableUseDynamicUrl(); + if (updated) { + server.ws.send({ type: "full-reload" }); + console.log("** updated **"); + } + fs.watchFile(manifestPath, () => { + console.log("** watchFile ** "); + const manifestContents = JSON.parse(fs.readFileSync(manifestPath, "utf8")); + if (manifestContents.web_accessible_resources.some((resource) => resource.use_dynamic_url)) { + const updated2 = forceDisableUseDynamicUrl(); + if (updated2) { + server.ws.send({ type: "full-reload" }); + console.log("** updated **"); + } + } + }); + }); + }, + writeBundle() { + console.log("### writeBundle ##"); + forceDisableUseDynamicUrl(); + } + }; +} +function forceDisableUseDynamicUrl() { + if (!fs.existsSync(manifestPath)) { + return false; + } + const manifestContents = JSON.parse(fs.readFileSync(manifestPath, "utf8")); + if (typeof manifestContents === "function" || !manifestContents.web_accessible_resources) return false; + if (manifestContents.web_accessible_resources.every((resource) => !resource.use_dynamic_url)) return false; + manifestContents.web_accessible_resources.forEach((resource) => { + if (resource.use_dynamic_url) resource.use_dynamic_url = false; + }); + fs.writeFileSync(manifestPath, JSON.stringify(manifestContents, null, 2)); + return true; +} + +// lib/base64loader.ts +import fs2 from "fs"; +import mime from "file:///Users/sethburkart/Documents/Coding/betterseqta-plus/node_modules/mime-types/index.js"; +var base64Loader = { + name: "base64-loader", + transform(_, id) { + const [filePath, query] = id.split("?"); + if (query !== "base64") return null; + const data = fs2.readFileSync(filePath, { encoding: "base64" }); + const mimeType = mime.lookup(filePath); + const dataURL = `data:${mimeType};base64,${data}`; + return `export default '${dataURL}';`; + } +}; + +// vite.config.ts +import react from "file:///Users/sethburkart/Documents/Coding/betterseqta-plus/node_modules/@vitejs/plugin-react/dist/index.mjs"; +import million from "file:///Users/sethburkart/Documents/Coding/betterseqta-plus/node_modules/million/dist/packages/compiler.mjs"; +import { svelte } from "file:///Users/sethburkart/Documents/Coding/betterseqta-plus/node_modules/@sveltejs/vite-plugin-svelte/src/index.js"; + +// lib/createManifest.ts +function createManifest(manifest, browser) { + return { + manifest, + browser + }; +} + +// src/manifests/manifest.json +var manifest_default = { + manifest_version: 3, + name: "BetterSEQTA+", + version: "3.4.0", + description: "Enhance SEQTA Learn's usability and aesthetics! A fork of BetterSEQTA to continue development add add heaps more features!", + icons: { + "32": "resources/icons/icon-32.png", + "48": "resources/icons/icon-48.png", + "64": "resources/icons/icon-64.png" + }, + action: { + browser_style: true, + default_popup: "interface/index.html#settings", + default_icon: { + "32": "resources/icons/icon-32.png", + "48": "resources/icons/icon-48.png", + "64": "resources/icons/icon-64.png" + } + }, + permissions: ["tabs", "notifications", "storage"], + host_permissions: ["https://newsapi.org/", "*://*/*"], + background: { + service_worker: "background.ts" + }, + content_security_policy: { + extension_pages: "script-src 'self'; object-src 'self'" + }, + content_scripts: [ + { + matches: ["*://*/*"], + js: ["SEQTA.ts"], + run_at: "document_start" + } + ], + web_accessible_resources: [ + { + resources: ["*://*/*"], + matches: ["*://*/*"] + }, + { + resources: ["resources/icons/*"], + matches: ["*://*/*"] + } + ] +}; + +// src/manifests/chrome.ts +var chrome = createManifest(manifest_default, "chrome"); + +// src/manifests/brave.ts +var brave = createManifest(manifest_default, "brave"); + +// src/manifests/edge.ts +var edge = createManifest(manifest_default, "edge"); + +// package.json +var package_default = { + name: "betterseqtaplus", + version: "3.4.0", + type: "module", + description: "Enhance SEQTA Learn's usability and aesthetics! A fork of BetterSEQTA to continue development, while incorporating a plethora of new and improved features!", + browserslist: "> 0.5%, last 2 versions, not dead", + scripts: { + dev: "cross-env MODE=chrome vite dev", + "dev:firefox": "cross-env MODE=firefox vite build --watch", + build: "cross-env MODE=chrome vite build && cross-env MODE=firefox vite build", + "build:chrome": "cross-env MODE=chrome vite build", + "build:firefox": "cross-env MODE=firefox vite build", + "build:safari": "cross-env MODE=safari vite build", + "convert:safari": "xcrun safari-web-extension-converter dist/safari --project-location . --app-name $npm_package_name-safari", + release: "gh release create $npm_package_name@$npm_package_version ./dist/*.zip --generate-notes", + publish: "bun lib/publish.js --b", + zip: "bedframe zip" + }, + targets: { + prod: { + sourceMap: { + inline: false + } + } + }, + keywords: [], + author: { + name: "SethBurkart123", + email: "betterseqta@betterseqta.com", + url: "https://github.com/BetterSEQTA/BetterSEQTA-plus" + }, + license: "MIT", + devDependencies: { + "@crxjs/vite-plugin": "2.0.0-beta.25", + "@types/mime-types": "^2.1.4", + "@vitejs/plugin-react-swc": "^3.7.0", + "cross-env": "^7.0.3", + eslint: "^8.57.0", + glob: "^11.0.0", + "mime-types": "^2.1.35", + prettier: "^3.3.3", + process: "^0.11.10", + sass: "^1.78.0", + "sass-loader": "^13.3.3", + semver: "^7.6.3", + url: "^0.11.4" + }, + dependencies: { + "@bedframe/cli": "^0.0.85", + "@codemirror/lang-css": "^6.3.0", + "@codemirror/lang-less": "^6.0.2", + "@codemirror/theme-one-dark": "^6.1.2", + "@sveltejs/vite-plugin-svelte": "^4.0.0", + "@tailwindcss/forms": "^0.5.9", + "@tsconfig/svelte": "^5.0.4", + "@types/chrome": "^0.0.270", + "@types/color": "^3.0.6", + "@types/dompurify": "^3.0.5", + "@types/lodash": "^4.17.7", + "@types/node": "^20.16.5", + "@types/react": "17", + "@types/react-dom": "17", + "@types/sortablejs": "^1.15.8", + "@types/uuid": "^9.0.8", + "@types/webextension-polyfill": "^0.10.7", + "@uiw/codemirror-extensions-color": "^4.23.3", + "@uiw/codemirror-theme-github": "^4.23.3", + "@vitejs/plugin-react": "^4.3.1", + autoprefixer: "^10.4.20", + classnames: "^2.5.1", + codemirror: "^6.0.1", + color: "^4.2.3", + dompurify: "^3.1.6", + "embla-carousel-autoplay": "^8.3.1", + "embla-carousel-svelte": "^8.3.1", + "fuse.js": "^7.0.0", + idb: "^8.0.0", + kolorist: "^1.8.0", + localforage: "^1.10.0", + lodash: "^4.17.21", + million: "^3.1.11", + motion: "^10.18.0", + postcss: "^8.4.45", + "publish-browser-extension": "^2.2.1", + react: "17", + "react-best-gradient-color-picker": "^3.0.10", + "react-dom": "17", + sortablejs: "^1.15.3", + svelte: "^5.1.9", + tailwindcss: "^3.4.11", + typescript: "^5.6.2", + uuid: "^9.0.1", + vite: "^5.4.4", + "webextension-polyfill": "^0.10.0" + } +}; + +// src/manifests/firefox.ts +var updatedFirefoxManifest = { + ...manifest_default, + background: { + scripts: [manifest_default.background.service_worker] + }, + action: { + "default_popup": "interface/index.html#settings" + }, + browser_specific_settings: { + gecko: { + id: package_default.author.email + } + } +}; +var firefox = createManifest(updatedFirefoxManifest, "firefox"); + +// src/manifests/opera.ts +var opera = createManifest(manifest_default, "opera"); + +// src/manifests/safari.ts +var updatedSafariManifest = { + ...manifest_default, + browser_specific_settings: { + safari: { + strict_min_version: "15.4", + strict_max_version: "*" + } + // ^^^ https://developer.apple.com/documentation/safariservices/safari_web_extensions/optimizing_your_web_extension_for_safari#3743239 + // https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/browser_specific_settings#safari_properties + } +}; +var safari = createManifest(updatedSafariManifest, "safari"); + +// vite.config.ts +import { crx } from "file:///Users/sethburkart/Documents/Coding/betterseqta-plus/node_modules/@crxjs/vite-plugin/dist/index.mjs"; +var __vite_injected_original_dirname = "/Users/sethburkart/Documents/Coding/betterseqta-plus"; +var targets = [ + chrome, + brave, + edge, + firefox, + opera, + safari +]; +var mode = process.env.MODE || "chrome"; +var vite_config_default = defineConfig({ + plugins: [ + base64Loader, + react(), + svelte({ + emitCss: false + }), + million.vite({ auto: true }), + //MillionLint.vite(), /* enable for testing and debugging performance */ + crx({ + manifest: targets.find((t) => t.browser === mode.toLowerCase())?.manifest ?? chrome.manifest, + browser: mode.toLowerCase() === "firefox" ? "firefox" : "chrome" + }), + updateManifestPlugin() + ], + root: resolve(__vite_injected_original_dirname, "./src"), + resolve: { + alias: { + "@": resolve(__vite_injected_original_dirname, "./src") + } + }, + server: { + port: 5173, + hmr: { + host: "localhost", + protocol: "ws", + port: 5173 + } + }, + build: { + outDir: resolve(__vite_injected_original_dirname, "dist", mode), + emptyOutDir: false, + minify: false, + rollupOptions: { + input: { + settings: join(__vite_injected_original_dirname, "src", "interface", "index.html"), + migration: join(__vite_injected_original_dirname, "src", "seqta", "utils", "migration", "migrate.html") + } + } + } +}); +export { + vite_config_default as default +}; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["vite.config.ts", "lib/patchPackage.ts", "lib/base64loader.ts", "lib/createManifest.ts", "src/manifests/manifest.json", "src/manifests/chrome.ts", "src/manifests/brave.ts", "src/manifests/edge.ts", "package.json", "src/manifests/firefox.ts", "src/manifests/opera.ts", "src/manifests/safari.ts"],
  "sourcesContent": ["const __vite_injected_original_dirname = \"/Users/sethburkart/Documents/Coding/betterseqta-plus\";const __vite_injected_original_filename = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/vite.config.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/sethburkart/Documents/Coding/betterseqta-plus/vite.config.ts\";import { defineConfig } from 'vite';\nimport { join, resolve } from 'path';\n\nimport { updateManifestPlugin } from './lib/patchPackage';\nimport { base64Loader } from './lib/base64loader';\nimport type { BuildTarget } from './lib/types';\n\nimport react from '@vitejs/plugin-react';\nimport million from \"million/compiler\";\n//import MillionLint from '@million/lint';\n\nimport { svelte } from '@sveltejs/vite-plugin-svelte'\n\nimport { chrome } from './src/manifests/chrome';\nimport { brave } from './src/manifests/brave';\nimport { edge } from './src/manifests/edge';\nimport { firefox } from './src/manifests/firefox';\nimport { opera } from './src/manifests/opera';\nimport { safari } from './src/manifests/safari';\nimport { crx } from '@crxjs/vite-plugin';\n\nconst targets: BuildTarget[] = [\n  chrome, brave, edge, firefox, opera, safari\n]\n\nconst mode = process.env.MODE || 'chrome';\n\nexport default defineConfig({\n  plugins: [\n    base64Loader,\n    react(),\n    svelte({\n      emitCss: false\n    }),\n    million.vite({ auto: true }),\n    //MillionLint.vite(), /* enable for testing and debugging performance */\n    crx({\n      manifest: targets.find(t => t.browser === mode.toLowerCase())?.manifest ?? chrome.manifest,\n      browser: mode.toLowerCase() === \"firefox\" ? \"firefox\" : \"chrome\"\n    }),\n    updateManifestPlugin()\n  ],\n  root: resolve(__dirname, './src'),\n  resolve: {\n    alias: {\n      '@': resolve(__dirname, './src')\n    },\n  },\n  server: {\n    port: 5173,\n    hmr: {\n      host: \"localhost\",\n      protocol: \"ws\",\n      port: 5173\n    }\n  },\n  build: {\n    outDir: resolve(__dirname, 'dist', mode),\n    emptyOutDir: false,\n    minify: false,\n    rollupOptions: {\n      input: {\n        settings: join(__dirname, 'src', 'interface', 'index.html'),\n        migration: join(__dirname, 'src', 'seqta', 'utils', 'migration', 'migrate.html')\n      }\n    }\n  }\n});", "const __vite_injected_original_dirname = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/lib\";const __vite_injected_original_filename = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/lib/patchPackage.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/sethburkart/Documents/Coding/betterseqta-plus/lib/patchPackage.ts\";/* \n  TEMPORARY FIX FOR CHROME 130+ builds\n*/\n\nimport path from 'node:path';\nimport fs from 'fs';\nimport { PluginOption } from 'vite';\nimport { ManifestV3Export } from '@crxjs/vite-plugin';\n\nconst manifestPath = path.resolve('dist/chrome/manifest.json');\n\nexport function updateManifestPlugin(): PluginOption {\n  return {\n    name: 'update-manifest-plugin',\n    enforce: 'post',\n    closeBundle() {\n      forceDisableUseDynamicUrl();\n    },\n\n    configureServer(server) {\n      server.httpServer?.once('listening', () => {\n        const updated = forceDisableUseDynamicUrl();\n        if (updated) {\n          server.ws.send({ type: 'full-reload' });\n          console.log('** updated **');\n        }\n\n        fs.watchFile(manifestPath, () => {\n          console.log('** watchFile ** ');\n          const manifestContents = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));\n          if (manifestContents.web_accessible_resources.some((resource: any) => resource.use_dynamic_url)) {\n            const updated = forceDisableUseDynamicUrl();\n            if (updated) {\n              server.ws.send({ type: 'full-reload' });\n              console.log('** updated **');\n            }\n          }\n        });\n      });\n    },\n\n    writeBundle() {\n      console.log('### writeBundle ##');\n      forceDisableUseDynamicUrl();\n    },\n  };\n}\n\nfunction forceDisableUseDynamicUrl() {\n  if (!fs.existsSync(manifestPath)) {\n    return false;\n  }\n\n  const manifestContents = JSON.parse(fs.readFileSync(manifestPath, 'utf8')) as Awaited<ManifestV3Export>;\n\n  if (typeof manifestContents === 'function' || !manifestContents.web_accessible_resources) return false;\n  if (manifestContents.web_accessible_resources.every((resource) => !resource.use_dynamic_url)) return false;\n\n  manifestContents.web_accessible_resources.forEach((resource) => {\n    if (resource.use_dynamic_url) resource.use_dynamic_url = false;\n  });\n\n  fs.writeFileSync(manifestPath, JSON.stringify(manifestContents, null, 2));\n  return true;\n}\n", "const __vite_injected_original_dirname = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/lib\";const __vite_injected_original_filename = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/lib/base64loader.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/sethburkart/Documents/Coding/betterseqta-plus/lib/base64loader.ts\";import fs from \"fs\";\nimport mime from \"mime-types\";\n\nexport const base64Loader = {\n  name: \"base64-loader\",\n  transform(_: any, id: string) {\n    const [filePath, query] = id.split(\"?\");\n    if (query !== \"base64\") return null;\n\n    const data = fs.readFileSync(filePath, { encoding: 'base64' });\n    const mimeType = mime.lookup(filePath);\n    const dataURL = `data:${mimeType};base64,${data}`;\n\n    return `export default '${dataURL}';`;\n  },\n};", "const __vite_injected_original_dirname = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/lib\";const __vite_injected_original_filename = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/lib/createManifest.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/sethburkart/Documents/Coding/betterseqta-plus/lib/createManifest.ts\";import type { Browser, BuildTarget, Manifest } from './types'\nimport type { AnyCase } from './utils'\n/**\n *\n *\n * @export\n * @param {Manifest} manifest\n * @param {AnyCase<Browser>} browser\n * @return {*}  {@link BuildTarget}\n */\nexport function createManifest(\n  manifest: Manifest,\n  browser: AnyCase<Browser>,\n): BuildTarget {\n  return {\n    manifest,\n    browser,\n  }\n}\n\n/**\n * create a base Manifest to inherit from\n * type Manifest = chrome.runtime.ManifestV3\n *\n * use as shared base to extend inBrowser manifests\n *\n * @export\n * @param {Manifest} manifest\n * @return {*}  {@link Manifest}\n */\nexport function createManifestBase(manifest: Manifest): Manifest {\n  return manifest\n}", "{\n  \"manifest_version\": 3,\n  \"name\": \"BetterSEQTA+\",\n  \"version\": \"3.4.0\",\n  \"description\": \"Enhance SEQTA Learn's usability and aesthetics! A fork of BetterSEQTA to continue development add add heaps more features!\",\n  \"icons\": {\n    \"32\": \"resources/icons/icon-32.png\",\n    \"48\": \"resources/icons/icon-48.png\",\n    \"64\": \"resources/icons/icon-64.png\"\n  },\n  \"action\": {\n    \"browser_style\": true,\n    \"default_popup\": \"interface/index.html#settings\",\n    \"default_icon\": {\n      \"32\": \"resources/icons/icon-32.png\",\n      \"48\": \"resources/icons/icon-48.png\",\n      \"64\": \"resources/icons/icon-64.png\"\n    }\n  },\n  \"permissions\": [\"tabs\", \"notifications\", \"storage\"],\n  \"host_permissions\": [\"https://newsapi.org/\", \"*://*/*\"],\n  \"background\": {\n    \"service_worker\": \"background.ts\"\n  },\n  \"content_security_policy\": {\n    \"extension_pages\": \"script-src 'self'; object-src 'self'\"\n  },\n  \"content_scripts\": [\n    {\n      \"matches\": [\"*://*/*\"],\n      \"js\": [\"SEQTA.ts\"],\n      \"run_at\": \"document_start\"\n    }\n  ],\n  \"web_accessible_resources\": [\n    {\n      \"resources\": [\"*://*/*\"],\n      \"matches\": [\"*://*/*\"]\n    },\n    {\n      \"resources\": [\"resources/icons/*\"],\n      \"matches\": [\"*://*/*\"]\n    }\n  ]\n}\n", "const __vite_injected_original_dirname = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests\";const __vite_injected_original_filename = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests/chrome.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests/chrome.ts\";import { createManifest } from '../../lib/createManifest'\nimport baseManifest from './manifest.json'\n\nexport const chrome = createManifest(baseManifest, 'chrome')\n", "const __vite_injected_original_dirname = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests\";const __vite_injected_original_filename = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests/brave.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests/brave.ts\";import { createManifest } from '../../lib/createManifest'\nimport baseManifest from './manifest.json'\n\nexport const brave = createManifest(baseManifest, 'brave')\n", "const __vite_injected_original_dirname = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests\";const __vite_injected_original_filename = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests/edge.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests/edge.ts\";import { createManifest } from '../../lib/createManifest'\nimport baseManifest from './manifest.json'\n\nexport const edge = createManifest(baseManifest, 'edge')\n", "{\n  \"name\": \"betterseqtaplus\",\n  \"version\": \"3.4.0\",\n  \"type\": \"module\",\n  \"description\": \"Enhance SEQTA Learn's usability and aesthetics! A fork of BetterSEQTA to continue development, while incorporating a plethora of new and improved features!\",\n  \"browserslist\": \"> 0.5%, last 2 versions, not dead\",\n  \"scripts\": {\n    \"dev\": \"cross-env MODE=chrome vite dev\",\n    \"dev:firefox\": \"cross-env MODE=firefox vite build --watch\",\n    \"build\": \"cross-env MODE=chrome vite build && cross-env MODE=firefox vite build\",\n    \"build:chrome\": \"cross-env MODE=chrome vite build\",\n    \"build:firefox\": \"cross-env MODE=firefox vite build\",\n    \"build:safari\": \"cross-env MODE=safari vite build\",\n    \"convert:safari\": \"xcrun safari-web-extension-converter dist/safari --project-location . --app-name $npm_package_name-safari\",\n    \"release\": \"gh release create $npm_package_name@$npm_package_version ./dist/*.zip --generate-notes\",\n    \"publish\": \"bun lib/publish.js --b\",\n    \"zip\": \"bedframe zip\"\n  },\n  \"targets\": {\n    \"prod\": {\n      \"sourceMap\": {\n        \"inline\": false\n      }\n    }\n  },\n  \"keywords\": [],\n  \"author\": {\n    \"name\": \"SethBurkart123\",\n    \"email\": \"betterseqta@betterseqta.com\",\n    \"url\": \"https://github.com/BetterSEQTA/BetterSEQTA-plus\"\n  },\n  \"license\": \"MIT\",\n  \"devDependencies\": {\n    \"@crxjs/vite-plugin\": \"2.0.0-beta.25\",\n    \"@types/mime-types\": \"^2.1.4\",\n    \"@vitejs/plugin-react-swc\": \"^3.7.0\",\n    \"cross-env\": \"^7.0.3\",\n    \"eslint\": \"^8.57.0\",\n    \"glob\": \"^11.0.0\",\n    \"mime-types\": \"^2.1.35\",\n    \"prettier\": \"^3.3.3\",\n    \"process\": \"^0.11.10\",\n    \"sass\": \"^1.78.0\",\n    \"sass-loader\": \"^13.3.3\",\n    \"semver\": \"^7.6.3\",\n    \"url\": \"^0.11.4\"\n  },\n  \"dependencies\": {\n    \"@bedframe/cli\": \"^0.0.85\",\n    \"@codemirror/lang-css\": \"^6.3.0\",\n    \"@codemirror/lang-less\": \"^6.0.2\",\n    \"@codemirror/theme-one-dark\": \"^6.1.2\",\n    \"@sveltejs/vite-plugin-svelte\": \"^4.0.0\",\n    \"@tailwindcss/forms\": \"^0.5.9\",\n    \"@tsconfig/svelte\": \"^5.0.4\",\n    \"@types/chrome\": \"^0.0.270\",\n    \"@types/color\": \"^3.0.6\",\n    \"@types/dompurify\": \"^3.0.5\",\n    \"@types/lodash\": \"^4.17.7\",\n    \"@types/node\": \"^20.16.5\",\n    \"@types/react\": \"17\",\n    \"@types/react-dom\": \"17\",\n    \"@types/sortablejs\": \"^1.15.8\",\n    \"@types/uuid\": \"^9.0.8\",\n    \"@types/webextension-polyfill\": \"^0.10.7\",\n    \"@uiw/codemirror-extensions-color\": \"^4.23.3\",\n    \"@uiw/codemirror-theme-github\": \"^4.23.3\",\n    \"@vitejs/plugin-react\": \"^4.3.1\",\n    \"autoprefixer\": \"^10.4.20\",\n    \"classnames\": \"^2.5.1\",\n    \"codemirror\": \"^6.0.1\",\n    \"color\": \"^4.2.3\",\n    \"dompurify\": \"^3.1.6\",\n    \"embla-carousel-autoplay\": \"^8.3.1\",\n    \"embla-carousel-svelte\": \"^8.3.1\",\n    \"fuse.js\": \"^7.0.0\",\n    \"idb\": \"^8.0.0\",\n    \"kolorist\": \"^1.8.0\",\n    \"localforage\": \"^1.10.0\",\n    \"lodash\": \"^4.17.21\",\n    \"million\": \"^3.1.11\",\n    \"motion\": \"^10.18.0\",\n    \"postcss\": \"^8.4.45\",\n    \"publish-browser-extension\": \"^2.2.1\",\n    \"react\": \"17\",\n    \"react-best-gradient-color-picker\": \"^3.0.10\",\n    \"react-dom\": \"17\",\n    \"sortablejs\": \"^1.15.3\",\n    \"svelte\": \"^5.1.9\",\n    \"tailwindcss\": \"^3.4.11\",\n    \"typescript\": \"^5.6.2\",\n    \"uuid\": \"^9.0.1\",\n    \"vite\": \"^5.4.4\",\n    \"webextension-polyfill\": \"^0.10.0\"\n  }\n}\n", "const __vite_injected_original_dirname = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests\";const __vite_injected_original_filename = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests/firefox.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests/firefox.ts\";import { createManifest } from '../../lib/createManifest'\nimport baseManifest from './manifest.json'\nimport pkg from '../../package.json'\n\nconst updatedFirefoxManifest = {\n  ...baseManifest,\n  background: {\n    scripts: [baseManifest.background.service_worker],\n  },\n  action: {\n    \"default_popup\": \"interface/index.html#settings\",\n  },\n  browser_specific_settings: {\n    gecko: {\n      id: pkg.author.email,\n    },\n  }\n}\n\nexport const firefox = createManifest(updatedFirefoxManifest, 'firefox')\n", "const __vite_injected_original_dirname = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests\";const __vite_injected_original_filename = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests/opera.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests/opera.ts\";import { createManifest } from '../../lib/createManifest'\nimport baseManifest from './manifest.json'\n\nexport const opera = createManifest(baseManifest, 'opera')\n", "const __vite_injected_original_dirname = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests\";const __vite_injected_original_filename = \"/Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests/safari.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/sethburkart/Documents/Coding/betterseqta-plus/src/manifests/safari.ts\";import { createManifest } from '../../lib/createManifest'\nimport baseManifest from './manifest.json'\n\nconst updatedSafariManifest = {\n  ...baseManifest,\n  browser_specific_settings: {\n    safari: {\n      strict_min_version: '15.4',\n      strict_max_version: '*',\n    },\n    // ^^^ https://developer.apple.com/documentation/safariservices/safari_web_extensions/optimizing_your_web_extension_for_safari#3743239\n    //     https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/browser_specific_settings#safari_properties\n  },\n}\n\nexport const safari = createManifest(updatedSafariManifest, 'safari')\n"],
  "mappings": "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",
  "names": ["updated", "fs", "fs"]
}
