@hellpig/anarchy-shared 1.5.2 → 1.6.2

package/CHANGELOG.md

@@ -4,3 +4,4 @@
 - 1.3.0 Vite plugin: emit json
 - 1.4.0 Json validation utils
 - 1.5.0 Added proper building and npm packaging
+- 1.6.0 Fixes npm package

package/README.md

@@ -31,4 +31,4 @@ SOFTWARE.
 See local files `LICENSE`, `CHANGELOG`, `NOTICE` (pointer), and files in `./legal`:
 `DISCLAIMER`, `EULA`, `PRIVACY`, `SECURITY`, `NOTICE` (full), `THIRD_PARTY_LICENSES`.
 
-Contacts — Privacy: {{PRIVACY_EMAIL}}, Security: {{SECURITY_EMAIL}}.
+Contacts — Privacy: pnf036+anarchy@gmail.com, Security: pnf036+anarchy_security@gmail.com.

package/ScriptUtils/CheckMinify.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+
+JS_FILE="$1"
+MAP_FILE="$2"
+GZ_FILE="${JS_FILE}.gz"
+BR_FILE="${JS_FILE}.br"
+
+if [[ -z "$JS_FILE" || -z "$MAP_FILE" ]]; then
+  echo "❌ Usage: ./CheckMinify.sh path/to/file.js path/to/file.js.map"
+  exit 1
+fi
+
+if [[ ! -f "$JS_FILE" ]]; then
+  echo "❌ JS file not found: $JS_FILE"
+  exit 1
+fi
+
+if [[ ! -f "$MAP_FILE" ]]; then
+  echo "❌ Map file not found: $MAP_FILE"
+  exit 1
+fi
+
+#LINES=$(wc -l < "$JS_FILE")
+#if [[ "$LINES" -gt 50 ]]; then
+#  echo "❌ Too many lines in JS file ($LINES). Probably not minified."
+#  exit 1
+#else
+#  echo "✅ JS file appears minified ($LINES lines)"
+#fi
+
+if [[ -f "$GZ_FILE" ]]; then
+  gunzip -c "$GZ_FILE" | cmp -s - "$JS_FILE"
+  if [[ $? -ne 0 ]]; then
+    echo "❌ Gzip file doesn't match JS file"
+    exit 1
+  else
+    echo "✅ Gzip file matches"
+  fi
+else
+  echo "⚠️ Gzip file not found: $GZ_FILE"
+fi
+
+if [[ -f "$BR_FILE" ]]; then
+  brotli -d -c "$BR_FILE" | cmp -s - "$JS_FILE"
+  if [[ $? -ne 0 ]]; then
+    echo "❌ Brotli file doesn't match JS file"
+    exit 1
+  else
+    echo "✅ Brotli file matches"
+  fi
+else
+  echo "⚠️ Brotli file not found: $BR_FILE"
+fi
+
+echo "🔍 Checking sourcemap integrity..."
+
+TMP_JSON=$(mktemp -t sourcemapXXXXXX.json)
+
+SOURCEMAP_ERR=$(npx --yes source-map-explorer "$JS_FILE" "$MAP_FILE" --json "$TMP_JSON" 2>&1)
+echo "📄 Sourcemap analysis written to: $TMP_JSON"
+
+if [[ $? -eq 0 && -s "$TMP_JSON" ]]; then
+  echo "✅ Sourcemap check passed: $JS_FILE"
+  rm "$TMP_JSON"
+else
+  echo "❌ Failed to analyze sourcemap: $JS_FILE"
+  echo "🧾 stderr:"
+  echo "$SOURCEMAP_ERR"
+  [[ -f "$TMP_JSON" ]] && cat "$TMP_JSON"
+rm -f "$TMP_JSON"
+  exit 1
+fi
+
+echo "🎉 All checks passed"

package/ScriptUtils/CopyDir.js

@@ -0,0 +1,24 @@
+import { copy } from 'fs-extra';
+import { resolve } from 'path';
+
+const args = process.argv.slice(2);
+const fromArg = args.find((arg) => arg.startsWith('from='));
+const toArg = args.find((arg) => arg.startsWith('to='));
+
+const fromPath = resolve(process.cwd(), fromArg.split('=')[1]);
+const toPath = resolve(process.cwd(), toArg.split('=')[1]);
+
+console.log(`Copying files...\nFrom: ${fromPath}\nTo:   ${toPath}`);
+
+try {
+  await copy(fromPath, toPath, {
+    overwrite: true,
+    errorOnExist: false,
+    recursive: true
+  });
+
+  console.log('✅ Copy completed.');
+} catch (err) {
+  console.error('Copy failed:', err);
+  process.exit(1);
+}

