tsprose 0.0.1

package/LICENSE

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

package/README.md

@@ -0,0 +1,152 @@
+<img src="./.github/assets/banner.svg" alt="TSProse banner">
+
+<p></p>
+
+# TSProse
+
+Write and structure prose content using TypeScript TSX with strong typing.
+
+- Write prose using **TSX** syntax
+- Define **your own** element schemas and tags
+- Link any elements with **"uniques"** system (e.g. for cross-referencing)
+- Convert raw TSX output into a stable, linkable prose tree
+- **Storage** system for attaching async/heavy/reusable data to elements
+
+TSProse is a **parser + structurer**: you write content in TSX, TSProse turns it into a typed element tree. Rendering, styling, and analysis are up to you.
+
+## Installation
+
+```bash
+npm install tsprose
+```
+
+Configure your `tsconfig.json` to use TSProse as the JSX runtime:
+
+```jsonc
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "jsxImportSource": "tsprose",
+  },
+}
+```
+
+## Core idea
+
+The idea is simple — you define schemas and tags, use tags to write raw prose in TSX, convert raw prose to prose with stable IDs and collected uniques, then do whatever you want with the prose tree (render, analyze, serialize, etc):
+
+1. **Schema** — Describes an element’s shape and rules (block vs inliner, linkable or not, typed data/children).
+2. **Tag (TSX)** — The callable you use in TSX files; it creates/configures **raw elements** according to the schema.
+3. **RawElement** — The initial, unprocessed elements produced by evaluating your TSX.
+4. **ProseElement** (via **`rawToProse`** function) — raw elements are transformed into prose elements via `rawToProse()` which assigns stable IDs to linkable elements and collects uniques.
+5. (optional) **Storage** — Attach async/heavy/reusable data to elements (e.g. computed metadata) when needed.
+6. **Use the prose tree** — Render, analyze, serialize, etc.
+
+## Get started (minimal example)
+
+This example defines two elements:
+
+- `paragraph` (block, linkable, optional data)
+- `bold` (inliner, non-linkable)
+
+```ts
+import {
+  defineSchema,
+  defineTag,
+  defineDocument,
+  rawToProse,
+  ensureTagInlinerChildren,
+  ensureTagChildren,
+  type BlockSchema,
+  type InlinerSchema,
+  type TextSchema,
+} from 'tsprose';
+
+//
+// 1. Schemas
+//
+
+interface ParagraphSchema extends BlockSchema {
+  name: 'paragraph';
+  type: 'block';
+  linkable: true;
+  Data: { center?: boolean } | undefined;
+  Storage: undefined;
+  Children: InlinerSchema[];
+}
+
+const paragraphSchema = defineSchema<ParagraphSchema>({
+  name: 'paragraph',
+  type: 'block',
+  linkable: true,
+});
+
+interface BoldSchema extends InlinerSchema {
+  name: 'bold';
+  type: 'inliner';
+  linkable: false;
+  Data: undefined;
+  Storage: undefined;
+  Children: TextSchema[];
+}
+
+const boldSchema = defineSchema<BoldSchema>({
+  name: 'bold',
+  type: 'inliner',
+  linkable: false,
+});
+
+//
+// 2. Tags
+//
+
+const P = defineTag({ tagName: 'P', schema: paragraphSchema })<{ center?: true }>(
+  ({ tagName, props, children, element }) => {
+    ensureTagInlinerChildren(tagName, children);
+    element.children = children;
+
+    if (props.center) {
+      element.data = { center: true };
+    }
+  },
+);
+
+const B = defineTag({ tagName: 'B', schema: boldSchema })(({ tagName, children, element }) => {
+  // `text` is built-in; strings become text elements automatically.
+  ensureTagInlinerChildren(tagName, children);
+  element.children = children;
+});
+
+//
+// 3. Document (TSX)
+//
+
+const document = defineDocument('my-document-id', {
+  uniques: { intro: P },
+})(({ uniques }) => (
+  <>
+    <P $={uniques.intro} center>
+      Hello <B>world</B>
+    </P>
+  </>
+));
+
+//
+// 4. Convert to prose (stable IDs + collected uniques)
+//
+
+const { prose, uniques } = await rawToProse({ rawProse: document.rawProse });
+
+console.log(prose.schema.name); // "mix" (fragment)
+console.log(uniques.intro.id); // "intro"
+```
+
+## Next steps
+
+- Walk the tree (`walkPre*` / `walkPost*`) to render/analyze
+- Serialize (`toJSON` / `fromJSON`) if you need persistence
+- Attach async data via storage (`fillProseStorage`) when you need it
+
+## License
+
+[MIT](./LICENSE)

