@genome-spy/core 0.36.1 → 0.37.0

package/dist/src/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright (c) 2010-2014 by tyPoland Lukasz Dziedzic (team@latofonts.com) with Reserved Font Name "Lato"
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/dist/src/fonts/README.md

@@ -0,0 +1,3 @@
+# SDF fonts
+
+The json metadata and SDFs were taken from https://github.com/etiennepinchon/aframe-fonts

package/dist/src/fonts/bmFontManager.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Loader for A-Frame fonts.
+ *
+ * See:
+ * https://github.com/mattdesl/bmfont2json
+ * https://github.com/etiennepinchon/aframe-fonts
+ *
+ *
+ * @typedef {import("../types/bmFont").BMFont} BMFont
+ * @typedef {import("./bmFontMetrics").BMFontMetrics} BMFontMetrics
+ *
+ * @typedef {"normal" | "italic"} FontStyle
+ * @typedef {number} FontWeight
+ *
+ * @typedef {object} FontKey
+ * @prop {string} family
+ * @prop {FontStyle} style
+ * @prop {FontWeight} weight
+ *
+ * @typedef {object} FontEntry
+ * @prop {BMFontMetrics} metrics
+ * @prop {WebGLTexture} texture
+ */
+export default class BmFontManager {
+    /**
+     * @param {import("../gl/webGLHelper").default} [webGLHelper]
+     */
+    constructor(webGLHelper?: import("../gl/webGLHelper").default);
+    _webGLHelper: import("../gl/webGLHelper").default;
+    fontRepository: string;
+    /**
+     * @type {Map<FontKey, FontEntry>}
+     */
+    _fonts: Map<FontKey, FontEntry>;
+    /** @type {Map<string, Promise<GoogleFontMetadataEntry[]>>} */
+    _metadataPromises: Map<string, Promise<GoogleFontMetadataEntry[]>>;
+    /** @type {Map<string, Promise<BMFontMetrics>>} */
+    _fontPromises: Map<string, Promise<BMFontMetrics>>;
+    /** @type {Promise<void>[]} Keep track of overall font loading state */
+    _promises: Promise<void>[];
+    /**
+     * A default/fallback font to be used when font loading fails
+     * @type {FontEntry}
+     */
+    _defaultFontEntry: FontEntry;
+    waitUntilReady(): Promise<void>;
+    /**
+     *
+     * @param {string} family For example: "Lato"
+     * @param {FontStyle} style
+     * @param {FontWeight | keyof WEIGHTS} weight
+     * @returns {FontEntry}
+     */
+    getFont(family: string, style?: FontStyle, weight?: FontWeight | keyof {
+        thin: number;
+        light: number;
+        regular: number;
+        normal: number;
+        medium: number;
+        bold: number;
+        black: number;
+    }): FontEntry;
+    /**
+     *
+     * @param {FontEntry} fontEntry An uninitialized font entry
+     * @param {FontKey} key
+     */
+    _loadFontEntry(fontEntry: FontEntry, key: FontKey): Promise<void>;
+    /**
+     * @param {string} url
+     */
+    _loadFont(url: string): Promise<import("./bmFontMetrics").BMFontMetrics>;
+    /**
+     *
+     * @param {string} family
+     */
+    _loadMetadata(family: string): Promise<GoogleFontMetadataEntry[]>;
+    getDefaultFont(): FontEntry;
+    /**
+     *
+     * @param {string} bitmapUrl
+     * @returns {Promise<WebGLTexture>}
+     */
+    _createTexture(bitmapUrl: string): Promise<WebGLTexture>;
+    /**
+     *
+     * @param {string} bitmapUrl
+     * @returns {WebGLTexture}
+     */
+    _createTextureNow(bitmapUrl: string): WebGLTexture;
+}
+/**
+ * A super-naive method for parsing METADATA.pb.
+ * It's a text-format protobuf message, but I couldn't find a lightweight parser
+ * for it.
+ */
+export type GoogleFontMetadataEntry = {
+    /**
+     * "Open Sans"
+     */
+    name: string;
+    /**
+     * "italic"
+     */
+    style: string;
+    /**
+     * 400
+     */
+    weight: number;
+    /**
+     * "OpenSans-Italic.ttf"
+     */
+    filename: string;
+    /**
+     * "OpenSans-Italic"
+     */
+    post_script_name: string;
+    /**
+     * "Open Sans Italic"
+     */
+    full_name: string;
+    /**
+     * "Digitized data copyright  2010-2011, Google Corporation."
+     */
+    copyright: string;
+};
+/**
+ * Loader for A-Frame fonts.
+ *
+ * See:
+ * https://github.com/mattdesl/bmfont2json
+ * https://github.com/etiennepinchon/aframe-fonts
+ */
+export type BMFont = import("../types/bmFont").BMFont;
+/**
+ * Loader for A-Frame fonts.
+ *
+ * See:
+ * https://github.com/mattdesl/bmfont2json
+ * https://github.com/etiennepinchon/aframe-fonts
+ */
+export type BMFontMetrics = import("./bmFontMetrics").BMFontMetrics;
+/**
+ * Loader for A-Frame fonts.
+ *
+ * See:
+ * https://github.com/mattdesl/bmfont2json
+ * https://github.com/etiennepinchon/aframe-fonts
+ */
+export type FontStyle = "normal" | "italic";
+/**
+ * Loader for A-Frame fonts.
+ *
+ * See:
+ * https://github.com/mattdesl/bmfont2json
+ * https://github.com/etiennepinchon/aframe-fonts
+ */
+export type FontWeight = number;
+/**
+ * Loader for A-Frame fonts.
+ *
+ * See:
+ * https://github.com/mattdesl/bmfont2json
+ * https://github.com/etiennepinchon/aframe-fonts
+ */
+export type FontKey = {
+    family: string;
+    style: FontStyle;
+    weight: FontWeight;
+};
+/**
+ * Loader for A-Frame fonts.
+ *
+ * See:
+ * https://github.com/mattdesl/bmfont2json
+ * https://github.com/etiennepinchon/aframe-fonts
+ */
+export type FontEntry = {
+    metrics: BMFontMetrics;
+    texture: WebGLTexture;
+};
+//# sourceMappingURL=bmFontManager.d.ts.map

