@veryfront/ext-css-tailwind 0.1.1183 → 0.1.1186

package/README.md

@@ -1,12 +1,14 @@
 # @veryfront/ext-css-tailwind
 
-> **Category:** Build | **Contract:** `CSSProcessor` | **Built-in**
+> **Category:** Build | **Contract:** `CSSProcessor` | **Explicit**
 
-Provides Tailwind CSS v4 compilation for Veryfront. Compiles stylesheets at render time and supports dynamic plugin loading from CDN.
+Provides Tailwind CSS v4 compilation for Veryfront. The extension owns the
+pinned compiler, local base stylesheet, plugin policy, plugin module loading,
+and every third-party import; framework core sees only `CSSProcessor`.
 
 ## Registration
 
-This extension is auto-enabled by core bootstrap. Add it to `veryfront.config.ts` only when you need to override the built-in registration:
+Install and compose the extension explicitly:
 
 ```ts
 import extTailwind from "@veryfront/ext-css-tailwind";
@@ -16,26 +18,54 @@ export default defineConfig({
 });
 ```
 
+Core never discovers or auto-registers this provider. Production pipelines
+that request CSS minification must also explicitly compose a
+`CSSOptimizationEngine` provider such as `@veryfront/ext-css-lightning`.
+If either requested provider is absent, compilation fails instead of returning
+empty or regex-rewritten CSS.
+
 ## Provided contract
 
 `CSSProcessor` — exposes:
 
-- `compile(stylesheet, options)` — delegates to Tailwind's native `compile()` and returns a compiler whose `build(candidates)` emits CSS for the class-name candidates discovered at render time.
+- `defaultStylesheet` — the extension-owned Tailwind import, typography plugin,
+  and dark-mode variant used only when the application supplies no stylesheet;
+- `compile(stylesheet)` — delegates to Tailwind's native `compile()` and returns
+  a compiler whose `build(candidates)` emits CSS for the class-name candidates
+  discovered at render time.
+
+## Plugin isolation
 
-## Plugin shims
+The extension accepts only its audited plugin allowlist and resolves every
+plugin to one exact, extension-owned npm dependency. All five plugin modules are
+statically imported and registered locally; compilation performs no plugin
+download, temporary-module write, source rewriting, or global shim injection.
+Unpinned version overrides and unknown packages are rejected before Tailwind
+receives a plugin value.
 
-On setup the extension installs three `globalThis` shims so that Tailwind plugin bundles loaded at runtime from `esm.sh` bind their `tailwindcss/plugin`, `tailwindcss/defaultTheme`, and `tailwindcss/colors` imports to the same tailwindcss copy this extension ships. Core's `plugin-loader.ts` rewrites plugin bundle code to reference these shims by name; without them, dynamic plugin loading fails.
+The audited local inventory is:
 
-The shims live at:
+- `@tailwindcss/forms@0.5.11`
+- `@tailwindcss/typography@0.5.19`
+- `daisyui@5.5.14`
+- `tailwind-scrollbar-hide@2.0.0`
+- `tailwindcss-animate@1.0.7`
 
-- `globalThis.__tailwindPluginShim`
-- `globalThis.__tailwindDefaultThemeShim`
-- `globalThis.__tailwindColorsShim`
+Stylesheets may use either the bare package name or that exact versioned
+specifier. No other version is accepted.
+
+The complete local plugin inventory and exact versions are bound into the
+processor cache identity. Changing any plugin implementation policy therefore
+invalidates compiled CSS caches deterministically.
 
 ## Capabilities
 
-- **net `esm.sh`:** loading user-declared Tailwind plugins from CDN at runtime.
+- **filesystem read:** reading the pinned package's `index.css`.
+
+The extension requests no network or filesystem-write capability.
 
 ## Configuration
 
-No factory options. The extension reads no environment variables and takes no config.
+No factory options. Inherited configuration, accessors, and unknown keys are
+rejected. The base stylesheet is local and mandatory; there is no CDN or empty
+stylesheet fallback.

