sdfsdfs

node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontTextParser.d.ts

@@ -0,0 +1,51 @@
+import type { BitmapFontData } from '../AbstractBitmapFont';
+/**
+ * Internal data format used to convert to BitmapFontData.
+ * @private
+ */
+export interface BitmapFontRawData {
+    info: {
+        face: string;
+        size: string;
+    }[];
+    common: {
+        lineHeight: string;
+        base: string;
+    }[];
+    page: {
+        id: string;
+        file: string;
+    }[];
+    chars: {
+        count: number;
+    }[];
+    char: {
+        id: string;
+        page: string;
+        xoffset: string;
+        yoffset: string;
+        xadvance: string;
+        x: string;
+        y: string;
+        width: string;
+        height: string;
+        letter?: string;
+        char?: string;
+    }[];
+    kernings?: {
+        count: number;
+    }[];
+    kerning?: {
+        first: string;
+        second: string;
+        amount: string;
+    }[];
+    distanceField?: {
+        fieldType: 'sdf' | 'msdf' | 'none';
+        distanceRange: string;
+    }[];
+}
+export declare const bitmapFontTextParser: {
+    test(data: string | XMLDocument | BitmapFontData): boolean;
+    parse(txt: string): BitmapFontData;
+};

node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontTextParser.js

