nibs 0.1.0__py3-none-any.whl

nibs/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("nibs")
+except PackageNotFoundError:  # running from a checkout that was never installed
+    __version__ = "unknown"

nibs/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

nibs/cache.py

@@ -0,0 +1,48 @@
+"""Pages already read, so that toc, section and find on one page fetch it once."""
+
+import hashlib
+import json
+import os
+import time
+
+from .paths import cache_dir
+
+# How long a fetched page is reused; the same default as Claude Code's WebFetch.
+TTL_SECONDS = 15 * 60
+
+
+def _path(url):
+    return cache_dir() / (hashlib.sha256(url.encode()).hexdigest() + ".json")
+
+
+def get(url):
+    try:
+        with open(_path(url), encoding="utf-8") as f:
+            entry = json.load(f)
+    except (OSError, ValueError):
+        return None
+    if entry.get("url") != url or time.time() - entry.get("time", 0) > TTL_SECONDS:
+        return None
+    return entry.get("text")
+
+
+def put(url, text):
+    try:
+        cache_dir().mkdir(parents=True, exist_ok=True)
+        _prune()
+        tmp = _path(url).with_suffix(".tmp")
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump({"url": url, "time": time.time(), "text": text}, f)
+        os.replace(tmp, _path(url))
+    except OSError:
+        pass  # A page that cannot be cached is fetched again next time.
+
+
+def _prune():
+    now = time.time()
+    for p in cache_dir().glob("*.json"):
+        try:
+            if now - p.stat().st_mtime > TTL_SECONDS:
+                p.unlink()
+        except OSError:
+            pass

nibs/cli.py

