samcan 0.0.2 → 0.1.0

package/dist/stroke/index.d.cts

@@ -0,0 +1,143 @@
+type vector2 = [number, number];
+type rectangle = [number, number, number, number];
+type color = [number, number, number, number];
+type spline_segment = {
+	a: number;
+	b: number;
+	c: number;
+	d: number;
+	x_start: number;
+	x_end: number;
+};
+type spline = {
+	segments_x: spline_segment[];
+	segments_y: spline_segment[];
+	point_count: number;
+};
+type circle = [number, number, number];
+type transform = [number, number, number, number, number, number];
+declare const path_move = 0;
+declare const path_line = 1;
+declare const path_cubic = 2;
+declare const path_close = 3;
+type path_command_move = [typeof path_move, number, number];
+type path_command_line = [typeof path_line, number, number];
+type path_command_cubic = [typeof path_cubic, number, number, number, number, number, number];
+type path_command_close = [typeof path_close];
+type path_command = path_command_move | path_command_line | path_command_cubic | path_command_close;
+type path = {
+	readonly commands: readonly path_command[];
+	readonly bounds: rectangle;
+};
+type stroke_style = {
+	color: color;
+	width: number;
+	opacity: number;
+	pressure_sensitivity: number;
+};
+type stroke_point = {
+	position: vector2;
+	pressure: number;
+	timestamp: number;
+};
+type live_stroke = {
+	id: string;
+	points: stroke_point[];
+	style: stroke_style;
+	stabilizer_state: stabilizer_state;
+};
+type stroke = {
+	id: string;
+	bounds: rectangle;
+	z_index: number;
+	layer_id: string;
+	points: vector2[];
+	pressure: number[] | null;
+	style: stroke_style;
+	simplified_points: vector2[];
+	spline: spline | null;
+	path_cache: path_command[] | null;
+};
+type stabilizer_state = {
+	history: vector2[];
+	smoothing_factor: number;
+};
+declare const default_stroke_style: stroke_style;
+declare function create_stroke_style(color: color, width: number, opacity?: number, pressure_sensitivity?: number): stroke_style;
+declare function clone_stroke_style(s: stroke_style): stroke_style;
+declare const default_smoothing_factor = .3;
+declare const default_stabilizer_history_size = 5;
+declare function create_stabilizer(smoothing_factor?: number): stabilizer_state;
+declare function stabilize_point(state: stabilizer_state, raw: vector2, out: vector2): vector2;
+declare function reset_stabilizer(state: stabilizer_state): void;
+declare function get_stabilized_history(state: stabilizer_state): readonly vector2[];
+type draw_style = {
+	readonly fill: color | null;
+	readonly stroke: color | null;
+	readonly stroke_width: number;
+	readonly line_cap: number;
+	readonly line_join: number;
+	readonly miter_limit: number;
+	readonly alpha: number;
+};
+type image_source = HTMLImageElement | HTMLCanvasElement | ImageBitmap;
+type renderer = {
+	readonly kind: number;
+	readonly width: number;
+	readonly height: number;
+	readonly pixel_ratio: number;
+	begin_frame: () => void;
+	end_frame: () => void;
+	set_transform: (t: transform) => void;
+	reset_transform: () => void;
+	save: () => void;
+	restore: () => void;
+	draw_path: (p: path, s: draw_style) => void;
+	draw_rectangle: (r: rectangle, s: draw_style) => void;
+	draw_circle: (c: circle, s: draw_style) => void;
+	draw_line: (a: vector2, b: vector2, s: draw_style) => void;
+	draw_polyline: (points: readonly vector2[], s: draw_style) => void;
+	draw_image: (image: image_source, r: rectangle, opacity: number, version?: number) => void;
+	clip_rectangle: (r: rectangle) => void;
+	clear: (c: color) => void;
+	resize: (width: number, height: number, pixel_ratio: number) => void;
+	dispose: () => void;
+};
+declare function generate_stroke_id(): string;
+declare function create_live_stroke(style: stroke_style, id?: string): live_stroke;
+declare function add_point_live_stroke(live: live_stroke, position: vector2, pressure?: number, timestamp?: number): live_stroke;
+declare function add_raw_point_live_stroke(live: live_stroke, raw_position: vector2, pressure?: number, timestamp?: number): live_stroke;
+declare function get_points_from_live_stroke(live: live_stroke): vector2[];
+declare function get_pressure_from_live_stroke(live: live_stroke): number[] | null;
+declare function render_live_stroke(live: live_stroke, renderer: renderer): void;
+declare function finalize_live_stroke(live: live_stroke, z_index: number, layer_id: string): {
+	points: vector2[];
+	pressure: number[] | null;
+	style: stroke_style;
+	id: string;
+	z_index: number;
+	layer_id: string;
+};
+declare const default_simplify_epsilon = 1;
+declare const default_lod_simplify_factor = 3;
+declare function simplify_stroke_points(points: vector2[], epsilon: number | undefined, out: vector2[]): number;
+declare function simplify_stroke_points_auto(points: vector2[], out: vector2[]): number;
+declare function fit_spline_to_stroke(points: vector2[], out_spline: spline): spline;
+declare function compute_stroke_bounds(points: vector2[], width: number, out: rectangle): rectangle;
+declare function process_stroke(points: vector2[], pressure: number[] | null, style: stroke_style, out_simplified: vector2[], out_spline: spline): {
+	simplified: vector2[];
+	spline: spline;
+};
+declare function get_simplified_for_lod(points: vector2[], lod_level: number, out: vector2[]): vector2[];
+declare const lod_high = 1;
+declare const lod_medium = .5;
+declare const lod_low = .25;
+declare const spline_evaluation_interval_high = 2;
+declare const spline_evaluation_interval_medium = 4;
+declare const spline_evaluation_interval_low = 8;
+declare function select_lod_from_zoom(zoom: number): number;
+declare function get_spline_evaluation_interval(lod: number): number;
+declare function stroke_to_path_commands(stroke: stroke, lod: number, out_commands: number[]): number;
+declare function render_stroke(stroke: stroke, renderer: renderer, zoom?: number): void;
+declare function render_stroke_with_pressure(stroke: stroke, renderer: renderer, _zoom?: number): void;
+export { stroke_to_path_commands, stroke_style, stroke_point, stroke, stabilizer_state, stabilize_point, spline_evaluation_interval_medium, spline_evaluation_interval_low, spline_evaluation_interval_high, simplify_stroke_points_auto, simplify_stroke_points, select_lod_from_zoom, reset_stabilizer, render_stroke_with_pressure, render_stroke, render_live_stroke, process_stroke, lod_medium, lod_low, lod_high, live_stroke, get_stabilized_history, get_spline_evaluation_interval, get_simplified_for_lod, get_pressure_from_live_stroke, get_points_from_live_stroke, generate_stroke_id, fit_spline_to_stroke, finalize_live_stroke, default_stroke_style, default_stabilizer_history_size, default_smoothing_factor, default_simplify_epsilon, default_lod_simplify_factor, create_stroke_style, create_stabilizer, create_live_stroke, compute_stroke_bounds, clone_stroke_style, add_raw_point_live_stroke, add_point_live_stroke };

