@ecoma-io/loom 0.2.0 → 0.4.0

package/dist/lib/field-context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"field-context.js","names":[],"sources":["../../src/lib/field-context.ts"],"sourcesContent":["import {\n  computed,\n  inject,\n  onScopeDispose,\n  provide,\n  reactive,\n  ref,\n  watchEffect,\n  type ComputedRef,\n  type InjectionKey,\n} from \"vue\";\nimport { optional } from \"./props\";\n\n/**\n * What a form-row wrapper (Field, Fieldset) knows about the control inside it.\n *\n * A wrapper renders a `<label for>` and a hint-or-error line, and it is the\n * only thing in the tree that knows the id it pointed that label at, the id of\n * the message, and whether the row is mandatory or in error. None of that can\n * reach a slotted control through props — the wrapper never rendered it — so\n * before this existed the caller copied three attributes by hand at every call\n * site, and forgetting one was a silent accessibility defect.\n *\n * Every member is a `ComputedRef` rather than a value. A row's `error` arrives\n * and clears while the control stays mounted, so the context has to move with\n * it; and a per-key ref is what lets one wrapper inherit a single key from\n * another (Field reads `readonly` off a Fieldset above it) without a hidden\n * whole-object merge.\n *\n * On the booleans, `undefined` means \"this wrapper has no opinion\" and never\n * \"false\". That is the whole precedence story — see `useFieldControl` — and it\n * is the same distinction `./props.ts` exists to explain, arriving from the\n * other side: there, a key is dropped so a child sees an absence; here, an\n * absence is a value a wrapper is allowed to hold.\n */\nexport interface FieldContext {\n  /** The id the primary control adopts, so the wrapper's `<label for>` names it. */\n  readonly controlId: ComputedRef<string | undefined>;\n  /** The id of the wrapper's `<label>`, for group controls to reference via `aria-labelledby`. */\n  readonly labelledBy: ComputedRef<string | undefined>;\n  /** The id of the hint-or-error line, and `undefined` while no message is rendered. */\n  readonly describedBy: ComputedRef<string | undefined>;\n  /** The form field name the control submits under. */\n  readonly name: ComputedRef<string | undefined>;\n  /** Whether the wrapper marks the row mandatory. Becomes `aria-required`. */\n  readonly required: ComputedRef<boolean | undefined>;\n  /** Whether the wrapper is showing an error, which is the same fact as the control being invalid. */\n  readonly invalid: ComputedRef<boolean | undefined>;\n  /** Whether the wrapper disables what is inside it. */\n  readonly disabled: ComputedRef<boolean | undefined>;\n  /** Whether the wrapper renders what is inside it read-only. */\n  readonly readonly: ComputedRef<boolean | undefined>;\n  /**\n   * Claims the row's single control id, and reports whether this control won it.\n   *\n   * `<Field><TextField /><TextField /></Field>` is a shape somebody will write,\n   * and without a claim both inputs adopt the same generated id — a duplicate\n   * id, and a `<label for>` that resolves to whichever the browser reaches\n   * first. The `axe` gate cannot be the backstop: `duplicate-id-active` is\n   * tagged `wcag2a-obsolete`/`deprecated` in axe-core, not `wcag2a`, so it does\n   * not match `WCAG_TAGS` and `e2e/accessibility.e2e.ts` never runs it.\n   *\n   * Reactive rather than a plain boolean because the claim can move: a `v-if`\n   * swapping the first control for the second must promote the second, or the\n   * label points at an id no longer in the document.\n   */\n  claimControlId(): ComputedRef<boolean>;\n}\n\n/**\n * What a wrapper hands `provideFieldContext`, as getters rather than values —\n * the wrapper writes plain expressions over its own props and this file does\n * the wrapping, so a wrapper never has to remember which of its answers are\n * derived.\n */\nexport interface FieldContextSource {\n  controlId: () => string | undefined;\n  labelledBy?: () => string | undefined;\n  describedBy: () => string | undefined;\n  name: () => string | undefined;\n  required: () => boolean | undefined;\n  invalid: () => boolean | undefined;\n  disabled: () => boolean | undefined;\n  readonly: () => boolean | undefined;\n}\n\n/**\n * The control's own side of the contract: what this control was told directly,\n * with `undefined` for everything the caller left unset.\n *\n * Each key is `?: T | undefined` rather than `?: T`. Under\n * `exactOptionalPropertyTypes` that is the form that accepts both an omitted\n * key and an explicit `undefined` — and an explicit `undefined` is exactly what\n * a control passes when its own prop is unset.\n */\nexport interface FieldControlProps {\n  /** The caller's `id`, which reaches a bare control as a fallthrough attr rather than a prop. */\n  readonly id?: string | undefined;\n  /** The caller's `aria-describedby`, likewise a fallthrough attr. */\n  readonly describedBy?: string | undefined;\n  /** The caller's `aria-labelledby`, for group controls that name themselves rather than being named by `label for`. */\n  readonly ariaLabelledby?: string | undefined;\n  readonly name?: string | undefined;\n  readonly required?: boolean | undefined;\n  readonly invalid?: boolean | undefined;\n  readonly disabled?: boolean | undefined;\n  readonly readonly?: boolean | undefined;\n}\n\n/**\n * The resolved attributes, ready to spread onto whichever node carries the\n * control's ARIA.\n *\n * A key whose value resolved to `undefined` is **absent**, not present-and-\n * undefined — `optional()` drops it. That is what makes the spread purely\n * additive: `v-bind=\"{ ...rest, ...field.attrs }\"` can never blank out an\n * attribute the caller passed through fallthrough, so a control renders exactly\n * what it renders today whenever there is no wrapper above it.\n *\n * `aria-required` and `aria-invalid` are omitted rather than set to `\"false\"`.\n * Both are legal and both say nothing, and the absent attribute already means\n * the same thing — the house `x || undefined` idiom, moved one layer in.\n */\nexport interface FieldControlAttrs {\n  readonly id?: string;\n  readonly name?: string;\n  readonly \"aria-describedby\"?: string;\n  // Narrowed to the literal rather than `string`: Vue types `aria-invalid` on a\n  // native element as `Booleanish | \"grammar\" | \"spelling\"`, so a widened\n  // `string` here fails to spread onto the very `<input>` this exists for.\n  readonly \"aria-required\"?: \"true\";\n  readonly \"aria-invalid\"?: \"true\";\n}\n\n/**\n * What `useFieldControl` resolved, after the control's own props won.\n *\n * Returned `reactive` rather than as a bag of refs, which is the one place in\n * `src/lib/` that does so. A template unwraps only a *top-level* ref, and a\n * control needs four of these at once under names — `disabled`, `invalid`,\n * `readonly`, `required` — that each shadow a prop of the same name. `reactive`\n * gives `field.invalid` in both the script and the template, and the shadowing\n * question never arises. Destructuring it does lose reactivity; read through\n * `field.` and there is nothing to get wrong.\n */\nexport interface FieldControl {\n  /** Spread onto the node that carries the control's ARIA, **after** the fallthrough attrs. */\n  readonly attrs: FieldControlAttrs;\n  readonly id: string | undefined;\n  readonly labelledBy: string | undefined;\n  readonly name: string | undefined;\n  readonly disabled: boolean;\n  readonly invalid: boolean;\n  readonly readonly: boolean;\n  readonly required: boolean;\n}\n\n/**\n * A `Symbol`, and not exported from `src/index.ts`: a consumer pinned to the\n * key is pinned to a shape that moves whenever a wrapper does. `useFieldControl`\n * is the supported way in.\n */\nconst FIELD_CONTEXT: InjectionKey<FieldContext> = Symbol(\"loom.field\");\n\n/**\n * The wrapper above this one, for a wrapper that composes over another.\n *\n * Only Field needs it, and only for `readonly`: Vue resolves `inject` to the\n * nearest provider **wholesale**, not per key, so a Field shadows the Fieldset\n * above it entirely. Any key both wrappers answer has to be merged by hand, and\n * reading the outer context here rather than merging inside\n * `provideFieldContext` keeps that decision visible in Field.vue, where the\n * reason for it lives.\n */\nexport function useOuterFieldContext(): FieldContext | undefined {\n  return inject(FIELD_CONTEXT, undefined);\n}\n\n/** Called by a wrapper — Field and Fieldset — from its own `setup`. */\nexport function provideFieldContext(source: FieldContextSource): void {\n  const claims = ref<symbol[]>([]);\n\n  provide(FIELD_CONTEXT, {\n    controlId: computed(source.controlId),\n    labelledBy: computed(source.labelledBy ?? (() => undefined)),\n    describedBy: computed(source.describedBy),\n    name: computed(source.name),\n    required: computed(source.required),\n    invalid: computed(source.invalid),\n    disabled: computed(source.disabled),\n    readonly: computed(source.readonly),\n    claimControlId() {\n      const token = Symbol(\"loom.field.control\");\n      claims.value = [...claims.value, token];\n      // The claiming scope is the control's, not the wrapper's, so this fires\n      // when that one control unmounts and the next in document order is\n      // promoted.\n      onScopeDispose(() => {\n        claims.value = claims.value.filter((held) => held !== token);\n      });\n      return computed(() => claims.value[0] === token);\n    },\n  });\n}\n\n/**\n * Opt a control into the wrapper around it. One call, one spread — see\n * `TextField.vue`, which is the worked example the rest of the family copies.\n *\n * **The rule is `own ?? wrapper ?? false`.** `??` and not `||`, so an explicit\n * `false` on the control beats a `true` from the wrapper: one control inside a\n * row that is showing an error can declare itself individually fine, and one\n * inside a clean row can declare itself individually invalid.\n *\n * That rule is worth nothing unless \"unset\" and \"set to `false`\" are still\n * different values by the time they arrive here, and by default they are not:\n * Vue resolves an absent `Boolean` prop with no declared default to `false`, so\n * `props.invalid ?? field` would short-circuit forever and the context would be\n * inert while looking perfectly wired. **Every participating prop must be\n * declared `boolean | undefined` with an explicit `undefined` default** — the\n * `| undefined` is what `exactOptionalPropertyTypes` needs to let `withDefaults`\n * take that default at all, and the default is what beats the Boolean cast.\n *\n * With no wrapper above, every chain falls through to the control's own props\n * and the `?? false` at the end is the same `false` the control's `withDefaults`\n * used to supply. Nothing about a control standing alone changes.\n *\n * The argument is a **getter**, not a props object, for the reason\n * `./attrs.ts` takes `useAttrs()` rather than a snapshot: a control feeds this a\n * mix of props and fallthrough attrs and both have to stay live.\n */\nexport function useFieldControl(own: () => FieldControlProps): FieldControl {\n  const field = inject(FIELD_CONTEXT, undefined);\n  const holdsControlId = field?.claimControlId();\n\n  const id = computed(\n    () => own().id ?? (holdsControlId?.value === true ? field?.controlId.value : undefined),\n  );\n  const name = computed(() => own().name ?? field?.name.value);\n  const labelledBy = computed(() => own().ariaLabelledby ?? field?.labelledBy.value);\n\n  // The one attribute whose rule is merge rather than replace, because\n  // `aria-describedby` is a token list: the row's message is additional to\n  // whatever else the caller pointed at, not an alternative to it. Replacing\n  // would silently drop the row's hint the moment a caller described their\n  // control for some other reason — which is the defect this file exists to\n  // remove, reintroduced from the other end. The control's own id reads first:\n  // a control that has something to say about itself is saying the more\n  // specific thing, and a screen reader reads the list in order.\n  const describedBy = computed(() => {\n    const ids = [own().describedBy, field?.describedBy.value].filter(\n      (candidate): candidate is string => candidate !== undefined && candidate.length > 0,\n    );\n    return ids.length > 0 ? ids.join(\" \") : undefined;\n  });\n\n  const required = computed(() => own().required ?? field?.required.value ?? false);\n  const invalid = computed(() => own().invalid ?? field?.invalid.value ?? false);\n  const disabled = computed(() => own().disabled ?? field?.disabled.value ?? false);\n  const readonly = computed(() => own().readonly ?? field?.readonly.value ?? false);\n\n  // A development-mode safety net for the one context key a control can\n  // deliberately decline. When a wrapper sets `readonly` but the control did\n  // not pass that key in its `FieldControlProps`, the wrapper's instruction is\n  // silently dropped — and without this warning the consumer has no signal\n  // that it was. The `\"readonly\" in own()` check distinguishes \"I defer to the\n  // wrapper\" (key present, value `undefined`) from \"I don't participate\" (key\n  // absent), which is the same distinction `exactOptionalPropertyTypes` makes\n  // at the type level.\n  if (import.meta.env.DEV && field) {\n    watchEffect(() => {\n      if (field.readonly.value && !(\"readonly\" in own())) {\n        console.warn(\"[Loom] readonly was set on the Field, but this control does not claim it.\");\n      }\n    });\n  }\n\n  const attrs = computed<FieldControlAttrs>(() =>\n    optional({\n      id: id.value,\n      name: name.value,\n      \"aria-describedby\": describedBy.value,\n      \"aria-required\": required.value ? (\"true\" as const) : undefined,\n      \"aria-invalid\": invalid.value ? (\"true\" as const) : undefined,\n    }),\n  );\n\n  return reactive({ attrs, id, labelledBy, name, disabled, invalid, readonly, required });\n}\n"],"mappings":";;;;;;;;AAkKA,IAAM,gBAA4C,OAAO,YAAY;;;;;;;;;;;AAYrE,SAAgB,uBAAiD;CAC/D,OAAO,OAAO,eAAe,KAAA,CAAS;AACxC;;AAGA,SAAgB,oBAAoB,QAAkC;CACpE,MAAM,SAAS,IAAc,CAAC,CAAC;CAE/B,QAAQ,eAAe;EACrB,WAAW,SAAS,OAAO,SAAS;EACpC,YAAY,SAAS,OAAO,qBAAqB,KAAA,EAAU;EAC3D,aAAa,SAAS,OAAO,WAAW;EACxC,MAAM,SAAS,OAAO,IAAI;EAC1B,UAAU,SAAS,OAAO,QAAQ;EAClC,SAAS,SAAS,OAAO,OAAO;EAChC,UAAU,SAAS,OAAO,QAAQ;EAClC,UAAU,SAAS,OAAO,QAAQ;EAClC,iBAAiB;GACf,MAAM,QAAQ,OAAO,oBAAoB;GACzC,OAAO,QAAQ,CAAC,GAAG,OAAO,OAAO,KAAK;GAItC,qBAAqB;IACnB,OAAO,QAAQ,OAAO,MAAM,QAAQ,SAAS,SAAS,KAAK;GAC7D,CAAC;GACD,OAAO,eAAe,OAAO,MAAM,OAAO,KAAK;EACjD;CACF,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,gBAAgB,KAA4C;CAC1E,MAAM,QAAQ,OAAO,eAAe,KAAA,CAAS;CAC7C,MAAM,iBAAiB,OAAO,eAAe;CAE7C,MAAM,KAAK,eACH,IAAI,CAAC,CAAC,OAAO,gBAAgB,UAAU,OAAO,OAAO,UAAU,QAAQ,KAAA,EAC/E;CACA,MAAM,OAAO,eAAe,IAAI,CAAC,CAAC,QAAQ,OAAO,KAAK,KAAK;CAC3D,MAAM,aAAa,eAAe,IAAI,CAAC,CAAC,kBAAkB,OAAO,WAAW,KAAK;CAUjF,MAAM,cAAc,eAAe;EACjC,MAAM,MAAM,CAAC,IAAI,CAAC,CAAC,aAAa,OAAO,YAAY,KAAK,CAAC,CAAC,QACvD,cAAmC,cAAc,KAAA,KAAa,UAAU,SAAS,CACpF;EACA,OAAO,IAAI,SAAS,IAAI,IAAI,KAAK,GAAG,IAAI,KAAA;CAC1C,CAAC;CAED,MAAM,WAAW,eAAe,IAAI,CAAC,CAAC,YAAY,OAAO,SAAS,SAAS,KAAK;CAChF,MAAM,UAAU,eAAe,IAAI,CAAC,CAAC,WAAW,OAAO,QAAQ,SAAS,KAAK;CAC7E,MAAM,WAAW,eAAe,IAAI,CAAC,CAAC,YAAY,OAAO,SAAS,SAAS,KAAK;CAChF,MAAM,WAAW,eAAe,IAAI,CAAC,CAAC,YAAY,OAAO,SAAS,SAAS,KAAK;CAkBhF,MAAM,QAAQ,eACZ,SAAS;EACP,IAAI,GAAG;EACP,MAAM,KAAK;EACX,oBAAoB,YAAY;EAChC,iBAAiB,SAAS,QAAS,SAAmB,KAAA;EACtD,gBAAgB,QAAQ,QAAS,SAAmB,KAAA;CACtD,CAAC,CACH;CAEA,OAAO,SAAS;EAAE;EAAO;EAAI;EAAY;EAAM;EAAU;EAAS;EAAU;CAAS,CAAC;AACxF"}

