@tscaps/engine 0.1.1 → 0.3.0

package/README.md

@@ -1,10 +1,10 @@
 # @tscaps/engine
 
-> Burn subtitles into video in the browser. No server, no editor.
+A TypeScript engine that adds captions to a video and burns them in — all in the browser, no server involved. It sources captions (in-browser Whisper transcription, an existing `.srt`, or a hand-built `Document`), lays them out through CSS, and exports the result frame-by-frame to a new video.
 
-`@tscaps/engine` is a TypeScript engine that takes a video file, sources its captions (in-browser Whisper transcription, an existing `.srt`, or a hand-built `Document`), lays them out through CSS, and exports the result frame-by-frame to a new video — all client-side, with no backend involved.
+Captions are HTML elements styled with CSS. On export, the engine rasterizes that DOM at each frame's timestamp into a bitmap and composites it with the video frame. The browser renders the captions.
 
-The defining technical bet: **CSS is the rendering engine**. Subtitle preview is a DOM overlay above a `<video>` element. Final export samples that same CSS-styled DOM into bitmaps per frame, composited by a browser-side video pipeline. One visual artifact, two rendering paths.
+**See it running:** [tscaps.io/local](https://tscaps.io/local) is a full caption editor built on this engine, transcription and export included, running entirely in the browser with no account and no upload. It is the fastest way to see what the engine does before writing any code against it.
 
 ## Install
 
@@ -256,17 +256,19 @@ Document
 
 The pipeline restructures the same `Word`s into different `Segment`s and `Line`s through `SegmentSplitter` and `LineSplitter`; the underlying word data (`text`, `time`, `tags`) does not change.
 
-The render layer exposes that document to CSS through three surfaces: a flat set of CSS classes per element, a flat set of CSS custom properties per element, and a tag system that adds more classes via taggers. Everything the examples above target — `.word`, `.word-being-narrated`, `--on-segment-starts`, `var(--on-line-being-narrated-starts)` — comes from these surfaces.
+The render layer exposes that document to CSS through four surfaces: a flat set of CSS classes per element, a flat set of CSS custom properties per element, a tag system that adds more classes via taggers, and an opt-in `data-tscaps-el` attribute for reaching one element by id. Everything the examples above target — `.word`, `.word-being-narrated`, `--on-segment-starts`, `var(--on-line-being-narrated-starts)` — comes from these surfaces.
+
+`Section` never renders as an element: it is the grouping that decides which splitter and tagger chain a run of segments goes through, and the rendered subtree starts at `.segment`.
 
 ### CSS classes the engine emits
 
 Every rendered element carries its element class:
 
-- `.section` — the root of the active Section
-- `.segment` — a caption block
+- `.segment` — a caption block, the root of the rendered subtree
 - `.line` — a visible line within a segment
 - `.word` — a single word within a line
 - `.letter` — a single letter within a word, emitted only when `rendering.splitWordsIntoLetters` is `true`
+- `.word-decoration` — a decoration attached to a word (an emoji, for instance)
 
 State classes — computed per frame from the current playback time and attached to the matching `.word` / `.line`:
 
@@ -281,17 +283,36 @@ Positional tags from `StructureTagger`, assigned once after splitting:
 - `first-line-in-segment`, `last-line-in-segment`
 - `first-line-in-section`, `last-line-in-section`
 - `first-segment-in-section`, `last-segment-in-section`
-- `first-section-in-document`, `last-section-in-document`
+- `first-segment-in-document`, `last-segment-in-document`
+
+Classes on elements the renderer creates rather than on document nodes, collected in the `CssClass` enum:
+
+- `behind-actor-active` — on `.segment` while the text-behind-actor effect is active for it
+- `tscaps-video-frame-layer` — the layer holding the video frame, emitted inside `.segment` when `rendering.videoFrame.required` is set
+- `segment-decorations-above`, `segment-decorations-below` — the containers of decorations lifted out of line flow
 
 Semantic tag classes come from `Tagger` implementations you add to the pipeline (see *Tags and taggers* below) and are entirely consumer-defined.
 
+### Addressing one element
+
+A class reaches every element of its kind. To reach a single one, name its id in `SubtitleStyle.addressableElementIds` and the renderer stamps `data-tscaps-el="<id>"` (`DataAttribute.ELEMENT_ID`) on it:
+
+```ts
+.withSubtitleStyles({ default: { ...style, addressableElementIds: new Set([word.id]) } })
+```
+
+```css
+[data-tscaps-el="<id>"] { color: #ff5c8a; }
+```
+
+Any element id qualifies — segment, line, word or decoration. A word the bidirectional algorithm paints in two places gets the attribute on both pieces. The attribute is serialized once per element per rendered tile, so a caption with every word addressed grows the batch by a double-digit percentage; address nothing and it costs nothing.
+
 ### CSS custom properties
 
 Each rendered element exposes timing values relative to the current frame, so you can drive `animation-delay`, `animation-duration`, or any other CSS value from the narration timeline. `--on-…-starts` and `--on-…-ends` are seconds until the event; they go negative once the event is in the past. `--…-duration` is a span.
 
-Element-level timing:
+Segment-level timing:
 
-- `--on-section-starts`, `--on-section-ends`, `--section-duration`
 - `--on-segment-starts`, `--on-segment-ends`, `--segment-duration`
 
 Per-state timing, for both `.line` and `.word` (substitute `<elem>` with `line` or `word`):
@@ -304,10 +325,24 @@ Letter-level, when splitting into letters:
 
 - `--letter-index`, `--letter-count`
 
+Structural metadata — unitless integers, so a rule can stagger, scale or branch by an element's position and size without randomness. No `on-` prefix, because they are not events:
+
+- `--segment-index` — the segment's 0-based position within its section
+- `--segment-char-count` — character length of the segment's full text, the input for auto-shrink rules
+- `--word-index` — the word's 0-based position within its line
+- `--word-count` — on `.segment` and on `.line`; the nearest ancestor wins for a `.word` reading it
+- `--word-char-count` — code-point length of the word's display text
+- `--last-word-char-count` — on `.segment` and on `.line`; the length of the closing word, without traversing to it
+
 Layout and frame:
 
 - `--subtitle-region-width`, `--subtitle-region-height`, `--subtitle-region-x`, `--subtitle-region-y` — the caption region's box, useful when positioning relative to the video frame
 - `--video-frame` — the underlying video frame as `url("data:image/jpeg;base64,…")`, only set when `rendering.videoFrame.required` is `true` (see [docs/RENDERING_INTERNALS.md](docs/RENDERING_INTERNALS.md))
+- `--segment-padding-top`, `--segment-padding-bottom` — the padding the renderer put on the segment to give a filter room to spread
+
+Read by the engine's own baseline rules, so a stylesheet writes them rather than reading them:
+
+- `--decoration-font-size-multiplier`, `--decoration-gap-multiplier` — how large a decoration renders next to its word, and how far from it
 
 ### Tags and taggers
 
@@ -323,7 +358,10 @@ Tags map one-to-one onto CSS classes through `Tag.toCssClass()`. Unknown tag cla
 
 The examples above cover the common cases. The pipeline exposes more knobs you'll reach for as your needs grow:
 
-- **Built-in transcribers**: `WhisperTranscriber` (the default, in-browser Whisper), `SrtTranscriber` (parses SubRip), `PassthroughTranscriber` (wraps a pre-built `Document`). Or implement your own by satisfying the `Transcriber` interface.
+- **Built-in transcribers**: `WhisperTranscriber` (the default, in-browser Whisper, with a `tiny` / `base` / `small` / `medium` model ladder), `SrtTranscriber` and `VttTranscriber` (parse SubRip and WebVTT, reading per-word timings where the file carries them), `PassthroughTranscriber` (wraps a pre-built `Document`). Or implement your own by satisfying the `Transcriber` interface.
+- **Writing subtitle files**: `SubtitleFileSerializer` is the inverse of the parsers. `SrtSubtitleFileSerializer`, `VttSubtitleFileSerializer`, `AssSubtitleFileSerializer`, `SbvSubtitleFileSerializer`, `TtmlSubtitleFileSerializer` and `TextSubtitleFileSerializer` each declare their own media type and extension, and `granularity: 'word'` asks for per-word timing where the format can express it.
+- **Right-to-left and mixed-script text**: each line is resolved through the Unicode bidirectional algorithm and its words are emitted in painting order. `RenderingConfig.textDirection` supplies the paragraph direction, `TextDirectionDetector` infers it from a text, and `AlignmentConfig.horizontalAlign` additionally accepts `start` / `end` so one declaration can follow the reading direction.
+- **Cuts**: time ranges declared on a `Document` are removed from the exported video, and captions realign to the shortened timeline.
 - **Segment splitters**: the default `CompositeSegmentSplitter` chains a sentence-boundary cut with a scaled-character budget. Individual strategies are exposed for custom chains — `BoundarySegmentSplitter`, `LimitByWordsSegmentSplitter`, `LimitByScaledCharsSegmentSplitter`, `PauseBasedSegmentSplitter`, `SpeakerChangeSegmentSplitter`.
 - **Line splitters**: `BalancedLineSplitter` (char-balanced, no measurer needed) and `BalancedPixelWidthLineSplitter` (pixel-balanced, backed by a `TextMeasurer` — `DomProbeCanvasTextMeasurer` is the default measurer).
 - **Replace any stage**: `withTranscriber`, `withSegmentSplitter`, `withLineSplitter`, `withVideoRenderer`, `withSubtitleFrameRenderer`, `withOverlayFrameRenderer`. Defaults stay in place until explicitly replaced.

package/dist/index.d.ts

@@ -1,11 +1,14 @@
 export * from './modules/document/index';
 export * from './modules/transcription/index';
+export * from './modules/subtitle-file/index';
 export * from './modules/video/index';
 export * from './modules/rendering/index';
 export * from './modules/css/index';
 export * from './modules/svg-filter/index';
 export * from './modules/splitting/index';
+export * from './modules/bidi/index';
 export * from './modules/tagging/index';
+export * from './modules/tags/index';
 export * from './modules/effect/index';
 export * from './modules/profiling/index';
 export * from './modules/pipeline/index';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC"}

package/dist/index.js

@@ -1,11 +1,14 @@
 export * from './modules/document/index';
 export * from './modules/transcription/index';
+export * from './modules/subtitle-file/index';
 export * from './modules/video/index';
 export * from './modules/rendering/index';
 export * from './modules/css/index';
 export * from './modules/svg-filter/index';
 export * from './modules/splitting/index';
+export * from './modules/bidi/index';
 export * from './modules/tagging/index';
+export * from './modules/tags/index';
 export * from './modules/effect/index';
 export * from './modules/profiling/index';
 export * from './modules/pipeline/index';

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC"}

package/dist/modules/bidi/BidiAnalyzer.d.ts

@@ -0,0 +1,23 @@
+import type { TextDirection } from '../bidi/TextDirection';
+/**
+ * Outcome of the Unicode bidirectional algorithm over one stretch of
+ * text. Both arrays are indexed by UTF-16 unit and have the same length
+ * as the analyzed string.
+ */
+export interface BidiAnalysis {
+    /** Resolved embedding level of each unit, in source order. */
+    readonly levels: ReadonlyArray<number>;
+    /** Source index of each unit, ordered as the text paints from left to right. */
+    readonly visualOrder: ReadonlyArray<number>;
+}
+/**
+ * Resolves the Unicode bidirectional algorithm (UAX #9) for a text.
+ *
+ * `baseDirection` is required rather than inferred from the text: the
+ * standard's own fallback picks the direction of the first strong
+ * character, which misreads a sentence opening with a foreign name.
+ */
+export interface BidiAnalyzer {
+    analyze(text: string, baseDirection: TextDirection): BidiAnalysis;
+}
+//# sourceMappingURL=BidiAnalyzer.d.ts.map

package/dist/modules/bidi/BidiAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BidiAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/modules/bidi/BidiAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACvC,gFAAgF;IAChF,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC7C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,GAAG,YAAY,CAAC;CACnE"}

package/dist/modules/bidi/BidiAnalyzer.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BidiAnalyzer.js.map

package/dist/modules/bidi/BidiAnalyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BidiAnalyzer.js","sourceRoot":"","sources":["../../../src/modules/bidi/BidiAnalyzer.ts"],"names":[],"mappings":""}

package/dist/modules/bidi/BidiCharacterClassifier.d.ts

@@ -0,0 +1,13 @@
+import type { TextDirection } from '../bidi/TextDirection';
+/**
+ * Reads the direction Unicode assigns to a single character.
+ *
+ * Most characters carry none of their own: digits, punctuation, spaces
+ * and symbols take their direction from whatever surrounds them, and
+ * only letters of a directional script speak for themselves.
+ */
+export interface BidiCharacterClassifier {
+    /** The character's own direction, or `null` when it takes one from its context. */
+    strongDirectionOf(character: string): TextDirection | null;
+}
+//# sourceMappingURL=BidiCharacterClassifier.d.ts.map

package/dist/modules/bidi/BidiCharacterClassifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BidiCharacterClassifier.d.ts","sourceRoot":"","sources":["../../../src/modules/bidi/BidiCharacterClassifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC,mFAAmF;IACnF,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAAC;CAC5D"}

package/dist/modules/bidi/BidiCharacterClassifier.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BidiCharacterClassifier.js.map

package/dist/modules/bidi/BidiCharacterClassifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BidiCharacterClassifier.js","sourceRoot":"","sources":["../../../src/modules/bidi/BidiCharacterClassifier.ts"],"names":[],"mappings":""}

package/dist/modules/bidi/BidiJsAnalyzer.d.ts

@@ -0,0 +1,14 @@
+import type { BidiAnalysis, BidiAnalyzer } from '../bidi/BidiAnalyzer';
+import type { TextDirection } from '../bidi/TextDirection';
+/**
+ * Bidi resolution backed by a standalone implementation of UAX #9.
+ *
+ * Resolves from the characters alone and never touches the DOM, so the
+ * same text yields the same layout in a browser, a worker, or a build
+ * step.
+ */
+export declare class BidiJsAnalyzer implements BidiAnalyzer {
+    private readonly bidi;
+    analyze(text: string, baseDirection: TextDirection): BidiAnalysis;
+}
+//# sourceMappingURL=BidiJsAnalyzer.d.ts.map

package/dist/modules/bidi/BidiJsAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BidiJsAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/modules/bidi/BidiJsAnalyzer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC7E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE;;;;;;GAMG;AACH,qBAAa,cAAe,YAAW,YAAY;IACjD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAuB;IAE5C,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,GAAG,YAAY;CAOlE"}

package/dist/modules/bidi/BidiJsAnalyzer.js

@@ -0,0 +1,19 @@
+import bidiFactory from 'bidi-js';
+/**
+ * Bidi resolution backed by a standalone implementation of UAX #9.
+ *
+ * Resolves from the characters alone and never touches the DOM, so the
+ * same text yields the same layout in a browser, a worker, or a build
+ * step.
+ */
+export class BidiJsAnalyzer {
+    bidi = bidiFactory();
+    analyze(text, baseDirection) {
+        const embedding = this.bidi.getEmbeddingLevels(text, baseDirection);
+        return {
+            levels: Array.from(embedding.levels),
+            visualOrder: this.bidi.getReorderedIndices(text, embedding),
+        };
+    }
+}
+//# sourceMappingURL=BidiJsAnalyzer.js.map

package/dist/modules/bidi/BidiJsAnalyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BidiJsAnalyzer.js","sourceRoot":"","sources":["../../../src/modules/bidi/BidiJsAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,WAA0B,MAAM,SAAS,CAAC;AAIjD;;;;;;GAMG;AACH,MAAM,OAAO,cAAc;IACR,IAAI,GAAS,WAAW,EAAE,CAAC;IAE5C,OAAO,CAAC,IAAY,EAAE,aAA4B;QAChD,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;QACpE,OAAO;YACL,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;YACpC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE,SAAS,CAAC;SAC5D,CAAC;IACJ,CAAC;CACF"}

package/dist/modules/bidi/BidiJsCharacterClassifier.d.ts

@@ -0,0 +1,8 @@
+import type { BidiCharacterClassifier } from '../bidi/BidiCharacterClassifier';
+import type { TextDirection } from '../bidi/TextDirection';
+/** Character classification read from the Unicode tables of a UAX #9 implementation. */
+export declare class BidiJsCharacterClassifier implements BidiCharacterClassifier {
+    private readonly bidi;
+    strongDirectionOf(character: string): TextDirection | null;
+}
+//# sourceMappingURL=BidiJsCharacterClassifier.d.ts.map

package/dist/modules/bidi/BidiJsCharacterClassifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BidiJsCharacterClassifier.d.ts","sourceRoot":"","sources":["../../../src/modules/bidi/BidiJsCharacterClassifier.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAQjE,wFAAwF;AACxF,qBAAa,yBAA0B,YAAW,uBAAuB;IACvE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAuB;IAE5C,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;CAM3D"}

package/dist/modules/bidi/BidiJsCharacterClassifier.js

@@ -0,0 +1,19 @@
+import bidiFactory from 'bidi-js';
+// The Unicode bidi classes that carry a direction of their own: `L` for
+// left-to-right letters, `R` and `AL` for right-to-left ones (`AL` being the
+// Arabic script specifically). Every other class is context-dependent.
+const STRONG_LEFT_TO_RIGHT = 'L';
+const STRONG_RIGHT_TO_LEFT = new Set(['R', 'AL']);
+/** Character classification read from the Unicode tables of a UAX #9 implementation. */
+export class BidiJsCharacterClassifier {
+    bidi = bidiFactory();
+    strongDirectionOf(character) {
+        const type = this.bidi.getBidiCharTypeName(character);
+        if (type === STRONG_LEFT_TO_RIGHT)
+            return 'ltr';
+        if (STRONG_RIGHT_TO_LEFT.has(type))
+            return 'rtl';
+        return null;
+    }
+}
+//# sourceMappingURL=BidiJsCharacterClassifier.js.map

package/dist/modules/bidi/BidiJsCharacterClassifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BidiJsCharacterClassifier.js","sourceRoot":"","sources":["../../../src/modules/bidi/BidiJsCharacterClassifier.ts"],"names":[],"mappings":"AAAA,OAAO,WAA0B,MAAM,SAAS,CAAC;AAIjD,wEAAwE;AACxE,6EAA6E;AAC7E,uEAAuE;AACvE,MAAM,oBAAoB,GAAG,GAAG,CAAC;AACjC,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;AAElD,wFAAwF;AACxF,MAAM,OAAO,yBAAyB;IACnB,IAAI,GAAS,WAAW,EAAE,CAAC;IAE5C,iBAAiB,CAAC,SAAiB;QACjC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC;QACtD,IAAI,IAAI,KAAK,oBAAoB;YAAE,OAAO,KAAK,CAAC;QAChD,IAAI,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO,KAAK,CAAC;QACjD,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/dist/modules/bidi/CursiveScriptDetector.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tells whether a text is written in a script whose letters join up.
+ *
+ * Text like that cannot be broken into independently painted letters:
+ * each letter would be shaped in isolation, the connections between
+ * them would disappear, and the word would read as a row of unrelated
+ * marks.
+ */
+export declare class CursiveScriptDetector {
+    isCursive(text: string): boolean;
+}
+//# sourceMappingURL=CursiveScriptDetector.d.ts.map

package/dist/modules/bidi/CursiveScriptDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CursiveScriptDetector.d.ts","sourceRoot":"","sources":["../../../src/modules/bidi/CursiveScriptDetector.ts"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH,qBAAa,qBAAqB;IAEhC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAGjC"}

