vehicle-path2 2.0.0 → 2.1.0

package/dist/index-D8o0W80x.js

@@ -0,0 +1,732 @@
+function y(t, e) {
+  const s = e.x - t.x, n = e.y - t.y;
+  return Math.sqrt(s * s + n * n);
+}
+function w(t, e) {
+  const s = e.x - t.x, n = e.y - t.y, i = Math.sqrt(s * s + n * n);
+  return i === 0 ? { x: 0, y: 0 } : { x: s / i, y: n / i };
+}
+function k(t, e) {
+  return e * (t === "proportional-40" ? 0.4 : 0.5522);
+}
+function q(t, e, s, n = !1, i) {
+  const { maxWheelbase: c, tangentMode: o } = s;
+  let r;
+  i?.fromOffset !== void 0 ? r = V(t, i.fromOffset, i.fromIsPercentage ?? !1) : r = t.end;
+  let a;
+  i?.toOffset !== void 0 ? a = V(e, i.toOffset, i.toIsPercentage ?? !1) : a = e.start;
+  const l = w(t.start, t.end), f = n ? {
+    // Transition with flip: kurva dimulai dari P (baseP0 - wheelbase in line direction)
+    x: r.x - l.x * c,
+    y: r.y - l.y * c
+  } : r, g = w(t.start, t.end), d = w(e.start, e.end), h = y(f, a), p = k(o, h), u = n ? { x: f.x - g.x * p, y: f.y - g.y * p } : { x: f.x + g.x * p, y: f.y + g.y * p }, v = {
+    x: a.x - d.x * p,
+    y: a.y - d.y * p
+  };
+  return { p0: f, p1: u, p2: v, p3: a };
+}
+function K(t, e) {
+  return {
+    x: t.start.x + (t.end.x - t.start.x) * e,
+    y: t.start.y + (t.end.y - t.start.y) * e
+  };
+}
+function V(t, e, s) {
+  const n = y(t.start, t.end);
+  let i;
+  return s ? i = e : i = n > 0 ? e / n : 0, i = Math.max(0, Math.min(1, i)), K(t, i);
+}
+function T(t, e) {
+  const { p0: s, p1: n, p2: i, p3: c } = t, o = 1 - e, r = o * o, a = r * o, l = e * e, f = l * e;
+  return {
+    x: a * s.x + 3 * r * e * n.x + 3 * o * l * i.x + f * c.x,
+    y: a * s.y + 3 * r * e * n.y + 3 * o * l * i.y + f * c.y
+  };
+}
+function ne(t, e, s = 10) {
+  return y(t, e) <= s;
+}
+function N(t, e = 100) {
+  const s = [{ t: 0, distance: 0 }];
+  let n = t.p0, i = 0;
+  for (let c = 1; c <= e; c++) {
+    const o = c / e, r = T(t, o);
+    i += y(n, r), s.push({ t: o, distance: i }), n = r;
+  }
+  return s;
+}
+function F(t, e) {
+  if (e <= 0) return 0;
+  const s = t[t.length - 1].distance;
+  if (e >= s) return 1;
+  let n = 0, i = t.length - 1;
+  for (; n < i - 1; ) {
+    const f = Math.floor((n + i) / 2);
+    t[f].distance < e ? n = f : i = f;
+  }
+  const c = t[n].distance, o = t[i].distance, r = t[n].t, a = t[i].t;
+  if (o === c) return r;
+  const l = (e - c) / (o - c);
+  return r + l * (a - r);
+}
+function se(t) {
+  return t[t.length - 1].distance;
+}
+function G(t, e = 100) {
+  let s = 0, n = t.p0;
+  for (let i = 1; i <= e; i++) {
+    const c = i / e, o = T(t, c);
+    s += y(n, o), n = o;
+  }
+  return s;
+}
+function E(t, e, s, n, i) {
+  const c = y(t.start, t.end), o = c - i;
+  if (o <= 0)
+    return c;
+  let r;
+  if (e === void 0)
+    r = n;
+  else if (s)
+    r = e;
+  else {
+    const a = Math.max(0, Math.min(e, o));
+    return i + a;
+  }
+  return i + r * o;
+}
+function W(t, e, s, n, i) {
+  const o = y(t.start, t.end) - i;
+  if (o <= 0)
+    return 0;
+  let r;
+  if (e === void 0)
+    r = n;
+  else if (s)
+    r = e;
+  else
+    return Math.max(0, Math.min(e, o));
+  return r * o;
+}
+function I(t, e, s) {
+  const n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map();
+  for (const o of t)
+    i.set(o.id, o), c.set(o.id, y(o.start, o.end)), n.set(o.id, []);
+  for (let o = 0; o < e.length; o++) {
+    const r = e[o], a = i.get(r.fromLineId), l = i.get(r.toLineId);
+    if (!a || !l) continue;
+    const f = E(a, r.fromOffset, r.fromIsPercentage, 1, s.maxWheelbase), g = W(l, r.toOffset, r.toIsPercentage, 0, s.maxWheelbase), d = q(
+      a,
+      l,
+      s,
+      !1,
+      // willFlip is always false now
+      {
+        fromOffset: f,
+        fromIsPercentage: !1,
+        // Already resolved to absolute
+        toOffset: g,
+        toIsPercentage: !1
+        // Already resolved to absolute
+      }
+    ), h = G(d), p = {
+      curveIndex: o,
+      fromLineId: r.fromLineId,
+      toLineId: r.toLineId,
+      fromOffset: f,
+      toOffset: g,
+      curveLength: h
+    };
+    n.get(r.fromLineId).push(p);
+  }
+  return { adjacency: n, lines: i, lineLengths: c };
+}
+function z(t, e) {
+  return t.curveCount !== e.curveCount ? t.curveCount - e.curveCount : t.totalDistance - e.totalDistance;
+}
+function Q(t, e, s, n, i = !1) {
+  const { adjacency: c, lines: o, lineLengths: r } = t;
+  if (!o.get(s)) return null;
+  const l = r.get(s), f = i ? n / 100 * l : n, g = [], d = /* @__PURE__ */ new Map(), h = (u, v) => `${u}:${Math.round(v)}`;
+  if (e.lineId === s && f >= e.offset) {
+    const u = f - e.offset;
+    return {
+      segments: [{
+        type: "line",
+        lineId: e.lineId,
+        startOffset: e.offset,
+        endOffset: f,
+        length: u
+      }],
+      totalDistance: u,
+      curveCount: 0
+    };
+  }
+  const p = c.get(e.lineId) || [];
+  for (const u of p) {
+    if (u.fromOffset < e.offset) continue;
+    const v = u.fromOffset - e.offset, x = v + u.curveLength, L = {
+      type: "line",
+      lineId: e.lineId,
+      startOffset: e.offset,
+      endOffset: u.fromOffset,
+      length: v
+    }, m = {
+      type: "curve",
+      curveIndex: u.curveIndex,
+      startOffset: 0,
+      endOffset: u.curveLength,
+      length: u.curveLength
+    };
+    g.push({
+      lineId: u.toLineId,
+      entryOffset: u.toOffset,
+      totalDistance: x,
+      curveCount: 1,
+      path: [L, m]
+    });
+  }
+  for (g.sort(z); g.length > 0; ) {
+    const u = g.shift(), v = h(u.lineId, u.entryOffset), x = d.get(v);
+    if (x !== void 0 && (x.curveCount < u.curveCount || x.curveCount === u.curveCount && x.distance <= u.totalDistance))
+      continue;
+    if (d.set(v, { curveCount: u.curveCount, distance: u.totalDistance }), u.lineId === s) {
+      const m = Math.abs(f - u.entryOffset);
+      if (f >= u.entryOffset) {
+        const C = {
+          type: "line",
+          lineId: s,
+          startOffset: u.entryOffset,
+          endOffset: f,
+          length: m
+        };
+        return {
+          segments: [...u.path, C],
+          totalDistance: u.totalDistance + m,
+          curveCount: u.curveCount
+        };
+      }
+    }
+    const L = c.get(u.lineId) || [];
+    for (const m of L) {
+      if (m.fromOffset < u.entryOffset) continue;
+      const C = m.fromOffset - u.entryOffset, b = u.totalDistance + C + m.curveLength, P = u.curveCount + 1, B = h(m.toLineId, m.toOffset), D = d.get(B);
+      if (D !== void 0 && (D.curveCount < P || D.curveCount === P && D.distance <= b))
+        continue;
+      const j = {
+        type: "line",
+        lineId: u.lineId,
+        startOffset: u.entryOffset,
+        endOffset: m.fromOffset,
+        length: C
+      }, $ = {
+        type: "curve",
+        curveIndex: m.curveIndex,
+        startOffset: 0,
+        endOffset: m.curveLength,
+        length: m.curveLength
+      };
+      g.push({
+        lineId: m.toLineId,
+        entryOffset: m.toOffset,
+        totalDistance: b,
+        curveCount: P,
+        path: [...u.path, j, $]
+      });
+    }
+    g.sort(z);
+  }
+  return null;
+}
+function A(t, e) {
+  const s = Math.sqrt(
+    Math.pow(t.end.x - t.start.x, 2) + Math.pow(t.end.y - t.start.y, 2)
+  ), n = s > 0 ? e / s : 0;
+  return {
+    x: t.start.x + (t.end.x - t.start.x) * Math.min(1, Math.max(0, n)),
+    y: t.start.y + (t.end.y - t.start.y) * Math.min(1, Math.max(0, n))
+  };
+}
+function O(t) {
+  return Math.sqrt(
+    Math.pow(t.end.x - t.start.x, 2) + Math.pow(t.end.y - t.start.y, 2)
+  );
+}
+function R(t, e, s) {
+  let n = 0;
+  for (let i = 0; i < e; i++)
+    n += t.segments[i].length;
+  return n += s, n;
+}
+function _(t, e) {
+  let s = 0;
+  for (let n = 0; n < t.segments.length; n++) {
+    const i = t.segments[n], c = s + i.length;
+    if (e < c)
+      return {
+        segmentIndex: n,
+        segmentDistance: e - s
+      };
+    if (e === c)
+      return n + 1 < t.segments.length ? {
+        segmentIndex: n + 1,
+        segmentDistance: 0
+      } : {
+        segmentIndex: n,
+        segmentDistance: i.length
+      };
+    s += i.length;
+  }
+  return null;
+}
+function ie(t, e, s, n) {
+  const c = R(
+    t,
+    e,
+    s
+  ) + n;
+  return _(t, c);
+}
+function H(t, e, s, n) {
+  const i = O(n), c = s.length + 1, o = new Array(c);
+  o[c - 1] = {
+    lineId: t,
+    absoluteOffset: e,
+    position: A(n, e)
+  };
+  let r = e;
+  for (let a = c - 2; a >= 0; a--)
+    r = Math.min(r + s[a], i), o[a] = {
+      lineId: t,
+      absoluteOffset: r,
+      position: A(n, r)
+    };
+  return o;
+}
+function J(t, e) {
+  return {
+    ...t,
+    state: "idle"
+  };
+}
+function U(t) {
+  return {
+    vehicle: t,
+    execution: null
+  };
+}
+function re(t, e) {
+  const s = [], n = /* @__PURE__ */ new Map();
+  for (const i of t) {
+    if (!e.get(i.lineId)) continue;
+    const o = J(i);
+    s.push(o);
+    const r = U(o);
+    n.set(i.id, r);
+  }
+  return { movingVehicles: s, stateMap: n };
+}
+function M(t, e) {
+  return { position: A(t, e), lineId: t.id, absoluteOffset: e };
+}
+function S(t, e) {
+  const s = F(t.arcLengthTable, e);
+  return { position: T(t.bezier, s) };
+}
+function X(t, e, s, n, i, c, o) {
+  const r = s.segments[e.currentSegmentIndex], a = e.segmentDistance + n;
+  if (a >= r.length) {
+    const f = a - r.length, g = e.currentSegmentIndex + 1;
+    if (g >= s.segments.length) {
+      if (o !== void 0 && r.type === "line") {
+        const u = i.get(r.lineId), v = r.startOffset + a;
+        if (v <= o) {
+          const L = M(u, v);
+          return {
+            axleState: { ...t, ...L },
+            execution: { ...e, segmentDistance: a },
+            completed: !1
+          };
+        }
+        const x = M(u, o);
+        return {
+          axleState: { ...t, ...x },
+          execution: { ...e, segmentDistance: o - r.startOffset },
+          completed: !0
+        };
+      }
+      const p = r.type === "line" ? M(
+        i.get(r.lineId),
+        r.endOffset
+      ) : S(
+        c.get(r.curveIndex),
+        r.length
+      );
+      return {
+        axleState: { ...t, ...p },
+        execution: { ...e, segmentDistance: r.length },
+        completed: !0
+      };
+    }
+    const d = s.segments[g], h = d.type === "line" ? M(
+      i.get(d.lineId),
+      d.startOffset + f
+    ) : S(
+      c.get(d.curveIndex),
+      f
+    );
+    return {
+      axleState: { ...t, ...h },
+      execution: {
+        currentSegmentIndex: g,
+        segmentDistance: f
+      },
+      completed: !1
+    };
+  }
+  const l = r.type === "line" ? M(
+    i.get(r.lineId),
+    r.startOffset + a
+  ) : S(
+    c.get(r.curveIndex),
+    a
+  );
+  return {
+    axleState: { ...t, ...l },
+    execution: { ...e, segmentDistance: a },
+    completed: !1
+  };
+}
+function Y(t, e, s, n) {
+  const i = /* @__PURE__ */ new Map();
+  for (const c of t.segments)
+    if (c.type === "curve" && c.curveIndex !== void 0) {
+      const o = e[c.curveIndex];
+      if (o) {
+        const r = s.get(o.fromLineId), a = s.get(o.toLineId);
+        if (r && a) {
+          const l = E(
+            r,
+            o.fromOffset,
+            o.fromIsPercentage,
+            1,
+            // Default: 100% = 1.0
+            n.maxWheelbase
+          ), f = W(
+            a,
+            o.toOffset,
+            o.toIsPercentage,
+            0,
+            n.maxWheelbase
+          ), g = q(
+            r,
+            a,
+            n,
+            !1,
+            // willFlip is always false now
+            {
+              fromOffset: l,
+              fromIsPercentage: !1,
+              // Already resolved to absolute
+              toOffset: f,
+              toIsPercentage: !1
+              // Already resolved to absolute
+            }
+          ), d = N(g);
+          i.set(c.curveIndex, { bezier: g, arcLengthTable: d });
+        }
+      }
+    }
+  return i;
+}
+function Z(t, e, s) {
+  const { graph: n, linesMap: i, curves: c, config: o } = s, r = i.get(e.targetLineId);
+  if (!r) return null;
+  const a = t.axleSpacings.reduce((u, v) => u + v, 0), f = O(r) - a;
+  if (f <= 0) return null;
+  const g = e.isPercentage ? e.targetOffset * f : Math.min(e.targetOffset, f), d = t.axles[t.axles.length - 1], h = Q(
+    n,
+    { lineId: d.lineId, offset: d.absoluteOffset },
+    e.targetLineId,
+    g,
+    !1
+  );
+  if (!h) return null;
+  const p = Y(h, c, i, o);
+  return { path: h, curveDataMap: p };
+}
+function oe(t, e) {
+  const s = t.execution, i = e.vehicleQueues.get(t.vehicle.id)?.[s.currentCommandIndex];
+  return i && e.onCommandComplete && e.onCommandComplete({
+    vehicleId: t.vehicle.id,
+    command: i,
+    finalPosition: {
+      lineId: t.vehicle.axles[t.vehicle.axles.length - 1].lineId,
+      absoluteOffset: t.vehicle.axles[t.vehicle.axles.length - 1].absoluteOffset,
+      position: t.vehicle.axles[t.vehicle.axles.length - 1].position
+    },
+    payload: i.payload
+  }), {
+    handled: !0,
+    vehicle: { ...t.vehicle, state: "waiting" },
+    newExecution: s,
+    // Keep execution state for resume
+    isWaiting: !0
+  };
+}
+function ee(t, e, s, n, i, c) {
+  let o;
+  const r = e[0];
+  if (r.currentSegmentIndex < s.segments.length) {
+    const l = s.segments[r.currentSegmentIndex];
+    if (l.type === "line") {
+      const f = i.get(l.lineId);
+      f && (o = O(f));
+    }
+  }
+  const a = t.map((l, f) => {
+    const g = f === 0 ? o : void 0;
+    return X(l, e[f], s, n, i, c, g);
+  });
+  return {
+    axles: a.map((l) => l.axleState),
+    axleExecutions: a.map((l) => l.execution),
+    arrived: a[0].completed
+    // axles[0] = terdepan menentukan arrived
+  };
+}
+class ce {
+  graph = null;
+  linesMap = /* @__PURE__ */ new Map();
+  curves = [];
+  config;
+  constructor(e) {
+    this.config = {
+      maxWheelbase: e.maxWheelbase,
+      tangentMode: e.tangentMode
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Accessors
+  // ---------------------------------------------------------------------------
+  get movementConfig() {
+    return this.config;
+  }
+  get lines() {
+    return Array.from(this.linesMap.values());
+  }
+  getCurves() {
+    return this.curves;
+  }
+  // ---------------------------------------------------------------------------
+  // Scene management
+  // ---------------------------------------------------------------------------
+  /**
+   * Replace the entire scene and rebuild the graph.
+   */
+  setScene(e, s) {
+    this.linesMap.clear();
+    for (const n of e)
+      this.linesMap.set(n.id, n);
+    this.curves = s, this.graph = I(e, s, this.config);
+  }
+  /**
+   * Add a single line. Returns false if a line with the same ID already exists.
+   */
+  addLine(e) {
+    return this.linesMap.has(e.id) ? !1 : (this.linesMap.set(e.id, e), this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config), !0);
+  }
+  /**
+   * Update start and/or end coordinates of an existing line.
+   */
+  updateLine(e, s) {
+    const n = this.linesMap.get(e);
+    return n ? (s.start && (n.start = s.start), s.end && (n.end = s.end), this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config), !0) : !1;
+  }
+  /**
+   * Update a single endpoint ('start' or 'end') of a line.
+   */
+  updateLineEndpoint(e, s, n) {
+    return this.updateLine(e, { [s]: n });
+  }
+  /**
+   * Rename a line ID and cascade the change to all connected curves.
+   */
+  renameLine(e, s) {
+    const n = s.trim();
+    if (!n) return { success: !1, error: "Name cannot be empty" };
+    if (n === e) return { success: !0 };
+    if (this.linesMap.has(n)) return { success: !1, error: `"${n}" already exists` };
+    const i = this.linesMap.get(e);
+    if (!i) return { success: !1, error: `Line "${e}" not found` };
+    i.id = n, this.linesMap.delete(e), this.linesMap.set(n, i);
+    for (const c of this.curves)
+      c.fromLineId === e && (c.fromLineId = n), c.toLineId === e && (c.toLineId = n);
+    return this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config), { success: !0 };
+  }
+  /**
+   * Remove a line and all curves connected to it.
+   */
+  removeLine(e) {
+    return this.linesMap.has(e) ? (this.linesMap.delete(e), this.curves = this.curves.filter((s) => s.fromLineId !== e && s.toLineId !== e), this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config), !0) : !1;
+  }
+  /**
+   * Add a directional curve (connection) from one line to another.
+   */
+  addCurve(e) {
+    this.curves.push(e), this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config);
+  }
+  /**
+   * Update a curve by index. Returns false if index is out of bounds.
+   */
+  updateCurve(e, s) {
+    return e < 0 || e >= this.curves.length ? !1 : (this.curves[e] = { ...this.curves[e], ...s }, this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config), !0);
+  }
+  /**
+   * Remove a curve by index. Returns false if index is out of bounds.
+   */
+  removeCurve(e) {
+    return e < 0 || e >= this.curves.length ? !1 : (this.curves.splice(e, 1), this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config), !0);
+  }
+  // ---------------------------------------------------------------------------
+  // Vehicle operations
+  // ---------------------------------------------------------------------------
+  /**
+   * Initialize a vehicle's N-axle position on a line.
+   *
+   * @param lineId - The line to place the vehicle on
+   * @param rearOffset - Absolute distance offset untuk axle paling belakang
+   * @param axleSpacings - Jarak antar axle berurutan (N-1 nilai untuk N axle)
+   * @returns Initial VehiclePathState, or null if lineId does not exist
+   */
+  initializeVehicle(e, s, n) {
+    const i = this.linesMap.get(e);
+    if (!i) return null;
+    const c = n.reduce((l, f) => l + f, 0), o = O(i), r = Math.min(s, o - c);
+    return {
+      axles: H(e, r, n, i).map((l) => ({ lineId: l.lineId, offset: l.absoluteOffset, position: l.position })),
+      axleSpacings: n
+    };
+  }
+  /**
+   * Prepare a path from the vehicle's current position to a target.
+   *
+   * Must be called before moveVehicle(). Returns null if no path exists.
+   *
+   * @param vehicleState - Current vehicle state (from initializeVehicle or previous tick)
+   * @param targetLineId - ID of the target line
+   * @param targetOffset - Position on the target line
+   * @param isPercentage - If true, targetOffset is 0-1 fraction; if false, absolute distance
+   */
+  preparePath(e, s, n, i = !1) {
+    if (!this.graph) return null;
+    const c = e.axleSpacings.reduce((h, p) => h + p, 0), o = e.axles[e.axles.length - 1], r = {
+      lineId: o.lineId,
+      offset: o.offset,
+      axles: e.axles.map((h) => ({
+        lineId: h.lineId,
+        position: h.position,
+        absoluteOffset: h.offset
+      })),
+      axleSpacings: e.axleSpacings
+    }, a = Z(r, {
+      targetLineId: s,
+      targetOffset: n,
+      isPercentage: i
+    }, {
+      graph: this.graph,
+      linesMap: this.linesMap,
+      curves: this.curves,
+      config: this.config
+    });
+    if (!a) return null;
+    let l = n;
+    const f = this.linesMap.get(s);
+    if (f) {
+      const h = Math.max(0, O(f) - c);
+      l = i ? n * h : Math.min(n, h);
+    }
+    let g = 0;
+    const d = [
+      { segmentIndex: 0, segmentDistance: c }
+      // axles[0] = front
+    ];
+    for (let h = 0; h < e.axleSpacings.length; h++)
+      g += e.axleSpacings[h], d.push({ segmentIndex: 0, segmentDistance: c - g });
+    return {
+      path: a.path,
+      curveDataMap: a.curveDataMap,
+      axleExecutions: d,
+      targetLineId: s,
+      targetOffset: l
+    };
+  }
+  /**
+   * Advance a vehicle by `distance` along its prepared path.
+   *
+   * Call this every tick. The returned `state` and `execution` replace the
+   * previous values. When `arrived` is true, the vehicle has reached the target.
+   *
+   * @param state - Current vehicle state
+   * @param execution - Current path execution (from preparePath or previous tick)
+   * @param distance - Distance to advance this tick (speed × deltaTime)
+   */
+  moveVehicle(e, s, n) {
+    const i = e.axles.map((r) => ({
+      lineId: r.lineId,
+      position: r.position,
+      absoluteOffset: r.offset
+    })), c = s.axleExecutions.map((r) => ({
+      currentSegmentIndex: r.segmentIndex,
+      segmentDistance: r.segmentDistance
+    })), o = ee(i, c, s.path, n, this.linesMap, s.curveDataMap);
+    return {
+      state: {
+        axles: o.axles.map((r) => ({ lineId: r.lineId, offset: r.absoluteOffset, position: r.position })),
+        axleSpacings: e.axleSpacings
+      },
+      execution: {
+        ...s,
+        axleExecutions: o.axleExecutions.map((r) => ({
+          segmentIndex: r.currentSegmentIndex,
+          segmentDistance: r.segmentDistance
+        }))
+      },
+      arrived: o.arrived
+    };
+  }
+}
+export {
+  w as A,
+  Z as B,
+  E as C,
+  W as D,
+  X as E,
+  ce as P,
+  _ as a,
+  N as b,
+  I as c,
+  G as d,
+  ie as e,
+  H as f,
+  S as g,
+  M as h,
+  k as i,
+  q as j,
+  U as k,
+  y as l,
+  F as m,
+  Q as n,
+  se as o,
+  R as p,
+  O as q,
+  T as r,
+  K as s,
+  V as t,
+  A as u,
+  oe as v,
+  re as w,
+  J as x,
+  ne as y,
+  ee as z
+};