liminal 0.5.1 → 0.5.3

package/types/TypeVisitor.ts

@@ -1,49 +0,0 @@
-import type { Type } from "./Type.ts"
-import { type IntrinsicTypes, typeName } from "./type_common.ts"
-
-export type VisitorArms<S, R> =
-  & {
-    hook?: (
-      next: (state: S, type: Type) => R,
-      state: S,
-      type: Type,
-    ) => R
-  }
-  & (
-    | (
-      & IntrinsicVisitorArms<S, R>
-      & { fallback?: never }
-    )
-    | (
-      & Partial<IntrinsicVisitorArms<S, R>>
-      & { fallback: () => R }
-    )
-  )
-
-export type IntrinsicVisitorArms<S, R> = {
-  [K in keyof IntrinsicTypes]: (
-    state: S,
-    ...args: IntrinsicTypes[K] extends Type ? [IntrinsicTypes[K]]
-      : IntrinsicTypes[K] extends (...args: infer A) => infer T ? [T, ...A]
-      : never
-  ) => R
-}
-
-export type TypeVisitor<S, R> = (state: S, type: Type) => R
-
-export function TypeVisitor<S, R>(arms: VisitorArms<S, R>): (state: S, type: Type) => R {
-  const { hook } = arms
-  if (hook) {
-    return (state, type) => hook(next, state, type)
-  }
-
-  return next
-
-  function next(state: S, type: Type): R {
-    return (arms[typeName(type)] as any ?? arms.fallback)(
-      state,
-      type,
-      ...(type.args ?? []),
-    )
-  }
-}

package/types/array.ts

@@ -1,20 +0,0 @@
-import { declareType } from "./declareType.ts"
-import type { JSONType } from "./JSONType.ts"
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import type { Type } from "./Type.ts"
-import { normalizeTypeLike, type NormalizeTypeLikeJ, type NormalizeTypeLikeT, type TypeLike } from "./TypeLike.ts"
-
-export function array<const F extends TypeLike>(
-  element: F,
-): Type<Array<NormalizeTypeLikeT<F>>, JSONArrayType<NormalizeTypeLikeJ<F>>> {
-  return _array(normalizeTypeLike(element)) as never
-}
-
-export function _array(element: Type): Type {
-  return declareType(() => _array, [element])
-}
-
-export interface JSONArrayType<E extends JSONType = any> extends JSONTypeBase {
-  type: "array"
-  items: E
-}

package/types/boolean.ts

@@ -1,9 +0,0 @@
-import { declareType } from "./declareType.ts"
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import type { Type } from "./Type.ts"
-
-export const boolean: Type<boolean, JSONBooleanType> = declareType(() => boolean)
-
-export interface JSONBooleanType extends JSONTypeBase {
-  type: "boolean"
-}

package/types/const.ts

@@ -1,17 +0,0 @@
-import type { JSONValue } from "../util/JSONValue.ts"
-import { declareType } from "./declareType.ts"
-import type { ConstableType } from "./JSONType.ts"
-import type { Type } from "./Type.ts"
-
-function const_<T extends JSONValue, J extends ConstableType, const V extends T>(
-  type: Type<T, J>,
-  value: V,
-): Type<V, JSONConstType<J, V>> {
-  return declareType(() => const_<T, J, V>, [type, value])
-}
-Object.defineProperty(const_, "name", { value: "const" })
-export { const_ as const }
-
-export type JSONConstType<J extends ConstableType = any, V extends JSONValue = JSONValue> = J & {
-  const: V
-}

package/types/declareType.ts

