7import TimeSpan from './timespan.mjs';
8import Fraction, { isFraction, lcm } from './fraction.mjs';
9import Hap from './hap.mjs';
10import State from './state.mjs';
11import { unionWithObj } from './value.mjs';

13import {
14  uniqsortr,
15  removeUndefineds,
16  flatten,
17  id,
18  listRange,
19  curry,
20  _mod,
21  numeralArgs,
22  parseNumeral,
23  pairs,
24  zipWith,
25  stringifyValues,
26} from './util.mjs';
27import drawLine from './drawLine.mjs';
28import { errorLogger, logger } from './logger.mjs';
29import { strudelScope } from './evaluate.mjs';
30
31let stringParser;
32
33let __steps = true;
34
35export const calculateSteps = function (x) {
36  __steps = x ? true : false;
37};

42export const setStringParser = (parser) => (stringParser = parser);

45export class Pattern {
46  /**
47   * Create a pattern. As an end user, you will most likely not create a Pattern directly.
48   *
49   * @param {function} query - The function that maps a `State` to an array of `Hap`.
50   * @noAutocomplete
51   */
52  constructor(query, steps = undefined) {
53    this.query = query;
54    this._Pattern = true; // this property is used to detectinstance of another Pattern
55    this._steps = steps; // in terms of number of steps per cycle
56  }
57
58  get _steps() {
59    return this.__steps;
60  }
61
62  set _steps(steps) {
63    this.__steps = steps === undefined ? undefined : Fraction(steps);
64  }
65
66  setSteps(steps) {
67    this._steps = steps;
68    return this;
69  }
70
71  withSteps(f) {
72    if (!__steps) {
73      return this;
74    }
75    return new Pattern(this.query, this._steps === undefined ? undefined : f(this._steps));
76  }
77
78  get hasSteps() {
79    return this._steps !== undefined;
80  }

95  withValue(func) {
96    const result = new Pattern((state) => this.query(state).map((hap) => hap.withValue(func)));
97    result._steps = this._steps;
98    return result;
99  }

102  withState(func) {
103    return new Pattern((state) => this.query(func(state)));
104  }

110  fmap(func) {
111    return this.withValue(func);
112  }

124  appWhole(whole_func, pat_val) {
125    const pat_func = this;
126    const query = function (state) {
127      const hap_funcs = pat_func.query(state);
128      const hap_vals = pat_val.query(state);
129      const apply = function (hap_func, hap_val) {
130        const s = hap_func.part.intersection(hap_val.part);
131        if (s == undefined) {
132          return undefined;
133        }
134        return new Hap(
135          whole_func(hap_func.whole, hap_val.whole),
136          s,
137          hap_func.value(hap_val.value),
138          hap_val.combineContext(hap_func),
139        );
140      };
141      return flatten(
142        hap_funcs.map((hap_func) => removeUndefineds(hap_vals.map((hap_val) => apply(hap_func, hap_val)))),
143      );
144    };
145    return new Pattern(query);
146  }

161  appBoth(pat_val) {
162    const pat_func = this;

165    const whole_func = function (span_a, span_b) {
166      if (span_a == undefined || span_b == undefined) {
167        return undefined;
168      }
169      return span_a.intersection_e(span_b);
170    };
171    const result = pat_func.appWhole(whole_func, pat_val);
172    if (__steps) {
173      result._steps = lcm(pat_val._steps, pat_func._steps);
174    }
175    return result;
176  }

189  appLeft(pat_val) {
190    const pat_func = this;
191
192    const query = function (state) {
193      const haps = [];
194      for (const hap_func of pat_func.query(state)) {
195        const hap_vals = pat_val.query(state.setSpan(hap_func.wholeOrPart()));
196        for (const hap_val of hap_vals) {
197          const new_whole = hap_func.whole;
198          const new_part = hap_func.part.intersection(hap_val.part);
199          if (new_part) {
200            const new_value = hap_func.value(hap_val.value);
201            const new_context = hap_val.combineContext(hap_func);
202            const hap = new Hap(new_whole, new_part, new_value, new_context);
203            haps.push(hap);
204          }
205        }
206      }
207      return haps;
208    };
209    const result = new Pattern(query);
210    result._steps = this._steps;
211    return result;
212  }

223  appRight(pat_val) {
224    const pat_func = this;
225
226    const query = function (state) {
227      const haps = [];
228      for (const hap_val of pat_val.query(state)) {
229        const hap_funcs = pat_func.query(state.setSpan(hap_val.wholeOrPart()));
230        for (const hap_func of hap_funcs) {
231          const new_whole = hap_val.whole;
232          const new_part = hap_func.part.intersection(hap_val.part);
233          if (new_part) {
234            const new_value = hap_func.value(hap_val.value);
235            const new_context = hap_val.combineContext(hap_func);
236            const hap = new Hap(new_whole, new_part, new_value, new_context);
237            haps.push(hap);
238          }
239        }
240      }
241      return haps;
242    };
243    const result = new Pattern(query);
244    result._steps = pat_val._steps;
245    return result;
246  }

248  bindWhole(choose_whole, func) {
249    const pat_val = this;
250    const query = function (state) {
251      const withWhole = function (a, b) {
252        return new Hap(
253          choose_whole(a.whole, b.whole),
254          b.part,
255          b.value,
256          Object.assign({}, a.context, b.context, {
257            locations: (a.context.locations || []).concat(b.context.locations || []),
258          }),
259        );
260      };
261      const match = function (a) {
262        return func(a.value)
263          .query(state.setSpan(a.part))
264          .map((b) => withWhole(a, b));
265      };
266      return flatten(pat_val.query(state).map((a) => match(a)));
267    };
268    return new Pattern(query);
269  }
270
271  bind(func) {
272    const whole_func = function (a, b) {
273      if (a == undefined || b == undefined) {
274        return undefined;
275      }
276      return a.intersection_e(b);
277    };
278    return this.bindWhole(whole_func, func);
279  }
280
281  join() {
282    // Flattens a pattern of patterns into a pattern, where wholes are
283    // the intersection of matched inner and outer haps.
284    return this.bind(id);
285  }
286
287  outerBind(func) {
288    return this.bindWhole((a) => a, func).setSteps(this._steps);
289  }
290
291  outerJoin() {
292    // Flattens a pattern of patterns into a pattern, where wholes are
293    // taken from outer haps.
294    return this.outerBind(id);
295  }
296
297  innerBind(func) {
298    return this.bindWhole((_, b) => b, func);
299  }
300
301  innerJoin() {
302    // Flattens a pattern of patterns into a pattern, where wholes are
303    // taken from inner haps.
304    return this.innerBind(id);
305  }

308  resetJoin(restart = false) {
309    const pat_of_pats = this;
310    return new Pattern((state) => {
311      return (
312        pat_of_pats
313          // drop continuous haps from the outer pattern.
314          .discreteOnly()
315          .query(state)
316          .map((outer_hap) => {
317            return (
318              outer_hap.value
319                // reset = align the inner pattern cycle start to outer pattern haps
320                // restart = align the inner pattern cycle zero to outer pattern haps
321                .late(restart ? outer_hap.whole.begin : outer_hap.whole.begin.cyclePos())
322                .query(state)
323                .map((inner_hap) =>
324                  new Hap(
325                    // Supports continuous haps in the inner pattern
326                    inner_hap.whole ? inner_hap.whole.intersection(outer_hap.whole) : undefined,
327                    inner_hap.part.intersection(outer_hap.part),
328                    inner_hap.value,
329                  ).setContext(outer_hap.combineContext(inner_hap)),
330                )
331                // Drop haps that didn't intersect
332                .filter((hap) => hap.part)
333            );
334          })
335          .flat()
336      );
337    });
338  }

340  restartJoin() {
341    return this.resetJoin(true);
342  }

347  squeezeJoin() {
348    // A pattern of patterns, which we call the 'outer' pattern, with patterns
349    // as values which we call the 'inner' patterns.
350    const pat_of_pats = this;
351    function query(state) {
352      // Get the events with the inner patterns. Ignore continuous events (without 'wholes')
353      const haps = pat_of_pats.discreteOnly().query(state);
354      // A function to map over the events from the outer pattern.
355      function flatHap(outerHap) {
356        // Get the inner pattern, slowed and shifted so that the 'whole'
357        // timespan of the outer event corresponds to the first cycle of the
358        // inner event
359        const inner_pat = outerHap.value._focusSpan(outerHap.wholeOrPart());
360        // Get the inner events, from the timespan of the outer event's part
361        const innerHaps = inner_pat.query(state.setSpan(outerHap.part));
362        // A function to map over the inner events, to combine them with the
363        // outer event
364        function munge(outer, inner) {
365          let whole = undefined;
366          if (inner.whole && outer.whole) {
367            whole = inner.whole.intersection(outer.whole);
368            if (!whole) {
369              // The wholes are present, but don't intersect
370              return undefined;
371            }
372          }
373          const part = inner.part.intersection(outer.part);
374          if (!part) {
375            // The parts don't intersect
376            return undefined;
377          }
378          const context = inner.combineContext(outer);
379          return new Hap(whole, part, inner.value, context);
380        }
381        return innerHaps.map((innerHap) => munge(outerHap, innerHap));
382      }
383      const result = flatten(haps.map(flatHap));
384      // remove undefineds
385      return result.filter((x) => x);
386    }
387    return new Pattern(query);
388  }

390  squeezeBind(func) {
391    return this.fmap(func).squeezeJoin();
392  }
393
394  polyJoin = function () {
395    const pp = this;
396    return pp.fmap((p) => p.extend(pp._steps.div(p._steps))).outerJoin();
397  };
398
399  polyBind(func) {
400    return this.fmap(func).polyJoin();
401  }

420  queryArc(begin, end, controls = {}) {
421    try {
422      return this.query(new State(new TimeSpan(begin, end), controls));
423    } catch (err) {
424      errorLogger(err, 'query');
425      return [];
426    }
427  }

437  splitQueries() {
438    const pat = this;
439    const q = (state) => {
440      return flatten(state.span.spanCycles.map((subspan) => pat.query(state.setSpan(subspan))));
441    };
442    return new Pattern(q);
443  }

453  withQuerySpan(func) {
454    return new Pattern((state) => this.query(state.withSpan(func)));
455  }

457  withQuerySpanMaybe(func) {
458    const pat = this;
459    return new Pattern((state) => {
460      const newState = state.withSpan(func);
461      if (!newState.span) {
462        return [];
463      }
464      return pat.query(newState);
465    });
466  }

476  withQueryTime(func) {
477    return new Pattern((state) => this.query(state.withSpan((span) => span.withTime(func))));
478  }

489  withHapSpan(func) {
490    return new Pattern((state) => this.query(state).map((hap) => hap.withSpan(func)));
491  }

501  withHapTime(func) {
502    return this.withHapSpan((span) => span.withTime(func));
503  }

512  withHaps(func) {
513    const result = new Pattern((state) => func(this.query(state), state));
514    result._steps = this._steps;
515    return result;
516  }

525  withHap(func) {
526    return this.withHaps((haps) => haps.map(func));
527  }

536  setContext(context) {
537    return this.withHap((hap) => hap.setContext(context));
538  }

547  withContext(func) {
548    const result = this.withHap((hap) => hap.setContext(func(hap.context)));
549    if (this.__pure !== undefined) {
550      result.__pure = this.__pure;
551      result.__pure_loc = this.__pure_loc;
552    }
553    return result;
554  }

562  stripContext() {
563    return this.withHap((hap) => hap.setContext({}));
564  }

575  withLoc(start, end) {
576    const location = {
577      start,
578      end,
579    };
580    const result = this.withContext((context) => {
581      const locations = (context.locations || []).concat([location]);
582      return { ...context, locations };
583    });
584    if (this.__pure) {
585      result.__pure = this.__pure;
586      result.__pure_loc = location;
587    }
588    return result;
589  }

599  filterHaps(hap_test) {
600    return new Pattern((state) => this.query(state).filter(hap_test));
601  }

615  filterValues(value_test) {
616    return new Pattern((state) => this.query(state).filter((hap) => value_test(hap.value))).setSteps(this._steps);
617  }

626  removeUndefineds() {
627    return this.filterValues((val) => val != undefined);
628  }

638  onsetsOnly() {
639    // Returns a new pattern that will only return haps where the start
640    // of the 'whole' timespan matches the start of the 'part'
641    // timespan, i.e. the haps that include their 'onset'.
642    return this.filterHaps((hap) => hap.hasOnset());
643  }

652  discreteOnly() {
653    // removes continuous haps that don't have a 'whole' timespan
654    return this.filterHaps((hap) => hap.whole);
655  }

663  defragmentHaps() {
664    // remove continuous haps
665    const pat = this.discreteOnly();
666
667    return pat.withHaps((haps) => {
668      const result = [];
669      for (var i = 0; i < haps.length; ++i) {
670        var searching = true;
671        var a = haps[i];
672        while (searching) {
673          const a_value = JSON.stringify(haps[i].value);
674          var found = false;
675
676          for (var j = i + 1; j < haps.length; j++) {
677            const b = haps[j];
678
679            if (a.whole.equals(b.whole)) {
680              if (a.part.begin.eq(b.part.end)) {
681                if (a_value === JSON.stringify(b.value)) {
682                  // eat the matching hap into 'a'
683                  a = new Hap(a.whole, new TimeSpan(b.part.begin, a.part.end), a.value);
684                  haps.splice(j, 1);
685                  // restart the search
686                  found = true;
687                  break;
688                }
689              } else if (b.part.begin.eq(a.part.end)) {
690                if (a_value == JSON.stringify(b.value)) {
691                  // eat the matching hap into 'a'
692                  a = new Hap(a.whole, new TimeSpan(a.part.begin, b.part.end), a.value);
693                  haps.splice(j, 1);
694                  // restart the search
695                  found = true;
696                  break;
697                }
698              }
699            }
700          }
701
702          searching = found;
703        }
704        result.push(a);
705      }
706      return result;
707    });
708  }

719  firstCycle(with_context = false) {
720    var self = this;
721    if (!with_context) {
722      self = self.stripContext();
723    }
724    return self.query(new State(new TimeSpan(Fraction(0), Fraction(1))));
725  }

732  get firstCycleValues() {
733    return this.firstCycle().map((hap) => hap.value);
734  }

741  get showFirstCycle() {
742    return this.firstCycle().map(
743      (hap) => `${hap.value}: ${hap.whole.begin.toFraction()} - ${hap.whole.end.toFraction()}`,
744    );
745  }

754  sortHapsByPart() {
755    return this.withHaps((haps) =>
756      haps.sort((a, b) =>
757        a.part.begin
758          .sub(b.part.begin)
759          .or(a.part.end.sub(b.part.end))
760          .or(a.whole.begin.sub(b.whole.begin).or(a.whole.end.sub(b.whole.end))),
761      ),
762    );
763  }

769  asNumber() {
770    return this.fmap(parseNumeral);
771  }

776  _opIn(other, func) {
777    return this.fmap(func).appLeft(reify(other));
778  }
779  _opOut(other, func) {
780    return this.fmap(func).appRight(reify(other));
781  }
782  _opMix(other, func) {
783    return this.fmap(func).appBoth(reify(other));
784  }
785  _opSqueeze(other, func) {
786    const otherPat = reify(other);
787    return this.fmap((a) => otherPat.fmap((b) => func(a)(b))).squeezeJoin();
788  }
789  _opSqueezeOut(other, func) {
790    const thisPat = this;
791    const otherPat = reify(other);
792    return otherPat.fmap((a) => thisPat.fmap((b) => func(b)(a))).squeezeJoin();
793  }
794  _opReset(other, func) {
795    const otherPat = reify(other);
796    return otherPat.fmap((b) => this.fmap((a) => func(a)(b))).resetJoin();
797  }
798  _opRestart(other, func) {
799    const otherPat = reify(other);
800    return otherPat.fmap((b) => this.fmap((a) => func(a)(b))).restartJoin();
801  }
802  _opPoly(other, func) {
803    const otherPat = reify(other);
804    return this.fmap((b) => otherPat.fmap((a) => func(a)(b))).polyJoin();
805  }

827  layer(...funcs) {
828    return stack(...funcs.map((func) => func(this)));
829  }

842  superimpose(...funcs) {
843    return this.stack(...funcs.map((func) => func(this)));
844  }

849  stack(...pats) {
850    return stack(this, ...pats);
851  }

853  sequence(...pats) {
854    return sequence(this, ...pats);
855  }
856
857  seq(...pats) {
858    return sequence(this, ...pats);
859  }
860  cat(...pats) {
861    return cat(this, ...pats);
862  }
863
864  fastcat(...pats) {
865    return fastcat(this, ...pats);
866  }
867
868  slowcat(...pats) {
869    return slowcat(this, ...pats);
870  }

875  onTrigger(onTrigger, dominant = true) {
876    return this.withHap((hap) =>
877      hap.setContext({
878        ...hap.context,
879        onTrigger: (...args) => {
880          // run previously set trigger, if it exists
881          hap.context.onTrigger?.(...args);
882          onTrigger(...args);
883        },
884        // if dominantTrigger is set to true, the default output (webaudio) will be disabled
885        // when using multiple triggers, you cannot flip this flag to false again!
886        // example: x.csound('CooLSynth').log() as well as x.log().csound('CooLSynth') should work the same
887        dominantTrigger: hap.context.dominantTrigger || dominant,
888      }),
889    );
890  }

900  log(func = (hap) => `[hap] ${hap.showWhole(true)}`, getData = (hap) => ({ hap })) {
901    return this.onTrigger((...args) => {
902      logger(func(...args), undefined, getData(...args));
903    }, false);
904  }

915  logValues(func = (value) => `[hap] ${stringifyValues(value, true)}`) {
916    return this.log((hap) => func(hap.value));
917  }

922  drawLine() {
923    console.log(drawLine(this));
924    return this;
925  }

931  unjoin(pieces, func = id) {
932    return pieces.withHap((hap) =>
933      hap.withValue((v) => (v ? func(this.ribbon(hap.whole.begin, hap.whole.duration)) : this)),
934    );
935  }

949  into(pieces, func) {
950    return this.unjoin(pieces, func).innerJoin();
951  }
952}