package/ScriptUtils/CopyFiles.js

@@ -0,0 +1,40 @@
+import { copyFile, mkdir } from 'fs/promises';
+import { resolve, dirname } from 'path';
+
+const args = process.argv.slice(2);
+
+// last arg must be the destination (e.g. to=dist-app/draco)
+const toArg = args.find((arg) => arg.startsWith('to='));
+if (!toArg) {
+  console.error('❌ Missing argument: to=<destination folder>');
+  process.exit(1);
+}
+
+const toDir = resolve(process.cwd(), toArg.split('=')[1]);
+
+// all other args treated as relative file paths to copy
+const filePaths = args.filter((arg) => !arg.startsWith('to='));
+if (filePaths.length === 0) {
+  console.error('❌ No files to copy provided.');
+  process.exit(1);
+}
+
+console.log(`Copying files to: ${toDir}`);
+console.log(filePaths.map((f) => `  - ${f}`).join('\n'));
+
+(async () => {
+  try {
+    for (const relativePath of filePaths) {
+      const src = resolve(process.cwd(), relativePath);
+      const dest = resolve(toDir, relativePath.split('/').pop());
+
+      await mkdir(dirname(dest), { recursive: true });
+      await copyFile(src, dest);
+    }
+
+    console.log('✅ Files copied successfully.');
+  } catch (err) {
+    console.error('❌ Copy failed:', err);
+    process.exit(1);
+  }
+})();

package/ScriptUtils/EnvUtils.js

