samcan 0.0.2 → 0.1.0

package/dist/stroke/index.cjs

@@ -0,0 +1,1010 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// stroke/index.ts
+var exports_stroke = {};
+__export(exports_stroke, {
+  stroke_to_path_commands: () => stroke_to_path_commands,
+  stabilize_point: () => stabilize_point,
+  spline_evaluation_interval_medium: () => spline_evaluation_interval_medium,
+  spline_evaluation_interval_low: () => spline_evaluation_interval_low,
+  spline_evaluation_interval_high: () => spline_evaluation_interval_high,
+  simplify_stroke_points_auto: () => simplify_stroke_points_auto,
+  simplify_stroke_points: () => simplify_stroke_points,
+  select_lod_from_zoom: () => select_lod_from_zoom,
+  reset_stabilizer: () => reset_stabilizer,
+  render_stroke_with_pressure: () => render_stroke_with_pressure,
+  render_stroke: () => render_stroke,
+  render_live_stroke: () => render_live_stroke,
+  process_stroke: () => process_stroke,
+  lod_medium: () => lod_medium,
+  lod_low: () => lod_low,
+  lod_high: () => lod_high,
+  get_stabilized_history: () => get_stabilized_history,
+  get_spline_evaluation_interval: () => get_spline_evaluation_interval,
+  get_simplified_for_lod: () => get_simplified_for_lod,
+  get_pressure_from_live_stroke: () => get_pressure_from_live_stroke,
+  get_points_from_live_stroke: () => get_points_from_live_stroke,
+  generate_stroke_id: () => generate_stroke_id,
+  fit_spline_to_stroke: () => fit_spline_to_stroke,
+  finalize_live_stroke: () => finalize_live_stroke,
+  default_stroke_style: () => default_stroke_style,
+  default_stabilizer_history_size: () => default_stabilizer_history_size,
+  default_smoothing_factor: () => default_smoothing_factor,
+  default_simplify_epsilon: () => default_simplify_epsilon,
+  default_lod_simplify_factor: () => default_lod_simplify_factor,
+  create_stroke_style: () => create_stroke_style,
+  create_stabilizer: () => create_stabilizer,
+  create_live_stroke: () => create_live_stroke,
+  compute_stroke_bounds: () => compute_stroke_bounds,
+  clone_stroke_style: () => clone_stroke_style,
+  add_raw_point_live_stroke: () => add_raw_point_live_stroke,
+  add_point_live_stroke: () => add_point_live_stroke
+});
+module.exports = __toCommonJS(exports_stroke);
+
+// 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;
+}
+// math/color.ts
+function create_color(r = 0, g = 0, b = 0, a = 1) {
+  return [
+    Math.max(0, Math.min(1, r)),
+    Math.max(0, Math.min(1, g)),
+    Math.max(0, Math.min(1, b)),
+    Math.max(0, Math.min(1, a))
+  ];
+}
+function clone_color(c) {
+  return [c[0], c[1], c[2], c[3]];
+}
+function set_color(r, g, b, a = 1, out) {
+  out[0] = Math.max(0, Math.min(1, r));
+  out[1] = Math.max(0, Math.min(1, g));
+  out[2] = Math.max(0, Math.min(1, b));
+  out[3] = Math.max(0, Math.min(1, a));
+  return out;
+}
+function copy_color(c, out) {
+  out[0] = c[0];
+  out[1] = c[1];
+  out[2] = c[2];
+  out[3] = c[3];
+  return out;
+}
+function from_rgb_color(r, g, b, a = 255) {
+  return create_color(r / 255, g / 255, b / 255, a / 255);
+}
+function from_hex_color(hex) {
+  const cleaned = hex.replace("#", "");
+  const r = parseInt(cleaned.substring(0, 2), 16) / 255;
+  const g = parseInt(cleaned.substring(2, 4), 16) / 255;
+  const b = parseInt(cleaned.substring(4, 6), 16) / 255;
+  const a = cleaned.length === 8 ? parseInt(cleaned.substring(6, 8), 16) / 255 : 1;
+  return create_color(r, g, b, a);
+}
+function to_rgba_string_color(c) {
+  return `rgba(${Math.round(c[0] * 255)}, ${Math.round(c[1] * 255)}, ${Math.round(c[2] * 255)}, ${c[3]})`;
+}
+function to_hex_string_color(c) {
+  const r = Math.round(c[0] * 255).toString(16).padStart(2, "0");
+  const g = Math.round(c[1] * 255).toString(16).padStart(2, "0");
+  const b = Math.round(c[2] * 255).toString(16).padStart(2, "0");
+  const a = Math.round(c[3] * 255).toString(16).padStart(2, "0");
+  return c[3] === 1 ? `#${r}${g}${b}` : `#${r}${g}${b}${a}`;
+}
+function lerp_color(c1, c2, t, out) {
+  out[0] = c1[0] + (c2[0] - c1[0]) * t;
+  out[1] = c1[1] + (c2[1] - c1[1]) * t;
+  out[2] = c1[2] + (c2[2] - c1[2]) * t;
+  out[3] = c1[3] + (c2[3] - c1[3]) * t;
+  return out;
+}
+function equals_color(c1, c2, epsilon = 0.0001) {
+  return Math.abs(c1[0] - c2[0]) < epsilon && Math.abs(c1[1] - c2[1]) < epsilon && Math.abs(c1[2] - c2[2]) < epsilon && Math.abs(c1[3] - c2[3]) < epsilon;
+}
+function white_color() {
+  return [1, 1, 1, 1];
+}
+function black_color() {
+  return [0, 0, 0, 1];
+}
+function transparent_color() {
+  return [0, 0, 0, 0];
+}
+
+// renderer/style.ts
+var line_cap_butt = 0;
+var line_cap_round = 1;
+var line_cap_square = 2;
+var line_join_miter = 0;
+var line_join_round = 1;
+var line_join_bevel = 2;
+function create_draw_style() {
+  return {
+    fill: null,
+    stroke: null,
+    stroke_width: 1,
+    line_cap: line_cap_round,
+    line_join: line_join_round,
+    miter_limit: 10,
+    alpha: 1
+  };
+}
+function clone_draw_style(s) {
+  return {
+    fill: s.fill,
+    stroke: s.stroke,
+    stroke_width: s.stroke_width,
+    line_cap: s.line_cap,
+    line_join: s.line_join,
+    miter_limit: s.miter_limit,
+    alpha: s.alpha
+  };
+}
+function copy_draw_style(s, out) {
+  const mutable_out = out;
+  mutable_out.fill = s.fill;
+  mutable_out.stroke = s.stroke;
+  mutable_out.stroke_width = s.stroke_width;
+  mutable_out.line_cap = s.line_cap;
+  mutable_out.line_join = s.line_join;
+  mutable_out.miter_limit = s.miter_limit;
+  mutable_out.alpha = s.alpha;
+  return out;
+}
+function set_draw_style(fill, stroke, stroke_width, line_cap, line_join, miter_limit, alpha, out) {
+  const mutable_out = out;
+  mutable_out.fill = fill;
+  mutable_out.stroke = stroke;
+  mutable_out.stroke_width = stroke_width;
+  mutable_out.line_cap = line_cap;
+  mutable_out.line_join = line_join;
+  mutable_out.miter_limit = miter_limit;
+  mutable_out.alpha = alpha;
+  return out;
+}
+function with_fill_draw_style(s, fill, out) {
+  const mutable_out = out;
+  mutable_out.fill = fill;
+  mutable_out.stroke = s.stroke;
+  mutable_out.stroke_width = s.stroke_width;
+  mutable_out.line_cap = s.line_cap;
+  mutable_out.line_join = s.line_join;
+  mutable_out.miter_limit = s.miter_limit;
+  mutable_out.alpha = s.alpha;
+  return out;
+}
+function with_stroke_draw_style(s, stroke, stroke_width, out) {
+  const mutable_out = out;
+  mutable_out.fill = s.fill;
+  mutable_out.stroke = stroke;
+  mutable_out.stroke_width = stroke_width;
+  mutable_out.line_cap = s.line_cap;
+  mutable_out.line_join = s.line_join;
+  mutable_out.miter_limit = s.miter_limit;
+  mutable_out.alpha = s.alpha;
+  return out;
+}
+function with_alpha_draw_style(s, alpha, out) {
+  const mutable_out = out;
+  mutable_out.fill = s.fill;
+  mutable_out.stroke = s.stroke;
+  mutable_out.stroke_width = s.stroke_width;
+  mutable_out.line_cap = s.line_cap;
+  mutable_out.line_join = s.line_join;
+  mutable_out.miter_limit = s.miter_limit;
+  mutable_out.alpha = alpha;
+  return out;
+}
+function with_line_cap_draw_style(s, line_cap, out) {
+  const mutable_out = out;
+  mutable_out.fill = s.fill;
+  mutable_out.stroke = s.stroke;
+  mutable_out.stroke_width = s.stroke_width;
+  mutable_out.line_cap = line_cap;
+  mutable_out.line_join = s.line_join;
+  mutable_out.miter_limit = s.miter_limit;
+  mutable_out.alpha = s.alpha;
+  return out;
+}
+function with_line_join_draw_style(s, line_join, miter_limit, out) {
+  const mutable_out = out;
+  mutable_out.fill = s.fill;
+  mutable_out.stroke = s.stroke;
+  mutable_out.stroke_width = s.stroke_width;
+  mutable_out.line_cap = s.line_cap;
+  mutable_out.line_join = line_join;
+  mutable_out.miter_limit = miter_limit;
+  mutable_out.alpha = s.alpha;
+  return out;
+}
+function equals_draw_style(a, b) {
+  const fill_equal = a.fill === null && b.fill === null || a.fill !== null && b.fill !== null && equals_color(a.fill, b.fill);
+  const stroke_equal = a.stroke === null && b.stroke === null || a.stroke !== null && b.stroke !== null && equals_color(a.stroke, b.stroke);
+  return fill_equal && stroke_equal && a.stroke_width === b.stroke_width && a.line_cap === b.line_cap && a.line_join === b.line_join && a.miter_limit === b.miter_limit && a.alpha === b.alpha;
+}
+
+// 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
+  };
+}
+// math/simplify.ts
+function create_simplify_result() {
+  return {
+    points: [],
+    original_count: 0,
+    simplified_count: 0,
+    reduction_ratio: 0
+  };
+}
+function clone_simplify_result(result) {
+  return {
+    points: result.points.map((point) => [point[0], point[1]]),
+    original_count: result.original_count,
+    simplified_count: result.simplified_count,
+    reduction_ratio: result.reduction_ratio
+  };
+}
+function copy_simplify_result(result, out) {
+  out.points = result.points.map((point) => [point[0], point[1]]);
+  out.original_count = result.original_count;
+  out.simplified_count = result.simplified_count;
+  out.reduction_ratio = result.reduction_ratio;
+  return out;
+}
+function perpendicular_distance_to_line(point, line_start, line_end) {
+  const dx = line_end[0] - line_start[0];
+  const dy = line_end[1] - line_start[1];
+  if (dx === 0 && dy === 0) {
+    const px = point[0] - line_start[0];
+    const py = point[1] - line_start[1];
+    return Math.sqrt(px * px + py * py);
+  }
+  const numerator = Math.abs(dy * point[0] - dx * point[1] + line_end[0] * line_start[1] - line_end[1] * line_start[0]);
+  const denominator = Math.sqrt(dx * dx + dy * dy);
+  return numerator / denominator;
+}
+function find_farthest_point(points, start_index, end_index, out_result) {
+  let max_distance = 0;
+  let farthest_index = -1;
+  const line_start = points[start_index];
+  const line_end = points[end_index];
+  for (let i = start_index + 1;i < end_index; i++) {
+    const distance = perpendicular_distance_to_line(points[i], line_start, line_end);
+    if (distance > max_distance) {
+      max_distance = distance;
+      farthest_index = i;
+    }
+  }
+  out_result.index = farthest_index;
+  out_result.distance = max_distance;
+  return out_result;
+}
+function douglas_peucker_recursive(points, start_index, end_index, epsilon, keep_flags) {
+  if (end_index <= start_index + 1) {
+    return;
+  }
+  const farthest_result = { index: -1, distance: 0 };
+  find_farthest_point(points, start_index, end_index, farthest_result);
+  if (farthest_result.index === -1 || farthest_result.distance <= epsilon) {
+    return;
+  }
+  keep_flags[farthest_result.index] = true;
+  douglas_peucker_recursive(points, start_index, farthest_result.index, epsilon, keep_flags);
+  douglas_peucker_recursive(points, farthest_result.index, end_index, epsilon, keep_flags);
+}
+function simplify_douglas_peucker(points, epsilon, out_points) {
+  if (points.length <= 2) {
+    for (let i = 0;i < points.length; i++) {
+      const p = points[i];
+      const out = out_points[i];
+      if (out) {
+        out[0] = p[0];
+        out[1] = p[1];
+      } else {
+        out_points[i] = [p[0], p[1]];
+      }
+    }
+    return points.length;
+  }
+  const keep_flags = Array.from({ length: points.length }, () => false);
+  keep_flags[0] = true;
+  keep_flags[points.length - 1] = true;
+  douglas_peucker_recursive(points, 0, points.length - 1, epsilon, keep_flags);
+  let result_count = 0;
+  for (let i = 0;i < points.length; i++) {
+    if (keep_flags[i]) {
+      const p = points[i];
+      const out = out_points[result_count];
+      if (out) {
+        out[0] = p[0];
+        out[1] = p[1];
+      } else {
+        out_points[result_count] = [p[0], p[1]];
+      }
+      result_count = result_count + 1;
+    }
+  }
+  return result_count;
+}
+function simplify_douglas_peucker_detailed(points, epsilon, out_result) {
+  const temp_points = Array.from({ length: points.length }, () => [0, 0]);
+  const simplified_count = simplify_douglas_peucker(points, epsilon, temp_points);
+  out_result.points = temp_points.slice(0, simplified_count);
+  out_result.original_count = points.length;
+  out_result.simplified_count = simplified_count;
+  out_result.reduction_ratio = points.length > 0 ? (points.length - simplified_count) / points.length : 0;
+  return out_result;
+}
+function estimate_epsilon_from_points(points, tolerance_factor = 0.1) {
+  if (points.length < 2) {
+    return 1;
+  }
+  let total_distance = 0;
+  let segment_count = 0;
+  for (let i = 1;i < points.length; i++) {
+    const dx = points[i][0] - points[i - 1][0];
+    const dy = points[i][1] - points[i - 1][1];
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    if (distance > 0) {
+      total_distance = total_distance + distance;
+      segment_count = segment_count + 1;
+    }
+  }
+  if (segment_count === 0) {
+    return 1;
+  }
+  const average_distance = total_distance / segment_count;
+  return average_distance * tolerance_factor;
+}
+function polyline_length(points) {
+  if (points.length < 2) {
+    return 0;
+  }
+  let total_length = 0;
+  for (let i = 1;i < points.length; i++) {
+    const dx = points[i][0] - points[i - 1][0];
+    const dy = points[i][1] - points[i - 1][1];
+    total_length = total_length + Math.sqrt(dx * dx + dy * dy);
+  }
+  return total_length;
+}
+function polyline_area_under_curve(points) {
+  if (points.length < 2) {
+    return 0;
+  }
+  let area = 0;
+  for (let i = 1;i < points.length; i++) {
+    const x1 = points[i - 1][0];
+    const y1 = points[i - 1][1];
+    const x2 = points[i][0];
+    const y2 = points[i][1];
+    area = area + (x2 - x1) * (y1 + y2) * 0.5;
+  }
+  return Math.abs(area);
+}
+function validate_simplified_polyline(points) {
+  if (points.length < 4) {
+    return true;
+  }
+  for (let i = 0;i < points.length - 3; i++) {
+    for (let j = i + 2;j < points.length - 1; j++) {
+      const p1 = points[i];
+      const p2 = points[i + 1];
+      const p3 = points[j];
+      const p4 = points[j + 1];
+      if (line_segments_intersect(p1, p2, p3, p4)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function line_segments_intersect(p1, p2, p3, p4) {
+  const d1 = direction(p3, p4, p1);
+  const d2 = direction(p3, p4, p2);
+  const d3 = direction(p1, p2, p3);
+  const d4 = direction(p1, p2, p4);
+  if ((d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0)) {
+    return true;
+  }
+  if (d1 === 0 && on_segment(p3, p1, p4))
+    return true;
+  if (d2 === 0 && on_segment(p3, p2, p4))
+    return true;
+  if (d3 === 0 && on_segment(p1, p3, p2))
+    return true;
+  if (d4 === 0 && on_segment(p1, p4, p2))
+    return true;
+  return false;
+}
+function direction(pi, pj, pk) {
+  return (pk[0] - pi[0]) * (pj[1] - pi[1]) - (pj[0] - pi[0]) * (pk[1] - pi[1]);
+}
+function on_segment(pi, pj, pk) {
+  return Math.min(pi[0], pk[0]) <= pj[0] && pj[0] <= Math.max(pi[0], pk[0]) && Math.min(pi[1], pk[1]) <= pj[1] && pj[1] <= Math.max(pi[1], pk[1]);
+}
+
+// math/spline.ts
+function create_spline() {
+  return {
+    segments_x: [],
+    segments_y: [],
+    point_count: 0
+  };
+}
+function clone_spline(s) {
+  return {
+    segments_x: s.segments_x.map((seg) => ({ ...seg })),
+    segments_y: s.segments_y.map((seg) => ({ ...seg })),
+    point_count: s.point_count
+  };
+}
+function build_natural_spline_1d(points, t_values) {
+  const n = points.length;
+  if (n < 2)
+    return [];
+  if (n === 2) {
+    const slope = (points[1] - points[0]) / (t_values[1] - t_values[0]);
+    return [
+      {
+        a: points[0],
+        b: slope,
+        c: 0,
+        d: 0,
+        x_start: t_values[0],
+        x_end: t_values[1]
+      }
+    ];
+  }
+  const h = Array.from({ length: n - 1 }, () => 0);
+  for (let i = 0;i < n - 1; i++) {
+    h[i] = t_values[i + 1] - t_values[i];
+  }
+  const alpha = Array.from({ length: n - 1 }, () => 0);
+  for (let i = 1;i < n - 1; i++) {
+    alpha[i] = 3 / h[i] * (points[i + 1] - points[i]) - 3 / h[i - 1] * (points[i] - points[i - 1]);
+  }
+  const l = Array.from({ length: n }, () => 0);
+  const mu = Array.from({ length: n }, () => 0);
+  const z = Array.from({ length: n }, () => 0);
+  l[0] = 1;
+  mu[0] = 0;
+  z[0] = 0;
+  for (let i = 1;i < n - 1; i++) {
+    l[i] = 2 * (t_values[i + 1] - t_values[i - 1]) - h[i - 1] * mu[i - 1];
+    mu[i] = h[i] / l[i];
+    z[i] = (alpha[i] - h[i - 1] * z[i - 1]) / l[i];
+  }
+  l[n - 1] = 1;
+  z[n - 1] = 0;
+  const c = Array.from({ length: n }, () => 0);
+  c[n - 1] = 0;
+  for (let j = n - 2;j >= 0; j--) {
+    c[j] = z[j] - mu[j] * c[j + 1];
+  }
+  const segments = [];
+  for (let i = 0;i < n - 1; i++) {
+    const a = points[i];
+    const b = (points[i + 1] - points[i]) / h[i] - h[i] * (c[i + 1] + 2 * c[i]) / 3;
+    const d = (c[i + 1] - c[i]) / (3 * h[i]);
+    segments.push({
+      a,
+      b,
+      c: c[i],
+      d,
+      x_start: t_values[i],
+      x_end: t_values[i + 1]
+    });
+  }
+  return segments;
+}
+function build_natural_spline_from_points(points, spline) {
+  const n = points.length;
+  if (n < 2) {
+    spline.segments_x = [];
+    spline.segments_y = [];
+    spline.point_count = 0;
+    return spline;
+  }
+  const t_values = Array.from({ length: n }, () => 0);
+  t_values[0] = 0;
+  for (let i = 1;i < n; i++) {
+    const dx = points[i][0] - points[i - 1][0];
+    const dy = points[i][1] - points[i - 1][1];
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    t_values[i] = t_values[i - 1] + distance;
+  }
+  const x_coords = points.map((p) => p[0]);
+  const y_coords = points.map((p) => p[1]);
+  spline.segments_x = build_natural_spline_1d(x_coords, t_values);
+  spline.segments_y = build_natural_spline_1d(y_coords, t_values);
+  spline.point_count = n;
+  return spline;
+}
+function evaluate_spline_segment(segment, t) {
+  const dt = t - segment.x_start;
+  return segment.a + segment.b * dt + segment.c * dt * dt + segment.d * dt * dt * dt;
+}
+function evaluate_spline_at_t(spline, t, out) {
+  if (spline.segments_x.length === 0 || spline.segments_y.length === 0) {
+    return null;
+  }
+  let segment_x = null;
+  let segment_y = null;
+  for (let i = 0;i < spline.segments_x.length; i++) {
+    const seg_x = spline.segments_x[i];
+    const seg_y = spline.segments_y[i];
+    if (t >= seg_x.x_start && t <= seg_x.x_end) {
+      segment_x = seg_x;
+      segment_y = seg_y;
+      break;
+    }
+  }
+  if (!segment_x || !segment_y) {
+    const last_idx = spline.segments_x.length - 1;
+    if (t > spline.segments_x[last_idx].x_end) {
+      segment_x = spline.segments_x[last_idx];
+      segment_y = spline.segments_y[last_idx];
+      t = segment_x.x_end;
+    } else {
+      segment_x = spline.segments_x[0];
+      segment_y = spline.segments_y[0];
+      t = segment_x.x_start;
+    }
+  }
+  out[0] = evaluate_spline_segment(segment_x, t);
+  out[1] = evaluate_spline_segment(segment_y, t);
+  return out;
+}
+function evaluate_spline_at_points(spline, t_values, out_points) {
+  let valid_count = 0;
+  const temp_point = [0, 0];
+  for (let i = 0;i < t_values.length; i++) {
+    const t_val = t_values[i];
+    if (evaluate_spline_at_t(spline, t_val, temp_point)) {
+      out_points[valid_count][0] = temp_point[0];
+      out_points[valid_count][1] = temp_point[1];
+      valid_count = valid_count + 1;
+    }
+  }
+  return valid_count;
+}
+function get_spline_length(spline, steps = 100) {
+  if (spline.segments_x.length === 0)
+    return 0;
+  const first_segment = spline.segments_x[0];
+  const last_segment = spline.segments_x[spline.segments_x.length - 1];
+  const t_start = first_segment.x_start;
+  const t_end = last_segment.x_end;
+  const dt = (t_end - t_start) / steps;
+  let length = 0;
+  const prev = [0, 0];
+  const curr = [0, 0];
+  evaluate_spline_at_t(spline, t_start, prev);
+  for (let i = 1;i <= steps; i++) {
+    const t = t_start + i * dt;
+    if (evaluate_spline_at_t(spline, t, curr)) {
+      const dx = curr[0] - prev[0];
+      const dy = curr[1] - prev[1];
+      length = length + Math.sqrt(dx * dx + dy * dy);
+      prev[0] = curr[0];
+      prev[1] = curr[1];
+    }
+  }
+  return length;
+}
+function simplify_points_for_spline(points, tolerance = 1) {
+  if (points.length <= 2)
+    return [...points];
+  const simplified = [points[0]];
+  for (let i = 1;i < points.length - 1; i++) {
+    const prev = points[i - 1];
+    const curr = points[i];
+    const next = points[i + 1];
+    const dx1 = curr[0] - prev[0];
+    const dy1 = curr[1] - prev[1];
+    const dx2 = next[0] - curr[0];
+    const dy2 = next[1] - curr[1];
+    const dist1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+    const dist2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+    if (dist1 < tolerance && dist2 < tolerance) {
+      if (dist1 > 0 && dist2 > 0) {
+        const dot = (dx1 * dx2 + dy1 * dy2) / (dist1 * dist2);
+        if (dot > 0.99) {
+          continue;
+        }
+      } else {
+        continue;
+      }
+    }
+    simplified.push(curr);
+  }
+  simplified.push(points[points.length - 1]);
+  return simplified;
+}
+
+// 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);
+}
+// 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 });
+  }
+}