@mapbox/mapbox-gl-style-spec 14.4.0 → 14.5.0

package/{validate_style.min.js → validate_style.min.ts}

@@ -1,27 +1,26 @@
-// @flow
-import latestStyleSpec from './reference/latest.js';
+import latestStyleSpec from './reference/latest';
 
-import _validateStyle from './validate/validate_style.js';
-import _validateSource from './validate/validate_source.js';
-import _validateLight from './validate/validate_light.js';
-import _validateLights from './validate/validate_lights.js';
-import _validateTerrain from './validate/validate_terrain.js';
-import _validateFog from './validate/validate_fog.js';
-import _validateLayer from './validate/validate_layer.js';
-import _validateFilter from './validate/validate_filter.js';
-import _validatePaintProperty from './validate/validate_paint_property.js';
-import _validateLayoutProperty from './validate/validate_layout_property.js';
-import _validateModel from './validate/validate_model.js';
+import _validateStyle from './validate/validate_style';
+import _validateSource from './validate/validate_source';
+import _validateLight from './validate/validate_light';
+import _validateLights from './validate/validate_lights';
+import _validateTerrain from './validate/validate_terrain';
+import _validateFog from './validate/validate_fog';
+import _validateLayer from './validate/validate_layer';
+import _validateFilter from './validate/validate_filter';
+import _validatePaintProperty from './validate/validate_paint_property';
+import _validateLayoutProperty from './validate/validate_layout_property';
+import _validateModel from './validate/validate_model';
 
-import type {StyleSpecification} from './types.js';
+import type {StyleSpecification} from './types';
 