package/dist/lib/icon-defaults.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"icon-defaults.d.ts","sourceRoot":"","sources":["../../src/lib/icon-defaults.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C"}

package/dist/lib/icon-defaults.js

@@ -1,32 +0,0 @@
-import { setLucideProps } from "@lucide/vue";
-//#region src/lib/icon-defaults.ts
-/**
-* Apply the Loom icon defaults once at a host's root: size 16, stroke 1.5 —
-* hairline-first, matching the 1px border language. Every `@lucide/vue` icon
-* rendered after this call inherits them, so an individual icon declares
-* `size` or `strokeWidth` only where it deliberately diverges.
-*
-* The one standing divergence: a glyph rendered at 12px or below declares
-* `stroke-width` 2.5 exactly. Stroke lives on the 24 grid and scales with
-* size, so 1.5 at 12px renders 0.75 device pixels against 1.0 at 16px; 2.5
-* restores the optical weight.
-*
-* The numbers live here, not in each host.
-*
-* Call it from the `setup()` of the host's root component — `App.vue`, or the
-* component a documentation theme wraps its layout in. It resolves to Vue's
-* `provide()`, so it needs an active component instance: called from a plain
-* entry module it silently provides nothing, and every icon keeps Lucide's own
-* 24/2 defaults. There is no app-level alternative, because the injection key
-* Lucide provides under is not part of its public surface.
-*/
-function applyLoomIconDefaults() {
-	setLucideProps({
-		size: 16,
-		strokeWidth: 1.5
-	});
-}
-//#endregion
-export { applyLoomIconDefaults };
-
-//# sourceMappingURL=icon-defaults.js.map

