@gmvjs/core 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexander Shibisty
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,107 @@
-# Temporary Holding Version
+# @gmvjs/core — the Game Model Viewer core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![Patreon](https://c5.patreon.com/external/logo/become_a_patron_button.png)](https://www.patreon.com/cw/shibisty)
+
+The core of a library for reading game models. It has no game formats at all: only the plugin API, shared model types, a registry with format detection, a viewing session, archives, textures and helper math. Games are added with engine packages (`@gmvjs/xray-v1`, `@gmvjs/source1`…), rendering with the `@gmvjs/renderer` package.
+
+Runs in the browser, in a Web Worker (no DOM) and in Node ≥ 20. ESM only, `sideEffects: false`.
+
+## Installation
+
+```sh
+npm i @gmvjs/core
+```
+
+## Quick start
+
+```ts
+import { createRegistry, ViewerSession } from '@gmvjs/core';
+import { gamebryoEngine } from '@gmvjs/gamebryo';
+
+const session = new ViewerSession(createRegistry([gamebryoEngine]), 'skyrimse');
+session.on('status', ({ text, error }) => console[error ? 'error' : 'log'](text));
+session.on('model', async ({ model }) => {
+  for (let i = 0; i < model.meshes.length; i++) {
+    const t = await session.resolveTexture(i); // { image, label, ok }
+  }
+});
+
+await session.addArchives([meshesBsa, texturesBsa]);
+await session.openEntry(session.archiveModels('chair').items[0]);
+```
+
+Parsing a file only, without a session (Node, Worker):
+
+```ts
+import { createRegistry } from '@gmvjs/core';
+import { idtech3Engine } from '@gmvjs/idtech3';
+
+const reg = createRegistry([idtech3Engine]);
+const det = await reg.detect(file); // { format, confidence, candidates }
+const model = await det!.format.load(file, { files: [file], archives: [], sibling: async () => null, readPath: async () => null });
+```
+
+## Your own engine
+
+```ts
+import { defineEngine, createRegistry, binary, type Model } from '@gmvjs/core';
+
+export const myEngine = defineEngine({
+  id: 'my',
+  title: 'My Engine',
+  formats: [{
+    id: 'my-mesh', title: 'My mesh', engine: 'my', extensions: ['mym'], status: 'beta',
+    sniff: (head) => (binary.hasMagic(head, 'MYM1') ? 1 : 0),
+    load: async (main) => (await import('./parser')).parse(await main.arrayBuffer()) as Model,
+  }],
+  games: [{ id: 'my-game', group: 'Games', title: 'My Game', engine: 'my', formats: ['my-mesh'] }],
+  i18n: { en: { title: 'My Engine', presets: { 'my-game': { title: 'My Game' } } } },
+});
+```
+
+By convention an engine package exports `<id>Engine` from its root and a subpath per game: `@gmvjs/<engine>/<game>` → `{ preset, engine }`, where `engine` is the same engine limited to that game's preset (`pickGames(engine, id)`).
+
+## What's inside
+
+| Module | Purpose |
+|---|---|
+| `types` | `Model`, `Mesh`, `Motion` (`NodeMotion`, `VertexMotion`, extensible by engines), `SkeletonRuntime`, `Lightmap`, `ScreenFx`, `InstancedScene`, `Archive`, `VFile` |
+| `plugin` | `defineEngine`, `EnginePlugin`, `FormatPlugin`, `ArchivePlugin`, `ImageCodec`, `TextureDictionaryPlugin`, `MaterialResolver`, `ExporterPlugin`, `GamePreset`, `pickGames()` |
+| `registry` | `Registry`, `createRegistry()`: plugin collection, detection by extension, path and first bytes, preset by format and folder markers |
+| `session` | `ViewerSession`: files, "Game folder", archives, model loading, textures, normals, PBR, external animations, `status` / `model` / `preset` events; `loadSameDirMotions` |
+| `textures` | `TextureLibrary`: texture lookup by name across all open archives, decoding through engine codecs |
+| `normals`, `surface` | tangents, normal map packing detection (RGB / RG / AG), combining PBR maps |
+| `skeleton` | `NodeSkeleton`: poses for node hierarchies: keys, layers, additive tracks, grid blending |
+| `scene`, `levelbuilder` | scene tree, ray picking, moving instances; building a level from instances by material |
+| `archives` | `createArchive`, folder (`openFolder`), ZIP (`openZip`; PK3/PK4/IWD/PAK) |
+| `codecs` | zlib / raw deflate (`DecompressionStream`) |
+| `images` | DDS (DXT1–5, uncompressed), TGA, PCX; BC4/BC5 (`decodeBC45`) and BC7 (`decodeBC7`) decoders for engines |
+| `writers` | ZIP, DDS (RGBA), OBJ + MTL (the `obj` export) |
+| `i18n` | `setLocale('ru' / 'en')`, `tr()`, `presetText()`, `engineTitle()`, `exporterText()`: English preset texts come from `EnginePlugin.i18n` |
+| `diagnostics` | `buildDiagnostics`, `hexDump`: a report about a failed load |
+| `binary`, `math`, `geometry` | reading binary data, matrices and quaternions, bounds and normals |
+| `builtin` | `coreEngine`: the ZIP archive, DDS/TGA/PCX codecs, OBJ export; `createRegistry` always attaches it |
+
+## API notes
+
+- **`EnginePlugin.i18n`** — `{ en?: { title?, groups?, presets?: Record<id, { title?, hint?, archiveLabel?, motionLabel? }>, exporters?: Record<id, { title?, description?, fields? }> } }`. The registry attaches the texts together with the engine; after `setLocale('en')`, `presetText` / `engineTitle` / `exporterText` return English texts.
+- **`MotionKinds`** — animation kinds by the `kind` field (the core has `node` and `vertex`). An engine adds its own kind by extending the interface, and narrowing by `m.kind` works in application code:
+
+  ```ts
+  declare module '@gmvjs/core/types' { interface MotionKinds { xray: XrayMotion } }
+  ```
+- **`pickGames(engine, ...ids)`** — an engine with only the chosen presets and the formats they reference (archives, codecs and export: all of them). The `@gmvjs/<engine>/<game>` subpaths are built on it. Two slices of one engine in the same registry are merged.
+- **`Registry.presetAvailable(preset)`** — whether the registry has the preset's format. A bridge preset with another package's format (`@gmvjs/source2/gltf`, `@gmvjs/cryengine3/dae` → `@gmvjs/assimp`) is unavailable without it, but the registry does not break.
+- **Module subpaths** `@gmvjs/core/<module>` (`binary`, `geometry`, `math`, `levelbuilder`, `images/dds`, `archives/common`…) are for engine packages.
+
+## Dependencies
+
+None.
+
+## License
+
+MIT
+
+[![Patreon](https://c5.patreon.com/external/logo/become_a_patron_button.png)](https://www.patreon.com/cw/shibisty)
+
+If this project helps you, consider supporting its development on Patreon ❤️

package/dist/archives/common.d.ts

@@ -0,0 +1,28 @@
+import type { Archive, ArchiveEntry, BlobFile } from '../types';
+/** Extensions that put an entry into the texture index (path without extension). */
+export declare const TEXTURE_RE: RegExp;
+export interface ArchiveSpec<E extends ArchiveEntry> {
+    name: string;
+    kind: string;
+    version: number;
+    entries: E[];
+    read(entry: E): Promise<Uint8Array>;
+    /** Custom lookup function (for example, by path suffix). */
+    lookup?(path: string): E | null;
+    byBase?: Map<string, E>;
+    /** Extra texture keys (default: the full path without extension). */
+    textureKeys?(entry: E): string[];
+    /** Display file name (default: the last path segment). */
+    displayName?(entry: E): string;
+    /** On a duplicate texture key keep the first entry (default: the last one, as in game archives). */
+    keepFirstTextureKey?: boolean;
+    /** Custom file contents (without a copy via read). */
+    fileBytes?(entry: E): Promise<ArrayBuffer>;
+    /** Source file of the entry (folder). */
+    blobOf?(entry: E): BlobFile | null;
+    /** Texture at an exact path that is not in the entry list. */
+    findTexture?(path: string): E | null;
+}
+export declare function createArchive<E extends ArchiveEntry>(spec: ArchiveSpec<E>): Archive;
+/** Read a byte range of the file. */
+export declare const readRange: (file: Blob, start: number, end: number) => Promise<Uint8Array>;

package/dist/archives/common.js

@@ -0,0 +1,45 @@
+import { stripExt, toArrayBuffer, baseName } from "../binary.js";
+const TEXTURE_RE = /\.(dds|tga|png|jpe?g|pcx|bmp|webp|paa|pac|pct|tex|xbt)$/;
+function createArchive(spec) {
+  const index = /* @__PURE__ */ new Map(), byKey = /* @__PURE__ */ new Map(), files = /* @__PURE__ */ new Map();
+  for (const e of spec.entries) {
+    index.set(e.path, e);
+    if (TEXTURE_RE.test(e.path)) {
+      for (const k of spec.textureKeys ? spec.textureKeys(e) : [stripExt(e.path)]) if (!spec.keepFirstTextureKey || !byKey.has(k)) byKey.set(k, e);
+    }
+  }
+  const arch = {
+    name: spec.name,
+    kind: spec.kind,
+    version: spec.version,
+    entries: spec.entries,
+    index,
+    byKey,
+    byBase: spec.byBase,
+    lookup: (p) => spec.lookup ? spec.lookup(p) : index.get(p) ?? null,
+    read: (e) => spec.read(e),
+    blobOf: spec.blobOf ? (e) => spec.blobOf(e) : void 0,
+    findTexture: spec.findTexture ? (p) => spec.findTexture(p) : void 0,
+    fileOf(e) {
+      let f = files.get(e);
+      if (!f) {
+        f = {
+          name: spec.displayName ? spec.displayName(e) : baseName(e.path),
+          path: e.path,
+          archive: arch,
+          arrayBuffer: spec.fileBytes ? () => spec.fileBytes(e) : async () => toArrayBuffer(await spec.read(e))
+        };
+        files.set(e, f);
+      }
+      return f;
+    }
+  };
+  return arch;
+}
+const readRange = async (file, start, end) => new Uint8Array(await file.slice(start, end).arrayBuffer());
+export {
+  TEXTURE_RE,
+  createArchive,
+  readRange
+};
+//# sourceMappingURL=common.js.map

package/dist/archives/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sources":["../../src/archives/common.ts"],"sourcesContent":["// Common archive plumbing: path and texture indexes, file-like entry objects.\nimport { baseName, stripExt, toArrayBuffer } from '../binary';\nimport type { Archive, ArchiveEntry, BlobFile, VFile } from '../types';\n\n/** Extensions that put an entry into the texture index (path without extension). */\nexport const TEXTURE_RE = /\\.(dds|tga|png|jpe?g|pcx|bmp|webp|paa|pac|pct|tex|xbt)$/;\n\nexport interface ArchiveSpec<E extends ArchiveEntry> {\n  name: string;\n  kind: string;\n  version: number;\n  entries: E[];\n  read(entry: E): Promise<Uint8Array>;\n  /** Custom lookup function (for example, by path suffix). */\n  lookup?(path: string): E | null;\n  byBase?: Map<string, E>;\n  /** Extra texture keys (default: the full path without extension). */\n  textureKeys?(entry: E): string[];\n  /** Display file name (default: the last path segment). */\n  displayName?(entry: E): string;\n  /** On a duplicate texture key keep the first entry (default: the last one, as in game archives). */\n  keepFirstTextureKey?: boolean;\n  /** Custom file contents (without a copy via read). */\n  fileBytes?(entry: E): Promise<ArrayBuffer>;\n  /** Source file of the entry (folder). */\n  blobOf?(entry: E): BlobFile | null;\n  /** Texture at an exact path that is not in the entry list. */\n  findTexture?(path: string): E | null;\n}\n\nexport function createArchive<E extends ArchiveEntry>(spec: ArchiveSpec<E>): Archive {\n  const index = new Map<string, ArchiveEntry>(), byKey = new Map<string, ArchiveEntry>(), files = new Map<ArchiveEntry, VFile>();\n  for (const e of spec.entries) {\n    index.set(e.path, e); // duplicate path (mods, appended archives): the last entry wins\n    if (TEXTURE_RE.test(e.path)) {\n      for (const k of spec.textureKeys ? spec.textureKeys(e) : [stripExt(e.path)]) if (!spec.keepFirstTextureKey || !byKey.has(k)) byKey.set(k, e);\n    }\n  }\n  const arch: Archive = {\n    name: spec.name,\n    kind: spec.kind,\n    version: spec.version,\n    entries: spec.entries,\n    index,\n    byKey,\n    byBase: spec.byBase,\n    lookup: (p) => (spec.lookup ? spec.lookup(p) : (index.get(p) as E | undefined) ?? null),\n    read: (e) => spec.read(e as E),\n    blobOf: spec.blobOf ? (e) => spec.blobOf!(e as E) : undefined,\n    findTexture: spec.findTexture ? (p) => spec.findTexture!(p) : undefined,\n    fileOf(e) {\n      let f = files.get(e);\n      if (!f) {\n        f = {\n          name: spec.displayName ? spec.displayName(e as E) : baseName(e.path),\n          path: e.path,\n          archive: arch,\n          arrayBuffer: spec.fileBytes ? () => spec.fileBytes!(e as E) : async () => toArrayBuffer(await spec.read(e as E)),\n        };\n        files.set(e, f);\n      }\n      return f;\n    },\n  };\n  return arch;\n}\n\n/** Read a byte range of the file. */\nexport const readRange = async (file: Blob, start: number, end: number): Promise<Uint8Array> =>\n  new Uint8Array(await file.slice(start, end).arrayBuffer());\n"],"names":[],"mappings":";AAKO,MAAM,aAAa;AAyBnB,SAAS,cAAsC,MAA+B;AACnF,QAAM,QAAQ,oBAAI,OAA6B,4BAAY,IAAA,GAA6B,QAAQ,oBAAI,IAAA;AACpG,aAAW,KAAK,KAAK,SAAS;AAC5B,UAAM,IAAI,EAAE,MAAM,CAAC;AACnB,QAAI,WAAW,KAAK,EAAE,IAAI,GAAG;AAC3B,iBAAW,KAAK,KAAK,cAAc,KAAK,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,EAAG,KAAI,CAAC,KAAK,uBAAuB,CAAC,MAAM,IAAI,CAAC,EAAG,OAAM,IAAI,GAAG,CAAC;AAAA,IAC7I;AAAA,EACF;AACA,QAAM,OAAgB;AAAA,IACpB,MAAM,KAAK;AAAA,IACX,MAAM,KAAK;AAAA,IACX,SAAS,KAAK;AAAA,IACd,SAAS,KAAK;AAAA,IACd;AAAA,IACA;AAAA,IACA,QAAQ,KAAK;AAAA,IACb,QAAQ,CAAC,MAAO,KAAK,SAAS,KAAK,OAAO,CAAC,IAAK,MAAM,IAAI,CAAC,KAAuB;AAAA,IAClF,MAAM,CAAC,MAAM,KAAK,KAAK,CAAM;AAAA,IAC7B,QAAQ,KAAK,SAAS,CAAC,MAAM,KAAK,OAAQ,CAAM,IAAI;AAAA,IACpD,aAAa,KAAK,cAAc,CAAC,MAAM,KAAK,YAAa,CAAC,IAAI;AAAA,IAC9D,OAAO,GAAG;AACR,UAAI,IAAI,MAAM,IAAI,CAAC;AACnB,UAAI,CAAC,GAAG;AACN,YAAI;AAAA,UACF,MAAM,KAAK,cAAc,KAAK,YAAY,CAAM,IAAI,SAAS,EAAE,IAAI;AAAA,UACnE,MAAM,EAAE;AAAA,UACR,SAAS;AAAA,UACT,aAAa,KAAK,YAAY,MAAM,KAAK,UAAW,CAAM,IAAI,YAAY,cAAc,MAAM,KAAK,KAAK,CAAM,CAAC;AAAA,QAAA;AAEjH,cAAM,IAAI,GAAG,CAAC;AAAA,MAChB;AACA,aAAO;AAAA,IACT;AAAA,EAAA;AAEF,SAAO;AACT;AAGO,MAAM,YAAY,OAAO,MAAY,OAAe,QACzD,IAAI,WAAW,MAAM,KAAK,MAAM,OAAO,GAAG,EAAE,aAAa;"}

package/dist/archives/folder.d.ts

@@ -0,0 +1,4 @@
+import type { Archive, BlobFile } from '../types';
+export declare function openFolder(files: readonly BlobFile[]): Archive;
+/** The same, but in chunks of `chunk` files, yielding to the browser (large game folders have hundreds of thousands of files). */
+export declare function openFolderAsync(files: readonly BlobFile[], onProgress?: (done: number, total: number) => void, chunk?: number): Promise<Archive>;

package/dist/archives/folder.js

@@ -0,0 +1,65 @@
+import { stripExt } from "../binary.js";
+import { createArchive, TEXTURE_RE } from "./common.js";
+const relPath = (f) => (f.webkitRelativePath || f.name).replace(/\\/g, "/");
+class FolderIndex {
+  entries = [];
+  full = /* @__PURE__ */ new Map();
+  byBase = /* @__PURE__ */ new Map();
+  bySuffix = /* @__PURE__ */ new Map();
+  root = "";
+  add(f) {
+    const rel = relPath(f), path = rel.toLowerCase();
+    if (!this.root && rel.includes("/")) this.root = rel.split("/")[0];
+    const e = { path, size: f.size, src: f };
+    this.entries.push(e);
+    if (!this.full.has(path)) this.full.set(path, e);
+    const sp = path.split("/"), base = sp[sp.length - 1];
+    if (!this.byBase.has(base)) this.byBase.set(base, e);
+    for (let i = 0; i < sp.length; i++) {
+      const k = sp.slice(i).join("/");
+      if (!this.bySuffix.has(k)) this.bySuffix.set(k, e);
+    }
+  }
+  archive() {
+    const { full, bySuffix } = this;
+    return createArchive({
+      name: this.root || "папка",
+      kind: "folder",
+      version: 0,
+      entries: this.entries,
+      byBase: this.byBase,
+      lookup: (p) => full.get(p) ?? bySuffix.get(p) ?? null,
+      read: async (e) => new Uint8Array(await e.src.arrayBuffer()),
+      fileBytes: (e) => e.src.arrayBuffer(),
+      blobOf: (e) => e.src,
+      displayName: (e) => e.src.name,
+      keepFirstTextureKey: true,
+      // keys for every path suffix: a/b/c, b/c, c — not tied to the folder root
+      textureKeys: (e) => {
+        const parts = stripExt(e.path).split("/");
+        return TEXTURE_RE.test(e.path) ? parts.map((_, i) => parts.slice(i).join("/")) : [];
+      }
+    });
+  }
+}
+function openFolder(files) {
+  const ix = new FolderIndex();
+  for (const f of files) ix.add(f);
+  return ix.archive();
+}
+async function openFolderAsync(files, onProgress, chunk = 5e3) {
+  const ix = new FolderIndex();
+  for (let i = 0; i < files.length; i += chunk) {
+    onProgress?.(i, files.length);
+    await new Promise((r) => setTimeout(r, 0));
+    for (let k = i; k < Math.min(files.length, i + chunk); k++) ix.add(files[k]);
+  }
+  onProgress?.(files.length, files.length);
+  await new Promise((r) => setTimeout(r, 0));
+  return ix.archive();
+}
+export {
+  openFolder,
+  openFolderAsync
+};
+//# sourceMappingURL=folder.js.map

package/dist/archives/folder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"folder.js","sources":["../../src/archives/folder.ts"],"sourcesContent":["// \"Game folder\": loose files of the selected folder as a virtual archive (lookup by path suffix, without reading contents).\nimport { stripExt } from '../binary';\nimport type { Archive, ArchiveEntry, BlobFile } from '../types';\nimport { createArchive, TEXTURE_RE } from './common';\n\ninterface FolderEntry extends ArchiveEntry { src: BlobFile }\n\nconst relPath = (f: BlobFile): string => (f.webkitRelativePath || f.name).replace(/\\\\/g, '/');\n\n/** Folder index: paths, full and by suffix (built in chunks, see openFolderAsync). */\nclass FolderIndex {\n  entries: FolderEntry[] = []; full = new Map<string, FolderEntry>(); byBase = new Map<string, FolderEntry>(); bySuffix = new Map<string, FolderEntry>(); root = '';\n  add(f: BlobFile): void {\n    const rel = relPath(f), path = rel.toLowerCase();\n    if (!this.root && rel.includes('/')) this.root = rel.split('/')[0]!;\n    const e: FolderEntry = { path, size: f.size, src: f };\n    this.entries.push(e);\n    if (!this.full.has(path)) this.full.set(path, e);\n    const sp = path.split('/'), base = sp[sp.length - 1]!;\n    if (!this.byBase.has(base)) this.byBase.set(base, e);\n    for (let i = 0; i < sp.length; i++) { const k = sp.slice(i).join('/'); if (!this.bySuffix.has(k)) this.bySuffix.set(k, e); }\n  }\n  archive(): Archive {\n    const { full, bySuffix } = this;\n    return createArchive<FolderEntry>({\n      name: this.root || 'папка',\n      kind: 'folder',\n      version: 0,\n      entries: this.entries,\n      byBase: this.byBase,\n      lookup: (p) => full.get(p) ?? bySuffix.get(p) ?? null,\n      read: async (e) => new Uint8Array(await e.src.arrayBuffer()),\n      fileBytes: (e) => e.src.arrayBuffer(),\n      blobOf: (e) => e.src,\n      displayName: (e) => e.src.name,\n      keepFirstTextureKey: true,\n      // keys for every path suffix: a/b/c, b/c, c — not tied to the folder root\n      textureKeys: (e) => {\n        const parts = stripExt(e.path).split('/');\n        return TEXTURE_RE.test(e.path) ? parts.map((_, i) => parts.slice(i).join('/')) : [];\n      },\n    });\n  }\n}\n\nexport function openFolder(files: readonly BlobFile[]): Archive {\n  const ix = new FolderIndex();\n  for (const f of files) ix.add(f);\n  return ix.archive();\n}\n\n/** The same, but in chunks of `chunk` files, yielding to the browser (large game folders have hundreds of thousands of files). */\nexport async function openFolderAsync(files: readonly BlobFile[], onProgress?: (done: number, total: number) => void, chunk = 5000): Promise<Archive> {\n  const ix = new FolderIndex();\n  for (let i = 0; i < files.length; i += chunk) {\n    onProgress?.(i, files.length);\n    await new Promise((r) => setTimeout(r, 0));\n    for (let k = i; k < Math.min(files.length, i + chunk); k++) ix.add(files[k]!);\n  }\n  onProgress?.(files.length, files.length);\n  await new Promise((r) => setTimeout(r, 0));\n  return ix.archive();\n}\n"],"names":[],"mappings":";;AAOA,MAAM,UAAU,CAAC,OAAyB,EAAE,sBAAsB,EAAE,MAAM,QAAQ,OAAO,GAAG;AAG5F,MAAM,YAAY;AAAA,EAChB,UAAyB,CAAA;AAAA,EAAI,2BAAW,IAAA;AAAA,EAA4B,6BAAa,IAAA;AAAA,EAA4B,+BAAe,IAAA;AAAA,EAA4B,OAAO;AAAA,EAC/J,IAAI,GAAmB;AACrB,UAAM,MAAM,QAAQ,CAAC,GAAG,OAAO,IAAI,YAAA;AACnC,QAAI,CAAC,KAAK,QAAQ,IAAI,SAAS,GAAG,EAAG,MAAK,OAAO,IAAI,MAAM,GAAG,EAAE,CAAC;AACjE,UAAM,IAAiB,EAAE,MAAM,MAAM,EAAE,MAAM,KAAK,EAAA;AAClD,SAAK,QAAQ,KAAK,CAAC;AACnB,QAAI,CAAC,KAAK,KAAK,IAAI,IAAI,EAAG,MAAK,KAAK,IAAI,MAAM,CAAC;AAC/C,UAAM,KAAK,KAAK,MAAM,GAAG,GAAG,OAAO,GAAG,GAAG,SAAS,CAAC;AACnD,QAAI,CAAC,KAAK,OAAO,IAAI,IAAI,EAAG,MAAK,OAAO,IAAI,MAAM,CAAC;AACnD,aAAS,IAAI,GAAG,IAAI,GAAG,QAAQ,KAAK;AAAE,YAAM,IAAI,GAAG,MAAM,CAAC,EAAE,KAAK,GAAG;AAAG,UAAI,CAAC,KAAK,SAAS,IAAI,CAAC,EAAG,MAAK,SAAS,IAAI,GAAG,CAAC;AAAA,IAAG;AAAA,EAC7H;AAAA,EACA,UAAmB;AACjB,UAAM,EAAE,MAAM,SAAA,IAAa;AAC3B,WAAO,cAA2B;AAAA,MAChC,MAAM,KAAK,QAAQ;AAAA,MACnB,MAAM;AAAA,MACN,SAAS;AAAA,MACT,SAAS,KAAK;AAAA,MACd,QAAQ,KAAK;AAAA,MACb,QAAQ,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK;AAAA,MACjD,MAAM,OAAO,MAAM,IAAI,WAAW,MAAM,EAAE,IAAI,aAAa;AAAA,MAC3D,WAAW,CAAC,MAAM,EAAE,IAAI,YAAA;AAAA,MACxB,QAAQ,CAAC,MAAM,EAAE;AAAA,MACjB,aAAa,CAAC,MAAM,EAAE,IAAI;AAAA,MAC1B,qBAAqB;AAAA;AAAA,MAErB,aAAa,CAAC,MAAM;AAClB,cAAM,QAAQ,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG;AACxC,eAAO,WAAW,KAAK,EAAE,IAAI,IAAI,MAAM,IAAI,CAAC,GAAG,MAAM,MAAM,MAAM,CAAC,EAAE,KAAK,GAAG,CAAC,IAAI,CAAA;AAAA,MACnF;AAAA,IAAA,CACD;AAAA,EACH;AACF;AAEO,SAAS,WAAW,OAAqC;AAC9D,QAAM,KAAK,IAAI,YAAA;AACf,aAAW,KAAK,MAAO,IAAG,IAAI,CAAC;AAC/B,SAAO,GAAG,QAAA;AACZ;AAGA,eAAsB,gBAAgB,OAA4B,YAAoD,QAAQ,KAAwB;AACpJ,QAAM,KAAK,IAAI,YAAA;AACf,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,OAAO;AAC5C,iBAAa,GAAG,MAAM,MAAM;AAC5B,UAAM,IAAI,QAAQ,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AACzC,aAAS,IAAI,GAAG,IAAI,KAAK,IAAI,MAAM,QAAQ,IAAI,KAAK,GAAG,IAAK,IAAG,IAAI,MAAM,CAAC,CAAE;AAAA,EAC9E;AACA,eAAa,MAAM,QAAQ,MAAM,MAAM;AACvC,QAAM,IAAI,QAAQ,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AACzC,SAAO,GAAG,QAAA;AACZ;"}

package/dist/archives/zip.d.ts

@@ -0,0 +1,2 @@
+import type { Archive, BlobFile } from '../types';
+export declare function openZip(file: BlobFile): Promise<Archive>;

package/dist/archives/zip.js

@@ -0,0 +1,42 @@
+import { normPath } from "../binary.js";
+import { inflateRaw } from "../codecs/zlib.js";
+import { readRange, createArchive } from "./common.js";
+async function openZip(file) {
+  const tailLen = Math.min(file.size, 65557), tail = await readRange(file, file.size - tailLen, file.size);
+  const tdv = new DataView(tail.buffer, tail.byteOffset, tail.byteLength);
+  let e = -1;
+  for (let i = tail.length - 22; i >= 0; i--) if (tdv.getUint32(i, true) === 101010256) {
+    e = i;
+    break;
+  }
+  if (e < 0) throw new Error(`${file.name}: не ZIP (нет конца каталога)`);
+  const cdSize = tdv.getUint32(e + 12, true), cdOff = tdv.getUint32(e + 16, true);
+  if (cdOff === 4294967295) throw new Error(`${file.name}: ZIP64 не поддерживается`);
+  const u8 = await readRange(file, cdOff, cdOff + cdSize), dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength), entries = [];
+  for (let p = 0; p + 46 <= u8.length && dv.getUint32(p, true) === 33639248; ) {
+    const method = dv.getUint16(p + 10, true), comp = dv.getUint32(p + 20, true), size = dv.getUint32(p + 24, true);
+    const nl = dv.getUint16(p + 28, true), xl = dv.getUint16(p + 30, true), cl = dv.getUint16(p + 32, true), off = dv.getUint32(p + 42, true);
+    let n = "";
+    for (let i = 0; i < nl; i++) n += String.fromCharCode(u8[p + 46 + i]);
+    if (!n.endsWith("/")) entries.push({ path: normPath(n), method, comp, size, off });
+    p += 46 + nl + xl + cl;
+  }
+  return createArchive({
+    name: file.name,
+    kind: "zip",
+    version: 0,
+    entries,
+    async read(en) {
+      const lh = new DataView(await file.slice(en.off, en.off + 30).arrayBuffer());
+      const start = en.off + 30 + lh.getUint16(26, true) + lh.getUint16(28, true);
+      const data = await readRange(file, start, start + en.comp);
+      if (en.method === 0) return data;
+      if (en.method === 8) return inflateRaw(data);
+      throw new Error("метод сжатия ZIP " + en.method + " не поддерживается");
+    }
+  });
+}
+export {
+  openZip
+};
+//# sourceMappingURL=zip.js.map

