@manyducks.co/dolla 2.0.0-alpha.4 → 2.0.0-alpha.41

package/dist/typeChecking.d.ts

@@ -1,8 +1,8 @@
-type TypeNames = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "null" | "array" | "class" | "promise" | "NaN";
+type TypeNames = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "null" | "array" | "class" | "promise" | "map" | "set" | "NaN";
 /**
  * Extends `typeof` operator with more specific and useful type distinctions.
  */
-export declare function typeOf(value: unknown): TypeNames;
+export declare function typeOf(value: any): TypeNames;
 /**
  * Throws a TypeError unless `condition` is truthy.
  *
@@ -18,12 +18,6 @@ export declare function isArray(value: unknown): value is Array<unknown>;
  * Throws an error if `value` is not an array.
  */
 export declare function assertArray(value: unknown, errorMessage?: string): value is Array<unknown>;
-/**
- * Returns a function that takes a `value` and ensures that it is an array for which `check` returns true for every item.
- *
- * @param check - Function to check items against.
- */
-export declare function isArrayOf<T>(check: (item: unknown) => boolean): (value: unknown) => value is T[];
 /**
  * Returns true when `value` is an array and `check` returns true for every item.
  *
@@ -31,12 +25,6 @@ export declare function isArrayOf<T>(check: (item: unknown) => boolean): (value:
  * @param value - A possible array.
  */
 export declare function isArrayOf<T>(check: (item: unknown) => boolean, value: unknown): value is T[];
-/**
- * Returns a function that takes a `value` and throws a TypeError unless it is an array for which `check` returns true for every item.
- *
- * @param check - Function to check items against.
- */
-export declare function assertArrayOf<T>(check: (item: unknown) => boolean): (value: unknown) => value is T[];
 /**
  * Throws a TypeError unless `value` is an array and `check` returns true for every item.
  *
@@ -45,14 +33,6 @@ export declare function assertArrayOf<T>(check: (item: unknown) => boolean): (va
  * @param errorMessage - A custom error message.
  */
 export declare function assertArrayOf<T>(check: (item: unknown) => boolean, value: unknown, errorMessage?: string): value is T[];
-/**
- * Returns true if `value` is equal to `true` or `false`.
- */
-export declare function isBoolean(value: unknown): value is boolean;
-/**
- * Throws a TypeError unless `value` is equal to `true` or `false`.
- */
-export declare function assertBoolean(value: unknown, errorMessage?: string): value is boolean;
 /**
  * Returns true if `value` is a string.
  */
@@ -77,34 +57,6 @@ export declare function isNumber(value: unknown): value is number;
  * Throws a TypeError unless `value` is a number.
  */
 export declare function assertNumber(value: unknown, errorMessage?: string): value is number;
-/**
- * Returns true if `value` implements the Promise protocol.
- * This matches true instances of Promise as well as any object that
- * implements `next`, `catch` and `finally` methods.
- *
- * To strictly match instances of Promise, use `isInstanceOf(Promise)`.
- */
-export declare function isPromise<T = unknown>(value: unknown): value is Promise<T>;
-/**
- * Throws a TypeError unless `value` implements the Promise protocol.
- * This matches true instances of Promise as well as any object that
- * implements `next`, `catch` and `finally` methods.
- *
- * To strictly allow only instances of Promise, use `Type.assertInstanceOf(Promise)`.
- */
-export declare function assertPromise<T = unknown>(value: unknown, errorMessage?: string): value is Promise<T>;
-/**
- * Returns true if `value` is a class.
- */
-export declare function isClass(value: unknown): value is {
-    new (): unknown;
-};
-/**
- * Throws a TypeError unless `value` is a class.
- */
-export declare function assertClass(value: unknown, errorMessage?: string): value is {
-    new (): unknown;
-};
 /**
  * Returns a function that takes a `value` and returns true if `value` is an instance of `constructor`.
  *
@@ -132,30 +84,6 @@ export declare function assertInstanceOf<T extends Function>(constructor: T): (v
  * @param errorMessage - A custom error message for when the assertion fails.
  */
 export declare function assertInstanceOf<T extends Function>(constructor: T, value: unknown, errorMessage?: string): value is T;