package/dist/lib/icon-defaults.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"icon-defaults.js","names":[],"sources":["../../src/lib/icon-defaults.ts"],"sourcesContent":["import { setLucideProps } from \"@lucide/vue\";\n\n/**\n * Apply the Loom icon defaults once at a host's root: size 16, stroke 1.5 —\n * hairline-first, matching the 1px border language. Every `@lucide/vue` icon\n * rendered after this call inherits them, so an individual icon declares\n * `size` or `strokeWidth` only where it deliberately diverges.\n *\n * The one standing divergence: a glyph rendered at 12px or below declares\n * `stroke-width` 2.5 exactly. Stroke lives on the 24 grid and scales with\n * size, so 1.5 at 12px renders 0.75 device pixels against 1.0 at 16px; 2.5\n * restores the optical weight.\n *\n * The numbers live here, not in each host.\n *\n * Call it from the `setup()` of the host's root component — `App.vue`, or the\n * component a documentation theme wraps its layout in. It resolves to Vue's\n * `provide()`, so it needs an active component instance: called from a plain\n * entry module it silently provides nothing, and every icon keeps Lucide's own\n * 24/2 defaults. There is no app-level alternative, because the injection key\n * Lucide provides under is not part of its public surface.\n */\nexport function applyLoomIconDefaults(): void {\n  setLucideProps({ size: 16, strokeWidth: 1.5 });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,wBAA8B;CAC5C,eAAe;EAAE,MAAM;EAAI,aAAa;CAAI,CAAC;AAC/C"}

package/dist/lib/label-registry.d.ts

@@ -1,75 +0,0 @@
-import type { CalendarPanelLabels, DateSegmentLabels, RangeCellLabels, TimeSegmentLabels } from "./date-labels";
-import type { DateRangeLabels } from "../primitives/DateRangePicker/DateRangePicker.vue";
-import type { DateTimeRangeLabels } from "../primitives/DateTimeRangePicker/DateTimeRangePicker.vue";
-import type { ComboboxLabels } from "../primitives/Combobox/Combobox.vue";
-import type { EditableLabels } from "../primitives/Editable/Editable.vue";
-import type { FileUploadLabels } from "../primitives/FileUpload/FileUpload.vue";
-import type { NumberFieldLabels } from "../primitives/NumberField/NumberField.vue";
-import type { OtpInputLabels } from "../primitives/OtpInput/OtpInput.vue";
-import type { PaginationLabels } from "../primitives/Pagination/Pagination.vue";
-import type { RatingLabels } from "../primitives/Rating/Rating.vue";
-import type { WindowControlsLabels } from "../primitives/WindowControls/WindowControls.vue";
-import type { AvatarGroupLabels } from "../primitives/AvatarGroup/AvatarGroup.vue";
-import type { ColorPickerLabels } from "../primitives/ColorPicker/ColorPicker.vue";
-import type { IndicatorLabels } from "../primitives/Indicator/Indicator.vue";
-import type { ProgressLabels } from "../primitives/Progress/Progress.vue";
-import type { RadialProgressLabels } from "../primitives/RadialProgress/RadialProgress.vue";
-import type { AlertDialogLabels } from "../primitives/AlertDialog/AlertDialog.vue";
-import type { DialogLabels } from "../primitives/Dialog/Dialog.vue";
-import type { DrawerLabels } from "../primitives/Drawer/Drawer.vue";
-import type { StepperLabels } from "../primitives/Stepper/Stepper.vue";
-import type { ToastLabels } from "../primitives/Toast/Toast.vue";
-import type { TagsInputLabels } from "../primitives/TagsInput/TagsInput.vue";
-import type { TextFieldLabels } from "../primitives/TextField/TextField.vue";
-import type { TextareaLabels } from "../primitives/Textarea/Textarea.vue";
-/**
- * Every slot a host can localise, and nothing else. One line per component that
- * speaks; the keys themselves live with the component that says them.
- *
- * This file exists so that both halves of the seam can be true at once. The
- * *keys* belong beside the component — `PaginationLabels` is declared in
- * `Pagination.vue`, where its doc comments sit next to the markup that renders
- * them and where a component's whole contract can be read in one file. The
- * *namespace* has to be central, or `provideLoomLabels({ pagination: … })` could
- * not check a misspelled slot and a consumer would have no single place to see
- * what the library can be asked to say.
- *
- * Every import here is `import type`, so this module emits nothing and the
- * apparent cycle — component imports `useLabels`, `useLabels` imports this,
- * this imports the component — exists only in the type graph, where TypeScript
- * resolves it lazily. A value import in this file would turn the whole library
- * into one chunk and cost every consumer the components they did not use.
- *
- * Adding a component to the sweep is one line. Adding it in the wrong shape is
- * a compile error at that component's own `useLabels` call, not here.
- */
-export interface LoomLabels {
-    readonly pagination: PaginationLabels;
-    readonly windowControls: WindowControlsLabels;
-    readonly dateSegments: DateSegmentLabels;
-    readonly timeSegments: TimeSegmentLabels;
-    readonly calendarPanel: CalendarPanelLabels;
-    readonly rangeCell: RangeCellLabels;
-    readonly dateRange: DateRangeLabels;
-    readonly dateTimeRange: DateTimeRangeLabels;
-    readonly numberField: NumberFieldLabels;
-    readonly combobox: ComboboxLabels;
-    readonly otpInput: OtpInputLabels;
-    readonly fileUpload: FileUploadLabels;
-    readonly rating: RatingLabels;
-    readonly tagsInput: TagsInputLabels;
-    readonly editable: EditableLabels;
-    readonly textField: TextFieldLabels;
-    readonly textarea: TextareaLabels;
-    readonly dialog: DialogLabels;
-    readonly alertDialog: AlertDialogLabels;
-    readonly drawer: DrawerLabels;
-    readonly stepper: StepperLabels;
-    readonly toast: ToastLabels;
-    readonly indicator: IndicatorLabels;
-    readonly avatarGroup: AvatarGroupLabels;
-    readonly progress: ProgressLabels;
-    readonly radialProgress: RadialProgressLabels;
-    readonly colorPicker: ColorPickerLabels;
-}
-//# sourceMappingURL=label-registry.d.ts.map

