@port-labs/jq-node-bindings 0.0.13 → 0.0.15-dev1

package/deps/jq/docs/build_manpage.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+from datetime import date
+from io import StringIO
+from lxml import etree
+import markdown
+from markdown.extensions import Extension
+import re
+import sys
+import yaml
+
+
+# Prevent our markdown parser from trying to help by interpreting things in angle brackets as HTML tags.
+class EscapeHtml(Extension):
+
+    def extendMarkdown(self, md):
+        md.preprocessors.deregister('html_block')
+        md.inlinePatterns.deregister('html')
+
+
+class RoffWalker(object):
+
+    def __init__(self, tree, output=sys.stdout):
+        self.tree = tree
+        self.target = output
+        self.f = StringIO()
+
+    def walk(self):
+        self._walk(self.tree, parent_tag=None)
+        # We don't want to start lines with \. because that can confuse man
+        # For lines that start with \., we need to prefix them with \& so it
+        # knows not to treat that line as a directive
+        data = re.sub(r'^\\\.', r'\&.', self.f.getvalue(), flags=re.MULTILINE)
+        self.target.write(data)
+
+    def _ul_is_special(self, root):
+        if len(root) != 1:
+            return False
+        child = root[0]
+        if child.tag != 'li':
+            return False
+        msg = ''.join(child.itertext()).strip()
+        return msg.endswith(':')
+
+    def _walk_child(self, root):
+        if len(root) > 0:
+            self._walk(root[0], parent_tag=root.tag)
+
+    def _write_element(self, root, ensure_newline=True):
+        if root.text is not None:
+            text = self._sanitize(root.text)
+            self.__write_raw(text)
+        self._walk_child(root)
+        self._write_tail(root, ensure_newline=ensure_newline)
+
+    def _write_tail(self, root, ensure_newline=False, inline=False):
+        if root.tail is not None:
+            if inline or root.tail != '\n':
+                text = self._sanitize(root.tail)
+                if text.endswith('\n'):
+                    ensure_newline = False
+                self.__write_raw(text)
+        if ensure_newline:
+            self.__write_raw('\n')
+
+    def _walk(self, root, parent_tag=None):
+        last_tag = None
+        while root is not None:
+            if root.tag == 'h1':
+                self.__write_cmd('.TH "JQ" "1" "{}" "" ""'.format(
+                    date.today().strftime('%B %Y')))
+                self.__write_cmd('.SH "NAME"')
+                # TODO: properly parse this
+                self.__write_raw(r'\fBjq\fR \- Command\-line JSON processor' +
+                                 "\n")
+
+            elif root.tag == 'h2':
+                self.__write_cmd('.SH "{}"'.format(''.join(
+                    root.itertext()).strip()))
+
+            elif root.tag == 'h3':
+                text = ''.join(root.itertext()).strip()
+                self.__write_cmd('.SS "{}"'.format(self._h3_sanitize(text)))
+
+            elif root.tag == 'p':
+                if last_tag not in ['h2', 'h3'] and parent_tag not in ['li']:
+                    self.__write_cmd('.P')
+                self._write_element(root, ensure_newline=(parent_tag != 'li'))
+
+            elif root.tag == 'a':
+                self._write_element(root, ensure_newline=(parent_tag != 'li'))
+
+            elif root.tag == 'ul':
+                if self._ul_is_special(root):
+                    li = root[0]
+                    self.__write_cmd('.TP')
+                    self._write_element(li)
+                    next = root.getnext()
+                    while next is not None and next.tag == 'p':
+                        if next.getnext() is not None and next.getnext(
+                        ).tag == 'pre':
+                            # we don't want to .IP these, because it'll look funny with the code indent
+                            break
+                        self.__write_cmd('.IP')
+                        self._write_element(next)
+                        root = next
+                        next = root.getnext()
+                else:
+                    self._walk_child(root)
+                    self._write_tail(root)
+                    # A pre tag after the end of a list doesn't want two of the indentation commands
+                    if root.getnext() is None or root.getnext().tag != 'pre':
+                        self.__write_cmd('.IP "" 0')
+
+            elif root.tag == 'li':
+                self.__write_cmd(r'.IP "\(bu" 4')
+                if root.text is not None and root.text.strip() != '':
+                    text = self._sanitize(root.text)
+                    self.__write_raw(text)
+                self._walk_child(root)
+                self._write_tail(root, ensure_newline=True)
+
+            elif root.tag == 'strong':
+                if root.text is not None:
+                    text = self._sanitize(root.text)
+                    self.__write_raw('\\fB{}\\fR'.format(text))
+
+                self._write_tail(root, inline=True)
+
+            elif root.tag == 'em':
+                if root.text is not None:
+                    text = self._sanitize(root.text)
+                    self.__write_raw('\\fI{}\\fR'.format(text))
+                self._write_tail(root, inline=True)
+
+            elif root.tag == 'code':
+                if root.text is not None:
+                    text = self._code_sanitize(root.text)
+                    self.__write_raw('\\fB{}\\fR'.format(text))
+                self._write_tail(root, inline=True)
+
+            elif root.tag == 'pre':
+                self.__write_cmd('.IP "" 4')
+                self.__write_cmd('.nf\n')  # extra newline for spacing reasons
+                next = root
+                first = True
+                while next is not None and next.tag == 'pre':
+                    if not first:
+                        self.__write_raw('\n')
+                    text = ''.join(next.itertext(with_tail=False))
+                    self.__write_raw(self._pre_sanitize(text))
+                    first = False
+                    root = next
+                    next = next.getnext()
+                self.__write_cmd('.fi')
+                self.__write_cmd('.IP "" 0')
+
+            else:
+                self._walk_child(root)
+
+            last_tag = root.tag
+            root = root.getnext()
+
+    def _base_sanitize(self, text):
+        text = re.sub(r'\\', r'\\e', text)
+        text = re.sub(r'\.', r'\\.', text)
+        text = re.sub("'", r"\'", text)
+        text = re.sub('-', r'\-', text)
+        return text
+
+    def _pre_sanitize(self, text):
+        return self._base_sanitize(text)
+
+    def _code_sanitize(self, text):
+        text = self._base_sanitize(text)
+        text = re.sub(r'\s', ' ', text)
+        return text
+
+    def _h3_sanitize(self, text):
+        text = self._base_sanitize(text)
+        text = re.sub(' \n|\n ', ' ', text)
+        text = re.sub('\n', ' ', text)
+        return text
+
+    def _sanitize(self, text):
+        text = self._base_sanitize(text)
+        text = re.sub(r'<([^>]+)>', r'\\fI\1\\fR', text)
+        text = re.sub(r' +', ' ', text)
+        text = re.sub('\n', ' ', text)
+        return text
+
+    def __write_cmd(self, dat):
+        print('.', dat, sep='\n', file=self.f)
+        pass
+
+    def __write_raw(self, dat):
+        print(dat, sep='', end='', file=self.f)
+        pass
+
+
+def load_yml_file(fn):
+    with open(fn) as f:
+        return yaml.safe_load(f)
+
+
+def dedent_body(body):
+    lines = [re.sub(r'^  (\S)', r'\1', l) for l in body.split('\n')]
+    return '\n'.join(lines)
+
+
+def convert_manual_to_markdown():
+    f = StringIO()
+    manual = load_yml_file("content/manual/dev/manual.yml")
+    f.write(manual.get('manpage_intro', '\n'))
+    f.write(dedent_body(manual.get('body', '\n')))
+    for section in manual.get('sections', []):
+        f.write('## {}\n'.format(section.get('title', '').upper()))
+        f.write(dedent_body(section.get('body', '\n')))
+        f.write('\n')
+        for entry in section.get('entries', []):
+            f.write('### {}\n'.format(entry.get('title', '')))
+            f.write(dedent_body(entry.get('body', '\n')))
+            f.write('\n')
+            if entry.get('examples') is not None:
+                f.write("~~~~\n")
+                first = True
+                for example in entry.get('examples'):
+                    if not first:
+                        f.write('\n')
+                    f.write("jq '{}'\n".format(example.get('program', '')))
+                    f.write("   {}\n".format(example.get('input', '')))
+                    output = [str(x) for x in example.get('output', [])]
+                    f.write("=> {}\n".format(', '.join(output)))
+                    first = False
+                f.write("~~~~\n")
+        f.write('\n')
+    f.write(manual.get('manpage_epilogue', ''))
+    return f.getvalue()
+
+
+# Convert manual.yml to our special markdown format
+markdown_data = convert_manual_to_markdown()
+
+# Convert markdown to html
+html_data = markdown.markdown(markdown_data,
+                              extensions=[EscapeHtml(), 'fenced_code'])
+
+# Parse the html into a tree so we can walk it
+tr = etree.HTML(html_data, etree.HTMLParser())
+
+# Convert the markdown to ROFF
+RoffWalker(tr).walk()

