pagyra-js 0.0.21 → 0.0.23

package/dist/src/css/apply-declarations.js

@@ -19,7 +19,8 @@ const SHORTHAND_PROPERTIES = new Set([
     "font",
     "text-decoration",
     "flex",
-    "gap"
+    "gap",
+    "grid-column"
 ]);
 // Cache for frequently used parsers to reduce Map lookups
 const parserCache = new Map();

package/dist/src/css/clip-path-types.d.ts

@@ -14,4 +14,12 @@ export interface ClipPathPolygon {
     }>;
     referenceBox?: ClipPathReferenceBox;
 }
-export type ClipPath = ClipPathPolygon;
+export interface ClipPathEllipse {
+    type: "ellipse";
+    rx: ClipPathLength;
+    ry: ClipPathLength;
+    cx: ClipPathLength;
+    cy: ClipPathLength;
+    referenceBox?: ClipPathReferenceBox;
+}
+export type ClipPath = ClipPathPolygon | ClipPathEllipse;

package/dist/src/css/compute-style/overrides.js

@@ -1,4 +1,4 @@
-import { BoxSizing } from "../enums.js";
+import { BoxSizing, OverflowMode } from "../enums.js";
 import { normalizeFontWeight } from "../font-weight.js";
 import { CssUnitResolver } from "../css-unit-resolver.js";
 import { LayoutPropertyResolver } from "../layout-property-resolver.js";
