Spork

Parse `(dyn :args)` according to options. If the arguments are incorrect,
will return nil and print usage information.

Each option is a table or struct that specifies a flag or option
for the script. The name of the option should be a string, specified
via `(argparse/argparse "..." op1-name {...} op2-name {...} ...)`. A help option
and usage text is automatically generated for you.

The keys in each option table are as follows:

* `:kind` - What kind of option is this? One of `:flag`, `:multi`, `:option`, or
 `:accumulate`. A flag can either be on or off, a multi is a flag that can be provided
 multiple times, each time adding 1 to a returned integer, an option is a key that
 will be set in the returned table, and accumulate means an option can be specified
 0 or more times, each time appending a value to an array.
* `:short` - Single letter for shorthand access.
* `:help` - Help text for the option, explaining what it is.
* `:default` - Default value for the option.
* `:required` - Whether or not an option is required.
* `:short-circuit` - Whether or not to stop parsing and fail if this option is hit.
* `:action` - A function that will be invoked when the option is parsed.

There is also a special option name `:default` that will be invoked on arguments
that do not start with a -- or -. Use this option to collect unnamed
arguments to your script. This is separate from the `:default` key in option specifiers.

After "--", every argument is treated as an unnamed argument.

Once parsed, values are accessible in the returned table by the name
of the option. For example `(result "verbose")` will check if the verbose
flag is enabled.

Converts a base64 encoded string to its binary representation of any format
(UTF-8, binary, ..).

Converts a string of any format (UTF-8, binary, ..) to base64 encoding.

Create a CRC function based on the given polynomial, initial value, xourout, and whether to invert input bytes.

Get a named CRC variant.

Check if a given time matches a cron specifier.

Given a cron schedule, get the next instance on the cron tab after time

Parse a cron string into a valid cron schedule object

Spawn a fiber into a nursery, similar to ev/go.

Suspend the current fiber until the nursery is emptied.

Run instances of a function over multiple threads. On failures, restart the failed thread. Normal function returns will not trigger a restart.

Group a number of fibers into a single object for structured concurrency

Call a function n times (in parallel) for side effects. Each function is called with an integer argument indicating a fiber index. Returns nil.

Executes a dag by calling f on every node in the graph. Can set the number of workers for parallel execution. The graph is represented as a table mapping nodes to arrays of child nodes. Each node will only be evaluated after all children have been evaluated. Modifying `dag` inside `f` will not affect the scheduling of workers. Returns a table mapping each node to the result of `(f node)`.

Map `f` over data in parallel, optionally limiting parallelism to `n` workers.

Function form of `ev/gather`. If any of the sibling fibers error, all other siblings will be canceled. Returns the gathered results in an array. `data` can be any indexed data structure.

Similar to pmap-full, but only runs work n-ways parallel.

Similar to ev/spawn but associate spawned fibers with a nursery

Wait forever until the current fiber is canceled, and then run some cleanup code.

Format a string of source code to a buffer.

Format a file

Format a string of source code and print the result.

Concatenate one or more generators or iterables into a single generator.

Repeatedly yield the elements of `ds`, looping back to the beginning when finished.

Drop `n` elements from `ds`.

Drop elements from `ds` until `p` is true.

Drop elements from `ds` while `p` is true.

Create a generator that filters `ds` with `p`.

Create a new generator around any iterable data structure.

Create a generator that maps `f` over `ds`.

Map `f` over `ds`, concatenating the results into a new generator.

Create a lazy range.

Evaluate `s` for side effects.

Take `n` elements from iterable `ds`.

Return elements from `ds` until `p` is true.

Return elements from `ds` while `p` is true.

Consume `s` into a new array.

Given a buffer and a cursor position, extract a string that will be used as context for autocompletion. Return a position and substring from the buffer to use for autocompletion.

Default handler to get available autocomplete options for a given substring.

Default handler for Ctrl-G to lookup docstrings in the current environment.

Reads a line of input into a buffer, like `getline`. However, allow looking up entries with a general lookup function rather than a environment table.

Maximal amount of items in the history

Escape characters in a string for HTML

Render HTML from standard data structures. Fills the provided optional buffer, or new one if it is not provided, with the html bytes.

Get an object that can be used to splice in HTML literals. `text` is not escaped in the output string.

Grammar to parse a cookie header to a series of keys and values.

Parses cookies into the table under :cookies key

Creates a logging middleware. The logger middleware prints URL route, return status, and elapsed request time.

Coerce any type to http middleware