package/dist/children.d.ts

@@ -0,0 +1,3 @@
+import type { RawElement } from './element.js';
+export type NormalizedChildren = RawElement[] | undefined;
+export declare function normalizeChildren(children: any, childStep?: (child: RawElement) => void): NormalizedChildren;

package/dist/children.js

@@ -0,0 +1,86 @@
+import { mixSchema } from './default/mix.js';
+import { textSchema } from './default/text.js';
+import { isRawElement, makeRawElement } from './elementUtils.js';
+import { isUnique } from './unique.js';
+import { hash } from './utils/hash.js';
+export function normalizeChildren(children, childStep) {
+    if (children === undefined) {
+        return undefined;
+    }
+    const childrenArray = Array.isArray(children) ? children : [children];
+    if (childrenArray.length === 0) {
+        return undefined;
+    }
+    const normalizedChildren = [];
+    for (const child of childrenArray) {
+        //
+        // <Mix>
+        //
+        if (isRawElement(child, mixSchema)) {
+            const subNormalized = normalizeChildren(child.children, childStep);
+            if (subNormalized) {
+                normalizedChildren.push(...subNormalized);
+            }
+            continue;
+        }
+        //
+        // Raw Element
+        //
+        if (isRawElement(child)) {
+            const clone = structuredClone(child);
+            childStep?.(clone);
+            normalizedChildren.push(clone);
+            continue;
+        }
+        //
+        // Unique
+        //
+        if (isUnique(child)) {
+            const clone = structuredClone(child.rawElement);
+            clone.slug = clone.uniqueName;
+            delete clone.uniqueName;
+            childStep?.(clone);
+            normalizedChildren.push(clone);
+            continue;
+        }
+        //
+        // Array
+        //
+        if (Array.isArray(child)) {
+            const subNormalized = normalizeChildren(child, childStep);
+            if (subNormalized) {
+                normalizedChildren.push(...subNormalized);
+            }
+            continue;
+        }
+        //
+        // Skip falsy values (null, false, empty string, etc.) but not 0
+        //
+        if (child === undefined ||
+            child === null ||
+            child === false ||
+            child === '') {
+            continue;
+        }
+        //
+        // Something else. Just stringify and maybe merge with previous text node if possible.
+        //
+        const strChild = String(child);
+        const textRawElement = makeRawElement({
+            schema: textSchema,
+            elementHandler: (element) => {
+                element.data = strChild;
+            },
+        });
+        childStep?.(textRawElement);
+        const lastNormalized = normalizedChildren.at(-1);
+        if (isRawElement(lastNormalized, textSchema)) {
+            lastNormalized.data += strChild;
+            lastNormalized.hash = hash(lastNormalized.data, 12);
+        }
+        else {
+            normalizedChildren.push(textRawElement);
+        }
+    }
+    return normalizedChildren;
+}

package/dist/default/mix.d.ts

@@ -0,0 +1,10 @@
+import { type Schema } from '../schema.js';
+export interface MixSchema extends Schema {
+    name: 'mix';
+    type: 'block';
+    linkable: false;
+    Data: undefined;
+    Storage: undefined;
+    Children: Schema[];
+}
+export declare const mixSchema: MixSchema;

package/dist/default/mix.js

