@natsuneko-laboratory/memora 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kanon Mochizuki
+
+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

@@ -0,0 +1,193 @@
+# Memora
+
+Memora は、VRChat・VRCX・ResoniteScreenshotExtensions が画像に埋め込んだメタデータを読み取る TypeScript ライブラリです。撮影者、ワールド、カメラ設定、参加者の位置・姿勢などを、形式ごとの型付きオブジェクトとして取得できます。
+
+Node.js、ブラウザー、React Native 向けに、`ArrayBuffer` または `Uint8Array` を受け取る API を提供します。ファイルの読み取りやネットワークアクセスは呼び出し側で行います。
+
+## インストール
+
+```sh
+$ pnpm install @natsuneko-laboratory/memora
+```
+
+## クイックスタート
+
+```ts
+import { parseImageMetadata } from "@natsuneko-laboratory/memora";
+
+// bytes: ArrayBuffer | Uint8Array
+const metadata = await parseImageMetadata(bytes);
+
+if (metadata) {
+  switch (metadata.type) {
+    case "VRChat":
+      console.log(metadata.author, metadata.worldDisplayName, metadata.createDate);
+      break;
+
+    case "VRCX":
+      console.log(metadata.author?.displayName, metadata.world?.instanceId);
+      console.log(metadata.players);
+      break;
+
+    case "ResoniteScreenshotExtensions":
+      console.log(metadata.takenBy?.name, metadata.cameraFOV);
+      console.log(metadata.userInfos);
+      break;
+  }
+}
+```
+
+`type` で分岐すると、その形式のプロパティへ型安全にアクセスできます。メタデータがない画像や、対応形式を認識できない入力では `null` を返します。
+
+## API
+
+### `parseImageMetadata(input)`
+
+```ts
+function parseImageMetadata(input: ArrayBuffer | Uint8Array): Promise<ImageMetadata | null>;
+```
+
+画像から 1 件のメタデータを取得します。複数形式が同居する場合は ResoniteScreenshotExtensions を優先し、それ以外は解析結果の先頭を返します。
+
+`parsePhotoMetadata` はこの関数の別名です。
+
+### `parseAllImageMetadata(input)`
+
+```ts
+function parseAllImageMetadata(input: ArrayBuffer | Uint8Array): Promise<ImageMetadata[]>;
+```
+
+画像内で認識できたすべてのメタデータを取得します。複数形式や複数パケットを扱う場合に使用してください。認識できるメタデータがなければ空配列を返します。
+
+### `ImageMetadata`
+
+```ts
+type ImageMetadata =
+  VrcxImageMetadata | VRChatImageMetadata | ResoniteScreenshotExtensionsImageMetadata;
+```
+
+すべての形式に、次のプロパティがあります。
+
+| プロパティ | 型                                                     | 内容                                                   |
+| ---------- | ------------------------------------------------------ | ------------------------------------------------------ |
+| `type`     | `"VRCX" \| "VRChat" \| "ResoniteScreenshotExtensions"` | メタデータの形式                                       |
+| `raw`      | `Uint8Array`                                           | 元画像全体のバイト列                                   |
+| `extra`    | `Record<string, unknown>`                              | 型定義にない項目、または期待する型へ解析できなかった値 |
+
+画像に含まれない項目は optional プロパティとして扱います。空文字が埋め込まれている場合は、その空文字を保持します。
+
+## 対応形式とフィールド
+
+### VRChat
+
+`type: "VRChat"`
+
+- `creatorTool`, `author`, `authorId`
+- `worldId`, `worldDisplayName`
+- `createDate`, `modifyDate`, `dateTime`
+- `title`: 言語ごとの `{ value: string; language?: string }[]`
+- `world`: 旧形式の `vrc:World`
+
+旧形式の `author` にはユーザー ID が入る場合があります。新しい形式では表示名と `authorId` を別々に取得できます。
+
+### VRCX
+
+`type: "VRCX"`
+
+- `application`, `version`
+- `author`: `id`, `displayName`
+- `world`: `id`, `name`, `instanceId`
+- `players`: `id`, `displayName` を持つユーザーの配列
+
+ユーザーとワールドには、それぞれ `extra` もあります。
+
+### ResoniteScreenshotExtensions
+
+`type: "ResoniteScreenshotExtensions"`
+
+- 場所: `locationName`, `locationAccessLevel`, `locationHiddenFromListing`, `locationHost`
+- 撮影: `timeTaken`, `takenBy`, `takenGlobalPosition`, `takenGlobalRotation`, `takenGlobalScale`
+- アプリ・カメラ: `appVersion`, `cameraManufacturer`, `cameraModel`, `cameraFOV`, `is360`, `stereoLayout`
+- 参加者: `userInfos`
+
+`locationHost` と `takenBy` は `id`, `name`, `machineId`, `extra` を持ちます。`userInfos` の各要素には、さらに次のフィールドがあります。
+
+- `isInVR`, `isPresent`
+- `headPosition`, `headOrientation`
+- `sessionJoinTimestamp`
+
+`userInfos` は、ユーザーが 1 人の場合も配列です。
+
+## 値の扱い
+
+- 日時は元の文字列を保持します。タイムゾーン変換や `Date` 化を行わず、小数秒の精度も維持します。
+- Resonite の名前は Unicode / URI エスケープを復元します。
+- 真偽値は `boolean`、カメラの画角は `number` に解析します。
+- 位置・スケールは `Vector3`（`[number, number, number]`）、回転は `Quaternion`（`[number, number, number, number]`）に解析します。座標変換や正規化は行いません。
+- 未知の項目や解析できない値は `extra` に保持し、既定値で補完しません。
+
+XML の属性や名前空間の構造は、形式ごとのプロパティへ整理されます。構文表記まで含めた元データが必要な場合は `raw` を利用してください。JSON 数値の精度は JavaScript の `number` に従います。
+
+## 実行環境ごとの利用例
+
+### Node.js
+
+```ts
+import { readFile } from "node:fs/promises";
+import { parseImageMetadata } from "@natsuneko-laboratory/memora";
+
+const bytes = await readFile("screenshot.png");
+const metadata = await parseImageMetadata(bytes);
+```
+
+### ブラウザー
+
+```ts
+import { parseImageMetadata } from "@natsuneko-laboratory/memora";
+
+async function readScreenshot(file: File | Blob) {
+  return parseImageMetadata(await file.arrayBuffer());
+}
+```
+
+### React Native
+
+```ts
+import { parseImageMetadata } from "@natsuneko-laboratory/memora";
+
+async function readScreenshot(uri: string, readBytes: (uri: string) => Promise<Uint8Array>) {
+  const bytes = await readBytes(uri);
+  return parseImageMetadata(bytes);
+}
+```
+
+`readBytes` には、アプリで採用しているファイルアクセスライブラリを使った読み取り関数を渡してください。URI、Base64、`File`、`Blob` をパーサーへ直接渡すことはできません。
+
+## 対応範囲と制約
+
+PNG の iTXt（非圧縮・zlib 圧縮）と XMP を読み取ります。ResoniteScreenshotExtensions の JPEG XMP にも対応します。
+
+画像のリサイズ・再圧縮・形式変換により、メタデータが削除される場合があります。変換前の元画像を使用してください。
+
+コアは React やネイティブモジュールに依存しません。Node.js の `Buffer` / `process`、DOM、`TextDecoder` がない環境でのバンドルテストを用意しています。
+
+## 開発
+
+リポジトリを取得した後、パッケージのディレクトリで実行します。
+
+```sh
+npm install
+npm test
+npm run typecheck
+npm run build
+```
+
+テストは TypeScript と Vitest で記述しています。実画像と合成画像を用い、形式の判別、全フィールドの取得、元バイト列の保持、部分バッファ入力、実行環境への依存を検証します。
+
+`npm run typecheck` は本体とテストの両方を検証します。テストのみの型チェックには `npm run typecheck:test` を使用できます。
+
+ビルドすると、ESM と型定義が `dist/` に生成されます。インストール時のスクリプトを無効にしている場合は、利用前に `npm run build` を実行してください。
+
+## ライセンス
+
+MIT

