Migrate analysis from parley to parley_core

This introduces `Analyzer` and `Analysis` as scratch, moves over
`analyze_text` from Parley into Parley Core, as well some types like
`CharInfo`, `Boundary`. Parley now calls into Parley Core for analysis.

Analysis is unchanged, except Parley Core is given word break spans by
Parley, where Parley previously reached into the style runs during
analysis.

Quite a bit is `pub` so Parley can reach into Core's fields. `CharInfo`
has different fields in linebender#634
(the big PR where all of shaping was migrated to `parley_core`), and we
may move to something like that later. For now, this should be fine.

Benches neutral as expected:

<details>
<summary>Benchmark results</summary>

```
$ cargo export target/benchmarks -- bench --bench=main
$ cargo bench -q --bench=main -- compare ../target/benchmarks/main -t 8.
Default Style - arabic 20 characters               [   8.7 us ...   8.7 us ]      -0.26%
Default Style - latin 20 characters                [   4.1 us ...   4.2 us ]      +1.69%*
Default Style - japanese 20 characters             [   8.1 us ...   8.2 us ]      +0.49%
Default Style - arabic 1 paragraph                 [  47.0 us ...  46.7 us ]      -0.66%
Default Style - latin 1 paragraph                  [  16.0 us ...  16.5 us ]      +2.78%*
Default Style - japanese 1 paragraph               [  69.1 us ...  68.7 us ]      -0.55%
Default Style - arabic 4 paragraph                 [ 203.1 us ... 196.7 us ]      -3.13%*
Default Style - latin 4 paragraph                  [  61.5 us ...  61.7 us ]      +0.39%
Default Style - japanese 4 paragraph               [  98.1 us ...  97.0 us ]      -1.14%*
Styled - arabic 20 characters                      [   9.7 us ...   9.7 us ]      +0.04%
Styled - latin 20 characters                       [   5.3 us ...   5.3 us ]      +1.55%*
Styled - japanese 20 characters                    [   8.6 us ...   8.6 us ]      -0.46%
Styled - arabic 1 paragraph                        [  49.3 us ...  49.0 us ]      -0.76%
Styled - latin 1 paragraph                         [  20.4 us ...  20.6 us ]      +0.93%
Styled - japanese 1 paragraph                      [  75.0 us ...  74.4 us ]      -0.90%
Styled - arabic 4 paragraph                        [ 220.1 us ... 215.6 us ]      -2.02%*
Styled - latin 4 paragraph                         [  79.5 us ...  80.0 us ]      +0.59%
Styled - japanese 4 paragraph                      [ 106.2 us ... 105.3 us ]      -0.85%
```
</details>

Author: tomcur

Cargo.lock

@@ -34,13 +34,11 @@ fontique = { workspace = true }
 parlance = { workspace = true }
 parley_core = { workspace = true }
 core_maths = { version = "0.1.1", optional = true }
-parley_data = { workspace = true, features = ["baked"] }
 accesskit = { workspace = true, optional = true }
 hashbrown = { workspace = true }
 harfrust = { workspace = true }
 icu_normalizer = { workspace = true, features = ["compiled_data"] }
 icu_properties = { workspace = true, features = ["compiled_data"] }
-icu_segmenter = { workspace = true, features = ["compiled_data"] }
 
 [dev-dependencies]
 parley_dev = { workspace = true }

parley/Cargo.toml

@@ -0,0 +1,57 @@
+// Copyright 2025 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+pub(crate) mod cluster;
+
+use crate::{Brush, LayoutContext};
+
+use icu_properties::props::{GeneralCategory, Script};
+use parley_core::break_overrides::LineBreakOverrideFn;
+
+use parley_core::{AnalysisDataSources, AnalysisOptions};
+
+pub(crate) fn analyze_text<B: Brush>(
+    lcx: &mut LayoutContext<B>,
+    text: &str,
+    line_break_override: Option<&LineBreakOverrideFn>,
+) {
+    let text = if text.is_empty() { " " } else { text };
+
+    // Collect the style runs word breaks. Gaps are `WordBreak::Normal`, so only non-`Normal`s need
+    // an entry.
+    lcx.word_break.clear();
+    lcx.word_break.extend(lcx.style_runs.iter().map(|sr| {
+        (
+            sr.range.clone(),
+            lcx.style_table[sr.style_index as usize].word_break,
+        )
+    }));
+
+    let options = AnalysisOptions {
+        word_break: &lcx.word_break,
+        line_break_override,
+    };
+    lcx.analyzer.analyze(text, &options, &mut lcx.analysis);
+
+    // Pair the char infos with style indices (which we set later in the builder).
+    lcx.info.clear();
+    lcx.info
+        .extend(lcx.analysis.char_infos().iter().map(|&ci| (ci, 0)));
+}
+
+/// All characters contribute to shaping except:
+/// - Control characters
+/// - Format characters, unless they use the "Inherited" script
+#[inline(always)]
+pub(crate) fn contributes_to_shaping(general_category: GeneralCategory, script: Script) -> bool {
+    if matches!(
+        general_category,
+        GeneralCategory::Control
+            | GeneralCategory::LineSeparator
+            | GeneralCategory::ParagraphSeparator
+    ) {
+        return false;
+    }
+
+    !(general_category == GeneralCategory::Format && script != Script::Inherited)
+}

parley/src/analysis.rs