@@ -0,0 +1,125 @@
+"""nibs: read only the part of a web page you need.
+
+  nibs toc <url>                 headings with their numbers and sizes
+  nibs section <url> <n|text>    one section (number from toc, or heading text)
+  nibs find <url> <regex>        matching lines, each with the section it is in
+  nibs stats                     how much of the pages nibs has printed so far
+
+Pages are fetched as Markdown when the site serves it (the URL itself, or the
+URL with .md added); otherwise the HTML is turned into headings and text.
+A page is fetched once and reused for 15 minutes.
+"""
+
+import argparse
+import contextlib
+import io
+import re
+import sys
+
+from . import __version__, page, usage
+
+NO_HEADINGS = (
+    "[nibs: no headings found. If the page shows more in a browser, it is likely "
+    "drawn by JavaScript, which nibs does not run]"
+)
+
+
+def cmd_toc(text, _args):
+    lines, secs = page.sections(text)
+    print(f"{len(text):,} chars, {len(secs)} headings")
+    for n, (level, title, start, end) in enumerate(secs, 1):
+        size = sum(len(line) + 1 for line in lines[start:end])
+        print(f'{n:3}. {"  " * (level - 1)}{title}  ({size:,})')
+    if not secs:
+        print(NO_HEADINGS)
+
+
+def cmd_section(text, args):
+    lines, secs = page.sections(text)
+    if not secs:
+        print(NO_HEADINGS, file=sys.stderr)
+        return 1
+    # A number picks the section with that number in toc; anything else, or a
+    # number toc does not have (a heading such as "2024"), is heading text.
+    q = args.query
+    try:
+        n = int(q) if q.isascii() and q.isdigit() else 0
+    except ValueError:  # more digits than int() converts
+        n = 0
+    if 0 < n <= len(secs):
+        picked = [secs[n - 1]]
+    else:
+        q = q.lower()
+        picked = [s for s in secs if s[1].lower() == q] or [s for s in secs if q in s[1].lower()]
+    if not picked:
+        print(f"nibs: no heading matches {args.query!r}; see nibs toc", file=sys.stderr)
+        return 1
+    if len(picked) > 1:
+        print(f"{len(picked)} headings match; showing the first. Others: " + "; ".join(s[1] for s in picked[1:6]))
+    _, _, start, end = picked[0]
+    body = "\n".join(lines[start:end]).strip()
+    if len(body) > args.max:
+        print(body[: args.max])
+        print(f"\n[nibs: cut at {args.max:,} of {len(body):,} chars; pick a subsection from nibs toc, or pass --max]")
+    else:
+        print(body)
+    return 0
+
+
+def cmd_find(text, args):
+    lines, secs = page.sections(text)
+    pattern = re.compile(args.regex, re.IGNORECASE)
+    shown, last = 0, None
+    for i, line in enumerate(lines):
+        if not pattern.search(line):
+            continue
+        sec = next((s for s in reversed(secs) if s[2] <= i), None)
+        if sec is not last:
+            print(f'## {sec[1] if sec else "(before the first heading)"}')
+            last = sec
+        print(f"  {line.strip()[:300]}")
+        shown += 1
+        if shown >= args.limit:
+            print(f"[nibs: stopped at {args.limit} matches; pass --limit]")
+            break
+    if not shown:
+        print("no match")
+
+
+def parser():
+    ap = argparse.ArgumentParser(prog="nibs", description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--version", action="version", version=f"nibs {__version__}")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    p = sub.add_parser("toc", help="list the headings")
+    p.add_argument("url")
+    p = sub.add_parser("section", help="print one section")
+    p.add_argument("url")
+    p.add_argument("query", help="a number from toc, or heading text")
+    p.add_argument("--max", type=int, default=8000, help="most characters to print (default 8000)")
+    p = sub.add_parser("find", help="print matching lines with their sections")
+    p.add_argument("url")
+    p.add_argument("regex")
+    p.add_argument("--limit", type=int, default=30, help="most lines to print (default 30)")
+    sub.add_parser("stats", help="how much nibs has saved so far")
+    return ap
+
+
+def main(argv=None):
+    args = parser().parse_args(argv)
+    if args.cmd == "stats":
+        return usage.print_stats()
+    if args.cmd == "find":
+        try:
+            re.compile(args.regex)
+        except re.error as err:
+            sys.exit(f"nibs: bad regex {args.regex!r}: {err}")
+    try:
+        text = page.load(args.url)
+    except page.FETCH_ERRORS as err:
+        sys.exit(f"nibs: cannot fetch {args.url}: {err}")
+    out = io.StringIO()
+    with contextlib.redirect_stdout(out):
+        status = {"toc": cmd_toc, "section": cmd_section, "find": cmd_find}[args.cmd](text, args)
+    sys.stdout.write(out.getvalue())
+    usage.record(args.cmd, args.url, len(text), len(out.getvalue()))
+    return status or 0

nibs/page.py

@@ -0,0 +1,223 @@
+"""Fetching a page as Markdown-like text and splitting it by its headings."""
+
+import http.client
+import re
+import urllib.error
+import urllib.request
+from html.parser import HTMLParser
+
+from . import __version__, cache
+
+MAX_BYTES = 5_000_000
+USER_AGENT = f"nibs/{__version__} (+https://github.com/nhinata/nibs)"
+CONTROL = re.compile(r"[\x00-\x08\x0b-\x1f\x7f-\x9f]")
+# What fetching can raise: URLError and the socket and SSL errors that reading
+# the body raises are all OSError; http.client raises HTTPException subclasses
+# such as IncompleteRead; a malformed URL raises ValueError.
+FETCH_ERRORS = (OSError, http.client.HTTPException, ValueError)
+
+# Web pages only: an opener with no handlers for file:, ftp: or data: URLs, so
+# that neither a URL given to nibs nor a redirect can read anything else.
+# ProxyHandler adds a handler for every scheme it has a proxy for (ftp_proxy
+# would make ftp: URLs go through the proxy), so it gets the web ones only.
+_WEB = ("http", "https")
+_OPENER = urllib.request.OpenerDirector()
+for _handler in (
+    urllib.request.ProxyHandler({k: v for k, v in urllib.request.getproxies().items() if k.lower() in _WEB}),
+    urllib.request.UnknownHandler(),
+    urllib.request.HTTPHandler(),
+    urllib.request.HTTPSHandler(),
+    urllib.request.HTTPDefaultErrorHandler(),
+    urllib.request.HTTPRedirectHandler(),
+    urllib.request.HTTPErrorProcessor(),
+):
+    _OPENER.add_handler(_handler)
+
+
+def fetch(url):
+    """(content type, text) of the response."""
+    req = urllib.request.Request(
+        url,
+        headers={"User-Agent": USER_AGENT, "Accept": "text/markdown, text/html;q=0.9, */*;q=0.5"},
+    )
+    with _OPENER.open(req, timeout=20) as res:
+        body = res.read(MAX_BYTES + 1)
+        ctype = res.headers.get("Content-Type", "")
+    return ctype.split(";")[0].strip(), decode(ctype, body[:MAX_BYTES])
+
+
+def decode(ctype, body):
+    try:
+        return body.decode(encoding(ctype, body), "replace")
+    except (LookupError, UnicodeError):  # a charset Python does not know, or one that cannot decode text
+        return body.decode("utf-8", "replace")
+
+
+CHARSET = re.compile(rb"""charset\s*=\s*["']?([\w.:-]+)""", re.IGNORECASE)
+
+
+def encoding(ctype, body):
+    """The charset in the Content-Type header, else, for an HTML page, one a <meta> tag
+    declares in the first 1,024 bytes (<meta charset> or <meta http-equiv>, as browsers
+    look), else UTF-8."""
+    m = CHARSET.search(ctype.encode("latin-1", "replace"))
+    if m is None and looks_like_html(ctype, body[:1024].decode("latin-1")):
+        m = re.search(rb"<meta[^>]*?" + CHARSET.pattern, body[:1024], re.IGNORECASE)
+    return m.group(1).decode("ascii") if m else "utf-8"
+
+
+def looks_like_html(ctype, text):
+    return "html" in ctype or text.lstrip()[:15].lower().startswith(("<!doctype", "<html"))
+
+
+class TextOfHtml(HTMLParser):
+    """Headings become Markdown headings, <pre> becomes a code block, other block text becomes lines.
+
+    Only heading tags make headings and only <pre> makes code blocks: a text line
+    that sections() would read as a heading or a fence is escaped with a backslash.
+    """
+
+    SKIP = {"script", "style", "nav", "aside", "noscript", "svg"}
+    # The page's own header and footer (banner, site links) are left out; inside
+    # <article>, <main> or <section> they belong to that content and are kept.
+    PAGE_ONLY = {"header", "footer"}
+    SECTIONING = {"article", "main", "section"}
+    BLOCK = {"p", "li", "td", "th", "blockquote", "dt", "dd", "div", "section", "article", "main", "tr", "br", "form"}
+
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self.lines, self.buf, self.skip, self.heading = [], [], 0, 0
+        self.sectioning, self.page_only, self.pre = 0, [], None
+
+    def flush(self):
+        text = " ".join("".join(self.buf).split())
+        if text:
+            if self.heading:
+                text = "#" * self.heading + " " + text
+            elif HEADING.match(text) or FENCE.match(text):
+                text = "\\" + text  # text, not a heading or a fence
+            self.lines.append(text)
+        self.buf = []
+
+    def handle_starttag(self, tag, attrs):
+        if self.pre is not None:
+            if tag == "br":
+                self.pre.append("\n")
+            return
+        if tag in self.PAGE_ONLY:
+            self.flush()
+            skipped = self.sectioning == 0
+            self.page_only.append(skipped)
+            self.skip += skipped
+        elif tag in self.SKIP:
+            self.skip += 1
+        elif re.fullmatch(r"h[1-6]", tag):
+            self.flush()
+            self.heading = int(tag[1])
+        elif tag == "pre":
+            self.flush()
+            self.pre = []
+        elif tag in self.BLOCK:
+            self.flush()
+        if tag in self.SECTIONING:
+            self.sectioning += 1
+
+    def handle_endtag(self, tag):
+        if self.pre is not None:
+            if tag == "pre":
+                self.end_pre()
+            return
+        if tag in self.PAGE_ONLY:
+            self.flush()
+            if self.page_only and self.page_only.pop():
+                self.skip = max(0, self.skip - 1)
+        elif tag in self.SKIP:
+            self.skip = max(0, self.skip - 1)
+        elif re.fullmatch(r"h[1-6]", tag):
+            self.flush()
+            self.heading = 0
+        elif tag in self.BLOCK:
+            self.flush()
+        if tag in self.SECTIONING:
+            self.sectioning = max(0, self.sectioning - 1)
+
+    def end_pre(self):
+        code = "".join(self.pre).strip("\n")
+        self.pre = None
+        if self.skip or not code.strip():
+            return
+        # Longer than any run of backticks in the code, so that nothing in it closes the fence.
+        fence = "`" * max(3, max((len(r) for r in re.findall(r"`+", code)), default=0) + 1)
+        self.lines.append(f"{fence}\n{code}\n{fence}")
+
+    def handle_data(self, data):
+        if self.pre is not None:
+            self.pre.append(data)
+        elif not self.skip:
+            self.buf.append(data)
+
+
+def html_to_text(html):
+    parser = TextOfHtml()
+    parser.feed(html)
+    parser.close()
+    if parser.pre is not None:  # a <pre> the page never closed
+        parser.end_pre()
+    parser.flush()
+    return "\n\n".join(parser.lines)
+
+
+def load(url):
+    """The page as Markdown-like text, from the cache when it was read recently."""
+    text = cache.get(url)
+    if text is None:
+        text = _download(url)
+        cache.put(url, text)
+    return text
+
+
+def _download(url):
+    ctype, text = fetch(url)
+    if looks_like_html(ctype, text) and not url.endswith(".md"):
+        # Many documentation sites serve the page's Markdown at the same URL plus .md.
+        try:
+            mctype, mtext = fetch(url.split("#")[0].rstrip("/") + ".md")
+            if not looks_like_html(mctype, mtext) and mtext.strip():
+                return CONTROL.sub("", mtext)
+        except FETCH_ERRORS:
+            pass
+    if looks_like_html(ctype, text):
+        text = html_to_text(text)
+    return CONTROL.sub("", text)
+
+
+# The Markdown structure sections() reads (README: Headings and code blocks).
+HEADING = re.compile(r"^(#{1,6})\s+(.*?)\s*#*\s*$")
+FENCE = re.compile(r"^(`{3,}|~{3,})(.*)$")
+
+
+def sections(text):
+    """(lines, [(level, title, start, end)]) over the lines of `text`.
+
+    The Markdown nibs reads is described in README (Headings and code blocks): only
+    `#` headings and code fences, by nibs' own small rule, not all of CommonMark.
+    """
+    lines = text.split("\n")
+    heads, fence = [], None
+    for i, line in enumerate(lines):
+        m = FENCE.match(line.strip())
+        if fence is not None:
+            if m and m.group(1)[0] == fence[0] and len(m.group(1)) >= len(fence) and not m.group(2).strip():
+                fence = None
+            continue
+        if m:
+            fence = m.group(1)
+            continue
+        h = HEADING.match(line)
+        if h:
+            heads.append((len(h.group(1)), h.group(2), i))
+    out = []
+    for n, (level, title, start) in enumerate(heads):
+        end = next((s for lv, _, s in heads[n + 1:] if lv <= level), len(lines))
+        out.append((level, title, start, end))
+    return lines, out

nibs/paths.py

@@ -0,0 +1,14 @@
+import os
+from pathlib import Path
+
+
+def cache_dir():
+    base = os.environ.get("XDG_CACHE_HOME") or Path.home() / ".cache"
+    return Path(base) / "nibs"
+
+
+def usage_log():
+    if os.environ.get("NIBS_LOG"):
+        return Path(os.environ["NIBS_LOG"])
+    base = os.environ.get("XDG_STATE_HOME") or Path.home() / ".local" / "state"
+    return Path(base) / "nibs" / "usage.jsonl"

nibs/usage.py

@@ -0,0 +1,48 @@
+"""A local record of what nibs printed, to compare with reading whole pages.
+
+One JSON line per run: the command, the URL, the page's size and how much was
+printed. Nothing is sent anywhere.
+"""
+
+import json
+import time
+
+from .paths import usage_log
+
+
+def record(cmd, url, page_chars, printed_chars):
+    path = usage_log()
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "a", encoding="utf-8") as f:
+            f.write(json.dumps({"time": time.strftime("%Y-%m-%dT%H:%M:%S"), "cmd": cmd, "url": url,
+                                "page": page_chars, "printed": printed_chars}) + "\n")
+    except OSError:
+        pass  # Measuring must never stop the lookup.
+
+
+def print_stats():
+    rows, unreadable = [], 0
+    try:
+        with open(usage_log(), "rb") as f:
+            for line in f:
+                if not line.strip():
+                    continue
+                try:
+                    row = json.loads(line.decode("utf-8"))
+                    rows.append({"time": str(row["time"]), "url": str(row["url"]),
+                                 "page": int(row["page"]), "printed": int(row["printed"])})
+                except (ValueError, TypeError, KeyError, OverflowError):
+                    unreadable += 1  # a line cut short by a full disk or a killed run
+    except FileNotFoundError:
+        pass
+    # Without nibs, each page would have been read whole, about once a day.
+    pages = {(r["time"][:10], r["url"]): r["page"] for r in rows}
+    whole = sum(pages.values())
+    printed = sum(r["printed"] for r in rows)
+    print(f"{len(rows)} runs over {len(pages)} page-days")
+    if unreadable:
+        print(f"skipped {unreadable} unreadable lines in {usage_log()}")
+    if whole:
+        print(f"printed {printed:,} chars; reading each page whole once a day: {whole:,} ({printed / whole:.0%} of that)")
+    return 0

