fasthtml-tailwindcss 4.3.3.post1__py3-none-any.whl

fasthtml_tailwindcss/__init__.py

@@ -0,0 +1,42 @@
+from collections.abc import Sequence
+from pathlib import Path
+from weakref import finalize
+
+from fasthtml.common import Link, vurl
+
+from .client import Session
+from .config import configuration
+
+__all__ = ["TailwindHead"]
+
+
+class TailwindHead:
+    def __init__(
+        self,
+        *,
+        watch: bool = False,
+        sources: Sequence[str | Path] | None = None,
+        input: str | Path | None = None,
+        css: str | None = None,
+        output: str | Path = "./static/tailwind.css",
+    ) -> None:
+        self._config = configuration(
+            sources=sources, input=input, css=css, output=output
+        )
+        (Path(self._config.root) / self._config.output).parent.mkdir(
+            parents=True, exist_ok=True
+        )
+        self._session = Session(self._config) if watch else None
+        if self._session is not None:
+            finalize(self, self._session.close)
+
+    def __deepcopy__(self, memo):
+        return self
+
+    def __ft__(self):
+        if self._session is not None:
+            self._session.start()
+            if self._session.error:
+                raise RuntimeError(self._session.error)
+        path = "/" + self._config.output
+        return Link(rel="stylesheet", href=vurl(path, root=self._config.root))

fasthtml_tailwindcss/build.py