package/dist/modules/bidi/CursiveScriptDetector.js

@@ -0,0 +1,20 @@
+// Scripts whose letters connect to their neighbours, so a letter takes a
+// different shape depending on what sits beside it. Listed by Unicode script
+// property rather than by codepoint range, and by `Script_Extensions` so the
+// letters Persian and Urdu add to the Arabic script come along. Hebrew, Thaana
+// and Divehi are right-to-left but do not join, so they are absent on purpose.
+const CURSIVE_SCRIPTS = /[\p{Script_Extensions=Arabic}\p{Script=Syriac}\p{Script=Mongolian}\p{Script=Nko}\p{Script=Adlam}\p{Script=Mandaic}\p{Script=Hanifi_Rohingya}]/u;
+/**
+ * Tells whether a text is written in a script whose letters join up.
+ *
+ * Text like that cannot be broken into independently painted letters:
+ * each letter would be shaped in isolation, the connections between
+ * them would disappear, and the word would read as a row of unrelated
+ * marks.
+ */
+export class CursiveScriptDetector {
+    isCursive(text) {
+        return CURSIVE_SCRIPTS.test(text);
+    }
+}
+//# sourceMappingURL=CursiveScriptDetector.js.map

package/dist/modules/bidi/CursiveScriptDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CursiveScriptDetector.js","sourceRoot":"","sources":["../../../src/modules/bidi/CursiveScriptDetector.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,6EAA6E;AAC7E,6EAA6E;AAC7E,+EAA+E;AAC/E,+EAA+E;AAC/E,MAAM,eAAe,GACnB,gJAAgJ,CAAC;AAEnJ;;;;;;;GAOG;AACH,MAAM,OAAO,qBAAqB;IAEhC,SAAS,CAAC,IAAY;QACpB,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;CACF"}