-export type ValidationError = interface {
-    message: string,
-    identifier?: ?string,
-    line?: ?number,
+export type ValidationError = {
+    message: string;
+    identifier?: string | null | undefined;
+    line?: number | null | undefined;
 };
-export type ValidationErrors = $ReadOnlyArray<ValidationError>;
-export type Validator = (Object) => ValidationErrors;
+export type ValidationErrors = ReadonlyArray<ValidationError>;
+export type Validator = (arg1: any) => ValidationErrors;
 
 /**
  * Validate a Mapbox GL style against the style specification. This entrypoint,
@@ -38,7 +37,7 @@ export type Validator = (Object) => ValidationErrors;
  *   var validate = require('mapbox-gl-style-spec/lib/validate_style.min');
  *   var errors = validate(style);
  */
-export function validateStyle(style: StyleSpecification, styleSpec: Object = latestStyleSpec): ValidationErrors {
+export function validateStyle(style: StyleSpecification, styleSpec: any = latestStyleSpec): ValidationErrors {
     const errors = _validateStyle(style, styleSpec);
     return sortErrors(errors);
 }

package/{validate_style.js → validate_style.ts}

@@ -1,10 +1,9 @@
-// @flow
-import {validateStyle as validateStyleMin} from './validate_style.min.js';
-import {v8} from './style-spec.js';
-import readStyle from './read_style.js';
+import {validateStyle as validateStyleMin} from './validate_style.min';
+import {v8} from './style-spec';
+import readStyle from './read_style';
 
-import type {ValidationErrors} from './validate_style.min.js';
-import type {StyleSpecification} from './types.js';
+import type {ValidationErrors} from './validate_style.min';
+import type {StyleSpecification} from './types';
 
 /**
  * Validate a Mapbox GL style against the style specification.
@@ -22,15 +21,16 @@ import type {StyleSpecification} from './types.js';
  *   var errors = validate(style);
  */
 
-export default function validateStyle(style: StyleSpecification | string | Buffer, styleSpec: Object = v8): ValidationErrors {
+export default function validateStyle(style: StyleSpecification | string | Buffer, styleSpec: any = v8): ValidationErrors {
     let s = style;
 
     try {
         s = readStyle(s);
-    } catch (e) {
+    } catch (e: any) {
         return [e];
     }
 
+    // @ts-expect-error - TS2345 - Argument of type 'string | StyleSpecification | Buffer' is not assignable to parameter of type 'StyleSpecification'.
     return validateStyleMin(s, styleSpec);
 }
 
@@ -45,4 +45,4 @@ export {
     validateFog as fog,
     validatePaintProperty as paintProperty,
     validateLayoutProperty as layoutProperty
-} from './validate_style.min.js';
+} from './validate_style.min';

package/{visit.js → visit.ts}

@@ -1,28 +1,26 @@
-// @flow
-
 import Reference from './reference/v8.json';
-import type {StylePropertySpecification} from './style-spec.js';
+import type {StylePropertySpecification} from './style-spec';
 import type {
     StyleSpecification,
     SourceSpecification,
     LayerSpecification,
     PropertyValueSpecification,
     DataDrivenPropertyValueSpecification
-} from './types.js';
+} from './types';
 
 function getPropertyReference(propertyName: string): StylePropertySpecification {
     for (let i = 0; i < Reference.layout.length; i++) {
         for (const key in Reference[Reference.layout[i]]) {
-            if (key === propertyName) return (Reference[Reference.layout[i]][key]: any);
+            if (key === propertyName) return Reference[Reference.layout[i]][key];
         }
     }
     for (let i = 0; i < Reference.paint.length; i++) {
         for (const key in Reference[Reference.paint[i]]) {
-            if (key === propertyName) return (Reference[Reference.paint[i]][key]: any);
+            if (key === propertyName) return Reference[Reference.paint[i]][key];
         }
     }
 
-    return (null: any);
+    return null as any;
 }
 
 export function eachSource(style: StyleSpecification, callback: (_: SourceSpecification) => void) {
@@ -37,22 +35,29 @@ export function eachLayer(style: StyleSpecification, callback: (_: LayerSpecific
     }
 }
 
-type PropertyCallback = ({
-    path: [string, 'paint' | 'layout', string], // [layerid, paint/layout, property key]
-    key: string,
-    value: PropertyValueSpecification<mixed> | DataDrivenPropertyValueSpecification<mixed>,
-    reference: StylePropertySpecification,
-    set: (PropertyValueSpecification<mixed> | DataDrivenPropertyValueSpecification<mixed>) => void
-}) => void;
+type PropertyCallback = (
+    arg1: {
+        path: [string, 'paint' | 'layout', string] // [layerid, paint/layout, property key];
+        key: string;
+        value: PropertyValueSpecification<unknown>  ;
+        reference: StylePropertySpecification;
+        set: (
+            arg1: PropertyValueSpecification<unknown>,
+        ) => void;
+    },
+) => void;
 
 export function eachProperty(
     style: StyleSpecification,
-    options: {paint?: boolean, layout?: boolean},
+    options: {
+        paint?: boolean;
+        layout?: boolean;
+    },
     callback: PropertyCallback
 ) {
     function inner(layer: LayerSpecification, propertyType: 'paint' | 'layout') {
-        if (layer.type === 'slot') return;
-        const properties = (layer[propertyType]: any);
+        if (layer.type === 'slot' || layer.type === 'clip') return;
+        const properties = (layer[propertyType] as any);
         if (!properties) return;
         Object.keys(properties).forEach((key) => {
             callback({

package/.eslintrc

@@ -1,10 +0,0 @@
-{
-  "overrides": [
-    {
-      "files": ["rollup.config.js", "test.js"],
-      "rules": {
-        "flowtype/require-valid-file-annotation": "off"
-      }
-    }
-  ]
-}

package/expression/expression.js

@@ -1,28 +0,0 @@
-// @flow
-
-import type {Type} from './types.js';
-import type {Class} from '../../types/class.js';
-import type ParsingContext from './parsing_context.js';
-import type EvaluationContext from './evaluation_context.js';
-
-export type SerializedExpression = Array<mixed> | Array<string> | string | number | boolean | null;
-
-export interface Expression {
-    +type: Type;
-
-    evaluate(ctx: EvaluationContext): any;
-
-    eachChild(fn: Expression => void): void;
-
-    /**
-     * Statically analyze the expression, attempting to enumerate possible outputs. Returns
-     * false if the complete set of outputs is statically undecidable, otherwise true.
-     */
-    outputDefined(): boolean;
-
-    serialize(): SerializedExpression;
-}
-
-export type ExpressionParser = (args: $ReadOnlyArray<mixed>, context: ParsingContext) => ?Expression;
-export type ExpressionRegistration = Class<Expression> & { +parse: ExpressionParser };
-export type ExpressionRegistry = {[_: string]: ExpressionRegistration};

package/flow-typed/cheap-ruler.js

@@ -1,25 +0,0 @@
-// @flow strict
-
-declare module 'cheap-ruler' {
-    import type { GeoJSONPosition} from '@mapbox/geojson-types';
-    declare export default class CheapRuler {
-        kx: number;
-        ky: number;
-        constructor(lat: number, units: string): CheapRuler;
-        distance(a: GeoJSONPosition, b: GeoJSONPosition): number;
-        bearing(a: GeoJSONPosition, b: GeoJSONPosition): number;
-        destination(p: GeoJSONPosition, dist: number , bearing: number): GeoJSONPosition;
-        offset(p: GeoJSONPosition, dx: number, dy: number): GeoJSONPosition;
-        lineDistance(points: Array<GeoJSONPosition>): number;
-        area(polygon: Array<Array<GeoJSONPosition>>): number;
-        along(line: Array<GeoJSONPosition>, dist: number): GeoJSONPosition;
-        pointToSegmentDistance(p: GeoJSONPosition, a: GeoJSONPosition, b: GeoJSONPosition): number;
-        pointOnLine(line: Array<GeoJSONPosition>, p: GeoJSONPosition): Object;
-        lineSlice(start: GeoJSONPosition, stop: GeoJSONPosition, line: Array<GeoJSONPosition>): Array<GeoJSONPosition>;
-        lineSliceAlong(start: GeoJSONPosition, stop: GeoJSONPosition, line: Array<GeoJSONPosition>): Array<GeoJSONPosition>;
-        bufferPoint(p: GeoJSONPosition, buffer: number): GeoJSONPosition;
-        bufferBBox(bbox: GeoJSONPosition, buffer: number): GeoJSONPosition;
-        insideBBox(p: GeoJSONPosition, bbox: GeoJSONPosition): boolean;
-
-    }
-}

package/flow-typed/geojson.js

@@ -1,44 +0,0 @@
-// @flow strict
-
-type Geometry<T, C> = { type: T, coordinates: C }
-
-declare module "@mapbox/geojson-types" {
-    declare export type GeoJSONPosition = [number, number] | [number, number, number];
-
-    declare export type GeoJSONPoint = Geometry<'Point', GeoJSONPosition>;
-    declare export type GeoJSONMultiPoint = Geometry<'MultiPoint', Array<GeoJSONPosition>>;
-
-    declare export type GeoJSONLineString = Geometry<'LineString', Array<GeoJSONPosition>>;
-    declare export type GeoJSONMultiLineString = Geometry<'MultiLineString', Array<Array<GeoJSONPosition>>>;
-
-    declare export type GeoJSONPolygon = Geometry<'Polygon', Array<Array<GeoJSONPosition>>>;
-    declare export type GeoJSONMultiPolygon = Geometry<'MultiPolygon', Array<Array<Array<GeoJSONPosition>>>>;
-
-    declare export type GeoJSONGeometry =
-        | GeoJSONPoint
-        | GeoJSONMultiPoint
-        | GeoJSONLineString
-        | GeoJSONMultiLineString
-        | GeoJSONPolygon
-        | GeoJSONMultiPolygon
-        | GeoJSONGeometryCollection;
-
-    declare export type GeoJSONGeometryCollection = {
-        type: 'GeometryCollection',
-        geometries: Array<GeoJSONGeometry>
-    };
-
-    declare export interface GeoJSONFeature {
-        type: 'Feature';
-        geometry: ?GeoJSONGeometry;
-        properties: ?{};
-        id?: number | string;
-    }
-
-    declare export type GeoJSONFeatureCollection = {
-        type: 'FeatureCollection',
-        features: Array<GeoJSONFeature>
-    };
-
-    declare export type GeoJSON = GeoJSONGeometry | GeoJSONFeature | GeoJSONFeatureCollection;
-}

package/flow-typed/gl-matrix.js

@@ -1,119 +0,0 @@
-// @flow
-type VecType = Array<number> | Float32Array | Float64Array;
-
-declare module "gl-matrix" {
-    declare type Vec2 = VecType;
-    declare type Vec3 = VecType;
-    declare type Vec4 = VecType;
-    declare type Quat = VecType;
-    declare type Mat2 = VecType;
-    declare type Mat3 = VecType;
-    declare type Mat4 = VecType;
-
-    declare var vec2: {
-        exactEquals(Vec2, Vec2): boolean
-    };
-
-    declare var vec3: {
-        create(): Float32Array,
-        fromValues(number, number, number): Float32Array,
-        length(Vec3): number,
-        len(Vec3): number,
-        distance(Vec3, Vec3): number,
-        squaredLength(Vec3): number,
-        dot(Vec3, Vec3): number,
-        equals(Vec3, Vec3): boolean,
-        exactEquals(Vec3, Vec3): boolean,
-        clone<T: Vec3>(T): T,
-        normalize<T: Vec3>(T, Vec3): T,
-        add<T: Vec3>(T, Vec3, Vec3): T,
-        sub<T: Vec3>(T, Vec3, Vec3): T,
-        set<T: Vec3>(T, number, number, number): T,
-        subtract<T: Vec3>(T, Vec3, Vec3): T,
-        cross<T: Vec3>(T, Vec3, Vec3): T,
-        negate<T: Vec3>(T, Vec3): T,
-        scale<T: Vec3>(T, Vec3, number): T,
-        scaleAndAdd<T: Vec3>(T, Vec3, Vec3, number): T,
-        multiply<T: Vec3>(T, Vec3, Vec3): T,
-        mul<T: Vec3>(T, Vec3, Vec3): T,
-        div<T: Vec3>(T, Vec3, Vec3): T,
-        min<T: Vec3>(T, Vec3, Vec3): T,
-        max<T: Vec3>(T, Vec3, Vec3): T,
-        lerp<T: Vec3>(T, Vec3, Vec3, number): T,
-        transformQuat<T: Vec3>(T, Vec3, Quat): T,
-        transformMat3<T: Vec3>(T, Vec3, Mat3): T,
-        transformMat4<T: Vec3>(T, Vec3, Mat4): T,
-        angle(Vec3, Vec3): number;
-        rotateX<T: Vec3>(T, Vec3, Vec3, number): T,
-        rotateY<T: Vec3>(T, Vec3, Vec3, number): T,
-        rotateZ<T: Vec3>(T, Vec3, Vec3, number): T,
-    };
-
-    declare var vec4: {
-        scale<T: Vec4>(T, Vec4, number): T,
-        mul<T: Vec4>(T, Vec4, Vec4): T,
-        transformMat4<T: Vec4>(T, Vec4, Mat4): T,
-        normalize<T: Vec4>(T, Vec4): T,
-        dot(Vec4, Vec4): number,
-        min<T: Vec4>(T, Vec4, Vec4): T,
-        max<T: Vec4>(T, Vec4, Vec4): T,
-    };
-
-    declare var mat2: {
-        create(): Float32Array,
-        rotate<T: Mat2>(T, Mat2, number): T,
-        invert<T: Mat2>(T, Mat2): T,
-        scale<T: Mat2>(T, Mat2, Vec2): T
-    };
-
-    declare var mat3: {
-        create(): Float32Array,
-
-        fromMat4<T: Mat3>(T, Mat4): T,
-        fromRotation<T: Mat3>(T, number): T,
-        mul<T: Mat3>(T, Mat3, Mat3): T,
-        multiply<T: Mat3>(T, Mat3, Mat3): T,
-        adjoint<T: Mat3>(T, Mat3): T,
-        invert<T: Mat3>(T, Mat3): T,
-        transpose<T: Mat3>(T, Mat3): T
-    };
-
-    declare var mat4: {
-        create(): Float32Array,
-
-        fromScaling<T: Mat4>(T, Vec3): T,
-        fromTranslation<T: Mat4>(T, Vec3): T,
-        fromQuat<T: Mat4>(T, Quat): T,
-        fromRotationTranslationScale<T: Mat4>(T, Quat, Vec3, Vec3): T,
-        ortho<T: Mat4>(T, number, number, number, number, number, number): T,
-        perspective<T: Mat4>(T, number, number, number, number): T,
-        identity<T: Mat4>(T): T,
-        scale<T: Mat4>(T, Mat4, Vec3): T,
-        mul<T: Mat4>(T, Mat4, Mat4): T,
-        multiply<T: Mat4>(T, Mat4, Mat4): T,
-        rotateX<T: Mat4>(T, Mat4, number): T,
-        rotateY<T: Mat4>(T, Mat4, number): T,
-        rotateZ<T: Mat4>(T, Mat4, number): T,
-        rotate<T: Mat4>(T, Mat4, number, Vec3): T,
-        fromRotation<T: Mat4>(T, number, Vec3): T,
-        translate<T: Mat4>(T, Mat4, Vec3): T,
-        invert<T: Mat4>(T, Mat4): T,
-        transpose<T: Mat4>(T, Mat4): T,
-        copy<T: Mat4>(T, Mat4): T,
-        clone<T: Mat4>(T): T
-    };
-
-    declare var quat: {
-        create(): Float32Array,
-        length(Quat): number,
-        exactEquals(Quat, Quat): boolean,
-
-        normalize<T: Quat>(T, Quat): T,
-        conjugate<T: Quat>(T, Quat): T,
-        identity<T: Quat>(T): T,
-        rotateX<T: Quat>(T, Quat, number): T,
-        rotateY<T: Quat>(T, Quat, number): T,
-        rotateZ<T: Quat>(T, Quat, number): T,
-        rotationTo<T:Quat>(T, Quat, Quat): T
-    }
-}

package/flow-typed/gl.js

@@ -1,5 +0,0 @@
-// @flow strict
-declare module "gl" {
-    declare function gl(width: number, height: number, attributes: WebGLContextAttributes): WebGL2RenderingContext;
-    declare module.exports: typeof gl;
-}

package/flow-typed/intl.js

@@ -1,58 +0,0 @@
-// @flow strict
-
-// Flow type declarations for Intl cribbed from
-// https://github.com/facebook/flow/issues/1270
-
-declare var Intl: {
-    NumberFormat: Class<Intl$NumberFormat>;
-    Collator: Class<Intl$Collator>;
-};
-
-declare class Intl$NumberFormat {
-    constructor (
-        locales?: string | string[],
-        options?: NumberFormatOptions
-    ): Intl$NumberFormat;
-
-    static (
-        locales?: string | string[],
-        options?: NumberFormatOptions
-    ): Intl$NumberFormat;
-
-    format(a: number): string;
-
-    resolvedOptions(): any;
-}
-
-type NumberFormatOptions = {
-    style?: 'decimal' | 'currency' | 'percent' | 'unit';
-    currency?: null | string;
-    unit?: null | string;
-    minimumFractionDigits?: null | string;
-    maximumFractionDigits?: null | string;
-};
-
-declare class Intl$Collator {
-    constructor (
-        locales?: string | string[],
-        options?: CollatorOptions
-    ): Intl$Collator;
-
-    static (
-        locales?: string | string[],
-        options?: CollatorOptions
-    ): Intl$Collator;
-
-    compare (a: string, b: string): number;
-
-    resolvedOptions(): any;
-}
-
-type CollatorOptions = {
-    localeMatcher?: 'lookup' | 'best fit',
-    usage?: 'sort' | 'search',
-    sensitivity?: 'base' | 'accent' | 'case' | 'variant',
-    ignorePunctuation?: boolean,
-    numeric?: boolean,
-    caseFirst?: 'upper' | 'lower' | 'false'
-}

package/flow-typed/kdbush.js

@@ -1,9 +0,0 @@
-// @flow strict
-declare module 'kdbush' {
-    declare export default class KDBush {
-        constructor(numPoints: number, nodeSize?: number, arrayType?: Class<$ArrayBufferView>): KDBush;
-        add(x: number, y: number): number;
-        finish(): void;
-        range(minX: number, minY: number, maxX: number, maxY: number): Array<number>;
-    }
-}

package/flow-typed/mapbox-gl-supported.js

@@ -1,16 +0,0 @@
-// @flow
-'use strict';
-declare module "@mapbox/mapbox-gl-supported" {
-    declare type SupportedOptions = {failIfMajorPerformanceCaveat: boolean};
-
-    declare type SupportedFn = {
-        (options?: SupportedOptions): boolean,
-        webGLContextAttributes: WebGLContextAttributes
-    };
-    declare function notSupportedReason(options?: SupportedOptions): ?string;
-
-    declare module.exports: {
-        supported: SupportedFn;
-        notSupportedReason: typeof notSupportedReason;
-    }
-}

package/flow-typed/mapbox-unitbezier.js

@@ -1,14 +0,0 @@
-'use strict';
-// @flow
-
-declare module "@mapbox/unitbezier" {
-    declare class UnitBezier {
-        constructor(p1x: number, p1y: number, p2x: number, p2y: number): UnitBezier;
-        sampleCurveX(t: number): number;
-        sampleCurveY(t: number): number;
-        sampleCurveDerivativeX(t: number): number;
-        solveCurveX(x: number, epsilon: number | void): number;
-        solve(x: number, epsilon: number | void): number;
-    }
-    declare module.exports: typeof UnitBezier;
-}

package/flow-typed/offscreen-canvas.js

@@ -1,9 +0,0 @@
-// @flow strict
-
-declare class OffscreenCanvas {
-    width: number;
-    height: number;
-
-    constructor(width: number, height: number): OffscreenCanvas;
-    getContext(contextType: '2d'): CanvasRenderingContext2D;
-}

package/flow-typed/pbf.js

@@ -1,26 +0,0 @@
-// @flow
-declare module "pbf" {
-    declare type ReadFunction<T> = (tag: number, result: T, pbf: Pbf) => void;
-
-    declare class Pbf {
-        constructor(buf?: ArrayBuffer | Uint8Array): Pbf;
-
-        readFields<T>(readField: ReadFunction<T>, result: T, end?: number): T;
-        readMessage<T>(readField: ReadFunction<T>, result: T): T;
-
-        readFixed32(): number;
-        readSFixed32(): number;
-        readFixed64(): number;
-        readSFixed64(): number;
-        readFloat(): number;
-        readDouble(): number;
-        readVarint(): number;
-        readVarint64(): number;
-        readSVarint(): number;
-        readBoolean(): boolean;
-        readString(): string;
-        readBytes(): Uint8Array;
-    }
-
-    declare export default Class<Pbf>;
-}

package/flow-typed/point-geometry.js

@@ -1,46 +0,0 @@
-// @flow strict
-declare module "@mapbox/point-geometry" {
-    declare export type PointLike = Point | [number, number];
-
-    declare class Point {
-        x: number;
-        y: number;
-        constructor(x: number, y: number): Point;
-        clone(): Point;
-        add(point: Point): Point;
-        sub(point: Point): Point;
-        multByPoint(point: Point): Point;
-        divByPoint(point: Point): Point;
-        mult(k: number): Point;
-        div(k: number): Point;
-        rotate(angle: number): Point;
-        rotateAround(angle: number, point: Point): Point;
-        matMult(matrix: [number, number, number, number]): Point;
-        unit(): Point;
-        perp(): Point;
-        round(): Point;
-        mag(): number;
-        equals(point: Point): boolean;
-        dist(point: Point): number;
-        distSqr(point: Point): number;
-        angle(): number;
-        angleTo(point: Point): number;
-        angleWith(point: Point): number;
-        angleWithSep(x: number, y: number): number;
-        _matMult(matrix: [number, number, number, number]): Point;
-        _add(point: Point): Point;
-        _sub(point: Point): Point;
-        _mult(k: number): Point;
-        _div(k: number): Point;
-        _multByPoint(point: Point): Point;
-        _divByPoint(point: Point): Point;
-        _unit(): Point;
-        _perp(): Point;
-        _rotate(angle: number): Point;
-        _rotateAround(angle: number, point: Point): Point;
-        _round(): Point;
-        static convert(a: PointLike): Point;
-    }
-
-    declare export default Class<Point>;
-}

package/flow-typed/potpack.js

@@ -1,13 +0,0 @@
-// @flow
-declare module "potpack" {
-    declare type Bin = {
-        x: number,
-        y: number,
-        w: number,
-        h: number
-    };
-
-    declare function potpack(bins: Array<Bin>): {w: number, h: number, fill: number};
-
-    declare module.exports: typeof potpack;
-}

package/flow-typed/tiny-sdf.js

@@ -1,31 +0,0 @@
-
-declare module '@mapbox/tiny-sdf' {
-    declare type TinySDFOptions = {
-        fontSize?: number;
-        buffer?: number;
-        radius?: number;
-        cutoff?: number;
-        fontFamily?: string;
-        fontWeight?: string;
-        fontStyle?: string;
-    };
-
-    declare type TinySDFGlyph = {
-        data: Uint8ClampedArray;
-        width: number;
-        height: number;
-        glyphWidth: number;
-        glyphHeight: number;
-        glyphTop: number;
-        glyphLeft: number;
-        glyphAdvance: number;
-    };
-
-    declare class TinySDF {
-        fontWeight: string;
-        constructor(options: TinySDFOptions): TinySDF;
-        draw(char: string): TinySDFGlyph;
-    }
-
-    declare export default Class<TinySDF>;
-}