effect-start 0.28.0 → 0.29.0

package/src/cli/Flag.ts

@@ -0,0 +1,63 @@
+import * as Function from "effect/Function"
+import type * as Redacted from "effect/Redacted"
+import * as Param from "./Param.ts"
+import * as Primitive from "./Primitive.ts"
+
+export interface Flag<A> extends Param.Param<"flag", A> {}
+
+const flagMake = Param.makeConstructor("flag")
+
+export const string = (name: string): Flag<string> => flagMake(name, Primitive.string)
+export const boolean = (name: string): Flag<boolean> => flagMake(name, Primitive.boolean)
+export const integer = (name: string): Flag<number> => flagMake(name, Primitive.integer)
+export const float = (name: string): Flag<number> => flagMake(name, Primitive.float)
+export const date = (name: string): Flag<Date> => flagMake(name, Primitive.date)
+export const redacted = (name: string): Flag<Redacted.Redacted<string>> =>
+  flagMake(name, Primitive.redacted)
+export const choice = <const C extends ReadonlyArray<string>>(
+  name: string,
+  choices: C,
+): Flag<C[number]> =>
+  Param.makeSingleParam({
+    kind: "flag",
+    name,
+    primitiveType: Primitive.choice(choices.map((v) => [v, v] as const)),
+  })
+export const choiceWithValue = <const C extends ReadonlyArray<readonly [string, any]>>(
+  name: string,
+  choices: C,
+): Flag<C[number][1]> =>
+  Param.makeSingleParam({ kind: "flag", name, primitiveType: Primitive.choice(choices) })
+export const keyValuePair = (name: string): Flag<Record<string, string>> =>
+  Param.paramMap(
+    Param.paramVariadic(
+      Param.makeSingleParam({ kind: "flag", name, primitiveType: Primitive.keyValuePair }),
+      { min: 1 },
+    ),
+    (objs) => Object.assign({}, ...objs),
+  ) as Flag<Record<string, string>>
+export const none: Flag<never> = Param.makeSingleParam({
+  kind: "flag",
+  name: "__none__",
+  primitiveType: Primitive.none,
+}) as Flag<never>
+
+export const withAlias: {
+  (alias: string): <A>(self: Flag<A>) => Flag<A>
+  <A>(self: Flag<A>, alias: string): Flag<A>
+} = Function.dual(
+  2,
+  <A>(self: Flag<A>, alias: string): Flag<A> => Param.paramWithAlias(self, alias),
+)
+
+const combinators = Param.makeParamCombinators("flag")
+export const optional = combinators.optional
+export const withDefault = combinators.withDefault
+export const withDescription = combinators.withDescription
+export const withMetavar = combinators.withMetavar
+export const map = combinators.map
+export const mapEffect = combinators.mapEffect
+export const variadic = combinators.variadic
+export const filter = combinators.filter
+export const withSchema = combinators.withSchema
+export const orElse = combinators.orElse

package/src/cli/HelpDoc.ts

@@ -0,0 +1,67 @@
+export interface HelpDoc {
+  readonly description: string
+  readonly usage: string
+  readonly flags: ReadonlyArray<FlagDoc>
+  readonly args?: ReadonlyArray<ArgDoc>
+  readonly subcommands?: ReadonlyArray<SubcommandDoc>
+}
+
+export interface FlagDoc {
+  readonly name: string
+  readonly aliases: ReadonlyArray<string>
+  readonly type: string
+  readonly description: string | undefined
+  readonly required: boolean
+}
+
+export interface SubcommandDoc {
+  readonly name: string
+  readonly description: string
+}
+
+export interface ArgDoc {
+  readonly name: string
+  readonly type: string
+  readonly description: string | undefined
+  readonly required: boolean
+  readonly variadic: boolean
+}
+
+export const formatHelpDoc = (doc: HelpDoc): string => {
+  const sections: Array<string> = []
+  if (doc.description) {
+    sections.push("DESCRIPTION")
+    sections.push(`  ${doc.description}`)
+    sections.push("")
+  }
+  sections.push("USAGE")
+  sections.push(`  ${doc.usage}`)
+  sections.push("")
+  if (doc.args && doc.args.length > 0) {
+    sections.push("ARGUMENTS")
+    for (const a of doc.args) {
+      let n = a.name + (a.variadic ? "..." : "")
+      const opt = a.required ? "" : " (optional)"
+      sections.push(`  ${n} ${a.type}    ${(a.description ?? "") + opt}`)
+    }
+    sections.push("")
+  }
+  if (doc.flags.length > 0) {
+    sections.push("FLAGS")
+    for (const f of doc.flags) {
+      const names = [`--${f.name}`, ...f.aliases].join(", ")
+      const tp = f.type !== "boolean" ? ` ${f.type}` : ""
+      sections.push(`  ${names}${tp}    ${f.description ?? ""}`)
+    }
+    sections.push("")
+  }
+  if (doc.subcommands && doc.subcommands.length > 0) {
+    sections.push("SUBCOMMANDS")
+    for (const s of doc.subcommands) sections.push(`  ${s.name}    ${s.description}`)
+    sections.push("")
+  }
+  if (sections[sections.length - 1] === "") sections.pop()
+  return sections.join("\n")
+}
+
+export const formatVersion = (name: string, version: string): string => `${name} v${version}`