package/dist/modules/bidi/HorizontalSide.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A side named by where reading begins and ends rather than by where it
+ * lands on screen. `start` is the left edge of left-to-right text and the
+ * right edge of right-to-left text.
+ */
+export type ReadingSide = 'start' | 'center' | 'end';
+/** A side of the screen, which stays where it is in either direction. */
+export type PhysicalSide = 'left' | 'center' | 'right';
+/** Every screen side, for reading one back off something that was stored. */
+export declare const PHYSICAL_SIDES: ReadonlyArray<PhysicalSide>;
+/**
+ * Either vocabulary, the way `text-align` accepts both. A layout value takes
+ * this type when the choice between them belongs to the author: naming a
+ * screen side pins the value to the frame, naming a reading side lets it
+ * follow the language of the text.
+ */
+export type HorizontalSide = PhysicalSide | ReadingSide;
+//# sourceMappingURL=HorizontalSide.d.ts.map

package/dist/modules/bidi/HorizontalSide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HorizontalSide.d.ts","sourceRoot":"","sources":["../../../src/modules/bidi/HorizontalSide.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;AAErD,yEAAyE;AACzE,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEvD,6EAA6E;AAC7E,eAAO,MAAM,cAAc,EAAE,aAAa,CAAC,YAAY,CAA+B,CAAC;AAEvF;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,WAAW,CAAC"}