nibs-0.1.0.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.5
+Name: nibs
+Version: 0.1.0
+Summary: Read a web page by its headings: list them, then print only the section you need
+Project-URL: Repository, https://github.com/nhinata/nibs
+Author: nhinata
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,cli,llm,markdown,tokens,web
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# nibs
+
+Read a web page by its headings: list them, then print only the section you need.
+
+An AI agent that reads a whole documentation page to answer one question puts tens of thousands of characters into its context, most of which it never uses. nibs lets it look at the page's headings first and then take just one section, in the page's own words.
+
+```console
+$ nibs toc https://docs.python.org/3/library/argparse.html
+82,019 chars, 57 headings
+  1.     Navigation  (254)
+  2. argparse — Parser for command-line options, arguments and subcommands¶  (81,665)
+  3.   ArgumentParser objects¶  (19,217)
+  4.     prog¶  (1,483)
+  5.     usage¶  (893)
+  ...
+$ nibs find https://docs.python.org/3/library/argparse.html allow_abbrev --limit 2
+## ArgumentParser objects¶
+  class argparse.ArgumentParser(prog=None, usage=None, description=None, epilog=None, ...
+  allow_abbrev - Allows long options to be abbreviated if the abbreviation is unambiguous (default: True)
+[nibs: stopped at 2 matches; pass --limit]
+$ nibs section https://docs.python.org/3/library/argparse.html 4
+```
+
+## Install
+
+```sh
+pipx install nibs      # or: uv tool install nibs
+```
+
+Python 3.11 or later. No other dependencies.
+
+## Commands
+
+```sh
+nibs toc <url>                  # headings, numbered, with each section's size in characters
+nibs section <url> <n|heading>  # one section, by its number in toc or by heading text
+nibs find <url> <regex>         # matching lines, each under the heading it belongs to
+nibs stats                      # characters printed so far, against reading each page whole
+```
+
+- `section` prints at most 8,000 characters; `--max` changes that. A heading given as text matches exactly first, then as a case-insensitive substring.
+- `find` prints at most 30 lines; `--limit` changes that.
+
+## How a page is read
+
+- Only `http` and `https` URLs are read, also when a page redirects.
+- If the site serves Markdown, either at the URL itself or at the URL with `.md` added, nibs uses it. Many documentation sites do.
+- Otherwise nibs turns the HTML into headings, text and code blocks (from `<pre>`). It leaves out scripts, styles, navigation, sidebars, and the page's own header and footer; a header or footer inside an article is kept. Only heading tags become headings, and only `<pre>` becomes a code block: a line of text that would read as either (see below) gets a backslash in front.
+- Control characters in the page are removed before printing.
+- nibs does not run JavaScript. A page that builds its content in the browser comes back with little or no text; when no headings are found, nibs says so.
+- A fetched page is kept for 15 minutes in `~/.cache/nibs` (or `$XDG_CACHE_HOME/nibs`), so `toc`, `section` and `find` on the same page fetch it once.
+
+### Headings and code blocks
+
+nibs splits a page by its Markdown headings. It reads only what it needs for that, by this rule rather than all of CommonMark:
+
+- A heading is a line that starts with 1 to 6 `#` and a space.
+- A line that starts with three or more `` ` `` or `~` opens a code block, after any spaces. The block ends at a line of the same character, at least as long, with nothing after it. Headings inside a code block are not headings.
+- Nothing else is read as structure: not headings underlined with `===` or `---`, not code indented by four spaces.
+
+## Using it from an agent
+
+Tell the agent in its instructions, for example in `CLAUDE.md` or `AGENTS.md`:
+
+```markdown
+To read documentation on the web, run `nibs toc <url>` to see the headings,
+then `nibs section <url> <n>` for the part you need, or `nibs find <url> <regex>`.
+```
+
+## The usage record
+
+Each run adds one line to `~/.local/state/nibs/usage.jsonl` (or `$XDG_STATE_HOME/nibs/usage.jsonl`): the time, the command, the URL, the page's size and how many characters were printed. `nibs stats` reads it. Set `NIBS_LOG` to another path to keep the record there. Nothing is sent anywhere.
+
+## License
+
+MIT

nibs-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+nibs/__init__.py,sha256=5xx2ZI7buRzpKsEkI7XHjE_2kipeKlncrBmI-GlZ4H4,210
+nibs/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+nibs/cache.py,sha256=VvxOFbVTUZmxAeaDsEU5FgBnLnuQA26pDrZkm6Dv1mg,1279
+nibs/cli.py,sha256=BDgKCdfJNbGFaLj9DiRA_ZYUcom-EvG4UFlHnlpqiZY,4706
+nibs/page.py,sha256=mf0C3REncEa-S2r8lql5nKvd9VR0upkx4e9yWZEj4hM,8191
+nibs/paths.py,sha256=bcaFuNWR51p6WVXadlswUbD7Th1a5zLjxB3t_hzH9oI,380
+nibs/usage.py,sha256=EHI7UEZocsTjB7r4c_IScLHtlkZZy5aXE3Igc3Qae4M,1876
+nibs-0.1.0.dist-info/METADATA,sha256=ikaaEw0N7NFCxCgFZcVMWt86CW7OtULKY7vYGbmT1Y0,4513
+nibs-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+nibs-0.1.0.dist-info/entry_points.txt,sha256=3b9vCkBq416TK_EkfT-mHu-kQr4H98TRueh5buUNJRo,39
+nibs-0.1.0.dist-info/licenses/LICENSE,sha256=RTp9_jaasWtI0jk_CouMJRPrHb8c2zdd19HbUZrksDM,1064
+nibs-0.1.0.dist-info/RECORD,,

nibs-0.1.0.dist-info/WHEEL

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

nibs-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nibs = nibs.cli:main

nibs-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nhinata
+
+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.