uxml-preview 0.1.0

package/dist/layout/yoga.d.ts

@@ -0,0 +1,63 @@
+import { ElementNode, NodeId, Warning } from '../model/types';
+import { ComputedStyle } from '../style/resolve';
+/**
+ * Purpose:      load the Yoga WebAssembly module.
+ * Deps/Effects: caches the module; awaiting it more than once is harmless.
+ *
+ * Imported from `yoga-layout/load` rather than `yoga-layout`, whose default
+ * entry uses top-level await. Going through `load` keeps this library's module
+ * graph synchronous, which is what lets `render` stay a synchronous call.
+ */
+export declare function loadLayoutEngine(): Promise<void>;
+export declare function isLayoutEngineReady(): boolean;
+export declare function liveNodeCount(): number;
+export interface LayoutBox {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface TextMetrics {
+    width: number;
+    height: number;
+}
+export interface TextContext {
+    fontSize: number;
+    /** `normal` | `bold` | `italic` | `bold-and-italic`. */
+    fontStyle: string;
+    whiteSpace: string;
+}
+export type MeasureText = (text: string, context: TextContext, availableWidth: number) => TextMetrics;
+export interface LayoutOptions {
+    size: {
+        width: number;
+        height: number;
+    };
+    /**
+     * Measures a control's text.
+     *
+     * Injectable because the default depends on a canvas, so results move with
+     * the platform and the installed fonts — and Phase 5 cannot put a number on
+     * accuracy if the measurement shifts underneath it.
+     */
+    measureText: MeasureText;
+}
+export interface LayoutTree {
+    /** Computed box per element, in panel coordinates. */
+    boxes: ReadonlyMap<NodeId, LayoutBox>;
+    /** Elements that were laid out, parents before children. */
+    painted: readonly ElementNode[];
+    warnings: readonly Warning[];
+    /**
+     * Deps/Effects: frees every Yoga node this tree owns.
+     * Requires: `boxes` must not be read afterwards. Calling twice is harmless.
+     */
+    dispose(): void;
+}
+/**
+ * Purpose:      build a Yoga tree, compute layout, hand back boxes in panel
+ *               coordinates.
+ * Deps/Effects: creates Yoga nodes; the returned tree owns them until disposed.
+ * Requires:     `loadLayoutEngine()` must have resolved.
+ */
+export declare function layoutDocument(root: ElementNode, styles: ReadonlyMap<NodeId, ComputedStyle>, options: LayoutOptions): LayoutTree;

package/dist/model/types.d.ts

@@ -0,0 +1,288 @@
+/**
+ * uxml-preview — in-memory document model.
+ *
+ * Phase 1 deliverable: types only. The parser that fills these lands in Phase 2.
+ * See docs/ROADMAP.md and the decision table in docs/progress.md.
+ *
+ * One rule governs this file:
+ *
+ *   The model holds what the file said, and nothing that can be computed from it.
+ *
+ * Computed styles, "can we render this control", line numbers, expanded
+ * shorthands — all derived, all kept out. Stored derived data goes stale when
+ * the document is edited, and stale data nobody notices is worse than no data.
+ */
+/**
+ * A half-open range into a source string: `[start, end)`.
+ *
+ * Which string it indexes is implied by where the span is reached from — spans
+ * under `UxmlDocument.root` index `UxmlDocument.source`, spans under a
+ * `StyleSheet` index that sheet's own `source`. `SourceRef` makes it explicit
+ * where that context is not available.
+ */
+export interface Span {
+    start: number;
+    end: number;
+}
+/** An explicit text location, for warnings and editor navigation. */
+export type SourceRef = {
+    in: 'uxml';
+    span: Span;
+} | {
+    in: 'uss';
+    sheet: number;
+    span: Span;
+};
+/**
+ * Opaque handle to a node, stable for the lifetime of the document.
+ *
+ * Assigned by the parser and never reused. Style provenance and warnings both
+ * point at nodes, and a positional path would shift those pointers whenever an
+ * unrelated sibling is inserted.
+ */
+export type NodeId = number & {
+    readonly __brand: 'NodeId';
+};
+/**
+ * Element name exactly as written.
+ *
+ * `prefix` is kept because serialization must restore `<ui:Label>` verbatim.
+ * `local` is kept separate because USS type selectors match the C# class name
+ * (`Label`), not the qualified tag.
+ */
+export interface ElementName {
+    /** Namespace prefix as written, or null for an unprefixed tag. */
+    prefix: string | null;
+    local: string;
+}
+export interface Attribute {
+    name: string;
+    /**
+     * Value exactly as written, XML entities NOT decoded.
+     *
+     * Decoding is lossy in the direction we care about: `&amp;` and `&#38;` both
+     * decode to `&`, so a decoded value cannot be written back as the author
+     * typed it. Consumers decode when they need the text.
+     */
+    value: string;
+    span: Span;
+}
+/**
+ * Three spans rather than one, so that an edit stays local.
+ *
+ * With a single outer span, editing any descendant would force the whole
+ * subtree to be regenerated — losing the author's indentation and attribute
+ * formatting all the way up to the root. Splitting the tag lets the serializer
+ * reuse whichever parts are untouched:
+ *
+ *   <ui:VisualElement class="row">      <- openTag
+ *     <ui:Button text="Use" />          <- inner: children AND the gaps between them
+ *   </ui:VisualElement>                 <- closeTag
+ *
+ * For a self-closing element, `inner` is empty and `closeTag` is null.
+ */
+export interface ElementSpans {
+    openTag: Span;
+    inner: Span;
+    closeTag: Span | null;
+}
+export interface ElementNode {
+    id: NodeId;
+    name: ElementName;
+    /** Source order. Round-trip must not reorder attributes. */
+    attributes: Attribute[];
+    children: ElementNode[];
+    spans: ElementSpans;
+    /**
+     * The open tag no longer matches `spans.openTag` (name or attributes changed),
+     * so it must be regenerated.
+     *
+     * Deliberately does not propagate upward: a dirty child leaves its parent's
+     * tag reusable, which is the entire reason `ElementSpans` is split.
+     */
+    tagDirty: boolean;
+    /**
+     * The child list changed — insert, remove, or reorder.
+     *
+     * Separate from `tagDirty` because it invalidates something different: the
+     * whitespace between children. While this is false the serializer can slice
+     * those gaps out of `spans.inner` even when individual children are dirty,
+     * so the author's indentation survives. Once true, separators must be
+     * synthesized (copy a sibling's leading whitespace).
+     */
+    childrenDirty: boolean;
+}
+export type Combinator = 'descendant' | 'child';
+/**
+ * One simple selector.
+ *
+ * `unknown` is the escape hatch for syntax USS does not support (`:nth-child`,
+ * `[attr]`, `::before`) and for anything the parser does not recognize. The
+ * parser stores it and moves on; the resolver drops the whole rule and warns.
+ * Keeping the text means the rule still round-trips intact.
+ */
+export type SimpleSelector = {
+    kind: 'universal';
+}
+/** C# class name — `Label`, `Button`, `VisualElement`. Case-sensitive. */
+ | {
+    kind: 'type';
+    name: string;
+} | {
+    kind: 'class';
+    name: string;
+}
+/** `#foo` — matches the UXML `name` attribute, not an HTML id. */
+ | {
+    kind: 'name';
+    name: string;
+}
+/** `hover`, `active`, `focus`, `disabled`, `checked`, `selected`, `root`, `inactive`. */
+ | {
+    kind: 'pseudo';
+    name: string;
+} | {
+    kind: 'unknown';
+    text: string;
+};
+/** A compound selector plus how it attaches to the part before it. */
+export interface SelectorPart {
+    /** Ignored on the first part of a selector. */
+    combinator: Combinator;
+    /** All must match the same element (`.a.b`). */
+    simple: SimpleSelector[];
+}
+/** One selector out of a comma-separated group. */
+export interface Selector {
+    parts: SelectorPart[];
+    span: Span;
+}
+export interface Declaration {
+    /** Custom properties keep their `--` prefix; they are not special-cased. */
+    property: string;
+    /**
+     * Value exactly as written — `6px 14px`, not four expanded longhands.
+     *
+     * Expanding here would force serialization to guess a form the author never
+     * typed (`6px 14px 6px 14px`), which breaks round-trip. The resolver expands;
+     * the model does not. Unrecognized value syntax survives for the same reason:
+     * it is just text until someone asks what it means.
+     */
+    value: string;
+    span: Span;
+    dirty: boolean;
+}
+export interface Rule {
+    /** Comma-separated group. */
+    selectors: Selector[];
+    declarations: Declaration[];
+    /** The whole rule, selector through closing brace. */
+    span: Span;
+    selectorSpan: Span;
+    selectorDirty: boolean;
+    /** See `ElementNode.childrenDirty` — same reason, applied to declarations. */
+    declarationsDirty: boolean;
+}
+/**
+ * A top-level item, in source order.
+ *
+ * `unknown` covers `@media`, malformed input, and anything else the parser does
+ * not model. It is preserved by span and never interpreted.
+ */
+export type SheetItem = {
+    kind: 'rule';
+    rule: Rule;
+} | {
+    kind: 'import';
+    url: string;
+    span: Span;
+} | {
+    kind: 'unknown';
+    span: Span;
+};
+export interface StyleSheet {
+    /** The text this sheet's spans index into. */
+    source: string;
+    /**
+     * Where the text came from — a path for `@import`ed sheets, null for the one
+     * passed directly to `parse()`. Used in warning messages only.
+     */
+    origin: string | null;
+    items: SheetItem[];
+}
+export type WarningKind = 'unsupported-control' | 'unsupported-property' | 'unsupported-selector' | 'unsupported-unit' | 'version-dependent' | 'asset-unresolved' | 'import-unresolved' | 'malformed';
+/**
+ * Never a thrown error. One unsupported property must not take down the render
+ * (see CLAUDE.md rule 6).
+ *
+ * There is no line number: it is derivable from `at.span` by counting newlines,
+ * and a stored one silently points at the wrong place after an edit.
+ */
+export interface Warning {
+    kind: WarningKind;
+    message: string;
+    /** Text location, when the warning has one. */
+    at?: SourceRef;
+    /** Element the warning is about, when it has one. Lets the UI highlight it. */
+    node?: NodeId;
+}
+export interface UxmlDocument {
+    /** The exact UXML text every tree span indexes into. */
+    source: string;
+    /**
+     * The `<ui:UXML>` element itself. It is a container, not a rendered control,
+     * but it is kept in the tree because it carries the namespace declarations
+     * that serialization must restore.
+     *
+     * Anything outside it — the XML declaration, a leading comment, a trailing
+     * newline — has no field of its own. It is `source` either side of the root's
+     * span, so serialization slices it back. Storing it would be storing a copy.
+     */
+    root: ElementNode;
+    /**
+     * At most one in v0.1. `@import` (Phase 3) appends sheets, each carrying its
+     * own `source`, which is why the source text lives on the sheet.
+     */
+    sheets: StyleSheet[];
+    /** Parse-time only — malformed input. Support judgments happen downstream. */
+    warnings: Warning[];
+}
+/**
+ * Where a computed value came from.
+ *
+ * Phase 8 needs this to answer "write to the inline style, or edit the rule?".
+ * Every variant points into the model, so the editor can jump straight to the
+ * declaration's span and rewrite exactly that text.
+ *
+ * Note the inline variant indexes declarations parsed on demand from the
+ * element's `style` attribute — those declarations are not stored on the node.
+ * The attribute string is the single source; a parsed copy alongside it could
+ * disagree with it.
+ */
+export type StyleOrigin = {
+    kind: 'inline';
+    node: NodeId;
+    declIndex: number;
+} | {
+    kind: 'rule';
+    sheet: number;
+    item: number;
+    declIndex: number;
+} | {
+    kind: 'inherited';
+    from: NodeId;
+    origin: StyleOrigin;
+}
+/** USS default, which is not always the CSS default — `flex-direction` is `column`. */
+ | {
+    kind: 'default';
+};
+/**
+ * Deliberately absent from this file:
+ *
+ * - computed style values — derived, recomputed on demand (Phase 3)
+ * - "is this control supported" — a renderer concern that changes in Phase 7,
+ *   while the file it was parsed from does not
+ * - line/column numbers — derived from spans
+ * - expanded shorthands — derived from declaration values
+ */

package/dist/parser/uss.d.ts

@@ -0,0 +1,33 @@
+import { Declaration, Span, StyleSheet, Warning } from '../model/types';
+export interface UssParseResult {
+    sheet: StyleSheet;
+    warnings: Warning[];
+}
+/**
+ * Purpose:      read `property: value` pairs out of [start, end).
+ * Deps/Effects: calls `onProblem` for text it cannot make a declaration of;
+ *               it never throws and never stops early.
+ *
+ * Shared by rule blocks and by the inline `style` attribute, which is the same
+ * grammar without the braces. Spans are absolute, so declarations parsed out of
+ * an inline style index the UXML source rather than a stylesheet.
+ */
+export declare function parseDeclarationList(source: string, start: number, end: number, onProblem?: (message: string, from: number, to: number) => void): Declaration[];
+/**
+ * Byte offset of an attribute value inside the UXML source.
+ *
+ * `Attribute.span` runs from the name to just past the closing quote, and the
+ * value is stored raw, so the value's start is fixed by arithmetic rather than
+ * by another field on the model. Returns null for the malformed shapes the
+ * scanner records without a quoted value.
+ */
+export declare function attributeValueStart(attr: {
+    value: string;
+    span: Span;
+}): number | null;
+/**
+ * Purpose:      USS text -> stylesheet with the spans serialization needs.
+ * Ensures:      never throws; unterminated blocks and unknown at-rules become
+ *               warnings plus an `unknown` item covering the remaining text.
+ */
+export declare function parseUss(source: string, origin?: string | null, sheetIndex?: number): UssParseResult;

package/dist/parser/uxml.d.ts

@@ -0,0 +1,12 @@
+import { ElementName, ElementNode, Warning } from '../model/types';
+export interface UxmlParseResult {
+    root: ElementNode;
+    warnings: Warning[];
+}
+/**
+ * Purpose:      UXML text -> element tree with the spans serialization needs.
+ * Ensures:      never throws; malformed input yields warnings and whatever tree
+ *               was recovered. Spans always stay within `source`.
+ */
+export declare function parseUxml(source: string): UxmlParseResult;
+export declare function qualify(name: ElementName): string;

package/dist/render/css-map.d.ts

@@ -0,0 +1,16 @@
+import { NodeId, Warning } from '../model/types';
+import { ComputedStyle } from '../style/resolve';
+export interface CssMapOptions {
+    resolveAsset?: ((path: string) => string | null) | undefined;
+}
+export interface CssMapResult {
+    declarations: Record<string, string>;
+    warnings: Warning[];
+}
+/**
+ * Purpose:      one element's computed style -> CSS declarations.
+ * Deps/Effects: calls `resolveAsset` for background images; warnings are
+ *               returned rather than thrown so one bad property cannot take
+ *               down the render.
+ */
+export declare function toCss(style: ComputedStyle, node: NodeId, options?: CssMapOptions): CssMapResult;

package/dist/render/measure.d.ts

@@ -0,0 +1,9 @@
+import { MeasureText } from '../layout/yoga';
+/**
+ * Purpose:      measure text with a canvas when one is available.
+ * Deps/Effects: creates one offscreen canvas and reuses it.
+ * Ensures:      falls back to a fixed per-character estimate when no canvas
+ *               exists, so headless callers still lay out rather than
+ *               collapsing every label to zero.
+ */
+export declare function createDefaultMeasureText(doc?: Document): MeasureText;

package/dist/render/paint.d.ts

@@ -0,0 +1,19 @@
+import { ElementNode, NodeId, Warning } from '../model/types';
+import { ComputedStyle } from '../style/resolve';
+import { LayoutBox } from '../layout/yoga';
+import { CssMapOptions } from './css-map';
+export declare const NODE_ATTRIBUTE = "data-uxml-node";
+export interface PaintResult {
+    warnings: Warning[];
+    /** Painted element per model node, for hit-testing and for tests. */
+    elements: Map<NodeId, HTMLElement>;
+}
+export interface PaintOptions extends CssMapOptions {
+    document: Document;
+}
+/**
+ * Purpose:      build the DOM for one laid-out document under `container`.
+ * Deps/Effects: replaces the container's children. The caller owns disposal.
+ * Requires:     `boxes` must come from a layout of this same tree.
+ */
+export declare function paint(root: ElementNode, boxes: ReadonlyMap<NodeId, LayoutBox>, styles: ReadonlyMap<NodeId, ComputedStyle>, container: HTMLElement, options: PaintOptions): PaintResult;

package/dist/render/values.d.ts

@@ -0,0 +1,50 @@
+/**
+ * USS values: initial values, and turning declaration text into numbers.
+ *
+ * This is the first place in the pipeline that interprets a value. The model
+ * and the resolver both keep declarations as the author wrote them, so `6px`
+ * stays `6px` until something needs a number — which is here.
+ */
+/**
+ * USS initial values for the properties layout depends on.
+ *
+ * The resolver deliberately does not fill defaults in, so this table is the
+ * only statement of them. Two entries are worth staring at:
+ *
+ *   - `flex-direction` is `column`. CSS says `row`. Getting this wrong rotates
+ *     every layout by ninety degrees, and it is the single most common way to
+ *     mis-port a stylesheet.
+ *   - `flex-shrink` is `1` here, while Yoga's own engine default is `0`. That
+ *     disagreement is exactly why every supported property is written to the
+ *     Yoga node explicitly rather than left at whatever the engine assumes.
+ *     Unverified against a running editor; Phase 5 settles it.
+ */
+export declare const INITIAL: Readonly<Record<string, string>>;
+export declare function initialValue(property: string): string | undefined;
+export type Length = {
+    kind: 'px';
+    value: number;
+} | {
+    kind: 'percent';
+    value: number;
+} | {
+    kind: 'auto';
+} | {
+    kind: 'none';
+};
+export interface LengthResult {
+    length: Length | null;
+    /** Set when the text names a unit USS does not support, or uses calc(). */
+    problem?: string;
+}
+/**
+ * Purpose:      `"6px"` / `"50%"` / `"auto"` / `"0"` -> a number with a unit.
+ * Ensures:      never throws. Returns `length: null` with a `problem` for text
+ *               it cannot make sense of, so the caller can warn and fall back
+ *               rather than render something wrong.
+ */
+export declare function parseLength(text: string): LengthResult;
+/** Bare numbers such as `flex-grow: 1`. Returns null when it is not one. */
+export declare function parseNumber(text: string): number | null;
+/** Seconds or milliseconds to milliseconds. */
+export declare function parseDuration(text: string): number | null;

package/dist/serializer/uss.d.ts

@@ -0,0 +1,6 @@
+import { StyleSheet } from '../model/types';
+/**
+ * Purpose:      stylesheet -> USS text.
+ * Ensures:      with nothing marked dirty, the result equals `sheet.source`.
+ */
+export declare function serializeUss(sheet: StyleSheet): string;

package/dist/serializer/uxml.d.ts

@@ -0,0 +1,8 @@
+import { ElementNode } from '../model/types';
+/**
+ * Purpose:      element tree -> UXML text.
+ * Deps/Effects: reads `source`, which must be the exact text the spans were
+ *               recorded against. Passing a different string yields garbage.
+ * Ensures:      with no node marked dirty, the result equals `source`.
+ */
+export declare function serializeUxml(source: string, root: ElementNode): string;

package/dist/style/properties.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Which properties inherit, and how shorthands split.
+ *
+ * Shorthand expansion belongs to the cascade rather than to rendering: once a
+ * sheet contains both `padding` and `padding-top`, deciding which one wins is a
+ * cascade question, and it cannot be answered without splitting the shorthand
+ * first.
+ */
+export declare function isInherited(property: string): boolean;
+/** Split a value on top-level whitespace, keeping `rgb(1, 2, 3)` in one piece. */
+export declare function splitValue(value: string): string[];
+/**
+ * Purpose:      one declaration -> the longhand declarations it stands for.
+ * Ensures:      returns `[[property, value]]` unchanged for anything it does
+ *               not split, so callers never need to special-case shorthands.
+ *
+ * `transition` is left whole on purpose: it is a comma-separated list whose
+ * longhands are lists too, and nothing before Phase 4 reads it.
+ */
+export declare function expandShorthand(property: string, value: string): Array<[string, string]>;

package/dist/style/resolve.d.ts

@@ -0,0 +1,42 @@
+import { ElementNode, NodeId, StyleOrigin, UxmlDocument, Warning } from '../model/types';
+import { Specificity } from './specificity';
+export interface ComputedValue {
+    /** `var()` already substituted. Otherwise exactly as the author wrote it. */
+    value: string;
+    origin: StyleOrigin;
+}
+export type ComputedStyle = ReadonlyMap<string, ComputedValue>;
+export interface ResolveOptions {
+    /** Pseudo-classes to treat as active, e.g. `new Set(['hover'])`. */
+    activeStates?: ReadonlySet<string>;
+}
+export interface ResolveResult {
+    styles: ReadonlyMap<NodeId, ComputedStyle>;
+    warnings: readonly Warning[];
+}
+/** One declaration that competed, winner or not. */
+export interface Candidate {
+    property: string;
+    value: string;
+    origin: StyleOrigin;
+    specificity: Specificity;
+    /** Position in cascade order; higher wins a specificity tie. */
+    order: number;
+    winner: boolean;
+}
+/**
+ * Purpose:      compute the style of every element in the document.
+ * Deps/Effects: reads `doc` only; nothing on the model is mutated.
+ * Ensures:      a property absent from a node's map is at its USS default.
+ */
+export declare function resolveStyles(doc: UxmlDocument, options?: ResolveOptions): ResolveResult;
+/**
+ * Purpose:      every declaration that competed for one property on one element.
+ * Ensures:      the entry marked `winner` is the one `resolveStyles` chose;
+ *               both call `collectCandidates` and `pickWinners`.
+ *
+ * This is what an editor asks before offering "change the inline style, or edit
+ * the rule?". Nothing precomputes it: a stored candidate list would go stale the
+ * moment a rule changed, and a stale answer here rewrites the wrong file.
+ */
+export declare function explainProperty(doc: UxmlDocument, node: ElementNode, property: string, options?: ResolveOptions): Candidate[];

package/dist/style/selector.d.ts

@@ -0,0 +1,21 @@
+import { ElementNode, Selector } from '../model/types';
+export interface MatchContext {
+    /** Parent of every node, built once per document. */
+    parentOf: (node: ElementNode) => ElementNode | null;
+    /**
+     * The element `:root` refers to.
+     *
+     * USS `:root` is not the CSS one: it names whichever element the stylesheet
+     * was applied to, and does not match that element's children. A preview has
+     * no UIDocument to attach to, so the `<ui:UXML>` element stands in — which
+     * keeps the usual custom-property token pattern working, since values
+     * declared there inherit down the whole tree.
+     */
+    root: ElementNode;
+    /** Pseudo-classes currently active, e.g. `hover`. Empty in a static render. */
+    activeStates: ReadonlySet<string>;
+}
+export declare function matchesSelector(selector: Selector, node: ElementNode, ctx: MatchContext): boolean;
+/** The first unsupported fragment in a selector group, if any. */
+export declare function unsupportedFragment(selectors: readonly Selector[]): string | null;
+export declare function buildParentMap(root: ElementNode): Map<ElementNode, ElementNode | null>;

package/dist/style/specificity.d.ts

@@ -0,0 +1,6 @@
+import { Selector } from '../model/types';
+/** `[#name, .class + :pseudo, Type]`, compared left to right. */
+export type Specificity = readonly [number, number, number];
+export declare function specificityOf(selector: Selector): Specificity;
+/** Negative when `a` loses to `b`, positive when it wins, 0 on a tie. */
+export declare function compareSpecificity(a: Specificity, b: Specificity): number;

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "uxml-preview",
+  "version": "0.1.0",
+  "description": "Preview Unity UI Toolkit UXML/USS in a browser without the Unity Editor. Uses Yoga (WebAssembly), the same layout engine UI Toolkit uses: 242 of 244 element coordinates identical to Unity 6. Parses and writes files back byte-for-byte.",
+  "keywords": [
+    "unity", "unity3d", "ui-toolkit", "uitk", "uielements", "uxml", "uss",
+    "yoga", "yoga-layout", "flexbox", "webassembly", "renderer", "preview",
+    "game-ui", "typescript", "editor-tooling", "unity-editor", "css-to-uss"
+  ],
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "README.md", "LICENSE", "THIRD-PARTY-NOTICES.md", "CHANGELOG.md"],
+  "sideEffects": false,
+  "engines": { "node": ">=18" },
+  "publishConfig": { "access": "public" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ReuHomi/uxml-preview.git"
+  },
+  "homepage": "https://reuhomi.github.io/uxml-preview/",
+  "bugs": { "url": "https://github.com/ReuHomi/uxml-preview/issues" },
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc --noEmit && vite build",
+    "build:site": "vite build --config vite.playground.config.ts",
+    "preview:site": "vite preview --config vite.playground.config.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:roundtrip": "vitest run tests/roundtrip",
+    "test:golden": "vitest run tests/golden --passWithNoTests",
+    "golden:emit": "node --experimental-strip-types --no-warnings scripts/emit-golden-cases.mjs",
+    "golden:update": "node scripts/update-golden.mjs",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build"
+  },
+  "dependencies": {
+    "yoga-layout": "^3.2.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "jsdom": "^30.0.1",
+    "pixelmatch": "^6.0.0",
+    "pngjs": "^7.0.0",
+    "typescript": "^5.6.0",
+    "vite": "^6.0.0",
+    "vite-plugin-dts": "^4.3.0",
+    "vitest": "^2.1.0"
+  },
+  "packageManager": "pnpm@9.12.0"
+}