package/dist/modules/bidi/HorizontalSide.js

@@ -0,0 +1,3 @@
+/** Every screen side, for reading one back off something that was stored. */
+export const PHYSICAL_SIDES = ['left', 'center', 'right'];
+//# sourceMappingURL=HorizontalSide.js.map

package/dist/modules/bidi/HorizontalSide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HorizontalSide.js","sourceRoot":"","sources":["../../../src/modules/bidi/HorizontalSide.ts"],"names":[],"mappings":"AAUA,6EAA6E;AAC7E,MAAM,CAAC,MAAM,cAAc,GAAgC,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC"}

package/dist/modules/bidi/HorizontalSideResolver.d.ts

@@ -0,0 +1,21 @@
+import type { HorizontalSide, PhysicalSide } from '../bidi/HorizontalSide';
+import type { TextDirection } from '../bidi/TextDirection';
+/**
+ * Resolves a horizontal side to the side of the screen it lands on under a
+ * given paragraph direction. A side already named in screen terms passes
+ * through, which is what lets a layout value accept either vocabulary.
+ *
+ * Values are resolved here rather than handed to CSS as `start` / `end`
+ * because CSS resolves its own flow-relative keywords against the element's
+ * `direction`, which the renderer pins so that words already placed in
+ * painting order are not placed again.
+ */
+export declare class HorizontalSideResolver {
+    toPhysical(side: HorizontalSide, textDirection: TextDirection): PhysicalSide;
+    /**
+     * Restates a fraction measured from the reading start as one measured from
+     * the left edge, and back — the conversion is its own inverse.
+     */
+    mirrorOffset(offset: number, textDirection: TextDirection): number;
+}
+//# sourceMappingURL=HorizontalSideResolver.d.ts.map