package/dist/container.d.ts

@@ -0,0 +1,31 @@
+export type PhotoInput = ArrayBuffer | Uint8Array;
+export type XmpMetadata = {
+    /** Original XML text, including whitespace and entity spellings. */
+    text: string;
+    /** All XML fields and attributes; no scalar coercion or namespace removal. */
+    data: Record<string, unknown> | null;
+};
+export type PhotoTextChunk = {
+    keyword: string;
+    compressionFlag: number;
+    compressionMethod: number;
+    languageTag: string;
+    translatedKeyword: string;
+    /** Decompressed text, or null if the payload cannot be decoded. */
+    text: string | null;
+    /** Complete JSON value for Description chunks, otherwise null. */
+    data: unknown;
+    /** Original iTXt payload, including its header and compressed bytes. */
+    raw: Uint8Array;
+};
+export type PhotoMetadata = {
+    /** Original image bytes, for lossless access beyond the decoded views. */
+    raw: Uint8Array;
+    /** All blocks returned by exifr, with numeric tag IDs and value translation disabled. */
+    exif: Record<string, unknown> | null;
+    /** All PNG iTXt chunks in file order, including unknown keywords and versions. */
+    itxt: PhotoTextChunk[];
+    xmp: XmpMetadata[];
+};
+/** Return embedded metadata without platform filtering, renaming, defaults or value normalization. */
+export declare const readMetadataContainer: (input: PhotoInput) => Promise<PhotoMetadata | null>;