package/dist/archives/zip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip.js","sources":["../../src/archives/zip.ts"],"sourcesContent":["// ZIP (id Tech pk3/pk4, CryEngine .pak, .zip): the central directory is read, data on demand (store / deflate).\nimport { normPath } from '../binary';\nimport { inflateRaw } from '../codecs/zlib';\nimport type { Archive, ArchiveEntry, BlobFile } from '../types';\nimport { createArchive, readRange } from './common';\n\ninterface ZipEntry extends ArchiveEntry { method: number; comp: number; off: number }\n\nexport async function openZip(file: BlobFile): Promise<Archive> {\n  const tailLen = Math.min(file.size, 65557), tail = await readRange(file, file.size - tailLen, file.size);\n  const tdv = new DataView(tail.buffer, tail.byteOffset, tail.byteLength);\n  let e = -1;\n  for (let i = tail.length - 22; i >= 0; i--) if (tdv.getUint32(i, true) === 0x06054b50) { e = i; break; }\n  if (e < 0) throw new Error(`${file.name}: не ZIP (нет конца каталога)`);\n  const cdSize = tdv.getUint32(e + 12, true), cdOff = tdv.getUint32(e + 16, true);\n  if (cdOff === 0xffffffff) throw new Error(`${file.name}: ZIP64 не поддерживается`);\n  const u8 = await readRange(file, cdOff, cdOff + cdSize), dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength), entries: ZipEntry[] = [];\n  for (let p = 0; p + 46 <= u8.length && dv.getUint32(p, true) === 0x02014b50;) {\n    const method = dv.getUint16(p + 10, true), comp = dv.getUint32(p + 20, true), size = dv.getUint32(p + 24, true);\n    const nl = dv.getUint16(p + 28, true), xl = dv.getUint16(p + 30, true), cl = dv.getUint16(p + 32, true), off = dv.getUint32(p + 42, true);\n    let n = '';\n    for (let i = 0; i < nl; i++) n += String.fromCharCode(u8[p + 46 + i]!);\n    if (!n.endsWith('/')) entries.push({ path: normPath(n), method, comp, size, off });\n    p += 46 + nl + xl + cl;\n  }\n  return createArchive<ZipEntry>({\n    name: file.name,\n    kind: 'zip',\n    version: 0,\n    entries,\n    async read(en) {\n      const lh = new DataView(await file.slice(en.off, en.off + 30).arrayBuffer());\n      const start = en.off + 30 + lh.getUint16(26, true) + lh.getUint16(28, true);\n      const data = await readRange(file, start, start + en.comp);\n      if (en.method === 0) return data;\n      if (en.method === 8) return inflateRaw(data);\n      throw new Error('метод сжатия ZIP ' + en.method + ' не поддерживается');\n    },\n  });\n}\n"],"names":[],"mappings":";;;AAQA,eAAsB,QAAQ,MAAkC;AAC9D,QAAM,UAAU,KAAK,IAAI,KAAK,MAAM,KAAK,GAAG,OAAO,MAAM,UAAU,MAAM,KAAK,OAAO,SAAS,KAAK,IAAI;AACvG,QAAM,MAAM,IAAI,SAAS,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU;AACtE,MAAI,IAAI;AACR,WAAS,IAAI,KAAK,SAAS,IAAI,KAAK,GAAG,IAAK,KAAI,IAAI,UAAU,GAAG,IAAI,MAAM,WAAY;AAAE,QAAI;AAAG;AAAA,EAAO;AACvG,MAAI,IAAI,EAAG,OAAM,IAAI,MAAM,GAAG,KAAK,IAAI,+BAA+B;AACtE,QAAM,SAAS,IAAI,UAAU,IAAI,IAAI,IAAI,GAAG,QAAQ,IAAI,UAAU,IAAI,IAAI,IAAI;AAC9E,MAAI,UAAU,WAAY,OAAM,IAAI,MAAM,GAAG,KAAK,IAAI,2BAA2B;AACjF,QAAM,KAAK,MAAM,UAAU,MAAM,OAAO,QAAQ,MAAM,GAAG,KAAK,IAAI,SAAS,GAAG,QAAQ,GAAG,YAAY,GAAG,UAAU,GAAG,UAAsB,CAAA;AAC3I,WAAS,IAAI,GAAG,IAAI,MAAM,GAAG,UAAU,GAAG,UAAU,GAAG,IAAI,MAAM,YAAa;AAC5E,UAAM,SAAS,GAAG,UAAU,IAAI,IAAI,IAAI,GAAG,OAAO,GAAG,UAAU,IAAI,IAAI,IAAI,GAAG,OAAO,GAAG,UAAU,IAAI,IAAI,IAAI;AAC9G,UAAM,KAAK,GAAG,UAAU,IAAI,IAAI,IAAI,GAAG,KAAK,GAAG,UAAU,IAAI,IAAI,IAAI,GAAG,KAAK,GAAG,UAAU,IAAI,IAAI,IAAI,GAAG,MAAM,GAAG,UAAU,IAAI,IAAI,IAAI;AACxI,QAAI,IAAI;AACR,aAAS,IAAI,GAAG,IAAI,IAAI,IAAK,MAAK,OAAO,aAAa,GAAG,IAAI,KAAK,CAAC,CAAE;AACrE,QAAI,CAAC,EAAE,SAAS,GAAG,WAAW,KAAK,EAAE,MAAM,SAAS,CAAC,GAAG,QAAQ,MAAM,MAAM,KAAK;AACjF,SAAK,KAAK,KAAK,KAAK;AAAA,EACtB;AACA,SAAO,cAAwB;AAAA,IAC7B,MAAM,KAAK;AAAA,IACX,MAAM;AAAA,IACN,SAAS;AAAA,IACT;AAAA,IACA,MAAM,KAAK,IAAI;AACb,YAAM,KAAK,IAAI,SAAS,MAAM,KAAK,MAAM,GAAG,KAAK,GAAG,MAAM,EAAE,EAAE,aAAa;AAC3E,YAAM,QAAQ,GAAG,MAAM,KAAK,GAAG,UAAU,IAAI,IAAI,IAAI,GAAG,UAAU,IAAI,IAAI;AAC1E,YAAM,OAAO,MAAM,UAAU,MAAM,OAAO,QAAQ,GAAG,IAAI;AACzD,UAAI,GAAG,WAAW,EAAG,QAAO;AAC5B,UAAI,GAAG,WAAW,EAAG,QAAO,WAAW,IAAI;AAC3C,YAAM,IAAI,MAAM,sBAAsB,GAAG,SAAS,oBAAoB;AAAA,IACxE;AAAA,EAAA,CACD;AACH;"}