@@ -0,0 +1,55 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { config as dotenvConfig } from 'dotenv';
+import { expand as dotenvExpand } from 'dotenv-expand';
+
+export function buildEnvChain(mode) {
+  const chain = ['.env', '.env.local'];
+  const tokens = String(mode).split('.').filter(Boolean);
+  const first = tokens[0]?.toLowerCase();
+  const firstAlias = first === 'dev' ? 'development' : first === 'prod' ? 'production' : undefined;
+
+  const seqs = [tokens];
+  if (firstAlias && firstAlias !== first) seqs.push([firstAlias, ...tokens.slice(1)]);
+
+  for (const seq of seqs) {
+    const accum = [];
+    for (const p of seq) {
+      accum.push(p);
+      const key = accum.join('.');
+      chain.push(`.env.${key}`);
+      chain.push(`.env.${key}.local`);
+    }
+  }
+
+  return Array.from(new Set(chain));
+}
+
+export function loadModeEnv(mode, cwd = process.cwd()) {
+  const loadEnvFile = (file) => {
+    const full = path.resolve(cwd, file);
+    if (!fs.existsSync(full)) return false;
+    const result = dotenvConfig({ path: full, override: true });
+    if (result.parsed) dotenvExpand({ parsed: result.parsed });
+    return true;
+  };
+
+  const chain = buildEnvChain(mode);
+  for (const file of chain) loadEnvFile(file);
+}
+
+export function parseListEnv(val) {
+  if (!val) return [];
+  return String(val)
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+export function parseBoolEnv(val, defaultValue = false) {
+  if (val == null) return defaultValue;
+  const s = String(val).trim().toLowerCase();
+  if (s === '1' || s === 'true' || s === 'yes' || s === 'on') return true;
+  if (s === '0' || s === 'false' || s === 'no' || s === 'off') return false;
+  return defaultValue;
+}

package/ScriptUtils/GenerateVersionsFile.js

@@ -0,0 +1,43 @@
+import { writeFileSync, existsSync, readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const cwd = process.cwd();
+
+const args = process.argv.slice(2);
+const pkgArg = args.find((arg) => arg.startsWith('--pkg='));
+const outArg = args.find((arg) => arg.startsWith('--out='));
+
+const pkgPath = pkgArg ? resolve(cwd, pkgArg.split('=')[1]) : resolve(cwd, 'package.json');
+
+const outPath = outArg ? resolve(cwd, outArg.split('=')[1]) : resolve(cwd, './versions.ts');
+
+if (!existsSync(pkgPath)) {
+  console.error(`❌ package.json not found at: ${pkgPath}`);
+  process.exit(1);
+}
+
+const raw = readFileSync(pkgPath, 'utf8');
+let version;
+
+try {
+  const pkg = JSON.parse(raw);
+  version = pkg.version;
+} catch (err) {
+  console.error(`❌ Failed to parse package.json:`, err);
+  process.exit(1);
+}
+
+if (!version) {
+  console.error(`❌ "version" field not found in ${pkgPath}`);
+  process.exit(1);
+}
+
+const content = `// This file is auto-generated by GenerateVersionsFile.js
+// Do not edit manually. Run the script to update.
+
+export const packageJsonVersion = '${version}';\n`;
+writeFileSync(outPath, content, 'utf8');
+
+console.log(`✅ version.ts generated at: ${outPath}`);
+console.log(`📦 version: ${version}`);

package/ScriptUtils/InjectMetadata.js

@@ -0,0 +1,37 @@
+import { Buffer } from 'buffer';
+import fs from 'fs';
+import path from 'path';
+import encode from 'png-chunks-encode';
+import extract from 'png-chunks-extract';
+
+//THis script meant to be used for testing of cleaning metadata
+
+const inputPath = path.resolve(process.cwd(), './test.png');
+const outputPath = path.resolve(process.cwd(), './test.png');
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function createTextChunk(keyword, text) {
+  // eslint-disable-next-line spellcheck/spell-checker
+  const keywordBuffer = Buffer.from(keyword, 'latin1');
+  const nullByte = Buffer.from([0x00]);
+  // eslint-disable-next-line spellcheck/spell-checker
+  const textBuffer = Buffer.from(text, 'latin1');
+  const data = Buffer.concat([keywordBuffer, nullByte, textBuffer]);
+  return {
+    name: 'tEXt',
+    data
+  };
+}
+
+const pngBuffer = fs.readFileSync(inputPath);
+
+const chunks = extract(pngBuffer);
+
+const myTextChunk = createTextChunk('Author', 'Someone (to remove)');
+
+chunks.splice(1, 0, myTextChunk);
+
+const newBuffer = Buffer.from(encode(chunks));
+fs.writeFileSync(outputPath, newBuffer);
+
+console.log('✅ PNG with metadata saved to with-meta.png');

package/ScriptUtils/MakeIcoFromPng.js

@@ -0,0 +1,139 @@
+// Creates .ico file from one or more PNGs, with optional resizing.
+// Usage:
+//   node scripts/MakeIcoFromPng.js --in assets/icon-1024.png --out assets/icon.ico
+//   node scripts/MakeIcoFromPng.js --in assets/256.png,assets/128.png --out assets/app.ico
+//   node scripts/MakeIcoFromPng.js --in assets/pngs --out assets/icon.ico
+//   node scripts/MakeIcoFromPng.js --in assets/icon-1024.png --out assets/icon.ico --size 256
+//
+// Notes:
+// - If --size is provided, all inputs are resized to NxN (requires dev-dep 'sharp').
+// - If --size is omitted, inputs are used as-is (no resizing).
+// - png-to-ico builds a valid ICO from given PNG buffers.
+
+import { readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { extname, resolve } from 'node:path';
+import process from 'node:process';
+import pngToIco from 'png-to-ico';
+import sharp from 'sharp';
+
+function printHelp() {
+  console.log(
+    `mk-ico — build a .ico from PNG(s)
+
+Options:
+  --in,  -i   Path to a PNG file. Can be repeated or comma-separated.
+              If a directory is passed, all *.png files in it are used (non-recursive).
+  --out, -o   Output .ico path (required).
+  --size, -s  Optional square size in px (e.g. 256). If omitted, images are not resized.
+  --help, -h  Show this help.
+
+Examples:
+  node scripts/MakeIcoFromPng.js --in assets/icon-1024.png --out assets/icon.ico
+  node scripts/MakeIcoFromPng.js -i assets/256.png,assets/128.png -o assets/icon.ico
+  node scripts/MakeIcoFromPng.js -i assets/pngs -o assets/icon.ico
+  node scripts/MakeIcoFromPng.js -i assets/icon-1024.png -o assets/icon.ico -s 256
+`
+  );
+}
+
+function parseArgs(argv) {
+  const args = { inputs: [], out: null, help: false, size: null };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--help' || a === '-h') {
+      args.help = true;
+      continue;
+    }
+    if (a === '--out' || a === '-o') {
+      args.out = argv[++i];
+      continue;
+    }
+    if (a === '--in' || a === '-i') {
+      const val = argv[++i];
+      if (val) args.inputs.push(...val.split(','));
+      continue;
+    }
+    if (a === '--size' || a === '-s') {
+      const val = argv[++i];
+      if (val && /^\d+$/.test(val)) args.size = Number(val);
+      else throw new Error(`--size expects a positive integer, got: ${val ?? '(missing)'}`);
+      continue;
+    }
+  }
+  return args;
+}
+
+async function listPngsFromDir(dirPath) {
+  const entries = await readdir(dirPath, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && extname(e.name).toLowerCase() === '.png').map((e) => resolve(dirPath, e.name));
+}
+
+async function resolveInputs(maybePaths) {
+  const result = [];
+  for (const p of maybePaths) {
+    const abs = resolve(p);
+    let st;
+    try {
+      st = await stat(abs);
+    } catch {
+      throw new Error(`Input path does not exist: ${abs}`);
+    }
+
+    if (st.isDirectory()) {
+      const pngs = await listPngsFromDir(abs);
+      if (pngs.length === 0) throw new Error(`Directory has no PNGs: ${abs}`);
+      result.push(...pngs);
+    } else if (st.isFile()) {
+      if (extname(abs).toLowerCase() !== '.png') throw new Error(`Input is not a .png file: ${abs}`);
+      result.push(abs);
+    } else {
+      throw new Error(`Unsupported input type (not file/dir): ${abs}`);
+    }
+  }
+  // de-dup, keep order
+  return [...new Set(result)];
+}
+
+async function maybeResize(buf, size) {
+  if (!size) return buf;
+  if (!(Number.isInteger(size) && size > 0 && size <= 4096)) {
+    throw new Error(`--size must be an integer in range 1..4096, got ${size}`);
+  }
+  return sharp(buf).resize(size, size, { fit: 'contain', withoutEnlargement: false }).png().toBuffer();
+}
+
+async function main() {
+  const { inputs, out, help, size } = parseArgs(process.argv.slice(2));
+  if (help || inputs.length === 0 || !out) {
+    printHelp();
+    if (help) return;
+    process.exit(1);
+  }
+
+  const inFiles = await resolveInputs(inputs);
+  if (inFiles.length === 0) throw new Error('No PNG inputs resolved.');
+
+  // Read PNGs, optional resize
+  const bufs = await Promise.all(
+    inFiles.map(async (p) => {
+      const b = await readFile(p);
+      return maybeResize(b, size);
+    })
+  );
+
+  try {
+    const icoBuf = await pngToIco(bufs);
+    const outPath = resolve(out);
+    await writeFile(outPath, icoBuf);
+    const sizeMsg = size ? ` (resized to ${size}x${size})` : '';
+    console.log(`✔ Wrote ICO: ${outPath} from ${inFiles.length} PNG file(s)${sizeMsg}.`);
+  } catch (e) {
+    console.error('✖ Failed to build ICO:', e?.message || e);
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('✖ Error:', err?.message || err);
+  process.exit(1);
+});

package/ScriptUtils/ModeUtils.js

@@ -0,0 +1,42 @@
+// Small helpers to parse and normalize build/run modes across scripts.
+
+// Extracts mode from argv supporting "--mode <val>" and "--mode=<val>"
+export function parseModeArg(argv = []) {
+  const idx = argv.findIndex((a) => a === '--mode');
+  if (idx !== -1 && argv[idx + 1]) return argv[idx + 1];
+  const eq = argv.find((a) => a.startsWith('--mode='));
+  if (eq) return eq.slice('--mode='.length);
+  return undefined;
+}
+
+// Normalizes common synonyms to canonical values and classifies composite modes.
+// dev -> development, prod -> production
+// development.* -> development, production.* -> production
+export function normalizeMode(input) {
+  if (!input) return 'production';
+  const s = String(input).trim().toLowerCase();
+  if (s === 'prod' || s === 'production' || s.startsWith('production.')) return 'production';
+  if (s === 'dev' || s === 'development' || s.startsWith('development.') || s.startsWith('dev.')) return 'development';
+  return s;
+}
+
+// Resolves the effective mode from argv and environment WITHOUT normalizing,
+// so Vite receives the full composite value (e.g., production.mac.arm64).
+// Priority: argv -> MODE -> npm_config_mode -> NODE_ENV -> default
+export function resolveMode(argv = [], env = process.env) {
+  const argMode = parseModeArg(argv);
+  const envMode = env.MODE;
+  const npmMode = env.npm_config_mode;
+  const nodeEnv = env.NODE_ENV;
+  return argMode || envMode || npmMode || nodeEnv || 'production';
+}
+
+// Detects a dry-run flag in argv.
+export function parseDryRunArg(argv = []) {
+  return argv.some((a) => a === '--dry-run' || a === '--dryrun' || a === '--dry');
+}
+
+// Resolves whether to run in dry-run mode from argv and environment.
+export function resolveDryRun(argv = [], env = process.env) {
+  return env.DRY_RUN === '1' || parseDryRunArg(argv);
+}

package/ScriptUtils/PostprocessScreenshots.js

@@ -0,0 +1,37 @@
+import fs from 'fs/promises';
+import path from 'path';
+import sharp from 'sharp';
+
+const SCREENSHOT_DIR = path.resolve(process.cwd(), './src');
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+async function processPng(filePath) {
+  const outputPath = filePath;
+  const buffer = await sharp(filePath)
+    .png({ force: true }) // 👈 без .withMetadata()
+    .toBuffer();
+  await fs.writeFile(outputPath, buffer);
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+async function processAllPngs(dir) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+
+  // eslint-disable-next-line functional/no-loop-statements
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await processAllPngs(fullPath);
+    } else if (entry.name.toLowerCase().endsWith('.png')) {
+      await processPng(fullPath);
+      console.log(`🧼 Cleaned metadata: ${fullPath}`);
+    }
+  }
+}
+
+processAllPngs(SCREENSHOT_DIR)
+  .then(() => console.log('✅ Screenshot metadata cleanup complete'))
+  .catch((err) => {
+    console.error('❌ Failed to clean screenshots:', err);
+    process.exit(1);
+  });