958function groupHapsBy(eq, haps) {
959  let groups = [];
960  haps.forEach((hap) => {
961    const match = groups.findIndex(([other]) => eq(hap, other));
962    if (match === -1) {
963      groups.push([hap]);
964    } else {
965      groups[match].push(hap);
966    }
967  });
968  return groups;
969}

972const congruent = (a, b) => a.spanEquals(b);

975Pattern.prototype.collect = function () {
976  return this.withHaps((haps) =>
977    groupHapsBy(congruent, haps).map((_haps) => new Hap(_haps[0].whole, _haps[0].part, _haps, {})),
978  );
979};

988export const arpWith = register('arpWith', (func, pat) => {
989  return pat
990    .collect()
991    .fmap((v) => reify(func(v)))
992    .innerJoin()
993    .withHap((h) => new Hap(h.whole, h.part, h.value.value, h.combineContext(h.value)));
994});

1003export const arp = register(
1004  'arp',
1005  (indices, pat) => pat.arpWith((haps) => reify(indices).fmap((i) => haps[_mod(i, haps.length)])),
1006  false,
1007);

1041function _nonArrayObject(x) {
1042  return !Array.isArray(x) && typeof x === 'object' && !isFraction(x);
1043}
1044function _composeOp(a, b, func) {
1045  if (_nonArrayObject(a) || _nonArrayObject(b)) {
1046    if (!_nonArrayObject(a)) {
1047      a = { value: a };
1048    }
1049    if (!_nonArrayObject(b)) {
1050      b = { value: b };
1051    }
1052    return unionWithObj(a, b, func);
1053  }
1054  return func(a, b);
1055}