-/**
- * Returns true if `value` is a Map.
- */
-export declare function isMap<K = unknown, V = unknown>(value: any): value is Map<K, V>;
-/**
- * Throws a TypeError unless `value` is a Map.
- */
-export declare function assertMap<K = unknown, V = unknown>(value: any, errorMessage?: string): value is Map<K, V>;
-/**
- * Returns true if `value` is a Set.
- */
-export declare function isSet<T = unknown>(value: any): value is Set<T>;
-/**
- * Throws a TypeError if `value` is not a Set.
- */
-export declare function assertSet<T = unknown>(value: any, errorMessage?: string): value is Set<T>;
-/**
- * Returns true if `value` implements the Iterable protocol.
- */
-export declare function isIterable<T>(value: any): value is Iterable<T>;
-/**
- * Throws a TypeError unless `value` implements the Iterable protocol.
- */
-export declare function assertIterable<T>(value: any, errorMessage?: string): value is Iterable<T>;
 /**
  * Returns true if `value` is a plain JavaScript object.
  */
@@ -164,28 +92,4 @@ export declare function isObject(value: unknown): value is Record<string | numbe
  * Throws a TypeError unless `value` is a plain JavaScript object.
  */
 export declare function assertObject(value: unknown, errorMessage?: string): value is object;
-/**
- * Returns true if `value` is equal to `null`.
- */
-export declare function isNull(value: unknown): value is null;
-/**
- * Throws a TypeError unless `value` is equal to `null`.
- */
-export declare function assertNull(value: unknown, errorMessage?: string): value is null;
-/**
- * Returns true if `value` is equal to `undefined`.
- */
-export declare function isUndefined(value: unknown): value is undefined;
-/**
- * Throws a TypeError unless `value` is equal to `undefined`.
- */
-export declare function assertUndefined(value: unknown, errorMessage?: string): value is undefined;
-/**
- * Returns true if `value` is equal to `null` or `undefined`.
- */
-export declare function isEmpty(value: unknown): value is void;
-/**
- * Throws a TypeError unless `value` is equal to `null` or `undefined`.
- */
-export declare function assertEmpty(value: unknown, errorMessage?: string): value is void;
 export {};

package/dist/typeChecking.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -1,17 +1,17 @@
 import type * as CSS from "csstype";
-import { Ref, type Markup } from "./markup.js";
-import { SettableSignal, Signal } from "./signals.js";
+import type { Markup } from "./core/markup.js";
+import { Reactive } from "./core/signals.js";
 /**
  * Represents everything that can be handled as a DOM node.
  * These are all the items considered valid to pass as children to any element.
  */
-export type Renderable = string | number | Markup | false | null | undefined | Signal<any> | (string | number | Markup | false | null | undefined | Signal<any>)[];
+export type Renderable = string | number | Markup | false | null | undefined | Reactive<any> | (string | number | Markup | false | null | undefined | Reactive<any>)[];
 export type Stringable = {
     toString(): string;
 };
-type MaybeSignal<T> = T | Signal<T> | Signal<T | undefined>;
-type OptionalProperty<T> = T | Signal<T> | Signal<T | undefined>;
-type RequiredProperty<T> = T | Signal<T>;
+type MaybeReactive<T> = T | Reactive<T> | Reactive<T | undefined>;
+type OptionalProperty<T> = MaybeReactive<T>;
+type RequiredProperty<T> = T | Reactive<T>;
 type AutocapitalizeValues = "off" | "on" | "none" | "sentences" | "words" | "characters";
 type ContentEditableValues = true | false | "true" | "false" | "plaintext-only" | "inherit";
 type ClassListValues = string | ClassMap | Array<string | ClassMap | (string | ClassMap)[]>;
