{⟦
  org ↦ ⟦
    eolang ↦ ⟦
      fs ↦ ⟦
        path(uri) ↦ ⟦
          φ ↦ Φ̇.sys.os.is-windows.if(
            ξ.win32(Φ̇.string(ξ.uri.as-bytes)), ξ.posix(Φ̇.string(ξ.uri.as-bytes))
          ).determined,
          joined(paths) ↦ ⟦
            joined-path ↦ Φ̇.string(
              Φ̇.txt.text(ξ.ρ.separator).joined(ξ.paths).as-bytes
            ),
            φ ↦ Φ̇.sys.os.is-windows.if(
              ξ.ρ.win32(ξ.joined-path), ξ.ρ.posix(ξ.joined-path)
            ).normalized
          ⟧,
          separator ↦ ⟦
            φ ↦ Φ̇.sys.os.is-windows.if(ξ.ρ.win32.separator, ξ.ρ.posix.separator)
          ⟧,
          posix(uri) ↦ ⟦
            determined ↦ ξ,
            separator ↦ "/",
            as-file ↦ Φ̇.fs.file(ξ.uri).size.ρ,
            as-dir ↦ Φ̇.fs.dir(Φ̇.fs.file(ξ.uri)).made.ρ,
            φ ↦ ξ.uri,
            is-absolute ↦ ⟦
              φ ↦ ξ.ρ.uri.length.gt(0).and(
                ξ.ρ.uri.as-bytes.slice(0, 1).eq(ξ.ρ.separator)
              )
            ⟧,
            normalized ↦ ⟦
              uri-as-bytes ↦ ξ.ρ.uri.as-bytes,
              is-absolute ↦ ξ.ρ.is-absolute.as-bool,
              has-trailing-slash ↦ ξ.uri-as-bytes.size.gt(0).and(
                ξ.uri-as-bytes.slice(ξ.uri-as-bytes.size.plus(-1), 1).eq(
                  ξ.ρ.separator
                )
              ),
              path ↦ Φ̇.txt.text(ξ.ρ.separator).joined(
                Φ̇.structs.list(Φ̇.txt.text(ξ.ρ.uri).split(ξ.ρ.separator)).reduced(
                  Φ̇.tuple.empty, ξ.auto-named-attr-at-102-25
                )
              ),
              normalized ↦ ξ.ρ.uri.length.eq(0).if(
                ".",
                ξ.is-absolute.if(ξ.ρ.separator.concat(ξ.path), ξ.path).concat(
                  ξ.has-trailing-slash.if(ξ.ρ.separator, Φ̇.bytes(⟦ Δ ⤍ -- ⟧))
                )
              ).as-bytes,
              φ ↦ ξ.ρ.ρ.posix(
                ξ.normalized.eq("//").if("/", Φ̇.string(ξ.normalized))
              ).determined,
              auto-named-attr-at-102-25(accum, segment) ↦ ⟦
                φ ↦ ξ.segment.eq("..").if(
                  ξ.accum.length.gt(0).and(ξ.accum.tail.eq("..").not).if(
                    ξ.accum.head, ξ.ρ.is-absolute.not.if(ξ.accum.with(ξ.segment), ξ.accum)
                  ),
                  ξ.segment.eq(".").or(ξ.segment.eq("")).if(
                    ξ.accum, ξ.accum.with(ξ.segment)
                  )
                )
              ⟧
            ⟧,
            resolved(other) ↦ ⟦
              other-as-bytes ↦ ξ.other.as-bytes,
              φ ↦ ξ.ρ.ρ.posix(
                Φ̇.string(
                  ξ.other-as-bytes.slice(0, 1).eq(ξ.ρ.separator).if(
                    ξ.other-as-bytes, ξ.ρ.uri.concat(ξ.ρ.separator).concat(ξ.other-as-bytes)
                  )
                )
              ).normalized
            ⟧,
            basename ↦ ⟦
              pth ↦ Φ̇.dataized(ξ.ρ.uri).as-bytes,
              txt ↦ Φ̇.txt.text(Φ̇.string(ξ.pth)),
              slice-start-idx ↦ Φ̇.dataized(
                ξ.txt.last-index-of(ξ.ρ.separator).plus(1)
              ).as-bytes,
              φ ↦ Φ̇.string(
                ξ.pth.size.eq(0).or(ξ.slice-start-idx.eq(0)).if(
                  ξ.pth,
                  ξ.txt.slice(
                    ξ.slice-start-idx, ξ.txt.length.minus(Φ̇.number(ξ.slice-start-idx))
                  ).as-bytes
                )
              )
            ⟧,
            extname ↦ ⟦
              base ↦ Φ̇.dataized(ξ.ρ.basename).as-bytes,
              txt ↦ Φ̇.txt.text(Φ̇.string(ξ.base)),
              slice-start-idx ↦ Φ̇.dataized(ξ.txt.last-index-of(".")).as-bytes,
              φ ↦ ξ.base.size.eq(0).or(ξ.slice-start-idx.eq(-1)).if(
                "",
                Φ̇.string(
                  ξ.txt.slice(
                    ξ.slice-start-idx, ξ.txt.length.minus(Φ̇.number(ξ.slice-start-idx))
                  ).as-bytes
                )
              )
            ⟧,
            dirname ↦ ⟦
              pth ↦ Φ̇.dataized(ξ.ρ.uri).as-bytes,
              txt ↦ Φ̇.txt.text(Φ̇.string(ξ.pth)),
              len ↦ Φ̇.dataized(ξ.txt.last-index-of(ξ.ρ.separator)).as-bytes,
              φ ↦ Φ̇.string(
                ξ.pth.size.eq(0).or(ξ.len.eq(-1)).if(
                  ξ.pth, ξ.txt.slice(0, ξ.len).as-bytes
                )
              )
            ⟧
          ⟧,
          win32(uri) ↦ ⟦
            separator ↦ "\\",
            φ ↦ ξ.validated(
              Φ̇.string(ξ.validated.separated-correctly(ξ.uri).as-bytes)
            ).determined,
            validated(uri) ↦ ⟦
              determined ↦ ξ,
              separator ↦ ξ.ρ.separator,
              as-file ↦ Φ̇.fs.file(ξ.uri).size.ρ,
              as-dir ↦ Φ̇.fs.dir(Φ̇.fs.file(ξ.uri)).made.ρ,
              φ ↦ ξ.uri,
              is-drive-relative(uri) ↦ ⟦
                φ ↦ Φ̇.txt.regex("/^[a-zA-Z]:/").matches(ξ.uri).as-bool
              ⟧,
              is-root-relative(uri) ↦ ⟦
                uri-as-bytes ↦ Φ̇.dataized(ξ.uri).as-bytes,
                φ ↦ ξ.uri-as-bytes.size.gt(0).and(
                  ξ.uri-as-bytes.slice(0, 1).eq(ξ.ρ.separator)
                )
              ⟧,
              separated-correctly(uri) ↦ ⟦
                uri-as-bytes ↦ Φ̇.dataized(ξ.uri).as-bytes,
                pth ↦ Φ̇.txt.text(Φ̇.string(ξ.uri-as-bytes)),
                replaced ↦ Φ̇.dataized(
                  ξ.pth.replaced(Φ̇.txt.regex("/\\//"), ξ.ρ.separator)
                ).as-bytes,
                φ ↦ ξ.pth.index-of(ξ.ρ.ρ.ρ.ρ.path.posix.separator).eq(-1).if(
                  Φ̇.string(ξ.uri-as-bytes), Φ̇.string(ξ.replaced)
                )
              ⟧,
              is-absolute ↦ ⟦
                uri-as-bytes ↦ Φ̇.dataized(ξ.ρ.uri).as-bytes,
                φ ↦ ξ.uri-as-bytes.size.eq(0).if(
                  Φ̇.false,
                  ξ.ρ.is-root-relative(ξ.uri-as-bytes).or(
                    ξ.uri-as-bytes.size.gt(1).and(
                      ξ.ρ.is-drive-relative(ξ.uri-as-bytes)
                    )
                  )
                )
              ⟧,
              normalized ↦ ⟦
                uri-as-bytes ↦ Φ̇.dataized(ξ.ρ.uri).as-bytes,
                is-drive-relative ↦ ξ.ρ.is-drive-relative(ξ.uri-as-bytes).as-bool,
                is-root-relative ↦ ξ.ρ.is-root-relative(ξ.uri-as-bytes).as-bool,
                driveless ↦ Φ̇.dataized(
                  ξ.is-drive-relative.if(
                    ξ.uri-as-bytes.slice(2, ξ.uri-as-bytes.size.plus(-2)), ξ.uri-as-bytes
                  )
                ).as-bytes,
                has-trailing-slash ↦ ξ.uri-as-bytes.size.gt(0).and(
                  ξ.uri-as-bytes.slice(ξ.uri-as-bytes.size.plus(-1), 1).eq(
                    ξ.ρ.separator
                  )
                ),
                path ↦ Φ̇.dataized(
                  Φ̇.txt.text(ξ.ρ.separator).joined(
                    Φ̇.structs.list(
                      Φ̇.txt.text(ξ.driveless).split(ξ.ρ.separator)
                    ).reduced(Φ̇.tuple.empty, ξ.auto-named-attr-at-357-27)
                  )
                ).as-bytes,
                normalized ↦ ξ.driveless.size.eq(0).if(
                  ".",
                  ξ.is-drive-relative.if(
                    ξ.driveless.slice(0, 1).eq(ξ.ρ.separator).if(
                      ξ.ρ.uri.slice(0, 3), ξ.ρ.uri.slice(0, 2)
                    ),
                    ξ.is-root-relative.if(ξ.ρ.separator, Φ̇.bytes(⟦ Δ ⤍ -- ⟧))
                  ).concat(ξ.path).concat(
                    ξ.has-trailing-slash.if(ξ.ρ.separator, Φ̇.bytes(⟦ Δ ⤍ -- ⟧))
                  )
                ).as-bytes,
                φ ↦ ξ.ρ.ρ.validated(
                  ξ.normalized.eq("\\\\").if(
                    ξ.ρ.separator, Φ̇.string(ξ.normalized)
                  )
                ).determined,
                auto-named-attr-at-357-27(accum, segment) ↦ ⟦
                  φ ↦ ξ.segment.eq("..").if(
                    ξ.accum.length.gt(0).and(ξ.accum.tail.eq("..").not).if(
                      ξ.accum.head,
                      ξ.ρ.is-root-relative.not.and(ξ.ρ.is-drive-relative.not).if(
                        ξ.accum.with(ξ.segment), ξ.accum
                      )
                    ),
                    ξ.segment.eq(".").or(ξ.segment.eq("")).if(
                      ξ.accum, ξ.accum.with(ξ.segment)
                    )
                  )
                ⟧
              ⟧,
              resolved(other) ↦ ⟦
                uri-as-bytes ↦ Φ̇.dataized(ξ.ρ.uri).as-bytes,
                valid-other ↦ Φ̇.dataized(ξ.ρ.separated-correctly(ξ.other)).as-bytes,
                other-is-drive-relative ↦ ξ.ρ.is-drive-relative(ξ.valid-other).as-bool,
                other-is-root-relative ↦ ξ.ρ.is-root-relative(ξ.valid-other).as-bool,
                φ ↦ ξ.ρ.ρ.validated(
                  Φ̇.string(
                    ξ.other-is-drive-relative.if(
                      ξ.valid-other,
                      ξ.other-is-root-relative.if(
                        ξ.ρ.is-drive-relative(ξ.uri-as-bytes).if(
                          ξ.uri-as-bytes.slice(0, 2).concat(ξ.valid-other), ξ.valid-other
                        ),
                        ξ.uri-as-bytes.concat(ξ.ρ.separator).concat(
                          ξ.valid-other
                        )
                      )
                    )
                  )
                ).normalized
              ⟧,
              basename ↦ ⟦
                pth ↦ Φ̇.dataized(ξ.ρ.uri).as-bytes,
                txt ↦ Φ̇.txt.text(Φ̇.string(ξ.pth)),
                slice-start-idx ↦ Φ̇.dataized(
                  ξ.txt.last-index-of(ξ.ρ.separator).plus(1)
                ).as-bytes,
                φ ↦ Φ̇.string(
                  ξ.pth.size.eq(0).or(ξ.slice-start-idx.eq(0)).if(
                    ξ.pth,
                    ξ.txt.slice(
                      ξ.slice-start-idx, ξ.txt.length.minus(Φ̇.number(ξ.slice-start-idx))
                    ).as-bytes
                  )
                )
              ⟧,
              extname ↦ ⟦
                base ↦ Φ̇.dataized(ξ.ρ.basename).as-bytes,
                txt ↦ Φ̇.txt.text(Φ̇.string(ξ.base)),
                slice-start-idx ↦ Φ̇.dataized(ξ.txt.last-index-of(".")).as-bytes,
                φ ↦ ξ.base.size.eq(0).or(ξ.slice-start-idx.eq(-1)).if(
                  "",
                  Φ̇.string(
                    ξ.txt.slice(
                      ξ.slice-start-idx, ξ.txt.length.minus(Φ̇.number(ξ.slice-start-idx))
                    ).as-bytes
                  )
                )
              ⟧,
              dirname ↦ ⟦
                pth ↦ Φ̇.dataized(ξ.ρ.uri).as-bytes,
                txt ↦ Φ̇.txt.text(Φ̇.string(ξ.pth)),
                len ↦ Φ̇.dataized(ξ.txt.last-index-of(ξ.ρ.separator)).as-bytes,
                φ ↦ Φ̇.string(
                  ξ.pth.size.eq(0).or(ξ.len.eq(-1)).if(
                    ξ.pth, ξ.txt.slice(0, ξ.len).as-bytes
                  )
                )
              ⟧
            ⟧
          ⟧
        ⟧,
        λ ⤍ Package
      ⟧,
      λ ⤍ Package
    ⟧,
    λ ⤍ Package
  ⟧
⟧}