@pikacss/core 0.0.29 → 0.0.31

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/dist/index.cjs +853 -977
  2. package/dist/index.d.cts +429 -427
  3. package/dist/index.d.mts +429 -427
  4. package/dist/index.mjs +853 -976
  5. package/package.json +3 -4
  6. package/dist/index.d.ts +0 -539
package/dist/index.cjs CHANGED
@@ -1,1083 +1,959 @@
1
- 'use strict';
2
1
 
2
+ //#region src/internal/constants.ts
3
3
  const ATOMIC_STYLE_ID_PLACEHOLDER = "%";
4
4
  const ATOMIC_STYLE_ID_PLACEHOLDER_RE_GLOBAL = /%/g;
5
5
 
6
+ //#endregion
7
+ //#region src/internal/utils.ts
6
8
  let _warn = (...args) => {
7
- console.warn("[@pikacss/core]", ...args);
9
+ console.warn("[@pikacss/core]", ...args);
8
10
  };
9
11
  function setWarnFn(fn) {
10
- _warn = fn;
12
+ _warn = fn;
11
13
  }
12
14
  function warn(...args) {
13
- _warn(...args);
15
+ _warn(...args);
14
16
  }
15
17
  const chars = [..."abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"];
16
18
  const numOfChars = chars.length;
17
19
  function numberToChars(num) {
18
- if (num < numOfChars)
19
- return chars[num];
20
- let result = "";
21
- let n = num;
22
- while (n >= 0) {
23
- result += chars[n % numOfChars];
24
- n = Math.floor(n / numOfChars) - 1;
25
- }
26
- return result;
20
+ if (num < numOfChars) return chars[num];
21
+ let result = "";
22
+ let n = num;
23
+ while (n >= 0) {
24
+ result += chars[n % numOfChars];
25
+ n = Math.floor(n / numOfChars) - 1;
26
+ }
27
+ return result;
27
28
  }
28
29
  const UPPER_CASE = /[A-Z]/g;
29
30
  function toKebab(str) {
30
- return str.replace(UPPER_CASE, (c) => `-${c.toLowerCase()}`);
31
+ return str.replace(UPPER_CASE, (c) => `-${c.toLowerCase()}`);
31
32
  }
32
33
  function isNotNullish(value) {
33
- return value != null;
34
+ return value != null;
34
35
  }
35
36
  function isNotString(value) {
36
- return typeof value !== "string";
37
+ return typeof value !== "string";
37
38
  }
38
39
  function isPropertyValue(v) {
39
- if (Array.isArray(v))
40
- return v.length === 2 && isPropertyValue(v[0]) && Array.isArray(v[1]) && v[1].every(isPropertyValue);
41
- if (v == null)
42
- return true;
43
- if (typeof v === "string" || typeof v === "number")
44
- return true;
45
- return false;
40
+ if (Array.isArray(v)) return v.length === 2 && isPropertyValue(v[0]) && Array.isArray(v[1]) && v[1].every(isPropertyValue);
41
+ if (v == null) return true;
42
+ if (typeof v === "string" || typeof v === "number") return true;
43
+ return false;
46
44
  }
47
45
  function serialize(value) {
48
- return JSON.stringify(value);
46
+ return JSON.stringify(value);
49
47
  }
50
48
  function addToSet(set, ...values) {
51
- values.forEach((value) => set.add(value));
49
+ values.forEach((value) => set.add(value));
52
50
  }