@@ -174,6 +174,15 @@ export function applyStyleInitOverrides(styleInit, styleOptions, mergedDefaults,
     if (styleInit.gridColumnSpan !== undefined) {
         styleOptions.gridColumnSpan = styleInit.gridColumnSpan;
     }
+    if (styleInit.breakInside !== undefined) {
+        styleOptions.breakInside = styleInit.breakInside;
+    }
+    if (styleInit.overflowX !== undefined) {
+        styleOptions.overflowX = styleInit.overflowX;
+    }
+    if (styleInit.overflowY !== undefined) {
+        styleOptions.overflowY = styleInit.overflowY;
+    }
     if (styleInit.justifyContent !== undefined)
         styleOptions.justifyContent = styleInit.justifyContent;
     if (styleInit.alignItems !== undefined)

package/dist/src/css/parsers/clip-path-parser.js

@@ -18,6 +18,10 @@ function parseClipPathValue(value) {
     if (polygon) {
         return polygon;
     }
+    const ellipse = parseEllipse(normalized);
+    if (ellipse) {
+        return ellipse;
+    }
     return undefined;
 }
 function parsePolygon(input) {
@@ -66,6 +70,53 @@ function splitEvenTokens(tokens) {
     }
     return result;
 }
+function parseEllipse(input) {
+    const match = /^ellipse\s*\((.+)\)$/i.exec(input);
+    if (!match) {
+        return undefined;
+    }
+    const body = match[1].trim();
+    // ellipse(rx ry at cx cy)
+    const atMatch = /^(.+?)\s+at\s+(.+)$/i.exec(body);
+    let rxToken;
+    let ryToken;
+    let cxToken = "50%";
+    let cyToken = "50%";
+    if (atMatch) {
+        const radii = atMatch[1].trim().split(/\s+/).filter(Boolean);
+        const center = atMatch[2].trim().split(/\s+/).filter(Boolean);
+        if (radii.length < 2 || center.length < 2) {
+            return undefined;
+        }
+        rxToken = radii[0];
+        ryToken = radii[1];
+        cxToken = center[0];
+        cyToken = center[1];
+    }
+    else {
+        const tokens = body.split(/\s+/).filter(Boolean);
+        if (tokens.length < 2) {
+            return undefined;
+        }
+        rxToken = tokens[0];
+        ryToken = tokens[1];
+    }
+    const rx = parseClipLength(rxToken);
+    const ry = parseClipLength(ryToken);
+    const cx = parseClipLength(cxToken);
+    const cy = parseClipLength(cyToken);
+    if (!rx || !ry || !cx || !cy) {
+        return undefined;
+    }
+    return {
+        type: "ellipse",
+        rx,
+        ry,
+        cx,
+        cy,
+        referenceBox: "border-box",
+    };
+}
 function parseClipLength(token) {
     const parsed = parseLengthOrPercent(token);
     if (parsed === undefined) {

package/dist/src/css/parsers/register-parsers.js

@@ -155,6 +155,17 @@ export function registerAllPropertyParsers() {
     registerPropertyParser("float", parseFloat);
     registerPropertyParser("overflow-wrap", parseOverflowWrap);
     registerPropertyParser("word-wrap", parseWordWrap);
+    registerPropertyParser("overflow", (value, target) => {
+        const val = value.trim().toLowerCase();
+        target.overflowX = val;
+        target.overflowY = val;
+    });
+    registerPropertyParser("overflow-x", (value, target) => {
+        target.overflowX = value.trim().toLowerCase();
+    });
+    registerPropertyParser("overflow-y", (value, target) => {
+        target.overflowY = value.trim().toLowerCase();
+    });
     registerPropertyParser("word-break", parseWordBreak);
     registerPropertyParser("text-shadow", parseTextShadow);
     registerPropertyParser("list-style-type", parseListStyleType);
@@ -165,6 +176,9 @@ export function registerAllPropertyParsers() {
     registerPropertyParser("counter-increment", (value, target) => {
         target.counterIncrement = parseCounterIncrement(value);
     });
+    registerPropertyParser("break-inside", (value, target) => {
+        target.breakInside = value.trim().toLowerCase();
+    });
     // Transform (store as raw string for limited later use)
     registerPropertyParser("transform", (value, target) => {
         // store raw transform string
@@ -176,7 +190,14 @@ export function registerAllPropertyParsers() {
     registerPropertyParser("background-origin", applyBackgroundOriginDecl);
     registerPropertyParser("background-repeat", applyBackgroundRepeatDecl);
     registerPropertyParser("background-clip", applyBackgroundClipDecl);
+    registerPropertyParser("-webkit-background-clip", applyBackgroundClipDecl);
     registerPropertyParser("background-image", parseBackgroundImage);
+    registerPropertyParser("mask", (value, target) => {
+        target.mask = value;
+    });
+    registerPropertyParser("-webkit-mask", (value, target) => {
+        target.mask = value;
+    });
     registerPropertyParser("background", parseBackground);
     registerPropertyParser("object-fit", parseObjectFit);
     registerPropertyParser("clip-path", parseClipPath);

package/dist/src/css/properties/visual.d.ts

@@ -83,6 +83,8 @@ export interface VisualProperties {
     overflowY: OverflowMode;
     /** Clipping path applied to the element */
     clipPath?: ClipPath;
+    /** CSS masking */
+    mask?: string;
     /** CSS filter — lista ordenada de funções (aplicadas da esquerda para direita) */
     filter?: FilterFunction[];
     /** CSS backdrop-filter — mesma estrutura, render diferente */

package/dist/src/css/style.d.ts

@@ -33,6 +33,7 @@ export interface StyleAccumulator {
     textShadows?: TextShadowInput[];
     transform?: string;
     clipPath?: ClipPath;
+    mask?: string;
     borderTop?: LengthInput;
     borderRight?: LengthInput;
     borderBottom?: LengthInput;
@@ -96,10 +97,13 @@ export interface StyleAccumulator {
     wordBreak?: WordBreak;
     trackListColumns?: TrackDefinitionInput[];
     trackListRows?: TrackDefinitionInput[];
+    overflowX?: string;
+    overflowY?: string;
     autoFlow?: GridAutoFlow;
     rowGap?: NumericLength | ClampNumericLength;
     columnGap?: NumericLength | ClampNumericLength;
     gridColumnSpan?: number;
+    breakInside?: string;
     zIndex?: number | "auto";
     top?: LengthInput;
     right?: LengthInput;
@@ -216,6 +220,7 @@ export declare class ComputedStyle implements StyleProperties {
     breakBefore: string;
     breakAfter: string;
     breakInside: string;
+    mask?: string;
     widows: number;
     orphans: number;
     opacity: number;

package/dist/src/css/style.js

@@ -97,6 +97,8 @@ export class ComputedStyle {
         this.flexWrap = data.flexWrap;
         this.trackListColumns = data.trackListColumns;
         this.trackListRows = data.trackListRows;
+        this.overflowX = data.overflowX;
+        this.overflowY = data.overflowY;
         this.autoFlow = data.autoFlow;
         this.rowGap = data.rowGap;
         this.columnGap = data.columnGap;
@@ -106,6 +108,7 @@ export class ComputedStyle {
         this.breakBefore = data.breakBefore;
         this.breakAfter = data.breakAfter;
         this.breakInside = data.breakInside;
+        this.mask = data.mask;
         this.widows = data.widows;
         this.orphans = data.orphans;
         this.textIndent = data.textIndent;

package/dist/src/css/ua-defaults/element-defaults.js

@@ -110,6 +110,19 @@ class ElementSpecificDefaultsImpl {
                 fontFamily: TypographyDefaults.getFontFamily(),
                 color: TypographyDefaults.getColor(),
             },
+            // Horizontal rule — UA default renders a thin line via its border. Without this,
+            // an <hr> with no explicit border (relying on browser defaults) is invisible.
+            hr: {
+                display: Display.Block,
+                marginTop: relativeLength("em", 0.5),
+                marginBottom: relativeLength("em", 0.5),
+                borderTop: 1,
+                borderColor: "#a0a0a0",
+                fontSize: relativeLength("em", 1),
+                lineHeight: createNormalLineHeight(),
+                fontFamily: TypographyDefaults.getFontFamily(),
+                color: TypographyDefaults.getColor(),
+            },
             // Lists
             ul: {
                 display: Display.Block,

package/dist/src/dom/node.d.ts

@@ -17,6 +17,7 @@ export interface NodeVisitor {
 }
 export interface LayoutNodeOptions {
     intrinsicInlineSize?: number;
+    minIntrinsicInlineSize?: number;
     intrinsicBlockSize?: number;
     textContent?: string;
     tagName?: string;
@@ -41,6 +42,7 @@ export declare class LayoutNode {
     establishesGFC: boolean;
     establishesTFC: boolean;
     intrinsicInlineSize?: number;
+    minIntrinsicInlineSize?: number;
     intrinsicBlockSize?: number;
     textContent?: string;
     tagName?: string;

package/dist/src/dom/node.js

@@ -12,6 +12,7 @@ export class LayoutNode {
         this.establishesGFC = false;
         this.establishesTFC = false;
         this.intrinsicInlineSize = options?.intrinsicInlineSize;
+        this.minIntrinsicInlineSize = options?.minIntrinsicInlineSize;
         this.intrinsicBlockSize = options?.intrinsicBlockSize;
         this.textContent = options?.textContent;
         this.tagName = options?.tagName;

package/dist/src/fonts/woff2/decoder.d.ts

@@ -1,5 +1,6 @@
 import type { ParsedFont } from "../types.js";
 import { type AsyncDecompressFn } from "../../compression/decompress.js";
+import { type GlyfReconstruction } from "./glyf-reconstructor.js";
 export interface Woff2Dependencies {
     decompress?: AsyncDecompressFn;
     transformers?: Map<number, Woff2Transform>;
@@ -20,15 +21,6 @@ interface Woff2Header {
     uncompressedSize: number;
     tables: Woff2Table[];
 }
-interface GlyfReconstruction {
-    glyfData: Uint8Array;
-    locaData: Uint8Array;
-    glyfChecksum: number;
-    locaChecksum: number;
-    numGlyphs: number;
-    indexFormat: number;
-    xMins: Int16Array;
-}
 interface TransformState {
     glyfInfo: GlyfReconstruction | null;
     numHMetrics: number;