package/dist/lib/label-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"label-registry.d.ts","sourceRoot":"","sources":["../../src/lib/label-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mDAAmD,CAAC;AACzF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2DAA2D,CAAC;AACrG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AACnF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iDAAiD,CAAC;AAC5F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AACnF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AACnF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iDAAiD,CAAC;AAC5F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AACnF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC;IAM9C,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAAC;IACzC,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAAC;IACzC,QAAQ,CAAC,aAAa,EAAE,mBAAmB,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,aAAa,EAAE,mBAAmB,CAAC;IAI5C,QAAQ,CAAC,WAAW,EAAE,iBAAiB,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IAKpC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAIlC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,iBAAiB,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAM5B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,WAAW,EAAE,iBAAiB,CAAC;IAIxC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC;IAC9C,QAAQ,CAAC,WAAW,EAAE,iBAAiB,CAAC;CACzC"}

package/dist/lib/labels.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../../src/lib/labels.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,WAAW,EAAqB,MAAM,KAAK,CAAC;AAErF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,OAAO,CAAC,IAAI,SAAS,MAAM,IAAI,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC;AAElE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,MAAM,IAAI;IAC7C,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS;CAC3C,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,CAAC,IAAI,MAAM,UAAU,CAAC,CAAC,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS;CAC7E,CAAC;AA4BF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,kBAAkB,GAAG,IAAI,CAMxE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,UAAU,EAAE,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,EAC3E,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,cAAc,CAAC,CAAC,CAAC,GAAG,SAAS,GACxC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAa5B"}

package/dist/lib/labels.js

@@ -1,84 +0,0 @@
-import { optional } from "./props.js";
-import { computed, inject, provide } from "vue";
-//#region src/lib/labels.ts
-/**
-* A `Symbol`, and not exported from `src/index.ts`, for the reason
-* `./field-context.ts` gives about its own: a consumer pinned to the key is
-* pinned to a shape that moves. `provideLoomLabels` is the supported way in.
-*/
-var LOOM_LABELS = Symbol("loom.labels");
-function mergeVocabularies(outer, inner) {
-	const merged = { ...outer };
-	const patches = inner;
-	for (const slot of Object.keys(patches)) {
-		const patch = patches[slot];
-		if (patch === void 0) continue;
-		merged[slot] = {
-			...merged[slot] ?? {},
-			...optional(patch)
-		};
-	}
-	return merged;
-}
-/**
-* Declare a host's vocabulary once, from the `setup` of its root component —
-* the same place, and for the same reason, as `applyLoomIconDefaults`. It
-* resolves to Vue's `provide()`, so called from a plain entry module it
-* silently provides nothing and every component keeps its English.
-*
-* A **getter**, not a value, for the reason `./attrs.ts` takes `useAttrs()`
-* rather than a snapshot: the getter runs inside the `computed` that
-* `useLabels` returns, which runs inside the render effect, so a host whose bag
-* reads `t("pager.next")` tracks their locale ref and every Loom component
-* repaints on a language switch with no work here at all. Snapshot the bag
-* instead and the first language renders correctly and every switch after it
-* does nothing — a failure with no error and no warning.
-*
-* **A nested call merges into the bag above it rather than replacing it**, and
-* that is a deliberate divergence from `./field-context.ts`, which documents
-* the opposite and hand-merges the single key that needs it. Vue resolves
-* `inject` wholesale to the nearest provider, so without this a host wrapping
-* one dialog in a second `provideLoomLabels` to change one string would lose
-* every other string in the application back to English. Hand-merging is right
-* for two wrappers and one key; it does not scale to a vocabulary this size at
-* an unknown depth.
-*/
-function provideLoomLabels(source) {
-	const outer = inject(LOOM_LABELS, void 0);
-	provide(LOOM_LABELS, computed(() => outer === void 0 ? source() : mergeVocabularies(outer.value, source())));
-}
-/**
-* Resolve one component's slot: **own prop, then the host's vocabulary, then
-* the component's own English** — key by key, never whole-object.
-*
-* Key by key is the whole point. A host providing `{ pagination: { next: "Sau" } }`
-* keeps English for the other seven rather than rendering a row of unnamed
-* buttons, and an instance overriding its own `nav` does not discard the host's
-* other six. `optional()` is what makes each spread purely additive: it drops
-* the `undefined`-valued keys, so an absent override cannot blank a present
-* default. Same function, same reasoning, as the attribute spread in
-* `./field-context.ts`.
-*
-* The prop beating the provider is not a preference. A page with two paginations
-* that need different names has no other way out, and an application-wide
-* vocabulary that could not be corrected per instance would force a host to
-* choose between localising and naming.
-*
-* `defaults` arrives from the component rather than from a central English
-* bundle, and that is what bounds the cost of the seam: a consumer importing
-* only `Button` ships no label bytes at all, and one importing `Pagination`
-* ships `Pagination`'s. A central `en` object would always ship whole.
-*
-* The result is typed from `defaults` rather than from `LoomLabels[K]`, with
-* the registry entry as a constraint on it. Structurally that is the same
-* check — a bag that does not match its registered slot does not compile — but
-* it keeps the resolved type nameable from the module that declared it.
-*/
-function useLabels(slot, defaults, own) {
-	const provided = inject(LOOM_LABELS, void 0);
-	return computed(() => Object.assign({}, defaults, optional(provided?.value[slot] ?? {}), optional(own?.() ?? {})));
-}
-//#endregion
-export { provideLoomLabels, useLabels };
-
-//# sourceMappingURL=labels.js.map