package/dist/stroke/index.d.ts

@@ -0,0 +1,143 @@
+type vector2 = [number, number];
+type rectangle = [number, number, number, number];
+type color = [number, number, number, number];
+type spline_segment = {
+	a: number;
+	b: number;
+	c: number;
+	d: number;
+	x_start: number;
+	x_end: number;
+};
+type spline = {
+	segments_x: spline_segment[];
+	segments_y: spline_segment[];
+	point_count: number;
+};
+type circle = [number, number, number];
+type transform = [number, number, number, number, number, number];
+declare const path_move = 0;
+declare const path_line = 1;
+declare const path_cubic = 2;
+declare const path_close = 3;
+type path_command_move = [typeof path_move, number, number];
+type path_command_line = [typeof path_line, number, number];
+type path_command_cubic = [typeof path_cubic, number, number, number, number, number, number];
+type path_command_close = [typeof path_close];
+type path_command = path_command_move | path_command_line | path_command_cubic | path_command_close;
+type path = {
+	readonly commands: readonly path_command[];
+	readonly bounds: rectangle;
+};
+type stroke_style = {
+	color: color;
+	width: number;
+	opacity: number;
+	pressure_sensitivity: number;
+};
+type stroke_point = {
+	position: vector2;
+	pressure: number;
+	timestamp: number;
+};
+type live_stroke = {
+	id: string;
+	points: stroke_point[];
+	style: stroke_style;
+	stabilizer_state: stabilizer_state;
+};
+type stroke = {
+	id: string;
+	bounds: rectangle;
+	z_index: number;
+	layer_id: string;
+	points: vector2[];
+	pressure: number[] | null;
+	style: stroke_style;
+	simplified_points: vector2[];
+	spline: spline | null;
+	path_cache: path_command[] | null;
+};
+type stabilizer_state = {
+	history: vector2[];
+	smoothing_factor: number;
+};
+declare const default_stroke_style: stroke_style;
+declare function create_stroke_style(color: color, width: number, opacity?: number, pressure_sensitivity?: number): stroke_style;
+declare function clone_stroke_style(s: stroke_style): stroke_style;
+declare const default_smoothing_factor = .3;
+declare const default_stabilizer_history_size = 5;
+declare function create_stabilizer(smoothing_factor?: number): stabilizer_state;
+declare function stabilize_point(state: stabilizer_state, raw: vector2, out: vector2): vector2;
+declare function reset_stabilizer(state: stabilizer_state): void;
+declare function get_stabilized_history(state: stabilizer_state): readonly vector2[];
+type draw_style = {
+	readonly fill: color | null;
+	readonly stroke: color | null;
+	readonly stroke_width: number;
+	readonly line_cap: number;
+	readonly line_join: number;
+	readonly miter_limit: number;
+	readonly alpha: number;
+};
+type image_source = HTMLImageElement | HTMLCanvasElement | ImageBitmap;
+type renderer = {
+	readonly kind: number;
+	readonly width: number;
+	readonly height: number;
+	readonly pixel_ratio: number;
+	begin_frame: () => void;
+	end_frame: () => void;
+	set_transform: (t: transform) => void;
+	reset_transform: () => void;
+	save: () => void;
+	restore: () => void;
+	draw_path: (p: path, s: draw_style) => void;
+	draw_rectangle: (r: rectangle, s: draw_style) => void;
+	draw_circle: (c: circle, s: draw_style) => void;
+	draw_line: (a: vector2, b: vector2, s: draw_style) => void;
+	draw_polyline: (points: readonly vector2[], s: draw_style) => void;
+	draw_image: (image: image_source, r: rectangle, opacity: number, version?: number) => void;
+	clip_rectangle: (r: rectangle) => void;
+	clear: (c: color) => void;
+	resize: (width: number, height: number, pixel_ratio: number) => void;
+	dispose: () => void;
+};
+declare function generate_stroke_id(): string;
+declare function create_live_stroke(style: stroke_style, id?: string): live_stroke;
+declare function add_point_live_stroke(live: live_stroke, position: vector2, pressure?: number, timestamp?: number): live_stroke;
+declare function add_raw_point_live_stroke(live: live_stroke, raw_position: vector2, pressure?: number, timestamp?: number): live_stroke;
+declare function get_points_from_live_stroke(live: live_stroke): vector2[];
+declare function get_pressure_from_live_stroke(live: live_stroke): number[] | null;
+declare function render_live_stroke(live: live_stroke, renderer: renderer): void;
+declare function finalize_live_stroke(live: live_stroke, z_index: number, layer_id: string): {
+	points: vector2[];
+	pressure: number[] | null;
+	style: stroke_style;
+	id: string;
+	z_index: number;
+	layer_id: string;
+};
+declare const default_simplify_epsilon = 1;
+declare const default_lod_simplify_factor = 3;
+declare function simplify_stroke_points(points: vector2[], epsilon: number | undefined, out: vector2[]): number;
+declare function simplify_stroke_points_auto(points: vector2[], out: vector2[]): number;
+declare function fit_spline_to_stroke(points: vector2[], out_spline: spline): spline;
+declare function compute_stroke_bounds(points: vector2[], width: number, out: rectangle): rectangle;
+declare function process_stroke(points: vector2[], pressure: number[] | null, style: stroke_style, out_simplified: vector2[], out_spline: spline): {
+	simplified: vector2[];
+	spline: spline;
+};
+declare function get_simplified_for_lod(points: vector2[], lod_level: number, out: vector2[]): vector2[];
+declare const lod_high = 1;
+declare const lod_medium = .5;
+declare const lod_low = .25;
+declare const spline_evaluation_interval_high = 2;
+declare const spline_evaluation_interval_medium = 4;
+declare const spline_evaluation_interval_low = 8;
+declare function select_lod_from_zoom(zoom: number): number;
+declare function get_spline_evaluation_interval(lod: number): number;
+declare function stroke_to_path_commands(stroke: stroke, lod: number, out_commands: number[]): number;
+declare function render_stroke(stroke: stroke, renderer: renderer, zoom?: number): void;
+declare function render_stroke_with_pressure(stroke: stroke, renderer: renderer, _zoom?: number): void;
+export { stroke_to_path_commands, stroke_style, stroke_point, stroke, stabilizer_state, stabilize_point, spline_evaluation_interval_medium, spline_evaluation_interval_low, spline_evaluation_interval_high, simplify_stroke_points_auto, simplify_stroke_points, select_lod_from_zoom, reset_stabilizer, render_stroke_with_pressure, render_stroke, render_live_stroke, process_stroke, lod_medium, lod_low, lod_high, live_stroke, get_stabilized_history, get_spline_evaluation_interval, get_simplified_for_lod, get_pressure_from_live_stroke, get_points_from_live_stroke, generate_stroke_id, fit_spline_to_stroke, finalize_live_stroke, default_stroke_style, default_stabilizer_history_size, default_smoothing_factor, default_simplify_epsilon, default_lod_simplify_factor, create_stroke_style, create_stabilizer, create_live_stroke, compute_stroke_bounds, clone_stroke_style, add_raw_point_live_stroke, add_point_live_stroke };

