ranuts 0.4.1-alpha.2 → 0.5.1

package/dist/src/utils/visual/shape/rectangle.d.ts

@@ -1,6 +1,6 @@
-import { Shape } from '@/utils/visual/shape/shape';
-import { SHAPE_TYPE } from '@/utils/visual/enums';
-import type { Point } from '@/utils/visual/vertex/point';
+import { Shape } from "./shape.js";
+import { SHAPE_TYPE } from "../enums.js";
+import type { Point } from "../vertex/point.js";
 export declare class Rectangle extends Shape {
     x: number;
     y: number;

package/dist/src/utils/visual/shape/rectangle.js

@@ -0,0 +1,18 @@
+import { SHAPE_TYPE as e } from "../enums.js";
+import { Shape as r } from "./shape.js";
+var n = class extends r {
+  x;
+  y;
+  width;
+  height;
+  type = e.RECTANGLE;
+  constructor(t = 0, h = 0, i = 0, s = 0) {
+    super(), this.x = t, this.y = h, this.width = i, this.height = s;
+  }
+  contains(t) {
+    return t.x > this.x && t.x < this.x + this.width && t.y > this.y && t.y < this.y + this.height;
+  }
+};
+export {
+  n as Rectangle
+};

package/dist/src/utils/visual/shape/roundedRectangle.d.ts

@@ -1,6 +1,6 @@
-import { Shape } from '@/utils/visual/shape/shape';
-import { SHAPE_TYPE } from '@/utils/visual/enums';
-import type { Point } from '@/utils/visual/vertex/point';
+import { Shape } from "./shape.js";
+import { SHAPE_TYPE } from "../enums.js";
+import type { Point } from "../vertex/point.js";
 export declare class RoundedRectangle extends Shape {
     x: number;
     y: number;

package/dist/src/utils/visual/shape/roundedRectangle.js

@@ -0,0 +1,32 @@
+import { SHAPE_TYPE as y } from "../enums.js";
+import { Shape as n } from "./shape.js";
+var o = class extends n {
+  x;
+  y;
+  width;
+  height;
+  radius;
+  type = y.ROUNDED_RECTANGLE;
+  constructor(t = 0, e = 0, s = 0, i = 0, h = 20) {
+    super(), this.x = t, this.y = e, this.width = s, this.height = i;
+    const r = Math.min(s, i) / 2;
+    this.radius = h > r ? r : h;
+  }
+  contains(t) {
+    if (!(t.x > this.x && t.x < this.x + this.width && t.y > this.y && t.y < this.y + this.height)) return !1;
+    const e = this.x + this.radius, s = this.y + this.radius;
+    if (t.x < e && t.y < s)
+      return (t.x - e) * (t.x - e) + (t.y - s) * (t.y - s) < this.radius * this.radius;
+    const i = this.x + this.radius, h = this.y + this.height - this.radius;
+    if (t.x < i && t.y > h)
+      return (t.x - i) * (t.x - i) + (t.y - h) * (t.y - h) < this.radius * this.radius;
+    const r = this.x + this.width - this.radius, u = this.y + this.radius;
+    if (t.x > r && t.y < u)
+      return (t.x - r) * (t.x - r) + (t.y - u) * (t.y - u) < this.radius * this.radius;
+    const a = this.x + this.width - this.radius, x = this.y + this.height - this.radius;
+    return t.x > a && t.y < x ? (t.x - a) * (t.x - a) + (t.y - x) * (t.y - x) < this.radius * this.radius : !0;
+  }
+};
+export {
+  o as RoundedRectangle
+};

package/dist/src/utils/visual/shape/shape.d.ts

@@ -1,5 +1,5 @@
-import type { SHAPE_TYPE } from '@/utils/visual/enums';
-import type { Point } from '@/utils/visual/vertex/point';
+import type { SHAPE_TYPE } from "../enums.js";
+import type { Point } from "../vertex/point.js";
 export declare abstract class Shape {
     abstract type: SHAPE_TYPE;
     abstract contains(point: Point): boolean;

package/dist/src/utils/visual/shape/shape.js

@@ -0,0 +1,5 @@
+var a = class {
+};
+export {
+  a as Shape
+};

package/dist/src/utils/visual/style/fill.js

@@ -0,0 +1,18 @@
+var i = class s {
+  color = "#ffffff";
+  alpha = 1;
+  visible = !1;
+  constructor() {
+    this.reset();
+  }
+  clone() {
+    const l = new s();
+    return l.color = this.color, l.alpha = this.alpha, l.visible = this.visible, l;
+  }
+  reset() {
+    this.color = "#ffffff", this.alpha = 1, this.visible = !1;
+  }
+};
+export {
+  i as Fill
+};

package/dist/src/utils/visual/style/index.d.ts

@@ -1,3 +1,3 @@
-import { Fill } from '@/utils/visual/style/fill';
-import { Line } from '@/utils/visual/style/line';
+import { Fill } from "./fill.js";
+import { Line } from "./line.js";
 export { Fill, Line };

package/dist/src/utils/visual/style/line.d.ts

@@ -1,5 +1,5 @@
-import { LINE_CAP, LINE_JOIN } from '@/utils/visual/enums';
-import { Fill } from '@/utils/visual/style/fill';
+import { LINE_CAP, LINE_JOIN } from "../enums.js";
+import { Fill } from "./fill.js";
 export declare class Line extends Fill {
     width: number;
     cap: LINE_CAP;

package/dist/src/utils/visual/style/line.js

@@ -0,0 +1,18 @@
+import { LINE_CAP as t, LINE_JOIN as s } from "../enums.js";
+import { Fill as h } from "./fill.js";
+var m = class e extends h {
+  width = 0;
+  cap = t.BUTT;
+  join = s.MITER;
+  miterLimit = 10;
+  clone() {
+    const i = new e();
+    return i.color = this.color, i.alpha = this.alpha, i.visible = this.visible, i.width = this.width, i.cap = this.cap, i.join = this.join, i.miterLimit = this.miterLimit, i;
+  }
+  reset() {
+    super.reset(), this.color = "#ffffff", this.width = 0, this.cap = t.BUTT, this.join = s.MITER, this.miterLimit = 10;
+  }
+};
+export {
+  m as Line
+};

package/dist/src/utils/visual/types.d.ts

@@ -1,4 +1,4 @@
-import type { LINE_CAP, LINE_JOIN, RENDERER_TYPE } from '@/utils/visual/enums';
+import type { LINE_CAP, LINE_JOIN, RENDERER_TYPE } from "./enums.js";
 export interface IApplicationOptions {
     prefer?: RENDERER_TYPE.CANVAS | RENDERER_TYPE.WEB_GL | RENDERER_TYPE.WEB_GPU;
     view?: HTMLCanvasElement;

package/dist/src/utils/visual/vertex/container.d.ts

@@ -1,8 +1,8 @@
-import { Vertex } from '@/utils/visual/vertex/vertex';
-import type { CanvasRenderer } from '@/utils/visual/render/canvasRenderer';
-import type { Point } from '@/utils/visual/vertex/point';
-import type { BatchRenderer } from '@/utils/visual/render/batchRenderer';
-import type { Batch } from '@/utils/visual/render/utils/batch/index';
+import { Vertex } from "./vertex.js";
+import type { CanvasRenderer } from "../render/canvasRenderer.js";
+import type { Point } from "./point.js";
+import type { BatchRenderer } from "../render/batchRenderer.js";
+import type { Batch } from "../render/utils/batch/index.js";
 export declare class Container extends Vertex {
     isSort: boolean;
     type: string;

package/dist/src/utils/visual/vertex/container.js

@@ -0,0 +1,54 @@
+import { CONTAINER as e } from "../enums.js";
+import { Transform as i } from "../math/transform.js";
+import { Vertex as s } from "./vertex.js";
+var o = class extends s {
+  isSort = !1;
+  type = e;
+  children = [];
+  worldId = 0;
+  batches = [];
+  batchCount = 0;
+  structureVersion = 0;
+  constructor() {
+    super();
+  }
+  markStructureDirty = () => {
+    let r = this.parent ?? this;
+    for (; r.parent; ) r = r.parent;
+    r.structureVersion++;
+  };
+  addChild = (r) => {
+    r.parent?.removeChild(r), this.children.push(r), r.parent = this, this.isSort = !0, this.markStructureDirty();
+  };
+  removeChild = (r) => {
+    for (let t = 0; t < this.children.length; t++) if (this.children[t] === r) {
+      this.children.splice(t, 1), r.parent = void 0, this.markStructureDirty();
+      return;
+    }
+  };
+  sortChildren = () => {
+    this.isSort && (this.children.sort((r, t) => r.zIndex - t.zIndex), this.isSort = !1);
+  };
+  renderCanvas(r) {
+  }
+  renderCanvasRecursive = (r) => {
+    if (!(this.worldAlpha <= 0 || !this.visible)) {
+      this.renderCanvas(r);
+      for (let t = 0; t < this.children.length; t++) this.children[t].renderCanvasRecursive(r);
+    }
+  };
+  updateTransform = () => {
+    this.sortChildren();
+    const r = this.parent?.transform || new i();
+    if (this.transform.updateTransform(r), this.worldAlpha = (this.parent?.worldAlpha || 1) * this.alpha, !(this.worldAlpha <= 0 || !this.visible))
+      for (let t = 0; t < this.children.length; t++) this.children[t].updateTransform();
+  };
+  containsPoint = (r) => this.hitArea ? this.hitArea.contains(r) : !1;
+  buildBatches(r) {
+  }
+  updateBatches(r) {
+  }
+};
+export {
+  o as Container
+};

package/dist/src/utils/visual/vertex/point.js

@@ -0,0 +1,37 @@
+var _ = class h {
+  x;
+  y;
+  constructor(s = 0, i = 0) {
+    this.x = s, this.y = i;
+  }
+  set(s = 0, i = s) {
+    this.x = s, this.y = i;
+  }
+  clone = () => new h(this.x, this.y);
+}, y = class {
+  _x;
+  _y;
+  cb;
+  constructor(t, s = 0, i = 0) {
+    this._x = s, this._y = i, this.cb = t;
+  }
+  set(t = 0, s = t) {
+    this._x = t, this._y = s, this.cb(this._x, this._y);
+  }
+  get x() {
+    return this._x;
+  }
+  set x(t) {
+    this._x !== t && (this._x = t, this.cb(this._x, this._y));
+  }
+  get y() {
+    return this._y;
+  }
+  set y(t) {
+    this._y !== t && (this._y = t, this.cb(this._x, this._y));
+  }
+};
+export {
+  y as ObservablePoint,
+  _ as Point
+};

package/dist/src/utils/visual/vertex/vertex.d.ts

@@ -1,10 +1,10 @@
-import { SyncHook } from '@/utils/subscribe';
-import { Transform } from '@/utils/visual/math/transform';
-import type { Container } from '@/utils/visual/vertex/container';
-import type { ObservablePoint } from '@/utils/visual/vertex/point';
-import type { Matrix } from '@/utils/visual/math/matrix';
-import type { Cursor, FederatedEventMap } from '@/utils/visual/event';
-import type { Shape } from '@/utils/visual/shape';
+import { SyncHook } from "../../subscribe.js";
+import { Transform } from "../math/transform.js";
+import type { Container } from "./container.js";
+import type { ObservablePoint } from "./point.js";
+import type { Matrix } from "../math/matrix.js";
+import type { Cursor, FederatedEventMap } from "../event/index.js";
+import type { Shape } from "../shape/index.js";
 export declare abstract class Vertex extends SyncHook {
     protected _zIndex: number;
     parent: Container | undefined;

package/dist/src/utils/visual/vertex/vertex.js

@@ -0,0 +1,76 @@
+import { SyncHook as n } from "../../subscribe.js";
+import { DEG_TO_RAD as a, RAD_TO_DEG as i } from "../math/enums.js";
+import { Transform as s } from "../math/transform.js";
+var p = class extends n {
+  _zIndex = 0;
+  parent = void 0;
+  visible = !0;
+  transform = new s();
+  alpha = 1;
+  worldAlpha = 1;
+  hitArea = null;
+  cursor = "auto";
+  get zIndex() {
+    return this._zIndex;
+  }
+  set zIndex(t) {
+    this._zIndex = t, this.parent && (this.parent.isSort = !0);
+  }
+  get position() {
+    return this.transform.position;
+  }
+  get localTransform() {
+    return this.transform.localTransform;
+  }
+  get worldTransform() {
+    return this.transform.worldTransform;
+  }
+  get x() {
+    return this.position.x;
+  }
+  set x(t) {
+    this.transform.position.x = t;
+  }
+  get y() {
+    return this.position.y;
+  }
+  set y(t) {
+    this.transform.position.y = t;
+  }
+  get scale() {
+    return this.transform.scale;
+  }
+  get pivot() {
+    return this.transform.pivot;
+  }
+  get skew() {
+    return this.transform.skew;
+  }
+  get rotation() {
+    return this.transform.rotation;
+  }
+  set rotation(t) {
+    this.transform.rotation = t;
+  }
+  get angle() {
+    return this.transform.rotation * i;
+  }
+  set angle(t) {
+    this.transform.rotation = t * a;
+  }
+  updateTransform() {
+    const t = this.parent?.transform || new s();
+    this.transform.updateTransform(t), this.worldAlpha = this.alpha * (this.parent?.worldAlpha || 1);
+  }
+  addEventListener = (t, e, r) => {
+    const o = typeof r == "boolean" && r || typeof r == "object" && r.capture ? `${t}capture` : t;
+    typeof r == "object" && r.once ? this.once(o, e) : this.tap(o, e);
+  };
+  removeEventListener = (t, e, r) => {
+    const o = r ? `${t}capture` : t;
+    this.off(o, e);
+  };
+};
+export {
+  p as Vertex
+};

package/dist/src/utils/worker.js

@@ -0,0 +1,89 @@
+var c = class {
+  worker = null;
+  nextOperationId = 1;
+  pending = /* @__PURE__ */ new Map();
+  options;
+  constructor(e) {
+    this.options = e;
+  }
+  get active() {
+    return this.worker !== null;
+  }
+  get pendingCount() {
+    return this.pending.size;
+  }
+  send = (e, t, r) => {
+    const n = this.nextOperationId++;
+    return new Promise((a, i) => {
+      const o = {
+        resolve: a,
+        reject: i,
+        onProgress: t
+      };
+      this.options.timeout && (o.timer = setTimeout(() => {
+        this.pending.delete(n), i(/* @__PURE__ */ new Error(`worker request timed out after ${this.options.timeout}ms`));
+      }, this.options.timeout)), this.pending.set(n, o);
+      try {
+        this.getWorker().postMessage({
+          ...e,
+          operationId: n
+        }, r ?? []);
+      } catch (g) {
+        this.settle(n), i(g instanceof Error ? g : new Error(String(g)));
+      }
+    });
+  };
+  dispose = () => {
+    this.worker?.terminate(), this.worker = null, this.rejectAll(/* @__PURE__ */ new Error("worker disposed"));
+  };
+  getWorker = () => (this.worker || (this.worker = this.options.create(), this.worker.onmessage = (e) => this.handleMessage(e.data), this.worker.onerror = (e) => this.rejectAll(new Error(e.message || "worker crashed"))), this.worker);
+  settle = (e) => {
+    const t = this.pending.get(e);
+    return t?.timer && clearTimeout(t.timer), this.pending.delete(e), t;
+  };
+  handleMessage = (e) => {
+    const t = this.pending.get(e.operationId);
+    if (!t) return;
+    const { isProgress: r, getProgress: n, isError: a, getErrorMessage: i } = this.options;
+    if (r ? r(e) : e.type === "progress") {
+      const o = n ? n(e) : e.progress;
+      t.onProgress?.(o);
+      return;
+    }
+    if (this.settle(e.operationId), a ? a(e) : e.type === "error") {
+      const o = i ? i(e) : e.message;
+      t.reject(new Error(o || "worker error"));
+    } else t.resolve(e);
+  };
+  rejectAll = (e) => {
+    for (const [t, r] of this.pending)
+      r.timer && clearTimeout(r.timer), r.reject(e), this.pending.delete(t);
+  };
+}, d = (e, t = {}) => {
+  const r = t.scope ?? globalThis;
+  if (!r || typeof r.addEventListener != "function") return () => {
+  };
+  const n = t.resultType ?? "result", a = (i) => {
+    const o = i.data;
+    if (!o || typeof o.operationId != "number") return;
+    const { operationId: g } = o, p = (s) => r.postMessage({
+      ...s,
+      operationId: g
+    }), h = { progress: (s) => p({
+      type: "progress",
+      progress: s
+    }) };
+    Promise.resolve().then(() => e(o, h)).then((s) => p(typeof s == "object" && s !== null ? s : {
+      type: n,
+      result: s
+    }), (s) => p({
+      type: "error",
+      message: s instanceof Error ? s.message : String(s)
+    }));
+  };
+  return r.addEventListener("message", a), () => r.removeEventListener("message", a);
+};
+export {
+  c as WorkerClient,
+  d as serveWorker
+};

package/dist/src/utils/zip.js

@@ -0,0 +1,161 @@
+var H = 67324752, I = 33639248, B = 101010256, A = 30, S = 46, O = 22, z = 65558, G = 0, M = 8, U = (t, e) => t[e] | t[e + 1] << 8, v = (t, e) => (t[e] | t[e + 1] << 8 | t[e + 2] << 16 | t[e + 3] << 24) >>> 0, V = /* @__PURE__ */ (() => {
+  const t = /* @__PURE__ */ new Uint32Array(256);
+  for (let e = 0; e < 256; e++) {
+    let n = e;
+    for (let c = 0; c < 8; c++) n = n & 1 ? 3988292384 ^ n >>> 1 : n >>> 1;
+    t[e] = n;
+  }
+  return t;
+})(), T = (t) => {
+  let e = 4294967295;
+  for (let n = 0; n < t.length; n++) e = (V[(e ^ t[n]) & 255] ?? 0) ^ e >>> 8;
+  return (e ^ 4294967295) >>> 0;
+}, N = async (t) => {
+  if (typeof DecompressionStream > "u") throw new Error("DecompressionStream is not available in this runtime");
+  const e = new DecompressionStream("deflate-raw"), n = e.writable.getWriter(), c = e.readable.getReader();
+  n.write(t), n.close();
+  const o = [];
+  for (; ; ) {
+    const { done: l, value: s } = await c.read();
+    if (l) break;
+    s && o.push(s);
+  }
+  return Z(o);
+}, Z = (t) => {
+  let e = 0;
+  for (const o of t) e += o.length;
+  const n = new Uint8Array(e);
+  let c = 0;
+  for (const o of t)
+    n.set(o, c), c += o.length;
+  return n;
+}, j = (t) => {
+  const e = Math.max(0, t.length - z);
+  for (let n = t.length - O; n >= e; n--) if (v(t, n) === B) return n;
+  return -1;
+}, k = (t) => {
+  const e = j(t);
+  if (e === -1) return [];
+  const n = U(t, e + 10), c = [];
+  let o = v(t, e + 16);
+  for (let l = 0; l < n && !(o + S > t.length || v(t, o) !== I); l++) {
+    const s = U(t, o + 10), i = U(t, o + 12), f = U(t, o + 14), g = v(t, o + 16), h = v(t, o + 20), E = v(t, o + 24), D = U(t, o + 28), L = U(t, o + 30), _ = U(t, o + 32), m = v(t, o + 42), r = t.slice(o + S, o + S + D), a = new TextDecoder("utf-8", { fatal: !1 }).decode(r), d = m + A <= t.length, u = d ? U(t, m + 26) : 0, w = d ? U(t, m + 28) : 0, p = o;
+    o += S + D + L + _, c.push({
+      name: a,
+      compression: s,
+      crc: g,
+      compressedSize: h,
+      uncompressedSize: E,
+      modTime: i,
+      modDate: f,
+      directory: a.endsWith("/"),
+      dataStart: m + A + u + w,
+      nameBytes: r,
+      localOffset: m,
+      centralStart: p,
+      centralEnd: o
+    });
+  }
+  return c;
+}, P = (t, e) => k(t).some((n) => n.name === e), y = async (t, e) => {
+  const n = typeof e == "string" ? k(t).find((o) => o.name === e) : e;
+  if (!n || n.directory || n.dataStart + n.compressedSize > t.length) return null;
+  const c = t.slice(n.dataStart, n.dataStart + n.compressedSize);
+  if (n.compression === 0) return c;
+  if (n.compression !== 8) return null;
+  try {
+    return await N(c);
+  } catch {
+    return null;
+  }
+}, R = (t, e, n, c = 0, o = 0) => {
+  const l = new Uint8Array(A + t.length), s = new DataView(l.buffer);
+  return s.setUint32(0, H, !0), s.setUint16(4, 20, !0), s.setUint16(6, 0, !0), s.setUint16(8, 0, !0), s.setUint16(10, c, !0), s.setUint16(12, o, !0), s.setUint32(14, n, !0), s.setUint32(18, e, !0), s.setUint32(22, e, !0), s.setUint16(26, t.length, !0), l.set(t, A), l;
+}, C = (t, e, n, c, o = 0, l = 0) => {
+  const s = new Uint8Array(S + t.length), i = new DataView(s.buffer);
+  return i.setUint32(0, I, !0), i.setUint16(4, 20, !0), i.setUint16(6, 20, !0), i.setUint16(8, 0, !0), i.setUint16(10, 0, !0), i.setUint16(12, o, !0), i.setUint16(14, l, !0), i.setUint32(16, n, !0), i.setUint32(20, e, !0), i.setUint32(24, e, !0), i.setUint16(28, t.length, !0), i.setUint32(42, c, !0), s.set(t, S), s;
+}, x = (t) => typeof t == "string" ? new TextEncoder().encode(t) : t, W = async (t, e = {}) => {
+  const { filter: n, transform: c, inject: o } = e, l = k(t);
+  if (l.length === 0) return t;
+  const s = /* @__PURE__ */ new Map();
+  if (c) {
+    for (const r of l)
+      if (!r.directory && !(n && !n(r)))
+        try {
+          const a = await y(t, r);
+          if (!a) continue;
+          const d = await c(a, r);
+          if (d == null) continue;
+          const u = x(d);
+          if (u.length === a.length && u.every((w, p) => w === a[p])) continue;
+          s.set(r, u);
+        } catch {
+        }
+  }
+  const i = (o ?? []).map(({ name: r, data: a }) => ({
+    nameBytes: new TextEncoder().encode(r),
+    data: x(a)
+  }));
+  if (s.size === 0 && i.length === 0) return t;
+  const f = [], g = [];
+  let h = 0;
+  for (const r of l) {
+    g.push(h);
+    const a = s.get(r);
+    if (a) {
+      const p = R(r.nameBytes, a.length, T(a), r.modTime, r.modDate);
+      f.push(p, a), h += p.length + a.length;
+      continue;
+    }
+    const d = new Uint8Array(A + r.nameBytes.length), u = new DataView(d.buffer);
+    u.setUint32(0, H, !0), u.setUint16(4, 20, !0), u.setUint16(6, 0, !0), u.setUint16(8, r.compression, !0), u.setUint16(10, r.modTime, !0), u.setUint16(12, r.modDate, !0), u.setUint32(14, r.crc, !0), u.setUint32(18, r.compressedSize, !0), u.setUint32(22, r.uncompressedSize, !0), u.setUint16(26, r.nameBytes.length, !0), d.set(r.nameBytes, A);
+    const w = t.slice(r.dataStart, r.dataStart + r.compressedSize);
+    f.push(d, w), h += d.length + w.length;
+  }
+  const E = [];
+  for (const r of i) {
+    E.push(h);
+    const a = R(r.nameBytes, r.data.length, T(r.data));
+    f.push(a, r.data), h += a.length + r.data.length;
+  }
+  const D = h;
+  for (let r = 0; r < l.length; r++) {
+    const a = l[r], d = s.get(a);
+    if (d) {
+      const p = C(a.nameBytes, d.length, T(d), g[r], a.modTime, a.modDate);
+      f.push(p), h += p.length;
+      continue;
+    }
+    const u = new Uint8Array(t.slice(a.centralStart, a.centralEnd)), w = new DataView(u.buffer);
+    w.setUint16(8, U(u, 8) & -9, !0), w.setUint32(42, g[r], !0), f.push(u), h += u.length;
+  }
+  for (let r = 0; r < i.length; r++) {
+    const a = i[r], d = C(a.nameBytes, a.data.length, T(a.data), E[r]);
+    f.push(d), h += d.length;
+  }
+  const L = l.length + i.length, _ = new Uint8Array(O), m = new DataView(_.buffer);
+  return m.setUint32(0, B, !0), m.setUint16(8, L, !0), m.setUint16(10, L, !0), m.setUint32(12, h - D, !0), m.setUint32(16, D, !0), f.push(_), Z(f);
+}, F = (t) => {
+  const e = [], n = [];
+  let c = 0;
+  for (const i of t) {
+    const f = new TextEncoder().encode(i.name), g = x(i.data), h = T(g), E = R(f, g.length, h);
+    n.push(C(f, g.length, h, c)), e.push(E, g), c += E.length + g.length;
+  }
+  const o = c;
+  for (const i of n)
+    e.push(i), c += i.length;
+  const l = new Uint8Array(O), s = new DataView(l.buffer);
+  return s.setUint32(0, B, !0), s.setUint16(8, t.length, !0), s.setUint16(10, t.length, !0), s.setUint32(12, c - o, !0), s.setUint32(16, o, !0), e.push(l), Z(e);
+};
+export {
+  M as ZIP_DEFLATE,
+  G as ZIP_STORED,
+  T as crc32,
+  F as createZip,
+  N as inflateRaw,
+  k as readZipEntries,
+  y as readZipEntry,
+  W as rewriteZip,
+  P as zipHasEntry
+};

package/dist/src/vnode/h.d.ts

@@ -1,4 +1,4 @@
-import type { VNode, VNodeChildren, VNodeData } from './vnode';
+import type { VNode, VNodeChildren, VNodeData } from "./vnode.js";
 export declare function addNS(data: VNodeData, children: Array<VNode | string | number> | undefined, sel: string | undefined): void;
 export declare function h(sel: string): VNode;
 export declare function h(sel: string, data: VNodeData | null): VNode;

package/dist/src/vnode/h.js

@@ -0,0 +1,22 @@
+import { vnode as v } from "./vnode.js";
+import { array as s, isVnode as g, primitive as r } from "./is.js";
+function a(e, t, o) {
+  if (e.ns = "http://www.w3.org/2000/svg", o !== "foreignObject" && t !== void 0) for (let f = 0; f < t.length; ++f) {
+    const i = t[f];
+    if (typeof i == "string" || typeof i == "number") continue;
+    const n = i.data;
+    n !== void 0 && a(n, i.children, i.sel);
+  }
+}
+function h(e, t, o) {
+  let f = {}, i, n, d;
+  if (o !== void 0 ? (t != null && (f = t), s(o) ? i = o : r(o) ? n = o : o && o.sel && (i = [o])) : t !== void 0 && t != null && (s(t) ? i = t : r(t) ? n = t : g(t) ? i = [t] : f = t), typeof i < "u") for (d = 0; d < i.length; ++d) {
+    const l = i[d];
+    r(l) && (i[d] = v(void 0, void 0, void 0, l, void 0));
+  }
+  return e[0] === "s" && e[1] === "v" && e[2] === "g" && (e.length === 3 || e[3] === "." || e[3] === "#") && a(f, i, e), v(e, f, i, n, void 0);
+}
+export {
+  a as addNS,
+  h
+};

package/dist/src/vnode/hooks.d.ts

@@ -1,4 +1,4 @@
-import type { VNode } from './vnode';
+import type { VNode } from "./vnode.js";
 export type PreHook = () => any;
 export type InitHook = (vNode: VNode) => any;
 export type CreateHook = (emptyVNode: VNode, vNode: VNode) => any;