@@ -1,71 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import { infer } from "../actions/infer.ts"
-import { LiminalAssertionError } from "../LiminalAssertionError.ts"
-import type { Falsy } from "../util/Falsy.ts"
-import { applyTemplateWithIndentation } from "../util/fixTemplateStrings.ts"
-import { isTemplateStringsArray } from "../util/isTemplateStringsArray.ts"
-import type { JSONObject } from "../util/JSONObject.ts"
-import { AssertDiagnostics, formatAssertDiagnostics } from "./AssertDiagnostics.ts"
-import type { JSONObjectType } from "./object.ts"
-import { toJSON } from "./toJSON.ts"
-import { type Type, TypeKey, type TypeMembers } from "./Type.ts"
-
-export function declareType<X extends Type>(
-  declaration: () => X | ((...args: any) => X),
-  args?: Array<unknown>,
-  descriptions: Array<string> = [],
-): X {
-  const type = Object.assign(
-    Type,
-    {
-      [TypeKey]: true,
-      declaration,
-      args,
-      descriptions,
-      description() {
-        return descriptions.join("\n")
-      },
-      "~standard": {
-        vendor: "liminal",
-        version: 1,
-        validate: (value) => {
-          const diagnostics = AssertDiagnostics({}, type as never, value)
-          if (diagnostics.length) {
-            return {
-              issues: diagnostics.map(({ path, error }): StandardSchemaV1.Issue => ({
-                path,
-                message: JSON.stringify(error),
-              })),
-            }
-          }
-          return { value: value as X["T"] }
-        },
-      },
-      toJSON,
-      assert: (value) => {
-        const diagnostics = AssertDiagnostics({}, type as never, value)
-        if (diagnostics.length) {
-          throw new LiminalAssertionError(formatAssertDiagnostics(diagnostics))
-        }
-        return value as never
-      },
-      ...{
-        *[Symbol.iterator](this: Type<JSONObject, JSONObjectType>) {
-          return yield* infer(this)
-        },
-      },
-    } satisfies TypeMembers<X["T"], X["J"]>,
-  ) as never as X
-  return type
-
-  function Type(template: TemplateStringsArray, ...substitutions: Array<string>): X
-  function Type(...values: Array<Falsy | string>): X
-  function Type(e0: TemplateStringsArray | Falsy | string, ...eRest: Array<Falsy | string>): X {
-    return declareType(declaration, args, [
-      ...descriptions,
-      ...isTemplateStringsArray(e0)
-        ? [applyTemplateWithIndentation(e0, ...eRest)]
-        : [e0, ...eRest].filter((v): v is string => !!v),
-    ])
-  }
-}

package/types/enum.ts

@@ -1,14 +0,0 @@
-import { declareType } from "./declareType.ts"
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import type { Type } from "./Type.ts"
-
-export { enum_ as enum }
-function enum_<A extends Array<string>>(...values: A): Type<A[number], JSONEnumType<A[number]>> {
-  return declareType(() => enum_<A>, values)
-}
-Object.defineProperty(enum_, "name", { value: "enum" })
-
-export interface JSONEnumType<K extends string = string> extends JSONTypeBase {
-  type: "string"
-  enum: Array<K>
-}

package/types/factories.ts

@@ -1,8 +0,0 @@
-export { array } from "./array.ts"
-export { boolean, const, enum, integer, null, number, ref, string } from "./intrinsics.ts"
-export { MetatypeDescriptor, MetatypeRootDescriptor } from "./Metatype/MetatypeDescriptor.ts"
-export { object } from "./object.ts"
-export { option } from "./types_derived/option.ts"
-export { taggedUnion } from "./types_derived/taggedUnion.ts"
-export { wrapper } from "./types_derived/wrapper.ts"
-export { union } from "./union.ts"

package/types/index.ts

@@ -1,2 +0,0 @@
-export * from "./factories.ts"
-export * from "./non_factories.ts"

package/types/integer.ts

@@ -1,9 +0,0 @@
-import { declareType } from "./declareType.ts"
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import type { Type } from "./Type.ts"
-
-export const integer: Type<number, JSONIntegerType> = declareType(() => integer)
-
-export interface JSONIntegerType extends JSONTypeBase {
-  type: "integer"
-}

package/types/intrinsics.ts

@@ -1,11 +0,0 @@
-export { _array } from "./array.ts"
-export { boolean } from "./boolean.ts"
-export { const } from "./const.ts"
-export { enum } from "./enum.ts"
-export { integer } from "./integer.ts"
-export { null } from "./null.ts"
-export { number } from "./number.ts"
-export { _object } from "./object.ts"
-export { ref } from "./ref.ts"
-export { string } from "./string.ts"
-export { _union } from "./union.ts"

package/types/match.ts