Grammar that parses a query string (sans url path and ? character) and returns a table.

Given a request, read the HTTP body from the connection. Returns the body as a buffer. If the request has no body, returns nil.

Read an HTTP request header from a connection. Returns a table with the following keys: * `:headers` - table mapping header names to header values. Header names are lowercase. * `:connection` - the connection stream for the header. * `:buffer` - the buffer instance that may contain extra bytes. * `:head-size` - the number of bytes used by the header. * `:method` - the HTTP method used. * `:path` - the path of the resource requested. The following keys are also present, but omitted if the user passes a truthy parameter to `no-query`. * `:route` - path of the resource requested without query string. * `:query-string` - segment of HTTP path after first ? character. * `:query` - the query string parsed into a table. Supports a single string value     for every string key, and any query parameters that aren't given a value are mapped to true.  Note that data is read in chunks and any data after the header terminator is  stored in `:buffer.`

Read an HTTP response header from a connection. Returns a table with the following keys: * `:headers` - table mapping header names to header values. Header names are lowercase. * `:connection` - the connection stream for the header. * `:buffer` - the buffer instance that may contain extra bytes. * `:head-size` - the number of bytes used by the header. * `:status` - the HTTP status code. * `:message` - the HTTP status message. Note that data is read in chunks and any data after the header terminator is stored in `:buffer.`

Make an HTTP request to a server. Returns a table contain response information. * `:head-size` - number of bytes in the http header * `:headers` - table mapping header names to header values. Header names are lowercase. * `:connection` - the connection stream for the header. * `:buffer` - the buffer instance that may contain extra bytes. * `:status` - HTTP status code as an integer. * `:message` - HTTP status message. * `:body` - Bytes of the response body.

PEG for parsing HTTP requests

PEG for parsing HTTP responses

Creates a router middleware. A router will dispatch to different routes based on the URL path.

Send an HTTP response over a connection. Will automatically use chunked encoding if body is not a byte sequence. `response` should be a table with the following keys: * `:headers` - optional headers to write * `:status` - integer status code to write * `:body` - optional byte sequence or iterable (for chunked body) for returning contents. The iterable can be lazy, i.e. for streaming    data.

Makes a simple http server. By default it binds to 0.0.0.0:8000, returns a new server stream. Simply wraps http/server-handler with a net/server.

A simple connection handler for an HTTP server. When a connection is accepted. Call this with a handler function to handle the connect. The handler will be called with one argument, the request table, which will contain the following keys: * `:head-size` - number of bytes in the http header. * `:headers` - table mapping header names to header values. * `:connection` - the connection stream for the header. * `:buffer` - the buffer instance that may contain extra bytes. * `:path` - HTTP path. * `:method` - HTTP method, as a string.

Mapping of HTTP status codes to their status message.

Grammar to parse a URL into domain, port, and path triplet. Only supports the http:// protocol.

Add all local functions defined with :path metadata to a server. Will read from the :schema, :doc, :path, and :route-doc metadata to determine how the route behaves.

Add a single manually route to a server. Prefer using `httpf/add-bindings-as-routes` for the usual case.

Add some metadata to all responses

Start server

Create a new server.

Returns a janet object after parsing JSON. If keywords is truthy, string keys will be converted to keywords. If nils is truthy, null will become nil instead of the keyword :null.

Encodes a janet value in JSON (utf-8). tab and newline are optional byte sequence which are used to format the output JSON. if buf is provided, the formated JSON is append to buf instead of a new buffer. Returns the modifed buffer.

Dynamic binding to front matter after parsing, compilation, and evaluation, of markup completes.

The htmlgen source that can be used to generate a document with htmlgen/html.

Allow importing and requiring markup as a module

Create an in-page anchor for a local link.

Make span element with bigger font

Make a block quote element

Center some content

Make code element with class mendoza-code

Inline code or codeblock

Add a horizontal rule

Embed some raw html

Make an image element

Create an anchor link

Parse mendoza markup and evaluate it returning an htmlgen document tree.

Loader for the mdz format

Create a section. Usually used to embed different parts of the content document into different parts of the main page.

Make span element with smaller font

Wrap some content in an html tag. If you need attributes or other properties, you may want to use raw HTML via the html function.

Return a function that discards any arguments and always returns `x`.

Get the third-to-last element from an indexed data structure.

Captures the standart error output of the variadic `body` and returns it
as a buffer.

Captures the standart output of the variadic `body` and returns it as
a buffer.

