@wix/origami-lint 1.34.28 → 1.34.30

package/dist/rules/index.js

@@ -7,13 +7,15 @@ import cssLayoutProperties from "./site-app/css-layout-properties.js";
 import cssSelectors from "./site-app/css-selectors.js";
 import dataValues from "./site-app/data-values.js";
 import globalStyles from "./site-app/global-styles.js";
+import knownTags from "./site-app/known-tags.js";
 import noAbsoluteSection from "./site-app/no-absolute-section.js";
 import pageStructure from "./site-app/page-structure.js";
 import slotAttributes from "./site-app/slot-attributes.js";
 import slotPlacement from "./site-app/slot-placement.js";
 import themeFontIds from "./site-app/theme-font-ids.js";
+import themeFontKnown from "./site-app/theme-font-known.js";
 import themeRoot from "./site-app/theme-root.js";
 import noFreeCode from "./site-app/no-free-code.js";
 // Execution registries combine already-checked rules; only this boundary erases their individual key unions.
-export const ruleRegistry = [allowedImports, noFreeCode, pageStructure, noAbsoluteSection, themeFontIds, slotAttributes, themeRoot, breakpoints, cssFileNesting, globalStyles, applyAndPresets, bindings, dataValues, cssLayoutProperties, cssSelectors, slotPlacement];
+export const ruleRegistry = [allowedImports, noFreeCode, pageStructure, noAbsoluteSection, themeFontIds, themeFontKnown, slotAttributes, themeRoot, breakpoints, cssFileNesting, globalStyles, applyAndPresets, bindings, dataValues, cssLayoutProperties, cssSelectors, slotPlacement, knownTags];
 export { defineRule } from "./site-app/define-rule.js";

package/dist/rules/site-app/allowed-imports.js

@@ -3,12 +3,10 @@
 // refuses a tag from them, parseJsx.ts:471, identity.ts:80; a call is free code, and fn() / ctx() refuse them as a source).
 import path from 'node:path';
 import { CSS_FILES, JSX_FILES } from "../../page-model/index.js";
-import { BUILDERS, RUNTIME_ONLY_BUILDERS, RUNTIME_PACKAGE } from "../../rules-api/index.js";
+import { BUILDERS, INTERACTIONS_PACKAGES, RUNTIME_ONLY_BUILDERS, RUNTIME_PACKAGE } from "../../rules-api/index.js";
 import { GLOBAL_COMPONENTS, GLOBAL_COMPONENTS_FOLDER, GLOBAL_FOLDER, SITE_SRC } from "../../shared/site-files-tree-mapping.js";
 import { defineRule } from "./define-rule.js";
 const CHECKS = ['disallowed_import_source', 'interaction_import', 'missing_global_import_name', 'invalid_global_import_name', 'default_builder_import', 'aliased_builder_import', 'wrong_builder_source'];