@@ -0,0 +1,6 @@
+import { defineSchema } from '../schema.js';
+export const mixSchema = defineSchema({
+    name: 'mix',
+    type: 'block',
+    linkable: false,
+});

package/dist/default/text.d.ts

@@ -0,0 +1,10 @@
+import { type Schema } from '../schema.js';
+export interface TextSchema extends Schema {
+    name: 'text';
+    type: 'inliner';
+    linkable: false;
+    Data: string;
+    Storage: undefined;
+    Children: undefined;
+}
+export declare const textSchema: TextSchema;

package/dist/default/text.js

@@ -0,0 +1,6 @@
+import { defineSchema } from '../schema.js';
+export const textSchema = defineSchema({
+    name: 'text',
+    type: 'inliner',
+    linkable: false,
+});

package/dist/document.d.ts

@@ -0,0 +1,28 @@
+import type { RawElement } from './element.js';
+import type { LinkableTag } from './tag.js';
+import { type AutoUnique, type ToUnique } from './unique.js';
+export declare const DOCUMENT_PREFIX = "__TSPROSE_document";
+export declare const DOCUMENT_AUTO_ID = "__TSPROSE_documentAutoId";
+export interface Document<UniquesTemplate extends DocumentUniquesTemplate = DocumentUniquesTemplate> {
+    [DOCUMENT_PREFIX]: true;
+    documentId: string;
+    uniques: DocumentUniques<UniquesTemplate>;
+    rawProse: RawElement;
+}
+export type DocumentUniquesTemplate<Template extends Record<string, LinkableTag> = Record<string, LinkableTag>> = Template;
+export type DocumentUniques<UniquesTemplate extends DocumentUniquesTemplate = DocumentUniquesTemplate> = {
+    [UniqueName in keyof UniquesTemplate]: ToUnique<UniquesTemplate[UniqueName]>;
+};
+export type DocumentContentCreator<UniquesTemplate extends DocumentUniquesTemplate = DocumentUniquesTemplate> = (context: {
+    uniques: DocumentUniques<UniquesTemplate>;
+    autoUnique: () => AutoUnique;
+}) => RawElement;
+export type DocumentFinalizer<UniquesTemplate extends DocumentUniquesTemplate = DocumentUniquesTemplate> = (contentCreator: DocumentContentCreator<UniquesTemplate>) => Document<UniquesTemplate>;
+export declare function defineDocument(): DocumentFinalizer<{}>;
+export declare function defineDocument<UniquesTemplate extends DocumentUniquesTemplate>(documentParameters: {
+    uniques: UniquesTemplate;
+}): DocumentFinalizer<UniquesTemplate>;
+export declare function defineDocument<UniquesTemplate extends DocumentUniquesTemplate>(documentId: string, documentParameters: {
+    uniques: UniquesTemplate;
+}): DocumentFinalizer<UniquesTemplate>;
+export declare function injectDocumentId(documentId: string, injectTo: string, defineDocumentAlias?: string): string;

package/dist/document.js