1058const COMPOSERS = {
1059  /**
1060   * When called on a pattern `a`, with a input pattern `b` (`a.set(b)`),
1061   * combines `a` and `b` such that anything defined in `b`
1062   * and anything defined in `a` that is *not* defined in `b`
1063   * will be in the resulting pattern.
1064   *
1065   * The structure is maintained from `a`,
1066   * because the default pattern alignment is `in`,
1067   * see the section on `Pattern Alignment`
1068   * in the technical manual in the docs
1069   *
1070   * This is the inverse of `keep`
1071   *
1072   * See examples below
1073   * @name set
1074   * @param {Pattern} pat
1075   * @returns {Pattern}
1076   * @memberof Pattern
1077   * @tags internal, combiners
1078   * @example
1079   * // because input pattern has `s` set,
1080   * // it overrides the "sine" declared earlier
1081   * note("c a f e").s("sine").set(s("triangle"))
1082   */
1083  set: [(a, b) => b],
1084  /**
1085   * When called on a pattern `a`, with a input pattern `b` (`a.keep(b)`),
1086   * combines `a` and `b` such that anything defined in `a`,
1087   * and anything defined in `b` that is *not* defined in `a`
1088   * will be in the resulting pattern
1089   *
1090   * The structure is maintained from `a`,
1091   * because the default pattern alignment is `in`,
1092   * see the section on `Pattern Alignment`
1093   * in the technical manual in the docs
1094   *
1095   * This is the inverse of `set`
1096   *
1097   * See examples below
1098   * @name keep
1099   * @param {Pattern} pat
1100   * @memberof Pattern
1101   * @returns {Pattern}
1102   * @tags internal, combiners
1103   * @example
1104   * // notes, already defined, will stay "c a f e",
1105   * // while "s", not defined, will be set to "piano"
1106   * note("c a f e").keep(note("e f a c").s("piano"))
1107   */
1108  keep: [(a) => a],
1109  keepif: [(a, b) => (b ? a : undefined)],

1129  add: [numeralArgs((a, b) => a + b)], // support string concatenation
1130  /**
1131   *
1132   * Like add, but the given numbers are subtracted.
1133   * @name sub
1134   * @memberof Pattern
1135   * @tags math
1136   * @example
1137   * n("0 2 4".sub("<0 1 2 3>")).scale("C4:minor")
1138   * // See add for more information.
1139   */
1140  sub: [numeralArgs((a, b) => a - b)],
1141  /**
1142   *
1143   * Multiplies each number by the given factor.
1144   * @name mul
1145   * @memberof Pattern
1146   * @tags math
1147   * @example
1148   * "<1 1.5 [1.66, <2 2.33>]>*4".mul(150).freq()
1149   */
1150  mul: [numeralArgs((a, b) => a * b)],
1151  /**
1152   *
1153   * Divides each number by the given factor.
1154   * @name div
1155   * @memberof Pattern
1156   * @tags math
1157   */
1158  div: [numeralArgs((a, b) => a / b)],
1159  mod: [numeralArgs(_mod)],
1160  pow: [numeralArgs(Math.pow)],
1161  band: [numeralArgs((a, b) => a & b)],
1162  bor: [numeralArgs((a, b) => a | b)],
1163  bxor: [numeralArgs((a, b) => a ^ b)],
1164  blshift: [numeralArgs((a, b) => a << b)],
1165  brshift: [numeralArgs((a, b) => a >> b)],

1168  lt: [(a, b) => a < b],
1169  gt: [(a, b) => a > b],
1170  lte: [(a, b) => a <= b],
1171  gte: [(a, b) => a >= b],
1172  eq: [(a, b) => a == b],
1173  eqt: [(a, b) => a === b],
1174  ne: [(a, b) => a != b],
1175  net: [(a, b) => a !== b],
1176  and: [(a, b) => a && b],
1177  or: [(a, b) => a || b],

1180  func: [(a, b) => b(a)],
1181};

1183const _setupAlignments = () => {
1184  // generate methods to do what and how
1185  for (const [what, [op, preprocess]] of Object.entries(COMPOSERS)) {
1186    // make plain version, e.g. pat._add(value) adds that plain value
1187    // to all the values in pat
1188    Pattern.prototype['_' + what] = function (value) {
1189      return this.fmap((x) => op(x, value));
1190    };

1193    Object.defineProperty(Pattern.prototype, what, {
1194      // Set to configurable so we can update if the default alignment changes
1195      configurable: true,
1196      // a getter that returns a function, so 'pat' can be
1197      // accessed by closures that are methods of that function..
1198      get: function () {
1199        const pat = this;

1202        const wrapper = (...other) => pat[what][DEFAULT_ALIGNMENT](...other);

1205        for (const how of ALIGNMENTS) {
1206          wrapper[how.toLowerCase()] = function (...other) {
1207            var howpat = pat;
1208            other = sequence(other);
1209            if (preprocess) {
1210              howpat = preprocess(howpat);
1211              other = preprocess(other);
1212            }
1213            var result;
1214            // hack to remove undefs when doing 'keepif'
1215            if (what === 'keepif') {
1216              // avoid union, as we want to throw away the value of 'b' completely
1217              result = howpat['_op' + how](other, (a) => (b) => op(a, b));
1218              result = result.removeUndefineds();
1219            } else {
1220              result = howpat['_op' + how](other, (a) => (b) => _composeOp(a, b, op));
1221            }
1222            return result;
1223          };
1224        }
1225        wrapper.squeezein = wrapper.squeeze;

1227        return wrapper;
1228      },
1229    });
1230  }
1231};
1232
1233let DEFAULT_ALIGNMENT = 'in';
1234const ALIGNMENTS = ['In', 'Out', 'Mix', 'Squeeze', 'SqueezeOut', 'Reset', 'Restart', 'Poly'];
1235const ALIGNMENT_KEYS = ALIGNMENTS.map((how) => how.toLowerCase());