package/dist/modules/bidi/HorizontalSideResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HorizontalSideResolver.d.ts","sourceRoot":"","sources":["../../../src/modules/bidi/HorizontalSideResolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE;;;;;;;;;GASG;AACH,qBAAa,sBAAsB;IACjC,UAAU,CAAC,IAAI,EAAE,cAAc,EAAE,aAAa,EAAE,aAAa,GAAG,YAAY;IAM5E;;;OAGG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,GAAG,MAAM;CAGnE"}

package/dist/modules/bidi/HorizontalSideResolver.js

@@ -0,0 +1,27 @@
+/**
+ * Resolves a horizontal side to the side of the screen it lands on under a
+ * given paragraph direction. A side already named in screen terms passes
+ * through, which is what lets a layout value accept either vocabulary.
+ *
+ * Values are resolved here rather than handed to CSS as `start` / `end`
+ * because CSS resolves its own flow-relative keywords against the element's
+ * `direction`, which the renderer pins so that words already placed in
+ * painting order are not placed again.
+ */
+export class HorizontalSideResolver {
+    toPhysical(side, textDirection) {
+        if (side === 'start')
+            return textDirection === 'ltr' ? 'left' : 'right';
+        if (side === 'end')
+            return textDirection === 'ltr' ? 'right' : 'left';
+        return side;
+    }
+    /**
+     * Restates a fraction measured from the reading start as one measured from
+     * the left edge, and back — the conversion is its own inverse.
+     */
+    mirrorOffset(offset, textDirection) {
+        return textDirection === 'ltr' ? offset : 1 - offset;
+    }
+}
+//# sourceMappingURL=HorizontalSideResolver.js.map

