@veryfront/ext-css-lightning 0.1.1186 → 0.1.1189

package/esm/deno.d.ts

@@ -0,0 +1,32 @@
+declare namespace _default {
+    let name: string;
+    let version: string;
+    let exports: string;
+    namespace veryfront {
+        let extension: boolean;
+        let activation: string;
+        namespace contracts {
+            let provides: string[];
+        }
+        let capabilities: ({
+            type: string;
+            keys: string[];
+        } | {
+            type: string;
+            keys?: undefined;
+        })[];
+    }
+    let imports: {
+        browserslist: string;
+        lightningcss: string;
+        "@std/assert": string;
+        "@std/testing/bdd": string;
+        "veryfront/extensions": string;
+        "veryfront/extensions/css": string;
+    };
+    namespace tasks {
+        let test: string;
+    }
+}
+export default _default;
+//# sourceMappingURL=deno.d.ts.map

package/esm/deno.d.ts.map

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

package/esm/deno.js

@@ -0,0 +1,35 @@
+export default {
+    "name": "@veryfront/ext-css-lightning",
+    "version": "0.1.0",
+    "exports": "./src/index.ts",
+    "veryfront": {
+        "extension": true,
+        "activation": "explicit",
+        "contracts": {
+            "provides": ["CSSOptimizationEngine"]
+        },
+        "capabilities": [
+            {
+                "type": "env:read",
+                "keys": [
+                    "CSS_TRANSFORMER_WASM",
+                    "BROWSERSLIST_DISABLE_CACHE",
+                    "BROWSERSLIST_IGNORE_OLD_DATA",
+                    "BROWSERSLIST_TRACE_WARNING"
+                ]
+            },
+            { "type": "native:ffi" }
+        ]
+    },
+    "imports": {
+        "browserslist": "npm:browserslist@4.28.7",
+        "lightningcss": "npm:lightningcss@1.29.2",
+        "@std/assert": "jsr:@std/assert@1.0.19",
+        "@std/testing/bdd": "jsr:@std/testing@1.0.17/bdd",
+        "veryfront/extensions": "../../src/extensions/types.ts",
+        "veryfront/extensions/css": "../../src/extensions/css/index.ts"
+    },
+    "tasks": {
+        "test": "deno test --no-lock --allow-env=CSS_TRANSFORMER_WASM,BROWSERSLIST_DISABLE_CACHE,BROWSERSLIST_IGNORE_OLD_DATA,BROWSERSLIST_TRACE_WARNING --allow-ffi src/"
+    }
+};

package/esm/src/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Lightning CSS and Browserslist implementation of CSSOptimizationEngine.
+ *
+ * @module extensions/ext-css-lightning
+ */
+import "../_dnt.polyfills.js";
+import type { ExtensionFactory } from "veryfront/extensions";
+import { type CSSOptimizationEngine, type CSSOptimizationRequest, type CSSOptimizationResult } from "veryfront/extensions/css";
+export interface LightningCSSOptimizationConfig {
+    /** Browserslist expressions resolved once when the extension is created. */
+    readonly browserQueries?: readonly string[];
+}
+/** Parser-backed CSS optimizer provided by this extension. */
+export declare class LightningCSSOptimizationEngine implements CSSOptimizationEngine {
+    #private;
+    readonly cacheIdentity: string;
+    constructor(config?: LightningCSSOptimizationConfig);
+    optimize(request: CSSOptimizationRequest): CSSOptimizationResult;
+}
+declare const extCSSLightning: ExtensionFactory;
+export default extCSSLightning;
+//# sourceMappingURL=index.d.ts.map

package/esm/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,sBAAsB,CAAC;AAK9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EACL,KAAK,qBAAqB,EAE1B,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAE3B,MAAM,0BAA0B,CAAC;AA0ClC,MAAM,WAAW,8BAA8B;IAC7C,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7C;AAwbD,8DAA8D;AAC9D,qBAAa,8BAA+B,YAAW,qBAAqB;;IAC1E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;gBAGnB,MAAM,GAAE,8BAAmC;IAqBvD,QAAQ,CAAC,OAAO,EAAE,sBAAsB,GAAG,qBAAqB;CAqCjE;AAED,QAAA,MAAM,eAAe,EAAE,gBA2BtB,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/esm/src/index.js