1238(function () {
1239  _setupAlignments();

1242  for (const how of ALIGNMENTS) {
1243    Pattern.prototype[how.toLowerCase()] = function (...args) {
1244      return this.set[how.toLowerCase()](args);
1245    };
1246  }
1247  // binary composers
1248  /**
1249   * Applies the given structure to the pattern:
1250   *
1251   * @tags temporal
1252   * @example
1253   * note("c,eb,g")
1254   *   .struct("x ~ x ~ ~ x ~ x ~ ~ ~ x ~ x ~ ~")
1255   *   .slow(2)
1256   */
1257  Pattern.prototype.struct = function (...args) {
1258    return this.keepif.out(...args);
1259  };
1260  Pattern.prototype.structAll = function (...args) {
1261    return this.keep.out(...args);
1262  };
1263  /**
1264   * Returns silence when mask is 0 or "~"
1265   *
1266   * @tags temporal
1267   * @example
1268   * note("c [eb,g] d [eb,g]").mask("<1 [0 1]>")
1269   */
1270  Pattern.prototype.mask = function (...args) {
1271    return this.keepif.in(...args);
1272  };
1273  Pattern.prototype.maskAll = function (...args) {
1274    return this.keep.in(...args);
1275  };
1276  /**
1277   * Resets the pattern to the start of the cycle for each onset of the reset pattern.
1278   *
1279   * @tags temporal
1280   * @example
1281   * s("[<bd lt> sd]*2, hh*8").reset("<x@3 x(5,8)>")
1282   */
1283  Pattern.prototype.reset = function (...args) {
1284    return this.keepif.reset(...args);
1285  };
1286  Pattern.prototype.resetAll = function (...args) {
1287    return this.keep.reset(...args);
1288  };
1289  /**
1290   * Restarts the pattern for each onset of the restart pattern.
1291   * While reset will only reset the current cycle, restart will start from cycle 0.
1292   *
1293   * @tags temporal
1294   * @example
1295   * s("[<bd lt> sd]*2, hh*8").restart("<x@3 x(5,8)>")
1296   */
1297  Pattern.prototype.restart = function (...args) {
1298    return this.keepif.restart(...args);
1299  };
1300  Pattern.prototype.restartAll = function (...args) {
1301    return this.keep.restart(...args);
1302  };
1303})();

1319export const setDefaultJoin = (alignment) => {
1320  alignment = alignment?.toLowerCase();
1321  if (DEFAULT_ALIGNMENT !== alignment && ALIGNMENT_KEYS.includes(alignment)) {
1322    DEFAULT_ALIGNMENT = alignment;
1323    _setupAlignments();
1324  }
1325};

1328export const polyrhythm = stack;
1329export const pr = stack;

1331export const pm = polymeter;

1361export const gap = (steps) => new Pattern(() => [], steps);

1370export const silence = gap(1);

1373export const nothing = gap(0);

1384export function pure(value) {
1385  function query(state) {
1386    return state.span.spanCycles.map((subspan) => new Hap(Fraction(subspan.begin).wholeCycle(), subspan, value));
1387  }
1388  const result = new Pattern(query, 1);
1389  result.__pure = value;
1390  return result;
1391}

1393export function isPattern(thing) {
1394  // thing?.constructor?.name !== 'Pattern' // <- this will fail when code is mangled
1395  const is = thing instanceof Pattern || thing?._Pattern;
1396  // TODO: find out how to check wrong core dependency. below will never work !thing === 'undefined'
1397  // wrapping it in (..) will result other checks to log that warning (e.g. isPattern('kalimba'))
1398  /* if (!thing instanceof Pattern) {
1399    console.warn(
1400      `Found Pattern that fails "instanceof Pattern" check.
1401      This may happen if you are using multiple versions of @strudel/core.
1402      Please check by running "npm ls @strudel/core".`,
1403    );
1404    console.log(thing);
1405  } */
1406  return is;
1407}
1408
1409export function reify(thing) {
1410  // Turns something into a pattern, unless it's already a pattern
1411  if (isPattern(thing)) {
1412    return thing;
1413  }
1414  if (stringParser && typeof thing === 'string') {
1415    return stringParser(thing);
1416  }
1417  return pure(thing);
1418}

1425export function sequenceP(pats) {
1426  let result = pure([]);
1427  for (const pat of pats) {
1428    result = result.bind((list) => pat.fmap((v) => list.concat([v])));
1429  }
1430  return result;
1431}

1449export function stack(...pats) {
1450  // Array test here is to avoid infinite recursions..
1451  pats = pats.map((pat) => (Array.isArray(pat) ? sequence(...pat) : reify(pat)));
1452  const query = (state) => flatten(pats.map((pat) => pat.query(state)));
1453  const result = new Pattern(query);
1454  if (__steps) {
1455    result._steps = lcm(...pats.map((pat) => pat._steps));
1456  }
1457  return result;
1458}

1460function _stackWith(func, pats) {
1461  pats = pats.map((pat) => (Array.isArray(pat) ? sequence(...pat) : reify(pat)));
1462  if (pats.length === 0) {
1463    return silence;
1464  }
1465  if (pats.length === 1) {
1466    return pats[0];
1467  }
1468  const [left, ...right] = pats.map((pat) => pat._steps);
1469  const steps = __steps ? left.maximum(...right) : undefined;
1470  return stack(...func(steps, pats));
1471}
1472
1473export function stackLeft(...pats) {
1474  return _stackWith(
1475    (steps, pats) => pats.map((pat) => (pat._steps.eq(steps) ? pat : stepcat(pat, gap(steps.sub(pat._steps))))),
1476    pats,
1477  );
1478}
1479
1480export function stackRight(...pats) {
1481  return _stackWith(
1482    (steps, pats) => pats.map((pat) => (pat._steps.eq(steps) ? pat : stepcat(gap(steps.sub(pat._steps)), pat))),
1483    pats,
1484  );
1485}
1486
1487export function stackCentre(...pats) {
1488  return _stackWith(
1489    (steps, pats) =>
1490      pats.map((pat) => {
1491        if (pat._steps.eq(steps)) {
1492          return pat;
1493        }
1494        const g = gap(steps.sub(pat._steps).div(2));
1495        return stepcat(g, pat, g);
1496      }),
1497    pats,
1498  );
1499}
1500
1501export function stackBy(by, ...pats) {
1502  const [left, ...right] = pats.map((pat) => pat._steps);
1503  const steps = left.maximum(...right);
1504  const lookup = {
1505    centre: stackCentre,
1506    left: stackLeft,
1507    right: stackRight,
1508    expand: stack,
1509    repeat: (...args) => polymeter(...args).steps(steps),
1510  };
1511  return by
1512    .inhabit(lookup)
1513    .fmap((func) => func(...pats))
1514    .innerJoin()
1515    .setSteps(steps);
1516}

1528export function slowcat(...pats) {
1529  // Array test here is to avoid infinite recursions..
1530  pats = pats.map((pat) => (Array.isArray(pat) ? fastcat(...pat) : reify(pat)));
1531
1532  if (!pats.length) {
1533    return silence;
1534  } else if (pats.length == 1) {
1535    return pats[0];
1536  }
1537
1538  const query = function (state) {
1539    const span = state.span;
1540    const pat_n = _mod(span.begin.sam(), pats.length);
1541    const pat = pats[pat_n];
1542    // A bit of maths to make sure that cycles from constituent patterns aren't skipped.
1543    // For example if three patterns are slowcat-ed, the fourth cycle of the result should
1544    // be the second (rather than fourth) cycle from the first pattern.
1545    const offset = span.begin.floor().sub(span.begin.div(pats.length).floor());
1546    return pat.withHapTime((t) => t.add(offset)).query(state.setSpan(span.withTime((t) => t.sub(offset))));
1547  };
1548  const steps = __steps ? lcm(...pats.map((x) => x._steps)) : undefined;
1549  return new Pattern(query).splitQueries().setSteps(steps);
1550}

1557export function slowcatPrime(...pats) {
1558  if (!pats.length) {
1559    return silence;
1560  }
1561  pats = pats.map(reify);
1562  const query = function (state) {
1563    const pat_n = _mod(Math.floor(state.span.begin), pats.length);
1564    const pat = pats[pat_n];
1565    return pat.query(state);
1566  };
1567  return new Pattern(query).splitQueries();
1568}

1586export function cat(...pats) {
1587  return slowcat(...pats);
1588}

1602export function arrange(...sections) {
1603  const total = sections.reduce((sum, [cycles]) => sum + cycles, 0);
1604  sections = sections.map(([cycles, section]) => [cycles, section.fast(cycles)]);
1605  return stepcat(...sections).slow(total);
1606}

1620export function seqPLoop(...parts) {
1621  let total = Fraction(0);
1622  const pats = [];
1623  for (let part of parts) {
1624    if (part.length == 2) {
1625      part.unshift(total);
1626    }
1627    total = part[1];
1628  }
1629
1630  return stack(
1631    ...parts.map(([start, stop, pat]) =>
1632      pure(reify(pat)).compress(Fraction(start).div(total), Fraction(stop).div(total)),
1633    ),
1634  )
1635    .slow(total)
1636    .innerJoin(); // or resetJoin or restartJoin ??
1637}

