#    { category: Help, label: " 🞂 [merge] enjoins partial layers; and [exclude] skips them" }
#    { category: Help, label: " 🞂 [animate=10] generates ❮animate*❯ subframes, flag: [pace] timing" }
#    { category: Help, label: " 🞂 [--delay=2.5] resets ImageMagick option (delay also for Pillow)",
#    { category: Help, label: $help, appearance: url }
# inx-export: .gif, image/gif, GIF slideshow (*.gif), Graphics Interchange Format 98a
# architecture: all
# pack: export_gif.py, *.inx, pmd2inks, animate_yo.py, svgelements.py, export_gif.svg, LICENSE=/usr/share/doc/inkscape-export-gif/copyright
# depends: python:inkex, bin:inkscape >= 1.1
# suggests: python:svgelements >= 1.8
# permissive: 0.5
# format: off
# author: mario#include-once:org
# url: https://inkscape.org/~culturaljuice/★export_gif
# help: https://fossil.include-once.org/scripts/wiki/inkscape
# orig: https://github.com/jespino/inkscape-export-layers
#
# Generates a GIF slideshow from image layers ☰  (Shift+Ctrl+L). The menu

        self.gif = parent
        self.convert_png = parent.convert_png
        self.svg = svg  # ← already a deepcopy
        self.layer = layer
        self.frames = layer.animate
        self.delay = float(layer.args.get("delay", self.gif.options.delay))
        self.layer.args.update({
            "delay": self.delay / self.frames   # frame time split between animation steps
        })

    def export(self):
        """ applies transforms in each subframe, yields filename+args list """
        transforms = []
        for anim in self.svg.xpath("//svg:animate"):
            transforms.append([self.animate_style(anim, **anim.attrib), self.pace(anim)])

                    apply(pace(index / (self.frames - 1))) # durations are mapped into the 0.0 - 1.0 range

            # custom export
            dest = f"{self.gif.tempdir}/{self.gif.index}+{index}.{self.layer.label}.png"
            GIFExport.export_layers(self, dest, show=True)

            yield [dest, self.layer.args]

        # reset, in case frame gets animated again ([fixed]/[bg])
        self.layer.args["delay"] = self.delay

    @animate_with_values
    def animate_style(self, anim, attributeName, to, **attrib):
        """ <animate to="#000000" attributeName="fill" /> """
        target = self.get_target(anim)
        #self.adapt(target, css={attributeName: attrib["from"]})
        transformed = self.adapt(

        return apply

    def animate_rotate(self, target, anim, start, end):
        """ simpler <animateTransform type=rotate> handler, does not fold the matrix at 180° """
        start = strargs(start) or [0]
        end = strargs(end) or [0]
        sfx = [str(coord) for coord in end[1:] + start[1:]]  # any center coordinates

        def apply(time, start=start[0], end=end[0], sfx=" ".join(sfx[0:2]), prepend=self.had_transform(target)):
            deg = start + (end - start) * time
            self.adapt(target, transform=prepend + f"rotate({deg} {sfx})")
        return apply

    def animate_motion(self, anim, path, **attrib): # pylint: disable=invalid-name

                    return (r_time - r_begin) / r_end

        if attr("repeatCount"):
            # meh: ignorantly zigzags the repeat into our .delay time slice
            def vary(r_time, count=int(attr("repeatCount")), vary=vary):
                """ amplify by repeatCount, modulo into 0.0 … 1.0 interval """
                return (count * vary(r_time)) % 1.0

        if attr("calcMode") == "discrete":
            def vary(r_time):
                """ just snaps from one to the other extreme; nobody will ever use it """
                return 0.0 if r_time < 0.5 else 1.0

        if attr("calcMode") == "paced" or smooth and not attr("calcMode"):
            def vary(r_time, vary=vary):
                """ dense sigmoid (quick approx via KmPlot) """
                return vary(10 / (10 + math.exp(-(9 * r_time - 7))))

        if attr("calcMode") == "spline" and attr("keyTimes"):  # (ignoring the actual keySplines= of course)
            def vary(r_time, steps=strargs(attr("keyTimes", "0;1")), vary=vary):
                """ only linear [0, 0.33, 0.66, 1.0] here, values=[] would require interpretation in handlers """
                length = len(steps) - 1
                dist = 1.0 / length                   # 0.25 for len=4
                offs = int(r_time * length)           # r=0.30 → vary index [1]
                steps = steps[:] + [1.0, 1.0]
                val_diff = steps[offs+1] - steps[offs]   # steps difference 0.33-0.25
                off_diff = (r_time - dist * offs) / dist # offset [2]+0.1 to quantify value
                return vary(steps[offs] + val_diff * off_diff)

        def vary(r_time, vary=vary):
            """ guard for invalid params and calculation hiccups """