Threading conditional macro. It takes `val` to mutate,
and `clauses` pairs with condition and operation to which the `val`,
is put as first argument. All conditions are tried and
for truthy conditions the operation is executed.
Returns the value mutated if any condition is truthy.

Threading conditional macro. It takes `val` to mutate,
and `clauses` pairs of condition and operation to which the `val`,
is put as last argument. All conditions are tried and
for truthy the operation is ran.
Returns mutated value if any condition is truthy.

Remove indentation after concatenating the arguments. Works by removing
leading whitespace, and then removing that same pattern of whitepsace after
new lines.

Defines many constants as in let `bindings`, but without creating new scope.

Do a depth first, pre-order traversal over a data structure.
Also allow for callbacks before and after visiting the children
of a node. Also allow for a custom `get-children` function to
change traversal as needed. Will detect cycles if an empty table
is passed as the `seen` parameter, which is used to cached values
that have been visited.

Convenience macro for defining constant named `c` with value `d` before `body`
and returning it after evaluating `body`, that presumably modifies 
the `c` refered content. For example buffer, table or array.

Convenience macro for defining varible named `v` with value `d` before `body`
and returning it after evaluating `body`, that presumably modifies `v`.

Same as print-table but pushes table into a buffer.

Recursive macro (get). Similar to get-in, but keys are variadic argument.

Insert elements in `arr` such that it remains sorted by the comparator. If
`arr` is not sorted beforehand, the results are undefined. Returns `arr`.

Insert elements in `arr` such that it remains sorted by the value returned
when `f` is called with the element, comparing the values with <. If `arr` is
not sorted beforehand, the results are undefined. Returns `arr`.

Stringify an integer in a particular base. Defaults to decimal (base 10).

(int/ & xs)

Perform integer division.

Print to a dynamic binding stream if that stream is set, otherwise do
nothing. Evaluate to nil. 
For example, `(log :err "value error: %V" my-value)` will print 
to `(dyn :err)` only if `(dyn :err)` has been set.

Convenience macro for creating new table from even number of kvs pairs in a variadic `table-or-pairs`
arguments and setting its prototype to `prototype`.
Factory function for creating new objects from prototypes.

Create a random, printable keyword id with 10 bytes of entropy
with an optional prefix.

Returns new table with function `f` applied to `data`'s
keys recursively.

Returns new table with function `f` applied to `data`'s values.

Get the second-to-last element from an indexed data structure.

Iterate through the rows of a data structure and print a table in a human
readable way, with padding and heading information. Can optionally provide
a function use to print a row, as well as optionally select column keys
for each row. Lastly, a `header-mapping` dictionary can be provided that
changes the printed header names by mapping column keys to the desired
header name. If no mapping is found, then the column key will be used as
the header name. Returns nil.

Randomizes array using the fisher-yates shuffle, takes an optional random
number generator.

Get the second element from an indexed data structure.

Returns new table with selected `keyz` from dictionary `data`.

Parallel `set` function. Takes a list of targets and
expressions, evaluates all the expressions, and then
assigns them to the targets. Each target can be a variable
or a 2-tuple, just like in the normal `set` special form.

Parse an integer in the given base. Defaults to decimal (base 10). Differs
from scan-number in that this does not recognize floating point notation.

Filter a key-value structure info a table. Semantics are the same as for
built-in `filter`, except that `pred` takes two arguments (key and value.)
Does not consider prototypes.

Get the third element from an indexed data structure.

Trim the specified prefix of a string if it has one

Trim the specified suffix of a string if it has one

Repeat `body` while the `cnd` is false.
Equivalent to (while (not cnd) ;body).

Defines many variables as in let `bindings`, but without creating new scope.

Create both a send an recv function from a stream, as with `make-send` and `make-recv`.

Get a function that, when invoked, gets the next message from a readable stream. Provide an optional unpack function that will parse the received buffer.

Create a function that when called with a msgs sends that msg. Provide an optional pack function that will convert a message to a string.

Connect to a repl server. The default host is "127.0.0.1" and the default port is "9365".

Default host to run server on and connect to.

Default port to run the net repl.

Start a repl server. The default host is "127.0.0.1" and the default port is "9365". Calling this will start a TCP server that exposes a repl into the given env. If no env is provided, a new env will be created per connection. If env is a function, that function will be invoked with the name and stream on each connection to generate an environment. `cleanup` is an optional function that will be called for each stream after closing if provided. `welcome-msg` is an optional string or function (welcome-msg client-name) to generate a message to print for the client on connection.