1639export function fastcat(...pats) {
1640  let result = slowcat(...pats);
1641  if (pats.length > 1) {
1642    result = result._fast(pats.length);
1643    result._steps = pats.length;
1644  }
1645  if (pats.length == 1 && pats[0].__steps_source) {
1646    pats._steps = pats[0]._steps;
1647  }
1648  return result;
1649}

1655export function sequence(...pats) {
1656  return fastcat(...pats);
1657}

1673export function seq(...pats) {
1674  return fastcat(...pats);
1675}

1677function _sequenceCount(x) {
1678  if (Array.isArray(x)) {
1679    if (x.length == 0) {
1680      return [silence, 0];
1681    }
1682    if (x.length == 1) {
1683      return _sequenceCount(x[0]);
1684    }
1685    return [fastcat(...x.map((a) => _sequenceCount(a)[0])), x.length];
1686  }
1687  return [reify(x), 1];
1688}
1689
1690export const mask = curry((a, b) => reify(b).mask(a));
1691export const struct = curry((a, b) => reify(b).struct(a));
1692export const superimpose = curry((a, b) => reify(b).superimpose(...a));
1693export const withValue = curry((a, b) => reify(b).withValue(a));
1694
1695export const bind = curry((a, b) => reify(b).bind(a));
1696export const innerBind = curry((a, b) => reify(b).innerBind(a));
1697export const outerBind = curry((a, b) => reify(b).outerBind(a));
1698export const squeezeBind = curry((a, b) => reify(b).squeezeBind(a));
1699export const stepBind = curry((a, b) => reify(b).stepBind(a));
1700export const polyBind = curry((a, b) => reify(b).polyBind(a));

1703export const set = curry((a, b) => reify(b).set(a));
1704export const keep = curry((a, b) => reify(b).keep(a));
1705export const keepif = curry((a, b) => reify(b).keepif(a));
1706export const add = curry((a, b) => reify(b).add(a));
1707export const sub = curry((a, b) => reify(b).sub(a));
1708export const mul = curry((a, b) => reify(b).mul(a));
1709export const div = curry((a, b) => reify(b).div(a));
1710export const mod = curry((a, b) => reify(b).mod(a));
1711export const pow = curry((a, b) => reify(b).pow(a));
1712export const band = curry((a, b) => reify(b).band(a));
1713export const bor = curry((a, b) => reify(b).bor(a));
1714export const bxor = curry((a, b) => reify(b).bxor(a));
1715export const blshift = curry((a, b) => reify(b).blshift(a));
1716export const brshift = curry((a, b) => reify(b).brshift(a));
1717export const lt = curry((a, b) => reify(b).lt(a));
1718export const gt = curry((a, b) => reify(b).gt(a));
1719export const lte = curry((a, b) => reify(b).lte(a));
1720export const gte = curry((a, b) => reify(b).gte(a));
1721export const eq = curry((a, b) => reify(b).eq(a));
1722export const eqt = curry((a, b) => reify(b).eqt(a));
1723export const ne = curry((a, b) => reify(b).ne(a));
1724export const net = curry((a, b) => reify(b).net(a));
1725export const and = curry((a, b) => reify(b).and(a));
1726export const or = curry((a, b) => reify(b).or(a));
1727export const func = curry((a, b) => reify(b).func(a));

1744export function register(name, func, patternify = true, preserveSteps = false, join = (x) => x.innerJoin()) {
1745  if (isPattern(name)) {
1746    throw new Error(
1747      'Name argument for register is a pattern, try using single quotes (\'name\') instead of double quotes ("name")',
1748    );
1749  }
1750
1751  if (Array.isArray(name)) {
1752    const result = {};
1753    for (const name_item of name) {
1754      result[name_item] = register(name_item, func, patternify, preserveSteps, join);
1755    }
1756    return result;
1757  }
1758  const arity = func.length;
1759  var pfunc; // the patternified function
1760
1761  if (patternify) {
1762    pfunc = function (...args) {
1763      args = args.map(reify);
1764      const pat = args[args.length - 1];
1765      let result;
1766
1767      if (arity === 1) {
1768        result = func(pat);
1769      } else {
1770        const firstArgs = args.slice(0, -1);
1771
1772        if (firstArgs.every((arg) => arg.__pure != undefined)) {
1773          const pureArgs = firstArgs.map((arg) => arg.__pure);
1774          const pureLocs = firstArgs.filter((arg) => arg.__pure_loc).map((arg) => arg.__pure_loc);
1775          result = func(...pureArgs, pat);
1776          result = result.withContext((context) => {
1777            const locations = (context.locations || []).concat(pureLocs);
1778            return { ...context, locations };
1779          });
1780        } else {
1781          const [left, ...right] = firstArgs;
1782
1783          let mapFn = (...args) => {
1784            return func(...args, pat);
1785          };
1786          mapFn = curry(mapFn, null, arity - 1);
1787          result = join(right.reduce((acc, p) => acc.appLeft(p), left.fmap(mapFn)));
1788        }
1789      }
1790      if (preserveSteps) {
1791        result._steps = pat._steps;
1792      }
1793      return result;
1794    };
1795  } else {
1796    pfunc = function (...args) {
1797      args = args.map(reify);
1798      const result = func(...args);
1799      if (preserveSteps) {
1800        result._steps = args[args.length - 1]._steps;
1801      }
1802      return result;
1803    };
1804  }
1805
1806  Pattern.prototype[name] = function (...args) {
1807    // For methods that take a single argument (plus 'this'), allow
1808    // multiple arguments but sequence them
1809    if (arity === 2 && args.length !== 1) {
1810      args = [sequence(...args)];
1811    } else if (arity !== args.length + 1) {
1812      throw new Error(`.${name}() expects ${arity - 1} inputs but got ${args.length}.`);
1813    }
1814    args = args.map(reify);
1815    return pfunc(...args, this);
1816  };
1817
1818  if (arity > 1) {
1819    // There are patternified args, so lets make an unpatternified
1820    // version, prefixed by '_'
1821    Pattern.prototype['_' + name] = function (...args) {
1822      const result = func(...args, this);
1823      if (preserveSteps) {
1824        result.setSteps(this._steps);
1825      }
1826      return result;
1827    };
1828  }

1832  const curried = curry(pfunc, null, arity);
1833  strudelScope[name] = curried;
1834  return curried;
1835}

1838function stepRegister(name, func, patternify = true, preserveSteps = false, join = (x) => x.stepJoin()) {
1839  return register(name, func, patternify, preserveSteps, join);
1840}

1855export const round = register('round', function (pat) {
1856  return pat.asNumber().fmap((v) => Math.round(v));
1857});

1869export const floor = register('floor', function (pat) {
1870  return pat.asNumber().fmap((v) => Math.floor(v));
1871});

1873export const log2 = register('log2', (pat) => pat.asNumber().fmap((v) => Math.log2(v)));

1886export const ceil = register('ceil', function (pat) {
1887  return pat.asNumber().fmap((v) => Math.ceil(v));
1888});

1896export const toBipolar = register('toBipolar', function (pat) {
1897  return pat.fmap((x) => x * 2 - 1);
1898});

1907export const fromBipolar = register('fromBipolar', function (pat) {
1908  return pat.fmap((x) => (x + 1) / 2);
1909});

1923export const range = register('range', function (min, max, pat) {
1924  return pat.mul(max - min).add(min);
1925});

1939export const rangex = register('rangex', function (min, max, pat) {
1940  return pat._range(Math.log(min), Math.log(max)).fmap(Math.exp);
1941});

1954export const range2 = register('range2', function (min, max, pat) {
1955  return pat.fromBipolar()._range(min, max);
1956});

1969export const ratio = register('ratio', (pat) =>
1970  pat.fmap((v) => {
1971    if (!Array.isArray(v)) {
1972      return v;
1973    }
1974    return v.slice(1).reduce((acc, n) => acc / n, v[0]);
1975  }),
1976);

1989export const compress = register('compress', function (b, e, pat) {
1990  b = Fraction(b);
1991  e = Fraction(e);
1992  if (b.gt(e) || b.gt(1) || e.gt(1) || b.lt(0) || e.lt(0)) {
1993    return silence;
1994  }
1995  return pat._fastGap(Fraction(1).div(e.sub(b)))._late(b);
1996});

1998export const { compressSpan, compressspan } = register(['compressSpan', 'compressspan'], function (span, pat) {
1999  return pat._compress(span.begin, span.end);
2000});