package/dist/stroke/index.js

@@ -0,0 +1,343 @@
+import {
+  compute_stroke_bounds,
+  default_lod_simplify_factor,
+  default_simplify_epsilon,
+  fit_spline_to_stroke,
+  get_simplified_for_lod,
+  process_stroke,
+  simplify_stroke_points,
+  simplify_stroke_points_auto
+} from "../shared/chunk-87399bz7.js";
+import {
+  evaluate_spline_at_t,
+  get_spline_length
+} from "../shared/chunk-rzxyjwk8.js";
+import {
+  line_cap_round,
+  line_join_round
+} from "../shared/chunk-wa3772hp.js";
+import"../shared/chunk-v53jprrn.js";
+
+// stroke/stroke.ts
+var default_stroke_style = {
+  color: [0, 0, 0, 1],
+  width: 3,
+  opacity: 1,
+  pressure_sensitivity: 0.5
+};
+function create_stroke_style(color, width, opacity = 1, pressure_sensitivity = 0.5) {
+  return {
+    color: [color[0], color[1], color[2], color[3]],
+    width,
+    opacity,
+    pressure_sensitivity
+  };
+}
+function clone_stroke_style(s) {
+  return {
+    color: [s.color[0], s.color[1], s.color[2], s.color[3]],
+    width: s.width,
+    opacity: s.opacity,
+    pressure_sensitivity: s.pressure_sensitivity
+  };
+}
+// stroke/stabilizer.ts
+var default_smoothing_factor = 0.3;
+var default_stabilizer_history_size = 5;
+function create_stabilizer(smoothing_factor = default_smoothing_factor) {
+  return {
+    history: [],
+    smoothing_factor
+  };
+}
+function stabilize_point(state, raw, out) {
+  if (state.history.length === 0) {
+    out[0] = raw[0];
+    out[1] = raw[1];
+  } else {
+    const last = state.history[state.history.length - 1];
+    out[0] = last[0] + state.smoothing_factor * (raw[0] - last[0]);
+    out[1] = last[1] + state.smoothing_factor * (raw[1] - last[1]);
+  }
+  state.history.push([out[0], out[1]]);
+  if (state.history.length > default_stabilizer_history_size) {
+    state.history.shift();
+  }
+  return out;
+}
+function reset_stabilizer(state) {
+  state.history = [];
+}
+function get_stabilized_history(state) {
+  return state.history;
+}
+// stroke/live.ts
+var live_stroke_counter = 0;
+function generate_stroke_id() {
+  live_stroke_counter = live_stroke_counter + 1;
+  return `stroke_${Date.now()}_${live_stroke_counter}`;
+}
+function create_live_stroke(style, id) {
+  return {
+    id: id ?? generate_stroke_id(),
+    points: [],
+    style: clone_stroke_style(style),
+    stabilizer_state: create_stabilizer()
+  };
+}
+function add_point_live_stroke(live, position, pressure = 0.5, timestamp = Date.now()) {
+  const next_stabilizer_state = {
+    ...live.stabilizer_state,
+    history: live.stabilizer_state.history.map((p) => [p[0], p[1]])
+  };
+  const stabilized = [0, 0];
+  stabilize_point(next_stabilizer_state, position, stabilized);
+  return add_point_to_live_stroke_internal(live, stabilized, pressure, timestamp, next_stabilizer_state);
+}
+function add_raw_point_live_stroke(live, raw_position, pressure = 0.5, timestamp = Date.now()) {
+  return add_point_to_live_stroke_internal(live, raw_position, pressure, timestamp);
+}
+function add_point_to_live_stroke_internal(live, position, pressure, timestamp, next_stabilizer_state) {
+  const point = {
+    position: [position[0], position[1]],
+    pressure,
+    timestamp
+  };
+  return {
+    ...live,
+    points: [...live.points, point],
+    stabilizer_state: next_stabilizer_state ?? {
+      ...live.stabilizer_state,
+      history: live.stabilizer_state.history.map((p) => [p[0], p[1]])
+    }
+  };
+}
+function get_points_from_live_stroke(live) {
+  return live.points.map((p) => p.position);
+}
+function get_pressure_from_live_stroke(live) {
+  if (live.points.length === 0)
+    return null;
+  return live.points.map((p) => p.pressure);
+}
+function render_live_stroke(live, renderer) {
+  if (live.points.length < 2) {
+    if (live.points.length === 1) {
+      const point = live.points[0];
+      const radius = live.style.width * (0.5 + point.pressure * live.style.pressure_sensitivity * 0.5);
+      renderer.draw_circle([point.position[0], point.position[1], radius], create_live_style(live.style, true));
+    }
+    return;
+  }
+  const points = get_points_from_live_stroke(live);
+  const style = create_live_style(live.style, false);
+  renderer.draw_polyline(points, style);
+}
+function create_live_style(style, is_dot) {
+  return {
+    fill: is_dot ? style.color : null,
+    stroke: style.color,
+    stroke_width: style.width,
+    line_cap: line_cap_round,
+    line_join: line_join_round,
+    miter_limit: 10,
+    alpha: style.opacity
+  };
+}
+function finalize_live_stroke(live, z_index, layer_id) {
+  const points = get_points_from_live_stroke(live);
+  const pressure = get_pressure_from_live_stroke(live);
+  return {
+    id: live.id,
+    points,
+    pressure,
+    style: live.style,
+    z_index,
+    layer_id
+  };
+}
+// stroke/render.ts
+var lod_scratch_buffer = [];
+function ensure_lod_scratch(size) {
+  while (lod_scratch_buffer.length < size) {
+    lod_scratch_buffer.push([0, 0]);
+  }
+  return lod_scratch_buffer;
+}
+var lod_high = 1;
+var lod_medium = 0.5;
+var lod_low = 0.25;
+var spline_evaluation_interval_high = 2;
+var spline_evaluation_interval_medium = 4;
+var spline_evaluation_interval_low = 8;
+function select_lod_from_zoom(zoom) {
+  if (zoom >= 1.5)
+    return lod_high;
+  if (zoom >= 0.5)
+    return lod_medium;
+  return lod_low;
+}
+function get_spline_evaluation_interval(lod) {
+  if (lod >= lod_medium)
+    return spline_evaluation_interval_high;
+  if (lod >= lod_low)
+    return spline_evaluation_interval_medium;
+  return spline_evaluation_interval_low;
+}
+function stroke_to_path_commands(stroke, lod, out_commands) {
+  let command_count = 0;
+  if (stroke.points.length === 0)
+    return 0;
+  if (stroke.points.length === 1) {
+    out_commands[command_count++] = 0;
+    out_commands[command_count++] = stroke.points[0][0];
+    out_commands[command_count++] = stroke.points[0][1];
+    return command_count;
+  }
+  const use_spline = stroke.spline !== null && stroke.spline.point_count >= 2;
+  const use_lod = lod < lod_high;
+  if (use_spline && !use_lod) {
+    const interval = get_spline_evaluation_interval(lod);
+    const spline_length = get_spline_length(stroke.spline);
+    const first_segment = stroke.spline.segments_x[0];
+    const last_segment = stroke.spline.segments_x[stroke.spline.segments_x.length - 1];
+    const t_start = first_segment.x_start;
+    const t_end = last_segment.x_end;
+    const steps = Math.max(2, Math.floor(spline_length / interval));
+    const dt = (t_end - t_start) / steps;
+    const temp_point = [0, 0];
+    for (let i = 0;i <= steps; i++) {
+      const t = t_start + i * dt;
+      evaluate_spline_at_t(stroke.spline, t, temp_point);
+      if (i === 0) {
+        out_commands[command_count++] = 0;
+      } else {
+        out_commands[command_count++] = 1;
+      }
+      out_commands[command_count++] = temp_point[0];
+      out_commands[command_count++] = temp_point[1];
+    }
+  } else {
+    const points_to_use = use_lod ? get_simplified_for_lod(stroke.points, 1 / lod, ensure_lod_scratch(stroke.points.length)) : stroke.points;
+    for (let i = 0;i < points_to_use.length; i++) {
+      const point = points_to_use[i];
+      if (point === undefined)
+        continue;
+      if (i === 0) {
+        out_commands[command_count++] = 0;
+      } else {
+        out_commands[command_count++] = 1;
+      }
+      out_commands[command_count++] = point[0];
+      out_commands[command_count++] = point[1];
+    }
+  }
+  return command_count;
+}
+function render_stroke(stroke, renderer, zoom = 1) {
+  if (stroke.points.length === 0)
+    return;
+  const lod = select_lod_from_zoom(zoom);
+  const style = create_stroke_draw_style(stroke.style);
+  if (stroke.points.length === 1) {
+    const point = stroke.points[0];
+    const radius = stroke.style.width / 2;
+    renderer.draw_circle([point[0], point[1], radius], style);
+    return;
+  }
+  const use_spline = stroke.spline !== null && stroke.spline.point_count >= 2;
+  const use_lod = lod < lod_high;
+  if (use_spline && !use_lod) {
+    const interval = get_spline_evaluation_interval(lod);
+    const spline_length = get_spline_length(stroke.spline);
+    const first_segment = stroke.spline.segments_x[0];
+    const last_segment = stroke.spline.segments_x[stroke.spline.segments_x.length - 1];
+    const t_start = first_segment.x_start;
+    const t_end = last_segment.x_end;
+    const steps = Math.max(2, Math.floor(spline_length / interval));
+    const dt = (t_end - t_start) / steps;
+    const temp_point = [0, 0];
+    const points = ensure_lod_scratch(steps + 1);
+    for (let i = 0;i <= steps; i++) {
+      const t = t_start + i * dt;
+      evaluate_spline_at_t(stroke.spline, t, temp_point);
+      const p = points[i];
+      p[0] = temp_point[0];
+      p[1] = temp_point[1];
+    }
+    renderer.draw_polyline(points.slice(0, steps + 1), style);
+  } else {
+    const points_to_use = use_lod ? get_simplified_for_lod(stroke.points, 1 / lod, ensure_lod_scratch(stroke.points.length)) : stroke.points;
+    renderer.draw_polyline(points_to_use, style);
+  }
+}
+function create_stroke_draw_style(style) {
+  return {
+    fill: null,
+    stroke: style.color,
+    stroke_width: style.width,
+    line_cap: line_cap_round,
+    line_join: line_join_round,
+    miter_limit: 10,
+    alpha: style.opacity
+  };
+}
+function render_stroke_with_pressure(stroke, renderer, _zoom = 1) {
+  if (stroke.points.length < 2 || stroke.pressure === null) {
+    render_stroke(stroke, renderer, _zoom);
+    return;
+  }
+  const points = stroke.points;
+  const pressure = stroke.pressure;
+  const base_style = create_stroke_draw_style(stroke.style);
+  const base_width = stroke.style.width;
+  const sensitivity = stroke.style.pressure_sensitivity;
+  for (let i = 0;i < points.length - 1; i++) {
+    const p1 = points[i];
+    const p2 = points[i + 1];
+    const pr1 = pressure[i] ?? 0.5;
+    const pr2 = pressure[i + 1] ?? pr1;
+    const avg_pressure = (pr1 + pr2) / 2;
+    const width = base_width * (1 + avg_pressure * sensitivity);
+    renderer.draw_line(p1, p2, { ...base_style, stroke_width: width });
+  }
+}
+export {
+  stroke_to_path_commands,
+  stabilize_point,
+  spline_evaluation_interval_medium,
+  spline_evaluation_interval_low,
+  spline_evaluation_interval_high,
+  simplify_stroke_points_auto,
+  simplify_stroke_points,
+  select_lod_from_zoom,
+  reset_stabilizer,
+  render_stroke_with_pressure,
+  render_stroke,
+  render_live_stroke,
+  process_stroke,
+  lod_medium,
+  lod_low,
+  lod_high,
+  get_stabilized_history,
+  get_spline_evaluation_interval,
+  get_simplified_for_lod,
+  get_pressure_from_live_stroke,
+  get_points_from_live_stroke,
+  generate_stroke_id,
+  fit_spline_to_stroke,
+  finalize_live_stroke,
+  default_stroke_style,
+  default_stabilizer_history_size,
+  default_smoothing_factor,
+  default_simplify_epsilon,
+  default_lod_simplify_factor,
+  create_stroke_style,
+  create_stabilizer,
+  create_live_stroke,
+  compute_stroke_bounds,
+  clone_stroke_style,
+  add_raw_point_live_stroke,
+  add_point_live_stroke
+};
+export { default_stroke_style, create_stroke_style, clone_stroke_style, default_smoothing_factor, default_stabilizer_history_size, create_stabilizer, stabilize_point, reset_stabilizer, get_stabilized_history, generate_stroke_id, create_live_stroke, add_point_live_stroke, add_raw_point_live_stroke, get_points_from_live_stroke, get_pressure_from_live_stroke, render_live_stroke, finalize_live_stroke, lod_high, lod_medium, lod_low, spline_evaluation_interval_high, spline_evaluation_interval_medium, spline_evaluation_interval_low, select_lod_from_zoom, get_spline_evaluation_interval, stroke_to_path_commands, render_stroke, render_stroke_with_pressure };