Not consuming all input is now treated as an error, unless the
`must_consume_all_input` flag is set to false when parsing.

THe `a.stringOf(' \r\n\t'.split('')),` pattern works fine for small sets
of characters, but is horrible for situations like "any alphanumeric".
Instead, let's make it take a callback function that is run on each
character.

This now can parse JSON correctly in various configurations.

…-components--puter.com

chore(main): release 1.0.0

GUI loading refactor + service-registered gui scripts

refactor(gui): add service scripts

refactor: add GetUserService

In the first pass I add a `register` method and update `defineComponent`
so it calls `register` as well. This made it possible to create a
proof-of-concept for registered classes. Additionally ExportService was
added to expose registered classes to service scripts. This first pass
works, but it would be better if all types of classes (components or
otherwise) were registered via the same method.

Add a git client

ExportService gets removed and instead a global class registry is added.
The `init.js` file is split into `init_sync.js` and `init_async.js`
so that synchronous code that isn't dependent on imports is guarenteed
to run before initgui.js. The globalThis scope and service-script API
now expose `def`, a function for registering class definitions, and
`use`, a function for obtaining registered classes.

class registry for service scripts

Add exit status codes to `puter.exit()`, and an `exit` builtin to Phoenix

Tidy up "newparser" so it can be used properly

refactor: Move PosixError class where it can be accessed outside of Phoenix

This commit adds the following components:
- Glyph

The following improvements were made:
- do not require empty object in constructor
- allow components to override render mode based on constructor values
- improve error handling in get()
- allow array of property names in on_ready()->listen()
- allow components to be attached to shadow roots

This commit adds the following components:
- ActionCard
- Frame
- NotifCard

UI Updates

…n hover

I've found this useful for stubbing out parts of a grammar during
development.

The counterpart of stringOf(), it reads characters until it matches its
parameter.

Let's organise this a bit.

This is ported over from an old forgotten branch I'd deleted, then
thankfully managed to dig up again. 😅

Instead of making GroupCommand contain child commands, use a flat array
for commands and implement groups as GroupStartCommand and
GroupEndCommand. This makes it much simpler to iterate the commands
list in order to jump to labels.

Then implement those labels and the commands that use them: b, t, and T.

Also add the s SubstituteCommand, and combine the code for the q and Q
commands.

Some shell apps care about what order the arguments appear in. When
`parseArgs()` is called with `tokens: true`, it produces this `tokens`
array which represents all the command line options and arguments, in
order, which is useful for these more advanced cases.

Sed is now finally able to actually run scripts, instead of ignoring all
input and running a hard-coded test script!

These make more sense combined into one Command which is controlled by
constructor parameters:

- b, t and T
- d and D
- g and G
- h and H
- p and P

feat(backend): improve logger and reduce logs

fix: fix typo

Actually parse sed scripts

refactor(backend): de-couple driver registration from DriverService

occured -> occurred

chore: update UI.js

The script service allows other services to register re-runnable tasks
called "scripts". These can be invoked via "script:run" in the console.

* Update docker-image.yaml

* Update docker-image.yaml

* Update docker-image.yaml

* Update docker-image.yaml

* Update docker-image.yaml

* Create Docker on Tag and push on main

A package called "useapi" is introduced to provide a dynamic import
system. This import system, rather than relying on the state of the
filesystem, is populated as modules are installed into Puter's kernel.

The "useapi" package is then used to add support for loading external
mod directories as Puter kernel modules, making it possible to mod puter
without any tooling.

Using npm install appears to have different results depending on whether
or not the parent directory of the puter repository happens to have a
package.json file (ex: nested workspaces).