package/esm/_dnt.polyfills.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+import { createRequire } from "node:module";
+import { type URL } from "node:url";
+declare global {
+    interface ImportMeta {
+        /** A string representation of the fully qualified module URL. When the
+         * module is loaded locally, the value will be a file URL (e.g.
+         * `file:///path/module.ts`).
+         *
+         * You can also parse the string as a URL to determine more information about
+         * how the current module was loaded. For example to determine if a module was
+         * local or not:
+         *
+         * ```ts
+         * const url = new URL(import.meta.url);
+         * if (url.protocol === "file:") {
+         *   console.log("this module was loaded locally");
+         * }
+         * ```
+         */
+        url: string;
+        /**
+         * A function that returns resolved specifier as if it would be imported
+         * using `import(specifier)`.
+         *
+         * ```ts
+         * console.log(import.meta.resolve("./foo.js"));
+         * // file:///dev/foo.js
+         * ```
+         *
+         * @param specifier The module specifier to resolve relative to `parent`.
+         * @param parent The absolute parent module URL to resolve from.
+         * @returns The absolute (`file:`) URL string for the resolved module.
+         */
+        resolve(specifier: string, parent?: string | URL | undefined): string;
+        /** A flag that indicates if the current module is the main module that was
+         * called when starting the program under Deno.
+         *
+         * ```ts
+         * if (import.meta.main) {
+         *   // this was loaded as the main module, maybe do some bootstrapping
+         * }
+         * ```
+         */
+        main: boolean;
+        /** The absolute path of the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.filename); // /home/alice/my_module.ts
+         *
+         * // Windows
+         * console.log(import.meta.filename); // C:\alice\my_module.ts
+         * ```
+         */
+        filename: string;
+        /** The absolute path of the directory containing the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.dirname); // /home/alice
+         *
+         * // Windows
+         * console.log(import.meta.dirname); // C:\alice
+         * ```
+         */
+        dirname: string;
+    }
+}
+type NodeRequest = ReturnType<typeof createRequire>;
+type NodeModule = NonNullable<NodeRequest["main"]>;
+interface ImportMetaPonyfillCommonjs {
+    (require: NodeRequest, module: NodeModule): ImportMeta;
+}
+interface ImportMetaPonyfillEsmodule {
+    (importMeta: ImportMeta): ImportMeta;
+}
+interface ImportMetaPonyfill extends ImportMetaPonyfillCommonjs, ImportMetaPonyfillEsmodule {
+}
+export declare let import_meta_ponyfill_commonjs: ImportMetaPonyfillCommonjs;
+export declare let import_meta_ponyfill_esmodule: ImportMetaPonyfillEsmodule;
+export declare let import_meta_ponyfill: ImportMetaPonyfill;
+export {};
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

package/esm/_dnt.polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAgC,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAGlE,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,UAAU;QAClB;;;;;;;;;;;;;;WAcG;QACH,GAAG,EAAE,MAAM,CAAC;QACZ;;;;;;;;;;;;WAYG;QACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,GAAG,MAAM,CAAC;QACtE;;;;;;;;WAQG;QACH,IAAI,EAAE,OAAO,CAAC;QAEd;;;;;;;;;;;;WAYG;QACH,QAAQ,EAAE,MAAM,CAAC;QAEjB;;;;;;;;;;;;WAYG;QACH,OAAO,EAAE,MAAM,CAAC;KACjB;CACF;AAED,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,KAAK,UAAU,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;AACnD,UAAU,0BAA0B;IAClC,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;CACxD;AACD,UAAU,0BAA0B;IAClC,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAAC;CACtC;AACD,UAAU,kBACR,SAAQ,0BAA0B,EAAE,0BAA0B;CAC/D;AAiBD,eAAO,IAAI,6BAA6B,EA2BnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,6BAA6B,EA4DnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,oBAAoB,EAoB1B,kBAAkB,CAAC"}

package/esm/_dnt.polyfills.js