Short-hand for serving up a a repl that has a single environment table in it. `env` must be a proper env table, not a function as is possible in netrepl/server.

Coerce a path to be absolute.

Check if a path is absolute.

Gets the base file name of a path.

Platform delimiter

Gets the directory name of a path.

Get the file extension for a path.

Join path elements together.

Normalize a path. This removes . and .. in the path, as well as empty path elements.

Split a path into its parts.

Coerce a path to be absolute.

Check if a path is absolute.

Gets the base file name of a path.

Platform delimiter

Gets the directory name of a path.

Get the file extension for a path.

Join path elements together.

Normalize a path. This removes . and .. in the path, as well as empty path elements.

Split a path into its parts.

Get the relative path between two subpaths.

Platform separator

Get the relative path between two subpaths.

Platform separator

Coerce a path to be absolute.

Check if a path is absolute.

Gets the base file name of a path.

Platform delimiter

Gets the directory name of a path.

Get the file extension for a path.

Join path elements together.

Normalize a path. This removes . and .. in the path, as well as empty path elements.

Split a path into its parts.

Get the relative path between two subpaths.

Platform separator

Begin raw terminal functionality. Return a stream that can be read from to get input.

Move to a new position in a buffer from index by incrementing by `delta` codepoints. Can also skip zero-width codepoints if desired.

A handler that a user can use to handle ctrl-z from input to suspend the current process.

End raw terminal functionality.

Get a byte of input from stdin, without blocking if possible. Returns a buffer.

Check if the current stdin is a tty.

Measure the monospace width of a string.

Get the monospace width of a rune. Returns either 0, 1, or 2.

Get the number of rows and columns visible in the terminal as tuple [rows cols]

Get a byte slice that will fit into a number of columns.

Compile a subset of regex to a PEG if pattern is a string. If pattern is a PEG, will return the PEG as is.

Similar to peg/find, but for regexes.

Similar to peg/find-all, but for regexes.

Similar to peg/match, but for regexes.

Peg used to generate peg source code from a regular expression string.

Similar to peg/replace, but for regexes.

Similar to peg/replace-all, but for regexes.

Compile a subset of regex to PEG source code.

Create an RPC client. The default host is "127.0.0.1" and the default port is "9366". Returns a table of async functions that can be used to make remote calls. This table also contains a :close function that can be used to close the connection.

Default host to run server on and connect to.

Default port to run the net repl.

Create an RPC server. The default host is "127.0.0.1" and the default port is "9366". Also must take a dictionary of functions that clients can call.

Generate a function that can be used to validate a data structure. This is the function form of `predicate`.

Generate a function that can be used to validate a data structure. This is the function form of `validator`.

Make a validation predicate given a certain schema.

Make a validation function of one argument. A validation function will throw an error on validation failure, otherwise, it will return the argument.

The currently running service manager, if there is one

The currently running service, if there is one

Spawn a service

Get a list of running services

Get the current manager. If no manager exists, create one.

Get the current service. If not in a service, raise an error

Group a number of fibers into a single object for structured concurrency. Also includes utilities for running services like servers in the background.

Print a table of all running services.

Remove a service

Set a textual description of the service to describe what it is doing currently

Start or restart a service

Stop a running service

Once a number of services have been spawned, call `wait` to block the fiber until the manager is canceled. This lets a manager fiber behave as a service itself.

Copy a file or directory recursively from one location to another.
Expects input to be unix style paths

Copy a file from source to destination. Creates all directories in the path to the destination file if they do not exist.

Create all directories in path specified as string including itself.

get the /dev/null equivalent of the current platform as an open file

Execute command specified by args returning it's exit code

Execute command specified by args, fails when command exits with non-zero exit code

Read stdout of command specified by args and return it trimmed in a string.

Read stdout and stderr of subprocess and return it trimmed in a struct with :err and :out containing the output as string.
This will also return the exit code under the :status key.

Check if the given file or directory exists. (Follows symlinks)

List the files in the given directory recursively. Return the paths to all files found, relative to the current working directory if the given path is a relative path, or as an absolute path otherwise.

Create and open a file, creating all the directories leading to the file if they do not exist, and return it. By default, open as a writable file (mode is `:w`).

Remove a directory and all sub directories recursively.

Scan a directory recursively, applying the given function on all files and directories in a depth-first manner. This function has no effect if the directory does not exist.

Return typed array buffer or create a new buffer.

Copy count elements (default 1) of src array from index sindex to dst array at position dindex memory can overlap.

Return typed array or buffer size.