2010export const { fastGap, fastgap } = register(['fastGap', 'fastgap'], function (factor, pat) {
2011  // A bit fiddly, to drop zero-width queries at the start of the next cycle
2012  const qf = function (span) {
2013    const cycle = span.begin.sam();
2014    const bpos = span.begin.sub(cycle).mul(factor).min(1);
2015    const epos = span.end.sub(cycle).mul(factor).min(1);
2016    if (bpos >= 1) {
2017      return undefined;
2018    }
2019    return new TimeSpan(cycle.add(bpos), cycle.add(epos));
2020  };
2021  // Also fiddly, to maintain the right 'whole' relative to the part
2022  const ef = function (hap) {
2023    const begin = hap.part.begin;
2024    const end = hap.part.end;
2025    const cycle = begin.sam();
2026    const beginPos = begin.sub(cycle).div(factor).min(1);
2027    const endPos = end.sub(cycle).div(factor).min(1);
2028    const newPart = new TimeSpan(cycle.add(beginPos), cycle.add(endPos));
2029    const newWhole = !hap.whole
2030      ? undefined
2031      : new TimeSpan(
2032          newPart.begin.sub(begin.sub(hap.whole.begin).div(factor)),
2033          newPart.end.add(hap.whole.end.sub(end).div(factor)),
2034        );
2035    return new Hap(newWhole, newPart, hap.value, hap.context);
2036  };
2037  return pat.withQuerySpanMaybe(qf).withHap(ef).splitQueries();
2038});

2046export const focus = register('focus', function (b, e, pat) {
2047  b = Fraction(b);
2048  e = Fraction(e);
2049  return pat
2050    ._early(b.sam())
2051    ._fast(Fraction(1).div(e.sub(b)))
2052    ._late(b);
2053});

2055export const { focusSpan, focusspan } = register(['focusSpan', 'focusspan'], function (span, pat) {
2056  return pat._focus(span.begin, span.end);
2057});

2064export const ply = register('ply', function (factor, pat) {
2065  const result = pat.fmap((x) => pure(x)._fast(factor)).squeezeJoin();
2066  if (__steps) {
2067    result._steps = Fraction(factor).mulmaybe(pat._steps);
2068  }
2069  return result;
2070});

2084export const { fast, density } = register(
2085  ['fast', 'density'],
2086  function (factor, pat) {
2087    if (factor === 0) {
2088      return silence;
2089    }
2090    factor = Fraction(factor);
2091    const fastQuery = pat.withQueryTime((t) => t.mul(factor));
2092    return fastQuery.withHapTime((t) => t.div(factor)).setSteps(pat._steps);
2093  },
2094  true,
2095  true,
2096);

2104export const hurry = register('hurry', function (r, pat) {
2105  return pat._fast(r).mul(pure({ speed: r }));
2106});

2120export const { slow, sparsity } = register(['slow', 'sparsity'], function (factor, pat) {
2121  if (factor === 0) {
2122    return silence;
2123  }
2124  return pat._fast(Fraction(1).div(factor));
2125});

2134export const inside = register('inside', function (factor, f, pat) {
2135  return f(pat._slow(factor))._fast(factor);
2136});

2145export const outside = register('outside', function (factor, f, pat) {
2146  return f(pat._fast(factor))._slow(factor);
2147});

2160export const lastOf = register('lastOf', function (n, func, pat) {
2161  const pats = Array(n - 1).fill(pat);
2162  pats.push(func(pat));
2163  return slowcatPrime(...pats);
2164});

2189export const { firstOf, every } = register(['firstOf', 'every'], function (n, func, pat) {
2190  const pats = Array(n - 1).fill(pat);
2191  pats.unshift(func(pat));
2192  return slowcatPrime(...pats);
2193});

2202export const apply = register('apply', function (func, pat) {
2203  return func(pat);
2204});

2214export const cpm = register('cpm', function (cpm, pat) {
2215  return pat._fast(cpm / 60 / 1);
2216});

2229export const early = register(
2230  'early',
2231  function (offset, pat) {
2232    offset = Fraction(offset);
2233    return pat.withQueryTime((t) => t.add(offset)).withHapTime((t) => t.sub(offset));
2234  },
2235  true,
2236  true,
2237);

2250export const late = register(
2251  'late',
2252  function (offset, pat) {
2253    offset = Fraction(offset);
2254    return pat._early(Fraction(0).sub(offset));
2255  },
2256  true,
2257  true,
2258);

2268export const zoom = register('zoom', function (s, e, pat) {
2269  e = Fraction(e);
2270  s = Fraction(s);
2271  if (s.gte(e)) {
2272    return nothing;
2273  }
2274  const d = e.sub(s);
2275  const steps = __steps ? pat._steps?.mulmaybe(d) : undefined;
2276  return pat
2277    .withQuerySpan((span) => span.withCycle((t) => t.mul(d).add(s)))
2278    .withHapSpan((span) => span.withCycle((t) => t.sub(s).div(d)))
2279    .splitQueries()
2280    .setSteps(steps);
2281});

2283export const { zoomArc, zoomarc } = register(['zoomArc', 'zoomarc'], function (a, pat) {
2284  return pat.zoom(a.begin, a.end);
2285});

2301export const bite = register(
2302  'bite',
2303  (npat, ipat, pat) => {
2304    return ipat
2305      .fmap((i) => (n) => {
2306        const a = Fraction(i).div(n).mod(1);
2307        const b = a.add(Fraction(1).div(n));
2308        return pat.zoom(a, b);
2309      })
2310      .appLeft(npat)
2311      .squeezeJoin();
2312  },
2313  false,
2314);

2323export const linger = register(
2324  'linger',
2325  function (t, pat) {
2326    if (t == 0) {
2327      return silence;
2328    } else if (t < 0) {
2329      return pat._zoom(t.add(1), 1)._slow(t);
2330    }
2331    return pat._zoom(0, t)._slow(t);
2332  },
2333  true,
2334  true,
2335);

2346export const { segment, seg } = register(['segment', 'seg'], function (rate, pat) {
2347  return pat.struct(pure(true)._fast(rate)).setSteps(rate);
2348});

2358export const swingBy = register('swingBy', (swing, n, pat) => pat.inside(n, late(seq(0, swing / 2))));

2368export const swing = register('swing', (n, pat) => pat.swingBy(1 / 3, n));

2378export const { invert, inv } = register(
2379  ['invert', 'inv'],
2380  function (pat) {
2381    // Swap true/false in a binary pattern
2382    return pat.fmap((x) => !x);
2383  },
2384  true,
2385  true,
2386);

2399export const when = register('when', function (on, func, pat) {
2400  return on ? func(pat) : pat;
2401});

2414export const off = register('off', function (time_pat, func, pat) {
2415  return stack(pat, func(pat.late(time_pat)));
2416});

2425export const brak = register('brak', function (pat) {
2426  return pat.when(slowcat(false, true), (x) => fastcat(x, silence)._late(0.25));
2427});

2439export const rev = register(
2440  'rev',
2441  function (pat) {
2442    const query = function (state) {
2443      const span = state.span;
2444      const cycle = span.begin.sam();
2445      const next_cycle = span.begin.nextSam();
2446      const reflect = function (to_reflect) {
2447        const reflected = to_reflect.withTime((time) => cycle.add(next_cycle.sub(time)));
2448        // [reflected.begin, reflected.end] = [reflected.end, reflected.begin] -- didn't work
2449        const tmp = reflected.begin;
2450        reflected.begin = reflected.end;
2451        reflected.end = tmp;
2452        return reflected;
2453      };
2454      const haps = pat.query(state.setSpan(reflect(span)));
2455      return haps.map((hap) => hap.withSpan(reflect));
2456    };
2457    return new Pattern(query).splitQueries();
2458  },
2459  false,
2460  true,
2461);

2476export const revv = register('revv', function (pat) {
2477  const negateSpan = (span) => new TimeSpan(Fraction(0).sub(span.end), Fraction(0).sub(span.begin));
2478  return pat.withQuerySpan(negateSpan).withHapSpan(negateSpan);
2479});

2490export const pressBy = register('pressBy', function (r, pat) {
2491  return pat.fmap((x) => pure(x).compress(r, 1)).squeezeJoin();
2492});

2502export const press = register('press', function (pat) {
2503  return pat._pressBy(0.5);
2504});

2515Pattern.prototype.hush = function () {
2516  return silence;
2517};

2525export const palindrome = register(
2526  'palindrome',
2527  function (pat) {
2528    return pat.lastOf(2, rev);
2529  },
2530  true,
2531  true,
2532);