package/deps/jq/docs/build_mantests.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+import yaml
+import re
+
+regex_program_pattern = re.compile(
+    r'\b(?:test|match|capture|scan|split|splits|sub|gsub)\s*\(')
+
+with open('content/manual/dev/manual.yml') as source, \
+        open('../tests/man.test', 'w') as man, \
+        open('../tests/manonig.test', 'w') as manonig:
+    manual = yaml.safe_load(source)
+    for section in manual.get('sections', []):
+        for entry in section.get('entries', []):
+            for example in entry.get('examples', []):
+                program = example.get('program', '').replace('\n', ' ')
+                out = manonig if regex_program_pattern.search(program) else man
+                print(program, file=out)
+                print(example.get('input', ''), file=out)
+                for s in example.get('output', []):
+                    print(s, file=out)
+                print('', file=out)

package/deps/jq/docs/build_website.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+import argparse
+import glob
+import itertools
+from jinja2 import Environment, FileSystemLoader, select_autoescape, pass_context
+from markdown import markdown
+from markupsafe import Markup
+import os
+import os.path
+import re
+import shutil
+import yaml
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--root', default='/jq')
+args = parser.parse_args()
+
+env = Environment(
+    loader=FileSystemLoader('templates'),
+    autoescape=select_autoescape(['html.j2']),
+)
+
+
+def load_yml_file(fn):
+    with open(fn) as f:
+        return yaml.safe_load(f)
+
+
+env.globals['url'] = 'https://jqlang.github.io/jq'
+env.globals['root'] = args.root
+
+env.filters['search_id'] = lambda input: input.replace(r'`', '')
+env.filters['section_id'] = lambda input: re.sub(
+    r'[^-a-zA-Z0-9_]', '', input.replace(' ', '-')).lower()
+env.filters['entry_id'] = lambda input: re.sub(
+    r'^(split|first-last-nth)$',
+    r'\1' + ('-1' if ';' not in input else '-2'),  # avoid id conflict
+    re.sub(
+        r'\b([^-]+)(?:-\1)+\b',
+        r'\1',  # e.g. range-range-range -> range
+        re.sub(r' ?/ ?|,? ', '-',
+               re.sub(r'[`;]|: .*|\(.*?\)| \[.+\]', '', input)))).lower()
+env.filters['markdownify'] = lambda input: Markup(markdown(input))
+env.filters['no_paragraph'] = lambda input: Markup(re.sub(r'</?p>', '', input))
+
+env.globals['unique_id'] = pass_context(
+    lambda ctx: str(next(ctx['unique_ctr'])))
+
+
+def raise_handler(message):
+    raise Exception(message)
+
+
+env.globals['raise'] = raise_handler
+
+
+def generate_file(env, fname):
+    path, base = os.path.split(fname)
+    path = os.path.relpath(path, 'content')
+    if path == '.':
+        path = ''
+        permalink = ''
+    else:
+        permalink = path + '/'
+
+    output_dir = os.path.join('output', path)
+    output_path = os.path.join(output_dir, 'index.html')
+
+    template_name = re.sub(r'.yml$', '.html.j2', base)
+
+    ctx = load_yml_file(fname)
+    ctx.update(unique_ctr=itertools.count(1),
+               permalink=permalink,
+               navitem=path)
+    os.makedirs(output_dir, exist_ok=True)
+    env.get_template(template_name).stream(ctx).dump(output_path,
+                                                     encoding='utf-8')
+
+
+def copy_public_files(root=''):
+    for f in os.scandir(os.path.join('public', root)):
+        src = os.path.join(root, f.name)
+        dst = os.path.join('output', src)
+        if f.is_dir():
+            os.makedirs(dst, exist_ok=True)
+            copy_public_files(src)
+        else:
+            shutil.copyfile(f.path, dst)
+
+
+os.makedirs('output', exist_ok=True)
+copy_public_files()
+
+for fn in glob.glob('content/**/*.yml', recursive=True):
+    generate_file(env, fn)