@@ -1,13 +0,0 @@
-import type { JSONValue } from "../util/JSONValue.ts"
-import { AssertDiagnostics } from "./AssertDiagnostics.ts"
-import type { Type } from "./Type.ts"
-
-export function match(value: JSONValue, members: Array<Type>): Type | undefined {
-  for (const member of members) {
-    const diagnostics = AssertDiagnostics({}, member, value)
-    if (!diagnostics.length) {
-      return member
-    }
-  }
-  return
-}

package/types/non_factories.ts

@@ -1,26 +0,0 @@
-export type { JSONArrayType } from "./array.ts"
-export type { JSONBooleanType } from "./boolean.ts"
-export type { JSONConstType } from "./const.ts"
-export type { JSONEnumType } from "./enum.ts"
-export type { JSONIntegerType } from "./integer.ts"
-export * from "./JSONRootType.ts"
-export * from "./JSONType.ts"
-export { match } from "./match.ts"
-export * from "./Metatype/fromMetatypeDescriptor.ts"
-export type { MetatypeDescriptor, MetatypeRootDescriptor } from "./Metatype/MetatypeDescriptor.ts"
-export type { JSONNullType } from "./null.ts"
-export type { JSONNumberType } from "./number.ts"
-export type {
-  JSONObjectType,
-  ObjectFields as _ObjectFields,
-  RecordFields as _RecordFields,
-  TupleFields as _TupleFields,
-} from "./object.ts"
-export type { JSONRefType } from "./ref.ts"
-export type { JSONStringType } from "./string.ts"
-export * from "./Type.ts"
-export * from "./TypeContext.ts"
-export * from "./TypeLike.ts"
-export type { TaggedUnionMembers } from "./types_derived/taggedUnion.ts"
-export * from "./TypeVisitor.ts"
-export type { JSONUnionType } from "./union.ts"

package/types/null.ts

@@ -1,10 +0,0 @@
-import { declareType } from "./declareType.ts"
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import type { Type } from "./Type.ts"
-
-const null_: Type<null, JSONNullType> = declareType(() => null_)
-export { null_ as null }
-
-export interface JSONNullType extends JSONTypeBase {
-  type: "null"
-}

package/types/number.ts

@@ -1,9 +0,0 @@
-import { declareType } from "./declareType.ts"
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import type { Type } from "./Type.ts"
-
-export const number: Type<number, JSONNumberType> = declareType(() => number)
-
-export interface JSONNumberType extends JSONTypeBase {
-  type: "number"
-}

package/types/object.ts

@@ -1,27 +0,0 @@
-import type { JSONKey } from "../util/JSONKey.ts"
-import { declareType } from "./declareType.ts"
-import type { JSONType } from "./JSONType.ts"
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import { type Type } from "./Type.ts"
-import { normalizeTypeLikes, type NormalizeTypeLikesJ, type NormalizeTypeLikesT, type TypeLikes } from "./TypeLike.ts"
-
-export function object<const F extends TypeLikes>(
-  fields: F,
-): Type<NormalizeTypeLikesT<F>, JSONObjectType<NormalizeTypeLikesJ<F>>> {
-  return normalizeTypeLikes(fields) as never
-}
-
-export function _object(fields: ObjectFields): Type {
-  return declareType(() => _object, [fields])
-}
-
-export interface JSONObjectType<F extends Record<JSONKey, JSONType> = any> extends JSONTypeBase {
-  type: "object"
-  properties: F
-  required: Array<keyof F>
-  additionalProperties: false
-}
-
-export type ObjectFields = TupleFields | RecordFields
-export type TupleFields = Array<Type>
-export type RecordFields = Record<JSONKey, Type>

package/types/ref.ts

@@ -1,12 +0,0 @@
-import type { JSONValue } from "../util/JSONValue.ts"
-import { declareType } from "./declareType.ts"
-import type { ConstableType } from "./JSONType.ts"
-import type { Type } from "./Type.ts"
-
-export function ref<T extends JSONValue, J extends ConstableType>(getType: () => Type<T, J>): Type<T, JSONRefType> {
-  return declareType(() => ref<T, J>, [getType])
-}
-
-export interface JSONRefType {
-  $ref: string
-}

package/types/string.ts

@@ -1,9 +0,0 @@
-import { declareType } from "./declareType.ts"
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import type { Type } from "./Type.ts"
-
-export const string: Type<string, JSONStringType> = declareType(() => string)
-
-export interface JSONStringType extends JSONTypeBase {
-  type: "string"
-}

