From 3f39e24e7594f81f7ee32db4e59f18ae8f342af2 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 1 Oct 2026 19:43:47 -0600 Subject: [PATCH] [subset] Partially instantiate lookup conditions Reduce LookupVariationRecord conditions to false, true, or a residual condition when axes are pinned or restricted. Fold compound AND, OR, and NOT conditions, remap value-condition variation indices, and emit a constant condition when a surviving lookup becomes unconditional. Extend the test font with a second axis and all condition formats so the subset tests cover structural, full, and partial instancing behavior. Tested with the full Meson test suite, targeted Clang HB_NO_VAR and GCC builds, and OTS validation of the fixture. Assisted-by: OpenAI Codex --- src/hb-ot-layout-common.hh | 258 +++++++++++++++++- test/api/test-ot-layout.c | 2 +- test/api/test-shape-plan.c | 2 +- test/api/test-subset.c | 58 +++- ...b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf | Bin 1220 -> 0 bytes ...30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf | Bin 0 -> 1344 bytes .../data/in-house/tests/variations.tests | 10 +- 7 files changed, 316 insertions(+), 14 deletions(-) delete mode 100644 test/shape/data/in-house/fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf create mode 100644 test/shape/data/in-house/fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf diff --git a/src/hb-ot-layout-common.hh b/src/hb-ot-layout-common.hh index 4ec2c7ebe..e47fc2ba0 100644 --- a/src/hb-ot-layout-common.hh +++ b/src/hb-ot-layout-common.hh @@ -4217,6 +4217,14 @@ enum Cond_with_Var_flag_t DROP_RECORD_WITH_VAR = 3, }; +enum lookup_condition_subset_result_t +{ + LOOKUP_CONDITION_SUBSET_ERROR, + LOOKUP_CONDITION_SUBSET_FALSE, + LOOKUP_CONDITION_SUBSET_TRUE, + LOOKUP_CONDITION_SUBSET_KEEP, +}; + struct Condition; template @@ -4413,6 +4421,7 @@ struct ConditionAnd auto *out = c->serializer->start_embed (this); if (unlikely (!out || !c->serializer->extend_min (out))) return_trace (false); + out->format = format; for (const auto &offset : conditions) if (unlikely (!subset_offset_array (c, out->conditions, this) (offset))) @@ -4468,6 +4477,7 @@ struct ConditionOr auto *out = c->serializer->start_embed (this); if (unlikely (!out || !c->serializer->extend_min (out))) return_trace (false); + out->format = format; for (const auto &offset : conditions) if (unlikely (!subset_offset_array (c, out->conditions, this) (offset))) @@ -4560,6 +4570,11 @@ struct ConditionNegate struct Condition { + lookup_condition_subset_result_t subset_lookup_condition ( + hb_subset_context_t *c, + unsigned depth = HB_MAX_NESTING_LEVEL, + bool materialize_true = false) const; + template bool evaluate (const int *coords, unsigned int coord_len, Instancer *instancer) const @@ -4616,6 +4631,11 @@ struct Condition const Condition *src, const hb_map_t &varidx_map); + private: + lookup_condition_subset_result_t subset_lookup_condition_impl ( + hb_subset_context_t *c, + unsigned depth) const; + protected: union { struct { HBUINT16 v; } format; /* Format identifier */ @@ -4774,6 +4794,231 @@ Condition::serialize (hb_serialize_context_t *c, } } +inline lookup_condition_subset_result_t +Condition::subset_lookup_condition (hb_subset_context_t *c, + unsigned depth, + bool materialize_true) const +{ + auto snap = c->serializer->snapshot (); + lookup_condition_subset_result_t result = + subset_lookup_condition_impl (c, depth); + if (result == LOOKUP_CONDITION_SUBSET_KEEP) + return result; + + c->serializer->revert (snap); + if (result != LOOKUP_CONDITION_SUBSET_TRUE || !materialize_true) + return result; + + auto *out = c->serializer->start_embed (); + if (unlikely (!out || !c->serializer->extend_min (out))) + return LOOKUP_CONDITION_SUBSET_ERROR; + out->format = 2; + out->defaultValue = 1; + out->varIdx = VarIdx::NO_VARIATION; + return LOOKUP_CONDITION_SUBSET_KEEP; +} + +inline lookup_condition_subset_result_t +Condition::subset_lookup_condition_impl (hb_subset_context_t *c, + unsigned depth) const +{ + if (unlikely (!depth)) + return LOOKUP_CONDITION_SUBSET_ERROR; + + auto subset_offset = [c, depth] (auto &out, + const Condition &condition) + -> lookup_condition_subset_result_t + { + auto snap = c->serializer->snapshot (); + auto *offset = out.serialize_append (c->serializer); + if (unlikely (!offset)) + return LOOKUP_CONDITION_SUBSET_ERROR; + + c->serializer->push (); + lookup_condition_subset_result_t result = + condition.subset_lookup_condition (c, depth - 1); + if (result == LOOKUP_CONDITION_SUBSET_KEEP) + c->serializer->add_link (*offset, c->serializer->pop_pack ()); + else + { + c->serializer->pop_discard (); + out.pop (); + c->serializer->revert (snap); + } + return result; + }; + + switch (u.format.v) + { + case 1: + { + const ConditionAxisRange &src = u.format1; + if (c->plan->user_axes_location.is_empty ()) + return c->serializer->embed (&src) ? + LOOKUP_CONDITION_SUBSET_KEEP : + LOOKUP_CONDITION_SUBSET_ERROR; + + hb_codepoint_t *axis_tag; + if (!c->plan->axes_old_index_tag_map.has (src.axisIndex, &axis_tag)) + return LOOKUP_CONDITION_SUBSET_ERROR; + + Triple axis_limit {-1.0, 0.0, 1.0}; + Triple *normalized_limit; + if (c->plan->axes_location.has (*axis_tag, &normalized_limit)) + axis_limit = *normalized_limit; + + double filter_min = (double) src.filterRangeMinValue.to_float (); + double filter_max = (double) src.filterRangeMaxValue.to_float (); + if (filter_min > filter_max) + return LOOKUP_CONDITION_SUBSET_FALSE; + if (axis_limit.is_point ()) + return filter_min <= axis_limit.middle && + axis_limit.middle <= filter_max ? + LOOKUP_CONDITION_SUBSET_TRUE : + LOOKUP_CONDITION_SUBSET_FALSE; + if (axis_limit.maximum < filter_min || + filter_max < axis_limit.minimum) + return LOOKUP_CONDITION_SUBSET_FALSE; + if (filter_min <= axis_limit.minimum && + axis_limit.maximum <= filter_max) + return LOOKUP_CONDITION_SUBSET_TRUE; + if (!c->plan->axes_index_map.has (src.axisIndex)) + return LOOKUP_CONDITION_SUBSET_ERROR; + + auto *out = c->serializer->embed (&src); + if (unlikely (!out)) + return LOOKUP_CONDITION_SUBSET_ERROR; + + TripleDistances axis_distances {1.0, 1.0}; + TripleDistances *distances; + if (c->plan->axes_triple_distances.has (*axis_tag, &distances)) + axis_distances = *distances; + + out->filterRangeMinValue.set_float ( + renormalizeValue (filter_min, axis_limit, axis_distances, false)); + out->filterRangeMaxValue.set_float ( + renormalizeValue (filter_max, axis_limit, axis_distances, false)); + if (unlikely (!c->serializer->check_assign ( + out->axisIndex, + c->plan->axes_index_map.get (src.axisIndex), + HB_SERIALIZE_ERROR_INT_OVERFLOW))) + return LOOKUP_CONDITION_SUBSET_ERROR; + return LOOKUP_CONDITION_SUBSET_KEEP; + } + + case 2: + { + const ConditionValue &src = u.format2; + auto *out = c->serializer->embed (&src); + if (unlikely (!out)) + return LOOKUP_CONDITION_SUBSET_ERROR; + + if (src.varIdx == VarIdx::NO_VARIATION) + return c->plan->user_axes_location.is_empty () ? + LOOKUP_CONDITION_SUBSET_KEEP : + ((int) src.defaultValue > 0 ? + LOOKUP_CONDITION_SUBSET_TRUE : + LOOKUP_CONDITION_SUBSET_FALSE); + + hb_pair_t *new_varidx_delta; + if (!c->plan->layout_variation_idx_delta_map.has (src.varIdx, + &new_varidx_delta)) + return c->plan->user_axes_location.is_empty () ? + LOOKUP_CONDITION_SUBSET_KEEP : + ((int) src.defaultValue > 0 ? + LOOKUP_CONDITION_SUBSET_TRUE : + LOOKUP_CONDITION_SUBSET_FALSE); + + int default_value = (int) src.defaultValue + + hb_second (*new_varidx_delta); + if (unlikely (!c->serializer->check_assign ( + out->defaultValue, + default_value, + HB_SERIALIZE_ERROR_INT_OVERFLOW))) + return LOOKUP_CONDITION_SUBSET_ERROR; + out->varIdx = hb_first (*new_varidx_delta); + + if (!c->plan->user_axes_location.is_empty () && + out->varIdx == VarIdx::NO_VARIATION) + return default_value > 0 ? + LOOKUP_CONDITION_SUBSET_TRUE : + LOOKUP_CONDITION_SUBSET_FALSE; + return LOOKUP_CONDITION_SUBSET_KEEP; + } + + case 3: + { + const ConditionAnd &src = u.format3; + auto *out = c->serializer->start_embed (&src); + if (unlikely (!out || !c->serializer->extend_min (out))) + return LOOKUP_CONDITION_SUBSET_ERROR; + out->format = 3; + + for (const auto &offset : src.conditions) + { + lookup_condition_subset_result_t result = + subset_offset (out->conditions, &src + offset); + if (result == LOOKUP_CONDITION_SUBSET_ERROR || + result == LOOKUP_CONDITION_SUBSET_FALSE) + return result; + } + return out->conditions ? + LOOKUP_CONDITION_SUBSET_KEEP : + LOOKUP_CONDITION_SUBSET_TRUE; + } + + case 4: + { + const ConditionOr &src = u.format4; + auto *out = c->serializer->start_embed (&src); + if (unlikely (!out || !c->serializer->extend_min (out))) + return LOOKUP_CONDITION_SUBSET_ERROR; + out->format = 4; + + for (const auto &offset : src.conditions) + { + lookup_condition_subset_result_t result = + subset_offset (out->conditions, &src + offset); + if (result == LOOKUP_CONDITION_SUBSET_ERROR || + result == LOOKUP_CONDITION_SUBSET_TRUE) + return result; + } + return out->conditions ? + LOOKUP_CONDITION_SUBSET_KEEP : + LOOKUP_CONDITION_SUBSET_FALSE; + } + + case 5: + { + const ConditionNegate &src = u.format5; + auto *out = c->serializer->embed (&src); + if (unlikely (!out)) + return LOOKUP_CONDITION_SUBSET_ERROR; + out->condition = 0; + + c->serializer->push (); + lookup_condition_subset_result_t result = + (&src + src.condition).subset_lookup_condition (c, depth - 1); + if (result == LOOKUP_CONDITION_SUBSET_KEEP) + { + c->serializer->add_link (out->condition, + c->serializer->pop_pack ()); + return result; + } + + c->serializer->pop_discard (); + if (result == LOOKUP_CONDITION_SUBSET_TRUE) + return LOOKUP_CONDITION_SUBSET_FALSE; + if (result == LOOKUP_CONDITION_SUBSET_FALSE) + return LOOKUP_CONDITION_SUBSET_TRUE; + return result; + } + + default: + return LOOKUP_CONDITION_SUBSET_FALSE; + } +} + struct ConditionSet { bool evaluate (const int *coords, unsigned int coord_len, @@ -5190,8 +5435,19 @@ struct LookupConditionRecord auto *out = c->serializer->embed (this); if (unlikely (!out)) return_trace (false); - if (unlikely (!out->condition.serialize_subset (c, condition, base))) + out->condition = 0; + c->serializer->push (); + lookup_condition_subset_result_t result = + (base + condition).subset_lookup_condition (c, + HB_MAX_NESTING_LEVEL, + true); + if (result != LOOKUP_CONDITION_SUBSET_KEEP) + { + c->serializer->pop_discard (); return_trace (false); + } + c->serializer->add_link (out->condition, c->serializer->pop_pack ()); + return_trace (out->lookupIndices.serialize_subset (c, lookupIndices, base, l)); } diff --git a/test/api/test-ot-layout.c b/test/api/test-ot-layout.c index f20583dbd..b5d8a07d2 100644 --- a/test/api/test-ot-layout.c +++ b/test/api/test-ot-layout.c @@ -298,7 +298,7 @@ static void test_ot_layout_collect_lookup_variations (void) { hb_face_t *face = hb_test_open_font_file ( - "../shape/data/in-house/fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf"); + "../shape/data/in-house/fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf"); const hb_tag_t features[] = {HB_TAG ('l','i','g','a'), HB_TAG_NONE}; hb_set_t *lookups = hb_set_create (); diff --git a/test/api/test-shape-plan.c b/test/api/test-shape-plan.c index 9852fa9a9..9946e5c2b 100644 --- a/test/api/test-shape-plan.c +++ b/test/api/test-shape-plan.c @@ -323,7 +323,7 @@ static void test_ot_shape_plan_lookup_variations_cache (void) { hb_face_t *face = hb_test_open_font_file ( - "../shape/data/in-house/fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf"); + "../shape/data/in-house/fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf"); hb_segment_properties_t props = HB_SEGMENT_PROPERTIES_DEFAULT; int coords[] = {0}; diff --git a/test/api/test-subset.c b/test/api/test-subset.c index 496cd4a98..a27885e27 100644 --- a/test/api/test-subset.c +++ b/test/api/test-subset.c @@ -96,7 +96,8 @@ test_subset_crash (void) static void assert_lookup_variations_shape (hb_face_t *face, const int *coords, - unsigned coord_count) + unsigned coord_count, + const hb_codepoint_t *expected) { hb_font_t *font = hb_font_create (face); hb_font_set_var_coords_normalized (font, coords, coord_count); @@ -108,8 +109,7 @@ assert_lookup_variations_shape (hb_face_t *face, unsigned length; const hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, &length); - const hb_codepoint_t expected[] = {2, 4, 6, 8, 9, 10}; - g_assert_cmpuint (length, ==, G_N_ELEMENTS (expected)); + g_assert_cmpuint (length, ==, 6); for (unsigned i = 0; i < length; i++) g_assert_cmpuint (info[i].codepoint, ==, expected[i]); @@ -121,7 +121,11 @@ static void test_subset_lookup_variations (void) { hb_face_t *face = hb_test_open_font_file ( - "../shape/data/in-house/fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf"); + "../shape/data/in-house/fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf"); + const hb_codepoint_t expected_all[] = {2, 4, 6, 8, 9, 10}; + const hb_codepoint_t expected_test_08_dumy_08[] = {2, 3, 6, 8, 9, 10}; + const hb_codepoint_t expected_test_03_dumy_0[] = {2, 4, 5, 7, 8, 11}; + const hb_codepoint_t expected_test_03_dumy_08[] = {2, 3, 6, 7, 8, 11}; hb_subset_input_t *input = hb_subset_input_create_or_fail (); hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F'); @@ -132,7 +136,24 @@ test_subset_lookup_variations (void) hb_face_t *subset = hb_subset_or_fail (face, input); g_assert_nonnull (subset); int coords[] = {13107}; /* 0.8 */ - assert_lookup_variations_shape (subset, coords, 1); + assert_lookup_variations_shape (subset, coords, 1, expected_all); + + hb_face_destroy (subset); + hb_subset_input_destroy (input); + + input = hb_subset_input_create_or_fail (); + hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F'); + features = hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG); + hb_set_clear (features); + hb_set_add (features, HB_TAG ('l', 'i', 'g', 'a')); + g_assert_true (hb_subset_input_pin_axis_location ( + input, face, HB_TAG ('T', 'E', 'S', 'T'), 0.8f)); + g_assert_true (hb_subset_input_pin_axis_location ( + input, face, HB_TAG ('D', 'U', 'M', 'Y'), 0.f)); + + subset = hb_subset_or_fail (face, input); + g_assert_nonnull (subset); + assert_lookup_variations_shape (subset, NULL, 0, expected_all); hb_face_destroy (subset); hb_subset_input_destroy (input); @@ -147,7 +168,32 @@ test_subset_lookup_variations (void) subset = hb_subset_or_fail (face, input); g_assert_nonnull (subset); - assert_lookup_variations_shape (subset, NULL, 0); + coords[0] = 0; + assert_lookup_variations_shape (subset, coords, 1, expected_all); + coords[0] = 13107; /* DUMY=0.8 */ + assert_lookup_variations_shape ( + subset, coords, 1, expected_test_08_dumy_08); + + hb_face_destroy (subset); + hb_subset_input_destroy (input); + + input = hb_subset_input_create_or_fail (); + hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F'); + features = hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG); + hb_set_clear (features); + hb_set_add (features, HB_TAG ('l', 'i', 'g', 'a')); + hb_set_add (features, HB_TAG ('r', 'l', 'i', 'g')); + g_assert_true (hb_subset_input_pin_axis_location ( + input, face, HB_TAG ('T', 'E', 'S', 'T'), 0.3f)); + + subset = hb_subset_or_fail (face, input); + g_assert_nonnull (subset); + coords[0] = 0; + assert_lookup_variations_shape ( + subset, coords, 1, expected_test_03_dumy_0); + coords[0] = 13107; /* DUMY=0.8 */ + assert_lookup_variations_shape ( + subset, coords, 1, expected_test_03_dumy_08); hb_face_destroy (subset); hb_subset_input_destroy (input); diff --git a/test/shape/data/in-house/fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf b/test/shape/data/in-house/fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf deleted file mode 100644 index c678e7298e0c463a75352c6e49fb9ee8fd922ef0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1220 zcmah}&ubG=5dPloCTXeGBB6)S%C^Q>AyiQ)f`ulrjUrK@S!+SCU21;OO*SMOiJrXI zgXlltt=>eudG;XU!J`L31S$Rlp6fSnlh8z=^O$)v-^{$7dGlB(04MMaCNejQ_i}GP zKhFZ@RX~;R7B602n_Im`{U)Qfcj|5vTlhfxBkfH2vDifo|L(h44Xn# zOYWoekNvOIzmS)z1k8E$k}ivOvRV(i#wInWHxx6TzvGIPZ8zL{ zX>V_KpZ+B6cTK+?{9HNUH;r$!w;{cdQ)jQd+B&uT2d4R(2o8R|?;hPnCz*1xCgzy- zA$tz1AtomsC8d#*1E`-l0AL!M>IEW@%8#R=(^p7L$RZ!sVA}XJa)1prsBFa5Go>Dr z9H*4iy>D`IKG=swq4CYUVIspr_@^x#R zNE&lJ-QWaohdN`%@Sx!PyPc-J;kIgSQ1csY+bOk!^-`td@i|dN0Y29*I%vYi23)jI zqYNm0G|(pMpu|1EI`;}AJss6YS>eAE8tzeMnN$YODHAEa$MY(J1r@~w6^mpST`!2_ zw7jn6s+Mb7=0&nc#m>?!5BLsaHD7Qr>A69JsD1;yYng~*C8k%axQMs7A@P*N2Ksj> zbCB6doP{W}=dpxac*v%CVdOD#l-ysVSUBxHz>j OXRYYyS4<k=Bz( zkK)O*CqX?6^&;ZIg9mSV5LA@n)q{8u;`e5g&;+G#^4`q*=9@Qf_RRzez;WDziNw{V z<>bD){|zwL0rm9e()o+?BdJRqUn6UC%X7-uz&`yq^b@%|PUX?_$L|3vN`E@vDm))Mc^^@~s^govUYVdXTfO{H$=x;*KLjCYM_Ism$<`+!!2N4{6e>r)$modeZ z$Xd9@wCmH1qq897L6J6~^-)5VXa-sK0r$!xPo}F`O*BQsW7})h|9_{K zdXFgsXOxL?-r2Lt!i4I=In`~=O*(F1CAGbxZA#mDZPQ|TcEuCNnI-TEMk>9KL7(dc zC8GMCupUx1#Y{}Mn0FAXu*1+@3eVB}&QdF>uka%1;_6XM;W}>f?EH|_D7A~)Y@Jwm zE82M$*_}M8S0~o{53F17Buv1j%KHl6L{ekVw3Uo-0f~?&T=}mFna$lpZ;0q+YLc4c zyVblH{{tk#Ko~)Nk*y4l6so=lRvtz(7!H$!npxP aH~4nAduDzqqhAZ1aJ@om`NmoYrv3stpO97n literal 0 HcmV?d00001 diff --git a/test/shape/data/in-house/tests/variations.tests b/test/shape/data/in-house/tests/variations.tests index 40506ea88..74914b751 100644 --- a/test/shape/data/in-house/tests/variations.tests +++ b/test/shape/data/in-house/tests/variations.tests @@ -4,8 +4,8 @@ ../fonts/ab40c89624a6104e5d0a2308e448a989302f515b.ttf;--variations=wdth=60;U+0020;[space=0+266] ../fonts/ab40c89624a6104e5d0a2308e448a989302f515b.ttf;--variations=wdth=402;U+0020;[space=0+639] ../fonts/e8691822f6a705e3e9fb48a0405c645b1a036590.ttf;--variations=0001=500;U+002E,U+0065;[period=0+681|e=1+650] -../fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf;--variations=TEST=0;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B=1+600|C=2+600|D=3+600|E=4+600|F=5+600] -../fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf;--variations=TEST=.3;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B.alt=1+600|C=2+600|D=3+600|E=4+600|F.alt=5+600] -../fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf;--variations=TEST=.6;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B.alt=1+600|C.alt=2+600|D=3+600|E=4+600|F.alt=5+600] -../fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf;--variations=TEST=.8;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B.alt=1+600|C.alt=2+600|D.alt=3+600|E=4+600|F.alt=5+600] -../fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf;--variations=TEST=0;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B=1+600|C=2+600|D=3+600|E=4+600|F=5+600] +../fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf;--variations=TEST=0;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B=1+600|C=2+600|D=3+600|E=4+600|F=5+600] +../fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf;--variations=TEST=.3;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B.alt=1+600|C=2+600|D=3+600|E=4+600|F.alt=5+600] +../fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf;--variations=TEST=.6;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B.alt=1+600|C.alt=2+600|D=3+600|E=4+600|F.alt=5+600] +../fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf;--variations=TEST=.8;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B.alt=1+600|C.alt=2+600|D.alt=3+600|E=4+600|F.alt=5+600] +../fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf;--variations=TEST=0;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B=1+600|C=2+600|D=3+600|E=4+600|F=5+600]