package/dist/binary.d.ts

@@ -0,0 +1,24 @@
+/** ASCII string up to a zero byte or n bytes. */
+export declare function cstr(u8: Uint8Array, start: number, maxLen: number): string;
+/** ASCII string in [a, b) up to the first zero byte. */
+export declare function cstrRange(u8: Uint8Array, a: number, b: number): string;
+/** ASCII in [a, b) without stopping at zero bytes. */
+export declare function ascii(u8: Uint8Array, a: number, b: number): string;
+/** Four characters as a little-endian uint32. */
+export declare const fourCC: (s: string) => number;
+/** IEEE 754 half -> number. */
+export declare function half(x: number): number;
+/** Copy of a Uint8Array's contents as a separate ArrayBuffer. */
+export declare function toArrayBuffer(u8: Uint8Array): ArrayBuffer;
+/** First n bytes of a file (for format detection). */
+export declare function readHead(file: Blob | {
+    arrayBuffer(): Promise<ArrayBuffer>;
+}, n?: number): Promise<Uint8Array>;
+/** Whether the first bytes match an ASCII signature. */
+export declare function hasMagic(head: Uint8Array, magic: string, offset?: number): boolean;
+export declare const u32le: (u8: Uint8Array, o: number) => number;
+export declare const extOf: (name: string) => string;
+export declare const normPath: (p: string) => string;
+export declare const stripExt: (p: string) => string;
+export declare const baseName: (p: string) => string;
+export declare const decodeText: (data: Uint8Array | ArrayBuffer) => string;

