mirror of
https://github.com/networkmastered/obsidian-compress.git
synced 2026-07-22 05:41:28 +00:00
validation completion
This commit is contained in:
networkmastered
parent
4d2bac86c0
commit
768afb5cb6
16 changed files with 7353 additions and 729 deletions
1
.gitignore
vendored
1
.gitignore
vendored
|
|
@ -23,3 +23,4 @@ data.json
|
|||
|
||||
util/dictionaryBIGUnusedWiki.json
|
||||
util/temp.js
|
||||
archive/versions
|
||||
2
LICENSE
2
LICENSE
|
|
@ -1,4 +1,4 @@
|
|||
Copyright (C) 2020-2025 by Dynalist Inc.
|
||||
Copyright (C) 2020-2025 by NetworkMastered.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
|
||||
|
||||
|
|
|
|||
31
README.md
31
README.md
|
|
@ -1,32 +1,35 @@
|
|||
# File Compressor
|
||||
<i>This is a plugin made for obsidian.</i>
|
||||
<i>This is a plugin made for Obsidian.</i>
|
||||
|
||||
File compressor creates a new file type which is a .ctxt(compressed txt). Although it says txt it does support markdown. The plugin is designed to be as automated as possible. Which means that you do not need to compress and decompress the files yourself. All you need to do is click the "Create new ctxt" button. Which will then create the new ctxt in the root directory of your vault.
|
||||
|
||||
Once you have a new ctxt file you just need to edit it like a normal file. The plugin will do the rest. If you ever see the compressed data then close the tab and re-open it.
|
||||
|
||||
The editor works by taking obsidians default markdown editor and then telling it to not refresh it to the saved data(which doesnt always work), then once obsidian saves the plugin will then copy all of the contents of the file and then compress it.
|
||||
The editor works by taking Obsidian's default markdown editor and then telling it to not refresh it to the saved data(which doesnt always work), then once Obsidian saves the plugin will then copy all of the contents of the file and then compress it.
|
||||
|
||||
Only .MD files have been tested. But we plan on making it work with multiple plugins by only compressing the data once youre done! This will come later though. But as of now it should still be able to compress any file. As long as it is just plain text. Once again though if you do convert a file then the plugin wont read it. If the plugin also uses a specific file type then it will not be saved. Instead itll be converted to a MD. This is planned to change.
|
||||
|
||||
## Installation
|
||||
You can install/update the plugin in one of two ways:
|
||||
|
||||
1. You can install and update the pluin from the obsidian community plugin marketplace.
|
||||
1. You can install and update the pluin from the Obsidian community plugin marketplace.
|
||||
|
||||
2. You may also go to this repositorys github releases and then download the latest main and manifest then go into your vaults directory, open up your .obsidian folder, if you are on linux you may need to find out how to view hidden files. Then you just need to open up the plugins folder, create a new folder. You can name the folder whatever you like, or just "FileCompressor" or "compressor" then just drag the main and manifest files you downloaded into the folder!
|
||||
2. You may also go to this repositorys github releases and then download the latest main and manifest then go into your vaults directory, open up your .Obsidian folder, if you are on linux you may need to find out how to view hidden files. Then you just need to open up the plugins folder, create a new folder. You can name the folder whatever you like, or just "FileCompressor" or "compressor" then just drag the main and manifest files you downloaded into the folder!
|
||||
|
||||
*simplified:*
|
||||
- Go to releases and download main.js and manifest.json
|
||||
- Goto your obsidian vault
|
||||
- open vault/.obsidian/Plugins/compressor (or create compressor folder)
|
||||
- place the main and manifest into the compressor folder
|
||||
*simplified/stepped:*
|
||||
- Go to releases and download the main.js and manifest.json files
|
||||
- Goto your Obsidian vault
|
||||
- Open vault/.Obsidian/Plugins/compressor (or create compressor folder)
|
||||
- Place the main.js and manifest.json files you downloaded into the compressor plugin folder.
|
||||
- Open obsidian or save your files and reload Obsidian(Ctrl+p Reload app without saving)
|
||||
|
||||
|
||||
## Drawbacks
|
||||
## NOTICE
|
||||
1. Changing a files contents to a more obscure one will come with the risk of data loss.
|
||||
2. Links do work but will not show up in the Graph.
|
||||
3. Plugins may fail to read the data.
|
||||
4. This uses a CLOSED source build script along with esbuild.
|
||||
|
||||
|
||||
## Uninstalling
|
||||
[!WARNING]
|
||||
|
|
@ -49,11 +52,13 @@ Buttons:
|
|||
> "**Show file storage in statusbar**" - This does what it says and will show the most recently opened/edited file's storage space in bytes at the bottom on the statusbar.
|
||||
|
||||
## Compression Ratios:
|
||||
These ratios will be based off of 1MB of lorem ipsum.
|
||||
These ratios will be based off of the bee movie script as it provides a realistic use case and has variations in the words.
|
||||
|
||||
*(can be found at https://www.sample-videos.com/download-sample-text-file.php)*
|
||||
|
||||
> What is a compression ratio?<br>a compression ratio is how much the compressed version takes up of the raw version. (25kB compressed of 100kB = 25%, 25kB compressed of 50kB = 50%)
|
||||
|
||||
1.0.0-1.0.2-1.1.0 PRE-RELEASE: Error
|
||||
1.0.0: 33.9%
|
||||
1.0.0-1.0.2-1.1.0 PRE-RELEASE: Error<br>
|
||||
1.0.0: 55.4% ( Initial Release )<br>
|
||||
1.1.0: 55.4% ( Ready for publishing )<br>
|
||||
1.2.0: 55.4% ( Decrease plugin size & start of plugin compression)<br>
|
||||
12
TODO
Normal file
12
TODO
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
[ ] Finish Compression on plugins
|
||||
[ ] If compression is only on open file cehck for ![[]] links for rendering
|
||||
[ ] Search for more custom data plugins
|
||||
[ ] Compressed Vault?
|
||||
[ ] Custom ViewType/Leaf
|
||||
[ ] Block the data
|
||||
[ ] checksum the data
|
||||
[ ] implament some kind of repairer
|
||||
[ ] Rewrite README to make it more polished and add links for easier reading
|
||||
[ ] Create a version control system so i dont accidently publish broken or same versions
|
||||
[ ] Create a setting for "Uncompress entire Vault" and "Uncompress open file and requisite"
|
||||
[ ] Seperate each plugin compression type to a new script
|
||||
61
archive/netwrkjscmp.log
Normal file
61
archive/netwrkjscmp.log
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
Generated log file from WDIR/version/execute.js
|
||||
|
||||
$> Executed Build.
|
||||
|
||||
> compress@1.1.2 build
|
||||
> node archive/testchecks.js && tsc -noEmit -skipLibCheck && node esbuild.config.mjs production && node archive/versions/execute.js
|
||||
|
||||
$> Executed Tests.
|
||||
Test netcompress 1. Passed ✔
|
||||
Test netcompress 2. Passed ✔
|
||||
Test netcompress 3. Passed ✔
|
||||
Test netcompress 4. Passed ✔
|
||||
Test netcompress 5. Passed ✔
|
||||
Test netcompress 6. Passed ✔
|
||||
Test netcompress 7. Passed ✔
|
||||
Test netcompress 8. Passed ✔
|
||||
Test netdecompress 9. Passed ✔
|
||||
Test netdecompress 10. Passed ✔
|
||||
Test netdecompress 11. Passed ✔
|
||||
Test encodeSafe 12. Passed ✔
|
||||
Test encodeSafe 13. Passed ✔
|
||||
Test encodeSafe 14. Passed ✔
|
||||
Test encodeSafe 15. Passed ✔
|
||||
Test encodeSafe 16. Passed ✔
|
||||
Test encodeSafe 17. Passed ✔
|
||||
Test encodeSafe 18. Passed ✔
|
||||
Test encodeSafe 19. Passed ✔
|
||||
Test encodeSafe 20. Passed ✔
|
||||
Test encodeSafe 21. Passed ✔
|
||||
Test encodeSafe 22. Passed ✔
|
||||
Test encodeSafe 23. Passed ✔
|
||||
Test decodeSafe 24. Passed ✔
|
||||
Test decodeSafe 25. Passed ✔
|
||||
Test decodeSafe 26. Passed ✔
|
||||
Test decodeSafe 27. Passed ✔
|
||||
Test decodeSafe 28. Passed ✔
|
||||
Test decodeSafe 29. Passed ✔
|
||||
Test decodeSafe 30. Passed ✔
|
||||
Test decodeSafe 31. Passed ✔
|
||||
Test decodeSafe 32. Passed ✔
|
||||
Test decodeSafe 33. Passed ✔
|
||||
Test decodeSafe 34. Passed ✔
|
||||
Test decodeSafe 35. Passed ✔
|
||||
Finished. 35 have passed 0 have failed 35/0
|
||||
(node:14788) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///C:/Users/user/Desktop/Repos/TextEditorObsidianPluginPublic/util/BB.js is not specified and it doesn't parse as CommonJS.
|
||||
Reparsing as ES module because module syntax was detected. This incurs a performance overhead.
|
||||
To eliminate this warning, add "type": "module" to C:\Users\user\Desktop\Repos\TextEditorObsidianPluginPublic\package.json.
|
||||
(Use `node --trace-warnings ...` to show where the warning was created)
|
||||
|
||||
$> Executed NMJSCompress
|
||||
VC Created new TS213484. FS 56. FLAGS: --master --full --repush -m -vc --bumpall -wl --save --mini2 --complvl5 -pr --MoveTo:LENV["ObsidianDir"] --ignore:myselfAndParent -wd:ParParPar
|
||||
|
||||
Running minifier V2
|
||||
minifier[LL:WARN]: Level 5 enabled. Level 5 is significently low. Set to approx 10+ (0-100). Use 'execute.js --printlvllist' or 'execute.js --pll' or click: [NetworkMasterCLIEnums.ConsoleLogging.EmbedTypes.New.V2.Button]{NWK::'EXEC',WTR:'/-=E;PR!BtnFt',STL:'BoxButton;BoldAndUnderline',WYD:NetworkMasterCLIEnums.ConsoleLogging.PrintingFunctions.Events.Execute_By_Meta_PREM,PREM:"__DIR.F;CD %F;EXEC_CMD __DIR.CR -pll"}(This.)
|
||||
Size Difference: 857 B
|
||||
|
||||
Copied over files to: LENV.ObsidianDir.
|
||||
|
||||
$> Execution Finished
|
||||
|
||||
$> ?? --wl detected. Written to wd[wiesl]/netwrkjscmp.log
|
||||
|
|
@ -5,17 +5,17 @@ const funcs = [netcompress, netdecompress, encodeSafe, decodeSafe, LZ.compress,
|
|||
const names = ["netcompress", "netdecompress", "encodeSafe", "decodeSafe", "LZcompress", "LZdecompress"]
|
||||
|
||||
const tests = [
|
||||
{ type: 0, inputs: ["hi", "type1"], output: "gAfoE" },
|
||||
{ type: 0, inputs: ["hi,", "type1"], output: "gAundefined" },
|
||||
{ type: 0, inputs: ["abcdefg formats", "type2"], output: "ABfUBiQDRURGdESBcEUT5kQVRF" },
|
||||
{ type: 0, inputs: ["master file true", "type3"], output: "gBfoOabmMbXmNdL31dZA" },
|
||||
{ type: 0, inputs: ["zygote", "type3"], output: "gBf8_D" },
|
||||
{ type: 0, inputs: ["zygotezygote", "type3"], output: "gBf8_z_P" },
|
||||
{ type: 0, inputs: ["hello World", "type4"], output: "ACfhello World" },
|
||||
{ type: 0, inputs: ["test test test test test", "type5"], output: "gCfgw2AhtBCbDE2GIsB" },
|
||||
{ type: 1, inputs: ["gAfoE"], output: "hi" },
|
||||
{ type: 1, inputs: ["ACfhello World"], output: "hello World" },
|
||||
{ type: 1, inputs: ["gCfgw2AhtBCbDE2GIsB"], output: "test test test test test" },
|
||||
{ type: 0, inputs: ["hi", "type1"], output: "hAfoE" },
|
||||
{ type: 0, inputs: ["hi,", "type1"], output: "hAundefined" },
|
||||
{ type: 0, inputs: ["abcdefg formats", "type2"], output: "BBfUBiQDRURGdESBcEUT5kQVRF" },
|
||||
{ type: 0, inputs: ["master file true", "type3"], output: "hBfoOabmMbXmNdL31dZA" },
|
||||
{ type: 0, inputs: ["zygote", "type3"], output: "hBf8_D" },
|
||||
{ type: 0, inputs: ["zygotezygote", "type3"], output: "hBf8_z_P" },
|
||||
{ type: 0, inputs: ["hello World", "type4"], output: "BCfhello World" },
|
||||
{ type: 0, inputs: ["test test test test test", "type5"], output: "hCB4-6C3XX4-6C•\" K" },
|
||||
{ type: 1, inputs: ["hAfoE"], output: "hi" },
|
||||
{ type: 1, inputs: ["BCfhello World"], output: "hello World" },
|
||||
{ type: 1, inputs: ["hCB4-6C3XX4-6C•\" K"], output: "test test test test test" },
|
||||
{ type: 2, inputs: ["A"], output: "A" },
|
||||
{ type: 2, inputs: ["AA"], output: "AA" },
|
||||
{ type: 2, inputs: ["AAA"], output: "óA" },
|
||||
|
|
|
|||
|
|
@ -1,13 +1,11 @@
|
|||
import esbuild from "esbuild";
|
||||
import process from "process";
|
||||
import fs from "fs";
|
||||
import path from "path";
|
||||
import builtins from "builtin-modules";
|
||||
import { execSync } from "child_process";
|
||||
|
||||
const banner =
|
||||
`/*
|
||||
THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
|
||||
if you want to view the source, please visit the github repository of this plugin
|
||||
*/
|
||||
`;
|
||||
const banner = ""
|
||||
|
||||
const prod = (process.argv[2] === "production");
|
||||
|
||||
|
|
@ -41,9 +39,52 @@ const context = await esbuild.context({
|
|||
minify: prod,
|
||||
});
|
||||
|
||||
const cyrb53 = (str, seed = 0) => {
|
||||
let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
|
||||
for (let i = 0, ch; i < str.length; i++) {
|
||||
ch = str.charCodeAt(i);
|
||||
h1 = Math.imul(h1 ^ ch, 2654435761);
|
||||
h2 = Math.imul(h2 ^ ch, 1597334677);
|
||||
}
|
||||
h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
|
||||
h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
|
||||
h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
|
||||
h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
|
||||
return 4294967296 * (2097151 & h2) + (h1 >>> 0);
|
||||
};
|
||||
|
||||
async function fscn(pth = "./") {
|
||||
let hashr = '';
|
||||
let files = fs.readdirSync(pth)
|
||||
for (let i = 0; i < files.length; i++) {
|
||||
let file = files[i]
|
||||
const filePath = path.join(pth, file)
|
||||
if (fs.statSync(filePath).isFile()) {
|
||||
hashr += fs.readFileSync(filePath, 'utf-8')
|
||||
} else if (fs.statSync(filePath).isDirectory() && !filePath.includes("node_modules") && !filePath.includes("copies") && !filePath.includes(".git")) {
|
||||
hashr += await fscn(filePath)
|
||||
}
|
||||
}
|
||||
return hashr
|
||||
}
|
||||
if (prod) {
|
||||
await context.rebuild();
|
||||
process.exit(0);
|
||||
} else {
|
||||
let lh = 0
|
||||
setTimeout(async () => {
|
||||
let ls = async () => {
|
||||
await fscn().then((data) => {
|
||||
let nh = cyrb53(data, 1)
|
||||
if (lh != nh) {
|
||||
execSync("node archive/versions/execute.js", { stdio: "inherit" })
|
||||
lh = nh
|
||||
}
|
||||
})
|
||||
await new Promise((r)=>setTimeout(r,250))
|
||||
ls()
|
||||
}
|
||||
ls()
|
||||
}, 1)
|
||||
await context.watch();
|
||||
}
|
||||
|
|
|
|||
81
main.ts
81
main.ts
|
|
@ -1,8 +1,8 @@
|
|||
import { App, MarkdownView, Notice, Plugin, PluginSettingTab, Setting } from 'obsidian';
|
||||
// import { inflate, deflate } from "./util/pakoMinified"
|
||||
// import { BB } from "./util/BB"
|
||||
|
||||
import { App, MarkdownView, Notice, Plugin, PluginSettingTab, Setting, FileView } from 'obsidian';
|
||||
// import { inflate, deflate } from "./util/pako"
|
||||
// import { encodeSafe, decodeSafe } from "./util/runlength"
|
||||
import { netcompress, netdecompress } from "./util/networkmastercompression"
|
||||
import { netcompress, netdecompress, plugincompress, plugindecompress } from "./util/networkmastercompression"
|
||||
|
||||
interface compressorSettingsData {
|
||||
// mySetting: string;
|
||||
|
|
@ -10,14 +10,16 @@ interface compressorSettingsData {
|
|||
FileSize: boolean;
|
||||
LeaveRawLinks: boolean;
|
||||
Debug: boolean;
|
||||
ExcalidrawPrecision: number;
|
||||
}
|
||||
|
||||
const DEFAULT_SETTINGS: compressorSettingsData = {
|
||||
// mySetting: 'default',
|
||||
PrintResult: true,
|
||||
FileSize: true,
|
||||
PrintResult: false,
|
||||
FileSize: false,
|
||||
LeaveRawLinks: true,
|
||||
Debug: false
|
||||
Debug: false,
|
||||
ExcalidrawPrecision: 2,
|
||||
}
|
||||
let globalLeafs: any[] = []
|
||||
let NoticePool: Notice[] = []
|
||||
|
|
@ -83,7 +85,7 @@ export default class compressorPlugin extends Plugin {
|
|||
this.app.vault.read(file2).then((data) => {
|
||||
if (statusBarItemEl2 && this.settings.FileSize) statusBarItemEl2.setText(data.length + "B")
|
||||
// if (file2 && data && (data.includes("\n") || data.includes(" "))) {
|
||||
if (file2 && data && checkCompFile(data)) {
|
||||
if (file2 && data && !checkCompFile(data)) {
|
||||
let compress = null
|
||||
try {
|
||||
NoticePool.forEach((n) => {
|
||||
|
|
@ -197,7 +199,7 @@ export default class compressorPlugin extends Plugin {
|
|||
//set elsewhere
|
||||
statusBarItemEl2 = this.addStatusBarItem();
|
||||
statusBarItemEl2.setText("");
|
||||
statusBarItemEl2.title = "File Size"
|
||||
statusBarItemEl2.title = "File size"
|
||||
|
||||
this.addCommand({
|
||||
id: 'createctxt',
|
||||
|
|
@ -233,9 +235,49 @@ export default class compressorPlugin extends Plugin {
|
|||
// }
|
||||
// }, 100));
|
||||
//<div style="position: absolute;left:0%;right:0%;width:100%;height:100%;background-color:rgba(20,20,20,0.6);z-index: 99999999999;">Content Compressed.</div>
|
||||
|
||||
|
||||
|
||||
//NOT FINISHED.
|
||||
// ; (async () => {
|
||||
// while (true) {
|
||||
// await new Promise((r) => { setTimeout(r, 100) })
|
||||
// if (this.app.vault.getFiles().length > 0) break
|
||||
// }
|
||||
// var hn = false
|
||||
// this.app.vault.getFiles().forEach((file) => {
|
||||
// console.log(file.name)
|
||||
// this.app.vault.read(file).then((data) => {
|
||||
// if (file) {
|
||||
// if (data.includes("excalidraw") && data.includes("```compressed-json") && !hn) {
|
||||
// alert("File Compressor: You have excalidraw installed with compression, please go to settings -> excalidraw -> Saving -> Compression and disable it. That way it can be compressed by this plugin. Source cause: " + file.path)
|
||||
// hn = true
|
||||
// }
|
||||
// // var out = plugindecompress(file, data)
|
||||
// plugincompress(file, data, this.settings)
|
||||
// var out = plugindecompress(file, data)
|
||||
// // if (out) this.app.vault.modify(file, out)
|
||||
// console.log("WRITER DISABLED.")
|
||||
// }
|
||||
// })
|
||||
// })
|
||||
// })()
|
||||
|
||||
this.app.workspace.on("quit", () => {
|
||||
//NOT FINISHED.
|
||||
// this.app.vault.getFiles().forEach((file) => {
|
||||
// console.log(file.name)
|
||||
// this.app.vault.read(file).then((data) => {
|
||||
// if (file) {
|
||||
// var out = plugincompress(file, data)
|
||||
// if (out) this.app.vault.modify(file, out)
|
||||
// }
|
||||
// })
|
||||
// })
|
||||
})
|
||||
}
|
||||
onunload() {
|
||||
alert("In order to view CTXT files you will need to re-enable the plugin. If you are deleting the plugin, please convert your files back before.")
|
||||
// alert("In order to view CTXT files you will need to re-enable the plugin. If you are deleting the plugin, please convert your files back before.")
|
||||
}
|
||||
async loadSettings() {
|
||||
this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
|
||||
|
|
@ -348,7 +390,7 @@ function decompressfile(data: string, notice?: boolean) {
|
|||
function checkCompFile(data: string) {
|
||||
var state = false
|
||||
try {
|
||||
state = netdecompress(data) == ""
|
||||
state = (netdecompress(data) || "").length > 0
|
||||
} catch (_) { }
|
||||
return state
|
||||
}
|
||||
|
|
@ -388,12 +430,27 @@ class compressorSettings extends PluginSettingTab {
|
|||
.setDesc('Unfortunetly the graph view will not maintain links. The graph cannot read the compressed data. Nor if the links are raw')
|
||||
new Setting(containerEl)
|
||||
.setName('Debug')
|
||||
.setDesc('Toast all data')
|
||||
.setDesc('Toasts all the events that are happening. Useful for debugging.')
|
||||
.addToggle(bool => bool
|
||||
.setValue(this.plugin.settings.Debug)
|
||||
.onChange(async (value) => {
|
||||
this.plugin.settings.Debug = value;
|
||||
await this.plugin.saveSettings();
|
||||
}));
|
||||
// new Setting(containerEl)
|
||||
// .setName('-----Plugin Data Compression-----')
|
||||
// .setDesc('Settings for compressing data that plugins save to vault')
|
||||
//useless excelidraw uses whole offsets
|
||||
// var ex_DP = new Setting(containerEl)
|
||||
// .setName('Excalidraw: Decimal Precision')
|
||||
// .setDesc(`How many decimals to have when saving numbers (${this.plugin.settings.ExcalidrawPrecision} DP)`)
|
||||
// .addSlider(num => num
|
||||
// .setValue(this.plugin.settings.ExcalidrawPrecision)
|
||||
// .setLimits(0, 5, 1)
|
||||
// .onChange(async (value) => {
|
||||
// this.plugin.settings.ExcalidrawPrecision = value;
|
||||
// ex_DP.setDesc(`How many decimals to have when saving numbers (${this.plugin.settings.ExcalidrawPrecision} DP) ${(this.plugin.settings.ExcalidrawPrecision==0)?"NO DECIMALS(VERY BAD)":""}`)
|
||||
// await this.plugin.saveSettings();
|
||||
// }));
|
||||
}
|
||||
}
|
||||
|
|
@ -1,7 +1,7 @@
|
|||
{
|
||||
"id": "compress",
|
||||
"name": "File Compressor",
|
||||
"version": "1.1.0",
|
||||
"version": "1.1.2",
|
||||
"minAppVersion": "0.15.0",
|
||||
"description": "Make your files smaller with compression!",
|
||||
"author": "networkmastered",
|
||||
|
|
|
|||
2
package-lock.json
generated
2
package-lock.json
generated
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "compress",
|
||||
"version": "1.0.0",
|
||||
"version": "1.1.2",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
|
|
|
|||
|
|
@ -1,11 +1,11 @@
|
|||
{
|
||||
"name": "compress",
|
||||
"version": "1.1.0",
|
||||
"version": "1.1.2",
|
||||
"description": "Make your files smaller with compression!",
|
||||
"main": "main.js",
|
||||
"scripts": {
|
||||
"dev": "node esbuild.config.mjs",
|
||||
"build": "node archive/testchecks.js && tsc -noEmit -skipLibCheck && node esbuild.config.mjs production",
|
||||
"dev": "node archive/testchecks.js && tsc -noEmit -skipLibCheck && node esbuild.config.mjs",
|
||||
"build": "node archive/testchecks.js && tsc -noEmit -skipLibCheck && node esbuild.config.mjs production && node archive/versions/execute.js",
|
||||
"version": "node version-bump.mjs && git add manifest.json versions.json"
|
||||
},
|
||||
"keywords": [],
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
6890
util/pako.js
Normal file
6890
util/pako.js
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -1,663 +0,0 @@
|
|||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
||||
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
||||
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.pako = {}));})(this, (function (exports) {
|
||||
'use strict';const Z_FIXED$1 = 4;const Z_BINARY = 0;const Z_TEXT = 1;const Z_UNKNOWN$1 = 2;function zero$1(buf) { let len = buf.length;while (--len >= 0) { buf[len] = 0;} }const STORED_BLOCK = 0;const STATIC_TREES = 1;const DYN_TREES = 2;const MIN_MATCH$1 = 3;const MAX_MATCH$1 = 258;const LENGTH_CODES$1 = 29;const LITERALS$1 = 256;const L_CODES$1 = LITERALS$1 + 1 + LENGTH_CODES$1;const D_CODES$1 = 30;const BL_CODES$1 = 19;const HEAP_SIZE$1 = 2 * L_CODES$1 + 1;const MAX_BITS$1 = 15;const Buf_size = 16;const MAX_BL_BITS = 7;const END_BLOCK = 256;const REP_3_6 = 16;const REPZ_3_10 = 17;const REPZ_11_138 = 18;const extra_lbits =
|
||||
new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]);const extra_dbits =
|
||||
new Uint8Array([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]);const extra_blbits =
|
||||
new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]);const bl_order =
|
||||
new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);const DIST_CODE_LEN = 512;const static_ltree = new Array((L_CODES$1 + 2) * 2);zero$1(static_ltree);const static_dtree = new Array(D_CODES$1 * 2);zero$1(static_dtree);const _dist_code = new Array(DIST_CODE_LEN);zero$1(_dist_code);const _length_code = new Array(MAX_MATCH$1 - MIN_MATCH$1 + 1);zero$1(_length_code);const base_length = new Array(LENGTH_CODES$1);zero$1(base_length);const base_dist = new Array(D_CODES$1);zero$1(base_dist);function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {this.static_tree = static_tree;this.extra_bits = extra_bits;this.extra_base = extra_base;this.elems = elems;this.max_length = max_length;this.has_stree = static_tree && static_tree.length;}let static_l_desc;let static_d_desc;let static_bl_desc;function TreeDesc(dyn_tree, stat_desc) {
|
||||
this.dyn_tree = dyn_tree;this.max_code = 0;this.stat_desc = stat_desc;}const d_code = (dist) => {return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];};const put_short = (s, w) => {s.pending_buf[s.pending++] = (w) & 0xff;s.pending_buf[s.pending++] = (w >>> 8) & 0xff;};const send_bits = (s, value, length) => {if (s.bi_valid > (Buf_size - length)) {
|
||||
s.bi_buf |= (value << s.bi_valid) & 0xffff;put_short(s, s.bi_buf);s.bi_buf = value >> (Buf_size - s.bi_valid);s.bi_valid += length - Buf_size;} else {
|
||||
s.bi_buf |= (value << s.bi_valid) & 0xffff;s.bi_valid += length;}};const send_code = (s, c, tree) => {send_bits(s, tree[c * 2], tree[c * 2 + 1]);};const bi_reverse = (code, len) => {let res = 0;do {
|
||||
res |= code & 1;code >>>= 1;res <<= 1;} while (--len > 0);return res >>> 1;};const bi_flush = (s) => {if (s.bi_valid === 16) {
|
||||
put_short(s, s.bi_buf);s.bi_buf = 0;s.bi_valid = 0;} else if (s.bi_valid >= 8) {
|
||||
s.pending_buf[s.pending++] = s.bi_buf & 0xff;s.bi_buf >>= 8;s.bi_valid -= 8;}};const gen_bitlen = (s, desc) => {const tree = desc.dyn_tree;const max_code = desc.max_code;const stree = desc.stat_desc.static_tree;const has_stree = desc.stat_desc.has_stree;const extra = desc.stat_desc.extra_bits;const base = desc.stat_desc.extra_base;const max_length = desc.stat_desc.max_length;let h;let n, m;let bits;let xbits;let f;let overflow = 0;for (bits = 0;bits <= MAX_BITS$1;bits++) {
|
||||
s.bl_count[bits] = 0;}tree[s.heap[s.heap_max] * 2 + 1] = 0;for (h = s.heap_max + 1;h < HEAP_SIZE$1;h++) {
|
||||
n = s.heap[h];bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;if (bits > max_length) {
|
||||
bits = max_length;overflow++;}tree[n * 2 + 1] = bits;if (n > max_code) { continue;} s.bl_count[bits]++;xbits = 0;if (n >= base) {
|
||||
xbits = extra[n - base];}f = tree[n * 2];s.opt_len += f * (bits + xbits);if (has_stree) {
|
||||
s.static_len += f * (stree[n * 2 + 1] + xbits);}}if (overflow === 0) { return;}do {
|
||||
bits = max_length - 1;while (s.bl_count[bits] === 0) { bits--;}s.bl_count[bits]--;s.bl_count[bits + 1] += 2;s.bl_count[max_length]--;overflow -= 2;} while (overflow > 0);for (bits = max_length;bits !== 0;bits--) {
|
||||
n = s.bl_count[bits];while (n !== 0) {
|
||||
m = s.heap[--h];if (m > max_code) { continue;}if (tree[m * 2 + 1] !== bits) {s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2];tree[m * 2 + 1] = bits;}n--;}}};const gen_codes = (tree, max_code, bl_count) => {const next_code = new Array(MAX_BITS$1 + 1);let code = 0;let bits;let n;for (bits = 1;bits <= MAX_BITS$1;bits++) {
|
||||
code = (code + bl_count[bits - 1]) << 1;next_code[bits] = code;}for (n = 0;n <= max_code;n++) {
|
||||
let len = tree[n * 2 + 1];if (len === 0) { continue;}tree[n * 2] = bi_reverse(next_code[len]++, len);}};const tr_static_init = () => {let n;let bits;let length;let code;let dist;const bl_count = new Array(MAX_BITS$1 + 1);length = 0;for (code = 0;code < LENGTH_CODES$1 - 1;code++) {
|
||||
base_length[code] = length;for (n = 0;n < (1 << extra_lbits[code]);n++) {
|
||||
_length_code[length++] = code;}}_length_code[length - 1] = code;dist = 0;for (code = 0;code < 16;code++) {
|
||||
base_dist[code] = dist;for (n = 0;n < (1 << extra_dbits[code]);n++) {
|
||||
_dist_code[dist++] = code;}}dist >>= 7;for (;code < D_CODES$1;code++) {
|
||||
base_dist[code] = dist << 7;for (n = 0;n < (1 << (extra_dbits[code] - 7));n++) {
|
||||
_dist_code[256 + dist++] = code;}}for (bits = 0;bits <= MAX_BITS$1;bits++) {
|
||||
bl_count[bits] = 0;}n = 0;while (n <= 143) {
|
||||
static_ltree[n * 2 + 1] = 8;n++;bl_count[8]++;}while (n <= 255) {
|
||||
static_ltree[n * 2 + 1] = 9;n++;bl_count[9]++;}while (n <= 279) {
|
||||
static_ltree[n * 2 + 1] = 7;n++;bl_count[7]++;}while (n <= 287) {
|
||||
static_ltree[n * 2 + 1] = 8;n++;bl_count[8]++;}gen_codes(static_ltree, L_CODES$1 + 1, bl_count);for (n = 0;n < D_CODES$1;n++) {
|
||||
static_dtree[n * 2 + 1] = 5;static_dtree[n * 2] = bi_reverse(n, 5);}static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS$1 + 1, L_CODES$1, MAX_BITS$1);static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES$1, MAX_BITS$1);static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES$1, MAX_BL_BITS);};const init_block = (s) => {let n;for (n = 0;n < L_CODES$1;n++) { s.dyn_ltree[n * 2] = 0;}for (n = 0;n < D_CODES$1;n++) { s.dyn_dtree[n * 2] = 0;}for (n = 0;n < BL_CODES$1;n++) { s.bl_tree[n * 2] = 0;}s.dyn_ltree[END_BLOCK * 2] = 1;s.opt_len = s.static_len = 0;s.sym_next = s.matches = 0;};const bi_windup = (s) => {
|
||||
if (s.bi_valid > 8) {
|
||||
put_short(s, s.bi_buf);} else if (s.bi_valid > 0) {s.pending_buf[s.pending++] = s.bi_buf;}s.bi_buf = 0;s.bi_valid = 0;};const smaller = (tree, n, m, depth) => {const _n2 = n * 2;const _m2 = m * 2;return (tree[_n2] < tree[_m2] ||
|
||||
(tree[_n2] === tree[_m2] && depth[n] <= depth[m]));};const pqdownheap = (s, tree, k) => {const v = s.heap[k];let j = k << 1;while (j <= s.heap_len) {if (j < s.heap_len &&
|
||||
smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {
|
||||
j++;}if (smaller(tree, v, s.heap[j], s.depth)) { break;}s.heap[k] = s.heap[j];k = j;j <<= 1;}s.heap[k] = v;};const compress_block = (s, ltree, dtree) => {let dist;let lc;let sx = 0;let code;let extra;if (s.sym_next !== 0) {
|
||||
do {
|
||||
dist = s.pending_buf[s.sym_buf + sx++] & 0xff;dist += (s.pending_buf[s.sym_buf + sx++] & 0xff) << 8;lc = s.pending_buf[s.sym_buf + sx++];if (dist === 0) {
|
||||
send_code(s, lc, ltree);} else {code = _length_code[lc];send_code(s, code + LITERALS$1 + 1, ltree);extra = extra_lbits[code];if (extra !== 0) {
|
||||
lc -= base_length[code];send_bits(s, lc, extra);}dist--;code = d_code(dist);send_code(s, code, dtree);extra = extra_dbits[code];if (extra !== 0) {
|
||||
dist -= base_dist[code];send_bits(s, dist, extra);}} } while (sx < s.sym_next);}send_code(s, END_BLOCK, ltree);};const build_tree = (s, desc) => {const tree = desc.dyn_tree;const stree = desc.stat_desc.static_tree;const has_stree = desc.stat_desc.has_stree;const elems = desc.stat_desc.elems;let n, m;let max_code = -1;let node;s.heap_len = 0;s.heap_max = HEAP_SIZE$1;for (n = 0;n < elems;n++) {
|
||||
if (tree[n * 2] !== 0) {
|
||||
s.heap[++s.heap_len] = max_code = n;s.depth[n] = 0;} else {
|
||||
tree[n * 2 + 1] = 0;}}while (s.heap_len < 2) {
|
||||
node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);tree[node * 2] = 1;s.depth[node] = 0;s.opt_len--;if (has_stree) {
|
||||
s.static_len -= stree[node * 2 + 1];}}desc.max_code = max_code;for (n = (s.heap_len >> 1);n >= 1;n--) { pqdownheap(s, tree, n);}node = elems;do {n = s.heap[1];s.heap[1] = s.heap[s.heap_len--];pqdownheap(s, tree, 1);m = s.heap[1];s.heap[--s.heap_max] = n;s.heap[--s.heap_max] = m;tree[node * 2] = tree[n * 2] + tree[m * 2];s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;tree[n * 2 + 1] = tree[m * 2 + 1] = node;s.heap[1] = node++;pqdownheap(s, tree, 1);} while (s.heap_len >= 2);s.heap[--s.heap_max] = s.heap[1];gen_bitlen(s, desc);gen_codes(tree, max_code, s.bl_count);};const scan_tree = (s, tree, max_code) => {let n;let prevlen = -1;let curlen;let nextlen = tree[0 * 2 + 1];let count = 0;let max_count = 7;let min_count = 4;if (nextlen === 0) {
|
||||
max_count = 138;min_count = 3;}tree[(max_code + 1) * 2 + 1] = 0xffff;for (n = 0;n <= max_code;n++) {
|
||||
curlen = nextlen;nextlen = tree[(n + 1) * 2 + 1];if (++count < max_count && curlen === nextlen) {
|
||||
continue;} else if (count < min_count) {
|
||||
s.bl_tree[curlen * 2] += count;} else if (curlen !== 0) {if (curlen !== prevlen) { s.bl_tree[curlen * 2]++;}s.bl_tree[REP_3_6 * 2]++;} else if (count <= 10) {
|
||||
s.bl_tree[REPZ_3_10 * 2]++;} else {
|
||||
s.bl_tree[REPZ_11_138 * 2]++;}count = 0;prevlen = curlen;if (nextlen === 0) {
|
||||
max_count = 138;min_count = 3;} else if (curlen === nextlen) {
|
||||
max_count = 6;min_count = 3;} else {
|
||||
max_count = 7;min_count = 4;}}};const send_tree = (s, tree, max_code) => {let n;let prevlen = -1;let curlen;let nextlen = tree[0 * 2 + 1];let count = 0;let max_count = 7;let min_count = 4;if (nextlen === 0) {
|
||||
max_count = 138;min_count = 3;}for (n = 0;n <= max_code;n++) {
|
||||
curlen = nextlen;nextlen = tree[(n + 1) * 2 + 1];if (++count < max_count && curlen === nextlen) {
|
||||
continue;} else if (count < min_count) {
|
||||
do { send_code(s, curlen, s.bl_tree);} while (--count !== 0);} else if (curlen !== 0) {
|
||||
if (curlen !== prevlen) {
|
||||
send_code(s, curlen, s.bl_tree);count--;}send_code(s, REP_3_6, s.bl_tree);send_bits(s, count - 3, 2);} else if (count <= 10) {
|
||||
send_code(s, REPZ_3_10, s.bl_tree);send_bits(s, count - 3, 3);} else {
|
||||
send_code(s, REPZ_11_138, s.bl_tree);send_bits(s, count - 11, 7);}count = 0;prevlen = curlen;if (nextlen === 0) {
|
||||
max_count = 138;min_count = 3;} else if (curlen === nextlen) {
|
||||
max_count = 6;min_count = 3;} else {
|
||||
max_count = 7;min_count = 4;}}};const build_bl_tree = (s) => {let max_blindex;scan_tree(s, s.dyn_ltree, s.l_desc.max_code);scan_tree(s, s.dyn_dtree, s.d_desc.max_code);build_tree(s, s.bl_desc);for (max_blindex = BL_CODES$1 - 1;max_blindex >= 3;max_blindex--) {
|
||||
if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !== 0) {
|
||||
break;}}s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;return max_blindex;};const send_all_trees = (s, lcodes, dcodes, blcodes) => {let rank;send_bits(s, lcodes - 257, 5);send_bits(s, dcodes - 1, 5);send_bits(s, blcodes - 4, 4);for (rank = 0;rank < blcodes;rank++) {send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1], 3);}send_tree(s, s.dyn_ltree, lcodes - 1);send_tree(s, s.dyn_dtree, dcodes - 1);};const detect_data_type = (s) => {let block_mask = 0xf3ffc07f;let n;for (n = 0;n <= 31;n++, block_mask >>>= 1) {
|
||||
if ((block_mask & 1) && (s.dyn_ltree[n * 2] !== 0)) {
|
||||
return Z_BINARY;}}if (s.dyn_ltree[9 * 2] !== 0 || s.dyn_ltree[10 * 2] !== 0 ||
|
||||
s.dyn_ltree[13 * 2] !== 0) {
|
||||
return Z_TEXT;}for (n = 32;n < LITERALS$1;n++) {
|
||||
if (s.dyn_ltree[n * 2] !== 0) {
|
||||
return Z_TEXT;}}return Z_BINARY;};let static_init_done = false;const _tr_init$1 = (s) => {if (!static_init_done) {
|
||||
tr_static_init();static_init_done = true;}s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);s.bi_buf = 0;s.bi_valid = 0;init_block(s);};const _tr_stored_block$1 = (s, buf, stored_len, last) => {send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);bi_windup(s);put_short(s, stored_len);put_short(s, ~stored_len);if (stored_len) {
|
||||
s.pending_buf.set(s.window.subarray(buf, buf + stored_len), s.pending);}s.pending += stored_len;};const _tr_align$1 = (s) => {
|
||||
send_bits(s, STATIC_TREES << 1, 3);send_code(s, END_BLOCK, static_ltree);bi_flush(s);};const _tr_flush_block$1 = (s, buf, stored_len, last) => {let opt_lenb, static_lenb;let max_blindex = 0;if (s.level > 0) {if (s.strm.data_type === Z_UNKNOWN$1) {
|
||||
s.strm.data_type = detect_data_type(s);}build_tree(s, s.l_desc);build_tree(s, s.d_desc);max_blindex = build_bl_tree(s);opt_lenb = (s.opt_len + 3 + 7) >>> 3;static_lenb = (s.static_len + 3 + 7) >>> 3;if (static_lenb <= opt_lenb) { opt_lenb = static_lenb;}} else {opt_lenb = static_lenb = stored_len + 5;}if ((stored_len + 4 <= opt_lenb) && (buf !== -1)) {_tr_stored_block$1(s, buf, stored_len, last);} else if (s.strategy === Z_FIXED$1 || static_lenb === opt_lenb) {send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);compress_block(s, static_ltree, static_dtree);} else {
|
||||
send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);compress_block(s, s.dyn_ltree, s.dyn_dtree);}init_block(s);if (last) {
|
||||
bi_windup(s);}};const _tr_tally$1 = (s, dist, lc) => {s.pending_buf[s.sym_buf + s.sym_next++] = dist;s.pending_buf[s.sym_buf + s.sym_next++] = dist >> 8;s.pending_buf[s.sym_buf + s.sym_next++] = lc;if (dist === 0) {s.dyn_ltree[lc * 2]++;} else {
|
||||
s.matches++;dist--;s.dyn_ltree[(_length_code[lc] + LITERALS$1 + 1) * 2]++;s.dyn_dtree[d_code(dist) * 2]++;}return (s.sym_next === s.sym_end);};let _tr_init_1 = _tr_init$1;let _tr_stored_block_1 = _tr_stored_block$1;let _tr_flush_block_1 = _tr_flush_block$1;let _tr_tally_1 = _tr_tally$1;let _tr_align_1 = _tr_align$1;let trees = {
|
||||
_tr_init: _tr_init_1,_tr_stored_block: _tr_stored_block_1,_tr_flush_block: _tr_flush_block_1,_tr_tally: _tr_tally_1,_tr_align: _tr_align_1
|
||||
};const adler32 = (adler, buf, len, pos) => {
|
||||
let s1 = (adler & 0xffff) | 0,s2 = ((adler >>> 16) & 0xffff) | 0,n = 0;while (len !== 0) {n = len > 2000 ? 2000 : len;len -= n;do {
|
||||
s1 = (s1 + buf[pos++]) | 0;s2 = (s2 + s1) | 0;} while (--n);s1 %= 65521;s2 %= 65521;}return (s1 | (s2 << 16)) | 0;};let adler32_1 = adler32;const makeTable = () => {
|
||||
let c, table = [];for (let n = 0;n < 256;n++) {
|
||||
c = n;for (let k = 0;k < 8;k++) {
|
||||
c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));}table[n] = c;}return table;};const crcTable = new Uint32Array(makeTable());const crc32 = (crc, buf, len, pos) => {
|
||||
const t = crcTable;const end = pos + len;crc ^= -1;for (let i = pos;i < end;i++) {
|
||||
crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];}return (crc ^ (-1));};let crc32_1 = crc32;let messages = {
|
||||
2: 'need dictionary',
|
||||
1: 'stream end',
|
||||
0: '',
|
||||
'-1': 'file error',
|
||||
'-2': 'stream error',
|
||||
'-3': 'data error',
|
||||
'-4': 'insufficient memory',
|
||||
'-5': 'buffer error',
|
||||
'-6': 'incompatible version'
|
||||
};let constants$2 = {Z_NO_FLUSH: 0,Z_PARTIAL_FLUSH: 1,Z_SYNC_FLUSH: 2,Z_FULL_FLUSH: 3,Z_FINISH: 4,Z_BLOCK: 5,Z_TREES: 6,Z_OK: 0,Z_STREAM_END: 1,Z_NEED_DICT: 2,Z_ERRNO: -1,Z_STREAM_ERROR: -2,Z_DATA_ERROR: -3,Z_MEM_ERROR: -4,Z_BUF_ERROR: -5,Z_NO_COMPRESSION: 0,Z_BEST_SPEED: 1,Z_BEST_COMPRESSION: 9,Z_DEFAULT_COMPRESSION: -1,Z_FILTERED: 1,Z_HUFFMAN_ONLY: 2,Z_RLE: 3,Z_FIXED: 4,Z_DEFAULT_STRATEGY: 0,Z_BINARY: 0,Z_TEXT: 1,Z_UNKNOWN: 2,Z_DEFLATED: 8};const { _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align } = trees;const {
|
||||
Z_NO_FLUSH: Z_NO_FLUSH$2, Z_PARTIAL_FLUSH, Z_FULL_FLUSH: Z_FULL_FLUSH$1, Z_FINISH: Z_FINISH$3, Z_BLOCK: Z_BLOCK$1,Z_OK: Z_OK$3, Z_STREAM_END: Z_STREAM_END$3, Z_STREAM_ERROR: Z_STREAM_ERROR$2, Z_DATA_ERROR: Z_DATA_ERROR$2, Z_BUF_ERROR: Z_BUF_ERROR$1,Z_DEFAULT_COMPRESSION: Z_DEFAULT_COMPRESSION$1,Z_FILTERED, Z_HUFFMAN_ONLY, Z_RLE, Z_FIXED, Z_DEFAULT_STRATEGY: Z_DEFAULT_STRATEGY$1,Z_UNKNOWN,Z_DEFLATED: Z_DEFLATED$2
|
||||
} = constants$2;const MAX_MEM_LEVEL = 9;const MAX_WBITS$1 = 15;const DEF_MEM_LEVEL = 8;const LENGTH_CODES = 29;const LITERALS = 256;const L_CODES = LITERALS + 1 + LENGTH_CODES;const D_CODES = 30;const BL_CODES = 19;const HEAP_SIZE = 2 * L_CODES + 1;const MAX_BITS = 15;const MIN_MATCH = 3;const MAX_MATCH = 258;const MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1);const PRESET_DICT = 0x20;const INIT_STATE = 42;const GZIP_STATE = 57;const EXTRA_STATE = 69;const NAME_STATE = 73;const COMMENT_STATE = 91;const HCRC_STATE = 103;const BUSY_STATE = 113;const FINISH_STATE = 666;const BS_NEED_MORE = 1;const BS_BLOCK_DONE = 2;const BS_FINISH_STARTED = 3;const BS_FINISH_DONE = 4;const OS_CODE = 0x03;const err = (strm, errorCode) => {
|
||||
strm.msg = messages[errorCode];return errorCode;};const rank = (f) => {
|
||||
return ((f) * 2) - ((f) > 4 ? 9 : 0);};const zero = (buf) => {
|
||||
let len = buf.length;while (--len >= 0) { buf[len] = 0;}};const slide_hash = (s) => {
|
||||
let n, m;let p;let wsize = s.w_size;n = s.hash_size;p = n;do {
|
||||
m = s.head[--p];s.head[p] = (m >= wsize ? m - wsize : 0);} while (--n);n = wsize;p = n;do {
|
||||
m = s.prev[--p];s.prev[p] = (m >= wsize ? m - wsize : 0);} while (--n);};let HASH_ZLIB = (s, prev, data) => ((prev << s.hash_shift) ^ data) & s.hash_mask;let HASH = HASH_ZLIB;const flush_pending = (strm) => {
|
||||
const s = strm.state;let len = s.pending;if (len > strm.avail_out) {
|
||||
len = strm.avail_out;}if (len === 0) { return;}strm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len), strm.next_out);strm.next_out += len;s.pending_out += len;strm.total_out += len;strm.avail_out -= len;s.pending -= len;if (s.pending === 0) {
|
||||
s.pending_out = 0;}};const flush_block_only = (s, last) => {
|
||||
_tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last);s.block_start = s.strstart;flush_pending(s.strm);};const put_byte = (s, b) => {
|
||||
s.pending_buf[s.pending++] = b;};const putShortMSB = (s, b) => {s.pending_buf[s.pending++] = (b >>> 8) & 0xff;s.pending_buf[s.pending++] = b & 0xff;};const read_buf = (strm, buf, start, size) => {let len = strm.avail_in;if (len > size) { len = size;}if (len === 0) { return 0;}strm.avail_in -= len;buf.set(strm.input.subarray(strm.next_in, strm.next_in + len), start);if (strm.state.wrap === 1) {
|
||||
strm.adler = adler32_1(strm.adler, buf, len, start);}else if (strm.state.wrap === 2) {
|
||||
strm.adler = crc32_1(strm.adler, buf, len, start);}strm.next_in += len;strm.total_in += len;return len;};const longest_match = (s, cur_match) => {let chain_length = s.max_chain_length;let scan = s.strstart;let match;let len;let best_len = s.prev_length;let nice_match = s.nice_match;const limit = (s.strstart > (s.w_size - MIN_LOOKAHEAD)) ?
|
||||
s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0;const _win = s.window;const wmask = s.w_mask;const prev = s.prev;const strend = s.strstart + MAX_MATCH;let scan_end1 = _win[scan + best_len - 1];let scan_end = _win[scan + best_len];if (s.prev_length >= s.good_match) {
|
||||
chain_length >>= 2;}if (nice_match > s.lookahead) { nice_match = s.lookahead;}do {match = cur_match;if (_win[match + best_len] !== scan_end ||
|
||||
_win[match + best_len - 1] !== scan_end1 ||
|
||||
_win[match] !== _win[scan] ||
|
||||
_win[++match] !== _win[scan + 1]) {
|
||||
continue;}scan += 2;match++;do {} while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
|
||||
_win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
|
||||
_win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
|
||||
_win[++scan] === _win[++match] && _win[++scan] === _win[++match] &&
|
||||
scan < strend);len = MAX_MATCH - (strend - scan);scan = strend - MAX_MATCH;if (len > best_len) {
|
||||
s.match_start = cur_match;best_len = len;if (len >= nice_match) {
|
||||
break;}scan_end1 = _win[scan + best_len - 1];scan_end = _win[scan + best_len];}} while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);if (best_len <= s.lookahead) {
|
||||
return best_len;}return s.lookahead;};const fill_window = (s) => {const _w_size = s.w_size;let n, more, str;do {
|
||||
more = s.window_size - s.lookahead - s.strstart;if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {s.window.set(s.window.subarray(_w_size, _w_size + _w_size - more), 0);s.match_start -= _w_size;s.strstart -= _w_size;s.block_start -= _w_size;if (s.insert > s.strstart) {
|
||||
s.insert = s.strstart;}slide_hash(s);more += _w_size;}if (s.strm.avail_in === 0) {
|
||||
break;}n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);s.lookahead += n;if (s.lookahead + s.insert >= MIN_MATCH) {
|
||||
str = s.strstart - s.insert;s.ins_h = s.window[str];s.ins_h = HASH(s, s.ins_h, s.window[str + 1]);while (s.insert) {s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);s.prev[str & s.w_mask] = s.head[s.ins_h];s.head[s.ins_h] = str;str++;s.insert--;if (s.lookahead + s.insert < MIN_MATCH) {
|
||||
break;}}}} while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);};const deflate_stored = (s, flush) => {let min_block = s.pending_buf_size - 5 > s.w_size ? s.w_size : s.pending_buf_size - 5;let len, left, have, last = 0;let used = s.strm.avail_in;do {len = 65535;have = (s.bi_valid + 42) >> 3;if (s.strm.avail_out < have) {
|
||||
break;}have = s.strm.avail_out - have;left = s.strstart - s.block_start;if (len > left + s.strm.avail_in) {
|
||||
len = left + s.strm.avail_in;}if (len > have) {
|
||||
len = have;}if (len < min_block && ((len === 0 && flush !== Z_FINISH$3) ||
|
||||
flush === Z_NO_FLUSH$2 ||
|
||||
len !== left + s.strm.avail_in)) {
|
||||
break;}last = flush === Z_FINISH$3 && len === left + s.strm.avail_in ? 1 : 0;_tr_stored_block(s, 0, 0, last);s.pending_buf[s.pending - 4] = len;s.pending_buf[s.pending - 3] = len >> 8;s.pending_buf[s.pending - 2] = ~len;s.pending_buf[s.pending - 1] = ~len >> 8;flush_pending(s.strm);if (left) {
|
||||
if (left > len) {
|
||||
left = len;}s.strm.output.set(s.window.subarray(s.block_start, s.block_start + left), s.strm.next_out);s.strm.next_out += left;s.strm.avail_out -= left;s.strm.total_out += left;s.block_start += left;len -= left;}if (len) {
|
||||
read_buf(s.strm, s.strm.output, s.strm.next_out, len);s.strm.next_out += len;s.strm.avail_out -= len;s.strm.total_out += len;}} while (last === 0);used -= s.strm.avail_in;if (used) {if (used >= s.w_size) {
|
||||
s.matches = 2;s.window.set(s.strm.input.subarray(s.strm.next_in - s.w_size, s.strm.next_in), 0);s.strstart = s.w_size;s.insert = s.strstart;}else {
|
||||
if (s.window_size - s.strstart <= used) {s.strstart -= s.w_size;s.window.set(s.window.subarray(s.w_size, s.w_size + s.strstart), 0);if (s.matches < 2) {
|
||||
s.matches++;}if (s.insert > s.strstart) {
|
||||
s.insert = s.strstart;}}s.window.set(s.strm.input.subarray(s.strm.next_in - used, s.strm.next_in), s.strstart);s.strstart += used;s.insert += used > s.w_size - s.insert ? s.w_size - s.insert : used;}s.block_start = s.strstart;}if (s.high_water < s.strstart) {
|
||||
s.high_water = s.strstart;}if (last) {
|
||||
return BS_FINISH_DONE;}if (flush !== Z_NO_FLUSH$2 && flush !== Z_FINISH$3 &&
|
||||
s.strm.avail_in === 0 && s.strstart === s.block_start) {
|
||||
return BS_BLOCK_DONE;}have = s.window_size - s.strstart;if (s.strm.avail_in > have && s.block_start >= s.w_size) {s.block_start -= s.w_size;s.strstart -= s.w_size;s.window.set(s.window.subarray(s.w_size, s.w_size + s.strstart), 0);if (s.matches < 2) {
|
||||
s.matches++;}have += s.w_size;if (s.insert > s.strstart) {
|
||||
s.insert = s.strstart;}}if (have > s.strm.avail_in) {
|
||||
have = s.strm.avail_in;}if (have) {
|
||||
read_buf(s.strm, s.window, s.strstart, have);s.strstart += have;s.insert += have > s.w_size - s.insert ? s.w_size - s.insert : have;}if (s.high_water < s.strstart) {
|
||||
s.high_water = s.strstart;}have = (s.bi_valid + 42) >> 3;have = s.pending_buf_size - have > 65535 ? 65535 : s.pending_buf_size - have;min_block = have > s.w_size ? s.w_size : have;left = s.strstart - s.block_start;if (left >= min_block ||
|
||||
((left || flush === Z_FINISH$3) && flush !== Z_NO_FLUSH$2 &&
|
||||
s.strm.avail_in === 0 && left <= have)) {
|
||||
len = left > have ? have : left;last = flush === Z_FINISH$3 && s.strm.avail_in === 0 &&
|
||||
len === left ? 1 : 0;_tr_stored_block(s, s.block_start, len, last);s.block_start += len;flush_pending(s.strm);}return last ? BS_FINISH_STARTED : BS_NEED_MORE;};const deflate_fast = (s, flush) => {let hash_head;let bflush;for (;;) {if (s.lookahead < MIN_LOOKAHEAD) {
|
||||
fill_window(s);if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH$2) {
|
||||
return BS_NEED_MORE;}if (s.lookahead === 0) {
|
||||
break;}}hash_head = 0;if (s.lookahead >= MIN_MATCH) {s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];s.head[s.ins_h] = s.strstart;}if (hash_head !== 0 && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) {s.match_length = longest_match(s, hash_head);}if (s.match_length >= MIN_MATCH) {bflush = _tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);s.lookahead -= s.match_length;if (s.match_length <= s.max_lazy_match && s.lookahead >= MIN_MATCH) {
|
||||
s.match_length--;do {
|
||||
s.strstart++;s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];s.head[s.ins_h] = s.strstart;} while (--s.match_length !== 0);s.strstart++;} else {
|
||||
s.strstart += s.match_length;s.match_length = 0;s.ins_h = s.window[s.strstart];s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]);}} else {bflush = _tr_tally(s, 0, s.window[s.strstart]);s.lookahead--;s.strstart++;}if (bflush) {flush_block_only(s, false);if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;}}}s.insert = ((s.strstart < (MIN_MATCH - 1)) ? s.strstart : MIN_MATCH - 1);if (flush === Z_FINISH$3) {flush_block_only(s, true);if (s.strm.avail_out === 0) {
|
||||
return BS_FINISH_STARTED;}return BS_FINISH_DONE;}if (s.sym_next) {flush_block_only(s, false);if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;}}return BS_BLOCK_DONE;};const deflate_slow = (s, flush) => {let hash_head;let bflush;let max_insert;for (;;) {if (s.lookahead < MIN_LOOKAHEAD) {
|
||||
fill_window(s);if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH$2) {
|
||||
return BS_NEED_MORE;}if (s.lookahead === 0) { break;}
|
||||
}hash_head = 0;if (s.lookahead >= MIN_MATCH) {s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];s.head[s.ins_h] = s.strstart;}s.prev_length = s.match_length;s.prev_match = s.match_start;s.match_length = MIN_MATCH - 1;if (hash_head !== 0 && s.prev_length < s.max_lazy_match &&
|
||||
s.strstart - hash_head <= (s.w_size - MIN_LOOKAHEAD)) {s.match_length = longest_match(s, hash_head);if (s.match_length <= 5 &&
|
||||
(s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096))) {s.match_length = MIN_MATCH - 1;}}if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {
|
||||
max_insert = s.strstart + s.lookahead - MIN_MATCH;bflush = _tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);s.lookahead -= s.prev_length - 1;s.prev_length -= 2;do {
|
||||
if (++s.strstart <= max_insert) {s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];s.head[s.ins_h] = s.strstart;}} while (--s.prev_length !== 0);s.match_available = 0;s.match_length = MIN_MATCH - 1;s.strstart++;if (bflush) {flush_block_only(s, false);if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;}}} else if (s.match_available) {bflush = _tr_tally(s, 0, s.window[s.strstart - 1]);if (bflush) {flush_block_only(s, false);}s.strstart++;s.lookahead--;if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;}} else {s.match_available = 1;s.strstart++;s.lookahead--;}}if (s.match_available) {bflush = _tr_tally(s, 0, s.window[s.strstart - 1]);s.match_available = 0;}s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;if (flush === Z_FINISH$3) {flush_block_only(s, true);if (s.strm.avail_out === 0) {
|
||||
return BS_FINISH_STARTED;}return BS_FINISH_DONE;}if (s.sym_next) {flush_block_only(s, false);if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;}}return BS_BLOCK_DONE;};const deflate_rle = (s, flush) => {let bflush;let prev;let scan, strend;const _win = s.window;for (;;) {if (s.lookahead <= MAX_MATCH) {
|
||||
fill_window(s);if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH$2) {
|
||||
return BS_NEED_MORE;}if (s.lookahead === 0) { break;}
|
||||
}s.match_length = 0;if (s.lookahead >= MIN_MATCH && s.strstart > 0) {
|
||||
scan = s.strstart - 1;prev = _win[scan];if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {
|
||||
strend = s.strstart + MAX_MATCH;do {} while (prev === _win[++scan] && prev === _win[++scan] &&
|
||||
prev === _win[++scan] && prev === _win[++scan] &&
|
||||
prev === _win[++scan] && prev === _win[++scan] &&
|
||||
prev === _win[++scan] && prev === _win[++scan] &&
|
||||
scan < strend);s.match_length = MAX_MATCH - (strend - scan);if (s.match_length > s.lookahead) {
|
||||
s.match_length = s.lookahead;}}}if (s.match_length >= MIN_MATCH) {bflush = _tr_tally(s, 1, s.match_length - MIN_MATCH);s.lookahead -= s.match_length;s.strstart += s.match_length;s.match_length = 0;} else {bflush = _tr_tally(s, 0, s.window[s.strstart]);s.lookahead--;s.strstart++;}if (bflush) {flush_block_only(s, false);if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;}}}s.insert = 0;if (flush === Z_FINISH$3) {flush_block_only(s, true);if (s.strm.avail_out === 0) {
|
||||
return BS_FINISH_STARTED;}return BS_FINISH_DONE;}if (s.sym_next) {flush_block_only(s, false);if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;}}return BS_BLOCK_DONE;};const deflate_huff = (s, flush) => {let bflush;for (;;) {if (s.lookahead === 0) {
|
||||
fill_window(s);if (s.lookahead === 0) {
|
||||
if (flush === Z_NO_FLUSH$2) {
|
||||
return BS_NEED_MORE;}break;}}s.match_length = 0;bflush = _tr_tally(s, 0, s.window[s.strstart]);s.lookahead--;s.strstart++;if (bflush) {flush_block_only(s, false);if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;}}}s.insert = 0;if (flush === Z_FINISH$3) {flush_block_only(s, true);if (s.strm.avail_out === 0) {
|
||||
return BS_FINISH_STARTED;}return BS_FINISH_DONE;}if (s.sym_next) {flush_block_only(s, false);if (s.strm.avail_out === 0) {
|
||||
return BS_NEED_MORE;}}return BS_BLOCK_DONE;};function Config(good_length, max_lazy, nice_length, max_chain, func) {this.good_length = good_length;this.max_lazy = max_lazy;this.nice_length = nice_length;this.max_chain = max_chain;this.func = func;}const configuration_table = [new Config(0, 0, 0, 0, deflate_stored),
|
||||
new Config(4, 4, 8, 4, deflate_fast),new Config(4, 5, 16, 8, deflate_fast),
|
||||
new Config(4, 6, 32, 32, deflate_fast), new Config(4, 4, 16, 16, deflate_slow),
|
||||
new Config(8, 16, 32, 32, deflate_slow),new Config(8, 16, 128, 128, deflate_slow),
|
||||
new Config(8, 32, 128, 256, deflate_slow),
|
||||
new Config(32, 128, 258, 1024, deflate_slow),
|
||||
new Config(32, 258, 258, 4096, deflate_slow)
|
||||
];const lm_init = (s) => {s.window_size = 2 * s.w_size;zero(s.head);s.max_lazy_match = configuration_table[s.level].max_lazy;s.good_match = configuration_table[s.level].good_length;s.nice_match = configuration_table[s.level].nice_length;s.max_chain_length = configuration_table[s.level].max_chain;s.strstart = 0;s.block_start = 0;s.lookahead = 0;s.insert = 0;s.match_length = s.prev_length = MIN_MATCH - 1;s.match_available = 0;s.ins_h = 0;};function DeflateState() {
|
||||
this.strm = null;this.status = 0;this.pending_buf = null;this.pending_buf_size = 0;this.pending_out = 0;this.pending = 0;this.wrap = 0;this.gzhead = null;this.gzindex = 0;this.method = Z_DEFLATED$2;this.last_flush = -1;this.w_size = 0;this.w_bits = 0;this.w_mask = 0;this.window = null;this.window_size = 0;this.prev = null;this.head = null;this.ins_h = 0;this.hash_size = 0;this.hash_bits = 0;this.hash_mask = 0;this.hash_shift = 0;this.block_start = 0;this.match_length = 0;this.prev_match = 0;this.match_available = 0;this.strstart = 0;this.match_start = 0;this.lookahead = 0;this.prev_length = 0;this.max_chain_length = 0;this.max_lazy_match = 0;this.level = 0;this.strategy = 0;this.good_match = 0;this.nice_match = 0;this.dyn_ltree = new Uint16Array(HEAP_SIZE * 2);this.dyn_dtree = new Uint16Array((2 * D_CODES + 1) * 2);this.bl_tree = new Uint16Array((2 * BL_CODES + 1) * 2);zero(this.dyn_ltree);zero(this.dyn_dtree);zero(this.bl_tree);this.l_desc = null;this.d_desc = null;this.bl_desc = null;this.bl_count = new Uint16Array(MAX_BITS + 1);this.heap = new Uint16Array(2 * L_CODES + 1);zero(this.heap);this.heap_len = 0;this.heap_max = 0;this.depth = new Uint16Array(2 * L_CODES + 1);zero(this.depth);this.sym_buf = 0;this.lit_bufsize = 0;this.sym_next = 0;this.sym_end = 0;this.opt_len = 0;this.static_len = 0;this.matches = 0;this.insert = 0;this.bi_buf = 0;this.bi_valid = 0;}const deflateStateCheck = (strm) => {if (!strm) {
|
||||
return 1;}const s = strm.state;if (!s || s.strm !== strm || (s.status !== INIT_STATE &&s.status !== GZIP_STATE &&s.status !== EXTRA_STATE &&
|
||||
s.status !== NAME_STATE &&
|
||||
s.status !== COMMENT_STATE &&
|
||||
s.status !== HCRC_STATE &&
|
||||
s.status !== BUSY_STATE &&
|
||||
s.status !== FINISH_STATE)) {
|
||||
return 1;}return 0;};const deflateResetKeep = (strm) => {if (deflateStateCheck(strm)) {
|
||||
return err(strm, Z_STREAM_ERROR$2);}strm.total_in = strm.total_out = 0;strm.data_type = Z_UNKNOWN;const s = strm.state;s.pending = 0;s.pending_out = 0;if (s.wrap < 0) {
|
||||
s.wrap = -s.wrap;}s.status =s.wrap === 2 ? GZIP_STATE :s.wrap ? INIT_STATE : BUSY_STATE;strm.adler = (s.wrap === 2) ?
|
||||
0
|
||||
:
|
||||
1;s.last_flush = -2;_tr_init(s);return Z_OK$3;};const deflateReset = (strm) => {const ret = deflateResetKeep(strm);if (ret === Z_OK$3) {
|
||||
lm_init(strm.state);}return ret;};const deflateSetHeader = (strm, head) => {if (deflateStateCheck(strm) || strm.state.wrap !== 2) {
|
||||
return Z_STREAM_ERROR$2;}strm.state.gzhead = head;return Z_OK$3;};const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => {if (!strm) {
|
||||
return Z_STREAM_ERROR$2;}let wrap = 1;if (level === Z_DEFAULT_COMPRESSION$1) {
|
||||
level = 6;}if (windowBits < 0) {
|
||||
wrap = 0;windowBits = -windowBits;}else if (windowBits > 15) {
|
||||
wrap = 2;windowBits -= 16;}if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED$2 ||
|
||||
windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
|
||||
strategy < 0 || strategy > Z_FIXED || (windowBits === 8 && wrap !== 1)) {
|
||||
return err(strm, Z_STREAM_ERROR$2);}if (windowBits === 8) {
|
||||
windowBits = 9;}const s = new DeflateState();strm.state = s;s.strm = strm;s.status = INIT_STATE;s.wrap = wrap;s.gzhead = null;s.w_bits = windowBits;s.w_size = 1 << s.w_bits;s.w_mask = s.w_size - 1;s.hash_bits = memLevel + 7;s.hash_size = 1 << s.hash_bits;s.hash_mask = s.hash_size - 1;s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);s.window = new Uint8Array(s.w_size * 2);s.head = new Uint16Array(s.hash_size);s.prev = new Uint16Array(s.w_size);s.lit_bufsize = 1 << (memLevel + 6);s.pending_buf_size = s.lit_bufsize * 4;s.pending_buf = new Uint8Array(s.pending_buf_size);s.sym_buf = s.lit_bufsize;s.sym_end = (s.lit_bufsize - 1) * 3;s.level = level;s.strategy = strategy;s.method = method;return deflateReset(strm);};const deflateInit = (strm, level) => {return deflateInit2(strm, level, Z_DEFLATED$2, MAX_WBITS$1, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY$1);};const deflate$2 = (strm, flush) => {if (deflateStateCheck(strm) || flush > Z_BLOCK$1 || flush < 0) {
|
||||
return strm ? err(strm, Z_STREAM_ERROR$2) : Z_STREAM_ERROR$2;}const s = strm.state;if (!strm.output ||
|
||||
(strm.avail_in !== 0 && !strm.input) ||
|
||||
(s.status === FINISH_STATE && flush !== Z_FINISH$3)) {
|
||||
return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR$1 : Z_STREAM_ERROR$2);}const old_flush = s.last_flush;s.last_flush = flush;if (s.pending !== 0) {
|
||||
flush_pending(strm);if (strm.avail_out === 0) {s.last_flush = -1;return Z_OK$3;}} else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) &&
|
||||
flush !== Z_FINISH$3) {
|
||||
return err(strm, Z_BUF_ERROR$1);}if (s.status === FINISH_STATE && strm.avail_in !== 0) {
|
||||
return err(strm, Z_BUF_ERROR$1);}if (s.status === INIT_STATE && s.wrap === 0) {
|
||||
s.status = BUSY_STATE;}if (s.status === INIT_STATE) {let header = (Z_DEFLATED$2 + ((s.w_bits - 8) << 4)) << 8;let level_flags = -1;if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
|
||||
level_flags = 0;} else if (s.level < 6) {
|
||||
level_flags = 1;} else if (s.level === 6) {
|
||||
level_flags = 2;} else {
|
||||
level_flags = 3;}header |= (level_flags << 6);if (s.strstart !== 0) { header |= PRESET_DICT;}header += 31 - (header % 31);putShortMSB(s, header);if (s.strstart !== 0) {
|
||||
putShortMSB(s, strm.adler >>> 16);putShortMSB(s, strm.adler & 0xffff);}strm.adler = 1;s.status = BUSY_STATE;flush_pending(strm);if (s.pending !== 0) {
|
||||
s.last_flush = -1;return Z_OK$3;}}if (s.status === GZIP_STATE) {strm.adler = 0;put_byte(s, 31);put_byte(s, 139);put_byte(s, 8);if (!s.gzhead) {
|
||||
put_byte(s, 0);put_byte(s, 0);put_byte(s, 0);put_byte(s, 0);put_byte(s, 0);put_byte(s, s.level === 9 ? 2 :
|
||||
(s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
|
||||
4 : 0));put_byte(s, OS_CODE);s.status = BUSY_STATE;flush_pending(strm);if (s.pending !== 0) {
|
||||
s.last_flush = -1;return Z_OK$3;}}else {
|
||||
put_byte(s, (s.gzhead.text ? 1 : 0) +
|
||||
(s.gzhead.hcrc ? 2 : 0) +
|
||||
(!s.gzhead.extra ? 0 : 4) +
|
||||
(!s.gzhead.name ? 0 : 8) +
|
||||
(!s.gzhead.comment ? 0 : 16)
|
||||
);put_byte(s, s.gzhead.time & 0xff);put_byte(s, (s.gzhead.time >> 8) & 0xff);put_byte(s, (s.gzhead.time >> 16) & 0xff);put_byte(s, (s.gzhead.time >> 24) & 0xff);put_byte(s, s.level === 9 ? 2 :
|
||||
(s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ?
|
||||
4 : 0));put_byte(s, s.gzhead.os & 0xff);if (s.gzhead.extra && s.gzhead.extra.length) {
|
||||
put_byte(s, s.gzhead.extra.length & 0xff);put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);}if (s.gzhead.hcrc) {
|
||||
strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending, 0);}s.gzindex = 0;s.status = EXTRA_STATE;}}if (s.status === EXTRA_STATE) {
|
||||
if (s.gzhead.extra) {
|
||||
let beg = s.pending;let left = (s.gzhead.extra.length & 0xffff) - s.gzindex;while (s.pending + left > s.pending_buf_size) {
|
||||
let copy = s.pending_buf_size - s.pending;s.pending_buf.set(s.gzhead.extra.subarray(s.gzindex, s.gzindex + copy), s.pending);s.pending = s.pending_buf_size;if (s.gzhead.hcrc && s.pending > beg) {
|
||||
strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);}s.gzindex += copy;flush_pending(strm);if (s.pending !== 0) {
|
||||
s.last_flush = -1;return Z_OK$3;}beg = 0;left -= copy;}let gzhead_extra = new Uint8Array(s.gzhead.extra);s.pending_buf.set(gzhead_extra.subarray(s.gzindex, s.gzindex + left), s.pending);s.pending += left;if (s.gzhead.hcrc && s.pending > beg) {
|
||||
strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);}s.gzindex = 0;}s.status = NAME_STATE;}if (s.status === NAME_STATE) {
|
||||
if (s.gzhead.name) {
|
||||
let beg = s.pending;let val;do {
|
||||
if (s.pending === s.pending_buf_size) {if (s.gzhead.hcrc && s.pending > beg) {
|
||||
strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);}flush_pending(strm);if (s.pending !== 0) {
|
||||
s.last_flush = -1;return Z_OK$3;}beg = 0;}if (s.gzindex < s.gzhead.name.length) {
|
||||
val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;} else {
|
||||
val = 0;}put_byte(s, val);} while (val !== 0);if (s.gzhead.hcrc && s.pending > beg) {
|
||||
strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);}s.gzindex = 0;}s.status = COMMENT_STATE;}if (s.status === COMMENT_STATE) {
|
||||
if (s.gzhead.comment) {
|
||||
let beg = s.pending;let val;do {
|
||||
if (s.pending === s.pending_buf_size) {if (s.gzhead.hcrc && s.pending > beg) {
|
||||
strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);}flush_pending(strm);if (s.pending !== 0) {
|
||||
s.last_flush = -1;return Z_OK$3;}beg = 0;}if (s.gzindex < s.gzhead.comment.length) {
|
||||
val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;} else {
|
||||
val = 0;}put_byte(s, val);} while (val !== 0);if (s.gzhead.hcrc && s.pending > beg) {
|
||||
strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);}}s.status = HCRC_STATE;}if (s.status === HCRC_STATE) {
|
||||
if (s.gzhead.hcrc) {
|
||||
if (s.pending + 2 > s.pending_buf_size) {
|
||||
flush_pending(strm);if (s.pending !== 0) {
|
||||
s.last_flush = -1;return Z_OK$3;}}put_byte(s, strm.adler & 0xff);put_byte(s, (strm.adler >> 8) & 0xff);strm.adler = 0;}s.status = BUSY_STATE;flush_pending(strm);if (s.pending !== 0) {
|
||||
s.last_flush = -1;return Z_OK$3;}}if (strm.avail_in !== 0 || s.lookahead !== 0 ||
|
||||
(flush !== Z_NO_FLUSH$2 && s.status !== FINISH_STATE)) {
|
||||
let bstate = s.level === 0 ? deflate_stored(s, flush) :
|
||||
s.strategy === Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
|
||||
s.strategy === Z_RLE ? deflate_rle(s, flush) :
|
||||
configuration_table[s.level].func(s, flush);if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {
|
||||
s.status = FINISH_STATE;}if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {
|
||||
if (strm.avail_out === 0) {
|
||||
s.last_flush = -1;}return Z_OK$3;}if (bstate === BS_BLOCK_DONE) {
|
||||
if (flush === Z_PARTIAL_FLUSH) {
|
||||
_tr_align(s);}else if (flush !== Z_BLOCK$1) { _tr_stored_block(s, 0, 0, false);if (flush === Z_FULL_FLUSH$1) {zero(s.head);if (s.lookahead === 0) {
|
||||
s.strstart = 0;s.block_start = 0;s.insert = 0;}}}flush_pending(strm);if (strm.avail_out === 0) {
|
||||
s.last_flush = -1;return Z_OK$3;}}}if (flush !== Z_FINISH$3) { return Z_OK$3;}if (s.wrap <= 0) { return Z_STREAM_END$3;}if (s.wrap === 2) {
|
||||
put_byte(s, strm.adler & 0xff);put_byte(s, (strm.adler >> 8) & 0xff);put_byte(s, (strm.adler >> 16) & 0xff);put_byte(s, (strm.adler >> 24) & 0xff);put_byte(s, strm.total_in & 0xff);put_byte(s, (strm.total_in >> 8) & 0xff);put_byte(s, (strm.total_in >> 16) & 0xff);put_byte(s, (strm.total_in >> 24) & 0xff);}else {
|
||||
putShortMSB(s, strm.adler >>> 16);putShortMSB(s, strm.adler & 0xffff);}flush_pending(strm);if (s.wrap > 0) { s.wrap = -s.wrap;}return s.pending !== 0 ? Z_OK$3 : Z_STREAM_END$3;};const deflateEnd = (strm) => {if (deflateStateCheck(strm)) {
|
||||
return Z_STREAM_ERROR$2;}const status = strm.state.status;strm.state = null;return status === BUSY_STATE ? err(strm, Z_DATA_ERROR$2) : Z_OK$3;};const deflateSetDictionary = (strm, dictionary) => {let dictLength = dictionary.length;if (deflateStateCheck(strm)) {
|
||||
return Z_STREAM_ERROR$2;}const s = strm.state;const wrap = s.wrap;if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {
|
||||
return Z_STREAM_ERROR$2;}if (wrap === 1) {strm.adler = adler32_1(strm.adler, dictionary, dictLength, 0);}s.wrap = 0;if (dictLength >= s.w_size) {
|
||||
if (wrap === 0) {zero(s.head);s.strstart = 0;s.block_start = 0;s.insert = 0;}let tmpDict = new Uint8Array(s.w_size);tmpDict.set(dictionary.subarray(dictLength - s.w_size, dictLength), 0);dictionary = tmpDict;dictLength = s.w_size;}const avail = strm.avail_in;const next = strm.next_in;const input = strm.input;strm.avail_in = dictLength;strm.next_in = 0;strm.input = dictionary;fill_window(s);while (s.lookahead >= MIN_MATCH) {
|
||||
let str = s.strstart;let n = s.lookahead - (MIN_MATCH - 1);do {s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);s.prev[str & s.w_mask] = s.head[s.ins_h];s.head[s.ins_h] = str;str++;} while (--n);s.strstart = str;s.lookahead = MIN_MATCH - 1;fill_window(s);}s.strstart += s.lookahead;s.block_start = s.strstart;s.insert = s.lookahead;s.lookahead = 0;s.match_length = s.prev_length = MIN_MATCH - 1;s.match_available = 0;strm.next_in = next;strm.input = input;strm.avail_in = avail;s.wrap = wrap;return Z_OK$3;};let deflateInit_1 = deflateInit;let deflateInit2_1 = deflateInit2;let deflateReset_1 = deflateReset;let deflateResetKeep_1 = deflateResetKeep;let deflateSetHeader_1 = deflateSetHeader;let deflate_2$1 = deflate$2;let deflateEnd_1 = deflateEnd;let deflateSetDictionary_1 = deflateSetDictionary;let deflateInfo = 'pako deflate (from Nodeca project)';let deflate_1$2 = {
|
||||
deflateInit: deflateInit_1,deflateInit2: deflateInit2_1,deflateReset: deflateReset_1,deflateResetKeep: deflateResetKeep_1,deflateSetHeader: deflateSetHeader_1,deflate: deflate_2$1,deflateEnd: deflateEnd_1,deflateSetDictionary: deflateSetDictionary_1,deflateInfo: deflateInfo
|
||||
};const _has = (obj, key) => {
|
||||
return Object.prototype.hasOwnProperty.call(obj, key);};let assign = function (obj ) {
|
||||
const sources = Array.prototype.slice.call(arguments, 1);while (sources.length) {
|
||||
const source = sources.shift();if (!source) { continue;}if (typeof source !== 'object') {
|
||||
throw new TypeError(source + 'must be non-object');}for (const p in source) {
|
||||
if (_has(source, p)) {
|
||||
obj[p] = source[p];}}}return obj;};let flattenChunks = (chunks) => {let len = 0;for (let i = 0, l = chunks.length;i < l;i++) {
|
||||
len += chunks[i].length;}const result = new Uint8Array(len);for (let i = 0, pos = 0, l = chunks.length;i < l;i++) {
|
||||
let chunk = chunks[i];result.set(chunk, pos);pos += chunk.length;}return result;};let common = {
|
||||
assign: assign,flattenChunks: flattenChunks
|
||||
};let STR_APPLY_UIA_OK = true;try { String.fromCharCode.apply(null, new Uint8Array(1));} catch (__) { STR_APPLY_UIA_OK = false;}const _utf8len = new Uint8Array(256);for (let q = 0;q < 256;q++) {
|
||||
_utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);}_utf8len[254] = _utf8len[254] = 1;let string2buf = (str) => {
|
||||
if (typeof TextEncoder === 'function' && TextEncoder.prototype.encode) {
|
||||
return new TextEncoder().encode(str);}let buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;for (m_pos = 0;m_pos < str_len;m_pos++) {
|
||||
c = str.charCodeAt(m_pos);if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
|
||||
c2 = str.charCodeAt(m_pos + 1);if ((c2 & 0xfc00) === 0xdc00) {
|
||||
c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);m_pos++;}}buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;}buf = new Uint8Array(buf_len);for (i = 0, m_pos = 0;i < buf_len;m_pos++) {
|
||||
c = str.charCodeAt(m_pos);if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
|
||||
c2 = str.charCodeAt(m_pos + 1);if ((c2 & 0xfc00) === 0xdc00) {
|
||||
c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);m_pos++;}}if (c < 0x80) {buf[i++] = c;} else if (c < 0x800) {buf[i++] = 0xC0 | (c >>> 6);buf[i++] = 0x80 | (c & 0x3f);} else if (c < 0x10000) {buf[i++] = 0xE0 | (c >>> 12);buf[i++] = 0x80 | (c >>> 6 & 0x3f);buf[i++] = 0x80 | (c & 0x3f);} else {buf[i++] = 0xf0 | (c >>> 18);buf[i++] = 0x80 | (c >>> 12 & 0x3f);buf[i++] = 0x80 | (c >>> 6 & 0x3f);buf[i++] = 0x80 | (c & 0x3f);}}return buf;};const buf2binstring = (buf, len) => {if (len < 65534) {
|
||||
if (buf.subarray && STR_APPLY_UIA_OK) {
|
||||
return String.fromCharCode.apply(null, buf.length === len ? buf : buf.subarray(0, len));}}let result = '';for (let i = 0;i < len;i++) {
|
||||
result += String.fromCharCode(buf[i]);}return result;};let buf2string = (buf, max) => {
|
||||
const len = max || buf.length;if (typeof TextDecoder === 'function' && TextDecoder.prototype.decode) {
|
||||
return new TextDecoder().decode(buf.subarray(0, max));}let i, out;const utf16buf = new Array(len * 2);for (out = 0, i = 0;i < len;) {
|
||||
let c = buf[i++];if (c < 0x80) { utf16buf[out++] = c;continue;}let c_len = _utf8len[c];if (c_len > 4) { utf16buf[out++] = 0xfffd;i += c_len - 1;continue;}c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;while (c_len > 1 && i < len) {
|
||||
c = (c << 6) | (buf[i++] & 0x3f);c_len--;}if (c_len > 1) { utf16buf[out++] = 0xfffd;continue;}if (c < 0x10000) {
|
||||
utf16buf[out++] = c;} else {
|
||||
c -= 0x10000;utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);utf16buf[out++] = 0xdc00 | (c & 0x3ff);}}return buf2binstring(utf16buf, out);};let utf8border = (buf, max) => {max = max || buf.length;if (max > buf.length) { max = buf.length;}let pos = max - 1;while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--;}if (pos < 0) { return max;}if (pos === 0) { return max;}return (pos + _utf8len[buf[pos]] > max) ? pos : max;};let strings = {
|
||||
string2buf: string2buf,buf2string: buf2string,utf8border: utf8border
|
||||
};function ZStream() {this.input = null;this.next_in = 0;this.avail_in = 0;this.total_in = 0;this.output = null;this.next_out = 0;this.avail_out = 0;this.total_out = 0;this.msg = '';this.state = null;this.data_type = 2;this.adler = 0;}let zstream = ZStream;const toString$1 = Object.prototype.toString;const {
|
||||
Z_NO_FLUSH: Z_NO_FLUSH$1, Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH: Z_FINISH$2,Z_OK: Z_OK$2, Z_STREAM_END: Z_STREAM_END$2,Z_DEFAULT_COMPRESSION,Z_DEFAULT_STRATEGY,Z_DEFLATED: Z_DEFLATED$1
|
||||
} = constants$2;function Deflate$1(options) {
|
||||
this.options = common.assign({
|
||||
level: Z_DEFAULT_COMPRESSION,method: Z_DEFLATED$1,chunkSize: 16384,windowBits: 15,memLevel: 8,strategy: Z_DEFAULT_STRATEGY
|
||||
}, options || {});let opt = this.options;if (opt.raw && (opt.windowBits > 0)) {
|
||||
opt.windowBits = -opt.windowBits;}else if (opt.gzip && (opt.windowBits > 0) && (opt.windowBits < 16)) {
|
||||
opt.windowBits += 16;}this.err = 0;this.msg = '';this.ended = false;this.chunks = [];this.strm = new zstream();this.strm.avail_out = 0;let status = deflate_1$2.deflateInit2(
|
||||
this.strm,opt.level,opt.method,opt.windowBits,opt.memLevel,opt.strategy
|
||||
);if (status !== Z_OK$2) {
|
||||
throw new Error(messages[status]);}if (opt.header) {
|
||||
deflate_1$2.deflateSetHeader(this.strm, opt.header);}if (opt.dictionary) {
|
||||
let dict;if (typeof opt.dictionary === 'string') {dict = strings.string2buf(opt.dictionary);} else if (toString$1.call(opt.dictionary) === '[object ArrayBuffer]') {
|
||||
dict = new Uint8Array(opt.dictionary);} else {
|
||||
dict = opt.dictionary;}status = deflate_1$2.deflateSetDictionary(this.strm, dict);if (status !== Z_OK$2) {
|
||||
throw new Error(messages[status]);}this._dict_set = true;}}Deflate$1.prototype.push = function (data, flush_mode) {
|
||||
const strm = this.strm;const chunkSize = this.options.chunkSize;let status, _flush_mode;if (this.ended) { return false;}if (flush_mode === ~~flush_mode) _flush_mode = flush_mode;else _flush_mode = flush_mode === true ? Z_FINISH$2 : Z_NO_FLUSH$1;if (typeof data === 'string') {strm.input = strings.string2buf(data);} else if (toString$1.call(data) === '[object ArrayBuffer]') {
|
||||
strm.input = new Uint8Array(data);} else {
|
||||
strm.input = data;}strm.next_in = 0;strm.avail_in = strm.input.length;for (;;) {
|
||||
if (strm.avail_out === 0) {
|
||||
strm.output = new Uint8Array(chunkSize);strm.next_out = 0;strm.avail_out = chunkSize;}if ((_flush_mode === Z_SYNC_FLUSH || _flush_mode === Z_FULL_FLUSH) && strm.avail_out <= 6) {
|
||||
this.onData(strm.output.subarray(0, strm.next_out));strm.avail_out = 0;continue;}status = deflate_1$2.deflate(strm, _flush_mode);if (status === Z_STREAM_END$2) {
|
||||
if (strm.next_out > 0) {
|
||||
this.onData(strm.output.subarray(0, strm.next_out));}status = deflate_1$2.deflateEnd(this.strm);this.onEnd(status);this.ended = true;return status === Z_OK$2;}if (strm.avail_out === 0) {
|
||||
this.onData(strm.output);continue;}if (_flush_mode > 0 && strm.next_out > 0) {
|
||||
this.onData(strm.output.subarray(0, strm.next_out));strm.avail_out = 0;continue;}if (strm.avail_in === 0) break;}return true;};Deflate$1.prototype.onData = function (chunk) {
|
||||
this.chunks.push(chunk);};Deflate$1.prototype.onEnd = function (status) {if (status === Z_OK$2) {
|
||||
this.result = common.flattenChunks(this.chunks);}this.chunks = [];this.err = status;this.msg = this.strm.msg;};function deflate$1(input, options) {
|
||||
const deflator = new Deflate$1(options);deflator.push(input, true);if (deflator.err) { throw deflator.msg || messages[deflator.err];}return deflator.result;}function deflateRaw$1(input, options) {
|
||||
options = options || {};options.raw = true;return deflate$1(input, options);}function gzip$1(input, options) {
|
||||
options = options || {};options.gzip = true;return deflate$1(input, options);}let Deflate_1$1 = Deflate$1;let deflate_2 = deflate$1;let deflateRaw_1$1 = deflateRaw$1;let gzip_1$1 = gzip$1;let constants$1 = constants$2;let deflate_1$1 = {
|
||||
Deflate: Deflate_1$1,deflate: deflate_2,deflateRaw: deflateRaw_1$1,gzip: gzip_1$1,constants: constants$1
|
||||
};const BAD$1 = 16209;const TYPE$1 = 16191;let inffast = function inflate_fast(strm, start) {
|
||||
let _in;let last;let _out;let beg;let end;let dmax;let wsize;let whave;let wnext;let s_window;let hold;let bits;let lcode;let dcode;let lmask;let dmask;let here;let op;let len;let dist;let from;let from_source;let input, output;const state = strm.state;_in = strm.next_in;input = strm.input;last = _in + (strm.avail_in - 5);_out = strm.next_out;output = strm.output;beg = _out - (start - strm.avail_out);end = _out + (strm.avail_out - 257);dmax = state.dmax;wsize = state.wsize;whave = state.whave;wnext = state.wnext;s_window = state.window;hold = state.hold;bits = state.bits;lcode = state.lencode;dcode = state.distcode;lmask = (1 << state.lenbits) - 1;dmask = (1 << state.distbits) - 1;top:
|
||||
do {
|
||||
if (bits < 15) {
|
||||
hold += input[_in++] << bits;bits += 8;hold += input[_in++] << bits;bits += 8;}here = lcode[hold & lmask];dolen:
|
||||
for (;;) {
|
||||
op = here >>> 24;hold >>>= op;bits -= op;op = (here >>> 16) & 0xff;if (op === 0) { output[_out++] = here & 0xffff;}else if (op & 16) {
|
||||
len = here & 0xffff;op &= 15;if (op) {
|
||||
if (bits < op) {
|
||||
hold += input[_in++] << bits;bits += 8;}len += hold & ((1 << op) - 1);hold >>>= op;bits -= op;}if (bits < 15) {
|
||||
hold += input[_in++] << bits;bits += 8;hold += input[_in++] << bits;bits += 8;}here = dcode[hold & dmask];dodist:
|
||||
for (;;) {
|
||||
op = here >>> 24;hold >>>= op;bits -= op;op = (here >>> 16) & 0xff;if (op & 16) {
|
||||
dist = here & 0xffff;op &= 15;if (bits < op) {
|
||||
hold += input[_in++] << bits;bits += 8;if (bits < op) {
|
||||
hold += input[_in++] << bits;bits += 8;}}dist += hold & ((1 << op) - 1);if (dist > dmax) {
|
||||
strm.msg = 'invalid distance too far back';state.mode = BAD$1;break top;}hold >>>= op;bits -= op;op = _out - beg;if (dist > op) {
|
||||
op = dist - op;if (op > whave) {
|
||||
if (state.sane) {
|
||||
strm.msg = 'invalid distance too far back';state.mode = BAD$1;break top;}}from = 0;from_source = s_window;if (wnext === 0) {
|
||||
from += wsize - op;if (op < len) {
|
||||
len -= op;do {
|
||||
output[_out++] = s_window[from++];} while (--op);from = _out - dist;from_source = output;}}else if (wnext < op) {
|
||||
from += wsize + wnext - op;op -= wnext;if (op < len) {
|
||||
len -= op;do {
|
||||
output[_out++] = s_window[from++];} while (--op);from = 0;if (wnext < len) {
|
||||
op = wnext;len -= op;do {
|
||||
output[_out++] = s_window[from++];} while (--op);from = _out - dist;from_source = output;}}}else {
|
||||
from += wnext - op;if (op < len) {
|
||||
len -= op;do {
|
||||
output[_out++] = s_window[from++];} while (--op);from = _out - dist;from_source = output;}}while (len > 2) {
|
||||
output[_out++] = from_source[from++];output[_out++] = from_source[from++];output[_out++] = from_source[from++];len -= 3;}if (len) {
|
||||
output[_out++] = from_source[from++];if (len > 1) {
|
||||
output[_out++] = from_source[from++];}}}else {
|
||||
from = _out - dist;do {
|
||||
output[_out++] = output[from++];output[_out++] = output[from++];output[_out++] = output[from++];len -= 3;} while (len > 2);if (len) {
|
||||
output[_out++] = output[from++];if (len > 1) {
|
||||
output[_out++] = output[from++];}}}}else if ((op & 64) === 0) {
|
||||
here = dcode[(here & 0xffff) + (hold & ((1 << op) - 1))];continue dodist;}else {
|
||||
strm.msg = 'invalid distance code';state.mode = BAD$1;break top;}break;}}else if ((op & 64) === 0) {
|
||||
here = lcode[(here & 0xffff) + (hold & ((1 << op) - 1))];continue dolen;}else if (op & 32) {state.mode = TYPE$1;break top;}else {
|
||||
strm.msg = 'invalid literal/length code';state.mode = BAD$1;break top;}break;}} while (_in < last && _out < end);len = bits >> 3;_in -= len;bits -= len << 3;hold &= (1 << bits) - 1;strm.next_in = _in;strm.next_out = _out;strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));state.hold = hold;state.bits = bits;return;};const MAXBITS = 15;const ENOUGH_LENS$1 = 852;const ENOUGH_DISTS$1 = 592;const CODES$1 = 0;const LENS$1 = 1;const DISTS$1 = 2;const lbase = new Uint16Array([
|
||||
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
|
||||
]);const lext = new Uint8Array([
|
||||
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78
|
||||
]);const dbase = new Uint16Array([
|
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,8193, 12289, 16385, 24577, 0, 0
|
||||
]);const dext = new Uint8Array([
|
||||
16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,23, 23, 24, 24, 25, 25, 26, 26, 27, 27,28, 28, 29, 29, 64, 64
|
||||
]);const inflate_table = (type, lens, lens_index, codes, table, table_index, work, opts) => {
|
||||
const bits = opts.bits;let len = 0;let sym = 0;let min = 0, max = 0;let root = 0;let curr = 0;let drop = 0;let left = 0;let used = 0;let huff = 0;let incr;let fill;let low;let mask;let next;let base = null;let match;const count = new Uint16Array(MAXBITS + 1);const offs = new Uint16Array(MAXBITS + 1);let extra = null;let here_bits, here_op, here_val;for (len = 0;len <= MAXBITS;len++) {
|
||||
count[len] = 0;}for (sym = 0;sym < codes;sym++) {
|
||||
count[lens[lens_index + sym]]++;}root = bits;for (max = MAXBITS;max >= 1;max--) {
|
||||
if (count[max] !== 0) { break;}}if (root > max) {
|
||||
root = max;}if (max === 0) {table[table_index++] = (1 << 24) | (64 << 16) | 0;table[table_index++] = (1 << 24) | (64 << 16) | 0;opts.bits = 1;return 0;}for (min = 1;min < max;min++) {
|
||||
if (count[min] !== 0) { break;}}if (root < min) {
|
||||
root = min;}left = 1;for (len = 1;len <= MAXBITS;len++) {
|
||||
left <<= 1;left -= count[len];if (left < 0) {
|
||||
return -1;}
|
||||
}if (left > 0 && (type === CODES$1 || max !== 1)) {
|
||||
return -1;}offs[1] = 0;for (len = 1;len < MAXBITS;len++) {
|
||||
offs[len + 1] = offs[len] + count[len];}for (sym = 0;sym < codes;sym++) {
|
||||
if (lens[lens_index + sym] !== 0) {
|
||||
work[offs[lens[lens_index + sym]]++] = sym;}}if (type === CODES$1) {
|
||||
base = extra = work;match = 20;} else if (type === LENS$1) {
|
||||
base = lbase;extra = lext;match = 257;} else {
|
||||
base = dbase;extra = dext;match = 0;}huff = 0;sym = 0;len = min;next = table_index;curr = root;drop = 0;low = -1;used = 1 << root;mask = used - 1;if ((type === LENS$1 && used > ENOUGH_LENS$1) ||
|
||||
(type === DISTS$1 && used > ENOUGH_DISTS$1)) {
|
||||
return 1;}for (;;) {here_bits = len - drop;if (work[sym] + 1 < match) {
|
||||
here_op = 0;here_val = work[sym];}else if (work[sym] >= match) {
|
||||
here_op = extra[work[sym] - match];here_val = base[work[sym] - match];}else {
|
||||
here_op = 32 + 64;here_val = 0;}incr = 1 << (len - drop);fill = 1 << curr;min = fill;do {
|
||||
fill -= incr;table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val | 0;} while (fill !== 0);incr = 1 << (len - 1);while (huff & incr) {
|
||||
incr >>= 1;}if (incr !== 0) {
|
||||
huff &= incr - 1;huff += incr;} else {
|
||||
huff = 0;}sym++;if (--count[len] === 0) {
|
||||
if (len === max) { break;}len = lens[lens_index + work[sym]];}if (len > root && (huff & mask) !== low) {if (drop === 0) {
|
||||
drop = root;}next += min;curr = len - drop;left = 1 << curr;while (curr + drop < max) {
|
||||
left -= count[curr + drop];if (left <= 0) { break;}curr++;left <<= 1;}used += 1 << curr;if ((type === LENS$1 && used > ENOUGH_LENS$1) ||
|
||||
(type === DISTS$1 && used > ENOUGH_DISTS$1)) {
|
||||
return 1;}low = huff & mask;table[low] = (root << 24) | (curr << 16) | (next - table_index) | 0;}}if (huff !== 0) {table[next + huff] = ((len - drop) << 24) | (64 << 16) | 0;}opts.bits = root;return 0;};let inftrees = inflate_table;const CODES = 0;const LENS = 1;const DISTS = 2;const {
|
||||
Z_FINISH: Z_FINISH$1, Z_BLOCK, Z_TREES,Z_OK: Z_OK$1, Z_STREAM_END: Z_STREAM_END$1, Z_NEED_DICT: Z_NEED_DICT$1, Z_STREAM_ERROR: Z_STREAM_ERROR$1, Z_DATA_ERROR: Z_DATA_ERROR$1, Z_MEM_ERROR: Z_MEM_ERROR$1, Z_BUF_ERROR,Z_DEFLATED
|
||||
} = constants$2;const HEAD = 16180;const FLAGS = 16181;const TIME = 16182;const OS = 16183;const EXLEN = 16184;const EXTRA = 16185;const NAME = 16186;const COMMENT = 16187;const HCRC = 16188;const DICTID = 16189;const DICT = 16190;const TYPE = 16191;const TYPEDO = 16192;const STORED = 16193;const COPY_ = 16194;const COPY = 16195;const TABLE = 16196;const LENLENS = 16197;const CODELENS = 16198;const LEN_ = 16199;const LEN = 16200;const LENEXT = 16201;const DIST = 16202;const DISTEXT = 16203;const MATCH = 16204;const LIT = 16205;const CHECK = 16206;const LENGTH = 16207;const DONE = 16208;const BAD = 16209;const MEM = 16210;const SYNC = 16211;const ENOUGH_LENS = 852;const ENOUGH_DISTS = 592;const MAX_WBITS = 15;const DEF_WBITS = MAX_WBITS;const zswap32 = (q) => {return (((q >>> 24) & 0xff) +
|
||||
((q >>> 8) & 0xff00) +
|
||||
((q & 0xff00) << 8) +
|
||||
((q & 0xff) << 24));};function InflateState() {
|
||||
this.strm = null;this.mode = 0;this.last = false;this.wrap = 0;this.havedict = false;this.flags = 0;this.dmax = 0;this.check = 0;this.total = 0;this.head = null;this.wbits = 0;this.wsize = 0;this.whave = 0;this.wnext = 0;this.window = null;this.hold = 0;this.bits = 0;this.length = 0;this.offset = 0;this.extra = 0;this.lencode = null;this.distcode = null;this.lenbits = 0;this.distbits = 0;this.ncode = 0;this.nlen = 0;this.ndist = 0;this.have = 0;this.next = null;this.lens = new Uint16Array(320);this.work = new Uint16Array(288);this.lendyn = null;this.distdyn = null;this.sane = 0;this.back = 0;this.was = 0;}const inflateStateCheck = (strm) => {if (!strm) {
|
||||
return 1;}const state = strm.state;if (!state || state.strm !== strm ||
|
||||
state.mode < HEAD || state.mode > SYNC) {
|
||||
return 1;}return 0;};const inflateResetKeep = (strm) => {if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1;}const state = strm.state;strm.total_in = strm.total_out = state.total = 0;strm.msg = '';if (state.wrap) {
|
||||
strm.adler = state.wrap & 1;}state.mode = HEAD;state.last = 0;state.havedict = 0;state.flags = -1;state.dmax = 32768;state.head = null;state.hold = 0;state.bits = 0;state.lencode = state.lendyn = new Int32Array(ENOUGH_LENS);state.distcode = state.distdyn = new Int32Array(ENOUGH_DISTS);state.sane = 1;state.back = -1;return Z_OK$1;};const inflateReset = (strm) => {if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1;}const state = strm.state;state.wsize = 0;state.whave = 0;state.wnext = 0;return inflateResetKeep(strm);};const inflateReset2 = (strm, windowBits) => {
|
||||
let wrap;if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1;}const state = strm.state;if (windowBits < 0) {
|
||||
wrap = 0;windowBits = -windowBits;}else {
|
||||
wrap = (windowBits >> 4) + 5;if (windowBits < 48) {
|
||||
windowBits &= 15;}}if (windowBits && (windowBits < 8 || windowBits > 15)) {
|
||||
return Z_STREAM_ERROR$1;}if (state.window !== null && state.wbits !== windowBits) {
|
||||
state.window = null;}state.wrap = wrap;state.wbits = windowBits;return inflateReset(strm);};const inflateInit2 = (strm, windowBits) => {if (!strm) { return Z_STREAM_ERROR$1;}const state = new InflateState();strm.state = state;state.strm = strm;state.window = null;state.mode = HEAD;const ret = inflateReset2(strm, windowBits);if (ret !== Z_OK$1) {
|
||||
strm.state = null;}return ret;};const inflateInit = (strm) => {return inflateInit2(strm, DEF_WBITS);};let virgin = true;let lenfix, distfix;const fixedtables = (state) => {if (virgin) {
|
||||
lenfix = new Int32Array(512);distfix = new Int32Array(32);let sym = 0;while (sym < 144) { state.lens[sym++] = 8;}while (sym < 256) { state.lens[sym++] = 9;}while (sym < 280) { state.lens[sym++] = 7;}while (sym < 288) { state.lens[sym++] = 8;}inftrees(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });sym = 0;while (sym < 32) { state.lens[sym++] = 5;}inftrees(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });virgin = false;}state.lencode = lenfix;state.lenbits = 9;state.distcode = distfix;state.distbits = 5;};const updatewindow = (strm, src, end, copy) => {let dist;const state = strm.state;if (state.window === null) {
|
||||
state.wsize = 1 << state.wbits;state.wnext = 0;state.whave = 0;state.window = new Uint8Array(state.wsize);}if (copy >= state.wsize) {
|
||||
state.window.set(src.subarray(end - state.wsize, end), 0);state.wnext = 0;state.whave = state.wsize;}else {
|
||||
dist = state.wsize - state.wnext;if (dist > copy) {
|
||||
dist = copy;}state.window.set(src.subarray(end - copy, end - copy + dist), state.wnext);copy -= dist;if (copy) {state.window.set(src.subarray(end - copy, end), 0);state.wnext = copy;state.whave = state.wsize;}else {
|
||||
state.wnext += dist;if (state.wnext === state.wsize) { state.wnext = 0;}if (state.whave < state.wsize) { state.whave += dist;}}}return 0;};const inflate$2 = (strm, flush) => {let state;let input, output;let next;let put;let have, left;let hold;let bits;let _in, _out;let copy;let from;let from_source;let here = 0;let here_bits, here_op, here_val;let last_bits, last_op, last_val;let len;let ret;const hbuf = new Uint8Array(4);let opts;let n;const order =
|
||||
new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);if (inflateStateCheck(strm) || !strm.output ||
|
||||
(!strm.input && strm.avail_in !== 0)) {
|
||||
return Z_STREAM_ERROR$1;}state = strm.state;if (state.mode === TYPE) { state.mode = TYPEDO;} put = strm.next_out;output = strm.output;left = strm.avail_out;next = strm.next_in;input = strm.input;have = strm.avail_in;hold = state.hold;bits = state.bits;_in = have;_out = left;ret = Z_OK$1;inf_leave:
|
||||
for (;;) {
|
||||
switch (state.mode) {
|
||||
case HEAD:
|
||||
if (state.wrap === 0) {
|
||||
state.mode = TYPEDO;break;}while (bits < 16) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}if ((state.wrap & 2) && hold === 0x8b1f) {
|
||||
if (state.wbits === 0) {
|
||||
state.wbits = 15;}state.check = 0;hbuf[0] = hold & 0xff;hbuf[1] = (hold >>> 8) & 0xff;state.check = crc32_1(state.check, hbuf, 2, 0);hold = 0;bits = 0;state.mode = FLAGS;break;}if (state.head) {
|
||||
state.head.done = false;}if (!(state.wrap & 1) ||
|
||||
(((hold & 0xff) << 8) + (hold >> 8)) % 31) {
|
||||
strm.msg = 'incorrect header check';state.mode = BAD;break;}if ((hold & 0x0f) !== Z_DEFLATED) {
|
||||
strm.msg = 'unknown compression method';state.mode = BAD;break;}hold >>>= 4;bits -= 4;len = (hold & 0x0f) + 8;if (state.wbits === 0) {
|
||||
state.wbits = len;}if (len > 15 || len > state.wbits) {
|
||||
strm.msg = 'invalid window size';state.mode = BAD;break;}state.dmax = 1 << state.wbits;state.flags = 0;strm.adler = state.check = 1;state.mode = hold & 0x200 ? DICTID : TYPE;hold = 0;bits = 0;break;case FLAGS:while (bits < 16) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}state.flags = hold;if ((state.flags & 0xff) !== Z_DEFLATED) {
|
||||
strm.msg = 'unknown compression method';state.mode = BAD;break;}if (state.flags & 0xe000) {
|
||||
strm.msg = 'unknown header flags set';state.mode = BAD;break;}if (state.head) {
|
||||
state.head.text = ((hold >> 8) & 1);}if ((state.flags & 0x0200) && (state.wrap & 4)) {hbuf[0] = hold & 0xff;hbuf[1] = (hold >>> 8) & 0xff;state.check = crc32_1(state.check, hbuf, 2, 0);}hold = 0;bits = 0;state.mode = TIME;case TIME:while (bits < 32) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}if (state.head) {
|
||||
state.head.time = hold;}if ((state.flags & 0x0200) && (state.wrap & 4)) {hbuf[0] = hold & 0xff;hbuf[1] = (hold >>> 8) & 0xff;hbuf[2] = (hold >>> 16) & 0xff;hbuf[3] = (hold >>> 24) & 0xff;state.check = crc32_1(state.check, hbuf, 4, 0);}hold = 0;bits = 0;state.mode = OS;case OS:while (bits < 16) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}if (state.head) {
|
||||
state.head.xflags = (hold & 0xff);state.head.os = (hold >> 8);}if ((state.flags & 0x0200) && (state.wrap & 4)) {hbuf[0] = hold & 0xff;hbuf[1] = (hold >>> 8) & 0xff;state.check = crc32_1(state.check, hbuf, 2, 0);}hold = 0;bits = 0;state.mode = EXLEN;case EXLEN:
|
||||
if (state.flags & 0x0400) {while (bits < 16) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}state.length = hold;if (state.head) {
|
||||
state.head.extra_len = hold;}if ((state.flags & 0x0200) && (state.wrap & 4)) {hbuf[0] = hold & 0xff;hbuf[1] = (hold >>> 8) & 0xff;state.check = crc32_1(state.check, hbuf, 2, 0);}hold = 0;bits = 0;}else if (state.head) {
|
||||
state.head.extra = null;}state.mode = EXTRA;case EXTRA:
|
||||
if (state.flags & 0x0400) {
|
||||
copy = state.length;if (copy > have) { copy = have;}if (copy) {
|
||||
if (state.head) {
|
||||
len = state.head.extra_len - state.length;if (!state.head.extra) {state.head.extra = new Uint8Array(state.head.extra_len);}state.head.extra.set(
|
||||
input.subarray(
|
||||
next,next + copy
|
||||
),len
|
||||
);}if ((state.flags & 0x0200) && (state.wrap & 4)) {
|
||||
state.check = crc32_1(state.check, input, copy, next);}have -= copy;next += copy;state.length -= copy;}if (state.length) { break inf_leave;}}state.length = 0;state.mode = NAME;case NAME:
|
||||
if (state.flags & 0x0800) {
|
||||
if (have === 0) { break inf_leave;}copy = 0;do {len = input[next + copy++];if (state.head && len &&
|
||||
(state.length < 65536 )) {
|
||||
state.head.name += String.fromCharCode(len);}} while (len && copy < have);if ((state.flags & 0x0200) && (state.wrap & 4)) {
|
||||
state.check = crc32_1(state.check, input, copy, next);}have -= copy;next += copy;if (len) { break inf_leave;}}else if (state.head) {
|
||||
state.head.name = null;}state.length = 0;state.mode = COMMENT;case COMMENT:
|
||||
if (state.flags & 0x1000) {
|
||||
if (have === 0) { break inf_leave;}copy = 0;do {
|
||||
len = input[next + copy++];if (state.head && len &&
|
||||
(state.length < 65536 )) {
|
||||
state.head.comment += String.fromCharCode(len);}} while (len && copy < have);if ((state.flags & 0x0200) && (state.wrap & 4)) {
|
||||
state.check = crc32_1(state.check, input, copy, next);}have -= copy;next += copy;if (len) { break inf_leave;}}else if (state.head) {
|
||||
state.head.comment = null;}state.mode = HCRC;case HCRC:
|
||||
if (state.flags & 0x0200) {while (bits < 16) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}if ((state.wrap & 4) && hold !== (state.check & 0xffff)) {
|
||||
strm.msg = 'header crc mismatch';state.mode = BAD;break;}hold = 0;bits = 0;}if (state.head) {
|
||||
state.head.hcrc = ((state.flags >> 9) & 1);state.head.done = true;}strm.adler = state.check = 0;state.mode = TYPE;break;case DICTID:while (bits < 32) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}strm.adler = state.check = zswap32(hold);hold = 0;bits = 0;state.mode = DICT;case DICT:
|
||||
if (state.havedict === 0) {strm.next_out = put;strm.avail_out = left;strm.next_in = next;strm.avail_in = have;state.hold = hold;state.bits = bits;return Z_NEED_DICT$1;}strm.adler = state.check = 1;state.mode = TYPE;case TYPE:
|
||||
if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave;}case TYPEDO:
|
||||
if (state.last) {hold >>>= bits & 7;bits -= bits & 7;state.mode = CHECK;break;}while (bits < 3) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}state.last = (hold & 0x01);hold >>>= 1;bits -= 1;switch ((hold & 0x03)) {
|
||||
case 0: state.mode = STORED;break;case 1:
|
||||
fixedtables(state);state.mode = LEN_;if (flush === Z_TREES) {hold >>>= 2;bits -= 2;break inf_leave;}break;case 2: state.mode = TABLE;break;case 3:
|
||||
strm.msg = 'invalid block type';state.mode = BAD;}hold >>>= 2;bits -= 2;break;case STORED:hold >>>= bits & 7;bits -= bits & 7;while (bits < 32) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {
|
||||
strm.msg = 'invalid stored block lengths';state.mode = BAD;break;}state.length = hold & 0xffff;hold = 0;bits = 0;state.mode = COPY_;if (flush === Z_TREES) { break inf_leave;}case COPY_:
|
||||
state.mode = COPY;case COPY:
|
||||
copy = state.length;if (copy) {
|
||||
if (copy > have) { copy = have;}if (copy > left) { copy = left;}if (copy === 0) { break inf_leave;}output.set(input.subarray(next, next + copy), put);have -= copy;next += copy;left -= copy;put += copy;state.length -= copy;break;}state.mode = TYPE;break;case TABLE:while (bits < 14) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}state.nlen = (hold & 0x1f) + 257;hold >>>= 5;bits -= 5;state.ndist = (hold & 0x1f) + 1;hold >>>= 5;bits -= 5;state.ncode = (hold & 0x0f) + 4;hold >>>= 4;bits -= 4;if (state.nlen > 286 || state.ndist > 30) {
|
||||
strm.msg = 'too many length or distance symbols';state.mode = BAD;break;}state.have = 0;state.mode = LENLENS;case LENLENS:
|
||||
while (state.have < state.ncode) {while (bits < 3) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}state.lens[order[state.have++]] = (hold & 0x07);hold >>>= 3;bits -= 3;}while (state.have < 19) {
|
||||
state.lens[order[state.have++]] = 0;}state.lencode = state.lendyn;state.lenbits = 7;opts = { bits: state.lenbits };ret = inftrees(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);state.lenbits = opts.bits;if (ret) {
|
||||
strm.msg = 'invalid code lengths set';state.mode = BAD;break;}state.have = 0;state.mode = CODELENS;case CODELENS:
|
||||
while (state.have < state.nlen + state.ndist) {
|
||||
for (;;) {
|
||||
here = state.lencode[hold & ((1 << state.lenbits) - 1)];here_bits = here >>> 24;here_op = (here >>> 16) & 0xff;here_val = here & 0xffff;if ((here_bits) <= bits) { break;}if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}if (here_val < 16) {hold >>>= here_bits;bits -= here_bits;state.lens[state.have++] = here_val;}else {
|
||||
if (here_val === 16) {n = here_bits + 2;while (bits < n) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}hold >>>= here_bits;bits -= here_bits;if (state.have === 0) {
|
||||
strm.msg = 'invalid bit length repeat';state.mode = BAD;break;}len = state.lens[state.have - 1];copy = 3 + (hold & 0x03);hold >>>= 2;bits -= 2;}else if (here_val === 17) {n = here_bits + 3;while (bits < n) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}hold >>>= here_bits;bits -= here_bits;len = 0;copy = 3 + (hold & 0x07);hold >>>= 3;bits -= 3;}else {n = here_bits + 7;while (bits < n) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}hold >>>= here_bits;bits -= here_bits;len = 0;copy = 11 + (hold & 0x7f);hold >>>= 7;bits -= 7;}if (state.have + copy > state.nlen + state.ndist) {
|
||||
strm.msg = 'invalid bit length repeat';state.mode = BAD;break;}while (copy--) {
|
||||
state.lens[state.have++] = len;}}}if (state.mode === BAD) { break;}if (state.lens[256] === 0) {
|
||||
strm.msg = 'invalid code -- missing end-of-block';state.mode = BAD;break;}state.lenbits = 9;opts = { bits: state.lenbits };ret = inftrees(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);state.lenbits = opts.bits;if (ret) {
|
||||
strm.msg = 'invalid literal/lengths set';state.mode = BAD;break;}state.distbits = 6;state.distcode = state.distdyn;opts = { bits: state.distbits };ret = inftrees(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);state.distbits = opts.bits;if (ret) {
|
||||
strm.msg = 'invalid distances set';state.mode = BAD;break;}state.mode = LEN_;if (flush === Z_TREES) { break inf_leave;}case LEN_:
|
||||
state.mode = LEN;case LEN:
|
||||
if (have >= 6 && left >= 258) {strm.next_out = put;strm.avail_out = left;strm.next_in = next;strm.avail_in = have;state.hold = hold;state.bits = bits;inffast(strm, _out);put = strm.next_out;output = strm.output;left = strm.avail_out;next = strm.next_in;input = strm.input;have = strm.avail_in;hold = state.hold;bits = state.bits;if (state.mode === TYPE) {
|
||||
state.back = -1;}break;}state.back = 0;for (;;) {
|
||||
here = state.lencode[hold & ((1 << state.lenbits) - 1)];here_bits = here >>> 24;here_op = (here >>> 16) & 0xff;here_val = here & 0xffff;if (here_bits <= bits) { break;}if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}if (here_op && (here_op & 0xf0) === 0) {
|
||||
last_bits = here_bits;last_op = here_op;last_val = here_val;for (;;) {
|
||||
here = state.lencode[last_val +
|
||||
((hold & ((1 << (last_bits + last_op)) - 1)) >> last_bits)];here_bits = here >>> 24;here_op = (here >>> 16) & 0xff;here_val = here & 0xffff;if ((last_bits + here_bits) <= bits) { break;}if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}hold >>>= last_bits;bits -= last_bits;state.back += last_bits;}hold >>>= here_bits;bits -= here_bits;state.back += here_bits;state.length = here_val;if (here_op === 0) {state.mode = LIT;break;}if (here_op & 32) {state.back = -1;state.mode = TYPE;break;}if (here_op & 64) {
|
||||
strm.msg = 'invalid literal/length code';state.mode = BAD;break;}state.extra = here_op & 15;state.mode = LENEXT;case LENEXT:
|
||||
if (state.extra) {n = state.extra;while (bits < n) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}state.length += hold & ((1 << state.extra) - 1);hold >>>= state.extra;bits -= state.extra;state.back += state.extra;}state.was = state.length;state.mode = DIST;case DIST:
|
||||
for (;;) {
|
||||
here = state.distcode[hold & ((1 << state.distbits) - 1)];here_bits = here >>> 24;here_op = (here >>> 16) & 0xff;here_val = here & 0xffff;if ((here_bits) <= bits) { break;}if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}if ((here_op & 0xf0) === 0) {
|
||||
last_bits = here_bits;last_op = here_op;last_val = here_val;for (;;) {
|
||||
here = state.distcode[last_val +
|
||||
((hold & ((1 << (last_bits + last_op)) - 1)) >> last_bits)];here_bits = here >>> 24;here_op = (here >>> 16) & 0xff;here_val = here & 0xffff;if ((last_bits + here_bits) <= bits) { break;}if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}hold >>>= last_bits;bits -= last_bits;state.back += last_bits;}hold >>>= here_bits;bits -= here_bits;state.back += here_bits;if (here_op & 64) {
|
||||
strm.msg = 'invalid distance code';state.mode = BAD;break;}state.offset = here_val;state.extra = (here_op) & 15;state.mode = DISTEXT;case DISTEXT:
|
||||
if (state.extra) {n = state.extra;while (bits < n) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}state.offset += hold & ((1 << state.extra) - 1);hold >>>= state.extra;bits -= state.extra;state.back += state.extra;}if (state.offset > state.dmax) {
|
||||
strm.msg = 'invalid distance too far back';state.mode = BAD;break;}state.mode = MATCH;case MATCH:
|
||||
if (left === 0) { break inf_leave;}copy = _out - left;if (state.offset > copy) {
|
||||
copy = state.offset - copy;if (copy > state.whave) {
|
||||
if (state.sane) {
|
||||
strm.msg = 'invalid distance too far back';state.mode = BAD;break;}}if (copy > state.wnext) {
|
||||
copy -= state.wnext;from = state.wsize - copy;}else {
|
||||
from = state.wnext - copy;}if (copy > state.length) { copy = state.length;}from_source = state.window;}else {
|
||||
from_source = output;from = put - state.offset;copy = state.length;}if (copy > left) { copy = left;}left -= copy;state.length -= copy;do {
|
||||
output[put++] = from_source[from++];} while (--copy);if (state.length === 0) { state.mode = LEN;}break;case LIT:
|
||||
if (left === 0) { break inf_leave;}output[put++] = state.length;left--;state.mode = LEN;break;case CHECK:
|
||||
if (state.wrap) {while (bits < 32) {
|
||||
if (have === 0) { break inf_leave;}have--;hold |= input[next++] << bits;bits += 8;}_out -= left;strm.total_out += _out;state.total += _out;if ((state.wrap & 4) && _out) {
|
||||
strm.adler = state.check =(state.flags ? crc32_1(state.check, output, _out, put - _out) : adler32_1(state.check, output, _out, put - _out));}_out = left;if ((state.wrap & 4) && (state.flags ? hold : zswap32(hold)) !== state.check) {
|
||||
strm.msg = 'incorrect data check';state.mode = BAD;break;}hold = 0;bits = 0;}state.mode = LENGTH;case LENGTH:
|
||||
if (state.wrap && state.flags) {while (bits < 32) {
|
||||
if (have === 0) { break inf_leave;}have--;hold += input[next++] << bits;bits += 8;}if ((state.wrap & 4) && hold !== (state.total & 0xffffffff)) {
|
||||
strm.msg = 'incorrect length check';state.mode = BAD;break;}hold = 0;bits = 0;}state.mode = DONE;case DONE:
|
||||
ret = Z_STREAM_END$1;break inf_leave;case BAD:
|
||||
ret = Z_DATA_ERROR$1;break inf_leave;case MEM:
|
||||
return Z_MEM_ERROR$1;case SYNC:default:
|
||||
return Z_STREAM_ERROR$1;}}strm.next_out = put;strm.avail_out = left;strm.next_in = next;strm.avail_in = have;state.hold = hold;state.bits = bits;if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&
|
||||
(state.mode < CHECK || flush !== Z_FINISH$1))) {
|
||||
if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out));}_in -= strm.avail_in;_out -= strm.avail_out;strm.total_in += _in;strm.total_out += _out;state.total += _out;if ((state.wrap & 4) && _out) {
|
||||
strm.adler = state.check =
|
||||
(state.flags ? crc32_1(state.check, output, _out, strm.next_out - _out) : adler32_1(state.check, output, _out, strm.next_out - _out));}strm.data_type = state.bits + (state.last ? 64 : 0) +
|
||||
(state.mode === TYPE ? 128 : 0) +
|
||||
(state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);if (((_in === 0 && _out === 0) || flush === Z_FINISH$1) && ret === Z_OK$1) {
|
||||
ret = Z_BUF_ERROR;}return ret;};const inflateEnd = (strm) => {if (inflateStateCheck(strm)) {
|
||||
return Z_STREAM_ERROR$1;}let state = strm.state;if (state.window) {
|
||||
state.window = null;}strm.state = null;return Z_OK$1;};const inflateGetHeader = (strm, head) => {if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1;}const state = strm.state;if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR$1;}state.head = head;head.done = false;return Z_OK$1;};const inflateSetDictionary = (strm, dictionary) => {
|
||||
const dictLength = dictionary.length;let state;let dictid;let ret;if (inflateStateCheck(strm)) { return Z_STREAM_ERROR$1;}state = strm.state;if (state.wrap !== 0 && state.mode !== DICT) {
|
||||
return Z_STREAM_ERROR$1;}if (state.mode === DICT) {
|
||||
dictid = 1;dictid = adler32_1(dictid, dictionary, dictLength, 0);if (dictid !== state.check) {
|
||||
return Z_DATA_ERROR$1;}}ret = updatewindow(strm, dictionary, dictLength, dictLength);if (ret) {
|
||||
state.mode = MEM;return Z_MEM_ERROR$1;}state.havedict = 1;return Z_OK$1;};let inflateReset_1 = inflateReset;let inflateReset2_1 = inflateReset2;let inflateResetKeep_1 = inflateResetKeep;let inflateInit_1 = inflateInit;let inflateInit2_1 = inflateInit2;let inflate_2$1 = inflate$2;let inflateEnd_1 = inflateEnd;let inflateGetHeader_1 = inflateGetHeader;let inflateSetDictionary_1 = inflateSetDictionary;let inflateInfo = 'pako inflate (from Nodeca project)';let inflate_1$2 = {
|
||||
inflateReset: inflateReset_1,inflateReset2: inflateReset2_1,inflateResetKeep: inflateResetKeep_1,inflateInit: inflateInit_1,inflateInit2: inflateInit2_1,inflate: inflate_2$1,inflateEnd: inflateEnd_1,inflateGetHeader: inflateGetHeader_1,inflateSetDictionary: inflateSetDictionary_1,inflateInfo: inflateInfo
|
||||
};function GZheader() {this.text = 0;this.time = 0;this.xflags = 0;this.os = 0;this.extra = null;this.extra_len = 0;this.name = '';this.comment = '';this.hcrc = 0;this.done = false;}let gzheader = GZheader;const toString = Object.prototype.toString;const {
|
||||
Z_NO_FLUSH, Z_FINISH,Z_OK, Z_STREAM_END, Z_NEED_DICT, Z_STREAM_ERROR, Z_DATA_ERROR, Z_MEM_ERROR
|
||||
} = constants$2;function Inflate$1(options) {
|
||||
this.options = common.assign({
|
||||
chunkSize: 1024 * 64,windowBits: 15,to: ''
|
||||
}, options || {});const opt = this.options;if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) {
|
||||
opt.windowBits = -opt.windowBits;if (opt.windowBits === 0) { opt.windowBits = -15;}}if ((opt.windowBits >= 0) && (opt.windowBits < 16) &&
|
||||
!(options && options.windowBits)) {
|
||||
opt.windowBits += 32;}if ((opt.windowBits > 15) && (opt.windowBits < 48)) {if ((opt.windowBits & 15) === 0) {
|
||||
opt.windowBits |= 15;}}this.err = 0;this.msg = '';this.ended = false;this.chunks = [];this.strm = new zstream();this.strm.avail_out = 0;let status = inflate_1$2.inflateInit2(
|
||||
this.strm,opt.windowBits
|
||||
);if (status !== Z_OK) {
|
||||
throw new Error(messages[status]);}this.header = new gzheader();inflate_1$2.inflateGetHeader(this.strm, this.header);if (opt.dictionary) {if (typeof opt.dictionary === 'string') {
|
||||
opt.dictionary = strings.string2buf(opt.dictionary);} else if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {
|
||||
opt.dictionary = new Uint8Array(opt.dictionary);}if (opt.raw) {
|
||||
status = inflate_1$2.inflateSetDictionary(this.strm, opt.dictionary);if (status !== Z_OK) {
|
||||
throw new Error(messages[status]);}}}}Inflate$1.prototype.push = function (data, flush_mode) {
|
||||
const strm = this.strm;const chunkSize = this.options.chunkSize;const dictionary = this.options.dictionary;let status, _flush_mode, last_avail_out;if (this.ended) return false;if (flush_mode === ~~flush_mode) _flush_mode = flush_mode;else _flush_mode = flush_mode === true ? Z_FINISH : Z_NO_FLUSH;if (toString.call(data) === '[object ArrayBuffer]') {
|
||||
strm.input = new Uint8Array(data);} else {
|
||||
strm.input = data;}strm.next_in = 0;strm.avail_in = strm.input.length;for (;;) {
|
||||
if (strm.avail_out === 0) {
|
||||
strm.output = new Uint8Array(chunkSize);strm.next_out = 0;strm.avail_out = chunkSize;}status = inflate_1$2.inflate(strm, _flush_mode);if (status === Z_NEED_DICT && dictionary) {
|
||||
status = inflate_1$2.inflateSetDictionary(strm, dictionary);if (status === Z_OK) {
|
||||
status = inflate_1$2.inflate(strm, _flush_mode);} else if (status === Z_DATA_ERROR) {status = Z_NEED_DICT;}}while (strm.avail_in > 0 &&
|
||||
status === Z_STREAM_END &&
|
||||
strm.state.wrap > 0 &&
|
||||
data[strm.next_in] !== 0) {
|
||||
inflate_1$2.inflateReset(strm);status = inflate_1$2.inflate(strm, _flush_mode);}switch (status) {
|
||||
case Z_STREAM_ERROR:
|
||||
case Z_DATA_ERROR:
|
||||
case Z_NEED_DICT:
|
||||
case Z_MEM_ERROR:
|
||||
this.onEnd(status);this.ended = true;return false;}last_avail_out = strm.avail_out;if (strm.next_out) {
|
||||
if (strm.avail_out === 0 || status === Z_STREAM_END) {if (this.options.to === 'string') {let next_out_utf8 = strings.utf8border(strm.output, strm.next_out);let tail = strm.next_out - next_out_utf8;let utf8str = strings.buf2string(strm.output, next_out_utf8);strm.next_out = tail;strm.avail_out = chunkSize - tail;if (tail) strm.output.set(strm.output.subarray(next_out_utf8, next_out_utf8 + tail), 0);this.onData(utf8str);} else {
|
||||
this.onData(strm.output.length === strm.next_out ? strm.output : strm.output.subarray(0, strm.next_out));}}}if (status === Z_OK && last_avail_out === 0) continue;if (status === Z_STREAM_END) {
|
||||
status = inflate_1$2.inflateEnd(this.strm);this.onEnd(status);this.ended = true;return true;}if (strm.avail_in === 0) break;}return true;};Inflate$1.prototype.onData = function (chunk) {
|
||||
this.chunks.push(chunk);};Inflate$1.prototype.onEnd = function (status) {if (status === Z_OK) {
|
||||
if (this.options.to === 'string') {
|
||||
this.result = this.chunks.join('');} else {
|
||||
this.result = common.flattenChunks(this.chunks);}}this.chunks = [];this.err = status;this.msg = this.strm.msg;};function inflate$1(input, options) {
|
||||
const inflator = new Inflate$1(options);inflator.push(input);if (inflator.err) throw inflator.msg || messages[inflator.err];return inflator.result;}function inflateRaw$1(input, options) {
|
||||
options = options || {};options.raw = true;return inflate$1(input, options);}let Inflate_1$1 = Inflate$1;let inflate_2 = inflate$1;let inflateRaw_1$1 = inflateRaw$1;let ungzip$1 = inflate$1;let constants = constants$2;let inflate_1$1 = {
|
||||
Inflate: Inflate_1$1,inflate: inflate_2,inflateRaw: inflateRaw_1$1,ungzip: ungzip$1,constants: constants
|
||||
};const { Deflate, deflate, deflateRaw, gzip } = deflate_1$1;const { Inflate, inflate, inflateRaw, ungzip } = inflate_1$1;let Deflate_1 = Deflate;let deflate_1 = deflate;let deflateRaw_1 = deflateRaw;let gzip_1 = gzip;let Inflate_1 = Inflate;let inflate_1 = inflate;let inflateRaw_1 = inflateRaw;let ungzip_1 = ungzip;let constants_1 = constants$2;let pako = {
|
||||
deflate: deflate_1,inflate: inflate_1,constants: constants_1
|
||||
};exports["default"] = pako;exports.deflate = deflate_1;exports.inflate = inflate_1;Object.defineProperty(exports, '__esModule', { value: true });}));
|
||||
148
util/pluginCompression/excalidraw.js
Normal file
148
util/pluginCompression/excalidraw.js
Normal file
|
|
@ -0,0 +1,148 @@
|
|||
export function CanDo(file, str, set) {
|
||||
console.log(str.startsWith(`---\n\nexcalidraw-plugin: parsed\ntags: [excalidraw]\n\n---\n==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠== You can decompress Drawing data with the command palette: \'Decompress current Excalidraw file\'. For more info check in plugin settings under \'Saving\'\n\n\n# Excalidraw Data\n\n`), str.includes("```json"), str)
|
||||
return str.startsWith(`---\n\nexcalidraw-plugin: parsed\ntags: [excalidraw]\n\n---\n==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠== You can decompress Drawing data with the command palette: \'Decompress current Excalidraw file\'. For more info check in plugin settings under \'Saving\'\n\n\n# Excalidraw Data\n\n`) && str.includes("```json")
|
||||
}
|
||||
export function CanUnDo(file, str) {
|
||||
console.log(str.startsWith(`---\n\nexcalidraw-plugin: parsed\ntags: [excalidraw]\n\n---\n==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠== You can decompress Drawing data with the command palette: \'Decompress current Excalidraw file\'. For more info check in plugin settings under \'Saving\'\n\n\n# Excalidraw Data\n\n`), str.includes("```json"), str)
|
||||
return str.startsWith("COMPDATA_-EXCALI:")
|
||||
}
|
||||
var brushTypes = [
|
||||
"line",
|
||||
"ellipse",
|
||||
"diamond",
|
||||
"arrow",
|
||||
"freedraw",
|
||||
"image",
|
||||
"text",
|
||||
"rectangle",
|
||||
]
|
||||
var Styles = {
|
||||
fills: ["cross-hatch", "hachure", "solid"],
|
||||
stroke: ["dotted", "dashed", "solid"],
|
||||
|
||||
}
|
||||
class saveconstruct {
|
||||
constructor(intl, type) {
|
||||
this.out = intl || ""
|
||||
this.type = type
|
||||
}
|
||||
addData(data) {
|
||||
if (this.type && this.type == "master") {
|
||||
this.out += data
|
||||
} else {
|
||||
this.out += data + ","
|
||||
}
|
||||
}
|
||||
export() {
|
||||
if (this.type == "master") return this.out
|
||||
return this.out.substring(0, this.out.length - 1)
|
||||
}
|
||||
}
|
||||
|
||||
export function Compress(file, str, set, BB) {
|
||||
// try {
|
||||
var textdata = str.substring(str.indexOf("## Text Elements"), str.indexOf("%%")).substring(17)
|
||||
var lack = str.substring(str.indexOf("## Drawing"), str.indexOf("%%", str.indexOf("## Drawing"))).substring(18).trim()
|
||||
lack = lack.substring(0, lack.length - 3).trim()
|
||||
console.log(lack)
|
||||
var drawdata = JSON.parse(lack)
|
||||
if (drawdata && drawdata) {
|
||||
let meta = new BB()
|
||||
meta.WU(5, drawdata.version || 2)
|
||||
meta.WU(5, set.ExcalidrawPrecision)
|
||||
drawdata.source.substring(69).split(".").forEach((v) => {
|
||||
meta.WU(5, v)
|
||||
})
|
||||
let bld = new saveconstruct(meta.G(), "master")
|
||||
// let bld = new saveconstruct(drawdata.version + "" + set.ExcalidrawPrecision + "@" + drawdata.source.substring(69), "master")
|
||||
console.log(drawdata)
|
||||
drawdata.elements.forEach((stroke) => {
|
||||
let localStroke = new saveconstruct(";" + stroke.id + ":")
|
||||
// let localStroke = stroke.id + ":"
|
||||
localStroke.addData(brushTypes.indexOf(stroke.type))
|
||||
localStroke.addData(Math.round(stroke.x * (10 ** set.ExcalidrawPrecision)))
|
||||
localStroke.addData(Math.round(stroke.y * (10 ** set.ExcalidrawPrecision)))
|
||||
|
||||
localStroke.addData(Math.round(stroke.width * (10 ** set.ExcalidrawPrecision)))
|
||||
localStroke.addData(Math.round(stroke.height * (10 ** set.ExcalidrawPrecision)))
|
||||
|
||||
localStroke.addData(Math.round(stroke.angle * (10 ** set.ExcalidrawPrecision)) % 360)
|
||||
|
||||
if (stroke.strokeColor.startsWith("#")) {
|
||||
localStroke.addData(stroke.strokeColor.substring(1))
|
||||
} else {
|
||||
localStroke.addData(stroke.strokeColor)
|
||||
}
|
||||
if (stroke.backgroundColor.startsWith("#")) {
|
||||
localStroke.addData(stroke.backgroundColor.substring(1))
|
||||
} else {
|
||||
localStroke.addData(stroke.backgroundColor)
|
||||
}
|
||||
|
||||
if (stroke.backgroundColor.startsWith("#")) {
|
||||
localStroke.addData(stroke.backgroundColor.substring(1))
|
||||
} else {
|
||||
localStroke.addData(stroke.backgroundColor)
|
||||
}
|
||||
|
||||
localStroke.addData(Styles.fills.indexOf(stroke.fillStyle))
|
||||
localStroke.addData(stroke.strokeWidth || 0)
|
||||
localStroke.addData(Styles.stroke.indexOf(stroke.strokeStyle))
|
||||
|
||||
localStroke.addData(stroke.roughness || 0)
|
||||
localStroke.addData(stroke.opacity >= 100 ? -1 : stroke.opacity)
|
||||
|
||||
localStroke.addData((stroke.groupIds && stroke.groupIds.length > 0) ? JSON.stringify(stroke.groupIds) : 0)
|
||||
|
||||
localStroke.addData(stroke.frameId || "")
|
||||
|
||||
localStroke.addData(stroke.index)
|
||||
|
||||
if (stroke.roundness) {
|
||||
localStroke.addData(stroke.roundness.type || 0)
|
||||
} else {
|
||||
localStroke.addData(0)
|
||||
}
|
||||
|
||||
if (stroke.seed && stroke.roughness > 0) {
|
||||
localStroke.addData(stroke.seed)
|
||||
} else {
|
||||
localStroke.addData(0)
|
||||
}
|
||||
|
||||
localStroke.addData(stroke.version || 0)
|
||||
|
||||
localStroke.addData(stroke.versionNonce || 0)
|
||||
|
||||
localStroke.addData(stroke.isDeleted ? 1 : 0)
|
||||
|
||||
localStroke.addData((stroke.boundElements && stroke.boundElements.length > 0) ? JSON.stringify(stroke.boundElements) : 0)
|
||||
|
||||
localStroke.addData(stroke.updated)
|
||||
|
||||
if (stroke.link) {
|
||||
if (stroke.link.startsWith("https://")) {
|
||||
localStroke.addData("”" + stroke.link.substring(8) || "")
|
||||
} else if (stroke.link.startsWith("http://")) {
|
||||
localStroke.addData("⁕" + stroke.link.substring(7) || "")
|
||||
} else {
|
||||
localStroke.addData(stroke.link || "")
|
||||
}
|
||||
}
|
||||
|
||||
localStroke.addData(stroke.locked ? 1 : 0)
|
||||
|
||||
bld.addData(localStroke.export())
|
||||
})
|
||||
console.log(bld.export())
|
||||
return "COMPDATA_-EXCALI:" + bld.export()
|
||||
} else {
|
||||
throw new Error("OOD")
|
||||
}
|
||||
return str
|
||||
// } catch (e) { return undefined }
|
||||
}
|
||||
export function Decompress(file, str, BB) {
|
||||
str = str.substring(7)
|
||||
console.log(str)
|
||||
}
|
||||
|
|
@ -1,4 +1,5 @@
|
|||
{
|
||||
"1.0.1": "0.15.0",
|
||||
"1.1.0": "0.15.0"
|
||||
"1.1.0": "0.15.0",
|
||||
"1.1.2": "0.15.0"
|
||||
}
|
||||
Loading…
Reference in a new issue