2542export const { juxBy, juxby } = register(['juxBy', 'juxby'], function (by, func, pat) {
2543  by /= 2;
2544  const elem_or = function (dict, key, dflt) {
2545    if (key in dict) {
2546      return dict[key];
2547    }
2548    return dflt;
2549  };
2550  const left = pat.withValue((val) => Object.assign({}, val, { pan: elem_or(val, 'pan', 0.5) - by }));
2551  const right = func(pat.withValue((val) => Object.assign({}, val, { pan: elem_or(val, 'pan', 0.5) + by })));
2552
2553  return stack(left, right).setSteps(__steps ? lcm(left._steps, right._steps) : undefined);
2554});

2563export const { juxFlipBy, juxflipby, fluxBy, fluxby } = register(
2564  ['juxFlipBy', 'juxflipby', 'fluxBy', 'fluxby'],
2565  function (by, func, pat) {
2566    return pat.juxBy(slowcat(by, -by), func);
2567  },
2568);

2580export const jux = register('jux', function (func, pat) {
2581  return pat._juxBy(1, func, pat);
2582});

2595export const { juxFlip, flux } = register(['juxFlip', 'juxflip', 'flux'], function (func, pat) {
2596  return pat._juxFlipBy(1, func, pat);
2597});

2612export const { echoWith, echowith, stutWith, stutwith } = register(
2613  ['echoWith', 'echowith', 'stutWith', 'stutwith'],
2614  function (times, time, func, pat) {
2615    return stack(...listRange(0, times - 1).map((i) => func(pat.late(Fraction(time).mul(i)), i)));
2616  },
2617);

2631export const echo = register('echo', function (times, time, feedback, pat) {
2632  return pat._echoWith(times, time, (pat, i) => pat.gain(Math.pow(feedback, i)));
2633});

2645export const stut = register('stut', function (times, feedback, time, pat) {
2646  return pat._echoWith(times, time, (pat, i) => pat.gain(Math.pow(feedback, i)));
2647});

2649export const applyN = register('applyN', function (n, func, p) {
2650  let result = p;
2651  for (let i = 0; i < n; i++) {
2652    result = func(result);
2653  }
2654  return result;
2655});

2669export const plyWith = register(['plyWith', 'plywith'], function (factor, func, pat) {
2670  const result = pat
2671    .fmap((x) => cat(...listRange(0, factor - 1).map((i) => applyN(i, func, x)))._fast(factor))
2672    .squeezeJoin();
2673  if (__steps) {
2674    result._steps = Fraction(factor).mulmaybe(pat._steps);
2675  }
2676  return result;
2677});

2692export const plyForEach = register(['plyForEach', 'plyforeach'], function (factor, func, pat) {
2693  const result = pat
2694    .fmap((x) => cat(cat(pure(x), ...listRange(1, factor - 1).map((i) => func(pure(x), i))))._fast(factor))
2695    .squeezeJoin();
2696  if (__steps) {
2697    result._steps = Fraction(factor).mulmaybe(pat._steps);
2698  }
2699  return result;
2700});

2712const _iter = function (times, pat, back = false) {
2713  times = Fraction(times);
2714  return slowcat(
2715    ...listRange(0, times.sub(1)).map((i) =>
2716      back ? pat.late(Fraction(i).div(times)) : pat.early(Fraction(i).div(times)),
2717    ),
2718  );
2719};

2721export const iter = register(
2722  'iter',
2723  function (times, pat) {
2724    return _iter(times, pat, false);
2725  },
2726  true,
2727  true,
2728);

2740export const { iterBack, iterback } = register(
2741  ['iterBack', 'iterback'],
2742  function (times, pat) {
2743    return _iter(times, pat, true);
2744  },
2745  true,
2746  true,
2747);

2758export const { repeatCycles } = register(
2759  'repeatCycles',
2760  function (n, pat) {
2761    return new Pattern(function (state) {
2762      const cycle = state.span.begin.sam();
2763      const source_cycle = cycle.div(n).sam();
2764      const delta = cycle.sub(source_cycle);
2765      state = state.withSpan((span) => span.withTime((spant) => spant.sub(delta)));
2766      return pat.query(state).map((hap) => hap.withSpan((span) => span.withTime((spant) => spant.add(delta))));
2767    }).splitQueries();
2768  },
2769  true,
2770  true,
2771);

2784const _chunk = function (n, func, pat, back = false, fast = false) {
2785  const binary = Array(n - 1).fill(false);
2786  binary.unshift(true);
2787  // Invert the 'back' because we want to shift the pattern forwards,
2788  // and so time backwards
2789  const binary_pat = _iter(n, sequence(...binary), !back);
2790  if (!fast) {
2791    pat = pat.repeatCycles(n);
2792  }
2793  return pat.when(binary_pat, func);
2794};

2796export const { chunk, slowchunk, slowChunk } = register(
2797  ['chunk', 'slowchunk', 'slowChunk'],
2798  function (n, func, pat) {
2799    return _chunk(n, func, pat, false, false);
2800  },
2801  true,
2802  true,
2803);

2816export const { chunkBack, chunkback } = register(
2817  ['chunkBack', 'chunkback'],
2818  function (n, func, pat) {
2819    return _chunk(n, func, pat, true);
2820  },
2821  true,
2822  true,
2823);

2838export const { fastchunk, fastChunk } = register(
2839  ['fastchunk', 'fastChunk'],
2840  function (n, func, pat) {
2841    return _chunk(n, func, pat, false, true);
2842  },
2843  true,
2844  true,
2845);

2857export const { chunkinto, chunkInto } = register(['chunkinto', 'chunkInto'], function (n, func, pat) {
2858  return pat.into(fastcat(true, ...Array(n - 1).fill(false))._iterback(n), func);
2859});

2871export const { chunkbackinto, chunkBackInto } = register(['chunkbackinto', 'chunkBackInto'], function (n, func, pat) {
2872  return pat.into(
2873    fastcat(true, ...Array(n - 1).fill(false))
2874      ._iter(n)
2875      ._early(1),
2876    func,
2877  );
2878});

2881export const bypass = register(
2882  'bypass',
2883  function (on, pat) {
2884    on = Boolean(parseInt(on));
2885    return on ? silence : pat;
2886  },
2887  true,
2888  true,
2889);

2908export const { ribbon, rib } = register(['ribbon', 'rib'], (offset, cycles, pat) =>
2909  pat.early(offset).restart(pure(1).slow(cycles)),
2910);

2912export const hsla = register('hsla', (h, s, l, a, pat) => {
2913  return pat.color(`hsla(${h}turn,${s * 100}%,${l * 100}%,${a})`);
2914});
2915
2916export const hsl = register('hsl', (h, s, l, pat) => {
2917  return pat.color(`hsl(${h}turn,${s * 100}%,${l * 100}%)`);
2918});

2932Pattern.prototype.tag = function (tag) {
2933  return this.withContext((ctx) => ({ ...ctx, tags: (ctx.tags || []).concat([tag]) }));
2934};

2944export const filter = register('filter', (test, pat) => pat.withHaps((haps) => haps.filter(test)));

2954export const filterWhen = register('filterWhen', (test, pat) => pat.filter((h) => test(h.whole.begin)));

2964export const within = register('within', (a, b, fn, pat) =>
2965  stack(
2966    fn(pat.filterWhen((t) => t.cyclePos() >= a && t.cyclePos() <= b)),
2967    pat.filterWhen((t) => t.cyclePos() < a || t.cyclePos() > b),
2968  ),
2969);

2974Pattern.prototype.stepJoin = function () {
2975  const pp = this;
2976  const first_t = stepcat(..._retime(_slices(pp.queryArc(0, 1))))._steps;
2977  const q = function (state) {
2978    const shifted = pp.early(state.span.begin.sam());
2979    const haps = shifted.query(state.setSpan(new TimeSpan(Fraction(0), Fraction(1))));
2980    const pat = stepcat(..._retime(_slices(haps)));
2981    return pat.query(state);
2982  };
2983  return new Pattern(q, first_t);
2984};