@@ -0,0 +1,439 @@
+/**
+ * Lightning CSS and Browserslist implementation of CSSOptimizationEngine.
+ *
+ * @module extensions/ext-css-lightning
+ */
+import "../_dnt.polyfills.js";
+import { createHash } from "node:crypto";
+import process from "node:process";
+import { CSSOptimizationEngineName, MAX_CSS_OPTIMIZATION_ENGINE_IDENTITY_CHARACTERS, } from "veryfront/extensions/css";
+import browserslist from "browserslist";
+import { browserslistToTargets, transform } from "lightningcss";
+import extensionPackage from "../deno.js";
+import { isWellFormedString } from "./is-well-formed-string.js";
+const MAX_BROWSER_QUERIES = 32;
+const MAX_BROWSER_QUERY_CHARACTERS = 256;
+const MAX_RESOLVED_BROWSERS = 4_096;
+const MAX_SOURCE_PATH_CHARACTERS = 4_096;
+const ENGINE_SEMANTICS_VERSION = "veryfront.css-lightning.v3";
+const apply = Reflect.apply;
+const arrayIsArray = Array.isArray;
+const freeze = Object.freeze;
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
+const getPrototypeOf = Object.getPrototypeOf;
+const hasOwn = Object.hasOwn;
+const ownKeys = Reflect.ownKeys;
+const createObject = Object.create;
+const defineProperty = Object.defineProperty;
+const arrayPush = Array.prototype.push;
+const arraySort = Array.prototype.sort;
+const arrayJoin = Array.prototype.join;
+const encodeText = TextEncoder.prototype.encode;
+const decodeText = TextDecoder.prototype.decode;
+const normalizeString = String.prototype.normalize;
+const trimString = String.prototype.trim;
+const charCodeAtString = String.prototype.charCodeAt;
+const executeRegularExpression = RegExp.prototype.exec;
+const stringifyJSON = JSON.stringify;
+const isSafeInteger = Number.isSafeInteger;
+const isArrayBufferView = ArrayBuffer.isView;
+const objectToString = Object.prototype.toString;
+const ObjectPrototype = Object.prototype;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { fatal: true });
+const EXACT_NPM_SPECIFIER = /^npm:(?:@[^/]+\/)?[^@/]+@([^@/]+)$/;
+const INEXACT_VERSION_CHARACTER = /[~^*<>=|\s]/u;
+const TARGET_NAME = /^[a-z][a-z0-9_]*$/;
+function descriptorValue(object, property, label) {
+    const descriptor = getOwnPropertyDescriptor(object, property);
+    if (descriptor === undefined || !hasOwn(descriptor, "value")) {
+        throw new TypeError(`${label} must be an own data property`);
+    }
+    return descriptor.value;
+}
+function dataPropertyValue(descriptors, property, label) {
+    const descriptor = descriptors[property];
+    if (descriptor === undefined || !hasOwn(descriptor, "value")) {
+        throw new TypeError(`${label} must be a data property`);
+    }
+    return descriptor.value;
+}
+function exactNpmVersion(value, dependency) {
+    if (typeof value !== "string") {
+        throw new TypeError(`${dependency} dependency must use an exact npm version`);
+    }
+    const match = apply(executeRegularExpression, EXACT_NPM_SPECIFIER, [value]);
+    if (match?.[1] === undefined ||
+        apply(executeRegularExpression, INEXACT_VERSION_CHARACTER, [match[1]]) !==
+            null) {
+        throw new TypeError(`${dependency} dependency must use an exact npm version`);
+    }
+    return match[1];
+}
+const extensionVersion = descriptorValue(extensionPackage, "version", "ext-css-lightning version");
+const extensionImports = descriptorValue(extensionPackage, "imports", "ext-css-lightning imports");
+if (typeof extensionVersion !== "string" ||
+    typeof extensionImports !== "object" ||
+    extensionImports === null ||
+    arrayIsArray(extensionImports)) {
+    throw new TypeError("ext-css-lightning manifest is invalid");
+}
+const lightningCSSVersion = exactNpmVersion(descriptorValue(extensionImports, "lightningcss", "lightningcss import"), "lightningcss");
+const browserslistVersion = exactNpmVersion(descriptorValue(extensionImports, "browserslist", "browserslist import"), "browserslist");
+const hashPrototype = getPrototypeOf(createHash("sha256"));
+const updateHashValue = descriptorValue(hashPrototype, "update", "Hash.update");
+const digestHashValue = descriptorValue(hashPrototype, "digest", "Hash.digest");
+if (typeof updateHashValue !== "function" ||
+    typeof digestHashValue !== "function") {
+    throw new TypeError("SHA-256 implementation is unavailable");
+}
+const updateHash = updateHashValue;
+const digestHash = digestHashValue;
+function sha256(value) {
+    const hash = createHash("sha256");
+    apply(updateHash, hash, [value, "utf8"]);
+    return apply(digestHash, hash, ["hex"]);
+}
+function hasControlOrLineSeparator(value) {
+    for (let index = 0; index < value.length; index++) {
+        const code = apply(charCodeAtString, value, [index]);
+        if (code <= 0x1f ||
+            (code >= 0x7f && code <= 0x9f) ||
+            code === 0x2028 ||
+            code === 0x2029) {
+            return true;
+        }
+    }
+    return false;
+}
+function frozenResolvedConfig(browserQueries) {
+    const config = createObject(null);
+    defineProperty(config, "browserQueries", {
+        value: browserQueries,
+        enumerable: true,
+    });
+    return freeze(config);
+}
+function snapshotBrowserQueries(value) {
+    if (value === undefined)
+        return undefined;
+    let isArray;
+    try {
+        isArray = arrayIsArray(value);
+    }
+    catch (cause) {
+        throw new TypeError("ext-css-lightning browserQueries could not be inspected", { cause });
+    }
+    if (!isArray) {
+        throw new TypeError("ext-css-lightning browserQueries must be an array");
+    }
+    let descriptors;
+    try {
+        descriptors = getOwnPropertyDescriptors(value);
+    }
+    catch (cause) {
+        throw new TypeError("ext-css-lightning browserQueries could not be inspected", { cause });
+    }
+    const length = dataPropertyValue(descriptors, "length", "ext-css-lightning browserQueries length");
+    if (!isSafeInteger(length) ||
+        length < 1 ||
+        length > MAX_BROWSER_QUERIES ||
+        ownKeys(descriptors).length !== length + 1) {
+        throw new TypeError("ext-css-lightning browserQueries must be a bounded dense array");
+    }
+    const queries = [];
+    for (let index = 0; index < length; index++) {
+        const descriptor = descriptors[String(index)];
+        if (descriptor === undefined ||
+            !hasOwn(descriptor, "value") ||
+            descriptor.enumerable !== true) {
+            throw new TypeError("ext-css-lightning browserQueries must contain data-property strings");
+        }
+        const query = descriptor.value;
+        if (typeof query !== "string" ||
+            query.length === 0 ||
+            query.length > MAX_BROWSER_QUERY_CHARACTERS ||
+            !isWellFormedString(query) ||
+            apply(normalizeString, query, ["NFC"]) !== query ||
+            apply(trimString, query, []) !== query ||
+            hasControlOrLineSeparator(query)) {
+            throw new TypeError("ext-css-lightning browserQueries must contain canonical bounded strings");
+        }
+        apply(arrayPush, queries, [query]);
+    }
+    return freeze(queries);
+}
+function readConfig(value) {
+    if (value === undefined)
+        return frozenResolvedConfig(undefined);
+    let valueIsArray;
+    try {
+        valueIsArray = arrayIsArray(value);
+    }
+    catch (cause) {
+        throw new TypeError("ext-css-lightning config could not be inspected", {
+            cause,
+        });
+    }
+    if (typeof value !== "object" || value === null || valueIsArray) {
+        throw new TypeError("ext-css-lightning config must be an object");
+    }
+    let descriptors;
+    let prototype;
+    try {
+        prototype = getPrototypeOf(value);
+        descriptors = getOwnPropertyDescriptors(value);
+    }
+    catch (cause) {
+        throw new TypeError("ext-css-lightning config could not be inspected", {
+            cause,
+        });
+    }
+    if (prototype !== ObjectPrototype && prototype !== null) {
+        throw new TypeError("ext-css-lightning config must not inherit configuration");
+    }
+    const keys = ownKeys(descriptors);
+    if (keys.length > 1 || (keys.length === 1 && keys[0] !== "browserQueries")) {
+        throw new TypeError("ext-css-lightning config contains unsupported properties");
+    }
+    const descriptor = descriptors.browserQueries;
+    if (descriptor !== undefined && !hasOwn(descriptor, "value")) {
+        throw new TypeError("ext-css-lightning browserQueries must be a data property");
+    }
+    return frozenResolvedConfig(snapshotBrowserQueries(descriptor?.value));
+}
+function copyStrings(values) {
+    const copy = [];
+    for (let index = 0; index < values.length; index++) {
+        apply(arrayPush, copy, [values[index]]);
+    }
+    return copy;
+}
+function createIsolatedBrowserQueryOptions() {
+    return {
+        path: false,
+        stats: createObject(null),
+        dangerousExtend: false,
+    };
+}
+function rejectExternalBrowserQuerySources(queries) {
+    const parsed = browserslist.parse(copyStrings(queries), createIsolatedBrowserQueryOptions());
+    if (!arrayIsArray(parsed) || parsed.length > MAX_BROWSER_QUERIES * 4) {
+        throw new TypeError("CSS browser queries produced an invalid parse result");
+    }
+    for (let index = 0; index < parsed.length; index++) {
+        const type = parsed[index]?.type;
+        if (type === "browserslist_config" ||
+            type === "extends" ||
+            type === "popularity_in_config_stats" ||
+            type === "cover_config") {
+            throw new TypeError("CSS browser queries must not load external configuration or statistics");
+        }
+    }
+}
+function snapshotResolvedTargets(value) {
+    if (typeof value !== "object" || value === null || arrayIsArray(value)) {
+        throw new TypeError("Lightning CSS returned invalid browser targets");
+    }
+    const descriptors = getOwnPropertyDescriptors(value);
+    const keys = ownKeys(descriptors);
+    if (keys.length === 0 || keys.length > 128) {
+        throw new TypeError("Lightning CSS returned invalid browser targets");
+    }
+    for (let index = 0; index < keys.length; index++) {
+        if (typeof keys[index] !== "string") {
+            throw new TypeError("Lightning CSS returned invalid browser targets");
+        }
+    }
+    apply(arraySort, keys, []);
+    const targets = createObject(null);
+    for (let index = 0; index < keys.length; index++) {
+        const key = keys[index];
+        const descriptor = descriptors[key];
+        if (apply(executeRegularExpression, TARGET_NAME, [key]) === null ||
+            !hasOwn(descriptor, "value")) {
+            throw new TypeError("Lightning CSS returned invalid browser targets");
+        }
+        const version = descriptor.value;
+        if (!isSafeInteger(version) ||
+            version < 0 ||
+            version > 0xff_ffff) {
+            throw new TypeError("Lightning CSS returned invalid browser targets");
+        }
+        defineProperty(targets, key, {
+            value: version,
+            enumerable: true,
+        });
+    }
+    return freeze(targets);
+}
+function datasetIdentity() {
+    const serialized = apply(stringifyJSON, JSON, [{
+            data: browserslist.data,
+            defaults: browserslist.defaults,
+            nodeVersions: browserslist.nodeVersions,
+            usage: browserslist.usage.global,
+            versionAliases: browserslist.versionAliases,
+        }]);
+    if (typeof serialized !== "string") {
+        throw new TypeError("Browserslist dataset could not be identified");
+    }
+    return sha256(serialized);
+}
+const defaultBrowserQueries = snapshotBrowserQueries(browserslist.defaults);
+const loadedDatasetIdentity = datasetIdentity();
+const loadedRuntimeFlavor = process.env.CSS_TRANSFORMER_WASM
+    ? "wasm"
+    : `native:${process.platform}:${process.arch}`;
+function resolveBrowserTargets(queries) {
+    const selectedQueries = queries ?? defaultBrowserQueries;
+    rejectExternalBrowserQuerySources(selectedQueries);
+    const browsers = browserslist(copyStrings(selectedQueries), createIsolatedBrowserQueryOptions());
+    if (!arrayIsArray(browsers) ||
+        browsers.length === 0 ||
+        browsers.length > MAX_RESOLVED_BROWSERS) {
+        throw new TypeError("CSS browser queries resolved to no bounded browser targets");
+    }
+    const targets = snapshotResolvedTargets(browserslistToTargets(browsers));
+    const identityParts = [`dataset=${loadedDatasetIdentity}`];
+    const targetKeys = ownKeys(targets);
+    apply(arraySort, targetKeys, []);
+    for (let index = 0; index < targetKeys.length; index++) {
+        const name = targetKeys[index];
+        apply(arrayPush, identityParts, [`${name}=${targets[name]}`]);
+    }
+    return freeze({
+        targets,
+        identity: sha256(apply(arrayJoin, identityParts, ["\n"])),
+    });
+}
+function snapshotRequest(request) {
+    if (typeof request !== "object" || request === null || arrayIsArray(request)) {
+        throw new TypeError("CSS optimization request must be an object");
+    }
+    const descriptors = getOwnPropertyDescriptors(request);
+    const keys = ownKeys(descriptors);
+    if (keys.length !== 4 ||
+        !hasOwn(descriptors, "css") ||
+        !hasOwn(descriptors, "sourcePath") ||
+        !hasOwn(descriptors, "minify") ||
+        !hasOwn(descriptors, "sourceMap")) {
+        throw new TypeError("CSS optimization request has an invalid shape");
+    }
+    for (let index = 0; index < keys.length; index++) {
+        if (keys[index] !== "css" &&
+            keys[index] !== "sourcePath" &&
+            keys[index] !== "minify" &&
+            keys[index] !== "sourceMap") {
+            throw new TypeError("CSS optimization request has an invalid shape");
+        }
+    }
+    const css = dataPropertyValue(descriptors, "css", "CSS optimization css");
+    const sourcePath = dataPropertyValue(descriptors, "sourcePath", "CSS optimization sourcePath");
+    const minify = dataPropertyValue(descriptors, "minify", "CSS optimization minify");
+    const sourceMap = dataPropertyValue(descriptors, "sourceMap", "CSS optimization sourceMap");
+    if (typeof css !== "string" || !isWellFormedString(css)) {
+        throw new TypeError("CSS optimization css must be a well-formed string");
+    }
+    if (typeof sourcePath !== "string" ||
+        sourcePath.length === 0 ||
+        sourcePath.length > MAX_SOURCE_PATH_CHARACTERS ||
+        !isWellFormedString(sourcePath) ||
+        apply(normalizeString, sourcePath, ["NFC"]) !== sourcePath ||
+        hasControlOrLineSeparator(sourcePath)) {
+        throw new TypeError("CSS optimization sourcePath must be a canonical path");
+    }
+    if (typeof minify !== "boolean" || typeof sourceMap !== "boolean") {
+        throw new TypeError("CSS optimization flags must be booleans");
+    }
+    return freeze({ css, sourcePath, minify, sourceMap });
+}
+function isByteView(value) {
+    return isArrayBufferView(value) &&
+        apply(objectToString, value, []) === "[object Uint8Array]";
+}
+/** Parser-backed CSS optimizer provided by this extension. */
+export class LightningCSSOptimizationEngine {
+    cacheIdentity;
+    #targets;
+    constructor(config = {}) {
+        const resolved = resolveBrowserTargets(readConfig(config).browserQueries);
+        this.#targets = resolved.targets;
+        const identityParts = [
+            ENGINE_SEMANTICS_VERSION,
+            `ext-css-lightning@${extensionVersion}`,
+            `lightningcss@${lightningCSSVersion}`,
+            `browserslist@${browserslistVersion}`,
+            loadedRuntimeFlavor,
+            `targets+data=${resolved.identity}`,
+        ];
+        this.cacheIdentity = apply(arrayJoin, identityParts, [";"]);
+        if (this.cacheIdentity.length >
+            MAX_CSS_OPTIMIZATION_ENGINE_IDENTITY_CHARACTERS) {
+            throw new TypeError("ext-css-lightning cache identity exceeds the core limit");
+        }
+        freeze(this);
+    }
+    optimize(request) {
+        const input = snapshotRequest(request);
+        const result = transform({
+            filename: input.sourcePath,
+            code: apply(encodeText, encoder, [input.css]),
+            minify: input.minify,
+            sourceMap: input.sourceMap,
+            targets: this.#targets,
+            analyzeDependencies: false,
+        });
+        const descriptors = getOwnPropertyDescriptors(result);
+        const code = dataPropertyValue(descriptors, "code", "Lightning CSS code");
+        const mapDescriptor = descriptors.map;
+        if (mapDescriptor !== undefined && !hasOwn(mapDescriptor, "value")) {
+            throw new TypeError("Lightning CSS source map must be a data property");
+        }
+        const map = mapDescriptor?.value;
+        if (!isByteView(code)) {
+            throw new TypeError("Lightning CSS returned invalid output bytes");
+        }
+        if (input.sourceMap && !isByteView(map)) {
+            throw new TypeError("Lightning CSS did not return the requested source map");
+        }
+        if (!input.sourceMap && map !== undefined && map !== null) {
+            throw new TypeError("Lightning CSS returned an unrequested source map");
+        }
+        const css = apply(decodeText, decoder, [code]);
+        if (map === undefined || map === null)
+            return freeze({ css });
+        return freeze({
+            css,
+            sourceMap: apply(decodeText, decoder, [map]),
+        });
+    }
+}
+const extCSSLightning = (config) => {
+    const engine = new LightningCSSOptimizationEngine(readConfig(config));
+    return {
+        name: "ext-css-lightning",
+        version: extensionVersion,
+        contracts: {
+            provides: ["CSSOptimizationEngine"],
+        },
+        capabilities: [
+            {
+                type: "env:read",
+                keys: [
+                    "CSS_TRANSFORMER_WASM",
+                    "BROWSERSLIST_DISABLE_CACHE",
+                    "BROWSERSLIST_IGNORE_OLD_DATA",
+                    "BROWSERSLIST_TRACE_WARNING",
+                ],
+            },
+            { type: "native:ffi" },
+        ],
+        setup(ctx) {
+            ctx.provide(CSSOptimizationEngineName, engine);
+            ctx.logger.debug(`[ext-css-lightning] ${CSSOptimizationEngineName} registered`);
+        },
+    };
+};
+export default extCSSLightning;