53
- function appendAutocompleteSelectors(config, ...selectors) {
54
- addToSet(config.autocomplete.selectors, ...selectors);
51
+ function appendAutocompleteSelectors(config, ...selectors$1) {
52
+ addToSet(config.autocomplete.selectors, ...selectors$1);
55
53
  }
56
54
  function appendAutocompleteStyleItemStrings(config, ...styleItemStrings) {
57
- addToSet(config.autocomplete.styleItemStrings, ...styleItemStrings);
55
+ addToSet(config.autocomplete.styleItemStrings, ...styleItemStrings);
58
56
  }
59
57
  function appendAutocompleteExtraProperties(config, ...properties) {
60
- addToSet(config.autocomplete.extraProperties, ...properties);
58
+ addToSet(config.autocomplete.extraProperties, ...properties);
61
59
  }
62
60
  function appendAutocompleteExtraCssProperties(config, ...properties) {
63
- addToSet(config.autocomplete.extraCssProperties, ...properties);
61
+ addToSet(config.autocomplete.extraCssProperties, ...properties);
64
62
  }
65
63
  function appendAutocompletePropertyValues(config, property, ...tsTypes) {
66
- const current = config.autocomplete.properties.get(property) || [];
67
- config.autocomplete.properties.set(property, [...current, ...tsTypes]);
64
+ const current = config.autocomplete.properties.get(property) || [];
65
+ config.autocomplete.properties.set(property, [...current, ...tsTypes]);
68
66
  }
69
67
  function appendAutocompleteCssPropertyValues(config, property, ...values) {
70
- const current = config.autocomplete.cssProperties.get(property) || [];
71
- config.autocomplete.cssProperties.set(property, [...current, ...values]);
68
+ const current = config.autocomplete.cssProperties.get(property) || [];
69
+ config.autocomplete.cssProperties.set(property, [...current, ...values]);
72
70
  }
73
71
  function renderCSSStyleBlocks(blocks, isFormatted, depth = 0) {
74
- const blockIndent = isFormatted ? " ".repeat(depth) : "";
75
- const blockBodyIndent = isFormatted ? " ".repeat(depth + 1) : "";
76
- const selectorEnd = isFormatted ? " " : "";
77
- const propertySpace = isFormatted ? " " : "";
78
- const lineEnd = isFormatted ? "\n" : "";
79
- const lines = [];
80
- blocks.forEach(({ properties, children }, selector) => {
81
- if (properties.length === 0 && children == null)
82
- return;
83
- lines.push(...[
84
- `${blockIndent}${selector}${selectorEnd}{`,
85
- ...properties.map(({ property, value }) => `${blockBodyIndent}${property}:${propertySpace}${value};`),
86
- ...children != null ? [renderCSSStyleBlocks(children, isFormatted, depth + 1)] : [],
87
- `${blockIndent}}`
88
- ]);
89
- });
90
- return lines.join(lineEnd);
72
+ const blockIndent = isFormatted ? " ".repeat(depth) : "";
73
+ const blockBodyIndent = isFormatted ? " ".repeat(depth + 1) : "";
74
+ const selectorEnd = isFormatted ? " " : "";
75
+ const propertySpace = isFormatted ? " " : "";
76
+ const lineEnd = isFormatted ? "\n" : "";
77
+ const lines = [];
78
+ blocks.forEach(({ properties, children }, selector) => {
79
+ if (properties.length === 0 && (children == null || children.size === 0)) return;
80
+ lines.push(...[
81
+ `${blockIndent}${selector}${selectorEnd}{`,
82
+ ...properties.map(({ property, value }) => `${blockBodyIndent}${property}:${propertySpace}${value};`),
83
+ ...children != null && children.size > 0 ? [renderCSSStyleBlocks(children, isFormatted, depth + 1)] : [],
84
+ `${blockIndent}}`
85
+ ]);
86
+ });
87
+ return lines.join(lineEnd);
91
88
  }
92
89
 
90
+ //#endregion
91
+ //#region src/internal/extractor.ts
93
92
  function replaceBySplitAndJoin(str, split, mapFn, join) {
94
- let splitted = str.split(split);
95
- if (mapFn != null)
96
- splitted = splitted.map(mapFn);
97
- return splitted.join(join);
93
+ let splitted = str.split(split);
94
+ if (mapFn != null) splitted = splitted.map(mapFn);
95
+ return splitted.join(join);
98
96
  }
99
97
  const RE_SPLIT = /\s*,\s*/g;
100
98
  const DEFAULT_SELECTOR_PLACEHOLDER_RE_GLOBAL = /\$/g;
101
99
  const ATTRIBUTE_SUFFIX_MATCH = "$=";
102
100
  const ATTRIBUTE_SUFFIX_MATCH_RE_GLOBAL = /\$=/g;
103
- function normalizeSelectors({
104
- selectors,
105
- defaultSelector
106
- }) {
107
- const normalized = selectors.map(
108
- (s) => replaceBySplitAndJoin(
109
- s.replace(RE_SPLIT, ","),
110
- ATOMIC_STYLE_ID_PLACEHOLDER_RE_GLOBAL,
111
- (a) => replaceBySplitAndJoin(
112
- a,
113
- ATTRIBUTE_SUFFIX_MATCH_RE_GLOBAL,
114
- (b) => replaceBySplitAndJoin(
115
- b,
116
- DEFAULT_SELECTOR_PLACEHOLDER_RE_GLOBAL,
117
- null,
118
- defaultSelector
119
- ),
120
- ATTRIBUTE_SUFFIX_MATCH
121
- ),
122
- ATOMIC_STYLE_ID_PLACEHOLDER
123
- )
124
- );
125
- return normalized;
101
+ function normalizeSelectors({ selectors: selectors$1, defaultSelector }) {
102
+ return selectors$1.map((s) => replaceBySplitAndJoin(s.replace(RE_SPLIT, ","), ATOMIC_STYLE_ID_PLACEHOLDER_RE_GLOBAL, (a) => replaceBySplitAndJoin(a, ATTRIBUTE_SUFFIX_MATCH_RE_GLOBAL, (b) => replaceBySplitAndJoin(b, DEFAULT_SELECTOR_PLACEHOLDER_RE_GLOBAL, null, defaultSelector), ATTRIBUTE_SUFFIX_MATCH), ATOMIC_STYLE_ID_PLACEHOLDER));
126
103
  }
127
104
  function normalizeValue(value) {
128
- if (value == null)
129
- return value;
130
- return [...new Set([value].flat(2).map((v) => String(v).trim()))];
131
- }
132
- async function extract({
133
- styleDefinition,
134
- levels = [],
135
- result = [],
136
- defaultSelector,
137
- transformSelectors,
138
- transformStyleItems,
139
- transformStyleDefinitions
140
- }) {
141
- for (const definition of await transformStyleDefinitions([styleDefinition])) {
142
- for (const [k, v] of Object.entries(definition)) {
143
- if (isPropertyValue(v)) {
144
- const selector = normalizeSelectors({
145
- selectors: await transformSelectors(levels),
146
- defaultSelector
147
- });
148
- if (selector.length === 0 || selector.every((s) => s.includes(ATOMIC_STYLE_ID_PLACEHOLDER) === false))
149
- selector.push(defaultSelector);
150
- result.push({
151
- selector,
152
- property: toKebab(k),
153
- value: normalizeValue(v)
154
- });
155
- } else if (Array.isArray(v)) {
156
- for (const styleItem of await transformStyleItems(v)) {
157
- if (typeof styleItem === "string")
158
- continue;
159
- await extract({
160
- styleDefinition: styleItem,
161
- levels: [...levels, k],
162
- result,
163
- transformSelectors,
164
- transformStyleItems,
165
- transformStyleDefinitions,
166
- defaultSelector
167
- });
168
- }
169
- } else {
170
- await extract({
171
- styleDefinition: v,
172
- levels: [...levels, k],
173
- result,
174
- transformSelectors,
175
- transformStyleItems,
176
- transformStyleDefinitions,
177
- defaultSelector
178
- });
179
- }
180
- }
181
- }
182
- return result;
105
+ if (value == null) return value;
106
+ return [...new Set([value].flat(2).map((v) => String(v).trim()))];
107
+ }
108
+ async function extract({ styleDefinition, levels = [], result = [], defaultSelector, transformSelectors, transformStyleItems, transformStyleDefinitions }) {
109
+ for (const definition of await transformStyleDefinitions([styleDefinition])) for (const [k, v] of Object.entries(definition)) if (isPropertyValue(v)) {
110
+ const selector = normalizeSelectors({
111
+ selectors: await transformSelectors(levels),
112
+ defaultSelector
113
+ });
114
+ if (selector.length === 0 || selector.every((s) => s.includes(ATOMIC_STYLE_ID_PLACEHOLDER) === false)) selector.push(defaultSelector);
115
+ result.push({
116
+ selector,
117
+ property: toKebab(k),
118
+ value: normalizeValue(v)
119
+ });
120
+ } else if (Array.isArray(v)) for (const styleItem of await transformStyleItems(v)) {
121
+ if (typeof styleItem === "string") continue;
122
+ await extract({
123
+ styleDefinition: styleItem,
124
+ levels: [...levels, k],
125
+ result,
126
+ transformSelectors,
127
+ transformStyleItems,
128
+ transformStyleDefinitions,
129
+ defaultSelector
130
+ });
131
+ }
132
+ else await extract({
133
+ styleDefinition: v,
134
+ levels: [...levels, k],
135
+ result,
136
+ transformSelectors,
137
+ transformStyleItems,
138
+ transformStyleDefinitions,
139
+ defaultSelector
140
+ });
141
+ return result;
183
142
  }
184
143
  function createExtractFn(options) {
185
- return (styleDefinition) => extract({
186
- styleDefinition,
187
- ...options
188
- });
144
+ return (styleDefinition) => extract({
145
+ styleDefinition,
146
+ ...options
147
+ });
189
148
  }
190
149
 
150
+ //#endregion
151
+ //#region src/internal/plugin.ts
191
152
  async function execAsyncHook(plugins, hook, payload) {
192
- for (const plugin of plugins) {
193
- if (plugin[hook] == null)
194
- continue;
195
- try {
196
- const newPayload = await plugin[hook](payload);
197
- if (newPayload != null)
198
- payload = newPayload;
199
- } catch (error) {
200
- warn(`Plugin "${plugin.name}" failed to execute hook "${hook}": ${error.message}`, error);
201
- }
202
- }
203
- return payload;
153
+ for (const plugin of plugins) {
154
+ if (plugin[hook] == null) continue;
155
+ try {
156
+ const newPayload = await plugin[hook](payload);
157
+ if (newPayload != null) payload = newPayload;
158
+ } catch (error) {
159
+ warn(`Plugin "${plugin.name}" failed to execute hook "${hook}": ${error.message}`, error);
160
+ }
161
+ }
162
+ return payload;
204
163
  }
205
164
  function execSyncHook(plugins, hook, payload) {
206
- for (const plugin of plugins) {
207
- if (plugin[hook] == null)
208
- continue;
209
- try {
210
- const newPayload = plugin[hook](payload);
211
- if (newPayload != null)
212
- payload = newPayload;
213
- } catch (error) {
214
- warn(`Plugin "${plugin.name}" failed to execute hook "${hook}": ${error.message}`, error);
215
- }
216
- }
217
- return payload;
165
+ for (const plugin of plugins) {
166
+ if (plugin[hook] == null) continue;
167
+ try {
168
+ const newPayload = plugin[hook](payload);
169
+ if (newPayload != null) payload = newPayload;
170
+ } catch (error) {
171
+ warn(`Plugin "${plugin.name}" failed to execute hook "${hook}": ${error.message}`, error);
172
+ }
173
+ }
174
+ return payload;
218
175
  }
219
176
  const hooks = {
220
- configureRawConfig: (plugins, config) => execAsyncHook(plugins, "configureRawConfig", config),
221
- rawConfigConfigured: (plugins, config) => execSyncHook(plugins, "rawConfigConfigured", config),
222
- configureResolvedConfig: (plugins, resolvedConfig) => execAsyncHook(plugins, "configureResolvedConfig", resolvedConfig),
223
- configureEngine: (plugins, engine) => execAsyncHook(plugins, "configureEngine", engine),
224
- transformSelectors: (plugins, selectors) => execAsyncHook(plugins, "transformSelectors", selectors),
225
- transformStyleItems: (plugins, styleItems) => execAsyncHook(plugins, "transformStyleItems", styleItems),
226
- transformStyleDefinitions: (plugins, styleDefinitions) => execAsyncHook(plugins, "transformStyleDefinitions", styleDefinitions),
227
- preflightUpdated: (plugins) => execSyncHook(plugins, "preflightUpdated", void 0),
228
- atomicStyleAdded: (plugins) => execSyncHook(plugins, "atomicStyleAdded", void 0),
229
- autocompleteConfigUpdated: (plugins) => execSyncHook(plugins, "autocompleteConfigUpdated", void 0)
177
+ configureRawConfig: (plugins, config) => execAsyncHook(plugins, "configureRawConfig", config),
178
+ rawConfigConfigured: (plugins, config) => execSyncHook(plugins, "rawConfigConfigured", config),
179
+ configureResolvedConfig: (plugins, resolvedConfig) => execAsyncHook(plugins, "configureResolvedConfig", resolvedConfig),
180
+ configureEngine: (plugins, engine) => execAsyncHook(plugins, "configureEngine", engine),
181
+ transformSelectors: (plugins, selectors$1) => execAsyncHook(plugins, "transformSelectors", selectors$1),
182
+ transformStyleItems: (plugins, styleItems) => execAsyncHook(plugins, "transformStyleItems", styleItems),
183
+ transformStyleDefinitions: (plugins, styleDefinitions) => execAsyncHook(plugins, "transformStyleDefinitions", styleDefinitions),
184
+ preflightUpdated: (plugins) => execSyncHook(plugins, "preflightUpdated", void 0),
185
+ atomicStyleAdded: (plugins) => execSyncHook(plugins, "atomicStyleAdded", void 0),
186
+ autocompleteConfigUpdated: (plugins) => execSyncHook(plugins, "autocompleteConfigUpdated", void 0)
230
187
  };
231
- const orderMap = /* @__PURE__ */ new Map([
232
- [void 0, 1],
233
- ["pre", 0],
234
- ["post", 2]
188
+ const orderMap = new Map([
189
+ [void 0, 1],
190
+ ["pre", 0],
191
+ ["post", 2]
235
192
  ]);
236
193
  function resolvePlugins(plugins) {
237
- return plugins.sort((a, b) => orderMap.get(a.order) - orderMap.get(b.order));
194
+ return plugins.sort((a, b) => orderMap.get(a.order) - orderMap.get(b.order));
238
195
  }
196
+ /* c8 ignore start */
239
197
  function defineEnginePlugin(plugin) {
240
- return plugin;
198
+ return plugin;
241
199
  }
200
+ /* c8 ignore end */
242
201
 
202
+ //#endregion
203
+ //#region src/internal/plugins/important.ts
204
+ function modifyPropertyValue(value) {
205
+ if (value == null) return null;
206
+ if (Array.isArray(value)) return [`${value[0]} !important`, value[1].map((i) => `${i} !important`)];
207
+ return `${value} !important`;
208
+ }
243
209
  function important() {
244
- let defaultValue;
245
- return defineEnginePlugin({
246
- name: "core:important",
247
- rawConfigConfigured(config) {
248
- defaultValue = config.important?.default ?? false;
249
- },
250
- configureEngine(engine) {
251
- engine.appendAutocompleteExtraProperties("__important");
252
- engine.appendAutocompletePropertyValues("__important", "boolean");
253
- },
254
- transformStyleDefinitions(styleDefinitions) {
255
- return styleDefinitions.map((styleDefinition) => {
256
- const { __important, ...rest } = styleDefinition;
257
- const value = __important;
258
- const important2 = value == null ? defaultValue : value;
259
- if (important2 === false)
260
- return rest;
261
- return Object.fromEntries(
262
- Object.entries(rest).map(([k, v]) => {
263
- if (isPropertyValue(v) === false || v == null)
264
- return [k, v];
265
- const modified = [v].flat(2).map((v2) => `${v2} !important`);
266
- return [k, modified];
267
- })
268
- );
269
- });
270
- }
271
- });
210
+ let defaultValue;
211
+ return defineEnginePlugin({
212
+ name: "core:important",
213
+ rawConfigConfigured(config) {
214
+ defaultValue = config.important?.default ?? false;
215
+ },
216
+ configureEngine(engine) {
217
+ engine.appendAutocompleteExtraProperties("__important");
218
+ engine.appendAutocompletePropertyValues("__important", "boolean");
219
+ },
220
+ transformStyleDefinitions(styleDefinitions) {
221
+ return styleDefinitions.map((styleDefinition) => {
222
+ const { __important, ...rest } = styleDefinition;
223
+ const value = __important;
224
+ if ((value == null ? defaultValue : value) === false) return rest;
225
+ return Object.fromEntries(Object.entries(rest).map(([k, v]) => {
226
+ if (isPropertyValue(v)) return [k, modifyPropertyValue(v)];
227
+ return [k, v];
228
+ }));
229
+ });
230
+ }
231
+ });
272
232
  }
273
233
 
234
+ //#endregion
235
+ //#region src/internal/plugins/keyframes.ts
274
236
  function keyframes() {
275
- let resolveKeyframesConfig;
276
- let configList;
277
- return defineEnginePlugin({
278
- name: "core:keyframes",
279
- rawConfigConfigured(config) {
280
- resolveKeyframesConfig = createResolveConfigFn({
281
- pruneUnused: config.keyframes?.pruneUnused
282
- });
283
- configList = config.keyframes?.keyframes ?? [];
284
- },
285
- configureEngine(engine) {
286
- engine.keyframes = {
287
- store: /* @__PURE__ */ new Map(),
288
- add: (...list) => {
289
- list.forEach((config) => {
290
- const resolved = resolveKeyframesConfig(config);
291
- const { name, frames, autocomplete: autocompleteAnimation } = resolved;
292
- if (frames != null)
293
- engine.keyframes.store.set(name, resolved);
294
- engine.appendAutocompleteCssPropertyValues("animationName", name);
295
- engine.appendAutocompleteCssPropertyValues("animation", `${name} `);
296
- if (autocompleteAnimation != null)
297
- engine.appendAutocompleteCssPropertyValues("animation", ...autocompleteAnimation);
298
- });
299
- engine.notifyPreflightUpdated();
300
- }
301
- };
302
- engine.keyframes.add(...configList);
303
- engine.addPreflight((engine2) => {
304
- const maybeUsedName = /* @__PURE__ */ new Set();
305
- engine2.store.atomicStyles.forEach(({ content: { property, value } }) => {
306
- if (property === "animationName") {
307
- value.forEach((name) => maybeUsedName.add(name));
308
- return;
309
- }
310
- if (property === "animation") {
311
- value.forEach((value2) => {
312
- const animations = value2.split(",").map((v) => v.trim());
313
- animations.forEach((animation) => {
314
- addToSet(maybeUsedName, ...animation.split(" "));
315
- });
316
- });
317
- }
318
- });
319
- const maybeUsedKeyframes = Array.from(engine2.keyframes.store.values()).filter(({ name, frames, pruneUnused }) => (pruneUnused === false || maybeUsedName.has(name)) && frames != null);
320
- const preflightDefinition = {};
321
- maybeUsedKeyframes.forEach(({ name, frames }) => {
322
- preflightDefinition[`@keyframes ${name}`] = Object.fromEntries(
323
- Object.entries(frames).map(([frame, properties]) => [
324
- frame,
325
- properties
326
- ])
327
- );
328
- });
329
- return preflightDefinition;
330
- });
331
- }
332
- });
333
- }
334
- function createResolveConfigFn({
335
- pruneUnused: defaultPruneUnused = true
336
- } = {}) {
337
- return function resolveKeyframesConfig(config) {
338
- if (typeof config === "string")
339
- return { name: config, frames: null, autocomplete: [], pruneUnused: defaultPruneUnused };
340
- if (Array.isArray(config)) {
341
- const [name2, frames2, autocomplete2 = [], pruneUnused2 = defaultPruneUnused] = config;
342
- return { name: name2, frames: frames2, autocomplete: autocomplete2, pruneUnused: pruneUnused2 };
343
- }
344
- const { name, frames, autocomplete = [], pruneUnused = defaultPruneUnused } = config;
345
- return { name, frames, autocomplete, pruneUnused };
346
- };
237
+ let resolveKeyframesConfig;
238
+ let configList;
239
+ return defineEnginePlugin({
240
+ name: "core:keyframes",
241
+ rawConfigConfigured(config) {
242
+ resolveKeyframesConfig = createResolveConfigFn({ pruneUnused: config.keyframes?.pruneUnused });
243
+ configList = config.keyframes?.keyframes ?? [];
244
+ },
245
+ configureEngine(engine) {
246
+ engine.keyframes = {
247
+ store: /* @__PURE__ */ new Map(),
248
+ add: (...list) => {
249
+ list.forEach((config) => {
250
+ const resolved = resolveKeyframesConfig(config);
251
+ const { name, frames, autocomplete: autocompleteAnimation } = resolved;
252
+ if (frames != null) engine.keyframes.store.set(name, resolved);
253
+ engine.appendAutocompleteCssPropertyValues("animationName", name);
254
+ engine.appendAutocompleteCssPropertyValues("animation", `${name} `);
255
+ if (autocompleteAnimation != null) engine.appendAutocompleteCssPropertyValues("animation", ...autocompleteAnimation);
256
+ });
257
+ engine.notifyPreflightUpdated();
258
+ }
259
+ };
260
+ engine.keyframes.add(...configList);
261
+ engine.addPreflight((engine$1) => {
262
+ const maybeUsedName = /* @__PURE__ */ new Set();
263
+ engine$1.store.atomicStyles.forEach(({ content: { property, value } }) => {
264
+ if (property === "animationName") {
265
+ value.forEach((name) => maybeUsedName.add(name));
266
+ return;
267
+ }
268
+ if (property === "animation") value.forEach((value$1) => {
269
+ value$1.split(",").map((v) => v.trim()).forEach((animation) => {
270
+ addToSet(maybeUsedName, ...animation.split(" "));
271
+ });
272
+ });
273
+ });
274
+ const maybeUsedKeyframes = Array.from(engine$1.keyframes.store.values()).filter(({ name, frames, pruneUnused }) => (pruneUnused === false || maybeUsedName.has(name)) && frames != null);
275
+ const preflightDefinition = {};
276
+ maybeUsedKeyframes.forEach(({ name, frames }) => {
277
+ preflightDefinition[`@keyframes ${name}`] = Object.fromEntries(Object.entries(frames).map(([frame, properties]) => [frame, properties]));
278
+ });
279
+ return preflightDefinition;
280
+ });
281
+ }
282
+ });
283
+ }
284
+ function createResolveConfigFn({ pruneUnused: defaultPruneUnused = true } = {}) {
285
+ return function resolveKeyframesConfig(config) {
286
+ if (typeof config === "string") return {
287
+ name: config,
288
+ frames: null,
289
+ autocomplete: [],
290
+ pruneUnused: defaultPruneUnused
291
+ };
292
+ if (Array.isArray(config)) {
293
+ const [name$1, frames$1, autocomplete$1 = [], pruneUnused$1 = defaultPruneUnused] = config;
294
+ return {
295
+ name: name$1,
296
+ frames: frames$1,
297
+ autocomplete: autocomplete$1,
298
+ pruneUnused: pruneUnused$1
299
+ };
300
+ }
301
+ const { name, frames, autocomplete = [], pruneUnused = defaultPruneUnused } = config;
302
+ return {
303
+ name,
304
+ frames,
305
+ autocomplete,
306
+ pruneUnused
307
+ };
308
+ };
347
309
  }
348
310
 
349
- class AbstractResolver {
350
- _resolvedResultsMap = /* @__PURE__ */ new Map();
351
- staticRulesMap = /* @__PURE__ */ new Map();
352
- dynamicRulesMap = /* @__PURE__ */ new Map();
353
- onResolved = () => {
354
- };
355
- get staticRules() {
356
- return [...this.staticRulesMap.values()];
357
- }
358
- get dynamicRules() {
359
- return [...this.dynamicRulesMap.values()];
360
- }
361
- addStaticRule(rule) {
362
- this.staticRulesMap.set(rule.key, rule);
363
- return this;
364
- }
365
- removeStaticRule(key) {
366
- const rule = this.staticRulesMap.get(key);
367
- if (rule == null)
368
- return this;
369
- this.staticRulesMap.delete(key);
370
- this._resolvedResultsMap.delete(rule.string);
371
- return this;
372
- }
373
- addDynamicRule(rule) {
374
- this.dynamicRulesMap.set(rule.key, rule);
375
- return this;
376
- }
377
- removeDynamicRule(key) {
378
- const rule = this.dynamicRulesMap.get(key);
379
- if (rule == null)
380
- return this;
381
- const matchedResolvedStringList = Array.from(this._resolvedResultsMap.keys()).filter((string) => rule.stringPattern.test(string));
382
- this.dynamicRulesMap.delete(key);
383
- matchedResolvedStringList.forEach((string) => this._resolvedResultsMap.delete(string));
384
- return this;
385
- }
386
- async _resolve(string) {
387
- const existedResult = this._resolvedResultsMap.get(string);
388
- if (existedResult != null)
389
- return existedResult;
390
- const staticRule = Array.from(this.staticRulesMap.values()).find((rule) => rule.string === string);
391
- if (staticRule != null) {
392
- const resolvedResult = { value: staticRule.resolved };
393
- this._resolvedResultsMap.set(string, resolvedResult);
394
- this.onResolved(string, "static", resolvedResult);
395
- return resolvedResult;
396
- }
397
- let dynamicRule;
398
- let matched;
399
- for (const rule of this.dynamicRulesMap.values()) {
400
- matched = string.match(rule.stringPattern);
401
- if (matched != null) {
402
- dynamicRule = rule;
403
- break;
404
- }
405
- }
406
- if (dynamicRule != null && matched != null) {
407
- const resolvedResult = { value: await dynamicRule.createResolved(matched) };
408
- this._resolvedResultsMap.set(string, resolvedResult);
409
- this.onResolved(string, "dynamic", resolvedResult);
410
- return resolvedResult;
411
- }
412
- return void 0;
413
- }
414
- _setResolvedResult(string, resolved) {
415
- const resolvedResult = this._resolvedResultsMap.get(string);
416
- if (resolvedResult) {
417
- resolvedResult.value = resolved;
418
- return;
419
- }
420
- this._resolvedResultsMap.set(string, { value: resolved });
421
- }
422
- }
311
+ //#endregion
312
+ //#region src/internal/resolver.ts
313
+ var AbstractResolver = class {
314
+ constructor() {
315
+ this._resolvedResultsMap = /* @__PURE__ */ new Map();
316
+ this.staticRulesMap = /* @__PURE__ */ new Map();
317
+ this.dynamicRulesMap = /* @__PURE__ */ new Map();
318
+ this.onResolved = () => {};
319
+ }
320
+ get staticRules() {
321
+ return [...this.staticRulesMap.values()];
322
+ }
323
+ get dynamicRules() {
324
+ return [...this.dynamicRulesMap.values()];
325
+ }
326
+ addStaticRule(rule) {
327
+ this.staticRulesMap.set(rule.key, rule);
328
+ return this;
329
+ }
330
+ removeStaticRule(key) {
331
+ const rule = this.staticRulesMap.get(key);
332
+ if (rule == null) return this;
333
+ this.staticRulesMap.delete(key);
334
+ this._resolvedResultsMap.delete(rule.string);
335
+ return this;
336
+ }
337
+ addDynamicRule(rule) {
338
+ this.dynamicRulesMap.set(rule.key, rule);
339
+ return this;
340
+ }
341
+ removeDynamicRule(key) {
342
+ const rule = this.dynamicRulesMap.get(key);
343
+ if (rule == null) return this;
344
+ const matchedResolvedStringList = Array.from(this._resolvedResultsMap.keys()).filter((string) => rule.stringPattern.test(string));
345
+ this.dynamicRulesMap.delete(key);
346
+ matchedResolvedStringList.forEach((string) => this._resolvedResultsMap.delete(string));
347
+ return this;
348
+ }
349
+ async _resolve(string) {
350
+ const existedResult = this._resolvedResultsMap.get(string);
351
+ if (existedResult != null) return existedResult;
352
+ const staticRule = Array.from(this.staticRulesMap.values()).find((rule) => rule.string === string);
353
+ if (staticRule != null) {
354
+ const resolvedResult = { value: staticRule.resolved };
355
+ this._resolvedResultsMap.set(string, resolvedResult);
356
+ this.onResolved(string, "static", resolvedResult);
357
+ return resolvedResult;
358
+ }
359
+ let dynamicRule;
360
+ let matched;
361
+ for (const rule of this.dynamicRulesMap.values()) {
362
+ matched = string.match(rule.stringPattern);
363
+ if (matched != null) {
364
+ dynamicRule = rule;
365
+ break;
366
+ }
367
+ }
368
+ if (dynamicRule != null && matched != null) {
369
+ const resolvedResult = { value: await dynamicRule.createResolved(matched) };
370
+ this._resolvedResultsMap.set(string, resolvedResult);
371
+ this.onResolved(string, "dynamic", resolvedResult);
372
+ return resolvedResult;
373
+ }
374
+ }
375
+ _setResolvedResult(string, resolved) {
376
+ const resolvedResult = this._resolvedResultsMap.get(string);
377
+ if (resolvedResult) {
378
+ resolvedResult.value = resolved;
379
+ return;
380
+ }
381
+ this._resolvedResultsMap.set(string, { value: resolved });
382
+ }
383
+ };
423
384
 
385
+ //#endregion
386
+ //#region src/internal/plugins/selectors.ts
424
387
  function selectors() {
425
- let engine;
426
- let configList;
427
- return defineEnginePlugin({
428
- name: "core:selectors",
429
- rawConfigConfigured(config) {
430
- configList = config.selectors?.selectors ?? [];
431
- },
432
- configureEngine(_engine) {
433
- engine = _engine;
434
- engine.selectors = {
435
- resolver: new SelectorResolver(),
436
- add: (...list) => {
437
- list.forEach((config) => {
438
- const resolved = resolveSelectorConfig(config);
439
- if (resolved == null)
440
- return;
441
- if (typeof resolved === "string") {
442
- engine.appendAutocompleteSelectors(resolved);
443
- return;
444
- }
445
- if (resolved.type === "static")
446
- engine.selectors.resolver.addStaticRule(resolved.rule);
447
- else if (resolved.type === "dynamic")
448
- engine.selectors.resolver.addDynamicRule(resolved.rule);
449
- engine.appendAutocompleteSelectors(...resolved.autocomplete);
450
- });
451
- }
452
- };
453
- engine.selectors.add(...configList);
454
- engine.selectors.resolver.onResolved = (string, type) => {
455
- if (type === "dynamic") {
456
- engine.appendAutocompleteSelectors(string);
457
- }
458
- };
459
- },
460
- async transformSelectors(selectors2) {
461
- const result = [];
462
- for (const selector of selectors2) {
463
- result.push(...await engine.selectors.resolver.resolve(selector));
464
- }
465
- return result;
466
- }
467
- });
468
- }
469
- class SelectorResolver extends AbstractResolver {
470
- async resolve(selector) {
471
- const resolved = await this._resolve(selector).catch((error) => {
472
- warn(`Failed to resolve selector "${selector}": ${error.message}`, error);
473
- return void 0;
474
- });
475
- if (resolved == null)
476
- return [selector];
477
- const result = [];
478
- for (const s of resolved.value)
479
- result.push(...await this.resolve(s));
480
- this._setResolvedResult(selector, result);
481
- return result;
482
- }
483
- }
388
+ let engine;
389
+ let configList;
390
+ return defineEnginePlugin({
391
+ name: "core:selectors",
392
+ rawConfigConfigured(config) {
393
+ configList = config.selectors?.selectors ?? [];
394
+ },
395
+ configureEngine(_engine) {
396
+ engine = _engine;
397
+ engine.selectors = {
398
+ resolver: new SelectorResolver(),
399
+ add: (...list) => {
400
+ list.forEach((config) => {
401
+ const resolved = resolveSelectorConfig(config);
402
+ if (resolved == null) return;
403
+ if (typeof resolved === "string") {
404
+ engine.appendAutocompleteSelectors(resolved);
405
+ return;
406
+ }
407
+ if (resolved.type === "static") engine.selectors.resolver.addStaticRule(resolved.rule);
408
+ else if (resolved.type === "dynamic") engine.selectors.resolver.addDynamicRule(resolved.rule);
409
+ engine.appendAutocompleteSelectors(...resolved.autocomplete);
410
+ });
411
+ }
412
+ };
413
+ engine.selectors.add(...configList);
414
+ engine.selectors.resolver.onResolved = (string, type) => {
415
+ if (type === "dynamic") engine.appendAutocompleteSelectors(string);
416
+ };
417
+ },
418
+ async transformSelectors(selectors$1) {
419
+ const result = [];
420
+ for (const selector of selectors$1) result.push(...await engine.selectors.resolver.resolve(selector));
421
+ return result;
422
+ }
423
+ });
424
+ }
425
+ var SelectorResolver = class extends AbstractResolver {
426
+ async resolve(selector) {
427
+ const resolved = await this._resolve(selector).catch((error) => {
428
+ warn(`Failed to resolve selector "${selector}": ${error.message}`, error);
429
+ });
430
+ if (resolved == null) return [selector];
431
+ const result = [];
432
+ for (const s of resolved.value) result.push(...await this.resolve(s));
433
+ this._setResolvedResult(selector, result);
434
+ return result;
435
+ }
436
+ };
484
437
  function resolveSelectorConfig(config) {
485
- if (typeof config === "string") {
486
- return config;
487
- }
488
- if (Array.isArray(config)) {
489
- if (typeof config[0] === "string" && typeof config[1] !== "function") {
490
- return {
491
- type: "static",
492
- rule: {
493
- key: config[0],
494
- string: config[0],
495
- resolved: [config[1]].flat(1)
496
- },
497
- autocomplete: [config[0]]
498
- };
499
- }
500
- if (config[0] instanceof RegExp && typeof config[1] === "function") {
501
- const fn = config[1];
502
- return {
503
- type: "dynamic",
504
- rule: {
505
- key: config[0].source,
506
- stringPattern: config[0],
507
- createResolved: async (match) => [await fn(match)].flat(1)
508
- },
509
- autocomplete: config[2] != null ? [config[2]].flat(1) : []
510
- };
511
- }
512
- return void 0;
513
- }
514
- if (typeof config.selector === "string" && typeof config.value !== "function") {
515
- return {
516
- type: "static",
517
- rule: {
518
- key: config.selector,
519
- string: config.selector,
520
- resolved: [config.value].flat(1)
521
- },
522
- autocomplete: [config.selector]
523
- };
524
- }
525
- if (config.selector instanceof RegExp && typeof config.value === "function") {
526
- const fn = config.value;
527
- return {
528
- type: "dynamic",
529
- rule: {
530
- key: config.selector.source,
531
- stringPattern: config.selector,
532
- createResolved: async (match) => [await fn(match)].flat(1)
533
- },
534
- autocomplete: "autocomplete" in config && config.autocomplete != null ? [config.autocomplete].flat(1) : []
535
- };
536
- }
537
- return void 0;
438
+ if (typeof config === "string") return config;
439
+ if (Array.isArray(config)) {
440
+ if (typeof config[0] === "string" && typeof config[1] !== "function") return {
441
+ type: "static",
442
+ rule: {
443
+ key: config[0],
444
+ string: config[0],
445
+ resolved: [config[1]].flat(1)
446
+ },
447
+ autocomplete: [config[0]]
448
+ };
449
+ if (config[0] instanceof RegExp && typeof config[1] === "function") {
450
+ const fn = config[1];
451
+ return {
452
+ type: "dynamic",
453
+ rule: {
454
+ key: config[0].source,
455
+ stringPattern: config[0],
456
+ createResolved: async (match) => [await fn(match)].flat(1)
457
+ },
458
+ autocomplete: config[2] != null ? [config[2]].flat(1) : []
459
+ };
460
+ }
461
+ return;
462
+ }
463
+ if (typeof config.selector === "string" && typeof config.value !== "function") return {
464
+ type: "static",
465
+ rule: {
466
+ key: config.selector,
467
+ string: config.selector,
468
+ resolved: [config.value].flat(1)
469
+ },
470
+ autocomplete: [config.selector]
471
+ };
472
+ if (config.selector instanceof RegExp && typeof config.value === "function") {
473
+ const fn = config.value;
474
+ return {
475
+ type: "dynamic",
476
+ rule: {
477
+ key: config.selector.source,
478
+ stringPattern: config.selector,
479
+ createResolved: async (match) => [await fn(match)].flat(1)
480
+ },
481
+ autocomplete: "autocomplete" in config && config.autocomplete != null ? [config.autocomplete].flat(1) : []
482
+ };
483
+ }
538
484
  }
539
485
 
486
+ //#endregion
487
+ //#region src/internal/plugins/shortcuts.ts
540
488
  function shortcuts() {
541
- let engine;
542
- let configList;
543
- return defineEnginePlugin({
544
- name: "core:shortcuts",
545
- rawConfigConfigured(config) {
546
- configList = config.shortcuts?.shortcuts ?? [];
547
- },
548
- configureEngine(_engine) {
549
- engine = _engine;
550
- engine.shortcuts = {
551
- resolver: new ShortcutResolver(),
552
- add: (...list) => {
553
- list.forEach((config) => {
554
- const resolved = resolveShortcutConfig(config);
555
- if (resolved == null)
556
- return;
557
- if (typeof resolved === "string") {
558
- engine.appendAutocompleteStyleItemStrings(resolved);
559
- return;
560
- }
561
- if (resolved.type === "static")
562
- engine.shortcuts.resolver.addStaticRule(resolved.rule);
563
- else if (resolved.type === "dynamic")
564
- engine.shortcuts.resolver.addDynamicRule(resolved.rule);
565
- engine.appendAutocompleteStyleItemStrings(...resolved.autocomplete);
566
- });
567
- }
568
- };
569
- engine.shortcuts.add(...configList);
570
- engine.shortcuts.resolver.onResolved = (string, type) => {
571
- if (type === "dynamic") {
572
- engine.appendAutocompleteStyleItemStrings(string);
573
- }
574
- };
575
- engine.appendAutocompleteExtraProperties("__shortcut");
576
- const unionType = ["(string & {})", "Autocomplete['StyleItemString']"].join(" | ");
577
- engine.appendAutocompletePropertyValues("__shortcut", unionType, `(${unionType})[]`);
578
- },
579
- async transformStyleItems(styleItems) {
580
- const result = [];
581
- for (const styleItem of styleItems) {
582
- if (typeof styleItem === "string") {
583
- result.push(...await engine.shortcuts.resolver.resolve(styleItem));
584
- continue;
585
- }
586
- result.push(styleItem);
587
- }
588
- return result;
589
- },
590
- async transformStyleDefinitions(styleDefinitions) {
591
- const result = [];
592
- for (const styleDefinition of styleDefinitions) {
593
- if ("__shortcut" in styleDefinition) {
594
- const { __shortcut, ...rest } = styleDefinition;
595
- const applied = [];
596
- for (const shortcut of __shortcut == null ? [] : [__shortcut].flat(1)) {
597
- const resolved = (await engine.shortcuts.resolver.resolve(shortcut)).filter(isNotString);
598
- applied.push(...resolved);
599
- }
600
- result.push(...applied, rest);
601
- } else {
602
- result.push(styleDefinition);
603
- }
604
- }
605
- return result;
606
- }
607
- });
608
- }
609
- class ShortcutResolver extends AbstractResolver {
610
- async resolve(shortcut) {
611
- const resolved = await this._resolve(shortcut).catch((error) => {
612
- warn(`Failed to resolve shortcut "${shortcut}": ${error.message}`, error);
613
- return void 0;
614
- });
615
- if (resolved == null)
616
- return [shortcut];
617
- const result = [];
618
- for (const partial of resolved.value) {
619
- if (typeof partial === "string")
620
- result.push(...await this.resolve(partial));
621
- else
622
- result.push(partial);
623
- }
624
- this._setResolvedResult(shortcut, result);
625
- return result;
626
- }
627
- }
489
+ let engine;
490
+ let configList;
491
+ return defineEnginePlugin({
492
+ name: "core:shortcuts",
493
+ rawConfigConfigured(config) {
494
+ configList = config.shortcuts?.shortcuts ?? [];
495
+ },
496
+ configureEngine(_engine) {
497
+ engine = _engine;
498
+ engine.shortcuts = {
499
+ resolver: new ShortcutResolver(),
500
+ add: (...list) => {
501
+ list.forEach((config) => {
502
+ const resolved = resolveShortcutConfig(config);
503
+ if (resolved == null) return;
504
+ if (typeof resolved === "string") {
505
+ engine.appendAutocompleteStyleItemStrings(resolved);
506
+ return;
507
+ }
508
+ if (resolved.type === "static") engine.shortcuts.resolver.addStaticRule(resolved.rule);
509
+ else if (resolved.type === "dynamic") engine.shortcuts.resolver.addDynamicRule(resolved.rule);
510
+ engine.appendAutocompleteStyleItemStrings(...resolved.autocomplete);
511
+ });
512
+ }
513
+ };
514
+ engine.shortcuts.add(...configList);
515
+ engine.shortcuts.resolver.onResolved = (string, type) => {
516
+ if (type === "dynamic") engine.appendAutocompleteStyleItemStrings(string);
517
+ };
518
+ engine.appendAutocompleteExtraProperties("__shortcut");
519
+ const unionType = ["(string & {})", "Autocomplete['StyleItemString']"].join(" | ");
520
+ engine.appendAutocompletePropertyValues("__shortcut", unionType, `(${unionType})[]`);
521
+ },
522
+ async transformStyleItems(styleItems) {
523
+ const result = [];
524
+ for (const styleItem of styleItems) {
525
+ if (typeof styleItem === "string") {
526
+ result.push(...await engine.shortcuts.resolver.resolve(styleItem));
527
+ continue;
528
+ }
529
+ result.push(styleItem);
530
+ }
531
+ return result;
532
+ },
533
+ async transformStyleDefinitions(styleDefinitions) {
534
+ const result = [];
535
+ for (const styleDefinition of styleDefinitions) if ("__shortcut" in styleDefinition) {
536
+ const { __shortcut, ...rest } = styleDefinition;
537
+ const applied = [];
538
+ for (const shortcut of __shortcut == null ? [] : [__shortcut].flat(1)) {
539
+ const resolved = (await engine.shortcuts.resolver.resolve(shortcut)).filter(isNotString);
540
+ applied.push(...resolved);
541
+ }
542
+ result.push(...applied, rest);
543
+ } else result.push(styleDefinition);
544
+ return result;
545
+ }
546
+ });
547
+ }
548
+ var ShortcutResolver = class extends AbstractResolver {
549
+ async resolve(shortcut) {
550
+ const resolved = await this._resolve(shortcut).catch((error) => {
551
+ warn(`Failed to resolve shortcut "${shortcut}": ${error.message}`, error);
552
+ });
553
+ if (resolved == null) return [shortcut];
554
+ const result = [];
555
+ for (const partial of resolved.value) if (typeof partial === "string") result.push(...await this.resolve(partial));
556
+ else result.push(partial);
557
+ this._setResolvedResult(shortcut, result);
558
+ return result;
559
+ }
560
+ };
628
561
  function resolveShortcutConfig(config) {
629
- if (typeof config === "string") {
630
- return config;
631
- } else if (Array.isArray(config)) {
632
- if (typeof config[0] === "string" && typeof config[1] !== "function") {
633
- return {
634
- type: "static",
635
- rule: {
636
- key: config[0],
637
- string: config[0],
638
- resolved: [config[1]].flat(1)
639
- },
640
- autocomplete: [config[0]]
641
- };
642
- }
643
- if (config[0] instanceof RegExp && typeof config[1] === "function") {
644
- const fn = config[1];
645
- return {
646
- type: "dynamic",
647
- rule: {
648
- key: config[0].source,
649
- stringPattern: config[0],
650
- createResolved: async (match) => [await fn(match)].flat(1)
651
- },
652
- autocomplete: config[2] != null ? [config[2]].flat(1) : []
653
- };
654
- }
655
- } else if (typeof config.shortcut === "string" && typeof config.value !== "function") {
656
- return {
657
- type: "static",
658
- rule: {
659
- key: config.shortcut,
660
- string: config.shortcut,
661
- resolved: [config.value].flat(1)
662
- },
663
- autocomplete: [config.shortcut]
664
- };
665
- } else if (config.shortcut instanceof RegExp && typeof config.value === "function") {
666
- const fn = config.value;
667
- return {
668
- type: "dynamic",
669
- rule: {
670
- key: config.shortcut.source,
671
- stringPattern: config.shortcut,
672
- createResolved: async (match) => [await fn(match)].flat(1)
673
- },
674
- autocomplete: "autocomplete" in config && config.autocomplete != null ? [config.autocomplete].flat(1) : []
675
- };
676
- }
677
- return void 0;
562
+ if (typeof config === "string") return config;
563
+ else if (Array.isArray(config)) {
564
+ if (typeof config[0] === "string" && typeof config[1] !== "function") return {
565
+ type: "static",
566
+ rule: {
567
+ key: config[0],
568
+ string: config[0],
569
+ resolved: [config[1]].flat(1)
570
+ },
571
+ autocomplete: [config[0]]
572
+ };
573
+ if (config[0] instanceof RegExp && typeof config[1] === "function") {
574
+ const fn = config[1];
575
+ return {
576
+ type: "dynamic",
577
+ rule: {
578
+ key: config[0].source,
579
+ stringPattern: config[0],
580
+ createResolved: async (match) => [await fn(match)].flat(1)
581
+ },
582
+ autocomplete: config[2] != null ? [config[2]].flat(1) : []
583
+ };
584
+ }
585
+ } else if (typeof config.shortcut === "string" && typeof config.value !== "function") return {
586
+ type: "static",
587
+ rule: {
588
+ key: config.shortcut,
589
+ string: config.shortcut,
590
+ resolved: [config.value].flat(1)
591
+ },
592
+ autocomplete: [config.shortcut]
593
+ };
594
+ else if (config.shortcut instanceof RegExp && typeof config.value === "function") {
595
+ const fn = config.value;
596
+ return {
597
+ type: "dynamic",
598
+ rule: {
599
+ key: config.shortcut.source,
600
+ stringPattern: config.shortcut,
601
+ createResolved: async (match) => [await fn(match)].flat(1)
602
+ },
603
+ autocomplete: "autocomplete" in config && config.autocomplete != null ? [config.autocomplete].flat(1) : []
604
+ };
605
+ }
678
606
  }
679
607
 
608
+ //#endregion
609
+ //#region src/internal/plugins/variables.ts
680
610
  function variables() {
681
- let resolveVariables;
682
- let rawVariables;
683
- let safeSet;
684
- return defineEnginePlugin({
685
- name: "core:variables",
686
- rawConfigConfigured(config) {
687
- resolveVariables = createResolveVariablesFn({
688
- pruneUnused: config.variables?.pruneUnused
689
- });
690
- rawVariables = config.variables?.variables ?? {};
691
- safeSet = new Set(config.variables?.safeList ?? []);
692
- },
693
- configureEngine(engine) {
694
- engine.variables = {
695
- store: /* @__PURE__ */ new Map(),
696
- add: (variables2) => {
697
- const list = resolveVariables(variables2);
698
- list.forEach((resolved) => {
699
- const { name, value, autocomplete: { asValueOf, asProperty } } = resolved;
700
- asValueOf.forEach((p) => {
701
- if (p !== "-")
702
- engine.appendAutocompleteCssPropertyValues(p, `var(${name})`);
703
- });
704
- if (asProperty)
705
- engine.appendAutocompleteExtraCssProperties(name);
706
- if (value != null) {
707
- const list2 = engine.variables.store.get(name) ?? [];
708
- list2.push(resolved);
709
- engine.variables.store.set(name, list2);
710
- }
711
- });
712
- engine.notifyPreflightUpdated();
713
- }
714
- };
715
- engine.variables.add(rawVariables);
716
- engine.addPreflight(async (engine2) => {
717
- const used = /* @__PURE__ */ new Set();
718
- engine2.store.atomicStyles.forEach(({ content: { value } }) => {
719
- value.flatMap(extractUsedVarNames).forEach((name) => used.add(normalizeVariableName(name)));
720
- });
721
- const usedVariables = Array.from(engine2.variables.store.values()).flat().filter(({ name, pruneUnused, value }) => (safeSet.has(name) || pruneUnused === false || used.has(name)) && value != null);
722
- const preflightDefinition = {};
723
- for (const { name, value, selector: _selector } of usedVariables) {
724
- const selector = await engine2.pluginHooks.transformSelectors(engine2.config.plugins, _selector);
725
- let current = preflightDefinition;
726
- selector.forEach((s) => {
727
- current[s] ||= {};
728
- current = current[s];
729
- });
730
- Object.assign(current, { [name]: value });
731
- }
732
- return preflightDefinition;
733
- });
734
- }
735
- });
736
- }
737
- function createResolveVariablesFn({
738
- pruneUnused: defaultPruneUnused = true
739
- } = {}) {
740
- function _resolveVariables(variables2, levels, result) {
741
- for (const [key, value] of Object.entries(variables2)) {
742
- if (key.startsWith("--")) {
743
- const isObject = typeof value === "object" && value !== null && !Array.isArray(value);
744
- const {
745
- value: varValue,
746
- autocomplete = {},
747
- pruneUnused = defaultPruneUnused
748
- } = isObject ? value : { value };
749
- result.push({
750
- name: key,
751
- value: varValue,
752
- selector: levels.length > 0 ? levels : [":root"],
753
- autocomplete: {
754
- asValueOf: autocomplete.asValueOf ? [autocomplete.asValueOf].flat() : ["*"],
755
- asProperty: autocomplete.asProperty ?? true
756
- },
757
- pruneUnused
758
- });
759
- } else {
760
- _resolveVariables(value, [...levels, key], result);
761
- }
762
- }
763
- return result;
764
- }
765
- return function resolveVariables(variables2) {
766
- return _resolveVariables(variables2, [], []);
767
- };
611
+ let resolveVariables;
612
+ let rawVariables;
613
+ let safeSet;
614
+ return defineEnginePlugin({
615
+ name: "core:variables",
616
+ rawConfigConfigured(config) {
617
+ resolveVariables = createResolveVariablesFn({ pruneUnused: config.variables?.pruneUnused });
618
+ rawVariables = config.variables?.variables ?? {};
619
+ safeSet = new Set(config.variables?.safeList ?? []);
620
+ },
621
+ configureEngine(engine) {
622
+ engine.variables = {
623
+ store: /* @__PURE__ */ new Map(),
624
+ add: (variables$1) => {
625
+ resolveVariables(variables$1).forEach((resolved) => {
626
+ const { name, value, autocomplete: { asValueOf, asProperty } } = resolved;
627
+ asValueOf.forEach((p) => {
628
+ if (p !== "-") engine.appendAutocompleteCssPropertyValues(p, `var(${name})`);
629
+ });
630
+ if (asProperty) engine.appendAutocompleteExtraCssProperties(name);
631
+ if (value != null) {
632
+ const list = engine.variables.store.get(name) ?? [];
633
+ list.push(resolved);
634
+ engine.variables.store.set(name, list);
635
+ }
636
+ });
637
+ engine.notifyPreflightUpdated();
638
+ }
639
+ };
640
+ engine.variables.add(rawVariables);
641
+ engine.addPreflight(async (engine$1) => {
642
+ const used = /* @__PURE__ */ new Set();
643
+ engine$1.store.atomicStyles.forEach(({ content: { value } }) => {
644
+ value.flatMap(extractUsedVarNames).forEach((name) => used.add(normalizeVariableName(name)));
645
+ });
646
+ const usedVariables = Array.from(engine$1.variables.store.values()).flat().filter(({ name, pruneUnused, value }) => (safeSet.has(name) || pruneUnused === false || used.has(name)) && value != null);
647
+ const preflightDefinition = {};
648
+ for (const { name, value, selector: _selector } of usedVariables) {
649
+ const selector = await engine$1.pluginHooks.transformSelectors(engine$1.config.plugins, _selector);
650
+ let current = preflightDefinition;
651
+ selector.forEach((s) => {
652
+ current[s] ||= {};
653
+ current = current[s];
654
+ });
655
+ Object.assign(current, { [name]: value });
656
+ }
657
+ return preflightDefinition;
658
+ });
659
+ }
660
+ });
661
+ }
662
+ function createResolveVariablesFn({ pruneUnused: defaultPruneUnused = true } = {}) {
663
+ function _resolveVariables(variables$1, levels, result) {
664
+ for (const [key, value] of Object.entries(variables$1)) if (key.startsWith("--")) {
665
+ const { value: varValue, autocomplete = {}, pruneUnused = defaultPruneUnused } = typeof value === "object" && value !== null && !Array.isArray(value) ? value : { value };
666
+ result.push({
667
+ name: key,
668
+ value: varValue,
669
+ selector: levels.length > 0 ? levels : [":root"],
670
+ autocomplete: {
671
+ asValueOf: autocomplete.asValueOf ? [autocomplete.asValueOf].flat() : ["*"],
672
+ asProperty: autocomplete.asProperty ?? true
673
+ },
674
+ pruneUnused
675
+ });
676
+ } else _resolveVariables(value, [...levels, key], result);
677
+ return result;
678
+ }
679
+ return function resolveVariables(variables$1) {
680
+ return _resolveVariables(variables$1, [], []);
681
+ };
768
682
  }
769
683
  const VAR_NAME_RE = /var\((--[\w-]+)/g;
770
684
  function extractUsedVarNames(input) {
771
- const matched = input.match(VAR_NAME_RE);
772
- if (!matched)
773
- return [];
774
- return matched.map((match) => {
775
- const varNameMatch = match.match(/--[^,)]+/);
776
- return varNameMatch ? varNameMatch[0] : "";
777
- }).filter(Boolean);
685
+ const matched = input.match(VAR_NAME_RE);
686
+ if (!matched) return [];
687
+ return matched.map((match) => {
688
+ const varNameMatch = match.match(/--[^,)]+/);
689
+ return varNameMatch ? varNameMatch[0] : "";
690
+ }).filter(Boolean);
778
691
  }
779
692
  function normalizeVariableName(name) {
780
- if (name.startsWith("--"))
781
- return name;
782
- return `--${name}`;
693
+ if (name.startsWith("--")) return name;
694
+ return `--${name}`;
783
695
  }
784
696
 
697
+ //#endregion
698
+ //#region src/internal/engine.ts
699
+ /* c8 ignore start */
785
700
  function defineEngineConfig(config) {
786
- return config;
701
+ return config;
787
702
  }
703
+ /* c8 ignore end */
788
704
  async function createEngine(config = {}) {
789
- const corePlugins = [
790
- important(),
791
- variables(),
792
- keyframes(),
793
- selectors(),
794
- shortcuts()
795
- ];
796
- const plugins = resolvePlugins([...corePlugins, ...config.plugins || []]);
797
- config.plugins = plugins;
798
- config = await hooks.configureRawConfig(
799
- config.plugins,
800
- config
801
- );
802
- hooks.rawConfigConfigured(
803
- resolvePlugins(config.plugins || []),
804
- config
805
- );
806
- let resolvedConfig = await resolveEngineConfig(config);
807
- resolvedConfig = await hooks.configureResolvedConfig(
808
- resolvedConfig.plugins,
809
- resolvedConfig
810
- );
811
- let engine = new Engine(resolvedConfig);
812
- engine = await hooks.configureEngine(
813
- engine.config.plugins,
814
- engine
815
- );
816
- return engine;
817
- }
818
- class Engine {
819
- config;
820
- pluginHooks = hooks;
821
- extract;
822
- store = {
823
- atomicStyleIds: /* @__PURE__ */ new Map(),
824
- atomicStyles: /* @__PURE__ */ new Map()
825
- };
826
- constructor(config) {
827
- this.config = config;
828
- this.extract = createExtractFn({
829
- defaultSelector: this.config.defaultSelector,
830
- transformSelectors: (selectors2) => hooks.transformSelectors(this.config.plugins, selectors2),
831
- transformStyleItems: (styleItems) => hooks.transformStyleItems(this.config.plugins, styleItems),
832
- transformStyleDefinitions: (styleDefinitions) => hooks.transformStyleDefinitions(this.config.plugins, styleDefinitions)
833
- });
834
- }
835
- notifyPreflightUpdated() {
836
- hooks.preflightUpdated(this.config.plugins);
837
- }
838
- notifyAtomicStyleAdded(atomicStyle) {
839
- hooks.atomicStyleAdded(this.config.plugins, atomicStyle);
840
- }
841
- notifyAutocompleteConfigUpdated() {
842
- hooks.autocompleteConfigUpdated(this.config.plugins);
843
- }
844
- appendAutocompleteSelectors(...selectors2) {
845
- appendAutocompleteSelectors(this.config, ...selectors2);
846
- this.notifyAutocompleteConfigUpdated();
847
- }
848
- appendAutocompleteStyleItemStrings(...styleItemStrings) {
849
- appendAutocompleteStyleItemStrings(this.config, ...styleItemStrings);
850
- this.notifyAutocompleteConfigUpdated();
851
- }
852
- appendAutocompleteExtraProperties(...properties) {
853
- appendAutocompleteExtraProperties(this.config, ...properties);
854
- this.notifyAutocompleteConfigUpdated();
855
- }
856
- appendAutocompleteExtraCssProperties(...properties) {
857
- appendAutocompleteExtraCssProperties(this.config, ...properties);
858
- this.notifyAutocompleteConfigUpdated();
859
- }
860
- appendAutocompletePropertyValues(property, ...tsTypes) {
861
- appendAutocompletePropertyValues(this.config, property, ...tsTypes);
862
- this.notifyAutocompleteConfigUpdated();
863
- }
864
- appendAutocompleteCssPropertyValues(property, ...values) {
865
- appendAutocompleteCssPropertyValues(this.config, property, ...values);
866
- this.notifyAutocompleteConfigUpdated();
867
- }
868
- addPreflight(preflight) {
869
- this.config.preflights.push(resolvePreflight(preflight));
870
- this.notifyPreflightUpdated();
871
- }
872
- async use(...itemList) {
873
- const {
874
- unknown,
875
- contents
876
- } = await resolveStyleItemList({
877
- itemList,
878
- transformStyleItems: (styleItems) => hooks.transformStyleItems(this.config.plugins, styleItems),
879
- extractStyleDefinition: (styleDefinition) => this.extract(styleDefinition)
880
- });
881
- const resolvedIds = [];
882
- contents.forEach((content) => {
883
- const id = getAtomicStyleId({
884
- content,
885
- prefix: this.config.prefix,
886
- stored: this.store.atomicStyleIds
887
- });
888
- resolvedIds.push(id);
889
- if (!this.store.atomicStyles.has(id)) {
890
- const atomicStyle = { id, content };
891
- this.store.atomicStyles.set(id, atomicStyle);
892
- this.notifyAtomicStyleAdded(atomicStyle);
893
- }
894
- });
895
- return [...unknown, ...resolvedIds];
896
- }
897
- async renderPreflights(isFormatted) {
898
- const lineEnd = isFormatted ? "\n" : "";
899
- return (await Promise.all(this.config.preflights.map(async (p) => {
900
- const result = await p(this, isFormatted);
901
- if (typeof result === "string")
902
- return result;
903
- return renderPreflightDefinition({
904
- engine: this,
905
- preflightDefinition: result,
906
- isFormatted
907
- });
908
- }))).join(lineEnd);
909
- }
910
- async renderAtomicStyles(isFormatted, options = {}) {
911
- const { atomicStyleIds = null, isPreview = false } = options;
912
- const atomicStyles = atomicStyleIds == null ? [...this.store.atomicStyles.values()] : atomicStyleIds.map((id) => this.store.atomicStyles.get(id)).filter(isNotNullish);
913
- return renderAtomicStyles({
914
- atomicStyles,
915
- isPreview,
916
- isFormatted,
917
- defaultSelector: this.config.defaultSelector
918
- });
919
- }
920
- }
705
+ config.plugins = resolvePlugins([...[
706
+ important(),
707
+ variables(),
708
+ keyframes(),
709
+ selectors(),
710
+ shortcuts()
711
+ ], ...config.plugins || []]);
712
+ config = await hooks.configureRawConfig(config.plugins, config);
713
+ hooks.rawConfigConfigured(resolvePlugins(config.plugins || []), config);
714
+ let resolvedConfig = await resolveEngineConfig(config);
715
+ resolvedConfig = await hooks.configureResolvedConfig(resolvedConfig.plugins, resolvedConfig);
716
+ let engine = new Engine(resolvedConfig);
717
+ engine = await hooks.configureEngine(engine.config.plugins, engine);
718
+ return engine;
719
+ }
720
+ var Engine = class {
721
+ constructor(config) {
722
+ this.pluginHooks = hooks;
723
+ this.store = {
724
+ atomicStyleIds: /* @__PURE__ */ new Map(),
725
+ atomicStyles: /* @__PURE__ */ new Map()
726
+ };
727
+ this.config = config;
728
+ this.extract = createExtractFn({
729
+ defaultSelector: this.config.defaultSelector,
730
+ transformSelectors: (selectors$1) => hooks.transformSelectors(this.config.plugins, selectors$1),
731
+ transformStyleItems: (styleItems) => hooks.transformStyleItems(this.config.plugins, styleItems),
732
+ transformStyleDefinitions: (styleDefinitions) => hooks.transformStyleDefinitions(this.config.plugins, styleDefinitions)
733
+ });
734
+ }
735
+ notifyPreflightUpdated() {
736
+ hooks.preflightUpdated(this.config.plugins);
737
+ }
738
+ notifyAtomicStyleAdded(atomicStyle) {
739
+ hooks.atomicStyleAdded(this.config.plugins, atomicStyle);
740
+ }
741
+ notifyAutocompleteConfigUpdated() {
742
+ hooks.autocompleteConfigUpdated(this.config.plugins);
743
+ }
744
+ appendAutocompleteSelectors(...selectors$1) {
745
+ appendAutocompleteSelectors(this.config, ...selectors$1);
746
+ this.notifyAutocompleteConfigUpdated();
747
+ }
748
+ appendAutocompleteStyleItemStrings(...styleItemStrings) {
749
+ appendAutocompleteStyleItemStrings(this.config, ...styleItemStrings);
750
+ this.notifyAutocompleteConfigUpdated();
751
+ }
752
+ appendAutocompleteExtraProperties(...properties) {
753
+ appendAutocompleteExtraProperties(this.config, ...properties);
754
+ this.notifyAutocompleteConfigUpdated();
755
+ }
756
+ appendAutocompleteExtraCssProperties(...properties) {
757
+ appendAutocompleteExtraCssProperties(this.config, ...properties);
758
+ this.notifyAutocompleteConfigUpdated();
759
+ }
760
+ appendAutocompletePropertyValues(property, ...tsTypes) {
761
+ appendAutocompletePropertyValues(this.config, property, ...tsTypes);
762
+ this.notifyAutocompleteConfigUpdated();
763
+ }
764
+ appendAutocompleteCssPropertyValues(property, ...values) {
765
+ appendAutocompleteCssPropertyValues(this.config, property, ...values);
766
+ this.notifyAutocompleteConfigUpdated();
767
+ }
768
+ addPreflight(preflight) {
769
+ this.config.preflights.push(resolvePreflight(preflight));
770
+ this.notifyPreflightUpdated();
771
+ }
772
+ async use(...itemList) {
773
+ const { unknown, contents } = await resolveStyleItemList({
774
+ itemList,
775
+ transformStyleItems: (styleItems) => hooks.transformStyleItems(this.config.plugins, styleItems),
776
+ extractStyleDefinition: (styleDefinition) => this.extract(styleDefinition)
777
+ });
778
+ const resolvedIds = [];
779
+ contents.forEach((content) => {
780
+ const id = getAtomicStyleId({
781
+ content,
782
+ prefix: this.config.prefix,
783
+ stored: this.store.atomicStyleIds
784
+ });
785
+ resolvedIds.push(id);
786
+ if (!this.store.atomicStyles.has(id)) {
787
+ const atomicStyle = {
788
+ id,
789
+ content
790
+ };
791
+ this.store.atomicStyles.set(id, atomicStyle);
792
+ this.notifyAtomicStyleAdded(atomicStyle);
793
+ }
794
+ });
795
+ return [...unknown, ...resolvedIds];
796
+ }
797
+ async renderPreflights(isFormatted) {
798
+ const lineEnd = isFormatted ? "\n" : "";
799
+ return (await Promise.all(this.config.preflights.map(async (p) => {
800
+ const result = await p(this, isFormatted);
801
+ if (typeof result === "string") return result;
802
+ return renderPreflightDefinition({
803
+ engine: this,
804
+ preflightDefinition: result,
805
+ isFormatted
806
+ });
807
+ }))).join(lineEnd);
808
+ }
809
+ async renderAtomicStyles(isFormatted, options = {}) {
810
+ const { atomicStyleIds = null, isPreview = false } = options;
811
+ return renderAtomicStyles({
812
+ atomicStyles: atomicStyleIds == null ? [...this.store.atomicStyles.values()] : atomicStyleIds.map((id) => this.store.atomicStyles.get(id)).filter(isNotNullish),
813
+ isPreview,
814
+ isFormatted,
815
+ defaultSelector: this.config.defaultSelector
816
+ });
817
+ }
818
+ };
921
819
  function calcAtomicStyleRenderingWeight(style, defaultSelector) {
922
- const { selector } = style.content;
923
- const isDefaultSelector = selector.length === 1 && selector[0] === defaultSelector;
924
- return isDefaultSelector ? 0 : selector.length;
820
+ const { selector } = style.content;
821
+ return selector.length === 1 && selector[0] === defaultSelector ? 0 : selector.length;
925
822
  }