package/dist/binary.js

@@ -0,0 +1,62 @@
+function cstr(u8, start, maxLen) {
+  let s = "";
+  for (let i = 0; i < maxLen && u8[start + i]; i++) s += String.fromCharCode(u8[start + i]);
+  return s;
+}
+function cstrRange(u8, a, b) {
+  let s = "";
+  for (let i = a; i < b && u8[i]; i++) s += String.fromCharCode(u8[i]);
+  return s;
+}
+function ascii(u8, a, b) {
+  let s = "";
+  for (let i = a; i < b; i++) s += String.fromCharCode(u8[i]);
+  return s;
+}
+const fourCC = (s) => (s.charCodeAt(0) | s.charCodeAt(1) << 8 | s.charCodeAt(2) << 16 | s.charCodeAt(3) << 24) >>> 0;
+function half(x) {
+  const s = x & 32768 ? -1 : 1, e = x >> 10 & 31, f = x & 1023;
+  if (e === 0) return s * 5960464477539063e-23 * f;
+  if (e === 31) return f ? NaN : s * Infinity;
+  return s * 2 ** (e - 15) * (1 + f / 1024);
+}
+function toArrayBuffer(u8) {
+  return u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength);
+}
+async function readHead(file, n = 64) {
+  if (typeof Blob !== "undefined" && file instanceof Blob) return new Uint8Array(await file.slice(0, n).arrayBuffer());
+  const buf = await file.arrayBuffer();
+  return new Uint8Array(buf, 0, Math.min(n, buf.byteLength));
+}
+function hasMagic(head, magic, offset = 0) {
+  if (head.length < offset + magic.length) return false;
+  for (let i = 0; i < magic.length; i++) if (head[offset + i] !== magic.charCodeAt(i)) return false;
+  return true;
+}
+const u32le = (u8, o) => u8.length >= o + 4 ? (u8[o] | u8[o + 1] << 8 | u8[o + 2] << 16 | u8[o + 3] << 24) >>> 0 : -1;
+const extOf = (name) => {
+  const i = name.lastIndexOf(".");
+  return i < 0 ? "" : name.slice(i + 1).toLowerCase();
+};
+const normPath = (p) => p.replace(/\\/g, "/").toLowerCase();
+const stripExt = (p) => p.replace(/\.[^./]+$/, "");
+const baseName = (p) => p.replace(/\\/g, "/").split("/").pop() ?? p;
+const decoder = new TextDecoder();
+const decodeText = (data) => decoder.decode(data);
+export {
+  ascii,
+  baseName,
+  cstr,
+  cstrRange,
+  decodeText,
+  extOf,
+  fourCC,
+  half,
+  hasMagic,
+  normPath,
+  readHead,
+  stripExt,
+  toArrayBuffer,
+  u32le
+};
+//# sourceMappingURL=binary.js.map

