@layoutit/polycss 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Layoutit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,199 @@
+> **Status: pre-1.0. APIs may still change before a stable 1.0 release.**
+
+# polycss
+
+Vanilla JS / custom elements package for CSS-based polygon mesh rendering. Loads OBJ, glTF, GLB, and MagicaVoxel `.vox` files; renders each polygon as a real DOM element (atlas-backed `<i>` for both textured and flat-color faces) positioned with `transform: matrix3d(...)`. No WebGL, no canvas-as-scene.
+
+Two entry points:
+
+- **`polycss`**: imperative `createPolyScene` API + custom element classes (without auto-registering them).
+- **`polycss/elements`**: side-effect import that registers the scene, mesh, polygon, controls, camera, helper, select, and transform-control custom elements.
+
+## Install
+
+```bash
+npm install @layoutit/polycss
+```
+
+Or via CDN (no build step):
+
+```html
+<script type="module" src="https://esm.sh/@layoutit/polycss/elements"></script>
+```
+
+## Custom elements (declarative, primary path)
+
+Register elements with the side-effect import:
+
+```html
+<script type="module" src="https://esm.sh/@layoutit/polycss/elements"></script>
+
+<poly-scene perspective="1000" rot-x="65" rot-y="45">
+  <poly-mesh src="/cottage.glb"></poly-mesh>
+</poly-scene>
+```
+
+With per-polygon elements:
+
+```html
+<poly-scene perspective="1000" rot-x="65" rot-y="45">
+  <poly-polygon
+    vertices="[[0,0,0],[1,0,0],[0,1,0]]"
+    color="#ff0000"
+  ></poly-polygon>
+  <poly-polygon
+    vertices="[[2,0,0],[3,0,0],[2,1,0]]"
+    color="#0000ff"
+  ></poly-polygon>
+</poly-scene>
+```
+
+Custom elements accept standard DOM events: no framework needed:
+
+```html
+<poly-scene id="scene" perspective="1000" rot-x="65" rot-y="45"></poly-scene>
+
+<script type="module">
+import "https://esm.sh/@layoutit/polycss/elements";
+
+const scene = document.querySelector("#scene");
+
+const polygons = [
+  { vertices: [[0,0,0],[1,0,0],[0,1,0]], color: "#f00", id: "a" },
+  { vertices: [[2,0,0],[3,0,0],[2,1,0]], color: "#00f", id: "b" },
+];
+
+polygons.forEach(p => {
+  const el = document.createElement("poly-polygon");
+  el.setAttribute("vertices", JSON.stringify(p.vertices));
+  el.setAttribute("color", p.color);
+  el.addEventListener("click", () => console.log("clicked", p.id));
+  el.addEventListener("mouseenter", () => el.classList.add("hover"));
+  el.addEventListener("mouseleave", () => el.classList.remove("hover"));
+  scene.appendChild(el);
+});
+</script>
+
+<style>
+poly-polygon.hover { filter: brightness(1.5); }
+</style>
+```
+
+### Custom element attributes
+
+**`<poly-scene>`**
+
+| Attribute | Description |
+|---|---|
+| `perspective` | CSS perspective distance in pixels |
+| `rot-x` | Camera X-axis rotation in degrees |
+| `rot-y` | Camera Y-axis rotation in degrees |
+| `zoom` | Scale factor |
+| `directional-direction` | Comma-separated `x, y, z` e.g. `"0.5, -0.7, 0.6"` |
+| `directional-color` | Directional light color hex |
+| `directional-intensity` | Directional light intensity |
+| `ambient-intensity` | Ambient light intensity |
+| `ambient-color` | Ambient light color hex |
+| `texture-lighting` | `"baked"` or `"dynamic"` |
+| `atlas-scale` | Raster scale for generated atlas pages; lower values reduce memory/detail |
+
+For pointer drag, wheel zoom, and autorotate, drop a `<poly-orbit-controls>` child inside the scene (or wire `createPolyOrbitControls(scene, ...)` against the imperative API). For pan-first map-style input use `<poly-map-controls>` / `createPolyMapControls` instead. Mirrors Three.js's split between camera state (`<poly-scene>`) and camera input.
+
+**`<poly-mesh>`**
+
+| Attribute | Description |
+|---|---|
+| `src` | URL to `.obj`, `.glb`, `.gltf`, or `.vox` |
+| `position` | Comma-separated `x, y, z` |
+| `scale` | Uniform scale factor |
+| `rotation` | Comma-separated euler degrees `x, y, z` |
+| `auto-center` | Boolean: shift mesh bbox center to origin |
+
+**`<poly-polygon>`**
+
+| Attribute | Description |
+|---|---|
+| `vertices` | JSON array of `[x,y,z]` arrays |
+| `color` | CSS color |
+| `texture` | Image URL |
+| `uvs` | JSON array of `[u,v]` pairs |
+| `position` | Comma-separated `x, y, z` |
+| `scale` | Uniform scale factor |
+| `rotation` | Comma-separated euler degrees `x, y, z` |
+
+## Imperative API (escape hatch)
+
+For programmatic control without custom elements:
+
+```js
+import { createPolyScene, loadMesh } from "@layoutit/polycss";
+
+const scene = createPolyScene(document.querySelector("#scene"), {
+  perspective: 1000,
+  rotX: 65,
+  rotY: 45,
+  directionalLight: { direction: [0.5, -0.7, 0.6] },
+});
+
+const mesh = await loadMesh("/cottage.glb", {
+  gltfOptions: { targetSize: 60 },
+});
+const handle = scene.add(mesh, { position: [0, 0, 0] });
+
+// Later:
+handle.setTransform({ position: [5, 0, 0] });
+handle.remove();
+mesh.dispose();
+```
+
+### Imperative API reference
+
+**`createPolyScene(host, options)`**
+
+| Option | Type | Description |
+|---|---|---|
+| `perspective` | `number` | CSS perspective distance |
+| `rotX` | `number` | Camera X rotation in degrees |
+| `rotY` | `number` | Camera Y rotation in degrees |
+| `zoom` | `number` | Camera zoom scale |
+| `distance` | `number` | Camera dolly pull-back in CSS pixels |
+| `target` | `Vec3` | World-coordinate camera target |
+| `directionalLight` | `PolyDirectionalLight` | Directional light config |
+| `ambientLight` | `PolyAmbientLight` | Ambient light config |
+| `textureLighting` | `"baked" \| "dynamic"` | Texture lighting mode |
+| `atlasScale` | `number \| "auto"` | Raster scale for generated atlas pages |
+| `autoCenter` | `boolean` | Rotate around the union bbox center of added meshes |
+
+Returns a `PolySceneHandle`:
+
+```ts
+interface PolySceneHandle {
+  add(mesh: ParseResult, opts?: { position?: Vec3; scale?: number | Vec3; rotation?: Vec3 }): PolyMeshHandle;
+  setOptions(partial: Partial<PolySceneOptions>): void;
+  destroy(): void;
+}
+```
+
+**`loadMesh(url, options?)`**
+
+Fetches and parses a mesh by URL (dispatches by extension: `.obj`, `.glb`, `.gltf`, `.vox`). Returns `Promise<ParseResult>`.
+
+## Subpath imports
+
+| Import | Effect |
+|---|---|
+| `import { createPolyScene } from "@layoutit/polycss"` | Imperative API + custom element classes (no auto-registration) |
+| `import "@layoutit/polycss/elements"` | Side-effect: registers the polycss custom elements |
+
+## Re-exports from `@layoutit/polycss-core`
+
+All `@layoutit/polycss-core` exports are re-exported from `@layoutit/polycss`, so vanilla users install one package:
+
+```ts
+import { parseObj, parseGltf, parseVox, loadMesh, normalizePolygons } from "@layoutit/polycss";
+import type { Polygon, Vec3, ParseResult } from "@layoutit/polycss";
+```
+
+## Docs
+
+Full documentation at [polycss.com](https://polycss.com).

package/dist/PolySelectElement-DCuYJb5J.d.cts

@@ -0,0 +1,367 @@
+import { Polygon, Vec3, ParseResult, PolyDirectionalLight, PolyAmbientLight, PolyTextureLightingMode, CameraHandle } from '@layoutit/polycss-core';
+
+type AtlasScale = number | "auto";
+
+/**
+ * createPolyScene — imperative scene API. The vanilla counterpart to
+ * `<PolyScene>` in React / Vue.
+ *
+ * Per §API freeze: takes a host element + scene options, returns a
+ * `PolySceneHandle` whose `add(parseResult, transform?)` mounts a mesh under
+ * the scene root and returns a removable `PolyMeshHandle`.
+ *
+ * Implementation:
+ *   - Inserts a `<div class="polycss-scene">` into the host.
+ *   - Each `add(...)` creates a `<div class="polycss-mesh">` with the
+ *     mesh transform; mounts every valid polygon as an atlas-backed
+ *     background sprite.
+ *   - `destroy()` removes the scene element and disposes every mesh
+ *     (which in turn disposes generated atlas blob URLs).
+ *
+ * The scene element is a 0×0 anchor at world (0,0,0) — pinned via
+ * top:50%/left:50% so it sits at the visible center of the host. This
+ * matches React/Vue's PolyScene anchor pattern. Polygons render around
+ * the anchor via their own matrix3d translations.
+ */
+
+interface PolySceneOptions {
+    perspective?: number | false;
+    rotX?: number;
+    rotY?: number;
+    zoom?: number;
+    /**
+     * Camera pull-back distance in CSS pixels. Increasing distance moves the
+     * camera farther from the target (scene appears smaller), applied as an
+     * outermost `translateZ(-distance)` in the scene transform. Matches the
+     * `distance` field in core's `CameraState`. Default: 0 (no dolly offset).
+     */
+    distance?: number;
+    /**
+     * World-coordinate camera target — the world point that appears at the
+     * viewport centre. Matches React's `CameraState.target`. Defaults to
+     * `[0, 0, 0]` so existing scenes that don't set it keep working.
+     *
+     * Internally encoded as the innermost translate in the scene transform:
+     * `scale(zoom) rotateX(rotX) rotate(rotY) translate3d(-ty*tile, -tx*tile, -tz*tile)`
+     * (world→CSS axis swap: world-X→CSS-Y, world-Y→CSS-X, world-Z→CSS-Z).
+     */
+    target?: Vec3;
+    directionalLight?: PolyDirectionalLight;
+    ambientLight?: PolyAmbientLight;
+    /** Textured polygon lighting mode. Defaults to "baked". */
+    textureLighting?: PolyTextureLightingMode;
+    /** Raster scale for generated atlas pages. `"auto"` reduces large atlases. */
+    atlasScale?: AtlasScale;
+    /**
+     * When `true`, rotation pivots around the union bbox of all added meshes
+     * instead of world (0,0,0). The scene wraps polygons in an inner div
+     * translated by `-bboxCenter`. Updates whenever a mesh is added/removed
+     * or `setOptions` is called. Mirrors React's `<PolyScene autoCenter>`.
+     */
+    autoCenter?: boolean;
+}
+interface PolyMeshTransform {
+    /** Stable identifier — exposed on the handle and reflected on the
+     *  wrapper as `data-poly-mesh-id`. Used by selection helpers to
+     *  resolve clicks back to the mesh and to dedupe selection state. */
+    id?: string;
+    position?: Vec3;
+    scale?: number | Vec3;
+    rotation?: Vec3;
+    /**
+     * Whether `scene.add()` should merge coplanar polygons before rendering.
+     * Defaults to `true`. Set `false` for animated/deforming meshes whose
+     * triangle topology must remain stable from frame to frame.
+     */
+    merge?: boolean;
+    /**
+     * Keep polygon leaf DOM nodes stable across setPolygons() calls when the
+     * mesh topology is unchanged. Intended for animated/deforming meshes.
+     */
+    stableDom?: boolean;
+    /**
+     * When `true`, this mesh's polygons are NOT included in the scene's
+     * auto-center bbox. Use for debug overlays / helpers that shouldn't
+     * shift the camera target when toggled. Defaults to `false`.
+     */
+    excludeFromAutoCenter?: boolean;
+}
+interface PolyMeshHandle {
+    /** The polygons that were loaded after normalization and automatic merge. */
+    polygons: Polygon[];
+    /** The `.polycss-mesh` wrapper div for this mesh. Exposed so layered
+     *  helpers (selection, transform controls) can resolve a click target
+     *  back to its owning mesh, attach event listeners, or measure the
+     *  mesh's screen position via `getBoundingClientRect`. */
+    readonly element: HTMLElement;
+    /** Identifier passed via `PolyMeshTransform.id` (if any). Reflected on
+     *  the wrapper as `data-poly-mesh-id`. */
+    readonly id?: string;
+    /** Current transform snapshot (position / rotation / scale). Returned
+     *  by reference — treat as read-only and use `setTransform` to
+     *  mutate. */
+    readonly transform: PolyMeshTransform;
+    /** Remove the mesh from the scene. */
+    remove(): void;
+    /** Replace polygon geometry without tearing down the scene or controls. */
+    setPolygons(polygons: Polygon[], options?: {
+        merge?: boolean;
+        stableDom?: boolean;
+        recomputeAutoCenter?: boolean;
+    }): void;
+    /** Update transform without re-parsing. */
+    setTransform(t: Partial<PolyMeshTransform>): void;
+    /** Revoke any blob URLs the parse created. Idempotent. */
+    dispose(): void;
+    /**
+     * Re-rasterize the atlas using the directional light inverse-rotated into
+     * the mesh's local frame. Call this after a mesh rotation has been
+     * committed (e.g., on pointer release in rotate-mode transform controls) to
+     * correct stale baked shading.
+     *
+     * **Background:** Baked atlas tiles encode `baseColor × Lambert(worldNormal,
+     * worldLight)`. When the mesh wrapper rotates via CSS, the polygon's normal
+     * in world space changes but the baked color doesn't — faces stay lit/unlit
+     * incorrectly. `rebakeAtlas()` inverse-rotates the world light into the
+     * mesh's local frame and re-runs the rasterizer; because
+     * `dot(localNormal, localLight) === dot(worldNormal, worldLight)` the
+     * output is correct for any rotation.
+     *
+     * **Performance note:** This does NOT run on every `setTransform` call —
+     * only when explicitly invoked, so dragging remains smooth. Call it on
+     * pointer release (or any point where you want to commit the new shading).
+     */
+    rebakeAtlas(): void;
+    /** Current `position` from the transform (matches framework API). */
+    getPosition(): Vec3 | undefined;
+    /** Current `rotation` from the transform (matches framework API). */
+    getRotation(): Vec3 | undefined;
+    /** Current `scale` from the transform (matches framework API). */
+    getScale(): number | Vec3 | undefined;
+    /** Polygons currently being rendered (matches framework API). */
+    getPolygons(): Polygon[];
+}
+interface PolySceneHandle {
+    /** Add a mesh to the scene. Returns a handle for later removal. */
+    add(mesh: ParseResult, opts?: PolyMeshTransform): PolyMeshHandle;
+    /** Update scene-level config (rotation, lighting, etc.). */
+    setOptions(partial: Partial<PolySceneOptions>): void;
+    /** Tear down the scene; revokes all blob URLs of registered meshes. */
+    destroy(): void;
+    /**
+     * The host element passed to `createPolyScene`. Exposed for layered
+     * helpers like `createPolyOrbitControls` that need to attach event listeners
+     * without tracking the host separately.
+     */
+    readonly host: HTMLElement;
+    /**
+     * Snapshot of the current options (camera, lighting, merge, autoCenter,
+     * textureLighting, atlasScale, perspective). Returned by reference, so
+     * callers must treat it as read-only — mutations won't propagate. Used
+     * by helpers that need to read the current camera state without
+     * duplicating it.
+     */
+    getOptions(): Readonly<PolySceneOptions>;
+    /** Snapshot of mesh handles currently in the scene (insertion order).
+     *  Used by selection helpers to enumerate hit-test candidates. */
+    meshes(): readonly PolyMeshHandle[];
+    /** Resolve a `.polycss-mesh` element back to its handle, or `null` if
+     *  the element doesn't belong to this scene. */
+    findMeshByElement(element: Element | null): PolyMeshHandle | null;
+}
+declare function createPolyScene(host: HTMLElement, options?: PolySceneOptions): PolySceneHandle;
+
+interface PolyCameraOptions {
+    zoom?: number;
+    target?: Vec3;
+    rotX?: number;
+    rotY?: number;
+    /** Camera pull-back in CSS pixels (dolly). Default 0. */
+    distance?: number;
+}
+interface PolyPerspectiveCameraOptions extends PolyCameraOptions {
+    /** CSS perspective distance in pixels. Default 8000. */
+    perspective?: number;
+}
+interface PolyOrthographicCameraOptions extends PolyCameraOptions {
+}
+/** Extends CameraHandle with projection info for the container element. */
+interface PolyPerspectiveCameraHandle extends CameraHandle {
+    readonly type: "perspective";
+    /** CSS `perspective` value to set on the camera container element. */
+    readonly perspectiveStyle: string;
+}
+interface PolyOrthographicCameraHandle extends CameraHandle {
+    readonly type: "orthographic";
+    /** CSS `perspective` value to set on the camera container element ("none"). */
+    readonly perspectiveStyle: "none";
+}
+/**
+ * Creates a perspective camera handle. The `perspectiveStyle` property
+ * returns the CSS value to apply to the camera container's `perspective`
+ * property (default `"8000px"`).
+ */
+declare function createPolyPerspectiveCamera(options?: PolyPerspectiveCameraOptions): PolyPerspectiveCameraHandle;
+/**
+ * Creates an orthographic camera handle. The `perspectiveStyle` property
+ * returns `"none"` — pass it to the container element's CSS `perspective`
+ * to disable perspective projection.
+ */
+declare function createPolyOrthographicCamera(options?: PolyOrthographicCameraOptions): PolyOrthographicCameraHandle;
+
+declare const ELEMENT_BASE$8: typeof HTMLElement;
+declare class PolySceneElement extends ELEMENT_BASE$8 {
+    static get observedAttributes(): string[];
+    private _scene;
+    /**
+     * Returns the underlying PolySceneHandle. Children call this during their own
+     * connectedCallback to register meshes.
+     */
+    getScene(): PolySceneHandle | null;
+    private _readOptions;
+    private _readDirectionalLight;
+    private _readAmbientLight;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+declare const ELEMENT_BASE$7: typeof HTMLElement;
+declare class PolyMeshElement extends ELEMENT_BASE$7 {
+    static get observedAttributes(): string[];
+    private _handle;
+    private _parseResult;
+    private _loadToken;
+    /** Returns the current mesh handle, or null if not yet loaded. */
+    getMeshHandle(): PolyMeshHandle | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    private _tearDown;
+    private _maybeLoad;
+}
+
+declare const ELEMENT_BASE$6: typeof HTMLElement;
+declare class PolyPolygonElement extends ELEMENT_BASE$6 {
+    static get observedAttributes(): string[];
+    private _handle;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+    private _tearDown;
+    private _mount;
+}
+
+declare const ELEMENT_BASE$5: typeof HTMLElement;
+declare class PolyOrbitControlsElement extends ELEMENT_BASE$5 {
+    static get observedAttributes(): string[];
+    private _controls;
+    private _readAnimate;
+    private _readOptions;
+    private _findScene;
+    private _attach;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+declare const ELEMENT_BASE$4: typeof HTMLElement;
+declare class PolyMapControlsElement extends ELEMENT_BASE$4 {
+    static get observedAttributes(): string[];
+    private _controls;
+    private _readAnimate;
+    private _readOptions;
+    private _findScene;
+    private _attach;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+/**
+ * <poly-perspective-camera> — standalone perspective camera element.
+ *
+ * Wraps `createPolyPerspectiveCamera`. Unlike <poly-scene> which owns the
+ * scene DOM, this element provides a camera context that child controls can
+ * read. It creates a `<div class="polycss-camera">` wrapper with the
+ * CSS `perspective` property set.
+ *
+ * Attributes (all optional):
+ *   perspective   — number, CSS perspective in pixels (default 8000)
+ *   zoom          — number
+ *   rot-x         — number, degrees (default 65)
+ *   rot-y         — number, degrees (default 45)
+ *   target        — "x,y,z" comma-separated world coordinates
+ *   distance      — number, camera pull-back in CSS pixels
+ */
+
+declare const ELEMENT_BASE$3: typeof HTMLElement;
+declare class PolyPerspectiveCameraElement extends ELEMENT_BASE$3 {
+    static get observedAttributes(): string[];
+    private _camera;
+    private _wrapper;
+    /** Returns the camera handle, or null if not yet connected. */
+    getCamera(): PolyPerspectiveCameraHandle | null;
+    private _readOptions;
+    private _mount;
+    private _teardown;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+/**
+ * <poly-orthographic-camera> — standalone orthographic camera element.
+ *
+ * Wraps `createPolyOrthographicCamera`. Sets CSS `perspective: none` on the
+ * camera wrapper, disabling perspective projection.
+ *
+ * Attributes (all optional):
+ *   zoom          — number
+ *   rot-x         — number, degrees (default 65)
+ *   rot-y         — number, degrees (default 45)
+ *   target        — "x,y,z" comma-separated world coordinates
+ *   distance      — number, camera pull-back in CSS pixels
+ */
+
+declare const ELEMENT_BASE$2: typeof HTMLElement;
+declare class PolyOrthographicCameraElement extends ELEMENT_BASE$2 {
+    static get observedAttributes(): string[];
+    private _camera;
+    private _wrapper;
+    /** Returns the camera handle, or null if not yet connected. */
+    getCamera(): PolyOrthographicCameraHandle | null;
+    private _readOptions;
+    private _mount;
+    private _teardown;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+declare const ELEMENT_BASE$1: typeof HTMLElement;
+declare class PolyTransformControlsElement extends ELEMENT_BASE$1 {
+    static get observedAttributes(): string[];
+    private _tc;
+    private _findScene;
+    private _findTargetMesh;
+    private _readOptions;
+    private _attach;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+declare const ELEMENT_BASE: typeof HTMLElement;
+declare class PolySelectElement extends ELEMENT_BASE {
+    static get observedAttributes(): string[];
+    private _selection;
+    private _findScene;
+    private _readOptions;
+    private _attach;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+}
+
+export { type PolySceneHandle as P, type PolyMeshHandle as a, type PolyCameraOptions as b, PolyMapControlsElement as c, PolyMeshElement as d, type PolyMeshTransform as e, PolyOrbitControlsElement as f, PolyOrthographicCameraElement as g, type PolyOrthographicCameraHandle as h, type PolyOrthographicCameraOptions as i, PolyPerspectiveCameraElement as j, type PolyPerspectiveCameraHandle as k, type PolyPerspectiveCameraOptions as l, PolyPolygonElement as m, PolySceneElement as n, type PolySceneOptions as o, PolySelectElement as p, PolyTransformControlsElement as q, createPolyOrthographicCamera as r, createPolyPerspectiveCamera as s, createPolyScene as t };