package/src/cli/Param.ts

@@ -0,0 +1,418 @@
+import * as Effect from "effect/Effect"
+import * as Function from "effect/Function"
+import * as Option from "effect/Option"
+import * as Pipeable from "effect/Pipeable"
+import * as Schema from "effect/Schema"
+import * as CliError from "./CliError.ts"
+import * as Primitive from "./Primitive.ts"
+
+export type ParamKind = "argument" | "flag"
+
+export interface Param<Kind extends ParamKind, out A> extends Pipeable.Pipeable {
+  readonly _tag: string
+  readonly kind: Kind
+  readonly parse: ParamParse<A>
+}
+
+export type ParamParse<A> = (
+  args: ParsedArgs,
+) => Effect.Effect<readonly [leftover: ReadonlyArray<string>, value: A], CliError.CliError>
+
+export interface ParsedArgs {
+  readonly flags: Record<string, ReadonlyArray<string>>
+  readonly arguments: ReadonlyArray<string>
+}
+
+export interface SingleParam<Kind extends ParamKind, out A> extends Param<Kind, A> {
+  readonly _tag: "Single"
+  readonly name: string
+  readonly description: string | undefined
+  readonly aliases: ReadonlyArray<string>
+  readonly primitiveType: Primitive.Primitive<A>
+  readonly typeName?: string | undefined
+}
+
+const ParamProto = {
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments)
+  },
+}
+
+export const isParam = (u: unknown): u is Param<any, any> =>
+  typeof u === "object" && u !== null && "_tag" in u && "kind" in u && "parse" in u
+
+export const isFlagParam = <A>(s: SingleParam<ParamKind, A>): s is SingleParam<"flag", A> =>
+  s.kind === "flag"
+
+export const makeSingleParam = <Kind extends ParamKind, A>(opts: {
+  kind: Kind
+  name: string
+  primitiveType: Primitive.Primitive<A>
+  typeName?: string
+  description?: string
+  aliases?: ReadonlyArray<string>
+}): SingleParam<Kind, A> => {
+  const parse: ParamParse<A> = (args) =>
+    opts.kind === "argument"
+      ? parsePositional(opts.name, opts.primitiveType, args)
+      : parseFlag(opts.name, opts.primitiveType, args)
+  return Object.assign(Object.create(ParamProto), {
+    _tag: "Single",
+    ...opts,
+    description: opts.description,
+    aliases: opts.aliases ?? [],
+    parse,
+  })
+}
+
+export const extractSingleParams = <K extends ParamKind>(
+  p: Param<K, any>,
+): Array<SingleParam<K, any>> => {
+  if (p._tag === "Single") return [p as SingleParam<K, any>]
+  if ("param" in p) return extractSingleParams((p as any).param)
+  return []
+}
+
+export const getUnderlyingSingle = <K extends ParamKind>(p: Param<K, any>): SingleParam<K, any> => {
+  const singles = extractSingleParams(p)
+  if (singles.length !== 1)
+    throw new Error(`Expected exactly one Single param, got ${singles.length}`)
+  return singles[0]
+}
+
+export const getParamMetadata = (
+  p: Param<any, any>,
+): { isOptional: boolean; isVariadic: boolean } => {
+  if (p._tag === "Optional") return { ...getParamMetadata((p as any).param), isOptional: true }
+  if (p._tag === "Variadic") return { ...getParamMetadata((p as any).param), isVariadic: true }
+  if ("param" in p) return getParamMetadata((p as any).param)
+  return { isOptional: false, isVariadic: false }
+}
+
+export const transformSingle = <K extends ParamKind, A>(
+  p: Param<K, A>,
+  f: <X>(s: SingleParam<K, X>) => SingleParam<K, X>,
+): Param<K, A> => {
+  if (p._tag === "Single") return f(p as SingleParam<K, any>) as Param<K, A>
+  if (p._tag === "Map") {
+    const m = p as any
+    return paramMap(transformSingle(m.param, f), m.f)
+  }
+  if (p._tag === "Transform") {
+    const t = p as any
+    return paramTransform(transformSingle(t.param, f), t.f)
+  }
+  if (p._tag === "Optional") {
+    const o = p as any
+    return paramOptional(transformSingle(o.param, f)) as Param<K, A>
+  }
+  if (p._tag === "Variadic") {
+    const v = p as any
+    return paramVariadic(transformSingle(v.param, f), { min: v.min, max: v.max }) as Param<K, A>
+  }
+  return p
+}
+
+const parsePositional = <A>(
+  name: string,
+  prim: Primitive.Primitive<A>,
+  args: ParsedArgs,
+): Effect.Effect<readonly [ReadonlyArray<string>, A], CliError.CliError> =>
+  Effect.gen(function* () {
+    if (args.arguments.length === 0)
+      return yield* Effect.fail(
+        new CliError.CliError({ reason: "MissingArgument", argument: name }),
+      )
+    const value = yield* Effect.mapError(
+      prim.parse(args.arguments[0]),
+      (error) =>
+        new CliError.CliError({
+          reason: "InvalidValue",
+          option: name,
+          value: args.arguments[0],
+          expected: error,
+          kind: "argument",
+        }),
+    )
+    return [args.arguments.slice(1), value] as const
+  })
+
+const parseFlag = <A>(
+  name: string,
+  prim: Primitive.Primitive<A>,
+  args: ParsedArgs,
+): Effect.Effect<readonly [ReadonlyArray<string>, A], CliError.CliError> =>
+  Effect.gen(function* () {
+    const values = args.flags[name]
+    if (!values || values.length === 0) {
+      if (Primitive.isBoolean(prim)) return [args.arguments, false as any] as const
+      return yield* Effect.fail(new CliError.CliError({ reason: "MissingOption", option: name }))
+    }
+    const value = yield* Effect.mapError(
+      prim.parse(values[0]),
+      (error) =>
+        new CliError.CliError({
+          reason: "InvalidValue",
+          option: name,
+          value: values[0],
+          expected: error,
+          kind: "flag",
+        }),
+    )
+    return [args.arguments, value] as const
+  })
+
+export const paramMap = <K extends ParamKind, A, B>(
+  self: Param<K, A>,
+  f: (a: A) => B,
+): Param<K, B> => {
+  const parse: ParamParse<B> = (args) =>
+    Effect.map(self.parse(args), ([l, v]) => [l, f(v)] as const)
+  return Object.assign(Object.create(ParamProto), {
+    _tag: "Map",
+    kind: self.kind,
+    param: self,
+    f,
+    parse,
+  })
+}
+
+export const paramTransform = <K extends ParamKind, A, B>(
+  self: Param<K, A>,
+  f: (parse: ParamParse<A>) => ParamParse<B>,
+): Param<K, B> =>
+  Object.assign(Object.create(ParamProto), {
+    _tag: "Transform",
+    kind: self.kind,
+    param: self,
+    f,
+    parse: f(self.parse),
+  })
+
+export const paramMapEffect = <K extends ParamKind, A, B>(
+  self: Param<K, A>,
+  f: (a: A) => Effect.Effect<B, CliError.CliError>,
+): Param<K, B> =>
+  paramTransform(
+    self,
+    (parse) => (args) =>
+      Effect.flatMap(parse(args), ([l, a]) => Effect.map(f(a), (b) => [l, b] as const)),
+  )
+
+export const paramOptional = <K extends ParamKind, A>(
+  p: Param<K, A>,
+): Param<K, Option.Option<A>> => {
+  const parse: ParamParse<Option.Option<A>> = (args) =>
+    p.parse(args).pipe(
+      Effect.map(([l, v]) => [l, Option.some(v)] as const),
+      Effect.catchAll((e) =>
+        e.reason === "MissingOption" || e.reason === "MissingArgument"
+          ? Effect.succeed([args.arguments, Option.none()] as const)
+          : Effect.fail(e),
+      ),
+    )
+  return Object.assign(Object.create(ParamProto), {
+    _tag: "Optional",
+    kind: p.kind,
+    param: p,
+    parse,
+  })
+}
+
+export const paramWithDefault = <K extends ParamKind, A, B>(
+  self: Param<K, A>,
+  defaultValue: B,
+): Param<K, A | B> =>
+  paramMap(
+    paramOptional(self),
+    Option.getOrElse(() => defaultValue),
+  )
+
+export const paramVariadic = <K extends ParamKind, A>(
+  self: Param<K, A>,
+  options?: { min?: number; max?: number },
+): Param<K, ReadonlyArray<A>> => {
+  const single = getUnderlyingSingle(self)
+  const parse: ParamParse<ReadonlyArray<A>> = (args) => {
+    if (single.kind === "argument") return parsePositionalVariadic(self, single, args, options)
+    return parseOptionVariadic(self, single, args, options)
+  }
+  return Object.assign(Object.create(ParamProto), {
+    _tag: "Variadic",
+    kind: self.kind,
+    param: self,
+    min: options?.min,
+    max: options?.max,
+    parse,
+  })
+}
+
+const parsePositionalVariadic = <K extends ParamKind, A>(
+  self: Param<K, A>,
+  single: SingleParam<K, A>,
+  args: ParsedArgs,
+  options?: { min?: number; max?: number },
+): Effect.Effect<readonly [ReadonlyArray<string>, ReadonlyArray<A>], CliError.CliError> =>
+  Effect.gen(function* () {
+    const results: Array<A> = []
+    const min = options?.min ?? 0
+    const max = options?.max ?? Infinity
+    let current = args.arguments
+    while (current.length > 0 && results.length < max) {
+      const [remaining, value] = yield* self.parse({ flags: args.flags, arguments: current })
+      results.push(value)
+      current = remaining
+    }
+    if (results.length < min) {
+      return yield* Effect.fail(
+        new CliError.CliError({
+          reason: "InvalidValue",
+          option: single.name,
+          value: `${results.length} values`,
+          expected: `at least ${min} value${min === 1 ? "" : "s"}`,
+          kind: single.kind,
+        }),
+      )
+    }
+    return [current, results] as const
+  })
+
+const parseOptionVariadic = <K extends ParamKind, A>(
+  self: Param<K, A>,
+  single: SingleParam<K, A>,
+  args: ParsedArgs,
+  options?: { min?: number; max?: number },
+): Effect.Effect<readonly [ReadonlyArray<string>, ReadonlyArray<A>], CliError.CliError> =>
+  Effect.gen(function* () {
+    const names = [single.name, ...single.aliases]
+    const values = names.flatMap((n) => args.flags[n] ?? [])
+    const count = values.length
+    if (options?.min !== undefined && count < options.min) {
+      return yield* count === 0
+        ? Effect.fail(new CliError.CliError({ reason: "MissingOption", option: single.name }))
+        : Effect.fail(
+            new CliError.CliError({
+              reason: "InvalidValue",
+              option: single.name,
+              value: `${count} occurrences`,
+              expected: `at least ${options.min} value${options.min === 1 ? "" : "s"}`,
+              kind: single.kind,
+            }),
+          )
+    }
+    if (options?.max !== undefined && count > options.max) {
+      return yield* Effect.fail(
+        new CliError.CliError({
+          reason: "InvalidValue",
+          option: single.name,
+          value: `${count} occurrences`,
+          expected: `at most ${options.max} value${options.max === 1 ? "" : "s"}`,
+          kind: single.kind,
+        }),
+      )
+    }
+    const results: Array<A> = []
+    for (const v of values) {
+      const [, parsed] = yield* self.parse({ flags: { [single.name]: [v] }, arguments: [] })
+      results.push(parsed)
+    }
+    return [args.arguments, results] as const
+  })
+
+const DASH_RE = /^-+/
+
+export const paramWithAlias = <K extends ParamKind, A>(
+  self: Param<K, A>,
+  alias: string,
+): Param<K, A> =>
+  transformSingle(self, (s) =>
+    makeSingleParam({ ...s, aliases: [...s.aliases, alias.replace(DASH_RE, "")] }),
+  )
+
+export const paramWithDescription = <K extends ParamKind, A>(
+  self: Param<K, A>,
+  desc: string,
+): Param<K, A> => transformSingle(self, (s) => makeSingleParam({ ...s, description: desc }))
+
+export const paramWithMetavar = <K extends ParamKind, A>(
+  self: Param<K, A>,
+  metavar: string,
+): Param<K, A> => transformSingle(self, (s) => makeSingleParam({ ...s, typeName: metavar }))
+
+export const makeParamCombinators = <K extends ParamKind>(_kind: K) => ({
+  optional: <A>(self: Param<K, A>): Param<K, Option.Option<A>> => paramOptional(self),
+  withDefault: Function.dual(
+    2,
+    <A, B>(self: Param<K, A>, value: B): Param<K, A | B> => paramWithDefault(self, value),
+  ),
+  withDescription: Function.dual(
+    2,
+    <A>(self: Param<K, A>, desc: string): Param<K, A> => paramWithDescription(self, desc),
+  ),
+  withMetavar: Function.dual(
+    2,
+    <A>(self: Param<K, A>, metavar: string): Param<K, A> => paramWithMetavar(self, metavar),
+  ),
+  map: Function.dual(
+    2,
+    <A, B>(self: Param<K, A>, f: (a: A) => B): Param<K, B> => paramMap(self, f),
+  ),
+  mapEffect: Function.dual(
+    2,
+    <A, B>(self: Param<K, A>, f: (a: A) => Effect.Effect<B, CliError.CliError>): Param<K, B> =>
+      paramMapEffect(self, f),
+  ),
+  variadic: Function.dual(
+    2,
+    <A>(self: Param<K, A>, options?: { min?: number; max?: number }): Param<K, ReadonlyArray<A>> =>
+      paramVariadic(self, options),
+  ),
+  filter: Function.dual(
+    3,
+    <A>(self: Param<K, A>, pred: (a: A) => boolean, onFalse: (a: A) => string): Param<K, A> =>
+      paramMapEffect(self, (a) => {
+        if (pred(a)) return Effect.succeed(a)
+        const s = getUnderlyingSingle(self)
+        return Effect.fail(
+          new CliError.CliError({
+            reason: "InvalidValue",
+            option: s.name,
+            value: String(a),
+            expected: onFalse(a),
+            kind: s.kind,
+          }),
+        )
+      }),
+  ),
+  withSchema: Function.dual(
+    2,
+    <A, B>(self: Param<K, A>, schema: Schema.Schema<B, A>): Param<K, B> => {
+      const decode = Schema.decodeUnknown(schema)
+      return paramMapEffect(self, (v) =>
+        Effect.mapError(decode(v), (err) => {
+          const s = getUnderlyingSingle(self)
+          return new CliError.CliError({
+            reason: "InvalidValue",
+            option: s.name,
+            value: String(v),
+            expected: `Schema validation failed: ${err.message}`,
+            kind: s.kind,
+          })
+        }),
+      )
+    },
+  ),
+  orElse: Function.dual(
+    2,
+    <A, B>(self: Param<K, A>, that: () => Param<K, B>): Param<K, A | B> =>
+      paramTransform<K, A, A | B>(
+        self,
+        (parse) => (args) => Effect.catchAll(parse(args), () => that().parse(args)),
+      ),
+  ),
+})
+
+export const makeConstructor =
+  <K extends ParamKind>(kind: K) =>
+  (name: string, prim: Primitive.Primitive<any>) =>
+    makeSingleParam({ kind, name, primitiveType: prim })