package/dist/modules/bidi/HorizontalSideResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HorizontalSideResolver.js","sourceRoot":"","sources":["../../../src/modules/bidi/HorizontalSideResolver.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,MAAM,OAAO,sBAAsB;IACjC,UAAU,CAAC,IAAoB,EAAE,aAA4B;QAC3D,IAAI,IAAI,KAAK,OAAO;YAAE,OAAO,aAAa,KAAK,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;QACxE,IAAI,IAAI,KAAK,KAAK;YAAE,OAAO,aAAa,KAAK,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;QACtE,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,YAAY,CAAC,MAAc,EAAE,aAA4B;QACvD,OAAO,aAAa,KAAK,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;IACvD,CAAC;CACF"}

package/dist/modules/bidi/StrongCharacterMajorityTextDirectionDetector.d.ts

@@ -0,0 +1,24 @@
+import type { BidiCharacterClassifier } from '../bidi/BidiCharacterClassifier';
+import type { TextDirection } from '../bidi/TextDirection';
+import type { TextDirectionDetector } from '../bidi/TextDirectionDetector';
+/**
+ * Decides by counting: whichever direction more of the text's own
+ * directional characters carry wins, and a text with none reads left to
+ * right.
+ *
+ * The standard's own fallback — take the direction of the first strong
+ * character — is a poor fit for a long text, because a single foreign
+ * name at the start would speak for everything after it. Counting looks
+ * at the whole text instead.
+ *
+ * A tie, or a text where a minority script still dominates the meaning,
+ * resolves left to right. That is the conservative side: a text wrongly
+ * read as right-to-left rearranges every line of it, while the opposite
+ * mistake leaves the text in the order it was written.
+ */
+export declare class StrongCharacterMajorityTextDirectionDetector implements TextDirectionDetector {
+    private readonly characterClassifier;
+    constructor(characterClassifier: BidiCharacterClassifier);
+    detect(text: string): TextDirection;
+}
+//# sourceMappingURL=StrongCharacterMajorityTextDirectionDetector.d.ts.map