2986Pattern.prototype.stepBind = function (func) {
2987  return this.fmap(func).stepJoin();
2988};
2989
2990export function _retime(timedHaps) {
2991  const occupied_perc = timedHaps.filter((t, pat) => pat.hasSteps).reduce((a, b) => a.add(b), Fraction(0));
2992  const occupied_steps = removeUndefineds(timedHaps.map((t, pat) => pat._steps)).reduce(
2993    (a, b) => a.add(b),
2994    Fraction(0),
2995  );
2996  const total_steps = occupied_perc.eq(0) ? undefined : occupied_steps.div(occupied_perc);
2997  function adjust(dur, pat) {
2998    if (pat._steps === undefined) {
2999      return [dur.mulmaybe(total_steps), pat];
3000    }
3001    return [pat._steps, pat];
3002  }
3003  return timedHaps.map((x) => adjust(...x));
3004}
3005
3006export function _slices(haps) {
3007  // slices evs = map (\s -> ((snd s - fst s), stack $ map value $ fit s evs))
3008  // $ pairs $ sort $ nubOrd $ 0:1:concatMap (\ev -> start (part ev):stop (part ev):[]) evs
3009  const breakpoints = flatten(haps.map((hap) => [hap.part.begin, hap.part.end]));
3010  const unique = uniqsortr([Fraction(0), Fraction(1), ...breakpoints]);
3011  const slicespans = pairs(unique);
3012  return slicespans.map((s) => [
3013    s[1].sub(s[0]),
3014    stack(..._fitslice(new TimeSpan(...s), haps).map((x) => x.value.withHap((h) => h.setContext(h.combineContext(x))))),
3015  ]);
3016}
3017
3018export function _fitslice(span, haps) {
3019  return removeUndefineds(haps.map((hap) => _match(span, hap)));
3020}
3021
3022export function _match(span, hap_p) {
3023  const subspan = span.intersection(hap_p.part);
3024  if (subspan == undefined) {
3025    return undefined;
3026  }
3027  return new Hap(hap_p.whole, subspan, hap_p.value, hap_p.context);
3028}

3039export const pace = register('pace', function (targetSteps, pat) {
3040  if (pat._steps === undefined) {
3041    return pat;
3042  }
3043  if (pat._steps.eq(Fraction(0))) {
3044    // avoid divide by zero..
3045    return nothing;
3046  }
3047  return pat._fast(Fraction(targetSteps).div(pat._steps)).setSteps(targetSteps);
3048});

3050export function _polymeterListSteps(steps, ...args) {
3051  const seqs = args.map((a) => _sequenceCount(a));
3052  if (seqs.length == 0) {
3053    return silence;
3054  }
3055  if (steps == 0) {
3056    steps = seqs[0][1];
3057  }
3058  const pats = [];
3059  for (const seq of seqs) {
3060    if (seq[1] == 0) {
3061      continue;
3062    }
3063    if (steps == seq[1]) {
3064      pats.push(seq[0]);
3065    } else {
3066      pats.push(seq[0]._fast(Fraction(steps).div(Fraction(seq[1]))));
3067    }
3068  }
3069  return stack(...pats);
3070}

3083export function polymeter(...args) {
3084  if (Array.isArray(args[0])) {
3085    // Support old behaviour
3086    return _polymeterListSteps(0, ...args);
3087  }

3090  args = args.filter((arg) => arg.hasSteps);

3092  if (args.length == 0) {
3093    return silence;
3094  }
3095  const steps = lcm(...args.map((x) => x._steps));
3096  if (steps.eq(Fraction(0))) {
3097    return nothing;
3098  }
3099
3100  const result = stack(...args.map((x) => x.pace(steps)));
3101  result._steps = steps;
3102  return result;
3103}

3119export function stepcat(...timepats) {
3120  if (timepats.length === 0) {
3121    return nothing;
3122  }
3123  const findsteps = (x) => (Array.isArray(x) ? x : [x._steps ?? 1, x]);
3124  timepats = timepats.map(findsteps);
3125  if (timepats.find((x) => x[0] === undefined)) {
3126    const times = timepats.map((a) => a[0]).filter((x) => x !== undefined);
3127    if (times.length === 0) {
3128      return fastcat(...timepats.map((x) => x[1]));
3129    }
3130    if (times.length === timepats.length) {
3131      return nothing;
3132    }
3133    const avg = times.reduce((a, b) => a.add(b), Fraction(0)).div(times.length);
3134    for (let timepat of timepats) {
3135      if (timepat[0] === undefined) {
3136        timepat[0] = avg;
3137      }
3138    }
3139  }
3140  if (timepats.length == 1) {
3141    const result = reify(timepats[0][1]);
3142    return result.withSteps((_) => timepats[0][0]);
3143  }
3144
3145  const total = timepats.map((a) => a[0]).reduce((a, b) => a.add(b), Fraction(0));
3146  let begin = Fraction(0);
3147  const pats = [];
3148  for (const [time, pat] of timepats) {
3149    if (Fraction(time).eq(0)) {
3150      continue;
3151    }
3152    const end = begin.add(time);
3153    pats.push(reify(pat)._compress(begin.div(total), end.div(total)));
3154    begin = end;
3155  }
3156  const result = stack(...pats);
3157  result._steps = total;
3158  return result;
3159}

3173export function stepalt(...groups) {
3174  groups = groups.map((a) => (Array.isArray(a) ? a.map(reify) : [reify(a)]));
3175
3176  const cycles = lcm(...groups.map((x) => Fraction(x.length)));
3177
3178  let result = [];
3179  for (let cycle = 0; cycle < cycles; ++cycle) {
3180    result.push(...groups.map((x) => (x.length == 0 ? silence : x[cycle % x.length])));
3181  }
3182  result = result.filter((x) => x.hasSteps && x._steps > 0);
3183  const steps = result.reduce((a, b) => a.add(b._steps), Fraction(0));
3184  result = stepcat(...result);
3185  result._steps = steps;
3186  return result;
3187}

3206export const take = stepRegister('take', function (i, pat) {
3207  if (!pat.hasSteps) {
3208    return nothing;
3209  }
3210  if (pat._steps.lte(0)) {
3211    return nothing;
3212  }
3213  i = Fraction(i);
3214  if (i.eq(0)) {
3215    return nothing;
3216  }
3217  const flip = i < 0;
3218  if (flip) {
3219    i = i.abs();
3220  }
3221  const frac = i.div(pat._steps);
3222  if (frac.lte(0)) {
3223    return nothing;
3224  }
3225  if (frac.gte(1)) {
3226    return pat;
3227  }
3228  if (flip) {
3229    return pat.zoom(Fraction(1).sub(frac), 1);
3230  }
3231  return pat.zoom(0, frac);
3232});

3250export const drop = stepRegister('drop', function (i, pat) {
3251  if (!pat.hasSteps) {
3252    return nothing;
3253  }
3254
3255  i = Fraction(i);
3256  if (i.lt(0)) {
3257    return pat.take(pat._steps.add(i));
3258  }
3259  return pat.take(Fraction(0).sub(pat._steps.sub(i)));
3260});

3275export const extend = stepRegister('extend', function (factor, pat) {
3276  return pat.fast(factor).expand(factor);
3277});

3294export const replicate = stepRegister('replicate', function (factor, pat) {
3295  return pat.repeatCycles(factor).fast(factor).expand(factor);
3296});

3306export const expand = stepRegister('expand', function (factor, pat) {
3307  return pat.withSteps((t) => t.mul(Fraction(factor)));
3308});

3318export const contract = stepRegister('contract', function (factor, pat) {
3319  return pat.withSteps((t) => t.div(Fraction(factor)));
3320});

3322Pattern.prototype.shrinklist = function (amount) {
3323  const pat = this;
3324
3325  if (!pat.hasSteps) {
3326    return [pat];
3327  }
3328
3329  let [amountv, times] = Array.isArray(amount) ? amount : [amount, pat._steps];
3330  amountv = Fraction(amountv);
3331
3332  if (times === 0 || amountv === 0) {
3333    return [pat];
3334  }
3335
3336  const fromstart = amountv > 0;
3337  const ranges = [];
3338  if (fromstart) {
3339    const seg = Fraction(1).div(pat._steps).mul(amountv);
3340    for (let i = 0; i < times; ++i) {
3341      const s = seg.mul(i);
3342      if (s.gt(1)) {
3343        break;
3344      }
3345      ranges.push([s, 1]);
3346    }
3347  } else {
3348    amountv = Fraction(0).sub(amountv);
3349    const seg = Fraction(1).div(pat._steps).mul(amountv);
3350    for (let i = 0; i < times; ++i) {
3351      const e = Fraction(1).sub(seg.mul(i));
3352      if (e.lt(0)) {
3353        break;
3354      }
3355      ranges.push([Fraction(0), e]);
3356    }
3357  }
3358  return ranges.map((x) => pat.zoom(...x));
3359};
3360
3361export const shrinklist = (amount, pat) => pat.shrinklist(amount);
3362
3363Pattern.prototype.growlist = function (amount) {
3364  return this.shrinklist(amount).reverse();
3365};
3366export const growlist = (amount, pat) => pat.growlist(amount);

3390export const shrink = register(
3391  'shrink',
3392  function (amount, pat) {
3393    if (!pat.hasSteps) {
3394      return nothing;
3395    }
3396
3397    const list = pat.shrinklist(amount);
3398    const result = stepcat(...list);
3399    // TODO is this calculation needed?
3400    result._steps = list.reduce((a, b) => a.add(b._steps), Fraction(0));
3401    return result;
3402  },
3403  true,
3404  false,
3405  (x) => x.stepJoin(),
3406);