samcan 0.0.2 → 0.1.0

package/dist/renderer/index.d.cts

@@ -0,0 +1,91 @@
+type vector2 = [number, number];
+type transform = [number, number, number, number, number, number];
+type rectangle = [number, number, number, number];
+type circle = [number, number, number];
+type color = [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;
+};
+declare function create_path(): path;
+declare function clone_path(p: path): path;
+declare function move_to_path(p: path, x: number, y: number): path;
+declare function line_to_path(p: path, x: number, y: number): path;
+declare function cubic_to_path(p: path, c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number): path;
+declare function close_path(p: path): path;
+declare function bounds_of_path(p: path): rectangle;
+declare function is_empty_path(p: path): boolean;
+declare function command_count_of_path(p: path): number;
+declare function transform_path(p: path, t: transform, out: path): path;
+declare function hash_of_path(p: path): number;
+declare function from_rectangle_path(r: rectangle): path;
+declare function from_circle_path(c: circle, segments: number): path;
+declare function from_polyline_path(points: readonly vector2[], closed: boolean): path;
+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;
+};
+declare const line_cap_butt = 0;
+declare const line_cap_round = 1;
+declare const line_cap_square = 2;
+declare const line_join_miter = 0;
+declare const line_join_round = 1;
+declare const line_join_bevel = 2;
+declare function create_draw_style(): draw_style;
+declare function clone_draw_style(s: draw_style): draw_style;
+declare function copy_draw_style(s: draw_style, out: draw_style): draw_style;
+declare function set_draw_style(fill: color | null, stroke: color | null, stroke_width: number, line_cap: number, line_join: number, miter_limit: number, alpha: number, out: draw_style): draw_style;
+declare function with_fill_draw_style(s: draw_style, fill: color | null, out: draw_style): draw_style;
+declare function with_stroke_draw_style(s: draw_style, stroke: color | null, stroke_width: number, out: draw_style): draw_style;
+declare function with_alpha_draw_style(s: draw_style, alpha: number, out: draw_style): draw_style;
+declare function with_line_cap_draw_style(s: draw_style, line_cap: number, out: draw_style): draw_style;
+declare function with_line_join_draw_style(s: draw_style, line_join: number, miter_limit: number, out: draw_style): draw_style;
+declare function equals_draw_style(a: draw_style, b: draw_style): boolean;
+declare const renderer_kind_canvas = 0;
+declare const renderer_kind_webgl = 1;
+type renderer_config = {
+	readonly prefer_webgl: boolean;
+	readonly path_cache_size: 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 create_renderer_config(): renderer_config;
+declare function create_renderer(canvas: HTMLCanvasElement, config: renderer_config): renderer | null;
+declare function create_renderer_canvas(canvas: HTMLCanvasElement, config: renderer_config): renderer | null;
+declare function create_renderer_webgl(canvas: HTMLCanvasElement, config: renderer_config): renderer | null;
+export { with_stroke_draw_style, with_line_join_draw_style, with_line_cap_draw_style, with_fill_draw_style, with_alpha_draw_style, transform_path, set_draw_style, renderer_kind_webgl, renderer_kind_canvas, renderer_config, renderer, path_move, path_line, path_cubic, path_command_move, path_command_line, path_command_cubic, path_command_close, path_command, path_close, path, move_to_path, line_to_path, line_join_round, line_join_miter, line_join_bevel, line_cap_square, line_cap_round, line_cap_butt, is_empty_path, image_source, hash_of_path, from_rectangle_path, from_polyline_path, from_circle_path, equals_draw_style, draw_style, cubic_to_path, create_renderer_webgl, create_renderer_config, create_renderer_canvas, create_renderer, create_path, create_draw_style, copy_draw_style, command_count_of_path, close_path, clone_path, clone_draw_style, bounds_of_path };

package/dist/renderer/index.d.ts

@@ -0,0 +1,91 @@
+type vector2 = [number, number];
+type transform = [number, number, number, number, number, number];
+type rectangle = [number, number, number, number];
+type circle = [number, number, number];
+type color = [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;
+};
+declare function create_path(): path;
+declare function clone_path(p: path): path;
+declare function move_to_path(p: path, x: number, y: number): path;
+declare function line_to_path(p: path, x: number, y: number): path;
+declare function cubic_to_path(p: path, c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number): path;
+declare function close_path(p: path): path;
+declare function bounds_of_path(p: path): rectangle;
+declare function is_empty_path(p: path): boolean;
+declare function command_count_of_path(p: path): number;
+declare function transform_path(p: path, t: transform, out: path): path;
+declare function hash_of_path(p: path): number;
+declare function from_rectangle_path(r: rectangle): path;
+declare function from_circle_path(c: circle, segments: number): path;
+declare function from_polyline_path(points: readonly vector2[], closed: boolean): path;
+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;
+};
+declare const line_cap_butt = 0;
+declare const line_cap_round = 1;
+declare const line_cap_square = 2;
+declare const line_join_miter = 0;
+declare const line_join_round = 1;
+declare const line_join_bevel = 2;
+declare function create_draw_style(): draw_style;
+declare function clone_draw_style(s: draw_style): draw_style;
+declare function copy_draw_style(s: draw_style, out: draw_style): draw_style;
+declare function set_draw_style(fill: color | null, stroke: color | null, stroke_width: number, line_cap: number, line_join: number, miter_limit: number, alpha: number, out: draw_style): draw_style;
+declare function with_fill_draw_style(s: draw_style, fill: color | null, out: draw_style): draw_style;
+declare function with_stroke_draw_style(s: draw_style, stroke: color | null, stroke_width: number, out: draw_style): draw_style;
+declare function with_alpha_draw_style(s: draw_style, alpha: number, out: draw_style): draw_style;
+declare function with_line_cap_draw_style(s: draw_style, line_cap: number, out: draw_style): draw_style;
+declare function with_line_join_draw_style(s: draw_style, line_join: number, miter_limit: number, out: draw_style): draw_style;
+declare function equals_draw_style(a: draw_style, b: draw_style): boolean;
+declare const renderer_kind_canvas = 0;
+declare const renderer_kind_webgl = 1;
+type renderer_config = {
+	readonly prefer_webgl: boolean;
+	readonly path_cache_size: 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 create_renderer_config(): renderer_config;
+declare function create_renderer(canvas: HTMLCanvasElement, config: renderer_config): renderer | null;
+declare function create_renderer_canvas(canvas: HTMLCanvasElement, config: renderer_config): renderer | null;
+declare function create_renderer_webgl(canvas: HTMLCanvasElement, config: renderer_config): renderer | null;
+export { with_stroke_draw_style, with_line_join_draw_style, with_line_cap_draw_style, with_fill_draw_style, with_alpha_draw_style, transform_path, set_draw_style, renderer_kind_webgl, renderer_kind_canvas, renderer_config, renderer, path_move, path_line, path_cubic, path_command_move, path_command_line, path_command_cubic, path_command_close, path_command, path_close, path, move_to_path, line_to_path, line_join_round, line_join_miter, line_join_bevel, line_cap_square, line_cap_round, line_cap_butt, is_empty_path, image_source, hash_of_path, from_rectangle_path, from_polyline_path, from_circle_path, equals_draw_style, draw_style, cubic_to_path, create_renderer_webgl, create_renderer_config, create_renderer_canvas, create_renderer, create_path, create_draw_style, copy_draw_style, command_count_of_path, close_path, clone_path, clone_draw_style, bounds_of_path };

package/dist/renderer/index.js

@@ -0,0 +1,89 @@
+import {
+  bounds_of_path,
+  clone_path,
+  close_path,
+  command_count_of_path,
+  create_path,
+  create_renderer,
+  create_renderer_canvas,
+  create_renderer_config,
+  create_renderer_webgl,
+  cubic_to_path,
+  from_circle_path,
+  from_polyline_path,
+  from_rectangle_path,
+  hash_of_path,
+  is_empty_path,
+  line_to_path,
+  move_to_path,
+  path_close,
+  path_cubic,
+  path_line,
+  path_move,
+  renderer_kind_canvas,
+  renderer_kind_webgl,
+  transform_path
+} from "../shared/chunk-s3qdcmcq.js";
+import"../shared/chunk-8ynnz57m.js";
+import"../shared/chunk-35pkr0zs.js";
+import {
+  clone_draw_style,
+  copy_draw_style,
+  create_draw_style,
+  equals_draw_style,
+  line_cap_butt,
+  line_cap_round,
+  line_cap_square,
+  line_join_bevel,
+  line_join_miter,
+  line_join_round,
+  set_draw_style,
+  with_alpha_draw_style,
+  with_fill_draw_style,
+  with_line_cap_draw_style,
+  with_line_join_draw_style,
+  with_stroke_draw_style
+} from "../shared/chunk-wa3772hp.js";
+import"../shared/chunk-v53jprrn.js";
+export {
+  with_stroke_draw_style,
+  with_line_join_draw_style,
+  with_line_cap_draw_style,
+  with_fill_draw_style,
+  with_alpha_draw_style,
+  transform_path,
+  set_draw_style,
+  renderer_kind_webgl,
+  renderer_kind_canvas,
+  path_move,
+  path_line,
+  path_cubic,
+  path_close,
+  move_to_path,
+  line_to_path,
+  line_join_round,
+  line_join_miter,
+  line_join_bevel,
+  line_cap_square,
+  line_cap_round,
+  line_cap_butt,
+  is_empty_path,
+  hash_of_path,
+  from_rectangle_path,
+  from_polyline_path,
+  from_circle_path,
+  equals_draw_style,
+  cubic_to_path,
+  create_renderer_webgl,
+  create_renderer_config,
+  create_renderer_canvas,
+  create_renderer,
+  create_path,
+  create_draw_style,
+  copy_draw_style,
+  command_count_of_path,
+  close_path,
+  clone_path,
+  clone_draw_style,
+  bounds_of_path
+};

package/dist/shared/chunk-35pkr0zs.js

@@ -0,0 +1,110 @@
+// math/rectangle.ts
+function create_rectangle(x = 0, y = 0, width = 0, height = 0) {
+  return [x, y, width, height];
+}
+function clone_rectangle(r) {
+  return [r[0], r[1], r[2], r[3]];
+}
+function from_center_rectangle(center, width, height, out) {
+  out[0] = center[0] - width / 2;
+  out[1] = center[1] - height / 2;
+  out[2] = width;
+  out[3] = height;
+  return out;
+}
+function top_of_rectangle(r) {
+  return r[1] + r[3];
+}
+function left_of_rectangle(r) {
+  return r[0];
+}
+function right_of_rectangle(r) {
+  return r[0] + r[2];
+}
+function bottom_of_rectangle(r) {
+  return r[1];
+}
+function center_of_rectangle(r, out) {
+  out[0] = r[0] + r[2] / 2;
+  out[1] = r[1] + r[3] / 2;
+  return out;
+}
+function width_of_rectangle(r) {
+  return r[2];
+}
+function height_of_rectangle(r) {
+  return r[3];
+}
+function area_of_rectangle(r) {
+  return r[2] * r[3];
+}
+function set_rectangle(x, y, width, height, out) {
+  out[0] = x;
+  out[1] = y;
+  out[2] = width;
+  out[3] = height;
+  return out;
+}
+function translate_rectangle(r, dx, dy, out) {
+  out[0] = r[0] + dx;
+  out[1] = r[1] + dy;
+  out[2] = r[2];
+  out[3] = r[3];
+  return out;
+}
+function scale_rectangle(r, scale, out) {
+  out[0] = r[0] * scale;
+  out[1] = r[1] * scale;
+  out[2] = r[2] * scale;
+  out[3] = r[3] * scale;
+  return out;
+}
+function contains_point_rectangle(r, x, y) {
+  return x >= r[0] && x <= r[0] + r[2] && y >= r[1] && y <= r[1] + r[3];
+}
+function contains_rectangle(r1, r2) {
+  return r2[0] >= r1[0] && r2[1] >= r1[1] && r2[0] + r2[2] <= r1[0] + r1[2] && r2[1] + r2[3] <= r1[1] + r1[3];
+}
+function intersects_rectangle(r1, r2) {
+  return r1[0] < r2[0] + r2[2] && r1[0] + r1[2] > r2[0] && r1[1] < r2[1] + r2[3] && r1[1] + r1[3] > r2[1];
+}
+function intersection_rectangle(r1, r2, out) {
+  const x1 = Math.max(r1[0], r2[0]);
+  const y1 = Math.max(r1[1], r2[1]);
+  const x2 = Math.min(r1[0] + r1[2], r2[0] + r2[2]);
+  const y2 = Math.min(r1[1] + r1[3], r2[1] + r2[3]);
+  if (x2 <= x1 || y2 <= y1) {
+    return null;
+  }
+  out[0] = x1;
+  out[1] = y1;
+  out[2] = x2 - x1;
+  out[3] = y2 - y1;
+  return out;
+}
+function union_rectangle(r1, r2, out) {
+  const x1 = Math.min(r1[0], r2[0]);
+  const y1 = Math.min(r1[1], r2[1]);
+  const x2 = Math.max(r1[0] + r1[2], r2[0] + r2[2]);
+  const y2 = Math.max(r1[1] + r1[3], r2[1] + r2[3]);
+  out[0] = x1;
+  out[1] = y1;
+  out[2] = x2 - x1;
+  out[3] = y2 - y1;
+  return out;
+}
+function expand_rectangle(r, amount, out) {
+  out[0] = r[0] - amount;
+  out[1] = r[1] - amount;
+  out[2] = r[2] + amount * 2;
+  out[3] = r[3] + amount * 2;
+  return out;
+}
+function is_empty_rectangle(r) {
+  return r[2] <= 0 || r[3] <= 0;
+}
+function equals_rectangle(r1, r2) {
+  return r1[0] === r2[0] && r1[1] === r2[1] && r1[2] === r2[2] && r1[3] === r2[3];
+}
+
+export { create_rectangle, clone_rectangle, from_center_rectangle, top_of_rectangle, left_of_rectangle, right_of_rectangle, bottom_of_rectangle, center_of_rectangle, width_of_rectangle, height_of_rectangle, area_of_rectangle, set_rectangle, translate_rectangle, scale_rectangle, contains_point_rectangle, contains_rectangle, intersects_rectangle, intersection_rectangle, union_rectangle, expand_rectangle, is_empty_rectangle, equals_rectangle };

package/dist/shared/chunk-7sr7q84y.js

@@ -0,0 +1,80 @@
+// math/vector2.ts
+function create_vector2(x, y) {
+  return [x, y];
+}
+function zero_vector2() {
+  return [0, 0];
+}
+function unit_vector2() {
+  return [1, 1];
+}
+function clone_vector2(v) {
+  return [v[0], v[1]];
+}
+function copy_vector2(v, out) {
+  out[0] = v[0];
+  out[1] = v[1];
+  return out;
+}
+function set_vector2(x, y, out) {
+  out[0] = x;
+  out[1] = y;
+  return out;
+}
+function add_vector2(a, b, out) {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  return out;
+}
+function subtract_vector2(a, b, out) {
+  out[0] = a[0] - b[0];
+  out[1] = a[1] - b[1];
+  return out;
+}
+function multiply_vector2(a, b, out) {
+  out[0] = a[0] * b;
+  out[1] = a[1] * b;
+  return out;
+}
+function divide_vector2(a, b, out) {
+  out[0] = a[0] / b;
+  out[1] = a[1] / b;
+  return out;
+}
+function normalize_vector2(a, out) {
+  const len = length_vector2(a);
+  if (len > 0) {
+    divide_vector2(a, len, out);
+  } else {
+    set_vector2(0, 0, out);
+  }
+  return out;
+}
+function lerp_vector2(a, b, t, out) {
+  out[0] = a[0] + t * (b[0] - a[0]);
+  out[1] = a[1] + t * (b[1] - a[1]);
+  return out;
+}
+function dot_vector2(a, b) {
+  return a[0] * b[0] + a[1] * b[1];
+}
+function cross_vector2(a, b) {
+  return a[0] * b[1] - a[1] * b[0];
+}
+function length_squared_vector2(a) {
+  return a[0] * a[0] + a[1] * a[1];
+}
+function length_vector2(a) {
+  return Math.sqrt(length_squared_vector2(a));
+}
+function distance_squared_vector2(a, b) {
+  return length_squared_vector2(subtract_vector2(a, b, zero_vector2()));
+}
+function distance_vector2(a, b) {
+  return Math.sqrt(distance_squared_vector2(a, b));
+}
+function is_equal_vector2(a, b, epsilon = 0.0001) {
+  return Math.abs(a[0] - b[0]) < epsilon && Math.abs(a[1] - b[1]) < epsilon;
+}
+
+export { create_vector2, zero_vector2, unit_vector2, clone_vector2, copy_vector2, set_vector2, add_vector2, subtract_vector2, multiply_vector2, divide_vector2, normalize_vector2, lerp_vector2, dot_vector2, cross_vector2, length_squared_vector2, length_vector2, distance_squared_vector2, distance_vector2, is_equal_vector2 };

package/dist/shared/chunk-87399bz7.js

@@ -0,0 +1,89 @@
+import {
+  build_natural_spline_from_points,
+  estimate_epsilon_from_points,
+  simplify_douglas_peucker,
+  simplify_points_for_spline
+} from "./chunk-rzxyjwk8.js";
+
+// stroke/process.ts
+var default_simplify_epsilon = 1;
+var default_lod_simplify_factor = 3;
+function simplify_stroke_points(points, epsilon = default_simplify_epsilon, out) {
+  return simplify_douglas_peucker(points, epsilon, out);
+}
+function simplify_stroke_points_auto(points, out) {
+  const epsilon = estimate_epsilon_from_points(points, 0.1);
+  return simplify_douglas_peucker(points, epsilon, out);
+}
+function fit_spline_to_stroke(points, out_spline) {
+  if (points.length < 2) {
+    out_spline.segments_x = [];
+    out_spline.segments_y = [];
+    out_spline.point_count = 0;
+    return out_spline;
+  }
+  const simplified_for_spline = simplify_points_for_spline(points, 2);
+  return build_natural_spline_from_points(simplified_for_spline, out_spline);
+}
+function compute_stroke_bounds(points, width, out) {
+  if (points.length === 0) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    return out;
+  }
+  let min_x = Infinity;
+  let min_y = Infinity;
+  let max_x = -Infinity;
+  let max_y = -Infinity;
+  for (let i = 0;i < points.length; i++) {
+    const point = points[i];
+    if (point === undefined)
+      continue;
+    min_x = Math.min(min_x, point[0]);
+    min_y = Math.min(min_y, point[1]);
+    max_x = Math.max(max_x, point[0]);
+    max_y = Math.max(max_y, point[1]);
+  }
+  const half_width = width / 2;
+  out[0] = min_x - half_width;
+  out[1] = min_y - half_width;
+  out[2] = max_x - min_x + width;
+  out[3] = max_y - min_y + width;
+  return out;
+}
+function process_stroke(points, pressure, style, out_simplified, out_spline) {
+  let epsilon = default_simplify_epsilon;
+  if (pressure && pressure.length > 1 && style.pressure_sensitivity > 0) {
+    const variance = calculate_pressure_variance(pressure);
+    epsilon = epsilon / (1 + variance * style.pressure_sensitivity * 2);
+  }
+  const simplified_count = simplify_stroke_points(points, epsilon, out_simplified);
+  const simplified = out_simplified.slice(0, simplified_count);
+  fit_spline_to_stroke(simplified, out_spline);
+  return {
+    simplified,
+    spline: out_spline
+  };
+}
+function calculate_pressure_variance(pressure) {
+  if (pressure.length < 2)
+    return 0;
+  let sum = 0;
+  let sum_sq = 0;
+  for (let i = 0;i < pressure.length; i++) {
+    const p = pressure[i];
+    sum += p;
+    sum_sq += p * p;
+  }
+  const mean = sum / pressure.length;
+  return Math.sqrt(Math.max(0, sum_sq / pressure.length - mean * mean));
+}
+function get_simplified_for_lod(points, lod_level, out) {
+  const lod_epsilon = default_simplify_epsilon * (lod_level * default_lod_simplify_factor);
+  const simplified_count = simplify_douglas_peucker(points, lod_epsilon, out);
+  return out.slice(0, simplified_count);
+}
+
+export { default_simplify_epsilon, default_lod_simplify_factor, simplify_stroke_points, simplify_stroke_points_auto, fit_spline_to_stroke, compute_stroke_bounds, process_stroke, get_simplified_for_lod };