package/types/toJSON.ts

@@ -1,111 +0,0 @@
-import type { JSONValue } from "../util/JSONValue.ts"
-import type { JSONArrayType } from "./array.ts"
-import type { JSONBooleanType } from "./boolean.ts"
-import { type JSONConstType } from "./const.ts"
-import type { JSONEnumType } from "./enum.ts"
-import type { JSONIntegerType } from "./integer.ts"
-import type { JSONRootType } from "./JSONRootType.ts"
-import { JSONSchema$schema } from "./JSONRootType.ts"
-import type { JSONRootableType, JSONType } from "./JSONType"
-import type { JSONNullType } from "./null.ts"
-import type { JSONNumberType } from "./number.ts"
-import { _object, type JSONObjectType } from "./object.ts"
-import { type JSONStringType } from "./string.ts"
-import { type Type } from "./Type.ts"
-import { PARENT_TYPE_NAMES, typeName } from "./type_common.ts"
-import { TypeContext } from "./TypeContext.ts"
-import { TypeVisitor } from "./TypeVisitor.ts"
-import type { JSONUnionType } from "./union.ts"
-
-export function toJSON<T extends JSONValue, J extends JSONRootableType>(this: Type<T, J>): JSONRootType<J> {
-  const { $defs: { 0: root, ...$defs } } = new ToJSONState(this)
-  return {
-    $schema: JSONSchema$schema,
-    ...root,
-    $defs,
-  } as never
-}
-
-class ToJSONState extends TypeContext {
-  readonly $defs: Record<string, JSONType | undefined> = {}
-  constructor(root: Type) {
-    super(root)
-    visit(this, root)
-  }
-}
-
-const visit: TypeVisitor<ToJSONState, JSONType> = TypeVisitor({
-  hook(next, state, type) {
-    const which = typeName(type)
-    if (PARENT_TYPE_NAMES[which]) {
-      const id = state.id(type)
-      if (!(id in state.$defs)) {
-        state.$defs[id] = undefined
-        state.$defs[id] = next(state, type)
-      }
-      return type === state.root ? { $ref: "$" } : { $ref: `#/$defs/${id}` }
-    }
-    if (which === "ref") {
-      if (state.ids.has(type)) {
-        const getType = type.args?.[0] as () => Type
-        return { $ref: `#/$defs/${state.id(getType())}` }
-      }
-      state.id(type)
-      return next(state, type)
-    }
-    return next(state, type)
-  },
-  null(): JSONNullType {
-    return { type: "null" }
-  },
-  boolean(): JSONBooleanType {
-    return { type: "boolean" }
-  },
-  integer(): JSONIntegerType {
-    return { type: "integer" }
-  },
-  number(): JSONNumberType {
-    return { type: "number" }
-  },
-  string(): JSONStringType {
-    return { type: "string" }
-  },
-  const(state, _type, valueType, value): JSONConstType {
-    return {
-      ...visit(state, valueType),
-      const: value,
-    } as never
-  },
-  _array(state, _type, element): JSONArrayType {
-    return {
-      type: "array",
-      items: visit(state, element),
-    }
-  },
-  enum(_state, _type, ...values): JSONEnumType {
-    return {
-      type: "string",
-      enum: values,
-    }
-  },
-  _union(state, _type, ...members): JSONUnionType {
-    return {
-      anyOf: members.map((m) => visit(state, m)),
-    }
-  },
-  _object(state, _type, fields): JSONObjectType {
-    return {
-      type: "object",
-      properties: Object.fromEntries(
-        Array.isArray(fields)
-          ? fields.map((v, i) => [i, visit(state, v)])
-          : Object.entries(fields).map(([k, v]) => [k, visit(state, v)]),
-      ),
-      required: Object.keys(fields),
-      additionalProperties: false,
-    }
-  },
-  ref(state, _type, getType) {
-    return visit(state, getType())
-  },
-})

package/types/type_common.ts