@@ -0,0 +1,61 @@
+import { TSProseError } from './error.js';
+import { defineAutoUnique, defineUnique, } from './unique.js';
+export const DOCUMENT_PREFIX = '__TSPROSE_document';
+export const DOCUMENT_AUTO_ID = '__TSPROSE_documentAutoId';
+export function defineDocument(arg1, arg2) {
+    const documentId = typeof arg1 === 'string' ? arg1 : DOCUMENT_AUTO_ID;
+    const uniquesTemplate = typeof arg1 === 'object' && 'uniques' in arg1
+        ? arg1.uniques
+        : arg2 && 'uniques' in arg2
+            ? arg2.uniques
+            : {};
+    const uniques = Object.fromEntries(Object.entries(uniquesTemplate).map(([key, value]) => [
+        key,
+        defineUnique({
+            documentId,
+            name: key,
+            tag: value,
+        }),
+    ]));
+    let autoUniquesCounter = 1;
+    const autoUnique = () => defineAutoUnique({
+        documentId,
+        name: `auto-unique-${autoUniquesCounter++}`,
+    });
+    function finalizeDocument(contentCreator) {
+        const rawProse = contentCreator({ uniques, autoUnique });
+        for (const unique of Object.values(uniques)) {
+            try {
+                unique.rawElement;
+            }
+            catch {
+                throw new TSProseError(`Unique "${unique.name}" for <${unique.tag.tagName}> was not used in the document content!\nAll uniques defined in the document must be used in the content creator function!`);
+            }
+        }
+        return {
+            [DOCUMENT_PREFIX]: true,
+            documentId,
+            uniques,
+            rawProse,
+        };
+    }
+    return finalizeDocument;
+}
+//
+// injectDocumentId
+//
+export function injectDocumentId(documentId, injectTo, defineDocumentAlias) {
+    const funcName = defineDocumentAlias ?? 'defineDocument';
+    const escapedFuncName = funcName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedId = documentId.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    const regex = new RegExp(`\\b${escapedFuncName}\\((\\s*)(?!['"\`])`, 'g');
+    return injectTo.replace(regex, (match, whitespace, offset) => {
+        const afterChar = injectTo[offset + match.length];
+        if (afterChar === ')' || afterChar === undefined) {
+            // defineDocument() → defineDocument('id')
+            return `${funcName}(${whitespace}'${escapedId}'`;
+        }
+        // defineDocument({ → defineDocument('id', {
+        return `${funcName}('${escapedId}',${whitespace}`;
+    });
+}

package/dist/element.d.ts

@@ -0,0 +1,33 @@
+import type { BlockSchema, InlinerSchema, LinkableSchema, Schema } from './schema.js';
+export declare const RAW_ELEMENT_PREFIX = "__TSPROSE_rawElement";
+export type ToRawElement<TSchema extends Schema, TagName extends string = string> = TSchema extends Schema ? {
+    [RAW_ELEMENT_PREFIX]: true;
+    schema: TSchema;
+    hash: string;
+    tagName?: TagName;
+    slug?: string;
+    uniqueName?: string;
+    data: TSchema['Data'];
+    storageKey: TSchema['Storage'] extends undefined ? undefined : string;
+    children: ToRawElementChildren<TSchema['Children']>;
+} : never;
+type ToRawElementChildren<TChildren> = TChildren extends (infer E extends Schema)[] ? ToRawElement<E>[] : TChildren extends undefined ? undefined : never;
+export type RawElement = ToRawElement<Schema>;
+export type BlockRawElement = ToRawElement<BlockSchema>;
+export type InlinerRawElement = ToRawElement<InlinerSchema>;
+export type LinkableRawElement = ToRawElement<LinkableSchema>;
+export declare const PROSE_ELEMENT_PREFIX = "__TSPROSE_proseElement";
+export type ToProseElement<TSchema extends Schema> = {
+    [PROSE_ELEMENT_PREFIX]: true;
+    schema: TSchema;
+    id: TSchema['linkable'] extends false ? undefined : string;
+    data: TSchema['Data'];
+    storageKey: TSchema['Storage'] extends undefined ? undefined : string;
+    children: ToProseElementChildren<TSchema['Children']>;
+};
+type ToProseElementChildren<TChildren> = TChildren extends (infer E extends Schema)[] ? ToProseElement<E>[] : TChildren extends undefined ? undefined : never;
+export type ProseElement = ToProseElement<Schema>;
+export type BlockProseElement = ToProseElement<BlockSchema>;
+export type InlinerProseElement = ToProseElement<InlinerSchema>;
+export type LinkableProseElement = ToProseElement<LinkableSchema>;
+export {};

package/dist/element.js

@@ -0,0 +1,8 @@
+//
+// Raw Element
+//
+export const RAW_ELEMENT_PREFIX = '__TSPROSE_rawElement';
+//
+// Prose Element
+//
+export const PROSE_ELEMENT_PREFIX = '__TSPROSE_proseElement';