package/dist/binary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.js","sources":["../src/binary.ts"],"sourcesContent":["// Small helpers for reading binary data.\n\n/** ASCII string up to a zero byte or n bytes. */\nexport function cstr(u8: Uint8Array, start: number, maxLen: number): string {\n  let s = '';\n  for (let i = 0; i < maxLen && u8[start + i]; i++) s += String.fromCharCode(u8[start + i]!);\n  return s;\n}\n\n/** ASCII string in [a, b) up to the first zero byte. */\nexport function cstrRange(u8: Uint8Array, a: number, b: number): string {\n  let s = '';\n  for (let i = a; i < b && u8[i]; i++) s += String.fromCharCode(u8[i]!);\n  return s;\n}\n\n/** ASCII in [a, b) without stopping at zero bytes. */\nexport function ascii(u8: Uint8Array, a: number, b: number): string {\n  let s = '';\n  for (let i = a; i < b; i++) s += String.fromCharCode(u8[i]!);\n  return s;\n}\n\n/** Four characters as a little-endian uint32. */\nexport const fourCC = (s: string): number =>\n  (s.charCodeAt(0) | (s.charCodeAt(1) << 8) | (s.charCodeAt(2) << 16) | (s.charCodeAt(3) << 24)) >>> 0;\n\n/** IEEE 754 half -> number. */\nexport function half(x: number): number {\n  const s = x & 0x8000 ? -1 : 1, e = (x >> 10) & 31, f = x & 1023;\n  if (e === 0) return s * 5.960464477539063e-8 * f;\n  if (e === 31) return f ? NaN : s * Infinity;\n  return s * 2 ** (e - 15) * (1 + f / 1024);\n}\n\n/** Copy of a Uint8Array's contents as a separate ArrayBuffer. */\nexport function toArrayBuffer(u8: Uint8Array): ArrayBuffer {\n  return u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength) as ArrayBuffer;\n}\n\n/** First n bytes of a file (for format detection). */\nexport async function readHead(file: Blob | { arrayBuffer(): Promise<ArrayBuffer> }, n = 64): Promise<Uint8Array> {\n  if (typeof Blob !== 'undefined' && file instanceof Blob) return new Uint8Array(await file.slice(0, n).arrayBuffer());\n  const buf = await file.arrayBuffer();\n  return new Uint8Array(buf, 0, Math.min(n, buf.byteLength));\n}\n\n/** Whether the first bytes match an ASCII signature. */\nexport function hasMagic(head: Uint8Array, magic: string, offset = 0): boolean {\n  if (head.length < offset + magic.length) return false;\n  for (let i = 0; i < magic.length; i++) if (head[offset + i] !== magic.charCodeAt(i)) return false;\n  return true;\n}\n\nexport const u32le = (u8: Uint8Array, o: number): number =>\n  u8.length >= o + 4 ? (u8[o]! | (u8[o + 1]! << 8) | (u8[o + 2]! << 16) | (u8[o + 3]! << 24)) >>> 0 : -1;\n\nexport const extOf = (name: string): string => {\n  const i = name.lastIndexOf('.');\n  return i < 0 ? '' : name.slice(i + 1).toLowerCase();\n};\nexport const normPath = (p: string): string => p.replace(/\\\\/g, '/').toLowerCase();\nexport const stripExt = (p: string): string => p.replace(/\\.[^./]+$/, '');\nexport const baseName = (p: string): string => p.replace(/\\\\/g, '/').split('/').pop() ?? p;\n\nconst decoder = new TextDecoder();\nexport const decodeText = (data: Uint8Array | ArrayBuffer): string => decoder.decode(data);\n"],"names":[],"mappings":"AAGO,SAAS,KAAK,IAAgB,OAAe,QAAwB;AAC1E,MAAI,IAAI;AACR,WAAS,IAAI,GAAG,IAAI,UAAU,GAAG,QAAQ,CAAC,GAAG,UAAU,OAAO,aAAa,GAAG,QAAQ,CAAC,CAAE;AACzF,SAAO;AACT;AAGO,SAAS,UAAU,IAAgB,GAAW,GAAmB;AACtE,MAAI,IAAI;AACR,WAAS,IAAI,GAAG,IAAI,KAAK,GAAG,CAAC,GAAG,IAAK,MAAK,OAAO,aAAa,GAAG,CAAC,CAAE;AACpE,SAAO;AACT;AAGO,SAAS,MAAM,IAAgB,GAAW,GAAmB;AAClE,MAAI,IAAI;AACR,WAAS,IAAI,GAAG,IAAI,GAAG,UAAU,OAAO,aAAa,GAAG,CAAC,CAAE;AAC3D,SAAO;AACT;AAGO,MAAM,SAAS,CAAC,OACpB,EAAE,WAAW,CAAC,IAAK,EAAE,WAAW,CAAC,KAAK,IAAM,EAAE,WAAW,CAAC,KAAK,KAAO,EAAE,WAAW,CAAC,KAAK,QAAS;AAG9F,SAAS,KAAK,GAAmB;AACtC,QAAM,IAAI,IAAI,QAAS,KAAK,GAAG,IAAK,KAAK,KAAM,IAAI,IAAI,IAAI;AAC3D,MAAI,MAAM,EAAG,QAAO,IAAI,uBAAuB;AAC/C,MAAI,MAAM,GAAI,QAAO,IAAI,MAAM,IAAI;AACnC,SAAO,IAAI,MAAM,IAAI,OAAO,IAAI,IAAI;AACtC;AAGO,SAAS,cAAc,IAA6B;AACzD,SAAO,GAAG,OAAO,MAAM,GAAG,YAAY,GAAG,aAAa,GAAG,UAAU;AACrE;AAGA,eAAsB,SAAS,MAAsD,IAAI,IAAyB;AAChH,MAAI,OAAO,SAAS,eAAe,gBAAgB,KAAM,QAAO,IAAI,WAAW,MAAM,KAAK,MAAM,GAAG,CAAC,EAAE,aAAa;AACnH,QAAM,MAAM,MAAM,KAAK,YAAA;AACvB,SAAO,IAAI,WAAW,KAAK,GAAG,KAAK,IAAI,GAAG,IAAI,UAAU,CAAC;AAC3D;AAGO,SAAS,SAAS,MAAkB,OAAe,SAAS,GAAY;AAC7E,MAAI,KAAK,SAAS,SAAS,MAAM,OAAQ,QAAO;AAChD,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,IAAK,KAAI,KAAK,SAAS,CAAC,MAAM,MAAM,WAAW,CAAC,EAAG,QAAO;AAC5F,SAAO;AACT;AAEO,MAAM,QAAQ,CAAC,IAAgB,MACpC,GAAG,UAAU,IAAI,KAAK,GAAG,CAAC,IAAM,GAAG,IAAI,CAAC,KAAM,IAAM,GAAG,IAAI,CAAC,KAAM,KAAO,GAAG,IAAI,CAAC,KAAM,QAAS,IAAI;AAE/F,MAAM,QAAQ,CAAC,SAAyB;AAC7C,QAAM,IAAI,KAAK,YAAY,GAAG;AAC9B,SAAO,IAAI,IAAI,KAAK,KAAK,MAAM,IAAI,CAAC,EAAE,YAAA;AACxC;AACO,MAAM,WAAW,CAAC,MAAsB,EAAE,QAAQ,OAAO,GAAG,EAAE,YAAA;AAC9D,MAAM,WAAW,CAAC,MAAsB,EAAE,QAAQ,aAAa,EAAE;AACjE,MAAM,WAAW,CAAC,MAAsB,EAAE,QAAQ,OAAO,GAAG,EAAE,MAAM,GAAG,EAAE,IAAA,KAAS;AAEzF,MAAM,UAAU,IAAI,YAAA;AACb,MAAM,aAAa,CAAC,SAA2C,QAAQ,OAAO,IAAI;"}

