@nekosuneprojects/honkaistarrail-api 0.0.0-stage → 1.0.0

package/data/meta.json

@@ -0,0 +1,14 @@
+{
+  "name": "Honkai: Star Rail",
+  "title": "A turn-based sci-fi/fantasy RPG following the Astral Express crew across the galaxy.",
+  "engine": "Unity",
+  "Platform": "PC, PlayStation 5, iOS, Android",
+  "Release date": "April 26, 2023 (Windows, iOS, Android) | October 11, 2023 (PS5)",
+  "Genre": "Turn-Based RPG, Gacha",
+  "developers": "miHoYo",
+  "publisher": "miHoYo (China) / HoYoverse (Global)",
+  "aliases": "HSR, Star Rail",
+  "image": "https://upload.wikimedia.org/wikipedia/en/thumb/8/8e/Honkai_Star_Rail_logo.svg/250px-Honkai_Star_Rail_logo.svg.png",
+  "description": "A free-to-play turn-based RPG by HoYoverse, following the crew of the Astral Express as they travel the stars.",
+  "url": "https://en.wikipedia.org/wiki/Honkai:_Star_Rail"
+}

package/index.js

@@ -0,0 +1,5 @@
+'use strict';
+const {createHonkaiStarRail}=require('./src/tracker');
+module.exports=createHonkaiStarRail;
+module.exports.HonkaiStarRail=createHonkaiStarRail;
+module.exports.createTracker=createHonkaiStarRail;

package/package.json