package/dist/src/fonts/bmFontManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bmFontManager.d.ts","sourceRoot":"","sources":["../../../src/fonts/bmFontManager.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IACI;;OAEG;IACH,0BAFW,OAAO,mBAAmB,EAAE,OAAO,EAgC7C;IA7BG,kDAA+B;IAE/B,uBACiF;IAEjF;;OAEG;IACH,QAFU,IAAI,OAAO,EAAE,SAAS,CAAC,CAEc;IAE/C,8DAA8D;IAC9D,mBADW,IAAI,MAAM,EAAE,QAAQ,uBAAuB,EAAE,CAAC,CAAC,CACxB;IAElC,kDAAkD;IAClD,eADW,IAAI,MAAM,EAAE,QAAQ,aAAa,CAAC,CAAC,CAChB;IAE9B,uEAAuE;IACvE,WADW,QAAQ,IAAI,CAAC,EAAE,CACP;IAEnB;;;OAGG;IACH,mBAFU,SAAS,CAOlB;IAGL,gCAEC;IAED;;;;;;OAMG;IACH,gBALW,MAAM,UACN,SAAS,WACT,UAAU,GAAG;;;;;;;;KAAa,GACxB,SAAS,CAyBrB;IAED;;;;OAIG;IACH,0BAHW,SAAS,OACT,OAAO,iBAwBjB;IAED;;OAEG;IACH,eAFW,MAAM,oDAoBhB;IAED;;;OAGG;IACH,sBAFW,MAAM,sCA2BhB;IAED,4BAEC;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,QAAQ,YAAY,CAAC,CAqBjC;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,YAAY,CA0BxB;CACJ;;;;;;;;;;UAgBS,MAAM;;;;WACN,MAAM;;;;YACN,MAAM;;;;cACN,MAAM;;;;sBACN,MAAM;;;;eACN,MAAM;;;;eACN,MAAM;;;;;;;;;qBA5PH,OAAO,iBAAiB,EAAE,MAAM;;;;;;;;4BAChC,OAAO,iBAAiB,EAAE,aAAa;;;;;;;;wBAEvC,QAAQ,GAAG,QAAQ;;;;;;;;yBACnB,MAAM;;;;;;;;;YAGT,MAAM;WACN,SAAS;YACT,UAAU;;;;;;;;;;aAGV,aAAa;aACb,YAAY"}