926
823
  function resolvePreflight(preflight) {
927
- return typeof preflight === "function" ? preflight : () => preflight;
824
+ return typeof preflight === "function" ? preflight : () => preflight;
928
825
  }
929
826
  async function resolveEngineConfig(config) {
930
- const {
931
- prefix = "",
932
- defaultSelector = `.${ATOMIC_STYLE_ID_PLACEHOLDER}`,
933
- plugins = [],
934
- preflights = []
935
- } = config;
936
- const resolvedConfig = {
937
- rawConfig: config,
938
- plugins: resolvePlugins(plugins),
939
- prefix,
940
- defaultSelector,
941
- preflights: [],
942
- autocomplete: {
943
- selectors: /* @__PURE__ */ new Set(),
944
- styleItemStrings: /* @__PURE__ */ new Set(),
945
- extraProperties: /* @__PURE__ */ new Set(),
946
- extraCssProperties: /* @__PURE__ */ new Set(),
947
- properties: /* @__PURE__ */ new Map(),
948
- cssProperties: /* @__PURE__ */ new Map()
949
- }
950
- };
951
- const resolvedPreflights = preflights.map(resolvePreflight);
952
- resolvedConfig.preflights.push(...resolvedPreflights);
953
- return resolvedConfig;
954
- }
955
- function getAtomicStyleId({
956
- content,
957
- prefix,
958
- stored
959
- }) {
960
- const key = serialize([content.selector, content.property, content.value]);
961
- const cached = stored.get(key);
962
- if (cached != null)
963
- return cached;
964
- const num = stored.size;
965
- const id = `${prefix}${numberToChars(num)}`;
966
- stored.set(key, id);
967
- return id;
827
+ const { prefix = "", defaultSelector = `.${ATOMIC_STYLE_ID_PLACEHOLDER}`, plugins = [], preflights = [] } = config;
828
+ const resolvedConfig = {
829
+ rawConfig: config,
830
+ plugins: resolvePlugins(plugins),
831
+ prefix,
832
+ defaultSelector,
833
+ preflights: [],
834
+ autocomplete: {
835
+ selectors: /* @__PURE__ */ new Set(),
836
+ styleItemStrings: /* @__PURE__ */ new Set(),
837
+ extraProperties: /* @__PURE__ */ new Set(),
838
+ extraCssProperties: /* @__PURE__ */ new Set(),
839
+ properties: /* @__PURE__ */ new Map(),
840
+ cssProperties: /* @__PURE__ */ new Map()
841
+ }
842
+ };
843
+ const resolvedPreflights = preflights.map(resolvePreflight);
844
+ resolvedConfig.preflights.push(...resolvedPreflights);
845
+ return resolvedConfig;
846
+ }
847
+ function getAtomicStyleId({ content, prefix, stored }) {
848
+ const key = serialize([
849
+ content.selector,
850
+ content.property,
851
+ content.value
852
+ ]);
853
+ const cached = stored.get(key);
854
+ if (cached != null) return cached;
855
+ const num = stored.size;
856
+ const id = `${prefix}${numberToChars(num)}`;
857
+ stored.set(key, id);
858
+ return id;
968
859
  }