@@ -1,6 +1,41 @@
-{
-  "name": "@nekosuneprojects/honkaistarrail-api",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "@nekosuneprojects/honkaistarrail-api",
+  "version": "1.0.0",
+  "description": "Local-first Honkai: Star Rail game and character JSON, redeem-code archive, and optional Enka.Network HSR public UID profiles.",
+  "main": "index.js",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "check": "node scripts/validate-package.js",
+    "test": "node --test",
+    "prepack": "npm run check && npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NekoSuneProjectsNPM/game-tracker.git"
+  },
+  "author": "NekoSuneVR",
+  "license": "MIT",
+  "keywords": [
+    "honkai-star-rail",
+    "honkaistarrail",
+    "hsr",
+    "redeem-codes",
+    "characters",
+    "enka-network",
+    "local-json"
+  ],
+  "files": [
+    "index.js",
+    "src/",
+    "data/",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/catalog.js

@@ -0,0 +1,105 @@
+'use strict';
+
+// Common reusable JSON discovery across any game or category.
+const path = require('node:path');
+
+const normalise = value => String(value ?? '').trim().normalize('NFKC').toLowerCase().replace(/[\s_-]+/g, ' ');
+const slug = value => normalise(value).replace(/[^a-z0-9 ]/g, '').replace(/ +/g, '');
+
+function descriptor(file, record) {
+  const type = file.split('/')[0] || 'data';
+  const id = path.posix.basename(file, '.json');
+  const name = typeof record?.name === 'string' ? record.name :
+    typeof record?.title === 'string' ? record.title : id.replace(/[-_]/g, ' ');
+  return { id: String(record?.id || id), name, type, path: file };
+}
+function valuesFrom(record, limit = 10000) {
+  const values = [];
+  const stack = [record];
+  while (stack.length && values.length < limit) {
+    const value = stack.pop();
+    if (typeof value === 'string' || typeof value === 'number') values.push(String(value));
+    else if (Array.isArray(value)) stack.push(...value.slice(0,1000));
+    else if (value && typeof value === 'object') stack.push(...Object.values(value).slice(0,1000));
+  }
+  return values;
+}
+function createCatalog(data) {
+  if (!data || typeof data.list !== 'function' || typeof data.get !== 'function')
+    throw new TypeError('A JSON data store is required');
+
+  async function all(category) {
+    const files = await data.list();
+    const prefix = category ? category + '/' : '';
+    const matches = [];
+    for (const file of files) {
+      if (!file.endsWith('.json') || (category && !file.startsWith(prefix))) continue;
+      try {
+        const record = await data.get(file);
+        matches.push({ ...descriptor(file, record), record });
+      } catch (error) {
+        if (error.code === 'ENOENT') continue;
+        throw error;
+      }
+    }
+    return matches;
+  }
+
+  async function search(query, { category, limit = 50 } = {}) {
+    if (typeof query !== 'string' || !query.trim()) throw new TypeError('Search query is required');
+    if (category && !/^[a-z0-9_-]+$/.test(category)) throw new TypeError('Invalid category');
+    if (!Number.isInteger(limit) || limit < 1 || limit > 500) throw new RangeError('limit must be between 1 and 500');
+    const needle = normalise(query);
+    const results = [];
+    for (const item of await all(category)) {
+      const shortFields = [item.id, item.name, item.path, item.record?.title, ...(Array.isArray(item.record?.aliases) ? item.record.aliases : [])];
+      const direct = shortFields.some(v => v != null && normalise(v).includes(needle));
+      const content = !direct && valuesFrom(item.record).some(v => normalise(v).includes(needle));
+      if (!direct && !content) continue;
+      const score = normalise(item.name) === needle || normalise(item.id) === needle || slug(item.name) === slug(query) ? 0 :
+        direct ? 1 : 2;
+      results.push({ id:item.id, name:item.name, type:item.type, path:item.path, score });
+    }
+    results.sort((a,b) => a.score-b.score || a.name.localeCompare(b.name) || a.path.localeCompare(b.path));
+    const found = results.slice(0,limit).map(({score,...result})=>result);
+    return {
+      query,
+      total: results.length,
+      results: found,
+      message: results.length ? `Found ${results.length} result(s) for "${query}".` : `We don't have anything related to "${query}".`
+    };
+  }
+
+  async function get(category, idOrName) {
+    if (typeof category !== 'string' || !/^[a-z0-9_-]+$/.test(category))
+      throw new TypeError('Invalid category');
+    if (typeof idOrName !== 'string' || !idOrName.trim()) throw new TypeError('Record name or ID is required');
+    const needle = normalise(idOrName);
+    const matches = (await all(category)).filter(item =>
+      normalise(item.id) === needle || normalise(item.name) === needle ||
+      slug(item.id) === slug(idOrName) || slug(item.name) === slug(idOrName) ||
+      normalise(item.path) === needle);
+    if (!matches.length) {
+      const error = new Error(`We don't have anything related to "${idOrName}" in ${category}.`);
+      error.code = 'NOT_FOUND';
+      throw error;
+    }
+    if (matches.length > 1) {
+      const error = new Error(`Multiple ${category} records match "${idOrName}". Select an exact result path.`);
+      error.code = 'AMBIGUOUS';
+      error.results = matches.map(({record,...info})=>info);
+      throw error;
+    }
+    return matches[0].record;
+  }
+
+  return Object.freeze({
+    search,
+    get,
+    character: id => get('characters', id),
+    item: id => get('items', id),
+    code: id => get('codes', id),
+    map: id => get('maps', id)
+  });
+}
+module.exports = { createCatalog };

package/src/codes.js

@@ -0,0 +1,24 @@
+'use strict';
+const path=require('node:path');
+const {createDataStore}=require('./data-store');
+const FILE='honkai-star-rail.json', GROUPS={active:'Active',expired:'Expired',unknown:'Unknown'};
+const norm=x=>String(x??'').trim().toLowerCase();
+function createCodes({cacheDir,githubToken,fetchImpl}={}){
+ const data=createDataStore({gameId:'honkaistarrail-codes',cacheDir,githubToken,fetchImpl,bundledDir:path.join(__dirname,'..','data','codes'),github:{owner:'NekoSuneProjectsNPM',repo:'game-tracker',branch:'JsonData',directory:'codes/games'},syncFiles:[FILE]});
+ async function snapshot({refresh=false,signal}={}){if(refresh)await data.sync({signal});const doc=await data.get(FILE);for(const k of Object.values(GROUPS))if(!Array.isArray(doc[k]))throw Error('Invalid HSR code archive: '+k);return doc;}
+ function filter(rows,{hasCode,status,category,limit}={}){
+   if(hasCode!==undefined&&typeof hasCode!=='boolean')throw new TypeError('hasCode must be boolean');
+   if(status!==undefined&&!Object.hasOwn(GROUPS,norm(status)))throw new RangeError('Invalid status');
+   if(limit!==undefined&&(!Number.isInteger(limit)||limit<1||limit>10000))throw new RangeError('limit must be 1–10000');
+   return rows.filter(v=>(hasCode===undefined||Boolean(v.code)===hasCode)&&(status===undefined||norm(v.status)===norm(status))&&(category===undefined||norm(v.category)===norm(category))).slice(0,limit??rows.length);
+ }
+ async function all(options={}){const doc=await snapshot(options);return filter([...doc.Active,...doc.Expired,...doc.Unknown],options);}
+ async function group(groupName,options={}){const doc=await snapshot(options);return filter(doc[GROUPS[groupName]],options);}
+ async function get(value,options={}){if(typeof value!=='string'&&!Number.isSafeInteger(value))throw new TypeError('Code or numeric ID required');const needle=norm(value);if(!needle)throw new TypeError('Nonempty code required');const entry=(await all(options)).find(v=>norm(v.code)===needle||norm(v.id)===needle);if(!entry)throw Object.assign(new Error('Code not found'),{code:'NOT_FOUND'});return entry;}
+ async function search(query,options={}){if(typeof query!=='string'||!query.trim())throw new TypeError('Search text required');const needle=norm(query);const results=(await all(options)).filter(v=>[v.code,v.status,v.category,...(v.items||[]).map(item=>item.name)].some(x=>norm(x).includes(needle)));return {query,total:results.length,results};}
+ // The archive contains scraped names and stale "active" statuses.
+ // Therefore verifiedActive intentionally returns no unverified records.
+ async function verifiedActive(){return [];}
+ return Object.freeze({snapshot,all,active:opts=>group('active',opts),expired:opts=>group('expired',opts),unknown:opts=>group('unknown',opts),get,search,verifiedActive,data,sync:opts=>data.sync(opts)});
+}
+module.exports={createCodes};

package/src/data-store.js

@@ -0,0 +1,138 @@
+'use strict';
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+
+function safePath(value) {
+  if (typeof value !== 'string' || !value || value.includes('\\') || value.includes('\0') ||
+      value.startsWith('/') || value.split('/').some(v => !v || v === '.' || v === '..') ||
+      !/^[a-zA-Z0-9_./-]+$/.test(value)) throw new TypeError('Unsafe JSON data path');
+  if (!value.endsWith('.json')) throw new TypeError('Only .json files are supported');
+  return value;
+}
+function sourceConfig(source) {
+  if (!source) return null;
+  const { owner, repo, branch = 'main', directory } = source;
+  for (const part of [owner, repo, branch]) {
+    if (typeof part !== 'string' || !/^[a-zA-Z0-9._-]+$/.test(part)) throw new TypeError('Invalid GitHub repository source');
+  }
+  if (typeof directory !== 'string' || !directory || directory.split('/').some(x => !x || x === '.' || x === '..') ||
+      !/^[a-zA-Z0-9_/-]+$/.test(directory)) throw new TypeError('Invalid GitHub source directory');
+  return { owner, repo, branch, directory };
+}
+function createDataStore({ gameId, cacheDir, bundledDir, github, githubToken, syncFiles, fetchImpl = globalThis.fetch } = {}) {
+  if (typeof gameId !== 'string' || !/^[a-z0-9][a-z0-9_-]*$/.test(gameId)) throw new TypeError('Valid gameId required');
+  if (typeof fetchImpl !== 'function') throw new TypeError('fetch is required');
+  const source = sourceConfig(github);
+  if (syncFiles !== undefined && (!Array.isArray(syncFiles) || syncFiles.length === 0)) throw new TypeError('syncFiles must be a nonempty array of JSON paths');
+  const whitelist = syncFiles === undefined ? null : new Set(syncFiles.map(safePath));
+  if (githubToken !== undefined && (typeof githubToken !== 'string' || !githubToken.trim())) throw new TypeError('githubToken must be a nonempty string');
+  const githubHeaders = { Accept: 'application/vnd.github+json', 'User-Agent': 'NekoSune-Game-Tracker', ...(githubToken ? { Authorization: 'Bearer ' + githubToken } : {}) };
+  const cache = path.resolve(cacheDir || path.join(os.homedir(), '.cache', 'nekosune-game-tracker', gameId));
+  const bundled = bundledDir ? path.resolve(bundledDir) : null;
+  const manifestFile = path.join(cache, '.manifest.json');
+  async function loadManifest() {
+    try {
+      const current = JSON.parse(await fs.readFile(manifestFile, 'utf8'));
+      if (current.source !== JSON.stringify({source, files: syncFiles || null}) || !current.files || typeof current.files !== 'object') return {};
+      return current.files;
+    } catch (err) { if (err.code === 'ENOENT' || err instanceof SyntaxError) return {}; throw err; }
+  }
+  async function atomicWrite(file, content) {
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const tmp = file + '.' + process.pid + '.' + require('node:crypto').randomBytes(6).toString('hex') + '.tmp';
+    try { await fs.writeFile(tmp, content); await fs.rename(tmp, file); }
+    catch (err) { await fs.rm(tmp, { force: true }); throw err; }
+  }
+  async function get(file) {
+    const relative = safePath(file);
+    for (const base of [cache, bundled].filter(Boolean)) {
+      try { return JSON.parse(await fs.readFile(path.join(base, relative), 'utf8')); }
+      catch (err) { if (err.code !== 'ENOENT') throw err; }
+    }
+    throw Object.assign(new Error('Local JSON not found: ' + relative), { code: 'ENOENT' });
+  }
+  async function list() {
+    const results = new Set();
+    async function walk(dir, relative = '') {
+      let entries;
+      try { entries = await fs.readdir(dir, { withFileTypes: true }); }
+      catch (err) { if (err.code === 'ENOENT') return; throw err; }
+      for (const entry of entries) {
+        if (entry.isSymbolicLink()) continue;
+        const rel = relative ? relative + '/' + entry.name : entry.name;
+        if (entry.isDirectory()) await walk(path.join(dir, entry.name), rel);
+        else if (entry.isFile() && rel.endsWith('.json') && rel !== '.manifest.json') {
+          try { safePath(rel); results.add(rel); } catch {}
+        }
+      }
+    }
+    if (bundled) await walk(bundled);
+    await walk(cache);
+    return [...results].sort();
+  }
+  async function sync({ signal } = {}) {
+    if (!source) throw new Error('No GitHub JSON source configured in this tracker branch');
+    const { owner, repo, branch, directory } = source;
+    const api = 'https://api.github.com/repos/' + owner + '/' + repo + '/git/trees/' + encodeURIComponent(branch) + '?recursive=1';
+    const request = await fetchImpl(api, { headers: githubHeaders, signal });
+    if (!request.ok) throw new Error('GitHub tree request failed: HTTP ' + request.status);
+    const tree = await request.json();
+    if (tree.truncated || !Array.isArray(tree.tree)) throw new Error('GitHub directory listing incomplete; refusing partial sync');
+    const prefix = directory + '/';
+    const files = tree.tree.filter(item => item.type === 'blob' && item.path.startsWith(prefix) && item.path.endsWith('.json') && (!whitelist || whitelist.has(item.path.slice(prefix.length))))
+      .map(item => ({ name: safePath(item.path.slice(prefix.length)), sha: item.sha, size: item.size }));
+    if (files.length > 5000) throw new Error('Too many JSON files');
+    const old = await loadManifest();
+    const next = { ...old };
+    let updated = 0, unchanged = 0;
+    for (const item of files) {
+      if (!/^[0-9a-f]{40}$/.test(item.sha) || item.size > 5 * 1024 * 1024) throw new Error('Invalid or oversized GitHub JSON blob');
+      const target = path.join(cache, item.name);
+      if (old[item.name] === item.sha) {
+        try {
+          const existing = await fs.readFile(target);
+          const existingHash = require('node:crypto').createHash('sha1')
+            .update('blob ' + existing.length + '\0').update(existing).digest('hex');
+          JSON.parse(existing.toString('utf8'));
+          if (existingHash === item.sha) { unchanged++; continue; }
+        } catch (err) {
+          if (err.code !== 'ENOENT' && !(err instanceof SyntaxError)) throw err;
+        }
+      }
+      // GitHub Git Blob API supports private repositories with a fine-grained read token.
+      // Fetch by content SHA so the downloaded file matches the exact tree snapshot.
+      const blobUrl = 'https://api.github.com/repos/' + owner + '/' + repo + '/git/blobs/' + item.sha;
+      const response = await fetchImpl(blobUrl, { headers: githubHeaders, signal });
+      if (!response.ok) throw new Error('GitHub JSON download failed (' + item.name + '): HTTP ' + response.status);
+      const blob = await response.json();
+      if (blob.encoding !== 'base64' || typeof blob.content !== 'string')
+        throw new Error('Unexpected GitHub blob encoding for ' + item.name);
+      const buffer = Buffer.from(blob.content.replace(/\s/g, ''), 'base64');
+      if (buffer.length > 5 * 1024 * 1024) throw new Error('JSON file too large');
+      const gitHash = require('node:crypto').createHash('sha1').update('blob ' + buffer.length + '\0').update(buffer).digest('hex');
+      if (gitHash !== item.sha) throw new Error('GitHub JSON checksum mismatch: ' + item.name);
+      JSON.parse(buffer.toString('utf8'));
+      await atomicWrite(target, buffer);
+      next[item.name] = item.sha;
+      updated++;
+    }
+    // Cache is additive: do not automatically delete removed upstream files or user files.
+    await atomicWrite(manifestFile, JSON.stringify({ source: JSON.stringify({source, files: syncFiles || null}), files: next }, null, 2) + '\n');
+    return { updated, unchanged, checked: files.length, cacheDir: cache };
+  }
+  // Ensures a newly published remote JSON record is available even when it
+  // was absent from the npm package and from this machine's cache.
+  async function ensure(file, { signal, refresh = false } = {}) {
+    const relative = safePath(file);
+    if (!refresh) {
+      try { return await get(relative); }
+      catch (err) { if (err.code !== 'ENOENT') throw err; }
+    }
+    if (!source) return get(relative);
+    await sync({ signal });
+    return get(relative);
+  }
+  return Object.freeze({ get, list, sync, ensure, cacheDir: cache });
+}
+module.exports = { createDataStore };

package/src/enka.js

@@ -0,0 +1,58 @@
+'use strict';
+const BASE='https://enka.network/api/hsr/uid/';
+class EnkaError extends Error {
+ constructor(message,{code='ENKA_ERROR',status=null,uid=null,retryAfter=null,cause}={}){
+   super(message,{cause});this.name='EnkaError';Object.assign(this,{code,status,uid,retryAfter});
+ }
+}
+function validUid(input){
+ const uid=String(input??'').trim();
+ if(!/^[1-9][0-9]{8}$/.test(uid))throw new TypeError('HSR UID must be a nine-digit number');
+ return uid;
+}
+function createEnka({fetchImpl=globalThis.fetch,timeoutMs=12000,userAgent='NekoSuneProjects-honkaistarrail-api/1.0 (https://github.com/NekoSuneProjectsNPM/game-tracker)',clock=()=>Date.now()}={}){
+ if(typeof fetchImpl!=='function')throw new TypeError('fetch required');
+ if(typeof clock!=='function')throw new TypeError('clock must be a function');
+ if(typeof userAgent!=='string'||!userAgent.trim())throw new TypeError('userAgent required');
+ if(!Number.isInteger(timeoutMs)||timeoutMs<100||timeoutMs>60000)throw new RangeError('timeoutMs must be 100–60000');
+ const cache=new Map(),inflight=new Map();
+ function clearCache(uid){if(uid===undefined){cache.clear();return;}cache.delete(validUid(uid));}
+ async function player(input,{refresh=false,signal}={}){
+   const uid=validUid(input);
+   if(typeof refresh!=='boolean')throw new TypeError('refresh must be boolean');
+   if(signal?.aborted)throw new EnkaError('Aborted',{code:'ABORTED',uid});
+   const cached=cache.get(uid);
+   if(!refresh&&cached&&cached.expires>clock())return cached.value;
+   if(!refresh&&inflight.has(uid))return inflight.get(uid);
+   const ctrl=new AbortController();
+   const abort=()=>ctrl.abort();
+   if(signal)signal.addEventListener('abort',abort,{once:true});
+   const timer=setTimeout(abort,timeoutMs);
+   const job=(async()=>{
+     try{
+       let res;
+       try{res=await fetchImpl(BASE+uid,{method:'GET',headers:{Accept:'application/json','User-Agent':userAgent},signal:ctrl.signal});}
+       catch(cause){throw new EnkaError('Enka fetch failed',{code:ctrl.signal.aborted?'ABORTED':'NETWORK_ERROR',uid,cause});}
+       if(!res||typeof res.ok!=='boolean'||!Number.isInteger(res.status))throw new EnkaError('Invalid HTTP response',{code:'INVALID_RESPONSE',uid});
+       if(!res.ok){
+         const codes={400:'INVALID_UID',404:'PLAYER_NOT_FOUND',424:'GAME_MAINTENANCE',429:'RATE_LIMITED',500:'SERVER_ERROR',503:'SERVICE_UNAVAILABLE'};
+         const retry=res.headers?.get?.('retry-after');
+         throw new EnkaError('Enka HTTP '+res.status,{code:codes[res.status]||'HTTP_ERROR',status:res.status,uid,retryAfter:retry&&/^\d+$/.test(retry)?Number(retry):null});
+       }
+       let json;
+       try{json=await res.json();}catch(cause){throw new EnkaError('Invalid Enka JSON',{code:'INVALID_JSON',status:res.status,uid,cause});}
+       if(!json||typeof json!=='object'||Array.isArray(json)||!json.detailInfo||typeof json.detailInfo!=='object'||Array.isArray(json.detailInfo))throw new EnkaError('Missing HSR detailInfo',{code:'INVALID_RESPONSE',status:res.status,uid});
+       const ttl=Number(json.ttl);
+       if(Number.isFinite(ttl)&&ttl>0)cache.set(uid,{value:json,expires:clock()+Math.min(ttl,3600)*1000});
+       else cache.delete(uid);
+       return json;
+     }finally{clearTimeout(timer);if(signal)signal.removeEventListener('abort',abort);}
+   })();
+   inflight.set(uid,job);
+   try{return await job;}finally{if(inflight.get(uid)===job)inflight.delete(uid);}
+ }
+ async function avatars(uid,options={}){const result=await player(uid,options);return Array.isArray(result.detailInfo.avatarDetailList)?result.detailInfo.avatarDetailList:[];}
+ async function info(uid,options={}){return (await player(uid,options)).detailInfo;}
+ return Object.freeze({get:player,player,info,avatars,clearCache,endpoint:BASE});
+}
+module.exports={createEnka,EnkaError};

package/src/tracker.js

@@ -0,0 +1,20 @@
+'use strict';
+const path=require('node:path');
+const {createDataStore}=require('./data-store');
+const {createCatalog}=require('./catalog');
+const {createCodes}=require('./codes');
+const {createEnka}=require('./enka');
+function createHonkaiStarRail({cacheDir,codesCacheDir,githubToken,fetchImpl,enkaOptions}={}){
+ const data=createDataStore({gameId:'honkaistarrail',cacheDir,githubToken,fetchImpl,bundledDir:path.join(__dirname,'..','data'),github:{owner:'NekoSuneProjectsNPM',repo:'game-tracker',branch:'JsonData',directory:'games/honkaistarrail'}});
+ const catalog=createCatalog(data);
+ const codes=createCodes({cacheDir:codesCacheDir,githubToken,fetchImpl});
+ const enka=createEnka({fetchImpl,...enkaOptions});
+ async function character(id,{refresh=false,signal}={}){
+   try{return await catalog.get('characters',id);}
+   catch(err){if(err.code!=='NOT_FOUND'||!refresh)throw err;await data.sync({signal});return catalog.get('characters',id);}
+ }
+ async function search(query,{refresh=false,signal,...opts}={}){if(refresh)await data.sync({signal});return catalog.search(query,opts);}
+ const characters=Object.freeze({get:character,list:async()=>Promise.all((await data.list()).filter(f=>f.startsWith('characters/')&&f.endsWith('.json')).map(f=>data.get(f))),search:(q,opts={})=>search(q,{...opts,category:'characters'})});
+ return Object.freeze({About:()=>data.get('meta.json'),character,characters,search,codes,data,enka,player:enka.player});
+}
+module.exports={createHonkaiStarRail};