@@ -0,0 +1,127 @@
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+//@ts-ignore
+import { createRequire } from "node:module";
+//@ts-ignore
+import { fileURLToPath, pathToFileURL } from "node:url";
+//@ts-ignore
+import { dirname } from "node:path";
+const defineGlobalPonyfill = (symbolFor, fn) => {
+    if (!Reflect.has(globalThis, Symbol.for(symbolFor))) {
+        Object.defineProperty(globalThis, Symbol.for(symbolFor), {
+            configurable: true,
+            get() {
+                return fn;
+            },
+        });
+    }
+};
+export let import_meta_ponyfill_commonjs = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-commonjs")) ??
+    (() => {
+        const moduleImportMetaWM = new WeakMap();
+        return (require, module) => {
+            let importMetaCache = moduleImportMetaWM.get(module);
+            if (importMetaCache == null) {
+                const importMeta = Object.assign(Object.create(null), {
+                    url: pathToFileURL(module.filename).href,
+                    main: require.main == module,
+                    resolve: (specifier, parentURL = importMeta.url) => {
+                        return pathToFileURL((importMeta.url === parentURL
+                            ? require
+                            : createRequire(parentURL))
+                            .resolve(specifier)).href;
+                    },
+                    filename: module.filename,
+                    dirname: module.path,
+                });
+                moduleImportMetaWM.set(module, importMeta);
+                importMetaCache = importMeta;
+            }
+            return importMetaCache;
+        };
+    })());
+defineGlobalPonyfill("import-meta-ponyfill-commonjs", import_meta_ponyfill_commonjs);
+export let import_meta_ponyfill_esmodule = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-esmodule")) ??
+    ((importMeta) => {
+        const resolveFunStr = String(importMeta.resolve);
+        const shimWs = new WeakSet();
+        //@ts-ignore
+        const mainUrl = ("file:///" + (process.argv[1] ?? "").replace(/\\/g, "/"))
+            .replace(/\/{3,}/, "///");
+        const commonShim = (importMeta) => {
+            if (typeof importMeta.main !== "boolean") {
+                importMeta.main = importMeta.url === mainUrl;
+            }
+            if (typeof importMeta.filename !== "string") {
+                importMeta.filename = fileURLToPath(importMeta.url);
+                importMeta.dirname = dirname(importMeta.filename);
+            }
+        };
+        if (
+        // v16.2.0+, v14.18.0+: Add support for WHATWG URL object to parentURL parameter.
+        resolveFunStr === "undefined" ||
+            // v20.0.0+, v18.19.0+"" This API now returns a string synchronously instead of a Promise.
+            resolveFunStr.startsWith("async")
+        // enable by --experimental-import-meta-resolve flag
+        ) {
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    const importMetaUrlRequire = {
+                        url: importMeta.url,
+                        require: createRequire(importMeta.url),
+                    };
+                    importMeta.resolve = function resolve(specifier, parentURL = importMeta.url) {
+                        return pathToFileURL((importMetaUrlRequire.url === parentURL
+                            ? importMetaUrlRequire.require
+                            : createRequire(parentURL)).resolve(specifier)).href;
+                    };
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        else {
+            /// native support
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        return import_meta_ponyfill_esmodule(importMeta);
+    }));
+defineGlobalPonyfill("import-meta-ponyfill-esmodule", import_meta_ponyfill_esmodule);
+export let import_meta_ponyfill = ((...args) => {
+    const _MODULE = (() => {
+        if (typeof require === "function" && typeof module === "object") {
+            return "commonjs";
+        }
+        else {
+            // eval("typeof import.meta");
+            return "esmodule";
+        }
+    })();
+    if (_MODULE === "commonjs") {
+        //@ts-ignore
+        import_meta_ponyfill = (r, m) => import_meta_ponyfill_commonjs(r, m);
+    }
+    else {
+        //@ts-ignore
+        import_meta_ponyfill = (im) => import_meta_ponyfill_esmodule(im);
+    }
+    //@ts-ignore
+    return import_meta_ponyfill(...args);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veryfront/ext-css-tailwind",
-  "version": "0.1.1183",
+  "version": "0.1.1186",
   "description": "Veryfront first-party extension package for ext-css-tailwind",
   "keywords": [
     "veryfront",
@@ -18,11 +18,11 @@
   "bugs": {
     "url": "https://github.com/veryfront/veryfront-code/issues"
   },
-  "module": "./esm/index.js",
+  "module": "./esm/src/index.js",
   "exports": {
     ".": {
-      "import": "./esm/index.js",
-      "types": "./esm/index.d.ts"
+      "import": "./esm/src/index.js",
+      "types": "./esm/src/index.d.ts"
     }
   },
   "scripts": {},
@@ -34,31 +34,34 @@
   },
   "veryfront": {
     "extension": true,
+    "activation": "explicit",
     "contracts": {
       "provides": [
         "CSSProcessor"
       ]
     },
+    "npm": {
+      "runtimeVersionFromManifest": true
+    },
     "capabilities": [
       {
-        "type": "net:outbound",
-        "hosts": [
-          "esm.sh"
-        ]
+        "type": "fs:read"
       }
     ]
   },
   "dependencies": {
-    "@deno/shim-deno": "~0.18.0",
-    "@deno/shim-crypto": "~0.3.1",
-    "@deno/shim-timers": "~0.1.0",
-    "tailwindcss": "4.2.2"
+    "@tailwindcss/forms": "0.5.11",
+    "@tailwindcss/typography": "0.5.19",
+    "daisyui": "5.5.14",
+    "tailwind-scrollbar-hide": "2.0.0",
+    "tailwindcss": "4.2.2",
+    "tailwindcss-animate": "1.0.7"
   },
   "peerDependencies": {
-    "veryfront": "^0.1.1183"
+    "veryfront": "^0.1.1186"
   },
   "type": "module",
-  "types": "./esm/index.d.ts",
+  "types": "./esm/src/index.d.ts",
   "files": [
     "esm",
     "LICENSE",

package/esm/_dnt.shims.d.ts

@@ -1,11 +0,0 @@
-import { Deno } from "@deno/shim-deno";
-export { Deno } from "@deno/shim-deno";
-export { crypto, type Crypto, type SubtleCrypto, type AlgorithmIdentifier, type Algorithm, type RsaOaepParams, type BufferSource, type AesCtrParams, type AesCbcParams, type AesGcmParams, type CryptoKey, type KeyAlgorithm, type KeyType, type KeyUsage, type EcdhKeyDeriveParams, type HkdfParams, type HashAlgorithmIdentifier, type Pbkdf2Params, type AesDerivedKeyParams, type HmacImportParams, type JsonWebKey, type RsaOtherPrimesInfo, type KeyFormat, type RsaHashedKeyGenParams, type RsaKeyGenParams, type BigInteger, type EcKeyGenParams, type NamedCurve, type CryptoKeyPair, type AesKeyGenParams, type HmacKeyGenParams, type RsaHashedImportParams, type EcKeyImportParams, type AesKeyAlgorithm, type RsaPssParams, type EcdsaParams } from "@deno/shim-crypto";
-export { setInterval, setTimeout } from "@deno/shim-timers";
-export declare const dntGlobalThis: Omit<typeof globalThis, "Deno" | "crypto" | "setInterval" | "setTimeout"> & {
-    Deno: typeof Deno;
-    crypto: import("@deno/shim-crypto").Crypto;
-    setInterval: any;
-    setTimeout: any;
-};
-//# sourceMappingURL=_dnt.shims.d.ts.map

package/esm/_dnt.shims.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,OAAO,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,mBAAmB,EAAE,KAAK,UAAU,EAAE,KAAK,uBAAuB,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,KAAK,gBAAgB,EAAE,KAAK,UAAU,EAAE,KAAK,kBAAkB,EAAE,KAAK,SAAS,EAAE,KAAK,qBAAqB,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,KAAK,iBAAiB,EAAE,KAAK,eAAe,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErvB,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAQ5D,eAAO,MAAM,aAAa;;;;;CAA2C,CAAC"}

package/esm/_dnt.shims.js

@@ -1,68 +0,0 @@
-import { Deno } from "@deno/shim-deno";
-export { Deno } from "@deno/shim-deno";
-import { crypto } from "@deno/shim-crypto";
-export { crypto } from "@deno/shim-crypto";
-import { setInterval, setTimeout } from "@deno/shim-timers";
-export { setInterval, setTimeout } from "@deno/shim-timers";
-const dntGlobals = {
-    Deno,
-    crypto,
-    setInterval,
-    setTimeout,
-};
-export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
-function createMergeProxy(baseObj, extObj) {
-    return new Proxy(baseObj, {
-        get(_target, prop, _receiver) {
-            if (prop in extObj) {
-                return extObj[prop];
-            }
-            else {
-                return baseObj[prop];
-            }
-        },
-        set(_target, prop, value) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            baseObj[prop] = value;
-            return true;
-        },
-        deleteProperty(_target, prop) {
-            let success = false;
-            if (prop in extObj) {
-                delete extObj[prop];
-                success = true;
-            }
-            if (prop in baseObj) {
-                delete baseObj[prop];
-                success = true;
-            }
-            return success;
-        },
-        ownKeys(_target) {
-            const baseKeys = Reflect.ownKeys(baseObj);
-            const extKeys = Reflect.ownKeys(extObj);
-            const extKeysSet = new Set(extKeys);
-            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
-        },
-        defineProperty(_target, prop, desc) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            Reflect.defineProperty(baseObj, prop, desc);
-            return true;
-        },
-        getOwnPropertyDescriptor(_target, prop) {
-            if (prop in extObj) {
-                return Reflect.getOwnPropertyDescriptor(extObj, prop);
-            }
-            else {
-                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
-            }
-        },
-        has(_target, prop) {
-            return prop in extObj || prop in baseObj;
-        },
-    });
-}

package/esm/index.d.ts

@@ -1,9 +0,0 @@
-import type { ExtensionFactory } from "veryfront/extensions";
-import type { CSSCompileOptions, CSSCompiler, CSSProcessor } from "veryfront/extensions/css";
-declare class TailwindCSSProcessor implements CSSProcessor {
-    compile(stylesheet: string, options: CSSCompileOptions): Promise<CSSCompiler>;
-}
-declare const extTailwind: ExtensionFactory;
-export default extTailwind;
-export { TailwindCSSProcessor };
-//# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAgB7F,cAAM,oBAAqB,YAAW,YAAY;IAC1C,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,WAAW,CAAC;CAgBpF;AAED,QAAA,MAAM,WAAW,EAAE,gBAsBlB,CAAC;AAEF,eAAe,WAAW,CAAC;AAC3B,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/esm/index.js

@@ -1,71 +0,0 @@
-/**
- * ext-css-tailwind — CSSProcessor implementation backed by Tailwind CSS v4.
- *
- * Provides the `CSSProcessor` contract:
- *  - `compile(stylesheet, options)` — delegates to tailwindcss `compile()`
- *    and returns a compiler whose `build(candidates)` emits CSS for the
- *    class-name candidates discovered at render time.
- *
- * The extension also installs three `globalThis` shims on setup so that
- * Tailwind plugin bundles loaded at runtime from esm.sh can bind their
- * `tailwindcss/plugin`, `tailwindcss/defaultTheme`, and `tailwindcss/colors`
- * imports to the same tailwindcss copy this extension ships. Core's
- * `plugin-loader.ts` rewrites plugin bundle code to reference these shims
- * by name; without the shims installed, dynamic plugin loading fails.
- *
- * @module extensions/ext-css-tailwind
- */
-import * as dntShim from "./_dnt.shims.js";
-import { compile } from "tailwindcss";
-import plugin from "tailwindcss/plugin";
-import defaultTheme from "tailwindcss/defaultTheme";
-import colors from "tailwindcss/colors";
-function installTailwindPluginShims() {
-    const g = dntShim.dntGlobalThis;
-    g.__tailwindPluginShim = { default: plugin, __esModule: true };
-    g.__tailwindDefaultThemeShim = { default: defaultTheme, __esModule: true };
-    g.__tailwindColorsShim = { default: colors, __esModule: true };
-}
-class TailwindCSSProcessor {
-    async compile(stylesheet, options) {
-        const native = await compile(stylesheet, {
-            base: options.base,
-            loadStylesheet: options.loadStylesheet,
-            loadModule: async (id) => {
-                const loaded = await options.loadModule(id);
-                // deno-lint-ignore no-explicit-any -- loaded plugin modules are opaque to the contract
-                return { module: loaded.module, base: loaded.base, path: loaded.path };
-            },
-        });
-        return {
-            build(candidates) {
-                return native.build(candidates);
-            },
-        };
-    }
-}
-const extTailwind = () => {
-    const impl = new TailwindCSSProcessor();
-    return {
-        name: "ext-css-tailwind",
-        version: "0.1.0",
-        contracts: {
-            provides: ["CSSProcessor"],
-        },
-        capabilities: [
-            { type: "net:outbound", hosts: ["esm.sh"] },
-        ],
-        setup(ctx) {
-            installTailwindPluginShims();
-            ctx.provide("CSSProcessor", impl);
-            ctx.logger.debug("[ext-css-tailwind] CSSProcessor registered");
-        },
-        teardown() {
-            // Shims stay installed — removing them could break in-flight plugin
-            // loads. The globalThis pollution is intentional and scoped to keys
-            // with `__tailwind` prefix.
-        },
-    };
-};
-export default extTailwind;
-export { TailwindCSSProcessor };