@caperjs/core 0.2.4 → 0.4.0

package/build/assetpack.mjs

@@ -33,6 +33,92 @@ function fontWeights() {
   };
 }
 
+/**
+ * Pipes an exempted asset must not enter. AssetPack's `mergePipeOptions` reads
+ * `asset.settings[pipe.name]` and treats `false` as "skip this pipe for this
+ * asset" — the same per-asset switch the `assetSettings` config exposes, only
+ * set programmatically here because the page names are inside the font file,
+ * not in anything an app author could glob.
+ *
+ * `cache-buster` is the one that actually breaks production, and it is also the
+ * one no tag can turn off (`cacheBuster().test` is `!asset.isFolder`, full
+ * stop), which is why this uses settings rather than the `nomip`/`nc` tags.
+ */
+const BITMAP_FONT_SKIPPED_PIPES = ['mipmap', 'compress', 'cache-buster'];
+
+/** Both text `.fnt` and XML bitmap fonts name their pages as `file="…png"`. */
+const fontPagePattern = /file="([^"]+\.png)"/g;
+
+const toPosix = (value) => value.replace(/\\/g, '/');
+const dirOf = (value) => toPosix(value).replace(/\/[^/]*$/, '');
+const baseOf = (value) => toPosix(value).replace(/^.*\//, '');
+
+/**
+ * AssetPack pipe that keeps pre-rasterized bitmap fonts out of the image
+ * pipeline entirely — no resolution variants, no webp conversion, no
+ * cache-bust rename — for the descriptor and every texture page it names.
+ *
+ * A `.fnt` hardcodes `page id=0 file="Syncopate.png"` and PixiJS fetches that
+ * exact name relative to the descriptor's own URL; the manifest is never
+ * consulted for it. So the moment assetpack hashes the page to
+ * `Syncopate-MPx5Vw.webp`, the loader asks for a file that no longer exists,
+ * gets vite's SPA fallback HTML back, and the app fails to boot. Resizing is
+ * just as fatal in the other direction: the glyph rects in the descriptor are
+ * exact pixel coordinates into that one image.
+ *
+ * Detection is automatic — no folder tagging asked of app authors. `start` runs
+ * against the whole asset tree before any transform, which is the only point
+ * where a font's descriptor can be read in time to exempt its siblings.
+ */
+export function bitmapFontPassthrough() {
+  return {
+    folder: false,
+    name: 'bitmap-font-passthrough',
+    defaultOptions: null,
+    async start(rootAsset) {
+      const files = new Map();
+      const descriptors = [];
+
+      const walk = (asset) => {
+        if (!asset.isFolder) {
+          files.set(toPosix(asset.path), asset);
+          if (/\.(fnt|xml)$/i.test(asset.path)) descriptors.push(asset);
+        }
+        for (const child of asset.children ?? []) walk(child);
+      };
+      walk(rootAsset);
+
+      const exempt = (asset) => {
+        asset.settings = { ...asset.settings };
+        for (const pipe of BITMAP_FONT_SKIPPED_PIPES) asset.settings[pipe] = false;
+      };
+
+      for (const descriptor of descriptors) {
+        let text;
+        try {
+          // A deleted asset is still on the tree, and a binary .fnt decodes to
+          // noise — either way the page match below simply finds nothing.
+          text = descriptor.buffer.toString('utf8');
+        } catch {
+          continue;
+        }
+
+        const pages = [...text.matchAll(fontPagePattern)].map((match) => match[1]);
+        // No page reference means it is not a bitmap font — an ordinary .xml
+        // data file must keep its cache-bust hash.
+        if (!pages.length) continue;
+
+        exempt(descriptor);
+        const directory = dirOf(descriptor.path);
+        for (const page of pages) {
+          const sibling = files.get(`${directory}/${baseOf(page)}`);
+          if (sibling) exempt(sibling);
+        }
+      }
+    },
+  };
+}
+
 const defaultManifestUrl = 'assets.json';
 
 const defaultPixiPipesConfig = {
@@ -185,6 +271,10 @@ export const assetpackConfig = (manifestUrl = defaultManifestUrl, pixiPipesConfi
   const wfIdx = pipes.findIndex((p) => p.name === 'webfont');
   pipes.splice(wfIdx >= 0 ? wfIdx : 0, 0, fontWeights());
 
+  // Position is irrelevant — this one only has a `start` hook, and AssetPack
+  // runs every pipe's `start` before the first asset is transformed.
+  pipes.unshift(bitmapFontPassthrough());
+
   return {
     manifestUrl,
     entry: './assets',

package/build/index.mjs

@@ -76,7 +76,9 @@ function caperPluginList({ assets = {}, pwa } = {}) {
     entityListPlugin(),
     uiListPlugin(),
     ...assetPlugins,
-    caperConfigPlugin(),
+    // The manifest name reaches build-time validation this way — it is the only
+    // place that knows a project overrode it.
+    caperConfigPlugin(true, manifestUrl),
     caperDevHelperPlugin(),
     ...(pwa ? caperPwaPlugins(pwa) : []),
   ];

package/build/internal/discovery.mjs

@@ -37,7 +37,7 @@ export async function findTypeScriptFiles(dir) {
 
       if (entry.isDirectory()) {
         await scan(fullPath);
-      } else if (entry.isFile() && /\.ts?$/.test(entry.name)) {
+      } else if (entry.isFile() && /\.tsx?$/.test(entry.name)) {
         files.push(fullPath);
       }
     }

package/build/internal/manifest.mjs

@@ -8,10 +8,15 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { cwd, logger } from './util.mjs';
+import { logger } from './util.mjs';
 
-export function loadManifestBundleNames(manifestUrl = 'assets.json') {
-  const manifestPath = path.join(process.cwd(), 'public', 'assets', manifestUrl);
+/**
+ * `root` is vite's resolved project root — not `process.cwd()`, which is
+ * whatever directory the build was launched from. See `internal/discovery.mjs`
+ * for the same contract.
+ */
+export function loadManifestBundleNames(root, manifestUrl = 'assets.json') {
+  const manifestPath = path.join(root, 'public', 'assets', manifestUrl);
   if (!fs.existsSync(manifestPath)) return null;
   try {
     const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));

package/build/internal/validate.mjs

@@ -12,6 +12,8 @@ import { logger } from './util.mjs';
 
 export function runBuildTimeValidation({
   server,
+  root,
+  manifestUrl,
   configPath,
   configObject,
   scenes,
@@ -21,7 +23,7 @@ export function runBuildTimeValidation({
   breakpointsName,
 }) {
   const warnings = [];
-  const bundleNames = loadManifestBundleNames();
+  const bundleNames = loadManifestBundleNames(root, manifestUrl);
 
   // 1. Scene bundle references
   if (bundleNames && bundleNames.size > 0) {

package/build/plugins/assetTypes.mjs

@@ -9,7 +9,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { loadManifestBundleNames } from '../internal/manifest.mjs';
-import { ASSET_DTS_FILE_NAME, debounce, delay, logger } from '../internal/util.mjs';
+import { ASSET_DTS_FILE_NAME, debounce, delay, env, logger } from '../internal/util.mjs';
 
 export { loadManifestBundleNames };
 
@@ -399,12 +399,12 @@ export function assetTypesPlugin(manifestUrl = 'assets.json') {
 
   return {
     name: 'vite-plugin-asset-types',
-    config(config) {
-      ispPwaEnabled = config.plugins.some((p) => p.name === 'vite-plugin-pwa');
-    },
     configResolved(config) {
       publicDir = config.publicDir;
       root = config.root;
+      // Resolved, so the list is flat: in the `config` hook `caper()` is still
+      // one nested array and vite-plugin-pwa is never found at the top level.
+      ispPwaEnabled = config.plugins.some((p) => p.name === 'vite-plugin-pwa');
     },
     async buildStart() {
       // a short delay to allow assetpack to generate the manifest

package/build/plugins/caperConfig.mjs

@@ -93,7 +93,7 @@ async function validateCaperConfig(server, root) {
 
 // write a debounce function
 
-export function caperConfigPlugin(isProject = true) {
+export function caperConfigPlugin(isProject = true, manifestUrl = 'assets.json') {
   // vite's resolved project root. Everything below resolves against this rather
   // than process.cwd(), so `vite --root elsewhere` and monorepo invocations from
   // a parent directory find the right caper.config.ts and src/ tree.
@@ -228,6 +228,8 @@ export function caperConfigPlugin(isProject = true) {
     // defaultScene pointing at a non-existent scene, duplicate IDs).
     runBuildTimeValidation({
       server,
+      root,
+      manifestUrl,
       configPath,
       configObject,
       scenes,
@@ -444,6 +446,7 @@ declare module '@caperjs/core' {
       const pluginsDir = path.resolve(root, 'src/plugins');
       const popupsDir = path.resolve(root, 'src/popups');
       const entitiesDir = path.resolve(root, 'src/entities');
+      const uisDir = path.resolve(root, 'src/ui');
       const localesDir = path.resolve(root, 'src/locales');
 
       const handleFileChange = async (file) => {
@@ -451,10 +454,11 @@ declare module '@caperjs/core' {
         const isPlugin = file.startsWith(pluginsDir);
         const isPopup = file.startsWith(popupsDir);
         const isEntity = file.startsWith(entitiesDir);
+        const isUI = file.startsWith(uisDir);
         const isLocale = file.startsWith(localesDir);
         const isConfig = file === configPath;
 
-        if (!isScene && !isPlugin && !isPopup && !isEntity && !isLocale && !isConfig) return;
+        if (!isScene && !isPlugin && !isPopup && !isEntity && !isUI && !isLocale && !isConfig) return;
 
         const msg = isScene
           ? 'Scene file changed'
@@ -464,9 +468,11 @@ declare module '@caperjs/core' {
               ? 'Popup file changed'
               : isEntity
                 ? 'Entity file changed'
-                : isLocale
-                  ? 'Locale file changed'
-                  : 'Config file changed';
+                : isUI
+                  ? 'UI file changed'
+                  : isLocale
+                    ? 'Locale file changed'
+                    : 'Config file changed';
         await build(`${msg}, regenerating types...`, server);
       };
 
@@ -475,6 +481,7 @@ declare module '@caperjs/core' {
       server.watcher.add(pluginsDir);
       server.watcher.add(popupsDir);
       server.watcher.add(entitiesDir);
+      server.watcher.add(uisDir);
       server.watcher.add(localesDir);
 
       server.watcher.on('change', handleFileChange);

package/build/plugins/lists.mjs

@@ -9,14 +9,11 @@
 import path from 'node:path';
 import {
   discoverEntities,
-  discoverLocaleKeys,
   discoverPlugins,
   discoverPopups,
   discoverScenes,
   discoverUIs,
 } from '../internal/discovery.mjs';
-import { logger } from '../internal/util.mjs';
-import { loadManifestBundleNames } from '../internal/manifest.mjs';
 
 export function createClassListPlugin({ virtualModuleId, discoverFn, exportName, pluginName }) {
   // vite's resolved project root, captured for the discovery pass. See
@@ -32,7 +29,15 @@ export function createClassListPlugin({ virtualModuleId, discoverFn, exportName,
 
   const generate = (items) => {
     const staticItems = items.filter((i) => i.module && !i.module.isFunction);
-    const imports = staticItems.map((i) => `import ${extractClassName(i)} from '${i.module}';`);
+    // Basenames alone collide when two files share a name in different
+    // directories (e.g. src/entities/a/Foo.ts and src/entities/b/Foo.ts),
+    // producing two `import Foo from '...'` lines — a duplicate-binding
+    // syntax error. Suffix with the item's index in the static-import list
+    // to keep identifiers unique while staying stable and readable, and
+    // look them up from the same map when emitting the object literal so
+    // the import and its `module:` reference always agree.
+    const importNames = new Map(staticItems.map((i, index) => [i, `${extractClassName(i)}_${index}`]));
+    const imports = staticItems.map((i) => `import ${importNames.get(i)} from '${i.module}';`);
 
     return `
     ${imports.join('\n')}
@@ -41,7 +46,7 @@ export function createClassListPlugin({ virtualModuleId, discoverFn, exportName,
         .map((item) => {
           const moduleExpr =
             item.module && !item.module.isFunction
-              ? extractClassName(item)
+              ? importNames.get(item)
               : (item.module?.toString?.() ?? `() => import('${item.importPath}')`);
           return `{
         id: '${item.id}',
@@ -157,7 +162,15 @@ export function pluginListPlugin(isProject = true) {
     // npm static imports would collide on class-name derivation from the pkg
     // path, so only local plugins support `dynamic = false`. npm packages are
     // always dynamic.
-    const imports = staticPlugins.map((p) => `import ${extractClassName(p)} from '${p.module}';`);
+    //
+    // Basenames alone collide when two files share a name in different
+    // directories, producing two `import Foo from '...'` lines — a
+    // duplicate-binding syntax error. Suffix with the item's index in the
+    // static-import list to keep identifiers unique while staying stable
+    // and readable, and look them up from the same map when emitting the
+    // object literal so the import and its `module:` reference always agree.
+    const importNames = new Map(staticPlugins.map((p, index) => [p, `${extractClassName(p)}_${index}`]));
+    const imports = staticPlugins.map((p) => `import ${importNames.get(p)} from '${p.module}';`);
 
     return `
     ${imports.join('\n')}
@@ -166,7 +179,7 @@ export function pluginListPlugin(isProject = true) {
         .map((plugin) => {
           const moduleExpr =
             plugin.module && !plugin.module.isFunction && plugin.isLocal
-              ? extractClassName(plugin)
+              ? importNames.get(plugin)
               : (plugin.module?.toString?.() ?? `() => import('${plugin.importPath}')`);
           return `{
         name: '${plugin.name}',
@@ -223,7 +236,14 @@ export function sceneListPlugin(isProject = true) {
     // extract non function scenes from the list
     const nonFunctionScenes = scenes.filter((scene) => !scene.module.isFunction);
 
-    const imports = nonFunctionScenes.map((scene) => `import ${extractClassName(scene)} from '${scene.module}';`);
+    // Basenames alone collide when two files share a name in different
+    // directories, producing two `import Foo from '...'` lines — a
+    // duplicate-binding syntax error. Suffix with the item's index in the
+    // static-import list to keep identifiers unique while staying stable
+    // and readable, and look them up from the same map when emitting the
+    // object literal so the import and its `module:` reference always agree.
+    const importNames = new Map(nonFunctionScenes.map((scene, index) => [scene, `${extractClassName(scene)}_${index}`]));
+    const imports = nonFunctionScenes.map((scene) => `import ${importNames.get(scene)} from '${scene.module}';`);
 
     const result = `
     ${imports.join('\n')}
@@ -233,7 +253,7 @@ export function sceneListPlugin(isProject = true) {
           (scene) => `{
         id: '${scene.id}',
         active: ${scene.active},
-        module: ${scene.module.isFunction ? scene.module.toString() : extractClassName(scene)},
+        module: ${scene.module.isFunction ? scene.module.toString() : importNames.get(scene)},
         debugLabel: ${JSON.stringify(scene.debugLabel)},
         debugGroup: ${JSON.stringify(scene.debugGroup)},
         debugOrder: ${scene.debugOrder},

package/build/plugins/pruneFallbacks.mjs

@@ -28,6 +28,17 @@ import path from 'node:path';
 /** A png image, a texture-packer descriptor, or a spine atlas for one. */
 const isPngSrc = (src) => /\.png(\.json|\.atlas)?$/.test(src);
 
+/** A bitmap font descriptor — text `.fnt` or XML `.fnt`/`.xml`, both quote `file="…"`. */
+const isFontSrc = (src) => /\.(fnt|xml)$/.test(src);
+
+/**
+ * PixiJS bitmap fonts hardcode their texture page filename inside the
+ * descriptor and fetch it relative to the descriptor's own URL — the asset
+ * manifest is never consulted for that request, so rewriting `src` there
+ * doesn't stop the loader asking for the exact name printed here.
+ */
+const fontPageNames = (text) => new Set([...text.matchAll(/file="([^"]+\.png)"/g)].map((match) => path.basename(match[1])));
+
 /**
  * Works out what to delete without touching the filesystem, so the decision is
  * testable on its own.
@@ -77,10 +88,22 @@ export function planPngPrune(manifest, readText) {
     doomed.push(rel);
   };
 
+  const protectedPngs = new Set();
+  for (const bundle of manifest.bundles ?? []) {
+    for (const asset of bundle.assets ?? []) {
+      for (const src of asset.src ?? []) {
+        if (!isFontSrc(src)) continue;
+        const text = readText(src);
+        if (text) for (const name of fontPageNames(text)) protectedPngs.add(name);
+      }
+    }
+  }
+
   for (const bundle of manifest.bundles ?? []) {
     for (const asset of bundle.assets ?? []) {
-      const png = (asset.src ?? []).filter(isPngSrc);
-      const kept = (asset.src ?? []).filter((src) => !isPngSrc(src));
+      const isProtected = (src) => isPngSrc(src) && protectedPngs.has(path.basename(src));
+      const png = (asset.src ?? []).filter((src) => isPngSrc(src) && !isProtected(src));
+      const kept = (asset.src ?? []).filter((src) => !isPngSrc(src) || isProtected(src));
       if (!png.length || !kept.length) continue;
 
       for (const rel of png) {

package/cli/create.mjs

@@ -88,6 +88,60 @@ function getFiles(dirPath) {
   return files;
 }
 
+/**
+ * Injects wizard-selected plugin config entries into a caper.config.ts file's
+ * `plugins:` array, whether that array is currently empty or already has entries.
+ *
+ * @param {string} configContents
+ * @param {string[]} pluginConfigs
+ * @returns {string}
+ */
+export function injectPluginsIntoConfig(configContents, pluginConfigs) {
+  // Empty array: replace it wholesale with the new entries.
+  if (/plugins:\s*\[\s*\]/.test(configContents)) {
+    return configContents.replace(
+      /plugins:\s*\[\s*\]/,
+      `plugins: [\n    ${pluginConfigs.join(',\n    ')}\n  ]`,
+    );
+  }
+
+  // Non-empty array: find the `plugins:` array's matching brackets (which may
+  // contain nested arrays, e.g. `['name', {...}]` entries) and append the new
+  // entries alongside the existing ones.
+  const keyMatch = configContents.match(/plugins:\s*\[/);
+  if (!keyMatch) {
+    return configContents;
+  }
+
+  const openBracketIndex = keyMatch.index + keyMatch[0].length - 1;
+  let depth = 0;
+  let closeBracketIndex = -1;
+  for (let i = openBracketIndex; i < configContents.length; i++) {
+    if (configContents[i] === '[') depth++;
+    else if (configContents[i] === ']') {
+      depth--;
+      if (depth === 0) {
+        closeBracketIndex = i;
+        break;
+      }
+    }
+  }
+  if (closeBracketIndex === -1) {
+    return configContents;
+  }
+
+  const existingEntries = configContents.slice(openBracketIndex + 1, closeBracketIndex).trim();
+  const allEntries = existingEntries
+    ? `${existingEntries},\n    ${pluginConfigs.join(',\n    ')}`
+    : pluginConfigs.join(',\n    ');
+
+  return (
+    configContents.slice(0, openBracketIndex) +
+    `[\n    ${allEntries}\n  ]` +
+    configContents.slice(closeBracketIndex + 1)
+  );
+}
+
 /**
  * @param {string} template
  * @param {string} applicationNameForPkg
@@ -180,11 +234,8 @@ function write_template_files(cwd, template, applicationNameForPkg, applicationN
       return `['${shortName}', { autoLoad: false }]`;
     });
 
-    // Replace empty plugins array with configured plugins
-    configContents = configContents.replace(
-      /plugins:\s*\[\s*\]/,
-      `plugins: [\n    ${pluginConfigs.join(',\n    ')}\n  ]`,
-    );
+    // Inject the configured plugins into the plugins array
+    configContents = injectPluginsIntoConfig(configContents, pluginConfigs);
   }
 
   fs.writeFileSync(configPath, configContents.replace(/__APPLICATION_NAME__/g, applicationName), 'utf-8');
@@ -304,7 +355,7 @@ export async function create(cwd = '.', packageManagerOverride) {
   });
 
   if (!appName) {
-    appName = name;
+    appName = defaultName;
   }
 
   // derive an application name from the project name by camel casing it

package/cli/create.test.mjs

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { injectPluginsIntoConfig } from './create.mjs';
+
+describe('injectPluginsIntoConfig', () => {
+  it('inserts plugins into an empty array', () => {
+    const configContents = `export default {\n  plugins: [],\n};\n`;
+    const pluginConfigs = [`['rollbar', { autoLoad: false }]`];
+
+    const result = injectPluginsIntoConfig(configContents, pluginConfigs);
+
+    expect(result).toContain(`plugins: [\n    ['rollbar', { autoLoad: false }]\n  ]`);
+  });
+
+  it('appends plugins alongside an existing non-empty array', () => {
+    const configContents = `export default {\n  plugins: [['existing', { autoLoad: false }]],\n};\n`;
+    const pluginConfigs = [`['rollbar', { autoLoad: false }]`];
+
+    const result = injectPluginsIntoConfig(configContents, pluginConfigs);
+
+    expect(result).toContain(`['existing', { autoLoad: false }]`);
+    expect(result).toContain(`['rollbar', { autoLoad: false }]`);
+    // both entries should end up inside a single well-formed array
+    expect(result).toMatch(/plugins: \[[\s\S]*existing[\s\S]*rollbar[\s\S]*\]/);
+  });
+
+  it('appends plugins alongside an existing multiline array', () => {
+    const configContents = `export default {\n  plugins: [\n    ['existing', { autoLoad: false }],\n  ],\n};\n`;
+    const pluginConfigs = [`['rollbar', { autoLoad: false }]`, `['rive', { autoLoad: false }]`];
+
+    const result = injectPluginsIntoConfig(configContents, pluginConfigs);
+
+    expect(result).toContain(`['existing', { autoLoad: false }]`);
+    expect(result).toContain(`['rollbar', { autoLoad: false }]`);
+    expect(result).toContain(`['rive', { autoLoad: false }]`);
+  });
+});

package/cli/update.mjs

@@ -2,7 +2,7 @@
 import {execSync} from 'node:child_process';
 import {package_manager} from './utils.mjs';
 
-const install_path = 'github:anthonysapp/caper';
+const install_path = '@caperjs/core@latest';
 
 export async function update() {
 	return execSync(`${package_manager} install ${install_path}`);

package/lib/{CaptionsPlugin-WPAcfAkx.js → CaptionsPlugin-cSJj-R9M.js}

@@ -1,5 +1,5 @@
-import { Dt as e, H as t, bt as n, f as r, jt as i } from "./registries-BLrxALZ0.js";
-import { ensurePadding as a } from "./caper.mjs";
+import { Dt as e, H as t, bt as n, f as r, jt as i } from "./registries-BfV-VF7a.js";
+import { t as a } from "./padding-1kHDpGlQ.js";
 import { Assets as o, Container as s, Texture as c } from "pixi.js";
 import { gsap as l } from "gsap";
 //#region src/plugins/captions/CaptionsRenderer.ts
@@ -194,13 +194,13 @@ var m = class extends t {
 	postInitialize() {
 		this.app.i18n.onLocaleChanged.connect(this._handleLocaleChange), this.app.voiceover.onVoiceOverStart.connect(this._handleVoiceOverStart), this.app.voiceover.onVoiceOverPaused.connect(this._handleVoiceOverPaused), this.app.voiceover.onVoiceOverResumed.connect(this._handleVoiceOverResumed), this.app.voiceover.onVoiceOverComplete.connect(this._handleVoiceoverComplete), this.app.voiceover.onVoiceOverStopped.connect(this._handleVoiceoverStopped), this.app.stage.addChild(this.view), this._options.maxWidth = p(this._originalOptions.maxWidth, this.app.size.width);
 		let e = this.options.renderer;
-		this.renderer = this.view.addChild(new e(this)), this.app.ticker.add(this.update), this.app.scenes.onSceneChangeStart.connect(this.stopAllCaptions);
+		this.renderer = this.view.addChild(new e(this)), this.addTickerCallback(this.update), this.app.scenes.onSceneChangeStart.connect(this.stopAllCaptions);
 	}
 	async setLocale(e) {
 		return this._locale === e ? this._locale : (this._activeCaptionId && this.stopCaption(this._activeCaptionId), this._activeCaptionId = void 0, await this._loadAndSetLocale(e), this._locale = e, this._locale);
 	}
 	async loadLocale(t) {
-		if (this._locale === "localeId") return;
+		if (this._dicts[t]) return;
 		let r = this._options.files.find((e) => t === e.id);
 		if (!r) {
 			e.error(`i18n:: Could not find locale file for ${t}`);
@@ -275,4 +275,4 @@ var m = class extends t {
 //#endregion
 export { m as CaptionsPlugin };
 
-//# sourceMappingURL=CaptionsPlugin-WPAcfAkx.js.map
+//# sourceMappingURL=CaptionsPlugin-cSJj-R9M.js.map