@@ -30,7 +30,6 @@ export interface ElementProps {
     /**
      * Object of event listeners.
      */
-    eventListeners?: OptionalProperty<Record<string, EventHandler<Event>>>;
     /**
      * CSS classes to be applied to this element. In addition to the standard space-separated list of class names,
      * this property also supports a class map object with class names as keys and booleans as values.
@@ -110,7 +109,7 @@ export interface ElementProps {
      *
      * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/style
      */
-    style?: string | CSSProperties | Signal<string> | Signal<CSSProperties> | Signal<string | CSSProperties> | Signal<string | undefined> | Signal<CSSProperties | undefined> | Signal<string | CSSProperties | undefined>;
+    style?: string | CSSProperties | Reactive<string> | Reactive<CSSProperties> | Reactive<string | CSSProperties> | Reactive<string | undefined> | Reactive<CSSProperties | undefined> | Reactive<string | CSSProperties | undefined>;
     /**
      * Fired when a CSS animation unexpectedly aborts.
      *
@@ -1210,7 +1209,7 @@ export type CSSProperties = {
     [K in keyof Styles]: OptionalProperty<Styles[K]>;
 };
 export interface ClassMap {
-    [className: string]: MaybeSignal<any>;
+    [className: string]: MaybeReactive<any>;
 }
 export type EventHandler<E> = (event: E) => void;
 export interface PropertiesOf<E extends HTMLElement> extends HTMLElementProps {
@@ -1219,9 +1218,9 @@ export interface PropertiesOf<E extends HTMLElement> extends HTMLElementProps {
      */
     children?: any;
     /**
-     * A settable signal or callback that receives the DOM node when rendered.
+     * Receives a reference to the DOM node when rendered.
      */
-    ref?: Ref<E> | Ref<HTMLElement> | Ref<Element> | Ref<Node>;
+    ref?: ((value: E | undefined) => void) | ((value: HTMLElement | undefined) => void) | ((value: Element | undefined) => void) | ((value: Node | undefined) => void);
 }
 /**
  * The following elements are defined based on the WHATWG HTML spec:
@@ -2098,7 +2097,7 @@ interface HTMLMediaElementProps<T extends HTMLMediaElement> extends HTMLElementP
      *
      * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/srcObject
      */
-    srcObject?: MediaStream | MediaSource | Blob | File | Signal<MediaStream> | Signal<MediaStream | undefined> | Signal<MediaSource> | Signal<MediaSource | undefined> | Signal<Blob> | Signal<Blob | undefined> | Signal<File> | Signal<File | undefined>;
+    srcObject?: MediaStream | MediaSource | Blob | File | Reactive<MediaStream> | Reactive<MediaStream | undefined> | Reactive<MediaSource> | Reactive<MediaSource | undefined> | Reactive<Blob> | Reactive<Blob | undefined> | Reactive<File> | Reactive<File | undefined>;
     /**
      * The current audio volume of the media element. Must be a number between 0 and 1.
      *
@@ -2597,7 +2596,7 @@ interface HTMLImageElementProps extends PropertiesOf<HTMLImageElement> {
      *
      * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/sizes
      */
-    sizes?: MaybeSignal<string>;
+    sizes?: MaybeReactive<string>;
     /**
      * The image URL.
      *
@@ -3143,7 +3142,6 @@ interface HTMLInputElementProps extends PropertiesOf<HTMLInputElement> {
     step?: OptionalProperty<number>;
     type?: OptionalProperty<InputType>;
     value?: OptionalProperty<string>;
-    $$value?: SettableSignal<any>;
     width?: OptionalProperty<string | number> | OptionalProperty<string> | OptionalProperty<number>;
     title?: OptionalProperty<string>;
     /**

package/dist/utils.d.ts

@@ -1,5 +1,18 @@
 export declare const noOp: () => void;
-export declare function deepEqual(one: any, two: any): boolean;
+export declare function getUniqueId(): string;
+/**
+ * Equality check that passes if both values are the same object.
+ * This is the default equality check for states.
+ */
+export declare function strictEqual(a: any, b: any): boolean;
+/**
+ * Equality check that passes if both values are the same object, or if both are objects or arrays with equal keys and values.
+ */
+export declare function shallowEqual(a: any, b: any): boolean;
+/**
+ * Equality check that passes if two objects have equal values, even if they are not the same object.
+ */
+export declare function deepEqual(a: any, b: any): boolean;
 /**
  * Takes an old value and a new value.  Returns a merged copy if both are objects, otherwise returns the new value.
  */
@@ -13,8 +26,10 @@ export declare function merge(one: unknown, two: unknown): any;
  * @param object - An object to clone without the omitted keys.
  */
 export declare function omit<O extends Record<any, any>>(keys: (keyof O)[], object: O): Record<any, any>;