package/dist/lib/labels.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"labels.js","names":[],"sources":["../../src/lib/labels.ts"],"sourcesContent":["import { computed, inject, provide, type ComputedRef, type InjectionKey } from \"vue\";\nimport { optional } from \"./props\";\nimport type { LoomLabels } from \"./label-registry\";\n\n/**\n * A message the component cannot write on its own, because it depends on a\n * value only the render knows — a page number, a file name, a count.\n *\n * **The argument is one object, and every member is a raw value: a `number`, a\n * `Date`, a `File`. Never a string Loom has already formatted.** That is the\n * entire pluralisation answer, and it is why this library ships no\n * pluralisation engine and takes no i18n dependency. \"3 unread\" has one form in\n * Vietnamese, two in English, three in Russian and six in Arabic, and no\n * placeholder syntax Loom could invent would carry that. Loom hands over the\n * facts and receives a finished string; selecting the plural category, shaping\n * the digits and ordering the sentence all happen in the consumer's own\n * `Intl.PluralRules`, `Intl.NumberFormat`, vue-i18n, or hand-written `if`.\n *\n * Hand over the number and a consumer can reach `Intl.NumberFormat` for Eastern\n * Arabic digits. Hand over `\"3\"` and they cannot: the decision was already made,\n * in English, inside a component that had no business making it.\n *\n * One object rather than positional parameters, for two reasons. A bare\n * `(4, 12)` in a consumer's locale file says nothing about what either number\n * is. And a fact added later is a new key an existing override simply ignores,\n * where a new positional parameter would silently re-order every call site.\n *\n * There is deliberately no third kind. A message is a `string` or it is one of\n * these; a `string | (() => string)` union was considered and rejected, because\n * the reactivity it exists to buy is already bought by `provideLoomLabels`\n * taking a getter — and it would put a `resolve()` call around every binding in\n * every component for the rest of the library's life.\n */\nexport type LabelOf<Args extends object> = (args: Args) => string;\n\n/**\n * What a consumer may pass for one component's bag: any subset of it.\n *\n * **This, not the bag interface itself, is the type a consumer annotates their\n * own object with.** A bag typed `PaginationLabels` must answer every key, so a\n * key added in a later release breaks that consumer's build; a bag typed\n * `LabelOverrides<PaginationLabels>` does not, which is what makes growing the\n * vocabulary a `feat` rather than a `feat!`.\n *\n * `T[K] | undefined` rather than a plain `Partial<T>`, because\n * `exactOptionalPropertyTypes` is on: under it `Partial<T>` rejects an\n * explicitly-`undefined` value, and an explicit `undefined` is exactly what a\n * consumer's own conditional expression produces when its condition is unmet.\n * It has to mean \"no opinion\", never \"blank this out\" — the same distinction\n * `./props.ts` exists to explain, arriving one layer in.\n */\nexport type LabelOverrides<T extends object> = {\n  readonly [K in keyof T]?: T[K] | undefined;\n};\n\n/**\n * A whole vocabulary, as a host supplies it: any subset of any slot.\n *\n * Both levels are partial and both are checked. A misspelled slot and a\n * misspelled key inside a slot are each a compile error — on a fresh object\n * literal, which is the caveat the localisation guide documents and the reason\n * it tells a consumer to write `satisfies LoomLabelOverrides` on a bag they\n * hoist to a module.\n */\nexport type LoomLabelOverrides = {\n  readonly [K in keyof LoomLabels]?: LabelOverrides<LoomLabels[K]> | undefined;\n};\n\n/** The shape both merge steps work in, once the slot's identity has been checked. */\ntype AnyBag = Record<string, unknown>;\n\n/**\n * A `Symbol`, and not exported from `src/index.ts`, for the reason\n * `./field-context.ts` gives about its own: a consumer pinned to the key is\n * pinned to a shape that moves. `provideLoomLabels` is the supported way in.\n */\nconst LOOM_LABELS: InjectionKey<ComputedRef<LoomLabelOverrides>> = Symbol(\"loom.labels\");\n\nfunction mergeVocabularies(\n  outer: LoomLabelOverrides,\n  inner: LoomLabelOverrides,\n): LoomLabelOverrides {\n  const merged = { ...outer } as AnyBag;\n  const patches = inner as AnyBag;\n  for (const slot of Object.keys(patches)) {\n    const patch = patches[slot] as AnyBag | undefined;\n    if (patch === undefined) continue;\n    // Per key inside the slot as well as per slot: a nested provider changing\n    // one string must not blank the rest of that slot back to English.\n    merged[slot] = { ...((merged[slot] ?? {}) as AnyBag), ...optional(patch) };\n  }\n  return merged;\n}\n\n/**\n * Declare a host's vocabulary once, from the `setup` of its root component —\n * the same place, and for the same reason, as `applyLoomIconDefaults`. It\n * resolves to Vue's `provide()`, so called from a plain entry module it\n * silently provides nothing and every component keeps its English.\n *\n * A **getter**, not a value, for the reason `./attrs.ts` takes `useAttrs()`\n * rather than a snapshot: the getter runs inside the `computed` that\n * `useLabels` returns, which runs inside the render effect, so a host whose bag\n * reads `t(\"pager.next\")` tracks their locale ref and every Loom component\n * repaints on a language switch with no work here at all. Snapshot the bag\n * instead and the first language renders correctly and every switch after it\n * does nothing — a failure with no error and no warning.\n *\n * **A nested call merges into the bag above it rather than replacing it**, and\n * that is a deliberate divergence from `./field-context.ts`, which documents\n * the opposite and hand-merges the single key that needs it. Vue resolves\n * `inject` wholesale to the nearest provider, so without this a host wrapping\n * one dialog in a second `provideLoomLabels` to change one string would lose\n * every other string in the application back to English. Hand-merging is right\n * for two wrappers and one key; it does not scale to a vocabulary this size at\n * an unknown depth.\n */\nexport function provideLoomLabels(source: () => LoomLabelOverrides): void {\n  const outer = inject(LOOM_LABELS, undefined);\n  provide(\n    LOOM_LABELS,\n    computed(() => (outer === undefined ? source() : mergeVocabularies(outer.value, source()))),\n  );\n}\n\n/**\n * Resolve one component's slot: **own prop, then the host's vocabulary, then\n * the component's own English** — key by key, never whole-object.\n *\n * Key by key is the whole point. A host providing `{ pagination: { next: \"Sau\" } }`\n * keeps English for the other seven rather than rendering a row of unnamed\n * buttons, and an instance overriding its own `nav` does not discard the host's\n * other six. `optional()` is what makes each spread purely additive: it drops\n * the `undefined`-valued keys, so an absent override cannot blank a present\n * default. Same function, same reasoning, as the attribute spread in\n * `./field-context.ts`.\n *\n * The prop beating the provider is not a preference. A page with two paginations\n * that need different names has no other way out, and an application-wide\n * vocabulary that could not be corrected per instance would force a host to\n * choose between localising and naming.\n *\n * `defaults` arrives from the component rather than from a central English\n * bundle, and that is what bounds the cost of the seam: a consumer importing\n * only `Button` ships no label bytes at all, and one importing `Pagination`\n * ships `Pagination`'s. A central `en` object would always ship whole.\n *\n * The result is typed from `defaults` rather than from `LoomLabels[K]`, with\n * the registry entry as a constraint on it. Structurally that is the same\n * check — a bag that does not match its registered slot does not compile — but\n * it keeps the resolved type nameable from the module that declared it.\n */\nexport function useLabels<K extends keyof LoomLabels, T extends LoomLabels[K]>(\n  slot: K,\n  defaults: T,\n  own?: () => LabelOverrides<T> | undefined,\n): ComputedRef<LoomLabels[K]> {\n  const provided = inject(LOOM_LABELS, undefined);\n  // Read inside the `computed`, never above it: that is what puts the host's\n  // getter and this component's props inside the render effect, and it is the\n  // one line that decides whether a language switch repaints.\n  //\n  // `Object.assign` rather than an object spread, and that is a type-level\n  // choice rather than a stylistic one: spreading a generic `LoomLabels[K]`\n  // widens it to an index signature that no longer satisfies the return type,\n  // where `Object.assign` composes an intersection that does.\n  return computed(() =>\n    Object.assign({}, defaults, optional(provided?.value[slot] ?? {}), optional(own?.() ?? {})),\n  );\n}\n"],"mappings":";;;;;;;;AA4EA,IAAM,cAA6D,OAAO,aAAa;AAEvF,SAAS,kBACP,OACA,OACoB;CACpB,MAAM,SAAS,EAAE,GAAG,MAAM;CAC1B,MAAM,UAAU;CAChB,KAAK,MAAM,QAAQ,OAAO,KAAK,OAAO,GAAG;EACvC,MAAM,QAAQ,QAAQ;EACtB,IAAI,UAAU,KAAA,GAAW;EAGzB,OAAO,QAAQ;GAAE,GAAK,OAAO,SAAS,CAAC;GAAe,GAAG,SAAS,KAAK;EAAE;CAC3E;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,kBAAkB,QAAwC;CACxE,MAAM,QAAQ,OAAO,aAAa,KAAA,CAAS;CAC3C,QACE,aACA,eAAgB,UAAU,KAAA,IAAY,OAAO,IAAI,kBAAkB,MAAM,OAAO,OAAO,CAAC,CAAE,CAC5F;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,UACd,MACA,UACA,KAC4B;CAC5B,MAAM,WAAW,OAAO,aAAa,KAAA,CAAS;CAS9C,OAAO,eACL,OAAO,OAAO,CAAC,GAAG,UAAU,SAAS,UAAU,MAAM,SAAS,CAAC,CAAC,GAAG,SAAS,MAAM,KAAK,CAAC,CAAC,CAAC,CAC5F;AACF"}

package/dist/lib/motion.d.ts