package/dist/container.js

@@ -0,0 +1,115 @@
+import exifr from "exifr";
+import { XMLParser } from "fast-xml-parser";
+import { strFromU8, unzlibSync } from "fflate";
+import extract from "png-chunks-extract";
+const parseXmp = (text) => {
+    try {
+        const data = new XMLParser({
+            ignoreAttributes: false,
+            parseTagValue: false,
+            parseAttributeValue: false,
+            trimValues: false,
+            processEntities: true,
+            ignoreDeclaration: false,
+            ignorePiTags: false,
+        }).parse(text);
+        return { text, data };
+    }
+    catch {
+        return { text, data: null };
+    }
+};
+const readTextChunks = (bytes) => {
+    try {
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        for (let offset = 8; offset < bytes.length;) {
+            if (bytes.length - offset < 12)
+                return [];
+            const length = view.getUint32(offset);
+            if (length > bytes.length - offset - 12)
+                return [];
+            offset += length + 12;
+        }
+        return extract(bytes)
+            .filter((chunk) => chunk.name === "iTXt")
+            .map(({ data: raw }) => {
+            const result = {
+                keyword: "",
+                compressionFlag: 0,
+                compressionMethod: 0,
+                languageTag: "",
+                translatedKeyword: "",
+                text: null,
+                data: null,
+                raw,
+            };
+            try {
+                const end = raw.indexOf(0);
+                if (end < 1 || end + 5 > raw.length)
+                    return result;
+                result.keyword = strFromU8(raw.subarray(0, end), true);
+                result.compressionFlag = raw[end + 1];
+                result.compressionMethod = raw[end + 2];
+                const languageEnd = raw.indexOf(0, end + 3);
+                if (languageEnd < 0)
+                    return result;
+                result.languageTag = strFromU8(raw.subarray(end + 3, languageEnd), true);
+                const translatedEnd = raw.indexOf(0, languageEnd + 1);
+                if (translatedEnd < 0)
+                    return result;
+                result.translatedKeyword = strFromU8(raw.subarray(languageEnd + 1, translatedEnd));
+                const payload = raw.subarray(translatedEnd + 1);
+                if (result.compressionMethod !== 0 || result.compressionFlag > 1)
+                    return result;
+                result.text = strFromU8(result.compressionFlag === 1 ? unzlibSync(payload) : payload);
+                if (result.keyword === "Description")
+                    result.data = JSON.parse(result.text);
+            }
+            catch {
+                // Keep the original bytes and any readable fields even if decoding fails.
+            }
+            return result;
+        });
+    }
+    catch {
+        return [];
+    }
+};
+/** Return embedded metadata without platform filtering, renaming, defaults or value normalization. */
+export const readMetadataContainer = async (input) => {
+    const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+    const itxt = readTextChunks(bytes);
+    let exif = null;
+    try {
+        exif =
+            (await exifr.parse(bytes, {
+                tiff: true,
+                ifd1: true,
+                interop: true,
+                makerNote: true,
+                userComment: true,
+                multiSegment: true,
+                exif: true,
+                gps: true,
+                iptc: true,
+                icc: true,
+                jfif: true,
+                xmp: { parse: false },
+                translateKeys: false,
+                translateValues: false,
+                reviveValues: false,
+                sanitize: false,
+                mergeOutput: false,
+            })) ?? null;
+    }
+    catch {
+        // iTXt remains available when another metadata block is unsupported or damaged.
+    }
+    const xmp = itxt
+        .filter((chunk) => chunk.keyword === "XML:com.adobe.xmp" && chunk.text !== null)
+        .map((chunk) => parseXmp(chunk.text));
+    // PNG XMP is already captured above, including duplicate packets and original headers.
+    if (xmp.length === 0 && typeof exif?.xmp === "string")
+        xmp.push(parseXmp(exif.xmp));
+    return exif || itxt.length ? { raw: bytes, exif, itxt, xmp } : null;
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import type { ImageMetadata, PhotoInput } from "./types.js";
+export type * from "./types.js";
+/** Read every recognized packet without dropping coexisting formats. Unknown formats return an empty array. */
+export declare const parseAllImageMetadata: (input: PhotoInput) => Promise<ImageMetadata[]>;
+/** Resonite takes precedence, matching steambird; use parseAllImageMetadata for mixed images. */
+export declare const parseImageMetadata: (input: PhotoInput) => Promise<ImageMetadata | null>;
+/** Alias for existing callers. */
+export declare const parsePhotoMetadata: typeof parseImageMetadata;

package/dist/index.js

@@ -0,0 +1,224 @@
+import { readMetadataContainer } from "./container.js";
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : undefined;
+const list = (value) => value === undefined ? [] : Array.isArray(value) ? value : [value];
+const string = (value) => typeof value === "string" ? value : undefined;
+const number = (value) => {
+    if (typeof value !== "number" && (typeof value !== "string" || !value.trim()))
+        return undefined;
+    const result = Number(value);
+    return Number.isFinite(result) ? result : undefined;
+};
+const boolean = (value) => value === true || value === "true"
+    ? true
+    : value === false || value === "false"
+        ? false
+        : undefined;
+const vector = (value) => {
+    if (typeof value !== "string" || !/^\[[^\[\]]+\]$/.test(value))
+        return undefined;
+    const parts = value.slice(1, -1).split(";").map(number);
+    return parts.every((part) => part !== undefined) ? parts : undefined;
+};
+const vector3 = (value) => {
+    const v = vector(value);
+    return v?.length === 3 ? [v[0], v[1], v[2]] : undefined;
+};
+const quaternion = (value) => {
+    const v = vector(value);
+    return v?.length === 4 ? [v[0], v[1], v[2], v[3]] : undefined;
+};
+const name = (value) => {
+    if (typeof value !== "string")
+        return undefined;
+    let result = value;
+    // ResoniteScreenshotExtensions escapes names as JSON string contents and URI text.
+    try {
+        result = JSON.parse(`"${result}"`);
+    }
+    catch {
+        /* Already readable text. */
+    }
+    try {
+        result = decodeURIComponent(result);
+    }
+    catch {
+        /* Literal percent sign. */
+    }
+    return result;
+};
+// Recognized fields that cannot be decoded remain in extra instead of disappearing.
+const fields = (source) => {
+    const extra = { ...source };
+    const get = (key, decode) => {
+        const result = decode(source[key]);
+        if (result !== undefined)
+            delete extra[key];
+        return result;
+    };
+    return { extra, get };
+};
+const compact = (value) => {
+    for (const key of Object.keys(value))
+        if (value[key] === undefined)
+            delete value[key];
+    return value;
+};
+const users = (decode) => (input) => {
+    if (!Array.isArray(input))
+        return undefined;
+    const values = input.map(decode);
+    return values.every((value) => value !== undefined) ? values : undefined;
+};
+const vrcxUser = (input) => {
+    const source = object(input);
+    if (!source)
+        return undefined;
+    const { get, extra } = fields(source);
+    return compact({ id: get("id", string), displayName: get("displayName", string), extra });
+};
+const vrcxWorld = (input) => {
+    const source = object(input);
+    if (!source)
+        return undefined;
+    const { get, extra } = fields(source);
+    return compact({
+        id: get("id", string),
+        name: get("name", string),
+        instanceId: get("instanceId", string),
+        extra,
+    });
+};
+/** Flatten XML attribute syntax only; keep namespace prefixes to avoid name collisions. */
+const xmlFields = (input) => Object.fromEntries(Object.entries(object(input) ?? {})
+    .filter(([key]) => key !== "#text" && !key.startsWith("@_xmlns") && key !== "@_rdf:about")
+    .map(([key, value]) => [key.startsWith("@_") ? key.slice(2) : key, value]));
+const scalar = (value) => string(value) ?? string(object(value)?.["#text"]);
+const resoniteUser = (input) => {
+    if (!object(input))
+        return undefined;
+    const { get, extra } = fields(xmlFields(input));
+    return compact({
+        id: get("rse:U-Id", scalar),
+        name: get("rse:U-Name", name),
+        machineId: get("rse:U-MachineId", scalar),
+        extra,
+    });
+};
+const resoniteUserInfo = (input) => {
+    const user = resoniteUser(input);
+    if (!user)
+        return undefined;
+    const { get, extra } = fields(user.extra);
+    return compact({
+        ...user,
+        isInVR: get("rse:UI-IsInVR", boolean),
+        isPresent: get("rse:UI-IsPresent", boolean),
+        headPosition: get("rse:UI-HeadPosition", vector3),
+        headOrientation: get("rse:UI-HeadOrientation", quaternion),
+        sessionJoinTimestamp: get("rse:UI-SessionJoinTimestamp", scalar),
+        extra,
+    });
+};
+const title = (input) => {
+    if (typeof input === "string")
+        return [{ value: input }];
+    const entries = object(object(input)?.["rdf:Alt"])?.["rdf:li"];
+    if (entries === undefined)
+        return undefined;
+    return list(entries).map((item) => compact({ value: scalar(item) ?? "", language: string(object(item)?.["@_xml:lang"]) }));
+};
+/** Read every recognized packet without dropping coexisting formats. Unknown formats return an empty array. */
+export const parseAllImageMetadata = async (input) => {
+    const container = await readMetadataContainer(input);
+    if (!container)
+        return [];
+    const raw = container.raw;
+    const result = [];
+    for (const chunk of container.itxt) {
+        const source = object(chunk.data);
+        if (chunk.keyword !== "Description" || source?.application !== "VRCX")
+            continue;
+        const { get, extra } = fields(source);
+        delete extra.application;
+        result.push(compact({
+            type: "VRCX",
+            raw,
+            application: "VRCX",
+            version: get("version", number),
+            author: get("author", vrcxUser),
+            world: get("world", vrcxWorld),
+            players: get("players", users(vrcxUser)),
+            extra,
+        }));
+    }
+    for (const packet of container.xmp) {
+        const root = object(packet.data?.["x:xmpmeta"]) ?? packet.data;
+        const rdf = object(root?.["rdf:RDF"]);
+        const descriptions = list(rdf?.["rdf:Description"]).map(xmlFields);
+        const source = {};
+        for (const description of descriptions) {
+            for (const [key, value] of Object.entries(description)) {
+                if (key in source)
+                    source[key] = [...list(source[key]), value];
+                else
+                    source[key] = value;
+            }
+        }
+        const { get, extra } = fields(source);
+        if (source["xmp:CreatorTool"] === "VRChat") {
+            delete extra["xmp:CreatorTool"];
+            result.push(compact({
+                type: "VRChat",
+                raw,
+                creatorTool: "VRChat",
+                author: get("xmp:Author", scalar),
+                authorId: get("vrc:AuthorID", scalar),
+                worldId: get("vrc:WorldID", scalar),
+                worldDisplayName: get("vrc:WorldDisplayName", scalar),
+                world: get("vrc:World", scalar),
+                createDate: get("xmp:CreateDate", scalar),
+                modifyDate: get("xmp:ModifyDate", scalar),
+                dateTime: get("tiff:DateTime", scalar),
+                title: get("dc:title", title),
+                extra,
+            }));
+        }
+        else if (source["rse:CameraManufacturer"] === "Resonite") {
+            delete extra["rse:CameraManufacturer"];
+            result.push(compact({
+                type: "ResoniteScreenshotExtensions",
+                raw,
+                cameraManufacturer: "Resonite",
+                locationName: get("rse:LocationName", name),
+                locationAccessLevel: get("rse:LocationAccessLevel", scalar),
+                locationHiddenFromListing: get("rse:LocationHiddenFromListing", boolean),
+                locationHost: get("rse:LocationHost", resoniteUser),
+                timeTaken: get("rse:TimeTaken", scalar),
+                takenBy: get("rse:TakenBy", resoniteUser),
+                takenGlobalPosition: get("rse:TakenGlobalPosition", vector3),
+                takenGlobalRotation: get("rse:TakenGlobalRotation", quaternion),
+                takenGlobalScale: get("rse:TakenGlobalScale", vector3),
+                appVersion: get("rse:AppVersion", scalar),
+                cameraModel: get("rse:CameraModel", scalar),
+                cameraFOV: get("rse:CameraFOV", number),
+                is360: get("rse:Is360", boolean),
+                stereoLayout: get("rse:StereoLayout", scalar),
+                userInfos: get("rse:UserInfos", (value) => {
+                    const infos = object(value)?.["rse:UserInfo"];
+                    return infos === undefined ? undefined : users(resoniteUserInfo)(list(infos));
+                }),
+                extra,
+            }));
+        }
+    }
+    return result;
+};
+/** Resonite takes precedence, matching steambird; use parseAllImageMetadata for mixed images. */
+export const parseImageMetadata = async (input) => {
+    const results = await parseAllImageMetadata(input);
+    return (results.find((result) => result.type === "ResoniteScreenshotExtensions") ?? results[0] ?? null);
+};
+/** Alias for existing callers. */
+export const parsePhotoMetadata = parseImageMetadata;

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+export type PhotoInput = ArrayBuffer | Uint8Array;
+export type Vector3 = [number, number, number];
+export type Quaternion = [number, number, number, number];
+/** Unrecognized source fields, retained at the level where they appeared. */
+export type ExtraFields = {
+    extra: Record<string, unknown>;
+};
+type ImageBase = ExtraFields & {
+    raw: Uint8Array;
+};
+export type VrcxUser = ExtraFields & {
+    id?: string;
+    displayName?: string;
+};
+export type VrcxWorld = ExtraFields & {
+    id?: string;
+    name?: string;
+    instanceId?: string;
+};
+export type VrcxImageMetadata = ImageBase & {
+    type: "VRCX";
+    application: "VRCX";
+    version?: number;
+    author?: VrcxUser;
+    world?: VrcxWorld;
+    players?: VrcxUser[];
+};
+export type VRChatImageMetadata = ImageBase & {
+    type: "VRChat";
+    creatorTool: "VRChat";
+    /** Original xmp:Author. Old screenshots contain the user ID here. */
+    author?: string;
+    authorId?: string;
+    worldId?: string;
+    worldDisplayName?: string;
+    /** Original vrc:World, used by the legacy format. */
+    world?: string;
+    createDate?: string;
+    modifyDate?: string;
+    dateTime?: string;
+    title?: Array<{
+        value: string;
+        language?: string;
+    }>;
+};
+export type ResoniteUser = ExtraFields & {
+    id?: string;
+    name?: string;
+    machineId?: string;
+};
+export type ResoniteUserInfo = ResoniteUser & {
+    isInVR?: boolean;
+    isPresent?: boolean;
+    headPosition?: Vector3;
+    headOrientation?: Quaternion;
+    sessionJoinTimestamp?: string;
+};
+export type ResoniteScreenshotExtensionsImageMetadata = ImageBase & {
+    type: "ResoniteScreenshotExtensions";
+    cameraManufacturer: "Resonite";
+    locationName?: string;
+    locationAccessLevel?: string;
+    locationHiddenFromListing?: boolean;
+    locationHost?: ResoniteUser;
+    timeTaken?: string;
+    takenBy?: ResoniteUser;
+    takenGlobalPosition?: Vector3;
+    takenGlobalRotation?: Quaternion;
+    takenGlobalScale?: Vector3;
+    appVersion?: string;
+    cameraModel?: string;
+    cameraFOV?: number;
+    is360?: boolean;
+    stereoLayout?: string;
+    userInfos?: ResoniteUserInfo[];
+};
+export type ImageMetadata = VrcxImageMetadata | VRChatImageMetadata | ResoniteScreenshotExtensionsImageMetadata;
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@natsuneko-laboratory/memora",
+  "version": "0.1.0",
+  "description": "Memora extracts VRChat, VRCX and ResoniteScreenshotExtensions metadata for Node.js, Browser and React Native.",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "exifr": "^7.1.3",
+    "fast-xml-parser": "^5.2.0",
+    "fflate": "^0.8.2",
+    "png-chunks-extract": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.1",
+    "@types/png-chunks-extract": "^1.0.2",
+    "esbuild": "^0.28.1",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json",
+    "test": "npm run build && vitest run",
+    "typecheck:test": "tsc -p tsconfig.test.json"
+  }
+}