package/esm/src/is-well-formed-string.d.ts

@@ -0,0 +1,3 @@
+/** Local UTF-16 well-formedness check independent of mutable host methods. */
+export declare function isWellFormedString(value: string): boolean;
+//# sourceMappingURL=is-well-formed-string.d.ts.map

package/esm/src/is-well-formed-string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-well-formed-string.d.ts","sourceRoot":"","sources":["../../src/src/is-well-formed-string.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAK9E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAazD"}

package/esm/src/is-well-formed-string.js

@@ -0,0 +1,20 @@
+/** Local UTF-16 well-formedness check independent of mutable host methods. */
+const apply = Reflect.apply;
+const stringCharCodeAt = String.prototype.charCodeAt;
+export function isWellFormedString(value) {
+    for (let index = 0; index < value.length; index++) {
+        const codeUnit = apply(stringCharCodeAt, value, [index]);
+        if (codeUnit >= 0xD800 && codeUnit <= 0xDBFF) {
+            index++;
+            if (index >= value.length)
+                return false;
+            const trailingCodeUnit = apply(stringCharCodeAt, value, [index]);
+            if (trailingCodeUnit < 0xDC00 || trailingCodeUnit > 0xDFFF)
+                return false;
+        }
+        else if (codeUnit >= 0xDC00 && codeUnit <= 0xDFFF) {
+            return false;
+        }
+    }
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veryfront/ext-css-lightning",
-  "version": "0.1.1186",
+  "version": "0.1.1189",
   "description": "Veryfront first-party extension package for ext-css-lightning",
   "keywords": [
     "veryfront",
@@ -27,7 +27,7 @@
   },
   "scripts": {},
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.3.0"
   },
   "publishConfig": {
     "access": "public"
@@ -60,7 +60,7 @@
     "lightningcss": "1.29.2"
   },
   "peerDependencies": {
-    "veryfront": "^0.1.1186"
+    "veryfront": "^0.1.1189"
   },
   "type": "module",
   "types": "./esm/src/index.d.ts",