gum-jsx 1.6.2 → 1.6.4

package/src/lib/utils.ts

@@ -2,7 +2,7 @@
 
 import { DEFAULTS as D, d2r, r2d } from './const'
 import { setSeed, random, uniform, normal, integer } from './rng'
-import type { Point, Rect, Limit, RGBA, MNumber, MPoint, Orient, Side, Side0, Angle, Direc, Size, Pair, Grad, Polar, Attrs } from './types'
+import type { Point, Rect, Limit, RGBA, MNumber, MPoint, Orient, Side, Side0, Direc, Size, Pair, Grad, Complex, Vector, Attrs } from './types'
 
 //
 // environment tests
@@ -72,6 +72,10 @@ function ensure_vector<T>(x: T | T[], n: number): T[] {
     }
 }
 
+function ensure_pair<T>(x: T | [T, T]): [T, T] {
+    return is_array(x) ? x : [ x, x ]
+}
+
 function ensure_singleton<T>(x: T[] | undefined): T | undefined {
     if (x == null) return undefined
     return is_array(x) ? x[0] : x
@@ -433,34 +437,102 @@ function invert(x: number | undefined): number | undefined {
 // pair arithmetic
 //
 
-function broadcast_point(p: number | Point): Point {
-    return is_scalar(p) ? [ p, p ] as Point : p
-}
-
 function add2(p0: number | Pair, p1: number | Pair): Pair {
-    const [ x0, y0 ] = broadcast_point(p0)
-    const [ x1, y1 ] = broadcast_point(p1)
+    const [ x0, y0 ] = ensure_pair(p0)
+    const [ x1, y1 ] = ensure_pair(p1)
     return [ x0 + x1, y0 + y1 ]
 }
 
 function sub2(p0: number | Pair, p1: number | Pair): Pair {
-    const [ x0, y0 ] = broadcast_point(p0)
-    const [ x1, y1 ] = broadcast_point(p1)
+    const [ x0, y0 ] = ensure_pair(p0)
+    const [ x1, y1 ] = ensure_pair(p1)
     return [ x0 - x1, y0 - y1 ]
 }
 
 function mul2(p0: number | Pair, p1: number | Pair): Pair {
-    const [ x0, y0 ] = broadcast_point(p0)
-    const [ x1, y1 ] = broadcast_point(p1)
+    const [ x0, y0 ] = ensure_pair(p0)
+    const [ x1, y1 ] = ensure_pair(p1)
     return [ x0 * x1, y0 * y1 ]
 }
 
 function div2(p0: number | Pair, p1: number | Pair): Pair {
-    const [ x0, y0 ] = broadcast_point(p0)
-    const [ x1, y1 ] = broadcast_point(p1)
+    const [ x0, y0 ] = ensure_pair(p0)
+    const [ x1, y1 ] = ensure_pair(p1)
     return [ x0 / x1, y0 / y1 ]
 }
 
+//
+// vector arithmetic
+//
+
+function broadcast_op(op: (x: number, y: number) => number, v0: Vector, v1: Vector): Vector {
+    return zip(v0, v1).map(([ x0, x1 ]) => op(x0, x1))
+}
+
+function addn(v0: Vector, v1: Vector): Vector {
+    return broadcast_op((x, y) => x + y, v0, v1)
+}
+
+function subn(v0: Vector, v1: Vector): Vector {
+    return broadcast_op((x, y) => x - y, v0, v1)
+}
+
+function muln(v0: Vector, v1: Vector): Vector {
+    return broadcast_op((x, y) => x * y, v0, v1)
+}
+
+function divn(v0: Vector, v1: Vector): Vector {
+    return broadcast_op((x, y) => x / y, v0, v1)
+}
+
+//
+// complex arithmetic
+//
+
+function ensure_complex(z: number | Complex): Complex {
+    return is_scalar(z) ? [ z, 0 ] as Complex : z
+}
+
+function addc(z: number | Complex, w: number | Complex): Complex {
+    const [ x, y ] = ensure_complex(z)
+    const [ u, v ] = ensure_complex(w)
+    return [ x + u, y + v ]
+}
+
+function subc(z: number | Complex, w: number | Complex): Complex {
+    const [ x, y ] = ensure_complex(z)
+    const [ u, v ] = ensure_complex(w)
+    return [ x - u, y - v ]
+}
+
+function mulc(z: number | Complex, w: number | Complex): Complex {
+    const [ x, y ] = ensure_complex(z)
+    const [ u, v ] = ensure_complex(w)
+    return [ x * u - y * v, x * v + y * u ]
+}
+
+function divc(z: number | Complex, w: number | Complex): Complex {
+    const [ x, y ] = ensure_complex(z)
+    const [ u, v ] = ensure_complex(w)
+    const denom = norm([ u, v ], 2)
+    return [ (x * u + y * v) / denom, (y * u - x * v) / denom ]
+}
+
+function conjc(z: number | Complex): Complex {
+    const [ x, y ] = ensure_complex(z)
+    return [ x, -y ]
+}
+
+function normc(z: number | Complex): number {
+    const [ x, y ] = ensure_complex(z)
+    return norm([ x, y ], 2)
+}
+
+function argc(z: number | Complex): number {
+    const [ x, y ] = ensure_complex(z)
+    return atan2(y, x)
+}
+
 //
 // metaposition arithmetic
 //
@@ -567,7 +639,7 @@ function rect_radial(rect: Rect, absolute: boolean = false): Rect {
 // TODO: add optimized path for Point/number case
 function radial_rect(p0: Point | MPoint, r0: number | Size): Rect {
     const p = ensure_mpoint(p0)
-    const r = broadcast_point(r0)
+    const r = ensure_pair(r0)
     const pa = sub2m(p, r)
     const pb = add2m(p, r)
     return [ ...squeeze_mpoint(pa), ...squeeze_mpoint(pb) ]
@@ -675,21 +747,21 @@ type LimitArgs = {
     [key in Orient]?: Limit
 }
 
-function join_limits({ v, h }: LimitArgs = {}): Rect {
+function join_limits({ h, v }: LimitArgs = {}): Rect {
     const [ vlo, vhi ] = v ?? D.lim
     const [ hlo, hhi ] = h ?? D.lim
     return [ hlo, vlo, hhi, vhi ]
 }
 
-function split_limits(coord: Rect | undefined): { xlim?: Limit, ylim?: Limit } {
+function split_limits(coord: Rect | undefined): { h?: Limit, v?: Limit } {
     if (coord == null) return {}
     const [ xlo, ylo, xhi, yhi ] = coord
-    return { xlim: [ xlo, xhi ], ylim: [ ylo, yhi ] }
+    return { h: [ xlo, xhi ], v: [ ylo, yhi ] }
 }
 
-function resolve_limits(xlim: Limit | undefined, ylim: Limit | undefined, coord: Rect | undefined): { xlim: Limit, ylim: Limit } {
-    const { xlim: xlim0, ylim: ylim0 } = split_limits(coord)
-    return { xlim: xlim ?? xlim0!, ylim: ylim ?? ylim0! }
+function resolve_limits(xlim: Limit | undefined, ylim: Limit | undefined, coord: Rect | undefined): { h: Limit | undefined, v: Limit | undefined } {
+    const { h: xlim0, v: ylim0 } = split_limits(coord)
+    return { h: xlim ?? xlim0, v: ylim ?? ylim0 }
 }
 
 function detect_coords(xvals: number[], yvals: number[], xlim: Limit | undefined, ylim: Limit | undefined): Rect {
@@ -795,15 +867,23 @@ function vector_angle(vector: Point): number {
     return r2d * Math.atan2(y, x)
 }
 
-function angle_direc(angle: Angle): Point {
-    return [ cos(d2r * angle), sin(d2r * angle) ]
+function radian_direc(angle: number): Point {
+    return [ cos(angle), sin(angle) ]
+}
+
+function angle_direc(angle: number): Point {
+    return radian_direc(d2r * angle)
 }
 
-function polar(angle: number, radius: number | Size = 1, center?: Point): Point {
-    const offset = mul2(radius, angle_direc(angle))
+function polar(theta: number, radius: number | Size = 1, center?: Point): Point {
+    const offset = mul2(radius, radian_direc(theta))
     return center ? add2(center, offset) : offset
 }
 
+function polard(angle: number, radius: number | Size = 1, center?: Point): Point {
+    return polar(d2r * angle, radius, center)
+}
+
 function norm_side(side: Side): Side0 {
     if (side == 'top' || side == 't' || side == 'north' || side == 'n') return 't'
     if (side == 'bottom' || side == 'b' || side == 'south' || side == 's') return 'b'
@@ -905,4 +985,4 @@ function binary_search(arr: number[], t: number): number {
 // export
 //
 
-export { is_browser, is_boolean, is_scalar, is_string, is_number, is_object, is_function, is_array, is_singleton, is_point, ensure_vector, ensure_singleton, ensure_function, check_singleton, check_array, check_string, gzip, zip, reshape, split, concat, squeeze, slice, intersperse, sum, prod, mean, all, any, cumsum, norm, normalize, range, linspace, enumerate, repeat, padvec, meshgrid, lingrid, map_object, filter_object, compress_whitespace, exp, log, log10, sin, cos, tan, cot, abs, pow, sqrt, sign, floor, ceil, round, atan, atan2, isNan, isInf, minimum, maximum, heaviside, heavisign, abs_min, abs_max, min, max, clamp, rescale, sigmoid, logit, smoothstep, identity, invert, setSeed, random, uniform, normal, integer, broadcast_point, add2, sub2, mul2, div2, ensure_number, ensure_point, ensure_mnumber, ensure_mpoint, addm, subm, add2m, sub2m, make_mpoint, squeeze_mnumber, squeeze_mpoint, rect_size, rect_dims, rect_center, rect_radius, rect_aspect, rect_radial, norm_angle, split_limits, vector_angle, angle_direc, polar, side_direc, unit_direc, norm_side, rgba_repr, interp, palette, detect_coords, resolve_limits, join_limits, invert_orient, aspect_invariant, flip_rect, radial_rect, box_rect, rect_box, cbox_rect, rect_cbox, merge_rects, merge_points, merge_limits, merge_values, expand_limits, expand_rect, upright_rect, upright_limits, rounder, remap_rect, resizer, rescaler, rotate_aspect, prefix_split, prefix_join, binary_search }
+export { is_browser, is_boolean, is_scalar, is_string, is_number, is_object, is_function, is_array, is_singleton, is_point, ensure_vector, ensure_pair, ensure_singleton, ensure_function, check_singleton, check_array, check_string, gzip, zip, reshape, split, concat, squeeze, slice, intersperse, sum, prod, mean, all, any, cumsum, norm, normalize, range, linspace, enumerate, repeat, padvec, meshgrid, lingrid, map_object, filter_object, compress_whitespace, exp, log, log10, sin, cos, tan, cot, abs, pow, sqrt, sign, floor, ceil, round, atan, atan2, isNan, isInf, minimum, maximum, heaviside, heavisign, abs_min, abs_max, min, max, clamp, rescale, sigmoid, logit, smoothstep, identity, invert, setSeed, random, uniform, normal, integer, add2, sub2, mul2, div2, addn, subn, muln, divn, addc, subc, mulc, divc, conjc, normc, argc, ensure_number, ensure_point, ensure_mnumber, ensure_mpoint, addm, subm, add2m, sub2m, make_mpoint, squeeze_mnumber, squeeze_mpoint, rect_size, rect_dims, rect_center, rect_radius, rect_aspect, rect_radial, norm_angle, split_limits, vector_angle, angle_direc, polar, polard, side_direc, unit_direc, norm_side, rgba_repr, interp, palette, detect_coords, resolve_limits, join_limits, invert_orient, aspect_invariant, flip_rect, radial_rect, box_rect, rect_box, cbox_rect, rect_cbox, merge_rects, merge_points, merge_limits, merge_values, expand_limits, expand_rect, upright_rect, upright_limits, rounder, remap_rect, resizer, rescaler, rotate_aspect, prefix_split, prefix_join, binary_search }

package/src/render.ts

@@ -5,6 +5,8 @@ import { createCanvas, loadImage, registerFont, type ImageData as CanvasImageDat
 import type { Size } from './lib/types'
 import { FONT_PATHS } from './fonts/fonts'
 import { light, regular, bold } from './lib/const'
+import { is_string } from './lib/utils'
+import { fitSize } from './eval'
 
 // register bundled fonts so SVG <text> resolves consistently
 for (const [ family, path ] of Object.entries(FONT_PATHS)) {
@@ -19,8 +21,7 @@ for (const [ family, path ] of Object.entries(FONT_PATHS)) {
 
 interface RasterizeBaseArgs {
   size?: Size
-  width?: number
-  height?: number
+  rasterSize?: Size
   background?: string
 }
 
@@ -45,32 +46,11 @@ interface FormatImageArgs {
 
 async function rasterizeSvg(svg: string | Buffer, args: RasterizePixelArgs): Promise<CanvasImageData>
 async function rasterizeSvg(svg: string | Buffer, args?: RasterizePngArgs): Promise<Buffer>
-async function rasterizeSvg(svg: string | Buffer, { size, width, height, background, pixelData }: RasterizeArgs = {}): Promise<Buffer | CanvasImageData> {
-  const buf = typeof svg === 'string' ? Buffer.from(svg) : svg
+async function rasterizeSvg(svg: string | Buffer, { size, rasterSize, background, pixelData }: RasterizeArgs = {}): Promise<Buffer | CanvasImageData> {
+  const buf = is_string(svg) ? Buffer.from(svg) : svg
   const img = await loadImage(buf)
-  const w0 = size?.[0] ?? img.width
-  const h0 = size?.[1] ?? img.height
-
-  // if both width and height given, scale to fit within (prefer smaller scale)
-  if (width != null && height != null) {
-    const scaleW = width / w0
-    const scaleH = height / h0
-    if (scaleW < scaleH) height = undefined
-    else width = undefined
-  }
-
-  // pick output dimensions; preserve aspect when only one of width/height given
-  let outW: number, outH: number
-  if (width != null) {
-    outW = width
-    outH = Math.round(width * h0 / w0)
-  } else if (height != null) {
-    outH = height
-    outW = Math.round(height * w0 / h0)
-  } else {
-    outW = w0
-    outH = h0
-  }
+  const imgSize = size ?? [ img.width, img.height ]
+  const [ outW, outH ] = fitSize(imgSize, rasterSize)
 
   // create canvas
   const canvas = createCanvas(outW, outH)

package/src/types/katex.d.ts

@@ -53,6 +53,13 @@ declare module 'katex' {
         body: TreeNode[]
     }
 
+    export type TreeFont = {
+        type: 'font'
+        mode: SymbolMode
+        font: string
+        body: TreeNode
+    }
+
     export type TreeSupSub = {
         type: 'supsub'
         base: TreeNode | null
@@ -115,6 +122,7 @@ declare module 'katex' {
         | TreeOp
         | TreeKern
         | TreeText
+        | TreeFont
         | TreeStyling
         | TreeAccent
         | TreeSupSub