package/src/cli/Primitive.ts

@@ -0,0 +1,94 @@
+import * as Effect from "effect/Effect"
+import * as Redacted from "effect/Redacted"
+
+export interface Primitive<out A> {
+  readonly _tag: string
+  readonly parse: (value: string) => Effect.Effect<A, string>
+}
+
+export const make = <A>(
+  tag: string,
+  parse: (value: string) => Effect.Effect<A, string>,
+): Primitive<A> => ({ _tag: tag, parse })
+
+export const isTrueValue = (v: string) => ["true", "1", "y", "yes", "on"].includes(v.toLowerCase())
+export const isFalseValue = (v: string) =>
+  ["false", "0", "n", "no", "off"].includes(v.toLowerCase())
+export const isBooleanLiteral = (v: string) => isTrueValue(v) || isFalseValue(v)
+export const isBoolean = (p: Primitive<unknown>): p is Primitive<boolean> => p._tag === "Boolean"
+
+export const boolean: Primitive<boolean> = make("Boolean", (value) => {
+  if (isTrueValue(value)) return Effect.succeed(true)
+  if (isFalseValue(value)) return Effect.succeed(false)
+  return Effect.fail(`Expected boolean (true/false/yes/no/on/off/1/0), got "${value}"`)
+})
+
+export const string: Primitive<string> = make("String", Effect.succeed)
+
+export const integer: Primitive<number> = make("Integer", (value) => {
+  const n = Number(value)
+  if (!Number.isInteger(n)) return Effect.fail(`Expected integer, got "${value}"`)
+  return Effect.succeed(n)
+})
+
+export const float: Primitive<number> = make("Float", (value) => {
+  const n = Number(value)
+  if (!Number.isFinite(n)) return Effect.fail(`Expected number, got "${value}"`)
+  return Effect.succeed(n)
+})
+
+export const date: Primitive<Date> = make("Date", (value) => {
+  const d = new Date(value)
+  if (Number.isNaN(d.getTime())) return Effect.fail(`Expected valid date, got "${value}"`)
+  return Effect.succeed(d)
+})
+
+export const redacted: Primitive<Redacted.Redacted<string>> = make("Redacted", (value) =>
+  Effect.succeed(Redacted.make(value)),
+)
+
+export const keyValuePair: Primitive<Record<string, string>> = make("KeyValuePair", (value) => {
+  const idx = value.indexOf("=")
+  if (idx <= 0 || idx === value.length - 1)
+    return Effect.fail(`Expected key=value format, got "${value}"`)
+  return Effect.succeed({ [value.slice(0, idx)]: value.slice(idx + 1) })
+})
+
+export const choice = <A>(choices: ReadonlyArray<readonly [string, A]>): Primitive<A> => {
+  const map = new Map(choices)
+  const valid = choices.map(([k]) => k).join(" | ")
+  return make("Choice", (value) =>
+    map.has(value)
+      ? Effect.succeed(map.get(value)!)
+      : Effect.fail(`Expected ${valid}, got "${value}"`),
+  )
+}
+
+export const none: Primitive<never> = make("None", () =>
+  Effect.fail("This option does not accept values"),
+)
+
+export const getTypeName = <A>(p: Primitive<A>): string => {
+  switch (p._tag) {
+    case "Boolean":
+      return "boolean"
+    case "String":
+      return "string"
+    case "Integer":
+      return "integer"
+    case "Float":
+      return "number"
+    case "Date":
+      return "date"
+    case "Choice":
+      return "choice"
+    case "Redacted":
+      return "string"
+    case "KeyValuePair":
+      return "key=value"
+    case "None":
+      return "none"
+    default:
+      return "value"
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,7 @@
+export * as Argument from "./Argument.ts"
+export * as CliError from "./CliError.ts"
+export * as Command from "./Command.ts"
+export * as Flag from "./Flag.ts"
+export * as HelpDoc from "./HelpDoc.ts"
+export * as Param from "./Param.ts"
+export * as Primitive from "./Primitive.ts"

package/src/datastar/watchers/patchElements.ts

@@ -402,8 +402,10 @@ const removeNode = (node: Node): void => {
   ctxIdMap.has(node) ? moveBefore(ctxPantry, node, null) : node.parentNode?.removeChild(node)
 }
 
-const moveBefore: (parentNode: Node, node: Node, after: Node | null) => void =
-  removeNode.call.bind(ctxPantry.moveBefore ?? ctxPantry.insertBefore)
+const moveBefore: (parentNode: Node, node: Node, after: Node | null) => void = removeNode.call.bind(
+  // @ts-expect-error
+  ctxPantry.moveBefore ?? ctxPantry.insertBefore,
+)
 
 const aliasedPreserveAttr = aliasify("preserve-attr")