package/dist/elementUtils.d.ts

@@ -0,0 +1,33 @@
+import { type BlockProseElement, type BlockRawElement, type InlinerProseElement, type InlinerRawElement, type ToProseElement, type ToRawElement } from './element.js';
+import type { Schema } from './schema.js';
+export declare function makeRawElement<TSchema extends Schema, ElementHandler extends (element: ToRawElement<TSchema, TagName>) => void, TagName extends string>(parameters: {
+    schema: TSchema;
+    tagName?: TagName;
+    elementHandler?: ElementHandler;
+}): ToRawElement<TSchema, TagName>;
+export declare function makeProseElement<TSchema extends Schema, ElementHandler extends (element: ToProseElement<TSchema>) => void>(parameters: {
+    schema: TSchema;
+    elementHandler?: ElementHandler;
+}): ToProseElement<TSchema>;
+export declare function isRawElement<TSchema extends Schema>(element: any, schema?: TSchema): element is ToRawElement<TSchema>;
+export declare function isProseElement<TSchema extends Schema>(element: any, schema?: TSchema): element is ToProseElement<TSchema>;
+export declare function ensureRawElement<TSchema extends Schema>(element: any, schema?: TSchema): asserts element is ToRawElement<TSchema>;
+export declare function ensureProseElement<TSchema extends Schema>(element: any, schema?: TSchema): asserts element is ToProseElement<TSchema>;
+export declare function isRawBlock(element: any): element is BlockRawElement;
+export declare function isRawInliner(element: any): element is InlinerRawElement;
+export declare function isProseBlock(element: any): element is BlockProseElement;
+export declare function isProseInliner(element: any): element is InlinerProseElement;
+export declare function ensureRawBlock(element: any): asserts element is BlockRawElement;
+export declare function ensureRawInliner(element: any): asserts element is InlinerRawElement;
+export declare function ensureProseBlock(element: any): asserts element is BlockProseElement;
+export declare function ensureProseInliner(element: any): asserts element is InlinerProseElement;
+export declare function hasChildren<T>(element: {
+    children?: T[];
+}): element is {
+    children: [T, ...T[]];
+};
+export declare function ensureChildren<T>(element: {
+    children?: T[];
+}): asserts element is {
+    children: [T, ...T[]];
+};

package/dist/elementUtils.js