package/dist/builtin-en.d.ts

@@ -0,0 +1,2 @@
+import type { EngineTexts } from './plugin';
+export declare const EN: EngineTexts;

package/dist/builtin-en.js

@@ -0,0 +1,24 @@
+const EN = {
+  "title": "Common formats",
+  "exporters": {
+    "obj": {
+      "title": "OBJ + MTL (Blender, 3ds Max, any 3D editor)",
+      "description": "Bind-pose geometry, UVs, normals and materials with DDS textures — one ZIP. OBJ does not store bones or animations.",
+      "fields": {
+        "name": {
+          "label": "File name"
+        },
+        "scale": {
+          "label": "Scale"
+        }
+      }
+    }
+  },
+  "groups": {
+    "Игры": "Games"
+  }
+};
+export {
+  EN
+};
+//# sourceMappingURL=builtin-en.js.map

package/dist/builtin-en.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-en.js","sources":["../src/builtin-en.ts"],"sourcesContent":["// English texts of the core engine (Russian ones live in the plugins themselves).\nimport type { EngineTexts } from './plugin';\n\nexport const EN: EngineTexts = {\n  \"title\": \"Common formats\",\n  \"exporters\": {\n    \"obj\": {\n      \"title\": \"OBJ + MTL (Blender, 3ds Max, any 3D editor)\",\n      \"description\": \"Bind-pose geometry, UVs, normals and materials with DDS textures — one ZIP. OBJ does not store bones or animations.\",\n      \"fields\": {\n        \"name\": {\n          \"label\": \"File name\"\n        },\n        \"scale\": {\n          \"label\": \"Scale\"\n        }\n      }\n    }\n  },\n  \"groups\": {\n    \"Игры\": \"Games\"\n  }\n};\n"],"names":[],"mappings":"AAGO,MAAM,KAAkB;AAAA,EAC7B,SAAS;AAAA,EACT,aAAa;AAAA,IACX,OAAO;AAAA,MACL,SAAS;AAAA,MACT,eAAe;AAAA,MACf,UAAU;AAAA,QACR,QAAQ;AAAA,UACN,SAAS;AAAA,QAAA;AAAA,QAEX,SAAS;AAAA,UACP,SAAS;AAAA,QAAA;AAAA,MACX;AAAA,IACF;AAAA,EACF;AAAA,EAEF,UAAU;AAAA,IACR,QAAQ;AAAA,EAAA;AAEZ;"}