package/dist/shared/chunk-8ynnz57m.js

@@ -0,0 +1,129 @@
+// math/transform.ts
+function create_transform(a = 1, b = 0, c = 0, d = 1, tx = 0, ty = 0) {
+  return [a, b, c, d, tx, ty];
+}
+function clone_transform(t) {
+  return [t[0], t[1], t[2], t[3], t[4], t[5]];
+}
+function set_transform(a, b, c, d, tx, ty, out) {
+  out[0] = a;
+  out[1] = b;
+  out[2] = c;
+  out[3] = d;
+  out[4] = tx;
+  out[5] = ty;
+  return out;
+}
+function copy_transform(t, out) {
+  out[0] = t[0];
+  out[1] = t[1];
+  out[2] = t[2];
+  out[3] = t[3];
+  out[4] = t[4];
+  out[5] = t[5];
+  return out;
+}
+function identity_transform() {
+  return [1, 0, 0, 1, 0, 0];
+}
+function set_identity_transform(out) {
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 1;
+  out[4] = 0;
+  out[5] = 0;
+  return out;
+}
+function translate_transform(x, y) {
+  return [1, 0, 0, 1, x, y];
+}
+function scale_transform(sx, sy = sx) {
+  return [sx, 0, 0, sy, 0, 0];
+}
+function rotate_transform(angle) {
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  return [cos, sin, -sin, cos, 0, 0];
+}
+function from_trs_transform(translation, rotation, scale) {
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  return [
+    cos * scale[0],
+    sin * scale[0],
+    -sin * scale[1],
+    cos * scale[1],
+    translation[0],
+    translation[1]
+  ];
+}
+function multiply_transform(t1, t2, out) {
+  out[0] = t1[0] * t2[0] + t1[2] * t2[1];
+  out[1] = t1[1] * t2[0] + t1[3] * t2[1];
+  out[2] = t1[0] * t2[2] + t1[2] * t2[3];
+  out[3] = t1[1] * t2[2] + t1[3] * t2[3];
+  out[4] = t1[0] * t2[4] + t1[2] * t2[5] + t1[4];
+  out[5] = t1[1] * t2[4] + t1[3] * t2[5] + t1[5];
+  return out;
+}
+function determinant_transform(t) {
+  return t[0] * t[3] - t[1] * t[2];
+}
+function invert_transform(t, out) {
+  const det = determinant_transform(t);
+  if (Math.abs(det) < 0.0000000001) {
+    return null;
+  }
+  const inverse_det = 1 / det;
+  out[0] = t[3] * inverse_det;
+  out[1] = -t[1] * inverse_det;
+  out[2] = -t[2] * inverse_det;
+  out[3] = t[0] * inverse_det;
+  out[4] = (t[2] * t[5] - t[3] * t[4]) * inverse_det;
+  out[5] = (t[1] * t[4] - t[0] * t[5]) * inverse_det;
+  return out;
+}
+function transform_point_transform(t, point, out) {
+  out[0] = t[0] * point[0] + t[2] * point[1] + t[4];
+  out[1] = t[1] * point[0] + t[3] * point[1] + t[5];
+  return out;
+}
+function transform_vector_transform(t, vector, out) {
+  out[0] = t[0] * vector[0] + t[2] * vector[1];
+  out[1] = t[1] * vector[0] + t[3] * vector[1];
+  return out;
+}
+function append_translation_transform(t, x, y, out) {
+  const translation = translate_transform(x, y);
+  return multiply_transform(t, translation, out);
+}
+function append_rotation_transform(t, angle, out) {
+  const rotation = rotate_transform(angle);
+  return multiply_transform(t, rotation, out);
+}
+function append_scale_transform(t, sx, sy = sx, out) {
+  const scale = scale_transform(sx, sy);
+  return multiply_transform(t, scale, out);
+}
+function prepend_translation_transform(x, y, t, out) {
+  const translation = translate_transform(x, y);
+  return multiply_transform(translation, t, out);
+}
+function prepend_rotation_transform(angle, t, out) {
+  const rotation = rotate_transform(angle);
+  return multiply_transform(rotation, t, out);
+}
+function prepend_scale_transform(sx, sy = sx, t, out) {
+  const scale = scale_transform(sx, sy);
+  return multiply_transform(scale, t, out);
+}
+function equals_transform(t1, t2, epsilon = 0.0001) {
+  return Math.abs(t1[0] - t2[0]) < epsilon && Math.abs(t1[1] - t2[1]) < epsilon && Math.abs(t1[2] - t2[2]) < epsilon && Math.abs(t1[3] - t2[3]) < epsilon && Math.abs(t1[4] - t2[4]) < epsilon && Math.abs(t1[5] - t2[5]) < epsilon;
+}
+function is_identity_transform(t, epsilon = 0.0001) {
+  const identity = identity_transform();
+  return equals_transform(t, identity, epsilon);
+}
+
+export { create_transform, clone_transform, set_transform, copy_transform, identity_transform, set_identity_transform, translate_transform, scale_transform, rotate_transform, from_trs_transform, multiply_transform, determinant_transform, invert_transform, transform_point_transform, transform_vector_transform, append_translation_transform, append_rotation_transform, append_scale_transform, prepend_translation_transform, prepend_rotation_transform, prepend_scale_transform, equals_transform, is_identity_transform };