146 lines
6.7 KiB
JavaScript
146 lines
6.7 KiB
JavaScript
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
'use strict';
|
|
importScripts('uc2-core.js', 'zip.js');
|
|
let core;
|
|
let entries = [];
|
|
let mounted = false;
|
|
let opened = false;
|
|
let sourceInfo;
|
|
const MAX_INPUT = 256 * 1024 * 1024;
|
|
const MAX_VERIFY = 1024 * 1024 * 1024;
|
|
|
|
async function decoded(row) {
|
|
check(core._uc2_web_extract(row.index, 1));
|
|
let bytes;
|
|
try {
|
|
const start = core._uc2_web_output();
|
|
bytes = core.HEAPU8.slice(start, start + row.size);
|
|
} finally { core._uc2_web_free_output(); }
|
|
const digest = await crypto.subtle.digest('SHA-256', bytes);
|
|
const sha256 = Array.from(new Uint8Array(digest), b => b.toString(16).padStart(2, '0')).join('');
|
|
return {bytes, sha256};
|
|
}
|
|
|
|
function check(result) {
|
|
if (result < 0) throw new Error(core.UTF8ToString(core._uc2_web_error()));
|
|
return result;
|
|
}
|
|
|
|
function readIndex(count) {
|
|
const rows = Array.from({length: count}, (_, index) => {
|
|
const field = n => core._uc2_web_field(index, n) >>> 0;
|
|
const name = core.UTF8ToString(core._uc2_web_name(index));
|
|
if (!name || name.includes('/') || name.includes('\\')) throw new Error('Invalid name component');
|
|
return {index, name, parent: field(0), id: field(1), directory: !!field(2),
|
|
size: field(3), compressedSize: field(4), dosTime: field(5), attributes: field(6), method: field(7)};
|
|
});
|
|
const directories = new Map();
|
|
for (const row of rows) if (row.directory) {
|
|
if (!row.id || directories.has(row.id)) throw new Error('Invalid directory identifier');
|
|
directories.set(row.id, row);
|
|
}
|
|
const kinds = new Map();
|
|
for (const row of rows) {
|
|
const parts = [row.name];
|
|
const seen = new Set();
|
|
let parent = row.parent;
|
|
while (parent) {
|
|
if (seen.has(parent) || seen.size >= 64) throw new Error('Cyclic or excessively deep directory');
|
|
seen.add(parent);
|
|
const directory = directories.get(parent);
|
|
if (!directory) throw new Error('Missing parent directory');
|
|
parts.unshift(directory.name);
|
|
parent = directory.parent;
|
|
}
|
|
row.path = parts.join('/');
|
|
if (row.path.length > 4096) throw new Error('Archive path is too long');
|
|
if (kinds.has(row.path) && (row.directory || kinds.get(row.path))) throw new Error('Conflicting paths');
|
|
kinds.set(row.path, row.directory);
|
|
}
|
|
const versions = new Map();
|
|
for (const row of [...rows].reverse()) {
|
|
row.version = versions.get(row.path) || 0;
|
|
versions.set(row.path, row.version + 1);
|
|
}
|
|
return rows;
|
|
}
|
|
|
|
self.onmessage = async ({data}) => {
|
|
const {id, action} = data;
|
|
try {
|
|
if (!core) core = await createUC2({print: () => {}, printErr: () => {}});
|
|
if (action === 'open') {
|
|
opened = false;
|
|
const file = data.file;
|
|
if (!(file instanceof Blob) || file.size > MAX_INPUT) throw new Error('Archive exceeds the 256 MiB browser limit');
|
|
core._uc2_web_close();
|
|
entries = [];
|
|
if (mounted) core.FS.unmount('/input');
|
|
else core.FS.mkdir('/input');
|
|
mounted = false;
|
|
core.FS.mount(core.WORKERFS, {blobs: [{name: 'archive.uc2', data: file}]}, '/input');
|
|
mounted = true;
|
|
entries = readIndex(check(core._uc2_web_open()));
|
|
sourceInfo = {name: String(file.name || 'archive.uc2').slice(0, 1024), size: file.size};
|
|
opened = true;
|
|
self.postMessage({id, entries});
|
|
} else if (action === 'read') {
|
|
if (!opened) throw new Error('Open an archive first');
|
|
const row = entries[data.index];
|
|
if (!row || row.directory) throw new Error('Select a file');
|
|
const {bytes, sha256} = await decoded(row);
|
|
self.postMessage({id, bytes, sha256}, [bytes.buffer]);
|
|
} else if (action === 'zip') {
|
|
if (!opened) throw new Error('Open an archive first');
|
|
const ids = data.indices;
|
|
if (!Array.isArray(ids) || !ids.length || ids.length > ZIP_FILES ||
|
|
new Set(ids).size !== ids.length || ids.some(index => !Number.isInteger(index) || !entries[index] || entries[index].directory))
|
|
throw new Error('Select between 1 and 1,000 distinct file versions');
|
|
const files = ids.map(index => entries[index]).sort((a, b) => a.index - b.index);
|
|
if (files.some(row => row.size > 64 * 1024 * 1024)) throw new Error('A selected file exceeds the 64 MiB limit');
|
|
const report = {schema: 'uc2-browser-export-1', source: sourceInfo,
|
|
note: 'Each selected file passed its UC2 checksum. ZIP paths are portable numbered names; original paths and versions are preserved here. Keep the original archive.',
|
|
files: files.map(row => ({...row, output: zipPath(row), sha256: '0'.repeat(64), verified: true}))};
|
|
const encodeReport = () => new TextEncoder().encode(JSON.stringify(report, null, 2) + '\n');
|
|
const manifestSize = encodeReport().length;
|
|
const overhead = files.reduce((sum, row) => sum + 76 + 2 * zipPath(row).length, 22 + 76 + 2 * 'inventory.json'.length);
|
|
if (manifestSize > 16 * 1024 * 1024 || files.reduce((sum, row) => sum + row.size, manifestSize + overhead) > ZIP_LIMIT)
|
|
throw new Error('ZIP exceeds the 128 MiB download limit (including its inventory)');
|
|
const zip = new UC2Zip();
|
|
for (let i = 0; i < files.length; i++) {
|
|
const row = files[i];
|
|
let result;
|
|
try { result = await decoded(row); }
|
|
catch (error) {
|
|
self.postMessage({id, progress: i + 1, total: files.length,
|
|
result: {index: row.index, verified: false, error: error.message}});
|
|
throw new Error(`ZIP stopped at ${row.path}: ${error.message}. No ZIP was saved.`);
|
|
}
|
|
zip.add(report.files[i].output, result.bytes, row.dosTime);
|
|
report.files[i].sha256 = result.sha256;
|
|
self.postMessage({id, progress: i + 1, total: files.length,
|
|
result: {index: row.index, verified: true, sha256: result.sha256}});
|
|
}
|
|
zip.add('inventory.json', encodeReport());
|
|
self.postMessage({id, blob: zip.finish(), count: files.length});
|
|
} else if (action === 'verify') {
|
|
if (!opened) throw new Error('Open an archive first');
|
|
const files = entries.filter(row => !row.directory);
|
|
if (files.reduce((total, row) => total + row.size, 0) > MAX_VERIFY) throw new Error('Verification exceeds the 1 GiB output limit');
|
|
const results = [];
|
|
for (const row of files) {
|
|
const result = core._uc2_web_extract(row.index, 0);
|
|
results.push({index: row.index, verified: result >= 0,
|
|
error: result < 0 ? core.UTF8ToString(core._uc2_web_error()) : null});
|
|
self.postMessage({id, progress: results.length, total: files.length, result: results[results.length - 1]});
|
|
}
|
|
self.postMessage({id, results});
|
|
} else {
|
|
throw new Error('Unknown operation');
|
|
}
|
|
} catch (error) {
|
|
if (action === 'open' && core) { core._uc2_web_close(); entries = []; opened = false; }
|
|
self.postMessage({id, error: error.message || String(error)});
|
|
}
|
|
};
|