@@ -1,14 +0,0 @@
-/**
- * The list-reveal stagger vocabulary — one source for every overlay that
- * reveals rows (DropdownMenu, Menubar, Select) and for the Motion
- * documentation page. Each revealed row is delayed one step after the
- * previous, capped so a long list does not tail off indefinitely.
- *
- * It lives here rather than in each template because it was written into
- * three of them independently once, which is how the three drifted.
- */
-export declare const LIST_STAGGER_STEP_MS = 24;
-export declare const LIST_STAGGER_CAP = 5;
-/** The inline `animation-delay` for the i-th revealed row. */
-export declare function listStaggerDelay(i: number): string;
-//# sourceMappingURL=motion.d.ts.map

package/dist/lib/motion.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../../src/lib/motion.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,8DAA8D;AAC9D,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAElD"}

package/dist/lib/motion.js

@@ -1,20 +0,0 @@
-//#region src/lib/motion.ts
-/**
-* The list-reveal stagger vocabulary — one source for every overlay that
-* reveals rows (DropdownMenu, Menubar, Select) and for the Motion
-* documentation page. Each revealed row is delayed one step after the
-* previous, capped so a long list does not tail off indefinitely.
-*
-* It lives here rather than in each template because it was written into
-* three of them independently once, which is how the three drifted.
-*/
-var LIST_STAGGER_STEP_MS = 24;
-var LIST_STAGGER_CAP = 5;
-/** The inline `animation-delay` for the i-th revealed row. */
-function listStaggerDelay(i) {
-	return `${String(Math.min(i, 5) * 24)}ms`;
-}
-//#endregion
-export { LIST_STAGGER_CAP, LIST_STAGGER_STEP_MS, listStaggerDelay };
-
-//# sourceMappingURL=motion.js.map

package/dist/lib/motion.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"motion.js","names":[],"sources":["../../src/lib/motion.ts"],"sourcesContent":["/**\n * The list-reveal stagger vocabulary — one source for every overlay that\n * reveals rows (DropdownMenu, Menubar, Select) and for the Motion\n * documentation page. Each revealed row is delayed one step after the\n * previous, capped so a long list does not tail off indefinitely.\n *\n * It lives here rather than in each template because it was written into\n * three of them independently once, which is how the three drifted.\n */\nexport const LIST_STAGGER_STEP_MS = 24;\nexport const LIST_STAGGER_CAP = 5;\n\n/** The inline `animation-delay` for the i-th revealed row. */\nexport function listStaggerDelay(i: number): string {\n  return `${String(Math.min(i, LIST_STAGGER_CAP) * LIST_STAGGER_STEP_MS)}ms`;\n}\n"],"mappings":";;;;;;;;;;AASA,IAAa,uBAAuB;AACpC,IAAa,mBAAmB;;AAGhC,SAAgB,iBAAiB,GAAmB;CAClD,OAAO,GAAG,OAAO,KAAK,IAAI,GAAA,CAAmB,IAAA,EAAwB,EAAE;AACzE"}

package/dist/lib/props.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../../src/lib/props.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxD,MAAM,EAAE,CAAC,GACR;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC;CAAE,CAM/C"}

package/dist/lib/props.js

@@ -1,37 +0,0 @@
-//#region src/lib/props.ts
-/**
-* Drops the keys whose value is `undefined`, so a `v-bind` passes only the
-* props that were actually set.
-*
-* Two rules collide to make this necessary, and neither is avoidable.
-*
-* Vue treats a prop that is absent and a prop explicitly set to `undefined` as
-* the same thing — both resolve to the child's default. TypeScript, under
-* `exactOptionalPropertyTypes`, does not: passing `undefined` to a `foo?: T` is
-* an error, because the flag exists precisely to tell "missing" apart from
-* "present and undefined". A Vue template always emits every key it binds, so
-* forwarding an optional prop straight through (`:open="open"`) hands a child's
-* `open?: boolean` an explicit `undefined` and fails to compile, while behaving
-* correctly at run time.
-*
-* That distinction is not academic for the components underneath. Reka reads
-* `undefined` as "no value supplied — manage this yourself", and any concrete
-* value, `false` included, as "the host owns this". So a control whose
-* `modelValue` is coerced to `false` on its way through stops being
-* uncontrolled and becomes permanently, silently off: it still emits its update
-* event, and its rendered state never moves. That failure has no error and no
-* warning; it looks like a component that ignores clicks.
-*
-* A cast (`open as boolean`) silences the compiler and is the reason to prefer
-* this: it states that a value is there when the whole point is that one may
-* not be. Omitting the key says what is true.
-*/
-function optional(values) {
-	const set = {};
-	for (const key of Object.keys(values)) if (values[key] !== void 0) set[key] = values[key];
-	return set;
-}
-//#endregion
-export { optional };
-
-//# sourceMappingURL=props.js.map

package/dist/lib/props.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"props.js","names":[],"sources":["../../src/lib/props.ts"],"sourcesContent":["/**\n * Drops the keys whose value is `undefined`, so a `v-bind` passes only the\n * props that were actually set.\n *\n * Two rules collide to make this necessary, and neither is avoidable.\n *\n * Vue treats a prop that is absent and a prop explicitly set to `undefined` as\n * the same thing — both resolve to the child's default. TypeScript, under\n * `exactOptionalPropertyTypes`, does not: passing `undefined` to a `foo?: T` is\n * an error, because the flag exists precisely to tell \"missing\" apart from\n * \"present and undefined\". A Vue template always emits every key it binds, so\n * forwarding an optional prop straight through (`:open=\"open\"`) hands a child's\n * `open?: boolean` an explicit `undefined` and fails to compile, while behaving\n * correctly at run time.\n *\n * That distinction is not academic for the components underneath. Reka reads\n * `undefined` as \"no value supplied — manage this yourself\", and any concrete\n * value, `false` included, as \"the host owns this\". So a control whose\n * `modelValue` is coerced to `false` on its way through stops being\n * uncontrolled and becomes permanently, silently off: it still emits its update\n * event, and its rendered state never moves. That failure has no error and no\n * warning; it looks like a component that ignores clicks.\n *\n * A cast (`open as boolean`) silences the compiler and is the reason to prefer\n * this: it states that a value is there when the whole point is that one may\n * not be. Omitting the key says what is true.\n */\nexport function optional<T extends Record<string, unknown>>(\n  values: T,\n): { [K in keyof T]?: Exclude<T[K], undefined> } {\n  const set: Record<string, unknown> = {};\n  for (const key of Object.keys(values)) {\n    if (values[key] !== undefined) set[key] = values[key];\n  }\n  return set as { [K in keyof T]?: Exclude<T[K], undefined> };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,SACd,QAC+C;CAC/C,MAAM,MAA+B,CAAC;CACtC,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,GAClC,IAAI,OAAO,SAAS,KAAA,GAAW,IAAI,OAAO,OAAO;CAEnD,OAAO;AACT"}

package/dist/lib/theme.d.ts