package/dist/src/fonts/bmFontManager.js

@@ -0,0 +1,359 @@
+import { InternMap } from "internmap";
+import { createTexture } from "twgl.js";
+import { isString } from "vega-util";
+import latoRegular from "../fonts/Lato-Regular.json";
+import latoRegularBitmap from "../fonts/Lato-Regular.png";
+import getMetrics from "./bmFontMetrics";
+
+const WEIGHTS = {
+    thin: 100,
+    light: 300,
+    regular: 400,
+    normal: 400,
+    medium: 500,
+    bold: 700,
+    black: 900,
+};
+
+/**
+ * Loader for A-Frame fonts.
+ *
+ * See:
+ * https://github.com/mattdesl/bmfont2json
+ * https://github.com/etiennepinchon/aframe-fonts
+ *
+ *
+ * @typedef {import("../types/bmFont").BMFont} BMFont
+ * @typedef {import("./bmFontMetrics").BMFontMetrics} BMFontMetrics
+ *
+ * @typedef {"normal" | "italic"} FontStyle
+ * @typedef {number} FontWeight
+ *
+ * @typedef {object} FontKey
+ * @prop {string} family
+ * @prop {FontStyle} style
+ * @prop {FontWeight} weight
+ *
+ * @typedef {object} FontEntry
+ * @prop {BMFontMetrics} metrics
+ * @prop {WebGLTexture} texture
+ */
+export default class BmFontManager {
+    /**
+     * @param {import("../gl/webGLHelper").default} [webGLHelper]
+     */
+    constructor(webGLHelper) {
+        this._webGLHelper = webGLHelper;
+
+        this.fontRepository =
+            "https://raw.githubusercontent.com/etiennepinchon/aframe-fonts/master/fonts/";
+
+        /**
+         * @type {Map<FontKey, FontEntry>}
+         */
+        this._fonts = new InternMap([], JSON.stringify);
+
+        /** @type {Map<string, Promise<GoogleFontMetadataEntry[]>>} */
+        this._metadataPromises = new Map();
+
+        /** @type {Map<string, Promise<BMFontMetrics>>} */
+        this._fontPromises = new Map();
+
+        /** @type {Promise<void>[]} Keep track of overall font loading state */
+        this._promises = [];
+
+        /**
+         * A default/fallback font to be used when font loading fails
+         * @type {FontEntry}
+         */
+        this._defaultFontEntry = {
+            metrics: getMetrics(latoRegular),
+            texture: webGLHelper
+                ? this._createTextureNow(latoRegularBitmap)
+                : undefined,
+        };
+    }
+
+    async waitUntilReady() {
+        await Promise.all(this._promises);
+    }
+
+    /**
+     *
+     * @param {string} family For example: "Lato"
+     * @param {FontStyle} style
+     * @param {FontWeight | keyof WEIGHTS} weight
+     * @returns {FontEntry}
+     */
+    getFont(family, style = "normal", weight = "regular") {
+        if (isString(weight)) {
+            weight =
+                WEIGHTS[/** @type {keyof WEIGHTS} */ (weight.toLowerCase())];
+            if (!weight) {
+                throw new Error("Unknown font weight: " + weight);
+            }
+        }
+
+        const key = { family, style, weight };
+        let fontEntry = this._fonts.get(key);
+        if (!fontEntry) {
+            // Return and empty entry, load it asynchronously
+            fontEntry = {
+                metrics: undefined,
+                texture: undefined,
+            };
+            this._fonts.set(key, fontEntry);
+
+            this._promises.push(this._loadFontEntry(fontEntry, key));
+        }
+
+        return fontEntry;
+    }
+
+    /**
+     *
+     * @param {FontEntry} fontEntry An uninitialized font entry
+     * @param {FontKey} key
+     */
+    async _loadFontEntry(fontEntry, key) {
+        try {
+            const metadataEntries = await this._loadMetadata(key.family);
+            const filename = findFilename(metadataEntries, key);
+
+            const urlBase =
+                this.fontRepository +
+                simplifyFamily(key.family) +
+                "/" +
+                filename.replace(/\.\w+/, "");
+
+            const texturePromise = this._createTexture(urlBase + ".png");
+            const metricsPromise = this._loadFont(urlBase + ".json");
+
+            fontEntry.texture = await texturePromise;
+            fontEntry.metrics = await metricsPromise;
+        } catch (error) {
+            console.log("Cannot load font. Using default.", error);
+
+            fontEntry.metrics = this._defaultFontEntry.metrics;
+            fontEntry.texture = this._defaultFontEntry.texture;
+        }
+    }
+
+    /**
+     * @param {string} url
+     */
+    _loadFont(url) {
+        let promise = this._fontPromises.get(url);
+        if (!promise) {
+            promise = fetch(url)
+                .then((response) => {
+                    if (!response.ok) {
+                        throw new Error(
+                            "Could not load font: " + response.status
+                        );
+                    }
+                    return response;
+                })
+                .then((response) => response.json())
+                .then((json) => getMetrics(/** @type {BMFont} */ (json)));
+
+            this._fontPromises.set(url, promise);
+        }
+        return promise;
+    }
+
+    /**
+     *
+     * @param {string} family
+     */
+    _loadMetadata(family) {
+        const dir = simplifyFamily(family);
+
+        let promise = this._metadataPromises.get(dir);
+        if (!promise) {
+            promise = fetch(this.fontRepository + dir + "/METADATA.pb")
+                .then((response) => {
+                    if (!response.ok) {
+                        throw new Error(
+                            "Could not load font metadata: " + response.status
+                        );
+                    }
+                    return response;
+                })
+                .then((response) => response.text())
+                .then((text) => parseMetadataPb(text))
+                .catch((error) => {
+                    console.warn(error);
+                    return undefined;
+                });
+
+            this._metadataPromises.set(dir, promise);
+        }
+
+        return promise;
+    }
+
+    getDefaultFont() {
+        return this._defaultFontEntry;
+    }
+
+    /**
+     *
+     * @param {string} bitmapUrl
+     * @returns {Promise<WebGLTexture>}
+     */
+    _createTexture(bitmapUrl) {
+        const gl = this._webGLHelper.gl;
+
+        return new Promise((resolve, reject) => {
+            createTexture(
+                gl,
+                {
+                    src: bitmapUrl,
+                    min: gl.LINEAR,
+                },
+                (err, texture, source) => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        resolve(texture);
+                    }
+                }
+            );
+        });
+    }
+
+    /**
+     *
+     * @param {string} bitmapUrl
+     * @returns {WebGLTexture}
+     */
+    _createTextureNow(bitmapUrl) {
+        const gl = this._webGLHelper.gl;
+
+        /** @type {WebGLTexture} */
+        let texture;
+        const promise = new Promise((resolve, reject) => {
+            texture = createTexture(
+                gl,
+                {
+                    src: bitmapUrl,
+                    min: gl.LINEAR,
+                },
+                (err, texture, source) => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        resolve(texture);
+                    }
+                }
+            );
+        });
+
+        this._promises.push(promise);
+        return texture;
+    }
+}
+
+/**
+ *
+ * @param {string} family
+ */
+function simplifyFamily(family) {
+    return family.toLowerCase().replaceAll(/[^\w]/g, "");
+}
+
+/**
+ * A super-naive method for parsing METADATA.pb.
+ * It's a text-format protobuf message, but I couldn't find a lightweight parser
+ * for it.
+ *
+ * @typedef {object} GoogleFontMetadataEntry
+ * @prop {string} name "Open Sans"
+ * @prop {string} style "italic"
+ * @prop {number} weight 400
+ * @prop {string} filename "OpenSans-Italic.ttf"
+ * @prop {string} post_script_name "OpenSans-Italic"
+ * @prop {string} full_name "Open Sans Italic"
+ * @prop {string} copyright "Digitized data copyright  2010-2011, Google Corporation."
+ *
+ * @param {string} metadata
+ * @returns {GoogleFontMetadataEntry[]}
+ */
+function parseMetadataPb(metadata) {
+    const lines = metadata.split("\n");
+
+    /** @type {GoogleFontMetadataEntry[]} */
+    const entries = [];
+
+    /** @type {GoogleFontMetadataEntry} */
+    let entry;
+
+    for (const line of lines) {
+        if (line.startsWith("fonts {")) {
+            /** @type {GoogleFontMetadataEntry} */
+            entry = {
+                name: undefined,
+                style: undefined,
+                weight: undefined,
+                filename: undefined,
+                post_script_name: undefined,
+                full_name: undefined,
+                copyright: undefined,
+            };
+        }
+
+        if (line.startsWith("}")) {
+            entries.push(entry);
+            entry = undefined;
+        }
+
+        if (entry) {
+            let m = line.match(/^\s*([A-Za-z_]+):[ ]?"(.*)"$/);
+            if (m) {
+                const key = /** @type {keyof GoogleFontMetadataEntry}*/ (m[1]);
+                // @ts-ignore
+                entry[key] = m[2];
+            }
+
+            m = line.match(/^\s*([A-Za-z_]+):[ ]?(\d+)$/);
+            if (m) {
+                const key = /** @type {keyof GoogleFontMetadataEntry}*/ (m[1]);
+                // @ts-ignore
+                entry[key] = +m[2];
+            }
+        }
+    }
+
+    return entries;
+}
+
+/**
+ * @param {GoogleFontMetadataEntry[]} metadataEntries
+ * @param {FontKey} key
+ */
+function findFilename(metadataEntries, key) {
+    /** @type {GoogleFontMetadataEntry}  */
+    let closest;
+    let closestDistance = Number.POSITIVE_INFINITY;
+
+    for (const e of metadataEntries) {
+        if (
+            key.family.localeCompare(e.name, undefined, {
+                sensitivity: "accent",
+            }) != 0
+        ) {
+            continue;
+        }
+
+        if (key.style == e.style) {
+            const distance = Math.abs(key.weight - e.weight);
+            if (distance < closestDistance) {
+                closestDistance = distance;
+                closest = e;
+            }
+        }
+    }
+
+    return closest?.filename;
+}