@@ -1,21 +0,0 @@
-import { nullaryMemo } from "../util/nullaryMemo.ts"
-import * as I from "./intrinsics.ts"
-import type { Type } from "./Type.ts"
-
-export type IntrinsicTypes = typeof I
-export type IntrinsicTypeName = keyof IntrinsicTypes
-export type IntrinsicType = IntrinsicTypes[IntrinsicTypeName]
-
-export const getIntrinsicNameLookup = nullaryMemo(() =>
-  new Map(Object.entries(I).map((entry) => entry.reverse() as [IntrinsicType, keyof IntrinsicTypes]))
-)
-
-export function typeName(type: Type): IntrinsicTypeName {
-  return getIntrinsicNameLookup().get(type.declaration() as IntrinsicType)!
-}
-
-export const PARENT_TYPE_NAMES: { [K in IntrinsicTypeName]?: true } = {
-  _object: true,
-  _array: true,
-  _union: true,
-}

package/types/types_derived/option.ts

@@ -1,10 +0,0 @@
-import { type JSONNullType, null as null_ } from "../null.ts"
-import type { Type } from "../Type.ts"
-import type { NormalizeTypeLikeJ, NormalizeTypeLikeT, TypeLike } from "../TypeLike.ts"
-import { _union, type JSONUnionType, union } from "../union.ts"
-
-export function option<const X extends TypeLike>(
-  of: X,
-): Type<null | NormalizeTypeLikeT<X>, JSONUnionType<JSONNullType | NormalizeTypeLikeJ<X>>> {
-  return union(null_, of)
-}

package/types/types_derived/taggedUnion.ts

@@ -1,30 +0,0 @@
-import type { JSONKey } from "../../util/JSONKey.ts"
-import type { JSONConstType } from "../const.ts"
-import { type JSONObjectType, object } from "../object.ts"
-import type { JSONStringType } from "../string.ts"
-import { type Type } from "../Type.ts"
-import { type NormalizeTypeLikeJ, type NormalizeTypeLikeT, type TypeLike } from "../TypeLike.ts"
-import { _union, type JSONUnionType, union } from "../union.ts"
-
-export function taggedUnion<const M extends TaggedUnionMembers, K extends Extract<keyof M, string>>(members: M): Type<
-  {
-    [L in K]: {
-      type: L
-      value: NormalizeTypeLikeT<M[L]>
-    }
-  }[K],
-  JSONUnionType<
-    {
-      [L in K]: JSONObjectType<{
-        type: JSONConstType<JSONStringType, L>
-        value: NormalizeTypeLikeJ<M[L]>
-      }>
-    }[K]
-  >
-> {
-  return union(
-    ...Object.entries(members).map(([type, value]) => object({ type, value })),
-  ) as never
-}
-
-export type TaggedUnionMembers = Record<JSONKey, TypeLike>

package/types/types_derived/wrapper.ts

@@ -1,10 +0,0 @@
-import { type JSONObjectType, object } from "../object.ts"
-import type { Type } from "../Type.ts"
-import type { NormalizeTypeLikeJ, NormalizeTypeLikeT, TypeLike } from "../TypeLike.ts"
-
-export function wrapper<X extends TypeLike>(value: X): Type<
-  { value: NormalizeTypeLikeT<X> },
-  JSONObjectType<{ value: NormalizeTypeLikeJ<X> }>
-> {
-  return object({ value }) as never
-}

package/types/union.ts

@@ -1,19 +0,0 @@
-import { declareType } from "./declareType.ts"
-import type { JSONType } from "./JSONType.ts"
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import type { Type } from "./Type.ts"
-import { normalizeTypeLike, type NormalizeTypeLikeJ, type NormalizeTypeLikeT, type TypeLike } from "./TypeLike.ts"
-
-export function union<const M extends Array<TypeLike>>(
-  ...members: M
-): Type<NormalizeTypeLikeT<M[number]>, JSONUnionType<NormalizeTypeLikeJ<M[number]>>> {
-  return _union(...members.map(normalizeTypeLike)) as never
-}
-
-export function _union(...members: Array<Type>): Type {
-  return declareType(() => _union, members)
-}
-
-export interface JSONUnionType<M extends JSONType = any> extends JSONTypeBase {
-  anyOf: Array<M>
-}

package/util/ArrayOfLength.ts