969
860
  function optimizeAtomicStyleContents(list) {
970
- const map = /* @__PURE__ */ new Map();
971
- list.forEach((content) => {
972
- const key = serialize([content.selector, content.property]);
973
- map.delete(key);
974
- if (content.value == null)
975
- return;
976
- map.set(key, content);
977
- });
978
- return [...map.values()];
979
- }
980
- async function resolveStyleItemList({
981
- itemList,
982
- transformStyleItems,
983
- extractStyleDefinition
984
- }) {
985
- const unknown = /* @__PURE__ */ new Set();
986
- const list = [];
987
- for (const styleItem of await transformStyleItems(itemList)) {
988
- if (typeof styleItem === "string")
989
- unknown.add(styleItem);
990
- else
991
- list.push(...await extractStyleDefinition(styleItem));
992
- }
993
- return {
994
- unknown,
995
- contents: optimizeAtomicStyleContents(list)
996
- };
861
+ const map = /* @__PURE__ */ new Map();
862
+ list.forEach((content) => {
863
+ const key = serialize([content.selector, content.property]);
864
+ map.delete(key);
865
+ if (content.value == null) return;
866
+ map.set(key, content);
867
+ });
868
+ return [...map.values()];
869
+ }
870
+ async function resolveStyleItemList({ itemList, transformStyleItems, extractStyleDefinition }) {
871
+ const unknown = /* @__PURE__ */ new Set();
872
+ const list = [];
873
+ for (const styleItem of await transformStyleItems(itemList)) if (typeof styleItem === "string") unknown.add(styleItem);
874
+ else list.push(...await extractStyleDefinition(styleItem));
875
+ return {
876
+ unknown,
877
+ contents: optimizeAtomicStyleContents(list)
878
+ };
997
879
  }