package/dist/modules/bidi/StrongCharacterMajorityTextDirectionDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrongCharacterMajorityTextDirectionDetector.d.ts","sourceRoot":"","sources":["../../../src/modules/bidi/StrongCharacterMajorityTextDirectionDetector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAEjF;;;;;;;;;;;;;;GAcG;AACH,qBAAa,4CAA6C,YAAW,qBAAqB;IAE5E,OAAO,CAAC,QAAQ,CAAC,mBAAmB;gBAAnB,mBAAmB,EAAE,uBAAuB;IAEzE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa;CAUpC"}

package/dist/modules/bidi/StrongCharacterMajorityTextDirectionDetector.js

@@ -0,0 +1,34 @@
+/**
+ * Decides by counting: whichever direction more of the text's own
+ * directional characters carry wins, and a text with none reads left to
+ * right.
+ *
+ * The standard's own fallback — take the direction of the first strong
+ * character — is a poor fit for a long text, because a single foreign
+ * name at the start would speak for everything after it. Counting looks
+ * at the whole text instead.
+ *
+ * A tie, or a text where a minority script still dominates the meaning,
+ * resolves left to right. That is the conservative side: a text wrongly
+ * read as right-to-left rearranges every line of it, while the opposite
+ * mistake leaves the text in the order it was written.
+ */
+export class StrongCharacterMajorityTextDirectionDetector {
+    characterClassifier;
+    constructor(characterClassifier) {
+        this.characterClassifier = characterClassifier;
+    }
+    detect(text) {
+        let rightToLeft = 0;
+        let leftToRight = 0;
+        for (const character of text) {
+            const direction = this.characterClassifier.strongDirectionOf(character);
+            if (direction === 'rtl')
+                rightToLeft++;
+            else if (direction === 'ltr')
+                leftToRight++;
+        }
+        return rightToLeft > leftToRight ? 'rtl' : 'ltr';
+    }
+}
+//# sourceMappingURL=StrongCharacterMajorityTextDirectionDetector.js.map