package/dist/builtin.d.ts

@@ -0,0 +1 @@
+export declare const coreEngine: import("./plugin").EnginePlugin;

package/dist/builtin.js

@@ -0,0 +1,46 @@
+import { hasMagic } from "./binary.js";
+import { openZip } from "./archives/zip.js";
+import { decodeDDS } from "./images/dds.js";
+import { decodePCX } from "./images/pcx.js";
+import { decodeTGA } from "./images/tga.js";
+import { defineEngine } from "./plugin.js";
+import { EN } from "./builtin-en.js";
+const coreEngine = defineEngine({
+  id: "core",
+  title: "Общие форматы",
+  i18n: { en: EN },
+  archives: [
+    {
+      id: "zip",
+      title: "ZIP (pk3, pk4, iwd, CryEngine .pak)",
+      engine: "core",
+      extensions: ["zip", "pk3", "pk4", "iwd", "pak"],
+      sniff: (h) => hasMagic(h, "PK") || hasMagic(h, "PK") ? 1 : 0,
+      // CryEngine .pak files (Far Cry, Crysis, KCD) open by themselves in the "Game folder": only the ZIP central directory is read
+      openFromFolder: (_h, name) => /\.pak$/i.test(name),
+      open: (file) => openZip(file)
+    }
+  ],
+  exporters: [
+    {
+      id: "obj",
+      title: "OBJ + MTL (Blender, 3ds Max, любой 3D-редактор)",
+      target: "obj",
+      description: "Геометрия в bind-позе, UV, нормали и материалы с текстурами DDS — одним ZIP. Кости и анимации OBJ не хранит.",
+      fields: [
+        { id: "name", label: "Имя файла", type: "text", default: (_m, base) => base },
+        { id: "scale", label: "Масштаб", type: "number", min: 0, step: 0.01, default: 1 }
+      ],
+      run: async (model, values, ctx) => (await import("./writers/obj.js")).exportObj(model, values, ctx)
+    }
+  ],
+  codecs: [
+    { id: "dds", extensions: ["dds"], decode: (b) => decodeDDS(b) },
+    { id: "tga", extensions: ["tga"], decode: (b) => decodeTGA(b) },
+    { id: "pcx", extensions: ["pcx"], decode: (b) => decodePCX(b) }
+  ]
+});
+export {
+  coreEngine
+};
+//# sourceMappingURL=builtin.js.map