998
880
  function renderAtomicStyles(payload) {
999
- const { atomicStyles, isPreview, isFormatted, defaultSelector } = payload;
1000
- const blocks = /* @__PURE__ */ new Map();
1001
- Array.from(atomicStyles).sort((a, b) => {
1002
- const weightA = calcAtomicStyleRenderingWeight(a, defaultSelector);
1003
- const weightB = calcAtomicStyleRenderingWeight(b, defaultSelector);
1004
- return weightA - weightB;
1005
- }).forEach(({ id, content: { selector, property, value } }) => {
1006
- const isValidSelector = selector.some((s) => s.includes(ATOMIC_STYLE_ID_PLACEHOLDER));
1007
- if (isValidSelector === false || value == null)
1008
- return;
1009
- const renderObject = {
1010
- selector: isPreview ? selector : selector.map((s) => s.replace(ATOMIC_STYLE_ID_PLACEHOLDER_RE_GLOBAL, id)),
1011
- properties: value.map((v) => ({ property, value: v }))
1012
- };
1013
- let currentBlocks = blocks;
1014
- for (let i = 0; i < renderObject.selector.length; i++) {
1015
- const s = renderObject.selector[i];
1016
- const blockBody = currentBlocks.get(s) || { properties: [] };
1017
- const isLastSelector = i === renderObject.selector.length - 1;
1018
- if (isLastSelector)
1019
- blockBody.properties.push(...renderObject.properties);
1020
- else
1021
- blockBody.children ||= /* @__PURE__ */ new Map();
1022
- currentBlocks.set(s, blockBody);
1023
- if (isLastSelector === false)
1024
- currentBlocks = blockBody.children;
1025
- }
1026
- });
1027
- return renderCSSStyleBlocks(blocks, isFormatted);
1028
- }
1029
- async function _renderPreflightDefinition({
1030
- engine,
1031
- preflightDefinition,
1032
- blocks = /* @__PURE__ */ new Map()
1033
- }) {
1034
- for (const [selector, propertiesOrDefinition] of Object.entries(preflightDefinition)) {
1035
- if (propertiesOrDefinition == null)
1036
- continue;
1037
- const selectors2 = normalizeSelectors({
1038
- selectors: await hooks.transformSelectors(engine.config.plugins, [selector]),
1039
- defaultSelector: ""
1040
- }).filter(Boolean);
1041
- let currentBlocks = blocks;
1042
- let currentBlockBody = null;
1043
- selectors2.forEach((s, i) => {
1044
- const isLast = i === selectors2.length - 1;
1045
- currentBlocks.set(s, currentBlocks.get(s) || { properties: [] });
1046
- if (isLast) {
1047
- currentBlockBody = currentBlocks.get(s);
1048
- return;
1049
- }
1050
- currentBlocks = currentBlocks.get(s).children ||= /* @__PURE__ */ new Map();
1051
- });
1052
- for (const [k, v] of Object.entries(propertiesOrDefinition)) {
1053
- if (isPropertyValue(v)) {
1054
- const property = toKebab(k);
1055
- const normalizedValue = normalizeValue(v);
1056
- if (normalizedValue != null) {
1057
- normalizedValue.forEach((value) => currentBlockBody.properties.push({ property, value }));
1058
- }
1059
- } else {
1060
- currentBlockBody.children ||= /* @__PURE__ */ new Map();
1061
- currentBlockBody.children.set(k, currentBlockBody.children.get(k) || { properties: [] });
1062
- _renderPreflightDefinition({
1063
- engine,
1064
- preflightDefinition: { [k]: v },
1065
- blocks: currentBlockBody.children
1066
- });
1067
- }
1068
- }
1069
- }
1070
- return blocks;
881
+ const { atomicStyles, isPreview, isFormatted, defaultSelector } = payload;
882
+ const blocks = /* @__PURE__ */ new Map();
883
+ Array.from(atomicStyles).sort((a, b) => {
884
+ return calcAtomicStyleRenderingWeight(a, defaultSelector) - calcAtomicStyleRenderingWeight(b, defaultSelector);
885
+ }).forEach(({ id, content: { selector, property, value } }) => {
886
+ if (selector.some((s) => s.includes(ATOMIC_STYLE_ID_PLACEHOLDER)) === false || value == null) return;
887
+ const renderObject = {
888
+ selector: isPreview ? selector : selector.map((s) => s.replace(ATOMIC_STYLE_ID_PLACEHOLDER_RE_GLOBAL, id)),
889
+ properties: value.map((v) => ({
890
+ property,
891
+ value: v
892
+ }))
893
+ };
894
+ let currentBlocks = blocks;
895
+ for (let i = 0; i < renderObject.selector.length; i++) {
896
+ const s = renderObject.selector[i];
897
+ const blockBody = currentBlocks.get(s) || { properties: [] };
898
+ const isLastSelector = i === renderObject.selector.length - 1;
899
+ if (isLastSelector) blockBody.properties.push(...renderObject.properties);
900
+ else blockBody.children ||= /* @__PURE__ */ new Map();
901
+ currentBlocks.set(s, blockBody);
902
+ if (isLastSelector === false) currentBlocks = blockBody.children;
903
+ }
904
+ });
905
+ return renderCSSStyleBlocks(blocks, isFormatted);
906
+ }
907
+ async function _renderPreflightDefinition({ engine, preflightDefinition, blocks = /* @__PURE__ */ new Map() }) {
908
+ for (const [selector, propertiesOrDefinition] of Object.entries(preflightDefinition)) {
909
+ if (propertiesOrDefinition == null) continue;
910
+ const selectors$1 = normalizeSelectors({
911
+ selectors: await hooks.transformSelectors(engine.config.plugins, [selector]),
912
+ defaultSelector: ""
913
+ }).filter(Boolean);
914
+ let currentBlocks = blocks;
915
+ let currentBlockBody = null;
916
+ selectors$1.forEach((s, i) => {
917
+ const isLast = i === selectors$1.length - 1;
918
+ currentBlocks.set(s, currentBlocks.get(s) || { properties: [] });
919
+ if (isLast) {
920
+ currentBlockBody = currentBlocks.get(s);
921
+ return;
922
+ }
923
+ currentBlocks = currentBlocks.get(s).children ||= /* @__PURE__ */ new Map();
924
+ });
925
+ for (const [k, v] of Object.entries(propertiesOrDefinition)) if (isPropertyValue(v)) {
926
+ const property = toKebab(k);
927
+ const normalizedValue = normalizeValue(v);
928
+ if (normalizedValue != null) normalizedValue.forEach((value) => currentBlockBody.properties.push({
929
+ property,
930
+ value
931
+ }));
932
+ } else {
933
+ currentBlockBody.children ||= /* @__PURE__ */ new Map();
934
+ currentBlockBody.children.set(k, currentBlockBody.children.get(k) || { properties: [] });
935
+ await _renderPreflightDefinition({
936
+ engine,
937
+ preflightDefinition: { [k]: v },
938
+ blocks: currentBlockBody.children
939
+ });
940
+ }
941
+ }
942
+ return blocks;
1071
943
  }