package/dist/src/fonts/bmFontMetrics.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Metrics calculation for msdf bmfonts:
+ *
+ * https://github.com/mattdesl/bmfont2json
+ * https://github.com/etiennepinchon/aframe-fonts
+ *
+ * @typedef {import("../types/bmFont").Char} Char
+ *
+ * @typedef {object} BMFontMetrics
+ * @prop {(text: string, fontSize?: number) => number} measureWidth
+ * @prop {(charCode: number) => Char} getCharByCode
+ * @prop {(char: string) => Char} getChar
+ * @prop {number} xHeight
+ * @prop {number} capHeight
+ * @prop {number} descent
+ * @prop {import("../types/bmFont").Common} common
+ *
+ * @param {import("../types/bmFont").BMFont} bmFont
+ * @returns {BMFontMetrics}
+ */
+export default function getMetrics(bmFont: import("../types/bmFont").BMFont): BMFontMetrics;
+export const SDF_PADDING: 5;
+/**
+ * Metrics calculation for msdf bmfonts:
+ *
+ * https://github.com/mattdesl/bmfont2json
+ * https://github.com/etiennepinchon/aframe-fonts
+ */
+export type Char = import("../types/bmFont").Char;
+/**
+ * Metrics calculation for msdf bmfonts:
+ *
+ * https://github.com/mattdesl/bmfont2json
+ * https://github.com/etiennepinchon/aframe-fonts
+ */
+export type BMFontMetrics = {
+    measureWidth: (text: string, fontSize?: number) => number;
+    getCharByCode: (charCode: number) => Char;
+    getChar: (char: string) => Char;
+    xHeight: number;
+    capHeight: number;
+    descent: number;
+    common: import("../types/bmFont").Common;
+};
+//# sourceMappingURL=bmFontMetrics.d.ts.map

package/dist/src/fonts/bmFontMetrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bmFontMetrics.d.ts","sourceRoot":"","sources":["../../../src/fonts/bmFontMetrics.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,2CAHW,OAAO,iBAAiB,EAAE,MAAM,GAC9B,aAAa,CAqFzB;AA3GD,4BAA6B;;;;;;;mBAUhB,OAAO,iBAAiB,EAAE,IAAI;;;;;;;;yBAG1B,MAAM,aAAa,MAAM,KAAK,MAAM;8BAChC,MAAM,KAAK,IAAI;oBACnB,MAAM,KAAK,IAAI;aACtB,MAAM;eACN,MAAM;aACN,MAAM;YACN,OAAO,iBAAiB,EAAE,MAAM"}