@@ -1,68 +0,0 @@
-/**
- * Theme switching for Loom.
- *
- * The single source of truth is the `data-theme` attribute on `<html>`.
- * This composable reads and writes it, persists the preference to
- * `localStorage`, and resolves `"system"` mode from the OS preference.
- *
- * SSR-safe: every DOM access is guarded. On the server, `theme` returns
- * the persisted or default preference, `resolvedTheme` resolves `"system"`
- * to `"light"` (the only safe default without a DOM), and the setter and
- * toggler are no-ops.
- *
- * Flash prevention: `themeScript` is a string of inline JavaScript that
- * reads `localStorage` and sets `data-theme` before the first paint.
- * Consumers rendering SSR inject it into `<head>`:
- *
- *   <script>${themeScript}</script>
- */
-import { type Ref } from "vue";
-/** The preference a user expresses — `"system"` defers to the OS. */
-export type ThemePreference = "light" | "dark" | "system";
-/** The actual theme applied — `"system"` is resolved away. */
-export type ResolvedTheme = "light" | "dark";
-/**
- * Reset the shared state. Intended for test isolation only — a real app
- * never needs this because the state lives for the app's lifetime.
- */
-export declare function _resetThemeState(): void;
-/**
- * Read and control the active Loom theme.
- *
- * @example
- * ```vue
- * <script setup>
- * import { useTheme } from "@ecoma-io/loom/theme"
- * const { theme, resolvedTheme, setTheme, toggleTheme } = useTheme()
- * </script>
- *
- * <template>
- *   <button @click="toggleTheme">
- *     {{ resolvedTheme === "dark" ? "☀️" : "🌙" }}
- *   </button>
- * </template>
- * ```
- */
-export declare function useTheme(): {
-    readonly theme: Ref<ThemePreference>;
-    readonly resolvedTheme: Readonly<Ref<ResolvedTheme>>;
-    readonly setTheme: (preference: ThemePreference) => void;
-    readonly toggleTheme: () => void;
-};
-/**
- * Inline script to prevent flash-of-wrong-theme on SSR pages.
- *
- * Paste it into `<head>` before any stylesheet links:
- *
- * ```html
- * <script><%= themeScript %></script>
- * ```
- *
- * It reads `localStorage` and sets `data-theme` on `<html>` synchronously,
- * before the browser paints, so the first frame is already in the right
- * theme. When no preference is stored, it follows the OS preference.
- *
- * The script is deliberately tiny and has no dependencies.
- */
-export declare const themeScript = "(() => {\n  const t = localStorage.getItem(\"loom:theme\");\n  const d = window.matchMedia(\"(prefers-color-scheme: dark)\").matches;\n  document.documentElement.setAttribute(\"data-theme\", (t === \"dark\" || (!t && d)) ? \"dark\" : \"light\");\n})()";
-//# sourceMappingURL=theme.d.ts.map

package/dist/lib/theme.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../src/lib/theme.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,KAAK,GAAG,EAAwC,MAAM,KAAK,CAAC;AAErE,qEAAqE;AACrE,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE1D,8DAA8D;AAC9D,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC;AA2B7C;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAKvC;AA+FD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,IAAI;IAC1B,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,eAAe,CAAC,CAAC;IACrC,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC;IACrD,QAAQ,CAAC,QAAQ,EAAE,CAAC,UAAU,EAAE,eAAe,KAAK,IAAI,CAAC;IACzD,QAAQ,CAAC,WAAW,EAAE,MAAM,IAAI,CAAC;CAClC,CA2CA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW,gQAInB,CAAC"}

package/dist/primitives/Accordion/Accordion.js

@@ -1,7 +0,0 @@
-import Accordion_vue_vue_type_script_setup_true_lang_default from "./Accordion.vue_vue_type_script_setup_true_lang.js";
-//#region src/primitives/Accordion/Accordion.vue
-var Accordion_default = Accordion_vue_vue_type_script_setup_true_lang_default;
-//#endregion
-export { Accordion_default as default };
-
-//# sourceMappingURL=Accordion.js.map

package/dist/primitives/Accordion/Accordion.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Accordion.js","names":[],"sources":["../../../src/primitives/Accordion/Accordion.vue"],"sourcesContent":["<script lang=\"ts\">\n/**\n * One collapsible section of the accordion. The list is data rather than markup\n * because the primitive stays free of structure logic — toggling a section emits\n * its `value` and the host decides what that open state means.\n */\nexport interface AccordionItem {\n  /** Unique key for the item. */\n  value: string;\n  /** The heading text shown on the trigger. */\n  label: string;\n  /** Inert: announced as disabled, and toggling it does nothing. */\n  disabled?: boolean;\n}\n\n/**\n * Whether the accordion allows one open item or many. The members mirror Reka's\n * own `AccordionType`, and the template binding is what enforces that.\n */\nexport type AccordionType = \"single\" | \"multiple\";\n\n/**\n * Vertical gap between items, tightening below the `sm` breakpoint where the\n * accordion is more likely inside a narrow panel.\n */\nexport type AccordionGap = \"sm\" | \"md\" | \"lg\";\n</script>\n\n<script setup lang=\"ts\">\nimport {\n  AccordionRoot,\n  AccordionItem as RekaAccordionItem,\n  AccordionTrigger,\n  AccordionContent,\n} from \"reka-ui\";\nimport { ChevronDown } from \"@lucide/vue\";\nimport { cn } from \"../../lib/cn\";\nimport { optional } from \"../../lib/props\";\n\n/**\n * Accordion — vertically stacked, expandable sections: each trigger reveals\n * its panel and collapses the rest (single mode) or lets several panels stay\n * open at once (multiple mode). Built on Reka UI's Accordion, which supplies\n * the `accordion`/`accordion-item`/`button`/`region` semantics and the\n * arrow-key navigation between triggers.\n *\n * Items are data rather than markup. A scoped default slot receives each item\n * so the host can render arbitrary content inside a panel — the primitive\n * owns the open/close mechanics and the trigger chrome, not what is inside the\n * panel.\n *\n * `collapsible` only matters in single mode: it governs whether the one open\n * item can be closed again. A non-collapsible single accordion always has\n * exactly one panel open. In multiple mode the prop is ignored — every item\n * can close independently.\n */\nwithDefaults(\n  defineProps<{\n    /** The sections, in order. Each needs a unique `value`. */\n    items: AccordionItem[];\n    /** Whether one or many items can be open at once. */\n    type?: AccordionType;\n    /** In single mode, whether the open item can be closed. Ignored in multiple mode. */\n    collapsible?: boolean;\n    /** Drive the open state from the host with `v-model`; omit it and the accordion owns its own state. */\n    modelValue?: string | string[] | undefined;\n    /** Vertical gap between items. */\n    gap?: AccordionGap;\n  }>(),\n  {\n    type: \"single\",\n    collapsible: true,\n    modelValue: undefined,\n    gap: \"md\",\n  },\n);\n\n// `modelValue: undefined` is load-bearing, not a redundant default — it is\n// what keeps the uncontrolled third state reachable past Vue's absent-Boolean\n// casting. `optional()` in the template is the other half; its docblock\n// carries the reasoning for both.\n\ndefineEmits<{ \"update:modelValue\": [value: string | string[]] }>();\n\nconst GAP_CLASSES: Record<AccordionGap, string> = {\n  sm: \"gap-1 sm:gap-2\",\n  md: \"gap-2 sm:gap-3\",\n  lg: \"gap-3 sm:gap-4\",\n};\n</script>\n\n<template>\n  <AccordionRoot\n    :type=\"type\"\n    :collapsible=\"collapsible\"\n    v-bind=\"optional({ modelValue })\"\n    :class=\"cn('flex flex-col', GAP_CLASSES[gap])\"\n    @update:model-value=\"$emit('update:modelValue', $event)\"\n  >\n    <RekaAccordionItem\n      v-for=\"item in items\"\n      :key=\"item.value\"\n      :value=\"item.value\"\n      :disabled=\"item.disabled ?? false\"\n      class=\"border-b border-border last:border-b-0\"\n    >\n      <AccordionTrigger\n        :class=\"\n          cn(\n            'flex items-center justify-between w-full px-4 py-3 text-sm font-medium text-foreground transition-colors duration-fast ease-out hover:bg-subtle rounded-md',\n            // A disabled trigger must still be reachable by arrow key, so the\n            // pointer is silenced but the element stays in the tab order.\n            'data-[disabled]:pointer-events-none data-[disabled]:text-muted-foreground',\n          )\n        \"\n      >\n        {{ item.label }}\n        <!-- The chevron rotates 180deg when the item opens, matching the\n             `data-[state=open]` attribute Reka sets on the trigger. A\n             transition rather than an animation, because the rotation has no\n             entrance/exit split — it just flips. -->\n        <ChevronDown\n          class=\"h-4 w-4 shrink-0 text-muted-foreground transition-transform duration-fast ease-out data-[state=open]:rotate-180\"\n        />\n      </AccordionTrigger>\n      <!-- Scoped to the open/closed state, never unconditional. Reka's\n           Presence keeps closed content mounted until an animationend arrives,\n           and a mount-only animation never fires a second one — so an\n           unconditional animation class strands invisible content over the\n           page. Scoped, the closed element computes `animation-name: none` and\n           Presence unmounts it at once.\n\n           The rise/fall pair is the existing vocabulary — a height animation\n           keyed to Reka's `--reka-accordion-content-height` would need its own\n           keyframe and utility registration, which belongs in `global.css` and\n           `theme.css` rather than in a single component. -->\n      <AccordionContent\n        class=\"overflow-hidden data-[state=closed]:animate-fade-fall data-[state=open]:animate-fade-rise\"\n      >\n        <div class=\"px-4 pb-3 text-sm text-muted-foreground\">\n          <!-- @slot The content of each panel. Receives the item as a slot prop. -->\n          <slot :item=\"item\" :index=\"items.indexOf(item)\" />\n        </div>\n      </AccordionContent>\n    </RekaAccordionItem>\n  </AccordionRoot>\n</template>\n"],"mappings":""}