Create new typed array.

Return typed array properties as a struct.

Takes a slice of a typed array from start to end. The range is half open, [start, end). Indexes can also be negative, indicating indexing from the end of the end of the typed array. By default, start is 0 and end is the size of the typed array. Returns a new janet array.

Swap count elements (default 1) between src array from index sindex and dst array at position dindex memory can overlap.

Get an array of all task ids for which there is still data on disk. If `detailed` is truthy, return full task metadata instead of ids.

Cancel a queued or running task.

Prevent any tasks from being added to queues. When an executor finishes it's current job, if there are any, it will terminate. When all executors complete, the call to `run-executors` will complete.

Default expiration time (1 day)

Default task priority

Default location of task records

Name of the file for logging errors

Maximum allowed priority (lower priority tasks will execute first)

Minimum allowed priority (lower priority tasks will execute first)

Create queues and various settings to run tasks. Create a new tasker table.

Name of the file for general logging

Add a task specification to a queue. Supply an argv string array that will be used to invoke s a subprocess. The optional `note` parameter is just a textual note for task trackingv. The `priority` parameter should be an integer between 0 and 9 inclusive, default is 4. Lower priority jobs in the same queue will be executed by higher priority. Use input to pass in generic, unstructured input to a task.

Delete old expired jobs saved on disk

Start a number of executors to run tasks as with `tasker/spawn-executors`, and then wait for all executors to complete.

Start a number of executors to run tasks. Tasks can be added to a queue by calling queue-task. A single tasker object can make multiple calls to spawn-executors.

A tuple of all possible statuses that a task can have.

Get a log file for a path. By default, will get a path to out.log.

Name of the task metadata file

Look up the status of a given task by id.

Adds the custom template loader to Janet's module/loaders and update module/paths.

Base environment for rendering

Compile a Temple template into a function which will return a
rendered buffer.

The resulting function should receive the template arguments in the
&keys format.

Compile a template string into a function. Optionally provide a location where the source is from to improve debugging. Returns the template function.

Override's the default assert with some nice error handling.

Assert that all symbols, when module on the path is required,
have proper doc string

Test passes if forms error.

Test passes if forms do not error.

Invert assert.

Runs the form and captures stderr. Returns tuple with result of the form
and a string with captured stderr.

Runs the form and captures stdout. Returns tuple with result of the form
and a string with captured stdout.

Ends test suite, prints summary and exits if any have failed.

Starts test suite.

Suppreses stdout from the body

Suppreses stdout from the body

Time the execution of `form` using `os/clock` before and after,
and print the result to stdout. returns: result of executing `form`.
Uses `tag` (default "Elapsed time:") to tag the printout.

Read a UTF-8 encoded Unicode codepoint from the buffer which starts at the given index. Returns a tuple [value width], where width = number of bytes consumed. If at the end of buffer or the buffer contains malformed UTF-8, returns [nil 0].

Encode a Unicode codepoint into the end of a buffer.

Given the first byte in an UTF-8 sequence, get the number of bytes that the codepoint sequence takes up, including the prefix byte.

Add a byte sequence to the zip writer.

Add a file to the zip writer.

Compress data and write to a buffer. Different compression levels can be used - higher compression levels trade smaller output with longer compression times. Returns `into`. If `into` not provided, a new buffer is created.

Decompress data and write to a buffer. If an `into` buffer is not provided, a new buffer will be created.

Extract a file from the zip archive, either to memory or to a file on disk.

Check if a file index is a directory.

Check if a file is encrypted inside an archive.

Check if a file is supported with this verstion of miniz.

Convert a file index index in the archive to a filename.

Get the index of a particular filename in the archive.

Read a byte sequence as a zip archive. Returns a new zip reader.

Read a file as a zip archive. Returns a new zip reader.

Close a reader and free related memory.

Get the number of files inside the zip archive. The files can be indexed 

Get stat information of file. Returns a new struct with the following fields:

* :index - integer index in master directory
* :version-made-by - zip verstion
* :version-needed - zip version needed to unzip
* :bit-flag
* :method - compression method
* :time - file time
* :crc32 - checksum of file contents
* :comp-size - size of file when compressed
* :uncomp-size - size of file when uncompressed
* :filename
* :comment
* :internal-attr
* :external-attr

Get the version string of the underlying miniz library.

Create a new zip archive writer that write to memory.

Create a new zip archive writer that will write into an archive file.

Close a ZipWriter.

Finalize a writer, writing any zip files to disk. Return the writer.