-export declare function getDefaultConsole(): any;
-export declare function colorFromString(value: string): string;
+/**
+ * Takes any string and returns an OKLCH color.
+ */
+export declare function okhash(value: string): string;
 export type MatcherFunction = (value: string) => boolean;
 /**
  * Parses a filter string into a matcher function.

package/docs/http.md

@@ -0,0 +1,29 @@
+# HTTP Client
+
+> TODO: Write me.
+
+This page goes into detail on how to use the built in HTTP client.
+
+```js
+import Dolla from "@manyducks.co/dolla";
+
+Dolla.http.use(async (req, next) => {
+  // Apply auth header to all API routes.
+  if (req.url.pathname.startsWith("/api/")) {
+    req.headers.set("authorization", `Bearer ${localStorage.getItem("api-key")}`);
+  }
+
+  await next();
+});
+
+const res = await Dolla.http.get("/api/some-api-route");
+res.body; // body is already parsed as JSON if server responded with JSON
+```
+
+---
+
+End.
+
+- [🗂️ Docs](./index.md)
+- [🏠 README](../README.md)
+- [🦆 That's a lot of ducks.](https://www.manyducks.co)

package/docs/i18n.md

@@ -0,0 +1,38 @@
+# Internationalization (i18n) Support
+
+```jsx
+import Dolla, { createState, t } from "@manyducks.co/dolla";
+
+function CounterView(props) {
+  const [$count, setCount] = createState(0);
+
+  const increment = () => {
+    setCount((count) => count + 1);
+  };
+
+  return (
+    <div>
+      <p>Clicks: {$count}</p>
+      <button onClick={increment}>{t("buttonLabel")}</button>
+    </div>
+  );
+});
+
+Dolla.i18n.setup({
+  locale: "en",
+  translations: [
+    { locale: "en", strings: { buttonLabel: "Click here to increment" } },
+    { locale: "ja", strings: { buttonLabel: "ここに押して増加する" } },
+  ],
+});
+
+Dolla.mount(document.body, CounterView);
+```
+
+---
+
+End.
+
+- [🗂️ Docs](./index.md)
+- [🏠 README](../README.md)
+- [🦆 That's a lot of ducks.](https://www.manyducks.co)

package/docs/index.md

@@ -0,0 +1,10 @@
+# Dolla Docs
+
+> Write table of contents (see files in this folder in the meantime)
+
+---
+
+End.
+
+- [🏠 README](../README.md)
+- [🦆 That's a lot of ducks.](https://www.manyducks.co)

package/docs/router.md

@@ -0,0 +1,80 @@
+# Router
+
+Dolla makes heavy use of client-side routing. You can define as many routes as you have views, and the URL
+will determine which one the app shows at any given time. By building an app around routes, lots of things one expects
+from a web app will just work; back and forward buttons, sharable URLs, bookmarks, etc.
+
+Routes are matched by highest specificity regardless of the order they were registered.
+This avoids some confusing situations that come up with order-based routers like that of `express`.
+On the other hand, order-based routers can support regular expressions as patterns which Dolla's router cannot.
+
+## Route Patterns
+
+Routes are defined with strings called patterns. A pattern defines the shape the URL path must match, with special
+placeholders for variables that appear within the route. Values matched by those placeholders are parsed out and exposed
+to your code (`router` store, `$params` readable). Below are some examples of patterns and how they work.
+
+- Static: `/this/is/static` has no params and will match only when the route is exactly `/this/is/static`.
+- Numeric params: `/users/{#id}/edit` has the named param `{#id}` which matches numbers only, such as `123` or `52`. The
+  resulting value will be parsed as a number.
+- Generic params: `/users/{name}` has the named param `{name}` which matches anything in that position in the path. The
+  resulting value will be a string.
+- Wildcard: `/users/*` will match anything beginning with `/users` and store everything after that in params
+  as `wildcard`. `*` is valid only at the end of a route.
+
+Now, here are some route examples in the context of an app:
+
+```js
+import Dolla, { createRouter } from "@manyducks.co/dolla";
+import { ThingIndex, ThingDetails, ThingEdit, ThingDelete } from "./views.js";
+
+const router = createRouter({
+  routes: [
+    {
+      // A `null` component with subroutes acts as a namespace for those subroutes.
+      // Passing a view instead of `null` results in subroutes being rendered inside that view wherever `ctx.outlet()` is called.
+      path: "/things",
+      view: null,
+      routes: [
+        { path: "/", view: ThingIndex }, // matches `/things`
+        { path: "/{#id}", view: ThingDetails }, // matches `/things/{#id}`
+        { path: "/{#id}/edit", view: ThingEdit }, // matches `/things/{#id}/edit`
+        { path: "/{#id}/delete", view: ThingDelete }, // matches `/things/{#id}/delete`
+      ],
+    },
+    // All routes that don't match anything else will redirect to `/things`
+    { path: "*", redirect: "/things" },
+  ],
+});
+
+// Mount the router in place of a view.
+Dolla.mount(document.body, router);
+```
+
+When the URL matches a pattern the corresponding view is displayed. If we visit `/people/john`,
+we will see the `PersonDetails` view and the params will be `{ name: "john" }`. Params can be
+accessed from anywhere in the app through `Dolla.router`.
+
+```js
+import Dolla from "@manyducks.co/dolla";
+
+// Info about the current route is exported as a set of Readables. Query params are also Writable through $$query:
+const { $path, $pattern, $params, $query } = router;
+
+router.back(); // Step back in the history to the previous route, if any.
+router.back(2); // Hit the back button twice.
+
+router.forward(); // Step forward in the history to the next route, if any.
+router.forward(4); // Hit the forward button 4 times.
+
+router.go("/things/152"); // Navigate to another path within the same app.
+router.go("https://www.example.com/another/site"); // Navigate to another domain entirely.
+```
+
+---
+
+End.
+
+- [🗂️ Docs](./index.md)
+- [🏠 README](../README.md)
+- [🦆 That's a lot of ducks.](https://www.manyducks.co)

package/docs/setup.md

@@ -0,0 +1,31 @@
+# Setting up Dolla
+
+## Installation
+
+Dolla is published on npm as `@manyducks.co/dolla`. You can install it in your project with the following command:
+
+```
+npm i @manyducks.co/dolla
+```
+
+## JSX
+
+If you want to use JSX in your app you can add the following options to your `tsconfig.json` or `jsconfig.json`. Modern build systems like [Vite](https://vite.dev) will pick these up automatically.
+
+```json
+{
+  "compilerOptions": {
+    // ... other options ...
+    "jsx": "react-jsx",
+    "jsxImportSource": "@manyducks.co/dolla"
+  }
+}
+```
+
+---
+
+End.
+
+- [🗂️ Docs](./index.md)
+- [🏠 README](../README.md)
+- [🦆 That's a lot of ducks.](https://www.manyducks.co)

package/docs/signals.md

@@ -0,0 +1,149 @@
+## ⚡ Reactive Updates with `State`
+
+Dolla sets out to solve the challenge of keeping your UI in sync with your data. All apps have state that changes at runtime, and as those values change your UI must update itself to stay in sync with that state. JavaScript frameworks all have their own ways of meeting this challenge, but there are two main ones; virtual DOM and signals.
+
+[React](https://react.dev) and similar frameworks make use of a [virtual DOM](https://svelte.dev/blog/virtual-dom-is-pure-overhead), in which every state change causes a "diff" of the real DOM nodes on the page against a lightweight representation of what those nodes _should_ look like, followed by a "patch" where the minimal updates are performed to bring the DOM in line with the ideal virtual DOM.
+
+[Solid](https://www.solidjs.com) and similar frameworks make use of [signals](https://dev.to/this-is-learning/the-evolution-of-signals-in-javascript-8ob), which are containers for data that will change over time. Signal values are accessed through special getter functions that can be called inside of a "scope" to track their values. When the value of a tracked signal changes, any computations that happened in scopes that depend on those signals are re-run. In an app like this, all of your DOM updates are performed with pinpoint accuracy without diffing as signal values change.
+
+Dolla uses a concept of a `State`, which is a signal-like container for values that change over time. Where `State` differs from signals, however, is that there is no magical scope tracking going on behind the scenes. All States that depend on others do so explicity, so your code is easier to read and understand.
+
+The `State` API has just four functions:
+
+- `createState` to create a new state and a linked setter function.
+- `derive` to create a new state whose value depends on one or more other states.
+- `toState` to ensure that a value is a state object.
+- `toValue` to ensure that a value is a plain value.
+
+- `atom`
+- `compose`
+- `effect`
+- `get`
+- `peek`
+- `set`
+
+
+### Basic State API
+
+```js
+import { createState } from "@manyducks.co/dolla";
+
+// Equivalent to React's `useState` or Solid's `createSignal`.
+// A new read-only State and linked Setter are created.
+const [$count, setCount] = createState(72);
+
+// Get the current value.
+$count.get(): // 72
+
+// Set a new value.
+setCount(300);
+
+// The State now reflects the latest value.
+$count.get(); // 300
+
+// Data can also be updated by passing a function.
+// This function takes the current state and returns a new one.
+setCount((current) => current + 1);
+$count.get(); // 301
+```
+
+### Deriving States from other States
+
+#### Example 1: Doubled
+
+```js
+import { createState, derive } from "@manyducks.co/dolla";
+
+const [$count, setCount] = createState(1);
+
+const $doubled = derive([$count], (count) => count * 2);
+
+setCount(10);
+$doubled.get(); // 20
+```
+
+That was a typical toy example where we create a `$doubled` state that always contains the value of `$count`... doubled! This is the essential basic example of computed properties, as written in Dolla.
+
+#### Example 2: Selecting a User
+
+```js
+import { createState, derive } from "@manyducks.co/dolla";
+
+const [$users, setUsers] = createState([
+  { id: 1, name: "Audie" },
+  { id: 2, name: "Bob" },
+  { id: 3, name: "Cabel" },
+]);
+const [$selectedUserId, setSelectedUserId] = createState(1);
+
+const $selectedUser = derive([$users, $selectedUserId], (users, id) => {
+  return users.find((user) => user.id === id);
+});
+
+$selectedUser.get(); // { id: 1, name: "Audie" }
+
+setSelectedId(3);
+
+$selectedUser.get(); // { id: 3, name: "Cabel" }
+```
+
+That was a more realistic example you might actually use in real life. Here we are selecting a user from a list based on its `id` field. This is kind of similar to a `JOIN` operation in a SQL database. I use this kind of pattern constantly in my apps.
+
+The strength of setting up a join like this is that the `$users` array can be updated (by API call, websockets, etc.) and your `$selectedUser` will always be pointing to the latest version of the user data.
+
+#### Example 3: Narrowing Complex Data
+
+```jsx
+import { createState, derive } from "@manyducks.co/dolla";
+
+const [$user, setUser] = createState({ id: 1, name: "Audie" });
+
+const $name = derive([$user], (user) => user.name);
+
+$name.get(); // "Audie"
+
+// In a view:
+<span class="user-name">{$name}</span>;
+```
+
+Another common pattern. In a real app, most data is stored as arrays of objects. But what you need in order to slot it into a view is just a string. In the example above we've selected the user's name and slotted it into a `span`. If the `$user` value ever changes, the name will stay in sync.
+
+### Converting to and from States
+
+```js
+import { createState, toState, toValue } from "@manyducks.co/dolla";
+
+const [$count, setCount] = createState(512);
+
+// Unwrap the value of $count. Returns 512.
+const count = toValue($count);
+// Passing a non-state value will simply return it.
+const name = toValue("World");
+
+// Wrap "Hello" into a State containing "Hello"
+const $value = toState("Hello");
+// Passing a state will simply return that same state.
+const $number = toState($count);
+```
+
+### In Views
+
+```jsx
+import { derive } from "@manyducks.co/dolla";
+
+function UserNameView(props, ctx) {
+  const $name = derive([props.$user], (user) => user.name);
+
+  return <span class={{ "user-name": true, "is-selected": props.$selected }}>{$name}</span>;
+});
+```
+
+In the example above we've displayed the `name` field from a `$user` object inside of a span. We are also assigning an `is-selected` class dynamically based on whether the `$selected` prop contains a truthy or falsy value.
+
+---
+
+End.
+
+- [🗂️ Docs](./index.md)
+- [🏠 README](../README.md)
+- [🦆 That's a lot of ducks.](https://www.manyducks.co)