@@ -1,5 +0,0 @@
-export type ArrayOfLength<
-  T,
-  L extends number,
-  A extends Array<T> = [],
-> = number extends L ? Array<T> : L extends A["length"] ? A : ArrayOfLength<T, L, [...A, T]>

package/util/DeferredOr.ts

@@ -1 +0,0 @@
-export type DeferredOr<T> = T | (() => T)

package/util/EnsureNarrow.ts

@@ -1,5 +0,0 @@
-export type EnsureNarrow<V> = unknown extends V ? [error: typeof WIDENING_TYPE_DISALLOWED]
-  : [V] extends [never] ? [error: typeof WIDENING_TYPE_DISALLOWED]
-  : []
-
-export declare const WIDENING_TYPE_DISALLOWED: unique symbol

package/util/EnsureRecord.ts

@@ -1,3 +0,0 @@
-import type { TupleToRecord } from "./TupleToRecord.ts"
-
-export type EnsureRecord<T> = T extends Array<any> ? TupleToRecord<T> : T

package/util/Expand.ts

@@ -1 +0,0 @@
-export type Expand<T> = T extends T ? { [K in keyof T]: T[K] } : never

package/util/Falsy.ts

@@ -1 +0,0 @@
-export type Falsy = false | 0 | 0n | "" | null | undefined

package/util/FromEntries.ts

@@ -1,3 +0,0 @@
-export type FromEntries<E extends [keyof any, any]> = {
-  [K in E[0]]: Extract<E, [K, any]> extends [K, infer V] ? V : never
-}

package/util/IteratorLike.ts

@@ -1 +0,0 @@
-export type IteratorLike<Y = any, O = any> = Iterator<Y, O> | AsyncIterator<Y, O>

package/util/JSONEntry.ts

@@ -1,3 +0,0 @@
-import type { JSONKey } from "./JSONKey.ts"
-
-export type JSONEntry<V = any> = [JSONKey, V]

package/util/JSONKey.ts

@@ -1 +0,0 @@
-export type JSONKey = number | string

package/util/JSONObject.ts

@@ -1,6 +0,0 @@
-import type { JSONKey } from "./JSONKey.ts"
-import type { JSONValue } from "./JSONValue.ts"
-
-export type JSONObject = {
-  [value: JSONKey]: JSONValue
-}

package/util/JSONSchemaMemo.ts

@@ -1,15 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import { toJSONSchema } from "standard-json-schema"
-import { isType } from "../types/Type.ts"
-
-const memo = new WeakMap<StandardSchemaV1, Promise<object>>()
-
-export function JSONSchemaMemo(type: StandardSchemaV1): Promise<object> {
-  let pending = memo.get(type)
-  if (pending) {
-    return pending
-  }
-  pending = isType(type) ? Promise.resolve(type.toJSON()) : toJSONSchema(type)
-  memo.set(type, pending)
-  return pending
-}

package/util/JSONValue.ts

@@ -1,3 +0,0 @@
-import type { JSONObject } from "./JSONObject.ts"
-
-export type JSONValue = null | boolean | number | string | Array<JSONValue> | JSONObject

package/util/PromiseOr.ts

@@ -1 +0,0 @@
-export type PromiseOr<T> = T | Promise<T>

package/util/Result.ts

@@ -1,7 +0,0 @@
-export type Result<T, E> = {
-  value: T
-  thrown?: never
-} | {
-  value?: never
-  thrown: E
-}

package/util/Taggable.ts

@@ -1,18 +0,0 @@
-import { applyTemplateWithIndentation } from "./fixTemplateStrings.ts"
-import { isTemplateStringsArray } from "./isTemplateStringsArray.ts"
-
-export interface Taggable<A extends Array<any>> {
-  (template: TemplateStringsArray, ...substitutions: Array<string>): this
-  (...values: A): this
-}
-
-export type TaggableArgs<A extends Array<any>> = A | [
-  raw: TemplateStringsArray,
-  ...substitutions: Array<string>,
-]
-
-export function normalizeTaggableArgs<A extends Array<unknown>>(...[e0, ...eRest]: TaggableArgs<A>) {
-  return isTemplateStringsArray(e0)
-    ? [applyTemplateWithIndentation(e0, ...eRest)] as [string]
-    : [e0, ...eRest] as A
-}