@@ -0,0 +1,92 @@
+import { PROSE_ELEMENT_PREFIX, RAW_ELEMENT_PREFIX, } from './element.js';
+import { TSProseError } from './error.js';
+import { hash } from './utils/hash.js';
+export function makeRawElement(parameters) {
+    const element = {
+        [RAW_ELEMENT_PREFIX]: true,
+        schema: parameters.schema,
+        tagName: parameters.tagName,
+    };
+    parameters.elementHandler?.(element);
+    element.hash = hash(element.schema.name +
+        JSON.stringify(element.data) +
+        JSON.stringify(element.children?.map((child) => child.hash).join()), 12);
+    return element;
+}
+export function makeProseElement(parameters) {
+    const element = {
+        [PROSE_ELEMENT_PREFIX]: true,
+        schema: parameters.schema,
+    };
+    parameters.elementHandler?.(element);
+    return element;
+}
+export function isRawElement(element, schema) {
+    return isElement(RAW_ELEMENT_PREFIX, element, schema);
+}
+export function isProseElement(element, schema) {
+    return isElement(PROSE_ELEMENT_PREFIX, element, schema);
+}
+function isElement(prefix, element, schema) {
+    if (element?.[prefix] === true) {
+        if (schema) {
+            return schema.name === element?.schema?.name;
+        }
+        return true;
+    }
+    return false;
+}
+export function ensureRawElement(element, schema) {
+    ensureElement(RAW_ELEMENT_PREFIX, element, schema);
+}
+export function ensureProseElement(element, schema) {
+    ensureElement(PROSE_ELEMENT_PREFIX, element, schema);
+}
+function ensureElement(prefix, element, schema) {
+    if (!isElement(prefix, element, schema)) {
+        throw new TSProseError(`Not a ${prefix === RAW_ELEMENT_PREFIX ? 'RawElement' : 'ProseElement'}${schema ? ` with "${schema.name}" schema` : ''}!\nProvided:${JSON.stringify(element)}`);
+    }
+}
+export function isRawBlock(element) {
+    return isType('raw', 'block', element);
+}
+export function isRawInliner(element) {
+    return isType('raw', 'inliner', element);
+}
+export function isProseBlock(element) {
+    return isType('prose', 'block', element);
+}
+export function isProseInliner(element) {
+    return isType('prose', 'inliner', element);
+}
+function isType(elementType, type, element) {
+    if (elementType === 'raw' ? isRawElement(element) : isProseElement(element)) {
+        return element.schema.type === type;
+    }
+    return false;
+}
+export function ensureRawBlock(element) {
+    ensureType('raw', 'block', element);
+}
+export function ensureRawInliner(element) {
+    ensureType('raw', 'inliner', element);
+}
+export function ensureProseBlock(element) {
+    ensureType('prose', 'block', element);
+}
+export function ensureProseInliner(element) {
+    ensureType('prose', 'inliner', element);
+}
+function ensureType(elementType, type, element) {
+    if (!isType(elementType, type, element)) {
+        throw new TSProseError(`Not a ${elementType} ${type}!\nProvided:${JSON.stringify(element)}`);
+    }
+}
+export function hasChildren(element) {
+    return element.children !== undefined && element.children.length > 0;
+}
+export function ensureChildren(element) {
+    if (!hasChildren(element)) {
+        throw new TSProseError('Provided element has no children!');
+    }
+}

package/dist/error.d.ts

@@ -0,0 +1,3 @@
+export declare class TSProseError extends Error {
+    constructor(message: string);
+}

package/dist/error.js

@@ -0,0 +1,6 @@
+export class TSProseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TSProseError';
+    }
+}

package/dist/externals.d.ts

@@ -0,0 +1,57 @@
+//
+// Images
+//
+
+declare module '*.png' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.jpg' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.jpeg' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.gif' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.bmp' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.webp' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.svg' {
+  const src: string;
+  export default src;
+}
+
+//
+// Videos
+//
+
+declare module '*.mp4' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.webm' {
+  const src: string;
+  export default src;
+}
+
+declare module '*.ogg' {
+  const src: string;
+  export default src;
+}

package/dist/id.d.ts

@@ -0,0 +1,3 @@
+import type { RawElement } from './element.js';
+export type IdMaker = (rawElement: RawElement, takenIds?: Set<string>) => string;
+export declare const defaultIdMaker: IdMaker;

package/dist/id.js

@@ -0,0 +1,17 @@
+export const defaultIdMaker = (rawElement, takenIds) => {
+    takenIds ||= new Set();
+    let id = '';
+    const humanReadable = rawElement.uniqueName || rawElement.slug;
+    if (humanReadable) {
+        id = humanReadable;
+    }
+    else {
+        id = rawElement.schema.name + '-' + rawElement.hash.substring(0, 9);
+    }
+    let candidate = id;
+    let counter = 1;
+    while (takenIds.has(candidate)) {
+        candidate = `${id}-${counter++}`;
+    }
+    return candidate;
+};

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export * from './default/mix.js';
+export * from './default/text.js';
+export * from './utils/hash.js';
+export * from './children.js';
+export * from './document.js';
+export * from './element.js';
+export * from './elementUtils.js';
+export * from './error.js';
+export * from './id.js';
+export * from './json.js';
+export * from './rawToProse.js';
+export * from './schema.js';
+export * from './storage.js';
+export * from './tag.js';
+export * from './tagUtils.js';
+export * from './unique.js';
+export * from './walk.js';