1072
944
  async function renderPreflightDefinition(payload) {
1073
- const { engine, preflightDefinition, isFormatted } = payload;
1074
- const blocks = await _renderPreflightDefinition({
1075
- engine,
1076
- preflightDefinition
1077
- });
1078
- return renderCSSStyleBlocks(blocks, isFormatted);
945
+ const { engine, preflightDefinition, isFormatted } = payload;
946
+ return renderCSSStyleBlocks(await _renderPreflightDefinition({
947
+ engine,
948
+ preflightDefinition
949
+ }), isFormatted);
1079
950
  }
1080
951
 
952
+ //#endregion
953
+ //#region src/index.ts
954
+ /* c8 ignore end */
955
+
956
+ //#endregion
1081
957
  exports.appendAutocompleteCssPropertyValues = appendAutocompleteCssPropertyValues;
1082
958
  exports.appendAutocompleteExtraCssProperties = appendAutocompleteExtraCssProperties;
1083
959
  exports.appendAutocompleteExtraProperties = appendAutocompleteExtraProperties;
@@ -1089,4 +965,4 @@ exports.defineEngineConfig = defineEngineConfig;
1089
965
  exports.defineEnginePlugin = defineEnginePlugin;
1090
966
  exports.renderCSSStyleBlocks = renderCSSStyleBlocks;
1091
967
  exports.setWarnFn = setWarnFn;
1092
- exports.warn = warn;
968
+ exports.warn = warn;