package/ScriptUtils/RenameFile.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import fs from 'fs/promises';
+import path from 'path';
+
+const [, , inputPath, outputPath] = process.argv;
+
+if (!inputPath || !outputPath) {
+  console.error('❌ Usage: node rename-preload.js <input.js> <output.mjs>');
+  process.exit(1);
+}
+
+try {
+  const resolvedInput = path.resolve(inputPath);
+  const resolvedOutput = path.resolve(outputPath);
+
+  await fs.rename(resolvedInput, resolvedOutput);
+
+  console.log(`✅ Renamed:\n  ${resolvedInput} →\n  ${resolvedOutput}`);
+} catch (err) {
+  console.error('❌ Rename failed:', err);
+  process.exit(1);
+}

package/ScriptUtils/SanitizeAssets.js

@@ -0,0 +1,120 @@
+import { NodeIO } from '@gltf-transform/core';
+import { exec } from 'child_process';
+import fg from 'fast-glob';
+import { promises as fs } from 'fs';
+import path from 'path';
+import sharp from 'sharp';
+import { optimize as optimizeSvg } from 'svgo';
+// eslint-disable-next-line spellcheck/spell-checker
+import { promisify } from 'util';
+
+// eslint-disable-next-line spellcheck/spell-checker
+const execAsync = promisify(exec);
+
+// Allow passing target directory as CLI arg; default to ./public
+const cliArg = process.argv[2];
+if (cliArg === '--help' || cliArg === '-h') {
+  console.log('Usage: node SanitizeAssets.js [targetDir]\nDefault targetDir is ./public');
+  process.exit(0);
+}
+const TARGET_DIR = path.resolve(process.cwd(), cliArg || './public');
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+async function cleanImage(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const image = sharp(filePath);
+  const buffer = ext === '.png' ? await image.png({ force: true }).toBuffer() : await image.jpeg({ force: true }).toBuffer();
+  await fs.writeFile(filePath, buffer);
+  console.log(`🧼 Cleaned ${ext.toUpperCase()}: ${filePath}`);
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+async function cleanSvg(filePath) {
+  const original = await fs.readFile(filePath, 'utf-8');
+  const result = optimizeSvg(original, {
+    multipass: true,
+    plugins: ['removeMetadata', 'removeTitle', 'removeDesc']
+  });
+  await fs.writeFile(filePath, result.data);
+  console.log(`🧼 Optimized SVG: ${filePath}`);
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+async function cleanMp3(filePath) {
+  const tmp = filePath + '.cleaned.mp3';
+  await execAsync(`ffmpeg -i "${filePath}" -map_metadata -1 -y "${tmp}"`);
+  await fs.rename(tmp, filePath);
+  console.log(`🧼 Stripped metadata from MP3: ${filePath}`);
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function sanitizeDocument(doc) {
+  const root = doc.getRoot();
+
+  // eslint-disable-next-line functional/immutable-data
+  root.getAsset().generator = undefined;
+
+  [
+    root.listAccessors(),
+    root.listAnimations(),
+    root.listBuffers(),
+    // root.listBufferViews(),
+    root.listCameras(),
+    // root.listImages(),
+    root.listMaterials(),
+    root.listMeshes(),
+    root.listNodes(),
+    // root.listSamplers(),
+    root.listScenes(),
+    root.listSkins(),
+    root.listTextures()
+  ]
+    .flat()
+    .forEach((item) => {
+      item.setExtras(undefined);
+    });
+
+  // eslint-disable-next-line functional/no-loop-statements
+  for (const extension of root.listExtensions()) {
+    // eslint-disable-next-line spellcheck/spell-checker
+    root.unregisterExtension(extension);
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+async function cleanGlb(filePath) {
+  try {
+    const io = new NodeIO();
+    const doc = await io.read(filePath);
+    sanitizeDocument(doc);
+    await io.write(filePath, doc);
+    console.log(`🧼 Cleaned GLB metadata: ${filePath}`);
+  } catch (err) {
+    console.warn(`⚠️ Failed to clean GLB: ${filePath}`, err.message);
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+async function sanitizeAssets() {
+  const files = await fg(['**/*.{png,jpg,jpeg,svg,mp3,ogg,glb,gltf}'], {
+    cwd: TARGET_DIR,
+    absolute: true
+  });
+
+  // eslint-disable-next-line functional/no-loop-statements
+  for (const file of files) {
+    const ext = path.extname(file).toLowerCase();
+    try {
+      if (['.png', '.jpg', '.jpeg'].includes(ext)) await cleanImage(file);
+      else if (ext === '.svg') await cleanSvg(file);
+      else if (['.mp3', '.ogg'].includes(ext)) await cleanMp3(file);
+      else if (['.glb'].includes(ext)) await cleanGlb(file);
+    } catch (err) {
+      console.warn(`⚠️ Failed to clean ${file}:`, err.message);
+    }
+  }
+
+  console.log('✅ Done: all assets sanitized');
+}
+
+sanitizeAssets();

package/package.json

@@ -2,7 +2,7 @@
   "name": "@hellpig/anarchy-shared",
   "author": "S. Panfilov",
   "private": false,
-  "version": "1.5.2",
+  "version": "1.6.2",
   "type": "module",
   "repository": {
     "type": "git",
@@ -16,7 +16,9 @@
   "publishConfig": {
     "access": "public"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "**/*.scss"
+  ],
   "license": "MIT",
   "description": "Anarchy-shared – a library with shared utilities and scripts for Anarchy Engine.",
   "keywords": [
@@ -31,7 +33,9 @@
     "NOTICE.md",
     "LICENSE",
     "README.md",
-    "dist/"
+    "dist/",
+    "ScriptUtils/",
+    "src/assets/"
   ],
   "exports": {
     "./Utils": {
@@ -50,10 +54,6 @@
       "types": "./dist/Plugins/index.d.ts",
       "import": "./dist/Plugins/index.es.js"
     },
-    "./assets": {
-      "types": "./dist/assets/index.d.ts",
-      "import": "./dist/assets/index.es.js"
-    },
     "./assets/*": "./src/assets/*",
     "./ScriptUtils/*": "./ScriptUtils/*"
   },