-/** The interactions packages, which the import reserves: structure.jsx imports nothing from them. Matched by source, not by name: `Interact` from @site/site-code is the site's own. */
-const INTERACTIONS_PACKAGES = ['interactReact', 'interact', 'motionPresets'];
 const SOURCE_HINT = `Only packages, files in ${path.posix.basename(GLOBAL_FOLDER)}/, and ${CSS_FILES.map((file) => `'./${file}'`).join(' or ')} can be.`;
 export default defineRule({
     name: 'allowed-imports',

package/dist/rules/site-app/known-tags.js

@@ -0,0 +1,100 @@
+// How a structure file writes its tags, as the converter reads them (tagOf and validTagOrIssue, parseJsx.ts, converter 0.88):
+// - a tag is <Name> or <NS.Name>: no <svg:rect>, no <UI.Forms.Input> (tracker CONV-parseJsx.ts:401);
+// - a lowercase tag is an HTML element, which the import refuses: <div> (CONV-parseJsx.ts:379). page-structure already reports
+//   one at the top of the file or directly in a section, so this rule doesn't. <NS.Name> needs `import * as NS` (379);
+// - no component comes from a source that holds none: the runtime (except <Remove>), a menu, `document/…`, @wix/sdk (CONV-parseJsx.ts:351).
+//   The DM's own `document` holds the classic components (<ClassicSection>). allowed-imports reports @wix/interact and
+//   @wix/motion-presets on the import line;
+// - a tag's name is capitalized (CONV-parseJsx.ts:359). It reads the local name: the export imports a context provider as
+//   `import { cartContext as CartContext }`, and only the site's providers tell it apart from `import { image as Image }`.
+// A capitalized tag with no import, <NS.Name> with no NS, and a namespace written as <NS> are TypeScript's (#409): it reports a name not in scope.
+import { INTERACTIONS_PACKAGES, SECTIONS } from "../../rules-api/index.js";
+import { defineRule } from "./define-rule.js";
+const CHECKS = ['unsupported_tag_name', 'html_tag', 'named_import_as_namespace', 'tag_from_reserved_source', 'lowercase_tag'];
+/** The converter's TAG_PATTERN (identity.ts). */
+const TAG_PATTERN = /^[A-Z][A-Za-z0-9_$]*$/;
+/** The sources the converter reserves (isReservedRegistry, identity.ts) that allowed-imports doesn't already report. */
+const RESERVED_SOURCES = ['runtime', 'menu', 'document', 'sdk'];
+/** The one tag the runtime has: the <Remove> wrapper. */
+const RUNTIME_TAG = 'Remove';
+export default defineRule({
+    name: 'known-tags',
+    checks: CHECKS,
+    editors: ['studio2'],
+    callbacks: {
+        JSXElement: (input) => {
+            if (!input.rulesApi.getComponent(input.node))
+                return;
+            if (!checkTagNameShape(input))
+                return;
+            if (!checkTagNotHtml(input))
+                return;
+            if (!checkTagNamespaceImport(input))
+                return;
+            if (!checkTagSource(input))
+                return;
+            checkTagCapitalized(input);
+        },
+    },
+});
+// ── the steps: each reports its problem; one that returns false ends the steps for the tag, as the converter stops at its first ──
+/** Reports <svg:rect> and <UI.Forms.Input> (CONV-parseJsx.ts:401). */
+function checkTagNameShape({ node, rulesApi, report }) {
+    const { name } = node.openingElement;
+    if (name.type === 'JSXIdentifier' || (name.type === 'JSXMemberExpression' && name.object.type === 'JSXIdentifier'))
+        return true;
+    report({ check: 'unsupported_tag_name', loc: name.loc, message: `<${rulesApi.getTagName(node)}> is not a supported tag name: write <Name> or <NS.Name> (one namespace import, one dot).` });
+    return false;
+}
+/** Reports a lowercase tag with no import: an HTML element (CONV-parseJsx.ts:379), unless page-structure reports it already. */
+function checkTagNotHtml({ node, rulesApi, report }) {
+    const { name } = node.openingElement;
+    if (name.type !== 'JSXIdentifier' || !/^[a-z]/.test(name.name) || rulesApi.getImport(node))
+        return true;
+    if (!isReportedByPageStructure(node, rulesApi)) {
+        report({ check: 'html_tag', loc: name.loc, message: `<${name.name}> is an HTML tag, which the import refuses: use an imported component (import { Name } from '@origami-wrappers/<app>/<name>', then <Name>).` });
+    }
+    return false;
+}
+/** Reports <NS.Name> whose NS is imported by name, not as `import * as NS` (CONV-parseJsx.ts:379). With no import at all, it's TypeScript's; from an interactions package, allowed-imports'. */
+function checkTagNamespaceImport({ node, rulesApi, report }) {
+    const { name } = node.openingElement;
+    const found = rulesApi.getImport(node);
+    if (name.type !== 'JSXMemberExpression' || name.object.type !== 'JSXIdentifier' || !found || found.imported === '*' || (found.kind && INTERACTIONS_PACKAGES.includes(found.kind)))
+        return true;
+    const namespace = name.object.name;
+    report({ check: 'named_import_as_namespace', loc: name.loc, message: `<${namespace}.${name.property.name}> reads \`${namespace}\` as a namespace, but \`${namespace}\` is imported by name: import it as \`import * as ${namespace} from '${found.source}'\`, or import ${name.property.name} by name and write <${name.property.name}>.` });
+    return false;
+}
+/** Reports a tag imported from a source that holds no components (CONV-parseJsx.ts:351). <Remove> from the runtime is a wrapper. */
+function checkTagSource({ node, rulesApi, report }) {
+    const found = rulesApi.getImport(node);
+    if (!found?.kind || !RESERVED_SOURCES.includes(found.kind) || (found.kind === 'runtime' && found.imported === RUNTIME_TAG))
+        return true;
+    const tag = rulesApi.getTagName(node);
+    const menuHint = found.kind === 'menu' ? `, and use the menu as a value (items: ${tag}.items)` : '';
+    report({ check: 'tag_from_reserved_source', loc: node.openingElement.name.loc, message: `<${tag}> is imported from '${found.source}', which holds no components (menus, runtime builders, document/…, @wix/sdk): import the component from its @origami-wrappers package${menuHint}.` });
+    return false;
+}
+/** Reports a tag whose name isn't capitalized (CONV-parseJsx.ts:359): its local name, and the name the converter reads (the imported name), both.
+ * A namespace as a tag is TypeScript's; a tag from an interactions package, allowed-imports'. */
+function checkTagCapitalized({ node, rulesApi, report }) {
+    const { name } = node.openingElement;
+    const found = rulesApi.getImport(node);
+    if (name.type !== 'JSXIdentifier' || !found || found.imported === '*' || (found.kind && INTERACTIONS_PACKAGES.includes(found.kind)))
+        return;
+    if (TAG_PATTERN.test(name.name) || TAG_PATTERN.test(found.imported))
+        return;
+    report({ check: 'lowercase_tag', loc: name.loc, message: `<${name.name}> must be capitalized: import the component under its capitalized export name (import { Name } from '${found.source}') and write <Name>; a lowercase tag is an HTML element.` });
+}
+// ── reading the code ──
+/** page-structure reports an element at the top of the file, and one directly in a section: its closest holder, wrappers skipped, is none or a section. */
+function isReportedByPageStructure(node, rulesApi) {
+    for (let holder = node.parent; holder; holder = holder.parent) {
+        if (holder.type !== 'JSXElement' || rulesApi.isWrapper(holder))
+            continue;
+        const type = rulesApi.getType(holder);
+        return type !== null && SECTIONS.includes(type) && rulesApi.getChildElements(holder).includes(node);
+    }
+    return true;
+}

package/dist/rules/site-app/theme-font-ids.js

@@ -1,71 +1,29 @@
 // Every theme font token (`--wst-heading-1-font: normal normal 700 --spx(88)/1em benzin`) must end in exactly one font id
 // from the Wix font catalog in @wix/origami-fonts: no quotes, commas or fallbacks, the same case. The editor reads that
-// family as one Wix font id and fails the import otherwise. A legacy font, which the editor no longer offers, counts as
-// not in the catalog. A `var(…)` token is left alone.
+// family as one Wix font id. The import keeps any family as written (an unknown id, a quoted one, a list, another case),
+// so this is a warning. A legacy font is in the catalog, and the import takes it. A `var(…)` token is left alone.
 // theme.css isn't a file oxlint lints, so the rule runs on each linted page (a theme change lints every page) and
 // marks the page's start; the message names the token's line in theme.css.
-import { fonts } from '@wix/origami-fonts';
-import { reportCssProblem } from "../../rules-api/index.js";
+import { CATALOG_FONTS, readFontShorthand, reportCssProblem } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
 const CHECKS = ['invalid_font_id'];
-const FONT_TOKEN = /^--wst-[\w-]+-font$/;
-// The size in a `font` shorthand, with its optional line height: the family follows it. The number's quantifiers
-// never overlap, so a long run of digits that is not a size fails in linear time.
-const SIZE = /^(?:--spx\(.*\)|calc\(.*\)|(?:\d+(?:\.\d*)?|\.\d+)(?:px|em|rem|%|vw|vh|pt)?)(?:\/\S+)?$/i;
-const FONT_IDS = new Set(fonts.filter((font) => font.permissions !== 'legacy').map((font) => font.id));
 export default defineRule({
     name: 'theme-font-ids',
     checks: CHECKS,
     editors: 'all',
+    severity: 'warn',
     callbacks: {
         Program: (input) => {
-            for (const token of getFontTokens(input))
+            for (const token of input.rulesApi.getThemeFontTokens())
                 hasCatalogFontId(token, input);
         },
     },
 });
 // ── the steps ──
-/** The theme's font tokens: `--wst-…-font`. */
-function getFontTokens({ rulesApi }) {
-    return rulesApi.getThemeTokens().filter(({ name }) => FONT_TOKEN.test(name));
-}
 /** Reports a font token whose family isn't exactly one id from the catalog. A `var(…)` or a value without a family isn't checked. */
 function hasCatalogFontId({ name, value, line }, { report }) {
-    const family = getFontFamily(value);
-    if (family === undefined || FONT_IDS.has(family))
+    const family = readFontShorthand(value)?.family;
+    if (family === undefined || CATALOG_FONTS.has(family))
         return;
     reportCssProblem(report, 'theme.css', line, 'invalid_font_id', `${name} must name exactly one Wix font id from the catalog; found ${family}. Run \`wix origami search-font --font <name>\` for the id.`);
 }
-// ── reading a font value ──
-/** A value split on top-level whitespace, so `--spx(16)/1.3em` stays one part. */
-function splitParts(value) {
-    const parts = [];
-    let depth = 0;
-    let current = '';
-    for (const char of value) {
-        if (char === '(')
-            depth++;
-        else if (char === ')')
-            depth--;
-        if (depth === 0 && /\s/.test(char)) {
-            if (current)
-                parts.push(current);
-            current = '';
-        }
-        else
-            current += char;
-    }
-    if (current)
-        parts.push(current);
-    return parts;
-}
-/** A font shorthand's family as written, after its last size; undefined for `var(…)` or no family. */
-function getFontFamily(value) {
-    if (value.includes('var('))
-        return undefined;
-    const parts = splitParts(value);
-    const size = parts.findLastIndex((part) => SIZE.test(part));
-    if (size === -1 || size === parts.length - 1)
-        return undefined;
-    return parts.slice(size + 1).join(' ');
-}

package/dist/rules/site-app/theme-font-known.js

@@ -0,0 +1,30 @@
+// A theme font token (`--wst-heading-1-font: normal normal 700 --spx(88)/1em benzin`) names a weight its font has, in
+// the Wix font catalog's weights (@wix/origami-fonts); tracker row KIT-fontCatalog. The import keeps the value as written,
+// so a weight the font lacks only renders worse (the browser synthesizes it): a warning. A font that isn't a catalog id is
+// theme-font-ids' warning, not checked again here; nor is a `var(…)`, or `bolder` / `lighter`, which depend on the parent.
+import { CATALOG_FONTS, readFontShorthand, reportCssProblem } from "../../rules-api/index.js";
+import { defineRule } from "./define-rule.js";
+const CHECKS = ['missing_font_weight'];
+export default defineRule({
+    name: 'theme-font-known',
+    checks: CHECKS,
+    editors: ['studio2'],
+    severity: 'warn',
+    callbacks: {
+        Program: checkThemeFontWeights,
+    },
+});
+// ── the steps ──
+/** Each theme font token's weight. */
+function checkThemeFontWeights(input) {
+    for (const token of input.rulesApi.getThemeFontTokens())
+        checkFontTokenWeight(token, input);
+}
+/** Reports a font token whose weight isn't one of its catalog font's weights. */
+function checkFontTokenWeight({ name, value, line }, { report }) {
+    const font = readFontShorthand(value);
+    const weights = font && CATALOG_FONTS.get(font.family)?.weights;
+    if (!font || font.weight === undefined || !weights || weights.includes(font.weight))
+        return;
+    reportCssProblem(report, 'theme.css', line, 'missing_font_weight', `${name} uses weight ${font.weight}, which ${font.family} does not have; the browser will synthesize it. Write one of its weights: ${weights.join(', ')} (rule KIT-fontCatalog).`);
+}

package/dist/rules-api/index.js

@@ -2,5 +2,5 @@
 export { createRulesApi, getOrCreateRulesApi } from "./rules-api.js";
 export { createCssFileReporter, describeAtRule, reportCssProblem } from "./report.js";
 export { bare, getAttribute, getExpression, getKey, getName, getObject, getProperties, getCallbackKind, getParamReadKind, getProperty, isBound, isOneEditAway, isRecord, isReservedAttribute, isStructure, isReadByImport, ownerOf, } from "../shared/utils.js";
-export { BUILDERS, CALLBACK_PROP, DATA_KEY, ELEMENT_PROPS, EVENT_ATTRIBUTE, GLOBAL_SECTIONS, INSTANCE_PROPS, LAYER_ATTRIBUTES, RESERVED_ATTRIBUTES, RESERVED_ENTRY_KEYS, RUNTIME_ONLY_BUILDERS, RUNTIME_PACKAGE, SECTIONS, SHARED_COMP_ID, STRUCTURE, SYSTEM_PACKAGE, TRANSFORM_BUILDERS, TYPED_BUILDERS, WRAPPERS, } from "../shared/constants.js";
-export { BREAKPOINT_AT_RULES, CONTENT_TARGET, getCssChildren, getDashedId, getMixinId, getSegmentClass, getSelectorSegments, isCssIdentifier, isPresetProperty, isSafeCssIdentifier, ORIGAMI_TARGETS, OVERFLOW_TARGET, PREAMBLE_LAYER, readSegment } from "../shared/css.js";
+export { BUILDERS, CATALOG_FONTS, CALLBACK_PROP, DATA_KEY, ELEMENT_PROPS, EVENT_ATTRIBUTE, GLOBAL_SECTIONS, INSTANCE_PROPS, INTERACTIONS_PACKAGES, LAYER_ATTRIBUTES, RESERVED_ATTRIBUTES, RESERVED_ENTRY_KEYS, RUNTIME_ONLY_BUILDERS, RUNTIME_PACKAGE, SECTIONS, SHARED_COMP_ID, STRUCTURE, SYSTEM_PACKAGE, TRANSFORM_BUILDERS, TYPED_BUILDERS, WRAPPERS, } from "../shared/constants.js";
+export { BREAKPOINT_AT_RULES, CONTENT_TARGET, getCssChildren, getDashedId, getMixinId, getSegmentClass, getSelectorSegments, isCssIdentifier, isPresetProperty, isSafeCssIdentifier, ORIGAMI_TARGETS, OVERFLOW_TARGET, PREAMBLE_LAYER, readFontShorthand, readSegment } from "../shared/css.js";

package/dist/rules-api/rules-api.js

@@ -6,7 +6,7 @@ import { GLOBAL_COMPONENTS_FOLDER } from "../shared/site-files-tree-mapping.js";
 import { models, pageId } from "../bi/stats.js";
 import { readPage } from "../page-model/index.js";
 import { getAttributeElements as getHeldElements, getAttributeValue, getChildren, getId, getImport, getImportKind, getImportedName, getPropNames, getSlot, getTagName, getType, hasDataAttributes, isTypeScript } from "../shared/utils.js";
-import { readBreakpointName, readCustomMedia, readThemeTokens } from "../shared/css.js";
+import { readBreakpointName, readCustomMedia, readThemeFontTokens, readThemeTokens } from "../shared/css.js";
 import { WRAPPERS } from "../shared/constants.js";
 import { getEnclosingAtRules, isBaseDeclaration } from "./utils.js";
 /** Theme lines come from @apply inside style.css, so style.css's own lines usually come after them. */
@@ -35,10 +35,12 @@ export function createRulesApi(page) {
         getCss,
         getBaseCss: (component, property) => getCss(component, property).filter(isBaseDeclaration).at(-1),
         getThemeTokens: () => readThemeTokens(page.css.files.theme),
+        getThemeFontTokens: () => readThemeFontTokens(page.css.files.theme),
         getCustomMedia: (kind) => readCustomMedia(page.css.files[kind]),
         getBreakpointName: readBreakpointName,
         getEnclosingAtRules,
         getType: (node) => getType(node, getProgram(node)),
+        isWrapper,
         getTagName,
         getId,
         getChildren,

package/dist/shared/constants.js

@@ -1,9 +1,15 @@
+// The constants more than one part reads: the groups of element types, the packages' names, and what the converter reserves on a tag (reservedAttributes.ts). A rule imports them from rules-api/index.ts; a part from here.
+import { fonts } from '@wix/origami-fonts';
+/** The Wix font catalog (@wix/origami-fonts) by id, legacy fonts too: the import takes a legacy font as it takes any other. */
+export const CATALOG_FONTS = new Map(fonts.map((font) => [font.id, font]));
 /** Any section: rules that don't care which one. */
 export const SECTIONS = ['section', 'header', 'footer'];
 /** A page's reference to a global component (`<HeaderSection_x sharedCompId="…" />`). */
 export const GLOBAL_SECTIONS = ['globalHeader', 'globalFooter', 'globalSection'];
 /** A tag that wraps one component and isn't one itself: `<Remove when={…}>`, `<Interaction interactKey="…">`, `<PinnedToScreen>` (the import drops it). */
 export const WRAPPERS = ['remove', 'interaction', 'pinnedToScreen'];
+/** The interactions packages, which the import reserves: structure.jsx imports nothing from them. Matched by source, not by name: `Interact` from @site/site-code is the site's own. */
+export const INTERACTIONS_PACKAGES = ['interactReact', 'interact', 'motionPresets'];
 /** The name a structure file exports its tree under: `export const Structure = () => (…)`. */
 export const STRUCTURE = 'Structure';
 /** The props a global component's Structure may take: its instance identity, `({ id, className })` (#300). */

package/dist/shared/css.js

@@ -18,6 +18,13 @@ const BASE_CLASS = /^\.[^:[\]"]+/;
 const FUNCTIONAL_PSEUDO = /^:[A-Za-z-]+\([^)]*\)/;
 /** A class after the first: a state (`&.onSale`). */
 const STATE_CLASS = /^\.[^.:[\]"]+/;
+/** A theme font token: `--wst-heading-1-font`. */
+const THEME_FONT_TOKEN = /^--wst-[\w-]+-font$/;
+// The size in a `font` shorthand, with its optional line height: the family follows it. The number's quantifiers
+// never overlap, so a long run of digits that is not a size fails in linear time.
+const FONT_SIZE = /^(?:--spx\(.*\)|calc\(.*\)|(?:\d+(?:\.\d*)?|\.\d+)(?:px|em|rem|%|vw|vh|pt)?)(?:\/\S+)?$/i;
+/** A number weight in a `font` shorthand: before the size, only the weight is a bare number. */
+const FONT_WEIGHT = /^\d+(?:\.\d+)?$/;
 const PSEUDO_CLASS = /^:[A-Za-z-]+/;
 const ATTRIBUTE = /^\[[^\]]*\]/;
 /** Every `--name: value` in a file, wherever it's declared, in order. No file → none. */
@@ -28,6 +35,8 @@ export function readThemeTokens(file) {
     });
     return tokens;
 }
+/** The theme's font tokens (`--wst-heading-1-font: …`), as readThemeTokens reads them. */
+export const readThemeFontTokens = (file) => readThemeTokens(file).filter(({ name }) => THEME_FONT_TOKEN.test(name));
 /** Every `@custom-media --name (query)` at a file's top level, in order, as the import reads them; theme.css's are the site's breakpoints. No file → none. */
 export function readCustomMedia(file) {
     if (file === undefined)
@@ -43,6 +52,51 @@ function parseCustomMedia(params) {
     const [, name = '', query = ''] = /^(\S*)\s*([\s\S]*)$/.exec(params.trim()) ?? [];
     return { name, query };
 }
+/** A `font` shorthand's weight and family; undefined for a `var(…)` or a value with no family after its size. */
+export function readFontShorthand(value) {
+    if (value.includes('var('))
+        return undefined;
+    const parts = splitFontParts(value);
+    const size = parts.findLastIndex((part) => FONT_SIZE.test(part));
+    if (size === -1 || size === parts.length - 1)
+        return undefined;
+    return { weight: readFontWeight(parts.slice(0, size)), family: parts.slice(size + 1).join(' ') };
+}
+/** The weight among a shorthand's parts before its size: a number, `bold`, or 400 (`normal`, or none written). */
+function readFontWeight(parts) {
+    for (const part of parts) {
+        if (FONT_WEIGHT.test(part))
+            return Number(part);
+        const keyword = part.toLowerCase();
+        if (keyword === 'bold')
+            return 700;
+        if (keyword === 'bolder' || keyword === 'lighter')
+            return undefined;
+    }
+    return 400;
+}
+/** A value split on top-level whitespace, so `--spx(16)/1.3em` stays one part. */
+function splitFontParts(value) {
+    const parts = [];
+    let depth = 0;
+    let current = '';
+    for (const char of value) {
+        if (char === '(')
+            depth++;
+        else if (char === ')')
+            depth--;
+        if (depth === 0 && /\s/.test(char)) {
+            if (current)
+                parts.push(current);
+            current = '';
+        }
+        else
+            current += char;
+    }
+    if (current)
+        parts.push(current);
+    return parts;
+}
 /** A container's children, comments aside; none for a node with no block. */
 export const getCssChildren = (node) => (node.nodes ?? []).filter((child) => child.type !== 'comment');
 /** Whether a property picks a preset (css/utils.ts `isPresetProperty`): `--preset` (the rule's own element) or `--preset-<part path>`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-lint",
-  "version": "1.34.28",
+  "version": "1.34.30",
   "description": "Offline lint for an exported Origami site: lints the pages that changed since the last passing run",
   "type": "module",
   "bin": {
@@ -52,5 +52,5 @@
       ]
     }
   },
-  "falconPackageHash": "97fa36a3eb31cb9ae9a81f66fff2679fde030431f3b1767dcaf5154a"
+  "falconPackageHash": "335c078a8c6afc26c556fcd6c71643e777664f3b26b63a3b7b9832a4"
 }