package/dist/modules/bidi/StrongCharacterMajorityTextDirectionDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrongCharacterMajorityTextDirectionDetector.js","sourceRoot":"","sources":["../../../src/modules/bidi/StrongCharacterMajorityTextDirectionDetector.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,4CAA4C;IAE1B;IAA7B,YAA6B,mBAA4C;QAA5C,wBAAmB,GAAnB,mBAAmB,CAAyB;IAAG,CAAC;IAE7E,MAAM,CAAC,IAAY;QACjB,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,KAAK,MAAM,SAAS,IAAI,IAAI,EAAE,CAAC;YAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,mBAAmB,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;YACxE,IAAI,SAAS,KAAK,KAAK;gBAAE,WAAW,EAAE,CAAC;iBAClC,IAAI,SAAS,KAAK,KAAK;gBAAE,WAAW,EAAE,CAAC;QAC9C,CAAC;QACD,OAAO,WAAW,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;IACnD,CAAC;CACF"}

package/dist/modules/bidi/TextDirection.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Base direction a stretch of text is laid out against. It is the
+ * paragraph embedding level the Unicode bidirectional algorithm starts
+ * from: `ltr` is level 0, `rtl` is level 1. Every level the algorithm
+ * resolves is relative to it, so the same text under a different base
+ * paints in a different order.
+ */
+export type TextDirection = 'ltr' | 'rtl';
+//# sourceMappingURL=TextDirection.d.ts.map

package/dist/modules/bidi/TextDirection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextDirection.d.ts","sourceRoot":"","sources":["../../../src/modules/bidi/TextDirection.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,KAAK,CAAC"}

package/dist/modules/bidi/TextDirection.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TextDirection.js.map

package/dist/modules/bidi/TextDirection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextDirection.js","sourceRoot":"","sources":["../../../src/modules/bidi/TextDirection.ts"],"names":[],"mappings":""}

package/dist/modules/bidi/TextDirectionDetector.d.ts

@@ -0,0 +1,12 @@
+import type { TextDirection } from '../bidi/TextDirection';
+/**
+ * Infers the direction a text is meant to be read in.
+ *
+ * The answer is a starting point, not a verdict: text that mixes scripts
+ * is genuinely ambiguous, so consumers are expected to let the reader
+ * override whatever comes back.
+ */
+export interface TextDirectionDetector {
+    detect(text: string): TextDirection;
+}
+//# sourceMappingURL=TextDirectionDetector.d.ts.map

package/dist/modules/bidi/TextDirectionDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextDirectionDetector.d.ts","sourceRoot":"","sources":["../../../src/modules/bidi/TextDirectionDetector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC;CACrC"}

package/dist/modules/bidi/TextDirectionDetector.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TextDirectionDetector.js.map

package/dist/modules/bidi/TextDirectionDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextDirectionDetector.js","sourceRoot":"","sources":["../../../src/modules/bidi/TextDirectionDetector.ts"],"names":[],"mappings":""}

package/dist/modules/bidi/WordFragment.d.ts

@@ -0,0 +1,34 @@
+import type { TextDirection } from '../bidi/TextDirection';
+/**
+ * One stretch of a word that resolves to a single bidi embedding level.
+ *
+ * A word normally yields exactly one. A word that wraps neutral
+ * characters around a run of another script yields several, and they can
+ * land far apart on the line, because the algorithm places each level
+ * separately.
+ */
+export interface WordFragment {
+    /** Position of the owning word within its line, in spoken order. */
+    readonly wordIndex: number;
+    readonly text: string;
+    /** Direction this fragment's own characters read in. */
+    readonly direction: TextDirection;
+    /**
+     * Whether the fragment painted immediately before this one ends where
+     * this one begins, with no word separator between them. Such a pair
+     * reads as one uninterrupted stretch and takes no inter-word gap.
+     */
+    readonly joinedToPrevious: boolean;
+    /**
+     * Whether this fragment's characters connect to one another, so
+     * painting them as separate boxes would break their shapes.
+     */
+    readonly charactersJoin: boolean;
+    /**
+     * Whether this is the last fragment of its word in paint order.
+     * Anything a word appends once — a decoration glyph, trailing text —
+     * belongs here, or a split word would show it on every piece.
+     */
+    readonly carriesWordTail: boolean;
+}
+//# sourceMappingURL=WordFragment.d.ts.map

package/dist/modules/bidi/WordFragment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WordFragment.d.ts","sourceRoot":"","sources":["../../../src/modules/bidi/WordFragment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,oEAAoE;IACpE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC;;;OAGG;IACH,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC"}

package/dist/modules/bidi/WordFragment.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=WordFragment.js.map

package/dist/modules/bidi/WordFragment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WordFragment.js","sourceRoot":"","sources":["../../../src/modules/bidi/WordFragment.ts"],"names":[],"mappings":""}