package/dist/primitives/Accordion/Accordion.vue.d.ts

@@ -1,68 +0,0 @@
-/**
- * One collapsible section of the accordion. The list is data rather than markup
- * because the primitive stays free of structure logic — toggling a section emits
- * its `value` and the host decides what that open state means.
- */
-export interface AccordionItem {
-    /** Unique key for the item. */
-    value: string;
-    /** The heading text shown on the trigger. */
-    label: string;
-    /** Inert: announced as disabled, and toggling it does nothing. */
-    disabled?: boolean;
-}
-/**
- * Whether the accordion allows one open item or many. The members mirror Reka's
- * own `AccordionType`, and the template binding is what enforces that.
- */
-export type AccordionType = "single" | "multiple";
-/**
- * Vertical gap between items, tightening below the `sm` breakpoint where the
- * accordion is more likely inside a narrow panel.
- */
-export type AccordionGap = "sm" | "md" | "lg";
-declare const _default: typeof __VLS_export;
-export default _default;
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
-    /** The sections, in order. Each needs a unique `value`. */
-    items: AccordionItem[];
-    /** Whether one or many items can be open at once. */
-    type?: AccordionType;
-    /** In single mode, whether the open item can be closed. Ignored in multiple mode. */
-    collapsible?: boolean;
-    /** Drive the open state from the host with `v-model`; omit it and the accordion owns its own state. */
-    modelValue?: string | string[] | undefined;
-    /** Vertical gap between items. */
-    gap?: AccordionGap;
-}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: string | string[]) => any;
-}, string, import("vue").PublicProps, Readonly<{
-    /** The sections, in order. Each needs a unique `value`. */
-    items: AccordionItem[];
-    /** Whether one or many items can be open at once. */
-    type?: AccordionType;
-    /** In single mode, whether the open item can be closed. Ignored in multiple mode. */
-    collapsible?: boolean;
-    /** Drive the open state from the host with `v-model`; omit it and the accordion owns its own state. */
-    modelValue?: string | string[] | undefined;
-    /** Vertical gap between items. */
-    gap?: AccordionGap;
-}> & Readonly<{
-    "onUpdate:modelValue"?: (value: string | string[]) => any;
-}>, {
-    gap: AccordionGap;
-    modelValue: string | string[] | undefined;
-    type: AccordionType;
-    collapsible: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {
-        item: AccordionItem;
-        index: number;
-    }) => any;
-}>;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
-//# sourceMappingURL=Accordion.vue.d.ts.map

package/dist/primitives/Accordion/Accordion.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Accordion.vue.d.ts","sourceRoot":"","sources":["../../../src/primitives/Accordion/Accordion.vue"],"names":[],"mappings":"AAiKA;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,+BAA+B;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,UAAU,CAAC;AAElD;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;wBACzB,OAAO,YAAY;AAAxC,wBAAyC;AACzC,QAAA,MAAM,YAAY;IAmBd,2DAA2D;WACpD,aAAa,EAAE;IACtB,qDAAqD;WAC9C,aAAa;IACpB,qFAAqF;kBACvE,OAAO;IACrB,uGAAuG;iBAC1F,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAC1C,kCAAkC;UAC5B,YAAY;;;;IATlB,2DAA2D;WACpD,aAAa,EAAE;IACtB,qDAAqD;WAC9C,aAAa;IACpB,qFAAqF;kBACvE,OAAO;IACrB,uGAAuG;iBAC1F,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAC1C,kCAAkC;UAC5B,YAAY;;;;SAAZ,YAAY;gBAFL,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;UAJnC,aAAa;iBAEN,OAAO;;cAwMX,CAAC,KAAK;;;KAAiB,KAAK,GAAG;EAWzC,CAAC;AAWL,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KACV,CAAA;CACD,CAAC"}

package/dist/primitives/Accordion/Accordion.vue_vue_type_script_setup_true_lang.js

@@ -1,67 +0,0 @@
-import { cn } from "../../lib/cn.js";
-import { optional } from "../../lib/props.js";
-import { ChevronDown } from "@lucide/vue";
-import { Fragment, createBlock, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, mergeProps, normalizeClass, openBlock, renderList, renderSlot, toDisplayString, unref, withCtx } from "vue";
-import { AccordionContent, AccordionItem, AccordionRoot, AccordionTrigger } from "reka-ui";
-//#region src/primitives/Accordion/Accordion.vue?vue&type=script&setup=true&lang.ts
-var _hoisted_1 = { class: "px-4 pb-3 text-sm text-muted-foreground" };
-var Accordion_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
-	__name: "Accordion",
-	props: {
-		items: {},
-		type: { default: "single" },
-		collapsible: {
-			type: Boolean,
-			default: true
-		},
-		modelValue: { default: void 0 },
-		gap: { default: "md" }
-	},
-	emits: ["update:modelValue"],
-	setup(__props) {
-		const GAP_CLASSES = {
-			sm: "gap-1 sm:gap-2",
-			md: "gap-2 sm:gap-3",
-			lg: "gap-3 sm:gap-4"
-		};
-		return (_ctx, _cache) => {
-			return openBlock(), createBlock(unref(AccordionRoot), mergeProps({
-				type: __props.type,
-				collapsible: __props.collapsible
-			}, unref(optional)({ modelValue: __props.modelValue }), {
-				class: unref(cn)("flex flex-col", GAP_CLASSES[__props.gap]),
-				"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.$emit("update:modelValue", $event))
-			}), {
-				default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.items, (item) => {
-					return openBlock(), createBlock(unref(AccordionItem), {
-						key: item.value,
-						value: item.value,
-						disabled: item.disabled ?? false,
-						class: "border-b border-border last:border-b-0"
-					}, {
-						default: withCtx(() => [createVNode(unref(AccordionTrigger), { class: normalizeClass(unref(cn)("flex items-center justify-between w-full px-4 py-3 text-sm font-medium text-foreground transition-colors duration-fast ease-out hover:bg-subtle rounded-md", "data-[disabled]:pointer-events-none data-[disabled]:text-muted-foreground")) }, {
-							default: withCtx(() => [createTextVNode(toDisplayString(item.label) + " ", 1), createVNode(unref(ChevronDown), { class: "h-4 w-4 shrink-0 text-muted-foreground transition-transform duration-fast ease-out data-[state=open]:rotate-180" })]),
-							_: 2
-						}, 1032, ["class"]), createVNode(unref(AccordionContent), { class: "overflow-hidden data-[state=closed]:animate-fade-fall data-[state=open]:animate-fade-rise" }, {
-							default: withCtx(() => [createElementVNode("div", _hoisted_1, [renderSlot(_ctx.$slots, "default", {
-								item,
-								index: __props.items.indexOf(item)
-							})])]),
-							_: 2
-						}, 1024)]),
-						_: 2
-					}, 1032, ["value", "disabled"]);
-				}), 128))]),
-				_: 3
-			}, 16, [
-				"type",
-				"collapsible",
-				"class"
-			]);
-		};
-	}
-});
-//#endregion
-export { Accordion_vue_vue_type_script_setup_true_lang_default as default };
-
-//# sourceMappingURL=Accordion.vue_vue_type_script_setup_true_lang.js.map