@@ -0,0 +1,98 @@
+'use strict';
+
+"use strict";
+const bitmapFontTextParser = {
+  test(data) {
+    return typeof data === "string" && data.startsWith("info face=");
+  },
+  parse(txt) {
+    const items = txt.match(/^[a-z]+\s+.+$/gm);
+    const rawData = {
+      info: [],
+      common: [],
+      page: [],
+      char: [],
+      chars: [],
+      kerning: [],
+      kernings: [],
+      distanceField: []
+    };
+    for (const i in items) {
+      const name = items[i].match(/^[a-z]+/gm)[0];
+      const attributeList = items[i].match(/[a-zA-Z]+=([^\s"']+|"([^"]*)")/gm);
+      const itemData = {};
+      for (const i2 in attributeList) {
+        const split = attributeList[i2].split("=");
+        const key = split[0];
+        const strValue = split[1].replace(/"/gm, "");
+        const floatValue = parseFloat(strValue);
+        const value = isNaN(floatValue) ? strValue : floatValue;
+        itemData[key] = value;
+      }
+      rawData[name].push(itemData);
+    }
+    const font = {
+      chars: {},
+      pages: [],
+      lineHeight: 0,
+      fontSize: 0,
+      fontFamily: "",
+      distanceField: null,
+      baseLineOffset: 0
+    };
+    const [info] = rawData.info;
+    const [common] = rawData.common;
+    const [distanceField] = rawData.distanceField ?? [];
+    if (distanceField) {
+      font.distanceField = {
+        range: parseInt(distanceField.distanceRange, 10),
+        type: distanceField.fieldType
+      };
+    }
+    font.fontSize = parseInt(info.size, 10);
+    font.fontFamily = info.face;
+    font.lineHeight = parseInt(common.lineHeight, 10);
+    const page = rawData.page;
+    for (let i = 0; i < page.length; i++) {
+      font.pages.push({
+        id: parseInt(page[i].id, 10) || 0,
+        file: page[i].file
+      });
+    }
+    const map = {};
+    font.baseLineOffset = font.lineHeight - parseInt(common.base, 10);
+    const char = rawData.char;
+    for (let i = 0; i < char.length; i++) {
+      const charNode = char[i];
+      const id = parseInt(charNode.id, 10);
+      let letter = charNode.letter ?? charNode.char ?? String.fromCharCode(id);
+      if (letter === "space")
+        letter = " ";
+      map[id] = letter;
+      font.chars[letter] = {
+        id,
+        // texture deets..
+        page: parseInt(charNode.page, 10) || 0,
+        x: parseInt(charNode.x, 10),
+        y: parseInt(charNode.y, 10),
+        width: parseInt(charNode.width, 10),
+        height: parseInt(charNode.height, 10),
+        xOffset: parseInt(charNode.xoffset, 10),
+        yOffset: parseInt(charNode.yoffset, 10),
+        xAdvance: parseInt(charNode.xadvance, 10),
+        kerning: {}
+      };
+    }
+    const kerning = rawData.kerning || [];
+    for (let i = 0; i < kerning.length; i++) {
+      const first = parseInt(kerning[i].first, 10);
+      const second = parseInt(kerning[i].second, 10);
+      const amount = parseInt(kerning[i].amount, 10);
+      font.chars[map[second]].kerning[map[first]] = amount;
+    }
+    return font;
+  }
+};
+
+exports.bitmapFontTextParser = bitmapFontTextParser;
+//# sourceMappingURL=bitmapFontTextParser.js.map

node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontTextParser.mjs

@@ -0,0 +1,96 @@
+"use strict";
+const bitmapFontTextParser = {
+  test(data) {
+    return typeof data === "string" && data.startsWith("info face=");
+  },
+  parse(txt) {
+    const items = txt.match(/^[a-z]+\s+.+$/gm);
+    const rawData = {
+      info: [],
+      common: [],
+      page: [],
+      char: [],
+      chars: [],
+      kerning: [],
+      kernings: [],
+      distanceField: []
+    };
+    for (const i in items) {
+      const name = items[i].match(/^[a-z]+/gm)[0];
+      const attributeList = items[i].match(/[a-zA-Z]+=([^\s"']+|"([^"]*)")/gm);
+      const itemData = {};
+      for (const i2 in attributeList) {
+        const split = attributeList[i2].split("=");
+        const key = split[0];
+        const strValue = split[1].replace(/"/gm, "");
+        const floatValue = parseFloat(strValue);
+        const value = isNaN(floatValue) ? strValue : floatValue;
+        itemData[key] = value;
+      }
+      rawData[name].push(itemData);
+    }
+    const font = {
+      chars: {},
+      pages: [],
+      lineHeight: 0,
+      fontSize: 0,
+      fontFamily: "",
+      distanceField: null,
+      baseLineOffset: 0
+    };
+    const [info] = rawData.info;
+    const [common] = rawData.common;
+    const [distanceField] = rawData.distanceField ?? [];
+    if (distanceField) {
+      font.distanceField = {
+        range: parseInt(distanceField.distanceRange, 10),
+        type: distanceField.fieldType
+      };
+    }
+    font.fontSize = parseInt(info.size, 10);
+    font.fontFamily = info.face;
+    font.lineHeight = parseInt(common.lineHeight, 10);
+    const page = rawData.page;
+    for (let i = 0; i < page.length; i++) {
+      font.pages.push({
+        id: parseInt(page[i].id, 10) || 0,
+        file: page[i].file
+      });
+    }
+    const map = {};
+    font.baseLineOffset = font.lineHeight - parseInt(common.base, 10);
+    const char = rawData.char;
+    for (let i = 0; i < char.length; i++) {
+      const charNode = char[i];
+      const id = parseInt(charNode.id, 10);
+      let letter = charNode.letter ?? charNode.char ?? String.fromCharCode(id);
+      if (letter === "space")
+        letter = " ";
+      map[id] = letter;
+      font.chars[letter] = {
+        id,
+        // texture deets..
+        page: parseInt(charNode.page, 10) || 0,
+        x: parseInt(charNode.x, 10),
+        y: parseInt(charNode.y, 10),
+        width: parseInt(charNode.width, 10),
+        height: parseInt(charNode.height, 10),
+        xOffset: parseInt(charNode.xoffset, 10),
+        yOffset: parseInt(charNode.yoffset, 10),
+        xAdvance: parseInt(charNode.xadvance, 10),
+        kerning: {}
+      };
+    }
+    const kerning = rawData.kerning || [];
+    for (let i = 0; i < kerning.length; i++) {
+      const first = parseInt(kerning[i].first, 10);
+      const second = parseInt(kerning[i].second, 10);
+      const amount = parseInt(kerning[i].amount, 10);
+      font.chars[map[second]].kerning[map[first]] = amount;
+    }
+    return font;
+  }
+};
+
+export { bitmapFontTextParser };
+//# sourceMappingURL=bitmapFontTextParser.mjs.map

node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontXMLParser.d.ts

@@ -0,0 +1,5 @@
+import type { BitmapFontData } from '../AbstractBitmapFont';
+export declare const bitmapFontXMLParser: {
+    test(data: string | XMLDocument | BitmapFontData): boolean;
+    parse(xml: Document): BitmapFontData;
+};

node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontXMLParser.js

@@ -0,0 +1,76 @@
+'use strict';
+
+"use strict";
+const bitmapFontXMLParser = {
+  test(data) {
+    const xml = data;
+    return typeof xml !== "string" && "getElementsByTagName" in xml && xml.getElementsByTagName("page").length && xml.getElementsByTagName("info")[0].getAttribute("face") !== null;
+  },
+  parse(xml) {
+    const data = {
+      chars: {},
+      pages: [],
+      lineHeight: 0,
+      fontSize: 0,
+      fontFamily: "",
+      distanceField: null,
+      baseLineOffset: 0
+    };
+    const info = xml.getElementsByTagName("info")[0];
+    const common = xml.getElementsByTagName("common")[0];
+    const distanceField = xml.getElementsByTagName("distanceField")[0];
+    if (distanceField) {
+      data.distanceField = {
+        type: distanceField.getAttribute("fieldType"),
+        range: parseInt(distanceField.getAttribute("distanceRange"), 10)
+      };
+    }
+    const page = xml.getElementsByTagName("page");
+    const char = xml.getElementsByTagName("char");
+    const kerning = xml.getElementsByTagName("kerning");
+    data.fontSize = parseInt(info.getAttribute("size"), 10);
+    data.fontFamily = info.getAttribute("face");
+    data.lineHeight = parseInt(common.getAttribute("lineHeight"), 10);
+    for (let i = 0; i < page.length; i++) {
+      data.pages.push({
+        id: parseInt(page[i].getAttribute("id"), 10) || 0,
+        file: page[i].getAttribute("file")
+      });
+    }
+    const map = {};
+    data.baseLineOffset = data.lineHeight - parseInt(common.getAttribute("base"), 10);
+    for (let i = 0; i < char.length; i++) {
+      const charNode = char[i];
+      const id = parseInt(charNode.getAttribute("id"), 10);
+      let letter = charNode.getAttribute("letter") ?? charNode.getAttribute("char") ?? String.fromCharCode(id);
+      if (letter === "space")
+        letter = " ";
+      map[id] = letter;
+      data.chars[letter] = {
+        id,
+        // texture deets..
+        page: parseInt(charNode.getAttribute("page"), 10) || 0,
+        x: parseInt(charNode.getAttribute("x"), 10),
+        y: parseInt(charNode.getAttribute("y"), 10),
+        width: parseInt(charNode.getAttribute("width"), 10),
+        height: parseInt(charNode.getAttribute("height"), 10),
+        // render deets..
+        xOffset: parseInt(charNode.getAttribute("xoffset"), 10),
+        yOffset: parseInt(charNode.getAttribute("yoffset"), 10),
+        // + baseLineOffset,
+        xAdvance: parseInt(charNode.getAttribute("xadvance"), 10),
+        kerning: {}
+      };
+    }
+    for (let i = 0; i < kerning.length; i++) {
+      const first = parseInt(kerning[i].getAttribute("first"), 10);
+      const second = parseInt(kerning[i].getAttribute("second"), 10);
+      const amount = parseInt(kerning[i].getAttribute("amount"), 10);
+      data.chars[map[second]].kerning[map[first]] = amount;
+    }
+    return data;
+  }
+};
+
+exports.bitmapFontXMLParser = bitmapFontXMLParser;
+//# sourceMappingURL=bitmapFontXMLParser.js.map

node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontXMLParser.mjs

@@ -0,0 +1,74 @@
+"use strict";
+const bitmapFontXMLParser = {
+  test(data) {
+    const xml = data;
+    return typeof xml !== "string" && "getElementsByTagName" in xml && xml.getElementsByTagName("page").length && xml.getElementsByTagName("info")[0].getAttribute("face") !== null;
+  },
+  parse(xml) {
+    const data = {
+      chars: {},
+      pages: [],
+      lineHeight: 0,
+      fontSize: 0,
+      fontFamily: "",
+      distanceField: null,
+      baseLineOffset: 0
+    };
+    const info = xml.getElementsByTagName("info")[0];
+    const common = xml.getElementsByTagName("common")[0];
+    const distanceField = xml.getElementsByTagName("distanceField")[0];
+    if (distanceField) {
+      data.distanceField = {
+        type: distanceField.getAttribute("fieldType"),
+        range: parseInt(distanceField.getAttribute("distanceRange"), 10)
+      };
+    }
+    const page = xml.getElementsByTagName("page");
+    const char = xml.getElementsByTagName("char");
+    const kerning = xml.getElementsByTagName("kerning");
+    data.fontSize = parseInt(info.getAttribute("size"), 10);
+    data.fontFamily = info.getAttribute("face");
+    data.lineHeight = parseInt(common.getAttribute("lineHeight"), 10);
+    for (let i = 0; i < page.length; i++) {
+      data.pages.push({
+        id: parseInt(page[i].getAttribute("id"), 10) || 0,
+        file: page[i].getAttribute("file")
+      });
+    }
+    const map = {};
+    data.baseLineOffset = data.lineHeight - parseInt(common.getAttribute("base"), 10);
+    for (let i = 0; i < char.length; i++) {
+      const charNode = char[i];
+      const id = parseInt(charNode.getAttribute("id"), 10);
+      let letter = charNode.getAttribute("letter") ?? charNode.getAttribute("char") ?? String.fromCharCode(id);
+      if (letter === "space")
+        letter = " ";
+      map[id] = letter;
+      data.chars[letter] = {
+        id,
+        // texture deets..
+        page: parseInt(charNode.getAttribute("page"), 10) || 0,
+        x: parseInt(charNode.getAttribute("x"), 10),
+        y: parseInt(charNode.getAttribute("y"), 10),
+        width: parseInt(charNode.getAttribute("width"), 10),
+        height: parseInt(charNode.getAttribute("height"), 10),
+        // render deets..
+        xOffset: parseInt(charNode.getAttribute("xoffset"), 10),
+        yOffset: parseInt(charNode.getAttribute("yoffset"), 10),
+        // + baseLineOffset,
+        xAdvance: parseInt(charNode.getAttribute("xadvance"), 10),
+        kerning: {}
+      };
+    }
+    for (let i = 0; i < kerning.length; i++) {
+      const first = parseInt(kerning[i].getAttribute("first"), 10);
+      const second = parseInt(kerning[i].getAttribute("second"), 10);
+      const amount = parseInt(kerning[i].getAttribute("amount"), 10);
+      data.chars[map[second]].kerning[map[first]] = amount;
+    }
+    return data;
+  }
+};
+
+export { bitmapFontXMLParser };
+//# sourceMappingURL=bitmapFontXMLParser.mjs.map

node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontXMLStringParser.d.ts

@@ -0,0 +1,5 @@
+import type { BitmapFontData } from '../AbstractBitmapFont';
+export declare const bitmapFontXMLStringParser: {
+    test(data: string | XMLDocument | BitmapFontData): boolean;
+    parse(data: string): BitmapFontData;
+};

node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontXMLStringParser.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var adapter = require('../../../environment/adapter.js');
+var bitmapFontXMLParser = require('./bitmapFontXMLParser.js');
+
+"use strict";
+const bitmapFontXMLStringParser = {
+  test(data) {
+    if (typeof data === "string" && data.includes("<font>")) {
+      return bitmapFontXMLParser.bitmapFontXMLParser.test(adapter.DOMAdapter.get().parseXML(data));
+    }
+    return false;
+  },
+  parse(data) {
+    return bitmapFontXMLParser.bitmapFontXMLParser.parse(adapter.DOMAdapter.get().parseXML(data));
+  }
+};
+
+exports.bitmapFontXMLStringParser = bitmapFontXMLStringParser;
+//# sourceMappingURL=bitmapFontXMLStringParser.js.map

node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontXMLStringParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitmapFontXMLStringParser.js","sources":["../../../../src/scene/text-bitmap/asset/bitmapFontXMLStringParser.ts"],"sourcesContent":["import { DOMAdapter } from '../../../environment/adapter';\nimport { bitmapFontXMLParser } from './bitmapFontXMLParser';\n\nimport type { BitmapFontData } from '../AbstractBitmapFont';\n\nexport const bitmapFontXMLStringParser = {\n    test(data: string | XMLDocument | BitmapFontData): boolean\n    {\n        if (typeof data === 'string' && data.includes('<font>'))\n        {\n            return bitmapFontXMLParser.test(DOMAdapter.get().parseXML(data));\n        }\n\n        return false;\n    },\n\n    parse(data: string): BitmapFontData\n    {\n        return bitmapFontXMLParser.parse(DOMAdapter.get().parseXML(data));\n    }\n};\n"],"names":["bitmapFontXMLParser","DOMAdapter"],"mappings":";;;;;;AAKO,MAAM,yBAA4B,GAAA;AAAA,EACrC,KAAK,IACL,EAAA;AACI,IAAA,IAAI,OAAO,IAAS,KAAA,QAAA,IAAY,IAAK,CAAA,QAAA,CAAS,QAAQ,CACtD,EAAA;AACI,MAAA,OAAOA,wCAAoB,IAAK,CAAAC,kBAAA,CAAW,KAAM,CAAA,QAAA,CAAS,IAAI,CAAC,CAAA,CAAA;AAAA,KACnE;AAEA,IAAO,OAAA,KAAA,CAAA;AAAA,GACX;AAAA,EAEA,MAAM,IACN,EAAA;AACI,IAAA,OAAOD,wCAAoB,KAAM,CAAAC,kBAAA,CAAW,KAAM,CAAA,QAAA,CAAS,IAAI,CAAC,CAAA,CAAA;AAAA,GACpE;AACJ;;;;"}

node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontXMLStringParser.mjs

@@ -0,0 +1,18 @@
+import { DOMAdapter } from '../../../environment/adapter.mjs';
+import { bitmapFontXMLParser } from './bitmapFontXMLParser.mjs';
+
+"use strict";
+const bitmapFontXMLStringParser = {
+  test(data) {
+    if (typeof data === "string" && data.includes("<font>")) {
+      return bitmapFontXMLParser.test(DOMAdapter.get().parseXML(data));
+    }
+    return false;
+  },
+  parse(data) {
+    return bitmapFontXMLParser.parse(DOMAdapter.get().parseXML(data));
+  }
+};
+
+export { bitmapFontXMLStringParser };
+//# sourceMappingURL=bitmapFontXMLStringParser.mjs.map

node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontXMLStringParser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitmapFontXMLStringParser.mjs","sources":["../../../../src/scene/text-bitmap/asset/bitmapFontXMLStringParser.ts"],"sourcesContent":["import { DOMAdapter } from '../../../environment/adapter';\nimport { bitmapFontXMLParser } from './bitmapFontXMLParser';\n\nimport type { BitmapFontData } from '../AbstractBitmapFont';\n\nexport const bitmapFontXMLStringParser = {\n    test(data: string | XMLDocument | BitmapFontData): boolean\n    {\n        if (typeof data === 'string' && data.includes('<font>'))\n        {\n            return bitmapFontXMLParser.test(DOMAdapter.get().parseXML(data));\n        }\n\n        return false;\n    },\n\n    parse(data: string): BitmapFontData\n    {\n        return bitmapFontXMLParser.parse(DOMAdapter.get().parseXML(data));\n    }\n};\n"],"names":[],"mappings":";;;;AAKO,MAAM,yBAA4B,GAAA;AAAA,EACrC,KAAK,IACL,EAAA;AACI,IAAA,IAAI,OAAO,IAAS,KAAA,QAAA,IAAY,IAAK,CAAA,QAAA,CAAS,QAAQ,CACtD,EAAA;AACI,MAAA,OAAO,oBAAoB,IAAK,CAAA,UAAA,CAAW,KAAM,CAAA,QAAA,CAAS,IAAI,CAAC,CAAA,CAAA;AAAA,KACnE;AAEA,IAAO,OAAA,KAAA,CAAA;AAAA,GACX;AAAA,EAEA,MAAM,IACN,EAAA;AACI,IAAA,OAAO,oBAAoB,KAAM,CAAA,UAAA,CAAW,KAAM,CAAA,QAAA,CAAS,IAAI,CAAC,CAAA,CAAA;AAAA,GACpE;AACJ;;;;"}

node_modules/pixi.js/lib/scene/text-bitmap/asset/loadBitmapFont.d.ts

@@ -0,0 +1,26 @@
+import { LoaderParserPriority } from '../../../assets/loader/parsers/LoaderParser';
+import { ExtensionType } from '../../../extensions/Extensions';
+import { BitmapFont } from '../BitmapFont';
+import type { Loader } from '../../../assets/loader/Loader';
+import type { ResolvedAsset } from '../../../assets/types';
+/** simple loader plugin for loading in bitmap fonts! */
+export declare const bitmapFontCachePlugin: {
+    extension: {
+        type: ExtensionType.CacheParser;
+        name: string;
+    };
+    test: (asset: BitmapFont) => boolean;
+    getCacheableAssets(keys: string[], asset: BitmapFont): Record<string, BitmapFont>;
+};
+export declare const loadBitmapFont: {
+    extension: {
+        type: ExtensionType.LoadParser;
+        priority: LoaderParserPriority;
+    };
+    name: string;
+    test(url: string): boolean;
+    testParse(data: string): Promise<boolean>;
+    parse<T>(asset: string, data: ResolvedAsset, loader: Loader): Promise<BitmapFont>;
+    load<T_1>(url: string, _options: ResolvedAsset): Promise<string>;
+    unload(bitmapFont: BitmapFont, _resolvedAsset: ResolvedAsset<any>, loader: Loader): Promise<void>;
+};

node_modules/pixi.js/lib/scene/text-bitmap/asset/loadBitmapFont.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var LoaderParser = require('../../../assets/loader/parsers/LoaderParser.js');
+var copySearchParams = require('../../../assets/utils/copySearchParams.js');
+var adapter = require('../../../environment/adapter.js');
+var Extensions = require('../../../extensions/Extensions.js');
+var path = require('../../../utils/path.js');
+var BitmapFont = require('../BitmapFont.js');
+var bitmapFontTextParser = require('./bitmapFontTextParser.js');
+var bitmapFontXMLStringParser = require('./bitmapFontXMLStringParser.js');
+
+"use strict";
+const validExtensions = [".xml", ".fnt"];
+const bitmapFontCachePlugin = {
+  extension: {
+    type: Extensions.ExtensionType.CacheParser,
+    name: "cacheBitmapFont"
+  },
+  test: (asset) => asset instanceof BitmapFont.BitmapFont,
+  getCacheableAssets(keys, asset) {
+    const out = {};
+    keys.forEach((key) => {
+      out[key] = asset;
+      out[`${key}-bitmap`] = asset;
+    });
+    out[`${asset.fontFamily}-bitmap`] = asset;
+    return out;
+  }
+};
+const loadBitmapFont = {
+  extension: {
+    type: Extensions.ExtensionType.LoadParser,
+    priority: LoaderParser.LoaderParserPriority.Normal
+  },
+  name: "loadBitmapFont",
+  test(url) {
+    return validExtensions.includes(path.path.extname(url).toLowerCase());
+  },
+  async testParse(data) {
+    return bitmapFontTextParser.bitmapFontTextParser.test(data) || bitmapFontXMLStringParser.bitmapFontXMLStringParser.test(data);
+  },
+  async parse(asset, data, loader) {
+    const bitmapFontData = bitmapFontTextParser.bitmapFontTextParser.test(asset) ? bitmapFontTextParser.bitmapFontTextParser.parse(asset) : bitmapFontXMLStringParser.bitmapFontXMLStringParser.parse(asset);
+    const { src } = data;
+    const { pages } = bitmapFontData;
+    const textureUrls = [];
+    const textureOptions = bitmapFontData.distanceField ? {
+      scaleMode: "linear",
+      alphaMode: "premultiply-alpha-on-upload",
+      autoGenerateMipmaps: false,
+      resolution: 1
+    } : {};
+    for (let i = 0; i < pages.length; ++i) {
+      const pageFile = pages[i].file;
+      let imagePath = path.path.join(path.path.dirname(src), pageFile);
+      imagePath = copySearchParams.copySearchParams(imagePath, src);
+      textureUrls.push({
+        src: imagePath,
+        data: textureOptions
+      });
+    }
+    const loadedTextures = await loader.load(textureUrls);
+    const textures = textureUrls.map((url) => loadedTextures[url.src]);
+    const bitmapFont = new BitmapFont.BitmapFont({
+      data: bitmapFontData,
+      textures
+    }, src);
+    return bitmapFont;
+  },
+  async load(url, _options) {
+    const response = await adapter.DOMAdapter.get().fetch(url);
+    return await response.text();
+  },
+  async unload(bitmapFont, _resolvedAsset, loader) {
+    await Promise.all(bitmapFont.pages.map((page) => loader.unload(page.texture.source._sourceOrigin)));
+    bitmapFont.destroy();
+  }
+};
+
+exports.bitmapFontCachePlugin = bitmapFontCachePlugin;
+exports.loadBitmapFont = loadBitmapFont;
+//# sourceMappingURL=loadBitmapFont.js.map

node_modules/pixi.js/lib/scene/text-bitmap/asset/loadBitmapFont.mjs

@@ -0,0 +1,79 @@
+import { LoaderParserPriority } from '../../../assets/loader/parsers/LoaderParser.mjs';
+import { copySearchParams } from '../../../assets/utils/copySearchParams.mjs';
+import { DOMAdapter } from '../../../environment/adapter.mjs';
+import { ExtensionType } from '../../../extensions/Extensions.mjs';
+import { path } from '../../../utils/path.mjs';
+import { BitmapFont } from '../BitmapFont.mjs';
+import { bitmapFontTextParser } from './bitmapFontTextParser.mjs';
+import { bitmapFontXMLStringParser } from './bitmapFontXMLStringParser.mjs';
+
+"use strict";
+const validExtensions = [".xml", ".fnt"];
+const bitmapFontCachePlugin = {
+  extension: {
+    type: ExtensionType.CacheParser,
+    name: "cacheBitmapFont"
+  },
+  test: (asset) => asset instanceof BitmapFont,
+  getCacheableAssets(keys, asset) {
+    const out = {};
+    keys.forEach((key) => {
+      out[key] = asset;
+      out[`${key}-bitmap`] = asset;
+    });
+    out[`${asset.fontFamily}-bitmap`] = asset;
+    return out;
+  }
+};
+const loadBitmapFont = {
+  extension: {
+    type: ExtensionType.LoadParser,
+    priority: LoaderParserPriority.Normal
+  },
+  name: "loadBitmapFont",
+  test(url) {
+    return validExtensions.includes(path.extname(url).toLowerCase());
+  },
+  async testParse(data) {
+    return bitmapFontTextParser.test(data) || bitmapFontXMLStringParser.test(data);
+  },
+  async parse(asset, data, loader) {
+    const bitmapFontData = bitmapFontTextParser.test(asset) ? bitmapFontTextParser.parse(asset) : bitmapFontXMLStringParser.parse(asset);
+    const { src } = data;
+    const { pages } = bitmapFontData;
+    const textureUrls = [];
+    const textureOptions = bitmapFontData.distanceField ? {
+      scaleMode: "linear",
+      alphaMode: "premultiply-alpha-on-upload",
+      autoGenerateMipmaps: false,
+      resolution: 1
+    } : {};
+    for (let i = 0; i < pages.length; ++i) {
+      const pageFile = pages[i].file;
+      let imagePath = path.join(path.dirname(src), pageFile);
+      imagePath = copySearchParams(imagePath, src);
+      textureUrls.push({
+        src: imagePath,
+        data: textureOptions
+      });
+    }
+    const loadedTextures = await loader.load(textureUrls);
+    const textures = textureUrls.map((url) => loadedTextures[url.src]);
+    const bitmapFont = new BitmapFont({
+      data: bitmapFontData,
+      textures
+    }, src);
+    return bitmapFont;
+  },
+  async load(url, _options) {
+    const response = await DOMAdapter.get().fetch(url);
+    return await response.text();
+  },
+  async unload(bitmapFont, _resolvedAsset, loader) {
+    await Promise.all(bitmapFont.pages.map((page) => loader.unload(page.texture.source._sourceOrigin)));
+    bitmapFont.destroy();
+  }
+};
+
+export { bitmapFontCachePlugin, loadBitmapFont };
+//# sourceMappingURL=loadBitmapFont.mjs.map