package/dist/builtin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin.js","sources":["../src/builtin.ts"],"sourcesContent":["// The core's built-in \"engine\": shared archives (ZIP) and codecs (DDS, TGA, PCX) used by many games.\nimport { hasMagic } from './binary';\nimport { openZip } from './archives/zip';\nimport { decodeDDS } from './images/dds';\nimport { decodePCX } from './images/pcx';\nimport { decodeTGA } from './images/tga';\nimport { defineEngine } from './plugin';\nimport { EN } from './builtin-en';\n\nexport const coreEngine = defineEngine({\n  id: 'core',\n  title: 'Общие форматы',\n  i18n: { en: EN },\n  archives: [\n    {\n      id: 'zip',\n      title: 'ZIP (pk3, pk4, iwd, CryEngine .pak)',\n      engine: 'core',\n      extensions: ['zip', 'pk3', 'pk4', 'iwd', 'pak'],\n      sniff: (h) => (hasMagic(h, 'PK\\x03\\x04') || hasMagic(h, 'PK\\x05\\x06') ? 1 : 0),\n      // CryEngine .pak files (Far Cry, Crysis, KCD) open by themselves in the \"Game folder\": only the ZIP central directory is read\n      openFromFolder: (_h, name) => /\\.pak$/i.test(name),\n      open: (file) => openZip(file),\n    },\n  ],\n  exporters: [\n    {\n      id: 'obj',\n      title: 'OBJ + MTL (Blender, 3ds Max, любой 3D-редактор)',\n      target: 'obj',\n      description: 'Геометрия в bind-позе, UV, нормали и материалы с текстурами DDS — одним ZIP. Кости и анимации OBJ не хранит.',\n      fields: [\n        { id: 'name', label: 'Имя файла', type: 'text', default: (_m, base) => base },\n        { id: 'scale', label: 'Масштаб', type: 'number', min: 0, step: 0.01, default: 1 },\n      ],\n      run: async (model, values, ctx) => (await import('./writers/obj')).exportObj(model, values, ctx),\n    },\n  ],\n  codecs: [\n    { id: 'dds', extensions: ['dds'], decode: (b) => decodeDDS(b) },\n    { id: 'tga', extensions: ['tga'], decode: (b) => decodeTGA(b) },\n    { id: 'pcx', extensions: ['pcx'], decode: (b) => decodePCX(b) },\n  ],\n});\n"],"names":[],"mappings":";;;;;;;AASO,MAAM,aAAa,aAAa;AAAA,EACrC,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,MAAM,EAAE,IAAI,GAAA;AAAA,EACZ,UAAU;AAAA,IACR;AAAA,MACE,IAAI;AAAA,MACJ,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,YAAY,CAAC,OAAO,OAAO,OAAO,OAAO,KAAK;AAAA,MAC9C,OAAO,CAAC,MAAO,SAAS,GAAG,MAAY,KAAK,SAAS,GAAG,MAAY,IAAI,IAAI;AAAA;AAAA,MAE5E,gBAAgB,CAAC,IAAI,SAAS,UAAU,KAAK,IAAI;AAAA,MACjD,MAAM,CAAC,SAAS,QAAQ,IAAI;AAAA,IAAA;AAAA,EAC9B;AAAA,EAEF,WAAW;AAAA,IACT;AAAA,MACE,IAAI;AAAA,MACJ,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,aAAa;AAAA,MACb,QAAQ;AAAA,QACN,EAAE,IAAI,QAAQ,OAAO,aAAa,MAAM,QAAQ,SAAS,CAAC,IAAI,SAAS,KAAA;AAAA,QACvE,EAAE,IAAI,SAAS,OAAO,WAAW,MAAM,UAAU,KAAK,GAAG,MAAM,MAAM,SAAS,EAAA;AAAA,MAAE;AAAA,MAElF,KAAK,OAAO,OAAO,QAAQ,SAAS,MAAM,OAAO,kBAAe,GAAG,UAAU,OAAO,QAAQ,GAAG;AAAA,IAAA;AAAA,EACjG;AAAA,EAEF,QAAQ;AAAA,IACN,EAAE,IAAI,OAAO,YAAY,CAAC,KAAK,GAAG,QAAQ,CAAC,MAAM,UAAU,CAAC,EAAA;AAAA,IAC5D,EAAE,IAAI,OAAO,YAAY,CAAC,KAAK,GAAG,QAAQ,CAAC,MAAM,UAAU,CAAC,EAAA;AAAA,IAC5D,EAAE,IAAI,OAAO,YAAY,CAAC,KAAK,GAAG,QAAQ,CAAC,MAAM,UAAU,CAAC,EAAA;AAAA,EAAE;AAElE,CAAC;"}

package/dist/codecs/zlib.d.ts

@@ -0,0 +1,4 @@
+/** zlib stream (with a 78 xx header). */
+export declare const inflateZlib: (u8: Uint8Array) => Promise<Uint8Array>;
+/** Raw deflate (ZIP, method 8). */
+export declare const inflateRaw: (u8: Uint8Array) => Promise<Uint8Array>;

package/dist/codecs/zlib.js

@@ -0,0 +1,11 @@
+async function run(u8, format) {
+  const stream = new Blob([u8]).stream().pipeThrough(new DecompressionStream(format));
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+const inflateZlib = (u8) => run(u8, "deflate");
+const inflateRaw = (u8) => run(u8, "deflate-raw");
+export {
+  inflateRaw,
+  inflateZlib
+};
+//# sourceMappingURL=zlib.js.map

package/dist/codecs/zlib.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zlib.js","sources":["../../src/codecs/zlib.ts"],"sourcesContent":["// zlib / raw deflate decompression via the standard DecompressionStream (browsers, Node 18+).\nasync function run(u8: Uint8Array, format: 'deflate' | 'deflate-raw'): Promise<Uint8Array> {\n  const stream = new Blob([u8 as BlobPart]).stream().pipeThrough(new DecompressionStream(format));\n  return new Uint8Array(await new Response(stream).arrayBuffer());\n}\n/** zlib stream (with a 78 xx header). */\nexport const inflateZlib = (u8: Uint8Array): Promise<Uint8Array> => run(u8, 'deflate');\n/** Raw deflate (ZIP, method 8). */\nexport const inflateRaw = (u8: Uint8Array): Promise<Uint8Array> => run(u8, 'deflate-raw');\n"],"names":[],"mappings":"AACA,eAAe,IAAI,IAAgB,QAAwD;AACzF,QAAM,SAAS,IAAI,KAAK,CAAC,EAAc,CAAC,EAAE,OAAA,EAAS,YAAY,IAAI,oBAAoB,MAAM,CAAC;AAC9F,SAAO,IAAI,WAAW,MAAM,IAAI,SAAS,MAAM,EAAE,aAAa;AAChE;AAEO,MAAM,cAAc,CAAC,OAAwC,IAAI,IAAI,SAAS;AAE9E,MAAM,aAAa,CAAC,OAAwC,IAAI,IAAI,aAAa;"}

package/dist/diagnostics.d.ts

@@ -0,0 +1,10 @@
+import type { BlobFile, VFile } from './types';
+export declare function hexDump(u8: Uint8Array, width?: number): string;
+export interface DiagnosticsInput {
+    file: VFile | BlobFile;
+    format?: string;
+    preset?: string;
+    error: string;
+    appVersion?: string;
+}
+export declare function buildDiagnostics(d: DiagnosticsInput, headBytes?: number): Promise<string>;

package/dist/diagnostics.js

@@ -0,0 +1,34 @@
+import { readHead } from "./binary.js";
+function hexDump(u8, width = 16) {
+  const lines = [];
+  for (let o = 0; o < u8.length; o += width) {
+    const row = u8.subarray(o, o + width);
+    const hex = Array.from(row, (b) => b.toString(16).padStart(2, "0")).join(" ").padEnd(width * 3 - 1);
+    const txt = Array.from(row, (b) => b >= 32 && b < 127 ? String.fromCharCode(b) : ".").join("");
+    lines.push(`${o.toString(16).padStart(4, "0")}  ${hex}  ${txt}`);
+  }
+  return lines.join("\n");
+}
+async function buildDiagnostics(d, headBytes = 64) {
+  let head = new Uint8Array(0);
+  try {
+    head = await readHead(d.file, headBytes);
+  } catch {
+  }
+  const size = typeof Blob !== "undefined" && d.file instanceof Blob ? d.file.size : void 0;
+  return [
+    `gmv ${d.appVersion ?? ""}`.trim(),
+    `Файл: ${"path" in d.file && d.file.path || d.file.name}${size !== void 0 ? ` (${size} байт)` : ""}`,
+    d.preset ? `Пресет: ${d.preset}` : "",
+    d.format ? `Формат: ${d.format}` : "",
+    `Ошибка: ${d.error}`,
+    `Сигнатура: ${Array.from(head.subarray(0, 4), (b) => b >= 32 && b < 127 ? String.fromCharCode(b) : ".").join("")}`,
+    `Заголовок (${head.length} байт):`,
+    hexDump(head)
+  ].filter(Boolean).join("\n");
+}
+export {
+  buildDiagnostics,
+  hexDump
+};
+//# sourceMappingURL=diagnostics.js.map