package/deps/jq/docs/content/download/default.yml

@@ -0,0 +1,249 @@
+headline: Download jq
+body:
+  - text: |
+
+      jq is written in C and has no runtime dependencies, so it should be
+      possible to build it for nearly any platform. Prebuilt binaries are
+      available for Linux, macOS and Windows.
+
+      The binaries should just run, but on macOS and Linux you may need
+      to make them executable first using `chmod +x jq`.
+
+      jq is licensed under the MIT license. For all of the gory
+      details, read the file `COPYING` in the source distribution.
+
+      jq uses a C library for decimal number support. This is an ICU 1.8.1
+      licensed code obtained from the ICU downloads archive.  
+      <https://download.icu-project.org/files/decNumber/decNumber-icu-368.zip>
+
+
+      ### Linux
+
+       * jq is in the official [Debian](https://packages.debian.org/jq) and
+         [Ubuntu](https://packages.ubuntu.com/jq) repositories. Install using
+         `sudo apt-get install jq`.
+
+       * jq is in the official [Fedora](https://src.fedoraproject.org/rpms/jq) repository.
+         Install using `sudo dnf install jq`.
+
+       * jq is in the official [openSUSE](https://software.opensuse.org/package/jq) repository.
+         Install using `sudo zypper install jq`.
+
+       * jq is in the official [Arch](https://archlinux.org/packages/?q=jq) repository.
+         Install using `sudo pacman -S jq`.
+
+       * jq 1.7.1 binaries for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.7.1/jq-linux-amd64)
+         or
+         [ARM64](https://github.com/jqlang/jq/releases/download/jq-1.7.1/jq-linux-arm64)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.7.1/jq-linux-i386).
+
+       * jq 1.7 binaries for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.7/jq-linux-amd64)
+         or
+         [ARM64](https://github.com/jqlang/jq/releases/download/jq-1.7/jq-linux-arm64)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.7/jq-linux-i386).
+
+       * jq 1.6 binaries for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.6/jq-linux64)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.6/jq-linux32).
+
+       * jq 1.5 binaries for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.5/jq-linux64)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.5/jq-linux32).
+
+       * jq 1.4 binaries for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.4/jq-linux-x86_64)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.4/jq-linux-x86).
+
+       * jq 1.3 binaries for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.3/jq-linux-x86_64)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.3/jq-linux-x86).
+
+      ### macOS
+
+       * Use [Homebrew](https://brew.sh/) to install jq with `brew install jq`.
+
+       * Use [MacPorts](https://www.macports.org) to install jq with `port install jq`.
+
+       * Use [Fink](https://finkproject.org) to install jq with `fink install jq`.
+
+       * jq 1.7.1 binaries for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.7.1/jq-macos-amd64)
+         or
+         [ARM64](https://github.com/jqlang/jq/releases/download/jq-1.7.1/jq-macos-arm64).
+
+       * jq 1.7 binaries for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.7/jq-macos-amd64)
+         or
+         [ARM64](https://github.com/jqlang/jq/releases/download/jq-1.7/jq-macos-arm64).
+
+       * jq 1.6 binary for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.6/jq-osx-amd64).
+
+       * jq 1.5 binary for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.5/jq-osx-amd64).
+
+       * jq 1.4 binaries for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.4/jq-osx-x86_64)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.4/jq-osx-x86).
+
+       * jq 1.3 binaries for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.3/jq-osx-x86_64)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.3/jq-osx-x86).
+
+      ### FreeBSD
+
+       * `pkg install jq` as root installs a pre-built
+         [binary package](https://www.freebsd.org/doc/en_US.ISO8859-1/books/handbook/pkgng-intro.html).
+
+       * `make -C /usr/ports/textproc/jq install clean` as root installs the
+         [jq](https://www.freshports.org/textproc/jq/)
+         [port](https://www.freebsd.org/doc/en_US.ISO8859-1/books/handbook/ports-using.html)
+         from source.
+
+      ### Solaris
+
+       * `pkgutil -i jq` in [OpenCSW](https://www.opencsw.org/p/jq) for Solaris
+         10+, Sparc and x86.
+
+       * jq 1.4 binaries for Solaris 11
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.4/jq-solaris11-64)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.4/jq-solaris11-32).
+
+      ### Windows
+
+       * Use [winget](https://learn.microsoft.com/en-us/windows/package-manager/winget/)
+         to install jq with `winget install jqlang.jq`.
+
+       * Use [scoop](https://scoop.sh/) to install jq with `scoop install jq`.
+
+       * Use [Chocolatey NuGet](https://chocolatey.org/) to install jq with
+         `choco install jq`.
+
+       * jq 1.7.1 executables for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.7.1/jq-windows-amd64.exe)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.7.1/jq-windows-i386.exe).
+
+       * jq 1.7 executables for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.7/jq-windows-amd64.exe)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.7/jq-windows-i386.exe).
+
+       * jq 1.6 executables for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.6/jq-win64.exe)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.6/jq-win32.exe).
+
+       * jq 1.5 executables for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.5/jq-win64.exe)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.5/jq-win32.exe).
+
+       * jq 1.4 executables for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.4/jq-win64.exe)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.4/jq-win32.exe).
+
+       * jq 1.3 executables for
+         [AMD64](https://github.com/jqlang/jq/releases/download/jq-1.3/jq-win64.exe)
+         or
+         [i386](https://github.com/jqlang/jq/releases/download/jq-1.3/jq-win32.exe).
+
+      ### Checksums and signatures
+
+      SHA-256 checksums are provided for all release and pre-release binaries.
+      They can be found under
+      [sig/v1.x/sha256sum.txt](https://github.com/jqlang/jq/tree/master/sig).
+      The checksums for jq 1.7.1 are in
+      [sig/v1.7.1/sha256sum.txt](https://raw.githubusercontent.com/jqlang/jq/master/sig/v1.7.1/sha256sum.txt).
+      The checksums for jq 1.7 are in
+      [sig/v1.7/sha256sum.txt](https://raw.githubusercontent.com/jqlang/jq/master/sig/v1.7/sha256sum.txt).
+      The checksums for jq 1.6 are in
+      [sig/v1.6/sha256sum.txt](https://raw.githubusercontent.com/jqlang/jq/master/sig/v1.6/sha256sum.txt).
+      The checksums for jq 1.5 are in
+      [sig/v1.5/sha256sum.txt](https://raw.githubusercontent.com/jqlang/jq/master/sig/v1.5/sha256sum.txt).
+
+      Additionally, all release artifacts are signed by a jq release key.  We have two release keys, [one for 1.6 and older releases](https://raw.githubusercontent.com/jqlang/jq/master/sig/jq-release-old.key), and [one for 1.7 and newer releases](https://raw.githubusercontent.com/jqlang/jq/master/sig/jq-release-new.key).
+      Signatures can be found under
+      [sig/v1.x/\*.asc](https://github.com/jqlang/jq/tree/master/sig).
+      The signatures for jq 1.7.1 are in
+      [sig/v1.7.1/\*.asc](https://github.com/jqlang/jq/tree/master/sig/v1.7.1).
+      The signatures for jq 1.7 are in
+      [sig/v1.7/\*.asc](https://github.com/jqlang/jq/tree/master/sig/v1.7).
+      The signatures for jq 1.6 are in
+      [sig/v1.6/\*.asc](https://github.com/jqlang/jq/tree/master/sig/v1.6).
+      The signatures for jq 1.5 are in
+      [sig/v1.5/\*.asc](https://github.com/jqlang/jq/tree/master/sig/v1.5).
+      You can use [GnuPG](https://gnupg.org/) to verify a signature by downloading
+      the signature and running `gpg --verify signature.asc`.
+
+      ### From source on Linux, macOS, Cygwin, and other POSIX-like operating systems
+
+       * [Source tarball for jq 1.7.1](https://github.com/jqlang/jq/releases/download/jq-1.7.1/jq-1.7.1.tar.gz)
+       * [Source tarball for jq 1.7](https://github.com/jqlang/jq/releases/download/jq-1.7/jq-1.7.tar.gz)
+       * [Source tarball for jq 1.6](https://github.com/jqlang/jq/releases/download/jq-1.6/jq-1.6.tar.gz)
+       * [Source tarball for jq 1.5](https://github.com/jqlang/jq/releases/download/jq-1.5/jq-1.5.tar.gz)
+
+      You can build it using the usual `./configure && make && sudo
+      make install` rigmarole.
+
+      If you're interested in using the latest development version, try:
+
+          git clone --recursive https://github.com/jqlang/jq.git
+          cd jq
+          autoreconf -i
+          ./configure
+          make
+          sudo make install
+
+      To build it from a git clone, you'll need to install a few
+      packages first:
+
+       * [GCC](https://gcc.gnu.org)
+       * [Make](https://www.gnu.org/software/make/)
+       * [Autotools](https://www.gnu.org/software/automake/)
+
+      For Linux systems, these will all be in your system's package
+      manager, and if you do development on the machine they're most
+      likely already installed.
+
+      On macOS, these are all included in Apple's command line tools, which can
+      be installed from [Xcode](https://developer.apple.com/xcode/). However,
+      you may find that you need a newer version of Bison than the one provided
+      by Apple. This can be found in [Homebrew](https://brew.sh/) or
+      [MacPorts](https://macports.org/).
+
+      If you want to generate the lexer and parser from source you can use the
+      `--enable-maintainer-mode` configure flag. This requires bison to be installed.
+      [Flex](https://github.com/westes/flex) and
+      [Bison](https://www.gnu.org/software/bison/).
+
+      ### Docker
+
+      Docker image is available from
+      [GitHub Container Registry](https://github.com/jqlang/jq/pkgs/container/jq).
+
+          docker run -i --rm ghcr.io/jqlang/jq -n 'range(3)'
+
+      #### Building the documentation
+
+      jq's documentation is compiled into static HTML using Python.
+      To build the docs, run `pipenv run python3 build_website.py --root /output`
+      in the `docs/` directory. To serve them locally, you can run
+      `python3 -m http.server`. You'll need a few Python dependencies,
+      which can be installed by following the instructions in `docs/README.md`.
+
+      The man page is built by `make jq.1`, or just `make`, also from
+      the YAML docs, and you'll still need the Python dependencies to
+      build the manpage.