@@ -0,0 +1,64 @@
+import argparse
+import importlib
+import importlib.util
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from .compiler import binary_path, input_css
+from .config import STATE_DIRECTORY, TailwindConfig
+
+
+def app_head(specification: str):
+    module_name, separator, object_name = specification.partition(":")
+    if not separator or not module_name or not object_name:
+        raise ValueError("Use an application reference such as app.main:app")
+    sys.path.insert(0, str(Path.cwd()))
+    module_spec = importlib.util.find_spec(module_name)
+    if module_spec is None or module_spec.origin is None:
+        raise ModuleNotFoundError(f"Cannot locate application module {module_name!r}")
+    os.chdir(Path(module_spec.origin).resolve().parent)
+    sys.path.insert(0, str(Path.cwd()))
+    value = importlib.import_module(module_name)
+    for part in object_name.split("."):
+        value = getattr(value, part)
+    from . import TailwindHead
+
+    heads = [
+        item for item in getattr(value, "hdrs", ()) if isinstance(item, TailwindHead)
+    ]
+    if len(heads) != 1:
+        raise ValueError("The application must have exactly one TailwindHead in hdrs")
+    return heads[0]
+
+
+def build(config: TailwindConfig) -> None:
+    root = Path(config.root)
+    directory = root / STATE_DIRECTORY
+    directory.mkdir(parents=True, exist_ok=True)
+    source = directory / "build-input.css"
+    source.write_text(input_css(config), encoding="utf-8")
+    output = root / config.output
+    output.parent.mkdir(parents=True, exist_ok=True)
+    subprocess.run(
+        [str(binary_path()), "-i", str(source), "-o", str(output), "--minify"],
+        cwd=root,
+        env={**os.environ, "NO_COLOR": "1"},
+        check=True,
+    )
+    print(f"Built {output}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="fasthtml-tailwindcss")
+    commands = parser.add_subparsers(dest="command", required=True)
+    build_command = commands.add_parser("build")
+    build_command.add_argument(
+        "app", help="Python app reference, for example app.main:app"
+    )
+    build(app_head(parser.parse_args().app)._config)
+
+
+if __name__ == "__main__":
+    main()

fasthtml_tailwindcss/client.py

@@ -0,0 +1,128 @@
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+from threading import Event, Lock, Thread
+
+from filelock import FileLock, Timeout
+
+from .compiler import stop_process
+from .config import TailwindConfig, config_json, state_directory
+
+
+def running(directory: Path) -> bool:
+    try:
+        with FileLock(str(directory / "worker.lock"), timeout=0):
+            return False
+    except Timeout:
+        return True
+
+
+class Session:
+    def __init__(self, config: TailwindConfig):
+        self.config_text = config_json(config)
+        self.directory = state_directory(config)
+        self.output = Path(config.root) / config.output
+        self.error = ""
+        self._closed = Event()
+        self._start_lock = Lock()
+        self._thread = Thread(target=self.heartbeat, daemon=True)
+        self._started = False
+
+    def start(self) -> None:
+        with self._start_lock:
+            if self._started:
+                return
+            self.connect()
+            self._thread.start()
+            try:
+                self.wait_for_css()
+                self._started = True
+            except BaseException:
+                self.close()
+                raise
+
+    def connect(self) -> None:
+        self.directory.mkdir(parents=True, exist_ok=True)
+        with FileLock(str(self.directory / "startup.lock"), timeout=30):
+            (self.directory / "heartbeat").touch()
+            self.wait_for_worker()
+            if not running(self.directory):
+                self.start_worker()
+
+    def wait_for_worker(self) -> None:
+        deadline = time.monotonic() + 10
+        while running(self.directory):
+            active = self.directory / "active.json"
+            if active.is_file() and (self.directory / "pid").exists():
+                if active.read_text(encoding="utf-8") == self.config_text:
+                    return
+                (self.directory / "stop").touch()
+            if time.monotonic() > deadline:
+                raise RuntimeError("Tailwind helper did not stop after settings changed")
+            time.sleep(0.05)
+
+    def start_worker(self) -> None:
+        for name in ("error", "pid", "active.json", "ready", "stop"):
+            (self.directory / name).unlink(missing_ok=True)
+        flags = 0
+        if os.name == "nt":
+            flags = subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
+        with (self.directory / "helper.log").open("w") as log:
+            process = subprocess.Popen(
+                [
+                    sys.executable,
+                    "-m",
+                    "fasthtml_tailwindcss.worker",
+                    self.config_text,
+                ],
+                stdin=subprocess.DEVNULL,
+                stdout=log,
+                stderr=log,
+                start_new_session=os.name != "nt",
+                creationflags=flags,
+            )
+        deadline = time.monotonic() + 10
+        pid = self.directory / "pid"
+        while not pid.exists():
+            if process.poll() is not None or time.monotonic() > deadline:
+                stop_process(process)
+                raise RuntimeError(
+                    (self.directory / "helper.log").read_text()
+                    or "Cannot start Tailwind helper"
+                )
+            time.sleep(0.05)
+
+    def wait_for_css(self) -> None:
+        deadline = time.monotonic() + 120
+        ready = self.directory / "ready"
+        while (
+            not ready.is_file()
+            or ready.read_text(encoding="utf-8") != self.config_text
+        ):
+            error = self.directory / "error"
+            if error.is_file():
+                raise RuntimeError(error.read_text(encoding="utf-8"))
+            if time.monotonic() > deadline:
+                raise RuntimeError(
+                    "Tailwind initial build timed out; see compiler.log in .fasthtml-tailwindcss"
+                )
+            time.sleep(0.05)
+
+    def heartbeat(self) -> None:
+        while not self._closed.is_set():
+            error = self.directory / "error"
+            if error.is_file():
+                self.error = error.read_text(encoding="utf-8")
+            elif not running(self.directory):
+                self.error = "Tailwind helper stopped; restart the application"
+            if self.error:
+                return
+            (self.directory / "heartbeat").touch()
+            self._closed.wait(2)
+
+    def close(self) -> None:
+        self._closed.set()
+        if self._thread.ident is not None:
+            self._thread.join()

fasthtml_tailwindcss/compiler.py

@@ -0,0 +1,40 @@
+import json
+import subprocess
+from importlib import import_module
+from pathlib import Path
+
+from .config import TailwindConfig
+
+
+def binary_path():
+    try:
+        package = import_module("fasthtml_tailwindcss_cli")
+    except ModuleNotFoundError as error:
+        raise RuntimeError(
+            'Install fasthtml-tailwindcss with the "dev" extra to use Tailwind'
+        ) from error
+    return package.binary_path()
+
+
+def stop_process(process: subprocess.Popen) -> None:
+    if process.poll() is not None:
+        return
+    process.terminate()
+    try:
+        process.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        process.wait()
+
+
+def input_css(config: TailwindConfig) -> str:
+    def quote(path):
+        return json.dumps(Path(path).as_posix(), ensure_ascii=False)
+
+    base = (
+        f"@import {quote(config.input)};"
+        if config.input
+        else '@import "tailwindcss" source(none);'
+    )
+    sources = "\n".join(f"@source {quote(path)};" for path in config.sources)
+    return f"{base}\n{sources}\n{config.css}\n"

fasthtml_tailwindcss/config.py

@@ -0,0 +1,57 @@
+import json
+import os
+from collections.abc import Sequence
+from dataclasses import asdict, dataclass
+from importlib.metadata import version
+from pathlib import Path
+
+STATE_DIRECTORY = ".fasthtml-tailwindcss"
+
+
+@dataclass(frozen=True)
+class TailwindConfig:
+    root: str
+    sources: tuple[str, ...]
+    input: str | None
+    css: str
+    output: str
+    version: str
+
+
+def config_json(config: TailwindConfig) -> str:
+    return json.dumps(asdict(config), sort_keys=True)
+
+
+def configuration(
+    *,
+    sources: Sequence[str | Path] | None,
+    input: str | Path | None,
+    css: str | None,
+    output: str | Path = "./static/tailwind.css",
+) -> TailwindConfig:
+    if isinstance(sources, (str, Path)):
+        raise TypeError("sources must be a sequence of paths, for example ['app']")
+    root = Path.cwd().resolve()
+    input_path = (root / input).resolve() if input is not None else None
+    if input_path is not None and not input_path.is_file():
+        raise FileNotFoundError(input_path)
+    output_path = Path(output)
+    if output_path.is_absolute():
+        output_path = output_path.resolve().relative_to(root)
+    output_path = Path(os.path.normpath(output_path))
+    if output_path.is_absolute() or ".." in output_path.parts:
+        raise ValueError("output must be inside the working directory")
+    if sources is None:
+        sources = [root] if input is None else []
+    return TailwindConfig(
+        root=str(root),
+        sources=tuple(str((root / path).resolve()) for path in sources),
+        input=str(input_path) if input_path is not None else None,
+        css=css or "",
+        output=output_path.as_posix(),
+        version=version("fasthtml-tailwindcss"),
+    )
+
+
+def state_directory(config: TailwindConfig) -> Path:
+    return Path(config.root) / STATE_DIRECTORY

fasthtml_tailwindcss/worker.py

@@ -0,0 +1,122 @@
+import json
+import os
+import re
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from filelock import FileLock, Timeout
+
+from .compiler import binary_path, input_css, stop_process
+from .config import TailwindConfig, state_directory
+
+IDLE_TIMEOUT = 15
+
+
+class Worker:
+    def __init__(self, config_text: str):
+        self.config_text = config_text
+        values = json.loads(config_text)
+        values["sources"] = tuple(values["sources"])
+        self.config = TailwindConfig(**values)
+        self.directory = state_directory(self.config)
+        self.output = Path(self.config.root) / self.config.output
+        self.stopping = False
+
+    def stop(self, *_args) -> None:
+        self.stopping = True
+
+    def start_compiler(self) -> subprocess.Popen:
+        source = self.directory / "input.css"
+        source.write_text(input_css(self.config), encoding="utf-8")
+        command = [
+            str(binary_path()),
+            "-i",
+            str(source),
+            "-o",
+            str(self.directory / "building.css"),
+            "--watch=always",
+        ]
+        with (self.directory / "compiler.log").open("w") as log:
+            return subprocess.Popen(
+                command,
+                cwd=self.config.root,
+                stdin=subprocess.DEVNULL,
+                stdout=log,
+                stderr=log,
+                env={**os.environ, "NO_COLOR": "1"},
+            )
+
+    def publish_css(self) -> None:
+        self.output.parent.mkdir(parents=True, exist_ok=True)
+        css = (self.directory / "building.css").read_bytes()
+        if not self.output.exists() or self.output.read_bytes() != css:
+            temporary = self.output.with_name(self.output.name + ".tmp")
+            temporary.write_bytes(css)
+            temporary.replace(self.output)
+        (self.directory / "ready").write_text(self.config_text, encoding="utf-8")
+
+    def idle(self) -> bool:
+        return time.time() - (self.directory / "heartbeat").stat().st_mtime > IDLE_TIMEOUT
+
+    def expired(self) -> bool:
+        if not self.idle():
+            return False
+        try:
+            with FileLock(str(self.directory / "startup.lock"), timeout=0):
+                if not self.idle():
+                    return False
+                (self.directory / "pid").unlink(missing_ok=True)
+                return True
+        except Timeout:
+            return False
+
+    def monitor(self, process: subprocess.Popen) -> None:
+        with (self.directory / "compiler.log").open(
+            encoding="utf-8", errors="replace"
+        ) as log:
+            pending = ""
+            while not self.stopping:
+                if (self.directory / "stop").exists() or self.expired():
+                    return
+                code = process.poll()
+                pending += log.read()
+                message, _, pending = pending.rpartition("\n")
+                if re.search(r"\bDone in\b", message):
+                    self.publish_css()
+                if code is not None:
+                    details = (self.directory / "compiler.log").read_text(
+                        encoding="utf-8", errors="replace"
+                    )
+                    raise RuntimeError(f"Tailwind stopped (exit {code}):\n{details}")
+                time.sleep(0.1)
+
+    def run(self) -> None:
+        process = None
+        (self.directory / "active.json").write_text(self.config_text, encoding="utf-8")
+        (self.directory / "pid").write_text(str(os.getpid()), encoding="utf-8")
+        try:
+            process = self.start_compiler()
+            self.monitor(process)
+        except (OSError, RuntimeError) as error:
+            (self.directory / "error").write_text(str(error), encoding="utf-8")
+        finally:
+            if process is not None:
+                stop_process(process)
+            (self.directory / "pid").unlink(missing_ok=True)
+            (self.directory / "active.json").unlink(missing_ok=True)
+
+
+def main(config_text: str) -> None:
+    worker = Worker(config_text)
+    for name in ("SIGTERM", "SIGINT", "SIGBREAK"):
+        if signum := getattr(signal, name, None):
+            signal.signal(signum, worker.stop)
+    with FileLock(str(worker.directory / "worker.lock"), timeout=0):
+        worker.run()
+
+
+if __name__ == "__main__":
+    main(sys.argv[1])

fasthtml_tailwindcss-4.3.3.post1.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.5
+Name: fasthtml-tailwindcss
+Version: 4.3.3.post1
+Summary: Tailwind CSS for FastHTML with a persistent development watcher and a build command for production CSS.
+Project-URL: Documentation, https://github.com/SpaceShaman/fasthtml-tailwindcss#readme
+Project-URL: Homepage, https://github.com/SpaceShaman/fasthtml-tailwindcss
+Project-URL: Issues, https://github.com/SpaceShaman/fasthtml-tailwindcss/issues
+Project-URL: Repository, https://github.com/SpaceShaman/fasthtml-tailwindcss
+Author-email: SpaceShaman <spaceshaman@tuta.io>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: components,css,fasthtml,tailwindcss,web
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: filelock>=3.16
+Requires-Dist: python-fasthtml>=0.14.13
+Provides-Extra: dev
+Requires-Dist: fasthtml-tailwindcss-cli<5,>=4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# fasthtml-tailwindcss
+
+[![License](https://img.shields.io/github/license/SpaceShaman/fasthtml-tailwindcss)](LICENSE)
+[![Release](https://img.shields.io/github/actions/workflow/status/SpaceShaman/fasthtml-tailwindcss/release.yml?label=release)](https://github.com/SpaceShaman/fasthtml-tailwindcss/actions/workflows/release.yml)
+[![Python versions](https://img.shields.io/pypi/pyversions/fasthtml-tailwindcss)](https://pypi.org/project/fasthtml-tailwindcss/)
+[![PyPI version](https://img.shields.io/pypi/v/fasthtml-tailwindcss)](https://pypi.org/project/fasthtml-tailwindcss/)
+[![FastHTML](https://img.shields.io/badge/framework-FastHTML-7854F7)](https://github.com/AnswerDotAI/fasthtml)
+[![Tailwind CSS](https://img.shields.io/badge/CSS-Tailwind_CSS-06B6D4?logo=tailwindcss&logoColor=white)](https://tailwindcss.com/)
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+[![Pytest](https://img.shields.io/badge/testing-pytest-0A9EDC?logo=pytest)](https://docs.pytest.org/)
+[![Ruff](https://img.shields.io/badge/linting-Ruff-D7FF64?logo=ruff)](https://github.com/astral-sh/ruff)
+
+Tailwind CSS for [FastHTML](https://github.com/AnswerDotAI/fasthtml) with a persistent development watcher and a build command for production CSS.
+
+## Installation
+
+| Environment | uv | pip |
+| --- | --- | --- |
+| Development and builds | `uv add "fasthtml-tailwindcss[dev]"` | `pip install "fasthtml-tailwindcss[dev]"` |
+| Production | `uv add fasthtml-tailwindcss` | `pip install fasthtml-tailwindcss` |
+
+The `dev` extra installs the standalone compiler through [fasthtml-tailwindcss-cli](https://pypi.org/project/fasthtml-tailwindcss-cli/). No Node.js or npm is needed. Production only needs the wrapper and generated CSS.
+
+On Alpine Linux, the compiler also needs:
+
+```sh
+apk add --no-cache libstdc++ libgcc
+```
+
+## Usage
+
+```python
+from fasthtml.common import Div, FastHTML, StaticImmutable
+from fasthtml_tailwindcss import TailwindHead
+
+app = FastHTML(hdrs=[TailwindHead(watch=True)])
+app.mount("/static", StaticImmutable(directory="static"), name="static")
+
+
+@app.route("/")
+def get():
+    return Div("Hello", cls="rounded-lg bg-blue-500 p-4 text-white")
+```
+
+`TailwindHead` creates the output directory and adds a stylesheet link. `vurl` versions the URL by content, and `StaticImmutable` lets browsers cache the CSS until it changes.
+
+### Watch mode
+
+```sh
+uv run uvicorn main:app --reload
+```
+
+For `app/main.py`, run `uv run --directory app uvicorn main:app --reload` from the project directory.
+
+With `watch=True`, compilation starts on the first page render and CSS rebuilds when sources change. The watcher survives server reloads, restarts if settings change, and stops 15 seconds after the last application stops using it. Refresh the browser to see changes; automatic browser refresh and stylesheet updates during HTMX fragment swaps are not included.
+
+### Production
+
+Use `TailwindHead()` with the default `watch=False` in the application, then build CSS in your deployment pipeline with the `dev` extra installed:
+
+```sh
+uv run fasthtml-tailwindcss build main:app
+```
+
+The command imports the app and builds minified CSS using its `TailwindHead` settings. The app must have exactly one `TailwindHead` in `hdrs`. For `app/main.py`, run `build app.main:app` from the project directory or `build main:app` from `app/`; both write to `app/static/tailwind.css` by default.
+
+Deploy the generated CSS alongside the application. With `watch=False`, `TailwindHead` only links the stylesheet; it does not run the compiler.
+
+## Options
+
+All configuration is passed to `TailwindHead`:
+
+```python
+TailwindHead(
+    watch=True,
+    css="@theme { --color-brand: #7854f7; }",
+    output="static/app.css",
+)
+```
+
+- `watch`: enable the persistent development compiler. Defaults to `False`.
+- `sources`: files or directories to scan. Defaults to the working directory; with a custom input, its own source detection applies unless extra sources are supplied.
+- `input`: custom stylesheet, such as `input="assets/app.css"`, replacing the built-in `@import "tailwindcss"`. Relative CSS imports resolve from that file.
+- `css`: CSS appended after the input, useful for `@theme`, variants, and `@source inline(...)`.
+- `output`: CSS file path, defaulting to `./static/tailwind.css`. The stylesheet URL follows this path, so mount its directory at the corresponding URL.
+
+Paths are relative to the working directory. The build command uses the application module's directory; run the server from that directory too. Temporary files and compiler logs live in `.fasthtml-tailwindcss/`, which you can add to `.gitignore`.
+
+Use complete class names such as `"bg-red-500"`; Tailwind cannot detect names constructed with `f"bg-{color}-500"`. Classes in installed component libraries need explicit sources or safelisting.
+
+For inline Lucide SVG icons with typed names and editor autocomplete, see [fasthtml-lucide](https://github.com/SpaceShaman/fasthtml-lucide).
+
+## Development
+
+### Setup and tests
+
+```sh
+uv sync --group build --group test --extra dev
+uv run --group test --extra dev pytest
+```
+
+### Build
+
+```sh
+uv build --no-sources
+uv build packages/cli --no-sources
+```
+
+CLI wheel builds download and verify the official executable using SHA-256. Supported platforms are Linux x64/ARM64 (glibc 2.28+ or musl 1.2+), macOS 13+ (Intel/Apple Silicon), and Windows x64. Building a CLI wheel needs network access unless the verified binary is already available locally.
+
+### Automated releases
+
+GitHub Actions checks daily for a new stable [Tailwind CSS release](https://github.com/tailwindlabs/tailwindcss/releases), then builds and tests both packages before publishing them to PyPI. Both package versions track the Tailwind version; wrapper-only fixes may add a `.postN` suffix.
+
+The [Release workflow](.github/workflows/release.yml) builds and tests both packages before publishing through PyPI Trusted Publishing. Configure the same publisher (`SpaceShaman/fasthtml-tailwindcss`, workflow `release.yml`, environment `pypi`) for both PyPI projects, and allow workflow version commits on the default branch.
+
+## Links
+
+- [GitHub repository](https://github.com/SpaceShaman/fasthtml-tailwindcss)
+- [PyPI package](https://pypi.org/project/fasthtml-tailwindcss/)
+- [Tailwind CLI package](https://pypi.org/project/fasthtml-tailwindcss-cli/)
+
+## License
+
+The wrapper and Tailwind CSS are MIT licensed. The CLI package includes both license notices.

fasthtml_tailwindcss-4.3.3.post1.dist-info/RECORD

@@ -0,0 +1,12 @@
+fasthtml_tailwindcss/__init__.py,sha256=T2FXnG_P-Fy_LxOeRXtOvQ9L6DiJ-0obWOkGIqxchks,1257
+fasthtml_tailwindcss/build.py,sha256=KPNhQcg2SdoV-cCZ4BEK6scaNhnMFq4-_sEQli6OZNI,2168
+fasthtml_tailwindcss/client.py,sha256=BtU_JPCVepNbuC8gHWFd1jh3bJTlqpLWHmLwj_Dr8qQ,4517
+fasthtml_tailwindcss/compiler.py,sha256=_kP40s11L0qx3IQALK9aU_JBa1W23PFBHzAX-whO5O4,1075
+fasthtml_tailwindcss/config.py,sha256=fnJPWlBpBuFx8FHVPZivFaP-eds8s17tnfvPIFXAR84,1797
+fasthtml_tailwindcss/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fasthtml_tailwindcss/worker.py,sha256=5Gaj0sRQ5sKltNVprf2aMqZrq86LVsEUM4P9mObxvUQ,4311
+fasthtml_tailwindcss-4.3.3.post1.dist-info/METADATA,sha256=ubF91a6lusBJQsTG9SXx835AYd2A4idMBvMPlo36Axg,7829
+fasthtml_tailwindcss-4.3.3.post1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+fasthtml_tailwindcss-4.3.3.post1.dist-info/entry_points.txt,sha256=GDpYcNFmUIR984OelfswXRkiZ98jSoj0CCE4yxt26FI,73
+fasthtml_tailwindcss-4.3.3.post1.dist-info/licenses/LICENSE,sha256=KYkziQfBpa3S7SN2jqaYr5uJyWlgUpnTzCAzRDPkZA4,1068
+fasthtml_tailwindcss-4.3.3.post1.dist-info/RECORD,,

fasthtml_tailwindcss-4.3.3.post1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

fasthtml_tailwindcss-4.3.3.post1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fasthtml-tailwindcss = fasthtml_tailwindcss.build:main

fasthtml_tailwindcss-4.3.3.post1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SpaceShaman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.