@lucidkiln/core 1.0.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.2.0
+
+- Inserted content is no longer re-indented to line up with its tag. ([46e6cae](https://github.com/buildlucid/kiln/commit/46e6cae3afbbc88ded8a19dcd9018f8559d4e7ce))
+- `withRender` now keeps your function's type parameters, and `RenderAware` takes the whole function type. ([08f192c](https://github.com/buildlucid/kiln/commit/08f192cd0fcf7913039bd065d9ced29d5453a73a))
+
+## 1.1.0
+
+- New `KilnFunctions`, `KilnFilters`, `KilnTests` and `KilnGlobals` interfaces. Add your own to them so your editor can show their types. See [Types from TypeScript](https://kilnlang.com/docs/tooling/editors/#types-from-typescript). ([d55ef63](https://github.com/buildlucid/kiln/commit/d55ef63677df3b34ea247f3b9f25562b201a18b0))
+- `withRender` now keeps the types of your function's arguments and result. ([d55ef63](https://github.com/buildlucid/kiln/commit/d55ef63677df3b34ea247f3b9f25562b201a18b0))
+- Cache tags. A function wrapped in `withRender` can call `render.tagCache("collection:pages")` to tag the `cache` section it runs in. The store's `set` now receives the section's `tags`, so it can clear copies when that data changes. See [Tags](https://kilnlang.com/docs/tags/cache/#tags). ([6a9b26f](https://github.com/buildlucid/kiln/commit/6a9b26f4d8beadc6d04f358e617a11b237a1487e))
+- `memoryCache` has a `clear` method, which removes every copy, or those with any of the tags you pass. ([6a9b26f](https://github.com/buildlucid/kiln/commit/6a9b26f4d8beadc6d04f358e617a11b237a1487e))
+- Copies saved by an earlier version of Kiln are treated as missing, so each section renders once more and is saved again. ([6a9b26f](https://github.com/buildlucid/kiln/commit/6a9b26f4d8beadc6d04f358e617a11b237a1487e))
+- New `@lucidkiln/core/syntax` entry point with Kiln's parser, for editor tools. Its shapes can change in any minor release. ([d55ef63](https://github.com/buildlucid/kiln/commit/d55ef63677df3b34ea247f3b9f25562b201a18b0))
+
 ## 1.0.0
 
 - The first stable release. Read the [documentation](https://kilnlang.com/docs/) to get started.

package/dist/ast-DDhHuwaY.d.ts

@@ -0,0 +1,350 @@
+//#region src/source.d.ts
+/** A range of a template's source, as zero-based offsets. `end` is exclusive. */
+type Span = {
+  start: number;
+  end: number;
+};
+type Position = {
+  /** Zero-based offset into the source. */
+  offset: number;
+  /** One-based. */
+  line: number;
+  /** One-based, counted in UTF-16 code units. */
+  column: number;
+};
+/**
+ * A template's text and resolved name.
+ *
+ * The line index is built on first use, because only errors and tooling need lines and columns. A byte order mark at the
+ * start is not counted in columns or shown in frames, as editors hide it, but offsets still count it.
+ */
+declare class Source {
+  #private;
+  readonly name: string;
+  readonly text: string;
+  constructor(name: string, text: string);
+  /** Converts an offset into a line and column. */
+  position(offset: number): Position;
+  /**
+   * Renders a few lines around a span, with a marker under it.
+   *
+   * ```text
+   *   3 | {% block content %}
+   * > 4 |   <h1>{{ titel }}</h1>
+   *     |          ^^^^^
+   * ```
+   */
+  frame(span: Span, context?: number): string;
+}
+//#endregion
+//#region src/parser/ast.d.ts
+type EscapeStrategy = "html" | "attr" | "js" | "css" | "url";
+type BinaryOperator = "or" | "and" | "??" | "?:" | "==" | "!=" | "<" | ">" | "<=" | ">=" | "in" | "not in" | "starts with" | "ends with" | ".." | "~" | "+" | "-" | "*" | "/" | "//" | "%" | "**";
+type Spread = {
+  type: "Spread";
+  value: Expression;
+  span: Span;
+};
+type Argument = {
+  type: "Positional";
+  value: Expression;
+  span: Span;
+} | {
+  type: "Named";
+  name: string;
+  value: Expression;
+  span: Span;
+} | Spread;
+type HashEntry = {
+  type: "Property";
+  key: Expression;
+  value: Expression;
+  span: Span;
+} | Spread;
+type Expression = {
+  type: "Literal";
+  value: null | boolean | number | string;
+  span: Span;
+} | {
+  type: "Name";
+  name: string;
+  span: Span;
+} |
+/** A double-quoted string with `#{}` interpolation. */
+{
+  type: "Interpolation";
+  parts: Expression[];
+  span: Span;
+} | {
+  type: "Array";
+  elements: (Expression | Spread)[];
+  span: Span;
+} | {
+  type: "Hash";
+  entries: HashEntry[];
+  span: Span;
+} | {
+  type: "Unary";
+  operator: "-" | "+" | "not";
+  operand: Expression;
+  span: Span;
+} | {
+  type: "Binary";
+  operator: BinaryOperator;
+  left: Expression;
+  right: Expression;
+  span: Span;
+} | {
+  type: "Conditional";
+  test: Expression;
+  consequent: Expression;
+  alternate: Expression | null;
+  span: Span;
+} | {
+  type: "Member";
+  object: Expression;
+  property: Expression;
+  /** True for `a?.b` and `a?.[b]`. */
+  optional: boolean;
+  span: Span;
+} | {
+  type: "Call";
+  callee: Expression;
+  args: Argument[];
+  span: Span;
+} | {
+  type: "Filter";
+  name: string;
+  nameSpan: Span;
+  input: Expression;
+  args: Argument[];
+  span: Span;
+} | {
+  type: "Test";
+  name: string;
+  nameSpan: Span;
+  input: Expression;
+  args: Argument[];
+  negated: boolean;
+  span: Span;
+} | {
+  type: "Arrow";
+  params: string[];
+  body: Expression;
+  span: Span;
+} |
+/** Wraps a member and call chain that contains `?.`, so null short-circuits the whole chain. */
+{
+  type: "OptionalChain";
+  expression: Expression;
+  span: Span;
+} |
+/** Stands in for an expression that failed to parse. */
+{
+  type: "Invalid";
+  span: Span;
+};
+type Param = {
+  name: string;
+  default: Expression | null;
+  span: Span;
+};
+/** Type names a prop can declare. See `TYPE_NAMES`. */
+type TypeName = (typeof TYPE_NAMES)[number];
+/**
+ * One member of a prop's type. A full type is a list of members, read as a union.
+ *
+ * - A built-in type name, such as `string`.
+ * - `{ literal }`: one exact string or number, such as `"primary"`.
+ * - `{ list }`: `T[]`, an array of the inner type.
+ * - `{ shape }`: `{ name: string }`, a hash or object with these keys.
+ * - `{ named }`: a type the host registers, such as `Post`.
+ */
+type PropType = TypeName | {
+  literal: string | number;
+} | {
+  list: PropType[];
+} | {
+  shape: ShapeKey[];
+} | {
+  named: string;
+};
+/** One key of a shape type, such as `url?: string`. */
+type ShapeKey = {
+  name: string;
+  optional: boolean;
+  type: PropType[];
+};
+/** A `props` entry. `type` is null when the prop is untyped. */
+type PropParam = Param & {
+  type: PropType[] | null;
+};
+type FilterCall = {
+  name: string;
+  args: Argument[];
+  span: Span;
+};
+type Statement = {
+  type: "Text";
+  value: string;
+  span: Span;
+} | {
+  type: "Output";
+  expression: Expression;
+  span: Span;
+} | {
+  type: "If";
+  branches: {
+    test: Expression;
+    body: Statement[];
+  }[];
+  alternate: Statement[] | null;
+  span: Span;
+} | {
+  type: "For";
+  keyName: string | null;
+  valueName: string;
+  iterable: Expression;
+  body: Statement[];
+  alternate: Statement[] | null;
+  span: Span;
+} | {
+  type: "Set";
+  name: string;
+  value: Expression;
+  span: Span;
+} | {
+  type: "SetBlock";
+  name: string;
+  body: Statement[];
+  span: Span;
+} |
+/** `rest` names the hash that collects undeclared variables, as in `...attributes`, or is null. */
+{
+  type: "Props";
+  props: PropParam[];
+  rest: string | null;
+  span: Span;
+} | {
+  type: "Extends";
+  template: Expression;
+  span: Span;
+} | {
+  type: "Block";
+  name: string;
+  body: Statement[];
+  span: Span;
+} | {
+  type: "Include";
+  template: Expression;
+  with: Expression | null;
+  ignoreMissing: boolean;
+  span: Span;
+} | {
+  type: "Component";
+  template: Expression;
+  with: Expression | null;
+  fills: {
+    name: string;
+    body: Statement[];
+    span: Span;
+  }[];
+  /** Content outside any `fill`, which fills the default slot. */
+  body: Statement[];
+  span: Span;
+} | {
+  type: "Slot";
+  name: string;
+  body: Statement[];
+  span: Span;
+} |
+/**
+ * A component that can load after the page. `body` is the fallback, shown until a deferred island loads. A deferred
+ * island writes its tags back as `<kiln-island>` lines where they stand on lines of their own. `indent` is set when
+ * the `island` tag does: its line's indentation. `closing` is set when `endisland` does: its indentation, or null
+ * when it shares that line with the `island` tag, and whether a line break followed it.
+ */
+{
+  type: "Island";
+  template: Expression;
+  with: Expression | null;
+  body: Statement[];
+  indent?: string;
+  closing?: {
+    indent: string | null;
+    newline: boolean;
+  };
+  span: Span;
+} | {
+  type: "Macro";
+  name: string;
+  params: Param[];
+  body: Statement[];
+  span: Span;
+} | {
+  type: "Import";
+  template: string;
+  alias: string;
+  span: Span;
+} | {
+  type: "FromImport";
+  template: string;
+  names: {
+    name: string;
+    alias: string;
+    span: Span;
+  }[];
+  span: Span;
+} | {
+  type: "With";
+  value: Expression;
+  body: Statement[];
+  span: Span;
+} |
+/** A place other templates add content to with `add to`, filled when the render ends. */
+{
+  type: "Outlet";
+  name: string;
+  span: Span;
+} |
+/** Closes the outlets reached so far, so a streamed render can send its output up to here. */
+{
+  type: "Flush";
+  span: Span;
+} |
+/** Content for the outlet named `outlet`. `once` adds it only the first time the tag runs in a render. */
+{
+  type: "Add";
+  outlet: string;
+  once: boolean;
+  body: Statement[];
+  span: Span;
+} |
+/** `seconds` is the `for` value, or null. */
+{
+  type: "Cache";
+  key: Expression;
+  seconds: Expression | null;
+  body: Statement[];
+  span: Span;
+} | {
+  type: "Apply";
+  filters: FilterCall[];
+  body: Statement[];
+  span: Span;
+} | {
+  type: "Autoescape";
+  strategy: EscapeStrategy | false;
+  body: Statement[];
+  span: Span;
+};
+type TemplateNode = {
+  type: "Template";
+  body: Statement[];
+  span: Span;
+};
+/** The value types a prop can declare, named as in the docs' table of types. */
+declare const TYPE_NAMES: readonly ["null", "boolean", "number", "string", "array", "hash", "set", "date", "markup", "object"];
+//#endregion
+export { HashEntry as a, PropType as c, Statement as d, TemplateNode as f, Span as g, Source as h, Expression as i, ShapeKey as l, Position as m, BinaryOperator as n, Param as o, TypeName as p, EscapeStrategy as r, PropParam as s, Argument as t, Spread as u };
+//# sourceMappingURL=ast-DDhHuwaY.d.ts.map

package/dist/ast-DDhHuwaY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-DDhHuwaY.d.ts","names":[],"sources":["../src/source.ts","../src/parser/ast.ts"],"mappings":";;KAGY;EAAS;EAAe;;KAExB;;EAEX;;EAEA;;EAEA;;;;;;;;cASY;;WAIF;WACA;EAFV,YACU,cACA;;EAIV,SAAS,iBAAiB;;;;;;;;;;EA0B1B,MAAM,MAAM,MAAM;;;;KCrDP;KAEA;KAyBA;EAAW;EAAgB,OAAO;EAAY,MAAM;;KAEpD;EACP;EAAoB,OAAO;EAAY,MAAM;;EAC7C;EAAe;EAAc,OAAO;EAAY,MAAM;IACxD;KAES;EACP;EAAkB,KAAK;EAAY,OAAO;EAAY,MAAM;IAC9D;KAES;EAET;EACA;EACA,MAAM;;EAEJ;EAAc;EAAc,MAAM;;;;EAElC;EAAuB,OAAO;EAAc,MAAM;;EAClD;EAAe,WAAW,aAAa;EAAW,MAAM;;EACxD;EAAc,SAAS;EAAa,MAAM;;EAE5C;EACA;EACA,SAAS;EACT,MAAM;;EAGN;EACA,UAAU;EACV,MAAM;EACN,OAAO;EACP,MAAM;;EAGN;EACA,MAAM;EACN,YAAY;EACZ,WAAW;EACX,MAAM;;EAGN;EACA,QAAQ;EACR,UAAU;;EAEV;EACA,MAAM;;EAEJ;EAAc,QAAQ;EAAY,MAAM;EAAY,MAAM;;EAE5D;EACA;EACA,UAAU;EACV,OAAO;EACP,MAAM;EACN,MAAM;;EAGN;EACA;EACA,UAAU;EACV,OAAO;EACP,MAAM;EACN;EACA,MAAM;;EAEJ;EAAe;EAAkB,MAAM;EAAY,MAAM;;;;EAEzD;EAAuB,YAAY;EAAY,MAAM;;;;EAErD;EAAiB,MAAM;;KAEhB;EAAU;EAAc,SAAS;EAAmB,MAAM;;;KAG1D,mBAAmB;;;;;;;;;;KAWnB,WACT;EACE;;EACA,MAAM;;EACN,OAAO;;EACP;;;KAGO;EAAa;EAAc;EAAmB,MAAM;;;KAGpD,YAAY;EAAU,MAAM;;KAE5B;EACX;EACA,MAAM;EACN,MAAM;;KAGK;EACP;EAAc;EAAe,MAAM;;EACnC;EAAgB,YAAY;EAAY,MAAM;;EAEhD;EACA;IAAY,MAAM;IAAY,MAAM;;EACpC,WAAW;EACX,MAAM;;EAGN;EACA;EACA;EACA,UAAU;EACV,MAAM;EACN,WAAW;EACX,MAAM;;EAEJ;EAAa;EAAc,OAAO;EAAY,MAAM;;EACpD;EAAkB;EAAc,MAAM;EAAa,MAAM;;;;EAEzD;EAAe,OAAO;EAAa;EAAqB,MAAM;;EAC9D;EAAiB,UAAU;EAAY,MAAM;;EAC7C;EAAe;EAAc,MAAM;EAAa,MAAM;;EAExD;EACA,UAAU;EACV,MAAM;EACN;EACA,MAAM;;EAGN;EACA,UAAU;EACV,MAAM;EACN;IAAS;IAAc,MAAM;IAAa,MAAM;;;EAEhD,MAAM;EACN,MAAM;;EAEJ;EAAc;EAAc,MAAM;EAAa,MAAM;;;;;;;;;EAQvD;EACA,UAAU;EACV,MAAM;EACN,MAAM;EACN;EACA;IAAY;IAAuB;;EACnC,MAAM;;EAGN;EACA;EACA,QAAQ;EACR,MAAM;EACN,MAAM;;EAEJ;EAAgB;EAAkB;EAAe,MAAM;;EAEzD;EACA;EACA;IAAS;IAAc;IAAe,MAAM;;EAC5C,MAAM;;EAEJ;EAAc,OAAO;EAAY,MAAM;EAAa,MAAM;;;;EAE1D;EAAgB;EAAc,MAAM;;;;EAEpC;EAAe,MAAM;;;;EAGvB;EACA;EACA;EACA,MAAM;EACN,MAAM;;;;EAIN;EACA,KAAK;EACL,SAAS;EACT,MAAM;EACN,MAAM;;EAEJ;EAAe,SAAS;EAAc,MAAM;EAAa,MAAM;;EAEjE;EACA,UAAU;EACV,MAAM;EACN,MAAM;;KAGG;EAAiB;EAAkB,MAAM;EAAa,MAAM;;;cAgB3D"}

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { mn as KilnSyntaxError } from "./source-BQxJGo5Y.js";
-import { n as format, t as KilnFormatError } from "./format-CJoqhehX.js";
+import { an as KilnSyntaxError } from "./source-BbikGqIb.js";
+import { n as format, t as KilnFormatError } from "./format-Di6-GUtH.js";
 import { readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
 import process from "node:process";

package/dist/{environment-BlQ8V4tX.d.ts → environment-DBvRrOn0.d.ts}

@@ -1,42 +1,4 @@
-//#region src/source.d.ts
-/** A range of a template's source, as zero-based offsets. `end` is exclusive. */
-type Span = {
-  start: number;
-  end: number;
-};
-type Position = {
-  /** Zero-based offset into the source. */
-  offset: number;
-  /** One-based. */
-  line: number;
-  /** One-based, counted in UTF-16 code units. */
-  column: number;
-};
-/**
- * A template's text and resolved name.
- *
- * The line index is built on first use, because only errors and tooling need lines and columns. A byte order mark at the
- * start is not counted in columns or shown in frames, as editors hide it, but offsets still count it.
- */
-declare class Source {
-  #private;
-  readonly name: string;
-  readonly text: string;
-  constructor(name: string, text: string);
-  /** Converts an offset into a line and column. */
-  position(offset: number): Position;
-  /**
-   * Renders a few lines around a span, with a marker under it.
-   *
-   * ```text
-   *   3 | {% block content %}
-   * > 4 |   <h1>{{ titel }}</h1>
-   *     |          ^^^^^
-   * ```
-   */
-  frame(span: Span, context?: number): string;
-}
-//#endregion
+import { c as PropType, g as Span, h as Source, m as Position, r as EscapeStrategy } from "./ast-DDhHuwaY.js";
 //#region src/errors.d.ts
 type Diagnostic = {
   /** A stable kebab-case code, such as `unknown-filter`. */
@@ -86,37 +48,6 @@ declare class KilnRenderError extends Error {
   get detail(): string;
 }
 //#endregion
-//#region src/parser/ast.d.ts
-type EscapeStrategy = "html" | "attr" | "js" | "css" | "url";
-/** Type names a prop can declare. See `TYPE_NAMES`. */
-type TypeName = (typeof TYPE_NAMES)[number];
-/**
- * One member of a prop's type. A full type is a list of members, read as a union.
- *
- * - A built-in type name, such as `string`.
- * - `{ literal }`: one exact string or number, such as `"primary"`.
- * - `{ list }`: `T[]`, an array of the inner type.
- * - `{ shape }`: `{ name: string }`, a hash or object with these keys.
- * - `{ named }`: a type the host registers, such as `Post`.
- */
-type PropType = TypeName | {
-  literal: string | number;
-} | {
-  list: PropType[];
-} | {
-  shape: ShapeKey[];
-} | {
-  named: string;
-};
-/** One key of a shape type, such as `url?: string`. */
-type ShapeKey = {
-  name: string;
-  optional: boolean;
-  type: PropType[];
-};
-/** The value types a prop can declare, named as in the docs' table of types. */
-declare const TYPE_NAMES: readonly ["null", "boolean", "number", "string", "array", "hash", "set", "date", "markup", "object"];
-//#endregion
 //#region src/runtime/islands.d.ts
 /** A value that survives JSON unchanged, which is what island props must be. */
 type JsonValue = null | boolean | number | string | JsonValue[] | {
@@ -206,12 +137,14 @@ type KilnCache = {
   }): string | null | undefined | Promise<string | null | undefined>;
   /**
    * Saves `value` under `key`. The value is Kiln's own string, holding the HTML and what the section added to outlets,
-   * to save as it is. `seconds` is the tag's `for` value, or null to let the store decide.
+   * to save as it is. `seconds` is the tag's `for` value, or null to let the store decide. `tags` are the section's
+   * tags from `RenderInfo.tagCache`, sorted, for a store that clears copies by tag.
    */
   set(entry: {
     key: string;
     value: string;
     seconds: number | null;
+    tags: string[];
   }): void | Promise<void>;
 };
 type RenderInfo<State = unknown> = {
@@ -221,6 +154,11 @@ type RenderInfo<State = unknown> = {
   /** Resolved name of the template making the call. */
   template: string;
   signal: AbortSignalLike | undefined;
+  /**
+   * Tags the cached section the call runs in, and every cached section around it, so a store can clear its copies
+   * when that data changes. Does nothing outside a cached section.
+   */
+  tagCache(...tags: string[]): void;
 };
 //#endregion
 //#region src/analyzer.d.ts
@@ -301,6 +239,24 @@ type Loader = {
  * ```
  */
 interface KilnTypes {}
+/**
+ * TypeScript types for the functions a project registers, which editors read to show types and complete properties.
+ * Empty until the host adds to it. `createKiln` doesn't check it against what you register.
+ *
+ * ```ts
+ * type Functions = typeof functions;
+ * declare module "@lucidkiln/core" {
+ * 	interface KilnFunctions extends Functions {}
+ * }
+ * ```
+ */
+interface KilnFunctions {}
+/** Like `KilnFunctions`, for filters. A filter's first argument is the value before the `|`. */
+interface KilnFilters {}
+/** Like `KilnFunctions`, for tests. */
+interface KilnTests {}
+/** Like `KilnFunctions`, for globals. */
+interface KilnGlobals {}
 /**
  * Project-wide template defaults, keyed by name without `.kiln`. An explicit schema on `createKiln` replaces these.
  */
@@ -331,13 +287,23 @@ type TemplateBlock<Name extends string, Templates extends object = KilnTemplates
   blocks: infer Block;
 } ? Block : string;
 declare const renderAware: unique symbol;
-/** A host function that receives `RenderInfo` before its arguments. Create it with `withRender`. */
-type RenderAware<State> = {
+/**
+ * Any function that takes `RenderInfo` first. Written as a method so `render` can declare any state, while a `render`
+ * without a type gets `RenderInfo<unknown>`, or the environment's state inside `createKiln`.
+ */
+type RenderCall = {
+  call(render: RenderInfo<unknown>, ...args: never): unknown;
+}["call"];
+/**
+ * A host function that receives `RenderInfo` before its arguments. Create it with `withRender`. `Call` is the function's
+ * own type, type parameters included, so editors can show it and work out what each call returns.
+ */
+type RenderAware<Call extends RenderCall = RenderCall> = {
   readonly [renderAware]: true;
-  readonly call: (render: RenderInfo<State>, ...args: never) => unknown;
+  readonly call: Call;
 };
 /** A function, filter or test a host registers. Parameter types are the host's to declare. */
-type KilnCallable<State = undefined> = ((...args: never) => unknown) | RenderAware<State>;
+type KilnCallable<State = undefined> = ((...args: never) => unknown) | RenderAware<(render: RenderInfo<State>, ...args: never) => unknown>;
 type Limits = {
   /** Characters of output, counted as string length. */
   maxOutputLength: number;
@@ -424,7 +390,7 @@ type Kiln<State = undefined, Schema extends KilnSchema = DefaultSchema> = {
  * document: withRender((render, collection: string) => fetchDocument(collection, render.state.locale))
  * ```
  */
-declare const withRender: <State, Args extends unknown[], Result>(fn: (render: RenderInfo<State>, ...args: Args) => Result) => RenderAware<State>;
+declare const withRender: <Call extends RenderCall>(fn: Call) => RenderAware<Call>;
 /**
  * Creates a Kiln environment: the loader, functions, filters, tests, globals and options every render uses.
  *
@@ -445,7 +411,7 @@ declare const memoryLoader: (templates: Record<string, string | PrecompiledTempl
 };
 /**
  * A store for the `cache` tag that keeps output in memory, for a long-running server. Holds up to `max` copies, 1,000
- * by default, and drops the oldest first.
+ * by default, and drops the oldest first. `clear` removes every copy, or those with any of the tags passed.
  *
  * ```ts
  * const kiln = createKiln({ loader, cache: memoryCache() });
@@ -457,12 +423,17 @@ declare const memoryCache: ({ max }?: {
   get: ({ key }: {
     key: string;
   }) => string | null;
-  set: ({ key, value, seconds }: {
+  set: ({ key, value, seconds, tags }: {
     key: string;
     value: string;
     seconds: number | null;
+    tags: string[];
+  }) => void;
+  /** Removes every copy, or with `tags`, the copies that have any of them. */
+  clear: ({ tags }?: {
+    tags?: readonly string[];
   }) => void;
 };
 //#endregion
-export { IslandEntry as A, ShapeKey as B, AnalysedProp as C, KilnCache as D, AbortSignalLike as E, deferIslands as F, TemplateLocation as G, Diagnostic as H, islandScript as I, Position as K, streamIslands as L, IslandMode as M, JsonValue as N, RenderInfo as O, StreamedIslands as P, EscapeStrategy as R, PrecompiledTemplate as S, TemplateReference as T, KilnRenderError as U, TypeName as V, KilnSyntaxError as W, memoryLoader as _, KilnTemplates as a, HtmlCheckLevel as b, Loader as c, TemplateBlock as d, TemplateContext as f, memoryCache as g, createKiln as h, KilnSchema as i, IslandManifest as j, DeferredIslands as k, RenderAware as l, TypeChecks as m, KilnCallable as n, KilnTypes as o, TemplateName as p, KilnOptions as r, Limits as s, Kiln as t, RenderOptions as u, withRender as v, Analysis as w, HtmlChecks as x, HtmlCheck as y, PropType as z };
-//# sourceMappingURL=environment-BlQ8V4tX.d.ts.map
+export { AbortSignalLike as A, islandScript as B, HtmlCheck as C, AnalysedProp as D, PrecompiledTemplate as E, IslandManifest as F, TemplateLocation as G, Diagnostic as H, IslandMode as I, JsonValue as L, RenderInfo as M, DeferredIslands as N, Analysis as O, IslandEntry as P, StreamedIslands as R, withRender as S, HtmlChecks as T, KilnRenderError as U, streamIslands as V, KilnSyntaxError as W, TemplateName as _, KilnGlobals as a, memoryCache as b, KilnTemplates as c, Limits as d, Loader as f, TemplateContext as g, TemplateBlock as h, KilnFunctions as i, KilnCache as j, TemplateReference as k, KilnTests as l, RenderOptions as m, KilnCallable as n, KilnOptions as o, RenderAware as p, KilnFilters as r, KilnSchema as s, Kiln as t, KilnTypes as u, TypeChecks as v, HtmlCheckLevel as w, memoryLoader as x, createKiln as y, deferIslands as z };
+//# sourceMappingURL=environment-DBvRrOn0.d.ts.map

package/dist/environment-DBvRrOn0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment-DBvRrOn0.d.ts","names":[],"sources":["../src/errors.ts","../src/runtime/islands.ts","../src/runtime/types.ts","../src/analyzer.ts","../src/compiler/precompiled.ts","../src/html/options.ts","../src/environment.ts"],"mappings":"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"}

package/dist/{format-CJoqhehX.js → format-Di6-GUtH.js}

@@ -1,4 +1,5 @@
-import { hn as createDiagnostic, mn as KilnSyntaxError, n as parse, r as scanParts, s as builtinTests, t as Source } from "./source-BQxJGo5Y.js";
+import { an as KilnSyntaxError, on as createDiagnostic, r as builtinTests, t as Source } from "./source-BbikGqIb.js";
+import { r as scanParts, t as parse } from "./parser-isboTef0.js";
 //#region src/formatter/delimiters.ts
 const KEYWORDS = /* @__PURE__ */ new Set([
 	"and",
@@ -651,7 +652,7 @@ const normaliseTree = (value) => {
 	if (typeof value !== "object" || value === null) return value;
 	const copy = {};
 	for (const [key, item] of Object.entries(value)) {
-		if (key === "span" || key === "nameSpan" || key === "lines" || key === "indent") continue;
+		if (key === "span" || key === "nameSpan" || key === "indent") continue;
 		copy[key] = key === "value" && value.type === "Text" ? normaliseText(item) : normaliseTree(item);
 	}
 	return copy;
@@ -693,4 +694,4 @@ const format = (text, options = {}) => applyEdits(text, formatEdits(text, option
 //#endregion
 export { format as n, formatEdits as r, KilnFormatError as t };
 
-//# sourceMappingURL=format-CJoqhehX.js.map
+//# sourceMappingURL=format-Di6-GUtH.js.map