@@ -307,7 +307,7 @@ fn build_into_layout<B: Brush>(
     layout.data.clear();
     layout.data.scale = scale;
     layout.data.quantize = quantize;
-    layout.data.base_level = lcx.bidi.base_level();
+    layout.data.base_level = lcx.analysis.paragraph_level();
     layout.data.text_len = text.len();
 
     let mut char_index = 0;
@@ -336,7 +336,7 @@ fn build_into_layout<B: Brush>(
             &lcx.style_table,
             &lcx.inline_boxes,
             &lcx.info,
-            lcx.bidi.levels(),
+            lcx.analysis.bidi_levels(),
             &mut lcx.scx,
             text,
             layout,

parley/src/builder.rs

@@ -3,17 +3,19 @@
 
 //! Context for layout.
 
+use core::ops::Range;
+
 use alloc::{vec, vec::Vec};
 
-use parley_core::bidi::BidiResolver;
+use parlance::WordBreak;
+use parley_core::{Analysis, AnalysisDataSources, Analyzer, CharInfo};
 
 use super::FontContext;
 use super::builder::{RangedBuilder, StyleRunBuilder};
 use super::resolve::tree::TreeStyleBuilder;
 use super::resolve::{RangedStyleBuilder, ResolveContext, ResolvedStyle, StyleRun};
 use super::style::{Brush, TextStyle};
 
-use crate::analysis::{AnalysisDataSources, CharInfo};
 use crate::builder::TreeBuilder;
 use crate::inline_box::InlineBox;
 use crate::shape::ShapeContext;
@@ -26,7 +28,11 @@ pub struct LayoutContext<B: Brush = [u8; 4]> {
     pub(crate) style_table: Vec<ResolvedStyle<B>>,
     pub(crate) style_runs: Vec<StyleRun>,
     pub(crate) inline_boxes: Vec<InlineBox>,
-    pub(crate) bidi: BidiResolver,
+
+    // Reusable text analysis
+    pub(crate) analyzer: Analyzer,
+    pub(crate) analysis: Analysis,
+    pub(crate) word_break: Vec<(Range<usize>, WordBreak)>,
 
     // Reusable style builders (to amortise allocations)
     pub(crate) ranged_style_builder: RangedStyleBuilder<B>,
@@ -47,7 +53,9 @@ impl<B: Brush> LayoutContext<B> {
             style_table: vec![],
             style_runs: vec![],
             inline_boxes: vec![],
-            bidi: BidiResolver::new(),
+            analyzer: Analyzer::new(),
+            analysis: Analysis::new(),
+            word_break: Vec::new(),
             ranged_style_builder: RangedStyleBuilder::default(),
             tree_style_builder: TreeStyleBuilder::default(),
             info: vec![],
@@ -187,7 +195,6 @@ impl<B: Brush> LayoutContext<B> {
         self.style_runs.clear();
         self.inline_boxes.clear();
         self.info.clear();
-        self.bidi.clear();
     }
 }
 

parley/src/context.rs

@@ -1,9 +1,8 @@
 // Copyright 2024 the Parley Authors
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-use crate::analysis::AnalysisDataSources;
-
 use icu_properties::props::Script;
+use parley_core::AnalysisDataSources;
 
 pub(crate) fn script_to_fontique(
     script: Script,

parley/src/convert.rs

@@ -9,9 +9,9 @@ use crate::{FontData, IndentOptions, InlineBoxKind, LineHeight, OverflowWrap, Te
 use core::ops::Range;
 
 use alloc::vec::Vec;
+use parley_core::{Boundary, CharInfo};
 
 use crate::analysis::cluster::Whitespace;
-use crate::analysis::{Boundary, CharInfo};
 
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub(crate) struct ClusterData {

parley/src/layout/data.rs

@@ -9,7 +9,6 @@ use alloc::vec::Vec;
 #[allow(unused_imports)]
 use core_maths::CoreFloat;
 
-use crate::analysis::Boundary;
 use crate::analysis::cluster::Whitespace;
 use crate::data::ClusterData;
 use crate::layout::{
@@ -20,6 +19,7 @@ use crate::style::Brush;
 use crate::{InlineBoxKind, OverflowWrap, TextWrapMode};
 
 use core::ops::Range;
+use parley_core::Boundary;
 
 #[derive(Default)]
 struct LineLayout {

parley/src/layout/line_break.rs

@@ -8,12 +8,12 @@ use alloc::vec::Vec;
 use core::mem;
 use core::ops::RangeInclusive;
 use harfrust::ShapeOptions;
+use parley_core::{AnalysisDataSources, CharInfo};
 
 use super::layout::Layout;
 use super::resolve::{ResolveContext, Resolved, ResolvedStyle};
 use super::style::{Brush, FontFeature, FontVariation};
 use crate::analysis::cluster::{Char, CharCluster, Status};
-use crate::analysis::{AnalysisDataSources, CharInfo};
 use crate::convert::script_to_harfrust;
 use crate::inline_box::InlineBox;
 use crate::lru_cache::LruCache;

parley/src/shape/mod.rs

@@ -1,11 +1,11 @@
 // Copyright 2025 the Parley Authors
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-use crate::analysis::Boundary;
 use crate::{FontContext, LayoutContext, RangedBuilder, StyleProperty, WordBreak};
 use alloc::{vec, vec::Vec};
 use fontique::FontWeight;
 use icu_properties::props::{GraphemeClusterBreak, Script};
+use parley_core::Boundary;
 
 #[derive(Default)]
 struct TestContext {
@@ -26,7 +26,7 @@ impl TestContext {
     }
 
     fn expect_bidi_embed_level_list(self, expected: Vec<u8>) -> Self {
-        let actual = self.layout_context.bidi.levels();
+        let actual = self.layout_context.analysis.bidi_levels();
         assert_eq!(actual, expected, "Bidi embed level list mismatch");
         self
     }